dowafu 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eddy Chang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,158 @@
+# dowafu
+
+Send a section of your design doc to external LLMs for review, from the terminal.
+
+You write a ticket. `dowafu` calls each provider's API. Each reviewer — a *spoke* —
+reads only the files you whitelisted, and returns observations with the evidence it
+read them from. Everything lands on disk for you to check.
+
+**Spokes produce observations, not verdicts.** What to do about them stays with you.
+
+> ### Tickets work in English or Chinese. The CLI's own output is Chinese.
+>
+> Write the ticket's section headings in either language and the rest follows: the
+> reviewer is prompted in that language, asked for its report in that language's
+> template, and the audit checks it against the matching one. The language is decided by
+> the headings themselves — there is no flag to forget — and the dry run prints which one
+> it resolved to, per reviewer.
+>
+> What is still Traditional Chinese: `--help`, error messages, the dry-run report and
+> `summary.md`. That is the development language and it has not been translated.
+
+## Install
+
+```bash
+npm install -g dowafu
+```
+
+The command is `dowafu`.
+
+## API keys
+
+Keys are read from `$DISPATCH_HOME/.env`, which defaults to `~/.config/dispatch/.env`
+(`DISPATCH_HOME` or `XDG_CONFIG_HOME` override it). Variables already present in the
+environment win over the file, so CI and one-off overrides need no file at all.
+
+```bash
+mkdir -p ~/.config/dispatch
+cat > ~/.config/dispatch/.env <<'EOF'
+DEEPSEEK_API_KEY=
+GEMINI_API_KEY=
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+EOF
+chmod 600 ~/.config/dispatch/.env
+```
+
+Only the providers you actually dispatch to need a key. The file is plain text — it is
+protected by nothing but its file permissions.
+
+**The current directory's `.env` is never read.** That directory is the project under
+review, and its secrets have no business in a process that talks to three external APIs.
+
+## Usage
+
+```bash
+dowafu <ticket-dir> --dry-run   # parse, validate, estimate. No API call, no cost.
+dowafu <ticket-dir> --yes       # run it. This is what costs money.
+dowafu --help                   # every flag
+```
+
+Without `--yes`, the command asks for confirmation. When stdin is not a TTY — which is
+the case whenever an agent runs it for you — there is nobody to answer, so it stops
+before calling anything.
+
+## The ticket
+
+A ticket is a directory with three kinds of file. The headings are **literal markers the
+parser matches** — use one of the two sets below, exactly as written.
+
+| English | 中文 |
+| --- | --- |
+| `# Questions` | `# 具體問題` |
+| `# Allowed reads` | `# 允許讀取` |
+| `# Under review` | `# 待審段落` |
+| `# Premises` | `# 前提（不受審）` |
+
+| File | Contents |
+| --- | --- |
+| `_dispatch.md` | which reviewers to run, and with which provider and model |
+| `_shared.md` | the premises, and the section under review, pasted in verbatim |
+| `<agent>.md` | one per reviewer: its questions, and the files it may read |
+
+```markdown
+<!-- _dispatch.md -->
+<!-- format: v1 -->
+# dispatch auth-review
+
+| agent | provider | model | effort |
+| --- | --- | --- | --- |
+| hole-finder-safety | deepseek | deepseek-v4-flash | |
+| hole-finder-feasibility | openai | gpt-5.6-luna | |
+```
+
+```markdown
+<!-- hole-finder-safety.md -->
+# Questions
+1. Does the permission check described here hold under concurrent requests?
+
+# Allowed reads
+- lib/auth-guard.ts
+- prisma/schema.prisma
+```
+
+The set you use decides the reviewer's language: `# Questions` gets an English prompt and
+an English report template, `# 具體問題` gets the Chinese ones. Mixing the two sets inside
+one reviewer's file is not supported — the first heading that matches wins.
+
+Reviewer definitions live in `.claude/agents/<agent>.md` under the repo root — they are
+the source of each spoke's system prompt, and the CLI reads them directly. Results are
+written to `tmp/spoke/<ticket-id>/`: each spoke's report, a `summary.md` with the audit
+table and estimated cost, `run.jsonl` with one line per event, and `raw/` with the exact
+requests and responses.
+
+## What the tool guarantees
+
+- **Reads are whitelisted per call.** A spoke asking for a file outside its list is
+  refused, and the refusal is recorded.
+- **`_docs/` is off limits**, whatever the whitelist says.
+- **Nothing is billed before you confirm.** The dry run prints the resolved repo root,
+  models, token estimates and output path, and calls no API.
+- **Secrets are masked** in `run.jsonl`, `raw/*.json` and stdout.
+- **Failures stop the run.** A missing key, an unknown model, a file that does not
+  exist — each aborts with the path or name that caused it, before any spend.
+
+## Models
+
+| provider | model |
+| --- | --- |
+| `openai` | `gpt-5.6-luna`, `gpt-5.6-terra`, `gpt-5.6-sol` |
+| `deepseek` | `deepseek-v4-flash` |
+| `gemini` | `gemini-3.1-flash-lite`, `gemini-3.5-flash-lite`, `gemini-3.6-flash` |
+| `anthropic` | `claude-opus-5`, `claude-sonnet-5` |
+
+The list ships with the package as `providers.json`. Point `--providers` at your own copy
+to use anything else.
+
+## Driving it from an agent
+
+`publish/` contains the skills and reviewer definitions to copy into a project, so that
+an agent working there knows how to write a ticket, what to check before spending, and
+how to read the results. Copy both directories — `.claude/` holds the reviewer
+definitions the CLI itself reads, so it is required no matter which agent you use.
+
+```bash
+TARGET=<your project>
+mkdir -p "$TARGET/.claude/skills" "$TARGET/.claude/agents" "$TARGET/.agents/skills"
+cp -R publish/.claude/skills/. "$TARGET/.claude/skills/"
+cp -R publish/.agents/skills/. "$TARGET/.agents/skills/"
+cp publish/.claude/agents/*.md "$TARGET/.claude/agents/"
+cp publish/workflow_spec.md "$TARGET/"
+```
+
+See `publish/README.md` for the details. Those documents are currently written in
+Traditional Chinese.
+
+## License
+
+MIT

package/dist/adapters/anthropic-messages.js

@@ -0,0 +1,145 @@
+// plan_dispatch_v2.7.md §29：anthropic-messages adapter（Claude Opus 5／Sonnet 5）。
+// 原生 Messages API，不套 OpenAI 相容殼——responses adapter 的具體型別（client.responses.create、
+// function_call_output、response.output）與這裡的 wire format 完全不同，即使 reasoning.style
+// 的 JSON 片段長得像 deepseek 的 output_config.effort（見規格二），也不得重用 responses adapter：
+// 那條路徑走 OpenAI SDK 與 /v1/responses 端點，端點、headers、訊息格式全不對。
+//
+// assistant turn 的 raw 是整個 {role:"assistant", content:[...blocks]} message 物件，續接時
+// 原樣放回 messages 陣列——與 gemini-native 同形，用 checkRawObjectIntegrity（不是
+// checkRawArrayIntegrity）。§29 規格六：Opus 4.5／4.6 以上模型會把前輪 thinking block
+// 併入 input 計費，且 manual 模式下最後一輪 assistant turn 須以 thinking block 開頭——
+// content 陣列必須原封不動塞回，不得過濾掉 thinking block。
+//
+// §29 規格五：Anthropic 的 tool_result block 放在 user role 的 message 裡，且多筆結果應併在
+// 同一則 message——runner.ts 每個 tool 呼叫各自 push 一個 { role:"tool" } turn，故這裡的轉換
+// 需要前瞻（look-ahead）把連續的 tool turn 合併成一則 user message，responses adapter 的
+// turnToInputItems 那種一對多純映射在此不適用（見 turnsToMessages）。
+//
+// §29 規格十一：本檔的所有形態已用 scripts/verify-providers.ts 對真實 API 逐項實測
+// 確認過（tool calling、tool_result 合併、usage 欄位名、effort 生效方向、cache_control
+// 生效、thinking.type:"enabled" 確實 400），結果見 facts_dispatch.md。
+import { normalizeAnthropicUsage, normalizeFinishReason } from "../usage.js";
+import { ProviderHttpError } from "../mask.js";
+import { checkRawObjectIntegrity } from "../raw-integrity.js";
+const ANTHROPIC_VERSION = "2023-06-01";
+// §29 規格四：max_tokens 是 Anthropic 專屬必要參數，SendOptions 沒有這個概念（openai／gemini
+// 都不需要）。寫死在 adapter，不提升到 SendOptions——那會逼另外兩個 adapter 處理用不到的欄位。
+// 初始值推導見規格四：十次派工單支最高 40,970 output token，32k 有 20% 餘裕；本版預設 effort
+// 不會用到官方建議 64k 起跳的 xhigh／max。撞到 stop_reason:"max_tokens" 再調，不在此臆測。
+const ANTHROPIC_MAX_TOKENS = 32768;
+const READ_FILE_TOOL = {
+    name: "read_file",
+    description: "讀取指定路徑的檔案內容",
+    input_schema: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"],
+    },
+};
+// §29 規格二：thinking.type:"enabled" 在 Opus 5／Sonnet 5 會 400（實測確認，見
+// facts_dispatch.md）。正確路徑是 adaptive thinking ＋ output_config.effort，兩者一起送——
+// 即使 output_config.effort 的 JSON 片段與 deepseek 的 reasoning.style 完全相同，這是巧合
+// 不是可重用的理由（deepseek 走 responses adapter／OpenAI SDK，端點與訊息格式全不同）。
+function buildReasoningParams(style, effort) {
+    if (!effort)
+        return {}; // §4：留白則不送任何 reasoning 參數（validate.ts 已解析為 default，實務上不會是 undefined）
+    if (style === "anthropic")
+        return { thinking: { type: "adaptive" }, output_config: { effort } };
+    throw new Error(`anthropic-messages adapter 不支援 reasoning.style=${style}`);
+}
+// §29 規格五：把 conv.turns 轉成 Anthropic 的 messages 陣列。tool turn 需要前瞻合併——
+// runner.ts 對同一輪的每個 tool call 各自 push 一個 { role:"tool" } turn，連續的多個 tool
+// turn 必須合併成一則 user message、內含多個 tool_result block，不能逐筆送出（逐筆送出會
+// 產生連續兩則 user message，Anthropic 不接受這種形態）。
+function turnsToMessages(turns) {
+    const messages = [];
+    let i = 0;
+    while (i < turns.length) {
+        const turn = turns[i];
+        if (turn.role === "user") {
+            messages.push({ role: "user", content: turn.text });
+            i++;
+            continue;
+        }
+        if (turn.role === "assistant") {
+            // raw 是上一輪原樣的 {role:"assistant", content:[...blocks]} 物件，原樣放回（§8／規格六）
+            messages.push(turn.raw);
+            i++;
+            continue;
+        }
+        // turn.role === "tool"：吃掉所有連續的 tool turn，併成一則 user message
+        const toolResults = [];
+        while (i < turns.length && turns[i].role === "tool") {
+            const toolTurn = turns[i];
+            toolResults.push({ type: "tool_result", tool_use_id: toolTurn.callId, content: toolTurn.result });
+            i++;
+        }
+        messages.push({ role: "user", content: toolResults });
+    }
+    return messages;
+}
+// 純函式：組出實際會送出的請求，並執行 §8 的 raw 完整性自我檢查（違反即拋 RawIntegrityError，
+// 不需打 API 就能測試——見 anthropic-messages.test.ts）。
+export function buildAnthropicRequest(conv, opts, config) {
+    const messages = turnsToMessages(conv.turns);
+    checkRawObjectIntegrity(conv, messages);
+    return {
+        model: opts.model,
+        max_tokens: ANTHROPIC_MAX_TOKENS,
+        system: conv.systemPrompt,
+        messages,
+        // §29 規格八：top-level 自動快取，由 API 自行管理斷點位置並隨對話推進。低於該模型最低
+        // 可快取 token 數時 API 靜默不快取、不報錯，故此欄位可無條件加，不需前置估算。
+        cache_control: { type: "ephemeral" },
+        ...(opts.enableTools === false ? {} : { tools: [READ_FILE_TOOL] }),
+        ...buildReasoningParams(config.reasoning.style, opts.effort),
+    };
+}
+export function createAnthropicAdapter(config) {
+    return {
+        async send(conv, opts) {
+            const body = buildAnthropicRequest(conv, opts, config);
+            const res = await fetch(`${config.baseURL}/v1/messages`, {
+                method: "POST",
+                headers: {
+                    "x-api-key": config.apiKey,
+                    "anthropic-version": ANTHROPIC_VERSION,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: opts.signal,
+            });
+            const responseBody = await res.json();
+            if (!res.ok) {
+                throw new ProviderHttpError(`Anthropic Messages API ${res.status}`, res.status, Object.fromEntries(res.headers.entries()), responseBody, body);
+            }
+            const content = responseBody.content ?? [];
+            const toolUseBlocks = content.filter((b) => b.type === "tool_use");
+            const toolCalls = toolUseBlocks.map((b) => ({
+                id: b.id,
+                name: b.name,
+                args: b.input ?? {},
+            }));
+            const text = content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("");
+            const { finishReason, finishReasonRaw } = normalizeFinishReason(responseBody.stop_reason ?? null);
+            return {
+                turn: { role: "assistant", raw: { role: "assistant", content }, toolCalls },
+                usage: normalizeAnthropicUsage(responseBody.usage),
+                usageRaw: responseBody.usage ?? null,
+                meta: {
+                    modelReturned: responseBody.model ?? null,
+                    finishReason,
+                    finishReasonRaw,
+                    requestId: responseBody.id ?? null,
+                    store: "n/a", // §6：Messages API 無 store 概念（規格九）
+                    text: toolCalls.length === 0 ? text || null : null,
+                },
+                request: body,
+                response: responseBody,
+            };
+        },
+    };
+}

package/dist/adapters/gemini-native.js

@@ -0,0 +1,114 @@
+// plan_dispatch_v1.4.md §7/§8：gemini-native adapter，原生 generateContent，不套 OpenAI
+// 相容殼（decision「介面策略」；issue_log_v1.md 2026-08-05「作一個專門給 Gemini」裁示）。
+// 金鑰走 x-goog-api-key header，不進 URL query string（§18）。
+//
+// assistant turn 的 raw 就是 candidate.content（{role:"model", parts:[...]}）整個物件，
+// 續接時原樣放回 contents（§8）——gemini-3.x 系列的 thoughtSignature 掛在 part 上，
+// 隨 raw 一起帶回，不需另闢欄位承接。
+import { normalizeFinishReason, normalizeGeminiUsage } from "../usage.js";
+import { ProviderHttpError } from "../mask.js";
+import { checkRawObjectIntegrity } from "../raw-integrity.js";
+const GEMINI_TOOL = {
+    functionDeclarations: [
+        {
+            name: "read_file",
+            description: "讀取指定路徑的檔案內容",
+            parameters: {
+                type: "object",
+                properties: { path: { type: "string" } },
+                required: ["path"],
+            },
+        },
+    ],
+};
+function turnToContent(turn) {
+    if (turn.role === "user") {
+        return { role: "user", parts: [{ text: turn.text }] };
+    }
+    if (turn.role === "tool") {
+        // functionResponse 以 name 對應，不需要 call id（實測確認，見 issue_log）
+        let responseObj;
+        try {
+            responseObj = JSON.parse(turn.result);
+        }
+        catch {
+            responseObj = { result: turn.result };
+        }
+        return {
+            role: "user",
+            parts: [{ functionResponse: { name: turn.callId, response: responseObj } }],
+        };
+    }
+    // assistant：raw 就是上一輪 candidate.content，原樣放回
+    return turn.raw;
+}
+// plan_dispatch_v1.8.md §5「reasoning.style 的三種轉換」（實測確認）：位置與大小寫都關鍵——
+// 頂層 thinking_level 會 400；巢狀內 snake_case（thinking_level）會 200 但 Google 對未知
+// 欄位靜默忽略、不生效。正確路徑是 generationConfig.thinkingConfig.thinkingLevel（camelCase）。
+function buildReasoningParams(effort) {
+    if (!effort)
+        return {};
+    return { generationConfig: { thinkingConfig: { thinkingLevel: effort } } };
+}
+// 純函式：組出實際會送出的 request body，並執行 §8 的 raw 完整性自我檢查（違反即拋
+// RawIntegrityError，不需打 API 就能測試——見 raw-integrity.test.ts）。
+export function buildGeminiRequest(conv, opts) {
+    const contents = conv.turns.map(turnToContent);
+    checkRawObjectIntegrity(conv, contents);
+    const body = {
+        contents,
+        system_instruction: { parts: [{ text: conv.systemPrompt }] },
+        ...(opts.enableTools === false ? {} : { tools: [GEMINI_TOOL] }),
+        ...buildReasoningParams(opts.effort),
+    };
+    return { contents, body };
+}
+export function createGeminiAdapter(config) {
+    return {
+        async send(conv, opts) {
+            const { body } = buildGeminiRequest(conv, opts);
+            const res = await fetch(`${config.baseURL}/models/${opts.model}:generateContent`, {
+                method: "POST",
+                headers: { "x-goog-api-key": config.apiKey, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: opts.signal,
+            });
+            const responseBody = await res.json();
+            if (!res.ok) {
+                throw new ProviderHttpError(`Gemini native API ${res.status}`, res.status, Object.fromEntries(res.headers.entries()), responseBody, body);
+            }
+            const candidate = responseBody.candidates?.[0];
+            const parts = candidate?.content?.parts ?? [];
+            const callParts = parts.filter((p) => p.functionCall);
+            const toolCalls = callParts.map((p, index) => ({
+                id: p.functionCall?.id ?? `gemini-call-${index}`,
+                name: p.functionCall.name,
+                args: p.functionCall.args ?? {},
+            }));
+            const text = parts
+                .filter((p) => typeof p.text === "string")
+                .map((p) => p.text)
+                .join("");
+            const { finishReason, finishReasonRaw } = normalizeFinishReason(candidate?.finishReason ?? null);
+            return {
+                turn: {
+                    role: "assistant",
+                    raw: candidate?.content ?? { role: "model", parts: [] },
+                    toolCalls,
+                },
+                usage: normalizeGeminiUsage(responseBody.usageMetadata),
+                usageRaw: responseBody.usageMetadata ?? null,
+                meta: {
+                    modelReturned: responseBody.modelVersion ?? null,
+                    finishReason,
+                    finishReasonRaw,
+                    requestId: responseBody.responseId ?? null,
+                    store: "n/a", // §6：generateContent 無此參數
+                    text: toolCalls.length === 0 ? text || null : null,
+                },
+                request: body,
+                response: responseBody,
+            };
+        },
+    };
+}

package/dist/adapters/responses.js

@@ -0,0 +1,112 @@
+// plan_dispatch_v1.4.md §7/§8：openai／deepseek 共用的 `responses` adapter。
+// 全面 stateless（§6）：每輪把 conv.turns 整段轉成 input 陣列重送，不用
+// previous_response_id。assistant turn 續接用 raw（該輪 response.output 整包），
+// 不用 toolCalls 重建——這是 v1.3 犯錯、v1.4 §8 明訂修正的地方。
+import OpenAI from "openai";
+import { normalizeFinishReason, normalizeResponsesUsage } from "../usage.js";
+import { ProviderHttpError } from "../mask.js";
+import { checkRawArrayIntegrity } from "../raw-integrity.js";
+const READ_FILE_TOOL = {
+    type: "function",
+    name: "read_file",
+    description: "讀取指定路徑的檔案內容",
+    parameters: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"],
+    },
+    strict: false,
+};
+// plan_dispatch_v1.8.md §5「reasoning.style 的三種轉換」（實測確認，v1.7 兩處填錯已修正）：
+// deepseek 正確路徑是 output_config.effort，不是 chat/completions 章節的
+// thinking/reasoning_effort——後者對 /v1/responses 端點回顯欄位但靜默不生效
+// （issue_log_v1.md 2026-08-06）。
+function buildReasoningParams(style, effort) {
+    if (!effort)
+        return {}; // §4：留白則不送任何 reasoning 參數（v1 起 validate.ts 已解析為 default，實務上不會是 undefined）
+    if (style === "openai")
+        return { reasoning: { effort } };
+    if (style === "deepseek")
+        return { output_config: { effort } };
+    throw new Error(`responses adapter 不支援 reasoning.style=${style}`);
+}
+function turnToInputItems(turn) {
+    if (turn.role === "user") {
+        return [{ role: "user", content: [{ type: "input_text", text: turn.text }] }];
+    }
+    if (turn.role === "tool") {
+        return [{ type: "function_call_output", call_id: turn.callId, output: turn.result }];
+    }
+    // assistant：raw 是上一輪的完整 response.output 陣列，原樣展開塞回（§8）
+    return turn.raw;
+}
+// 純函式：組出實際會送出的請求，並執行 §8 的 raw 完整性自我檢查（違反即拋
+// RawIntegrityError，不需打 API 就能測試——見 raw-integrity.test.ts）。
+export function buildResponsesRequest(conv, opts, config) {
+    const input = conv.turns.flatMap(turnToInputItems);
+    checkRawArrayIntegrity(conv, input);
+    return {
+        model: opts.model,
+        instructions: conv.systemPrompt,
+        input,
+        ...(opts.enableTools === false ? {} : { tools: [READ_FILE_TOOL] }),
+        ...(config.store === false ? { store: false } : {}),
+        include: ["reasoning.encrypted_content"],
+        ...buildReasoningParams(config.reasoning.style, opts.effort),
+    };
+}
+export function createResponsesAdapter(config) {
+    const client = new OpenAI({ apiKey: config.apiKey, baseURL: config.baseURL });
+    return {
+        async send(conv, opts) {
+            const params = buildResponsesRequest(conv, opts, config);
+            let response;
+            try {
+                response = await client.responses.create(params, { signal: opts.signal });
+            }
+            catch (err) {
+                if (err && typeof err === "object" && "status" in err) {
+                    const anyErr = err;
+                    throw new ProviderHttpError(anyErr.message ?? "responses adapter 呼叫失敗", anyErr.status ?? 0, anyErr.headers ?? {}, anyErr.error, params);
+                }
+                throw err;
+            }
+            const functionCalls = response.output.filter((item) => item.type === "function_call");
+            const toolCalls = functionCalls.map((call) => ({
+                id: call.call_id,
+                name: call.name,
+                args: safeParseArgs(call.arguments),
+            }));
+            const messageItem = response.output.find((item) => item.type === "message");
+            const text = messageItem?.content
+                .filter((c) => c.type === "output_text")
+                .map((c) => c.text)
+                .join("") ?? null;
+            const { finishReason, finishReasonRaw } = normalizeFinishReason(response.status);
+            return {
+                turn: { role: "assistant", raw: response.output, toolCalls },
+                usage: normalizeResponsesUsage(response.usage),
+                usageRaw: response.usage ?? null,
+                meta: {
+                    modelReturned: response.model ?? null,
+                    finishReason,
+                    finishReasonRaw,
+                    requestId: response.id ?? null,
+                    store: config.store === false ? "false" : "n/a",
+                    text: functionCalls.length === 0 ? text : null,
+                },
+                request: params,
+                response,
+            };
+        },
+    };
+}
+function safeParseArgs(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}