2 Commits

Author	SHA1	Message	Date
Jack	bb96bb687d	refactor(task): sink parser page-cap override into pipeline package (#17905) ... ## Summary Moves the canvas-debug parser page-cap injection out of the `task` orchestrator and into a **debug-agnostic** `pipeline` helper, so `PipelineExecutor` keeps only the orchestration skeleton (resolving one of the P1 review findings: the executor was overloaded with DSL/parser-param assembly). ### Changes - **`pipeline/parser_page_cap.go`** (new): - `BuildParserPageCapOverride(parserConfig, dsl, docType, capPages int, parserComponentName string, familyOf)` — injects the `ParserConfig[cpnID][family]["pages"]` cap through the same `override_params` channel production uses. The cap value and family resolution are injected by the caller, so the function carries no debug semantics and is reusable for any page-cap scenario. - `ExtractParserCpnID(dsl, parserComponentName)` — shared Parser cpnID discovery from (optionally enveloped) DSL. - `UnwrapCanvasDSL(raw []byte)` — exported single source of truth for stripping the `{"dsl": {...}}` canvas envelope. - `pipeline` does **not** import `component` (no reverse dependency); callers inject `component.ComponentNameParser` / `component.ParserFileFamily`. - **`task/pipeline_executor.go`**: removed `injectDebugPageCap` (the `debugPageCapPages = 2` constant stays in the task package). The debug branch now calls `pipeline.BuildParserPageCapOverride(...)`. - **`task/pipeline_executor.go` `warnUnknownComponentParams`**: fixed a production no-op bug — it passed the enveloped DSL straight to `ExtractAllComponentParams`, which silently errored and disabled the unknown-cpnID guard. It now unwraps the envelope first. - **`task/debug_result_dsl.go`**: reuses `pipeline.UnwrapCanvasDSL` instead of a third inline envelope-unwrap copy. ### Behavior No external debug-preview behavior changes. The three original invariants are preserved exactly: 1. explicit `pages` caps under `cpnID+family` are respected (not overwritten), 2. an empty family (unknown docType) is a no-op, 3. the injected shape is `[]any{[]any{1, capPages}}` (the `[]any`-of-`[]any` form `NormalizePDFPages` requires). ## Test plan - New `pipeline/parser_page_cap_test.go`: `BuildParserPageCapOverride` (inject / respect-existing / unknown-family no-op / no-Parser no-op), `ExtractParserCpnID` (enveloped + raw), `UnwrapCanvasDSL`. - `task/debug_test.go`: `TestInjectDebugPageCap` migrated to the new helper; new `TestWarnUnknownComponentParamsDetectsUnknownCPNFromEnvelope` captures the warning via `zaptest/observer` to prove the envelope no-op bug is fixed. - Both `internal/ingestion/pipeline` and `internal/ingestion/task` pass `build.sh --test` (unit tier). ## Notes - `TOKEN_CHUNKER_HANDOFF.md` is an unrelated untracked file and was deliberately **not** included in this PR.	2026-08-06 15:50:39 +08:00
Jack	8546eb62bf	Feat(ingestion): add canvas pipeline debug (dry-run) mode with View result log (#17538) ... ## Summary Adds a side-effect-free DataFlow canvas **debug (dry-run) mode** plus a **debug run log with a "View result" panel**, so a canvas can be executed synchronously and inspected end-to-end (per-component progress and parsed chunks) without persisting anything. ### Dry-run execution (inline parsed chunks) - `task/debug.go`: `NewDebugTaskContext` builds an in-memory `TaskContext` with **`KB.ID == ""` — the single debug signal used across the ingestion pipeline**. A canvas debug run has no knowledgebase, and production ingestion always supplies one, so `kb_id == ""` occurs ONLY in debug mode. Components gate their own side effects on this signal without any dedicated debug vocabulary (the former `CANVAS_DEBUG_DOC_ID` marker constant is removed). - `task/pipeline_executor.go`: `validateTaskContext` no longer requires a KB when `KB.ID == ""` (debug); debug runs return `collectDebugOutput` (chunks) instead of a no-op; uploaded bytes are delivered as `inputs['binary']` for doc-less runs; `injectDebugPageCap` caps the parser to the first pages for a fast preview via the production `override_params` channel (Parser cpnID + family). - `component/tokenizer.go`: `shouldHaveEmbedding` skips embedding when `kb_id == ""` — the embedder is configured on the knowledgebase, so a debug run has nothing to resolve against and stays side-effect free. - `chunker/register.go`: chunk images are uploaded to MinIO only when a KB is present (persist run). **In debug mode the raw image bytes are intentionally dropped (`delete(ck, "image")`)** — the debug preview does not render chunk images, and dropping the bytes keeps them out of memory and out of the Redis-stored debug log. This is a deliberate trade-off, not an oversight. - `component/file.go`: pass through in-memory binary bytes, skipping `doc_id` -> storage resolution. - `handler/agent.go` + `agent_webhook.go`: detect `dataflow_canvas` and run a sync debug returning chunks inline on the existing chat/completions endpoint; reject DataFlow canvases from webhooks (fixes the previously dead `== "DataFlow"` check; mirrors Python `agent_api.py`). - `parser_dispatch.go`: export `ParserFileFamily` for the executor's page-cap injection. ### Debug run log + "View result" Mirrors Python's debug-log contract so the front-end can replay each component's progress and parsed output: - `task/debug_log_sink.go`: a `DebugLogSink` records every component's lifecycle into a `[{component_id, trace}]` array (each trace entry carries `message`, `progress`, `timestamp`, `elapsed_time`). `Flush` appends a terminal `END` marker whose first trace message is non-empty so the front-end detects completion. On failure the END marker is prefixed `[ERROR]` yet still carries the run, so the failure timeline renders instead of being stuck empty. Timestamps and `elapsed_time` are in seconds (matching the rest of the app). - `task/debug_result_dsl.go`: `BuildDebugResultDSL` builds the `dsl` the END marker carries — the Go analogue of Python's `Graph.__str__` + END-marker `dsl` in `rag/flow/pipeline.py`. It combines the static DSL structure (component_name / downstream / params / graph.nodes) with the run output map (`output["state"][<id>]`) to emit, per component, `obj.params.outputs[<format>].value` (chunks / text / json / html / markdown) — the exact keys the front-end `dataflow-result` page reads to render each step's parsed chunks. Raw embedding vectors (including the dimension-scoped `q_<dim>_vec` keys) are stripped so the stored log stays Python-scale. - `task/pipeline_executor.go`: after the run, attach the built `dsl` to the END marker via the `ResultSink` capability. - `handler/agent.go`: `runCanvasPipelineDebug` generates a stable `message_id` up-front and always flushes the log (success or failure); `respondWithDebugResult` returns `message_id` in **both** the success and the error envelope so the front-end can poll the log. The debug-log endpoint `GET /agents/:id/logs/:message_id` serves the array. - `web/src/pages/agent/hooks/use-run-dataflow.ts`: on a run failure, also surface `message_id` via `setMessageId` so the log sheet renders the failure timeline (the `[ERROR]` END marker is already written). Guarded by `if (msgId)`, so it is a safe no-op when the back-end does not return an id. ## Behavioral notes - Debug parses only the first pages (`debugPageCapPages`) for a fast preview; an explicit `pages` cap already present in the ParserConfig is respected. - Debug mode does not keep chunk images (see above) and does not compute embeddings — it exercises parse + chunk only. ## Test plan - Go: `debug_test.go`, `debug_log_sink_test.go` (trace pairing, END marker, `[ERROR]` prefix, fractional-second timestamp/elapsed_time, size caps, and a real-pipeline test asserting the END-marker `dsl` carries non-empty per-component `params.outputs` with chunks), `debug_result_dsl_test.go` (flat and real nested `output["state"]` shapes, vector stripping, format priority), `debug_pages_integration_test.go`, `pipeline_executor_persist_test.go`, `handler/agent_pipeline_debug_test.go`, `handler/agent_logs_test.go` (incl. `TestRunCanvasPipelineDebug_ErrorStillExposesMessageID` / `TestRespondWithDebugResult_ErrorCarriesMessageID` locking `message_id` on failure), plus updates to `agent_test.go` / `agent_webhook_test.go` / `chunker/image_upload_test.go` / `tokenizer*.go`. - `go build ./...` and `./build.sh --test` for affected packages. 🤖 Generated with [CodeBuddy Code](https://cnb.cool/codebuddy) --------- Co-authored-by: CodeBuddy Code <noreply@tencent.com>	2026-07-31 13:10:08 +08:00