@bubblebrain-ai/bubble 0.0.4 → 0.0.6

package/dist/prompt/reminders.js

@@ -1,13 +1,13 @@
 /**
  * System reminders - short, runtime-variable instructions injected into the
- * message stream as <system-reminder>-wrapped user messages with isMeta=true.
+ * message stream as hidden meta messages.
  *
  * Rationale: the static system prompt is stable and cacheable. Mode transitions
  * and other ephemeral state are signaled via reminders so we do not invalidate
  * the prompt cache every time something changes.
  */
 export function wrapInSystemReminder(content) {
-    return `<system-reminder>\n${content.trim()}\n</system-reminder>`;
+    return content.trim();
 }
 export function isPermissionModeReminder(content) {
     if (typeof content !== "string")
@@ -20,7 +20,7 @@ const PLAN_MODE_ENTER = `
 Plan mode is now ACTIVE.
 
 Rules while in plan mode:
-- Only read-only tools are allowed, including read, glob, grep, lsp, web_search, web_fetch, task, skill, todo_write, tool_search, question, and exit_plan_mode.
+- Only read-only tools are allowed, including read, glob, grep, lsp, web_search, web_fetch, spawn_agent, wait_agent, send_input, close_agent, skill, todo_write, tool_search, question, and exit_plan_mode.
 - Writes, edits, and shell commands WILL be rejected by the harness; do not try them.
 - Do not edit files or claim implementation is complete while plan mode is active.
 - Investigate the codebase, then use the question tool to clarify important ambiguities, tradeoffs, requirements, or preference choices that would materially change the plan.
@@ -55,7 +55,6 @@ export function reminderForMode(mode) {
             return wrapInSystemReminder(DEFAULT_ENTER);
     }
 }
-// Backward-compat exports kept in case external code pinned the old names.
 export const PLAN_MODE_ENTER_REMINDER = reminderForMode("plan");
 export const PLAN_MODE_EXIT_REMINDER = reminderForMode("default");
 /**
@@ -172,13 +171,59 @@ Treat the task output as a bounded subtask result:
 - do not re-run the same exploratory search unless the subtask uncovered a concrete contradiction
 `);
 }
-export function buildVerificationReminder(reason) {
+// Removed: buildVerificationReminder / buildVerificationFailureReminder.
+// The verification reminder ladder pressured the model to run a "verification"
+// after every file change. For models with hex-tokenization blind spots (e.g.
+// DeepSeek v4-pro), this triggered death loops where the model wrote ad-hoc
+// validation scripts that found the bug but could never fix it. CC trusts the
+// model to decide when verification is meaningful; we follow that.
+/**
+ * Fired when the same edit/write tool call (identical tool name + args) has
+ * just failed for the second time in a row. Models — especially thinking-heavy
+ * ones — can otherwise spiral on `No changes made: identical content` or
+ * `oldText not found` because their internal reasoning convinces them they
+ * are typing the change correctly even though the JSON args arrive identical.
+ * This nudge forces a strategy change.
+ */
+export function buildEditRetryEscalationReminder(reason) {
     return wrapInSystemReminder(`
-Verification required before final answer.
+The same edit/write call has failed twice with identical arguments.
 
 ${reason}
 
-You have changed files in this turn. Run the narrowest meaningful verification command or runtime check before finalizing.
-If verification truly cannot be run, state the concrete blocker and the residual risk.
+Stop retrying the same call. Pick one of:
+- Re-read the target file and compare the actual bytes to your intended oldText / newText. Trailing whitespace, unicode lookalikes, or off-by-one boundaries are common causes.
+- If you intended to add a single character (e.g. fixing a 5-digit hex color to 6 digits), confirm that your newText string actually contains the added character before sending again.
+- Use the write tool with overwrite=true and the full new content instead of edit — useful when the change spans many lines or the diff anchor is ambiguous. Existing files must be read or modified in this session before full-file replacement.
+- If you cannot determine the cause, ask the user for clarification.
+`);
+}
+/**
+ * Fired the FIRST time the model re-reads a file it already read in this turn.
+ * Soft — does not freeze the tool. Just prevents a 3rd / 4th re-read.
+ */
+export function buildRedundantReadReminder(path) {
+    return wrapInSystemReminder(`
+You already read ${path} earlier in this turn. Use the content already in context rather than re-reading.
+Only re-read this path if a subsequent tool call (edit/write/bash) modified it since.
+`);
+}
+/**
+ * Injected once at task start when the user's input looks like a small,
+ * focused task (e.g. "write an HTML page about X"). Counterweight to the
+ * default protocol which biases toward thorough exploration.
+ */
+export function buildSmallTaskHint() {
+    return wrapInSystemReminder(`
+This appears to be a small, focused task (short request, single deliverable, no integration ambiguity).
+
+Prefer direct execution over exploration:
+- If the target file path is given or obvious, use write/edit directly.
+- Do not glob, read, or grep adjacent files unless the request explicitly references them.
+- Do not pre-plan with todo_write for tasks that can be done in one or two tool calls.
+- Skip the "investigate the codebase" step that applies to larger changes.
 `);
 }
+// Removed: buildFinalizeOpportunityReminder. Was paired with the verification
+// nag ladder. Without the ladder, "you can finalize now" advice is redundant —
+// the model finalises whenever its own judgement says the task is done.

package/dist/prompt/runtime.d.ts

@@ -3,7 +3,7 @@ export interface RuntimePromptOptions {
     thinkingLevel?: ThinkingLevel;
     /**
      * Kept for API compatibility. Agent mode is no longer baked into the static
-     * system prompt — mode changes are signalled via <system-reminder> injections
+     * system prompt — mode changes are signalled via hidden runtime reminders
      * (see src/prompt/reminders.ts) so the base prompt stays stable for caching.
      */
     mode?: PermissionMode;

package/dist/prompt/runtime.js

@@ -1,30 +1,24 @@
+// Compact, prose-shaped guidelines. Each line is one rule. The set is kept
+// short on purpose: a thinking-heavy model burns reasoning tokens on every
+// rule it has to weigh per turn, and most behaviors should be background
+// disposition, not active checklist items. Add to this list only when an
+// observed failure cannot be addressed by an existing rule.
 const defaultGuidelines = [
-    "Inspect relevant files, command output, or runtime state before making claims about code behavior",
-    "Separate confirmed facts from inference when the evidence is incomplete",
-    "Prefer runtime and call-chain evidence over README text or configuration names for behavior questions",
-    "Before editing or writing files, read them first if they exist",
-    "Use edit for targeted changes to existing files; use write for creating new files",
-    "Edit only the files required for the requested change",
-    "Prefer structured search tools over bash for repository searches whenever possible",
-    "Do not repeat near-identical searches when they are not producing new evidence",
-    "When investigating configuration or security questions, stop once the relevant load path, storage path, and exposure path are identified",
-    "Use the task tool for bounded investigative subproblems instead of letting the main loop churn on repeated exploratory searches",
-    "After code edits, run the narrowest meaningful verification command or explain why verification is not possible",
-    "When finishing a coding task, report what changed, where it changed, verification results, and remaining risk",
-    "Be concise in your responses",
+    "Ground decisions in the codebase: inspect relevant files, command output, or runtime state before making claims about behavior. Separate confirmed facts from inference when evidence is incomplete.",
+    "Choose the smallest coherent change. Edit only the files required for the requested change; do not refactor or improve adjacent code unprompted.",
+    "For modifications to existing code, read the file first. For brand-new files whose target path is known and does not exist, write directly without exploratory reading. Use edit for small targeted changes; use write with overwrite=true for intentional full-file replacement of an existing file. Never delete and recreate a file just to overwrite it.",
+    "Prefer structured tools (glob, grep, lsp, read) over bash for search and inspection. Do not repeat a near-identical search or re-read the same file unless new evidence changes the question.",
+    "If a tool fails, diagnose the error before switching tactics. Do not retry the identical call with identical arguments. After two equivalent failures, switch approach — re-read the file, use a different tool, rewrite the whole file with write overwrite=true, or ask the user.",
+    "Before reporting a task complete, verify it works when verification is meaningful and cheap — run the existing test, execute the script, check the output. If no test exists, the change is purely declarative (static HTML/markdown/config), or running the code is not practical, state that explicitly rather than inventing a verification step. Do not write throwaway validation scripts to prove correctness; if there is no real check to run, report the change and stop.",
 ];
 export function buildRuntimePrompt(options = {}) {
-    const thinkingLevel = options.thinkingLevel ?? "off";
     const guidelines = dedupe(defaultGuidelines, options.guidelines ?? []);
-    return `Current thinking level: ${thinkingLevel}
-
-Execution protocol:
-1. Understand the user's requested outcome and current constraints.
-2. Inspect the relevant files or state before making claims or edits.
-3. Choose the smallest coherent change that solves the actual problem.
-4. Edit only the necessary files.
-5. Verify with the narrowest meaningful command or runtime check when possible.
-6. Finish with changed files, verification results, and unresolved risk.
+    // The execution flow is stated as a single prose sentence rather than a
+    // numbered protocol. Numbered checklists prompt thinking models to walk
+    // each step explicitly in their reasoning every turn, even for trivial
+    // tasks — multiplying latency without improving quality. Prose lets the
+    // protocol act as background disposition.
+    return `Work by understanding the requested outcome, grounding decisions in the codebase, making the smallest coherent change, and verifying when possible. Scale your effort to the task: a one-file create-or-edit deserves direct execution, not extensive pre-exploration.
 
 Guidelines:
 ${guidelines.map((item) => `- ${item}`).join("\n")}`;

package/dist/provider-artifacts.d.ts

@@ -0,0 +1,7 @@
+export declare function stripProviderProtocolArtifacts(text: string): string;
+export declare function isOnlyProviderProtocolArtifacts(text: string): boolean;
+export interface ProviderProtocolArtifactFilter {
+    push(text: string): string;
+    flush(): string;
+}
+export declare function createProviderProtocolArtifactFilter(): ProviderProtocolArtifactFilter;

package/dist/provider-artifacts.js

@@ -0,0 +1,60 @@
+// Models with non-OpenAI chat templates (GLM-4.5/4.6, DeepSeek, some Kimi builds)
+// emit tool-call delimiters as inline assistant text instead of as structured
+// tool_calls deltas. The shapes vary — `<|tool_call|>`, `<｜｜DSML｜｜tool_calls>`,
+// `<｜｜DSML｜｜invoke name="x">`, closing `</｜｜DSML｜｜tool_calls>`, etc. — but
+// they always share the pattern of a tag whose name is wrapped in `|` or `｜`.
+// If we let any of that text reach the consumer it pollutes the streamed
+// assistant text and, downstream, the subagent's summary field.
+const TOOL_PROTOCOL_PATTERNS = [
+    // Generic: opening or closing tag whose name is wrapped in `|` or `｜`,
+    // optionally with attributes after the closing pipe (e.g. `invoke name="x"`).
+    /<\/?\s*[｜|]+[^<>]*?[｜|]+[^<>]*>/g,
+    // Plain ASCII variants without attributes.
+    /<\/?\|tool_calls?\|>/gi,
+];
+export function stripProviderProtocolArtifacts(text) {
+    let out = text;
+    for (const pattern of TOOL_PROTOCOL_PATTERNS) {
+        out = out.replace(pattern, "");
+    }
+    return out;
+}
+export function isOnlyProviderProtocolArtifacts(text) {
+    return !!text.trim() && stripProviderProtocolArtifacts(text).trim().length === 0;
+}
+export function createProviderProtocolArtifactFilter() {
+    let pending = "";
+    return {
+        push(text) {
+            pending = stripProviderProtocolArtifacts(pending + text);
+            const keep = trailingPossibleMarkerLength(pending);
+            const emit = pending.slice(0, pending.length - keep);
+            pending = pending.slice(pending.length - keep);
+            return emit;
+        },
+        flush() {
+            const out = stripProviderProtocolArtifacts(pending);
+            pending = "";
+            return out;
+        },
+    };
+}
+// Hold back a trailing fragment if it could be the start of a pipe-wrapped tag
+// whose closing `>` hasn't arrived yet. Without this guard, a stream that flushes
+// mid-tag (`<` ... `｜DSML｜tool_calls`) would emit the partial tag as text, then
+// emit the rest later — the stripping regex only matches complete tags.
+function trailingPossibleMarkerLength(text) {
+    const lastLt = text.lastIndexOf("<");
+    if (lastLt === -1)
+        return 0;
+    const tail = text.slice(lastLt);
+    if (tail.includes(">"))
+        return 0;
+    // Hold back only when the trailing fragment looks like the start of a protocol
+    // tag. Anything else (e.g. `if (x < y)` in source) flushes immediately.
+    if (/^<\/?$/.test(tail))
+        return tail.length;
+    if (/^<\/?\s*[｜|]/.test(tail))
+        return tail.length;
+    return 0;
+}

package/dist/provider.d.ts

@@ -3,9 +3,13 @@
  *
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
-import type { Message, Provider, StreamChunk, ThinkingLevel } from "./types.js";
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
 type ReasoningContentEcho = "tool_calls" | "all";
-export declare function toChatCompletionsMessage(message: Message, options?: {
+export type ToolArgsMergeMode = "delta" | "snapshot";
+export interface TranslateOpenAIStreamOptions {
+    toolArgsMergeMode?: ToolArgsMergeMode;
+}
+export declare function toChatCompletionsMessage(message: ProviderMessage, options?: {
     reasoningContentEcho?: ReasoningContentEcho;
 }): Record<string, unknown>;
 export interface ProviderInstanceOptions {
@@ -17,15 +21,19 @@ export interface ProviderInstanceOptions {
 }
 export declare function createUnavailableProvider(message: string): Provider;
 export declare function createProviderInstance(options: ProviderInstanceOptions): Provider;
+export interface NormalizedToolArgs {
+    args: string;
+    corrupt: boolean;
+}
+export declare function normalizeToolArgsDetailed(raw: string): NormalizedToolArgs;
 export declare function normalizeToolArgs(raw: string): string;
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
- * Multi-tool-call streams are buffered by `index` and emitted in index order at
- * `finish_reason === "tool_calls"`, so the agent layer always sees a clean
- * (isStart -> args -> isEnd) sequence per call. This matters for providers like
- * Kimi K2.5 that emit several parallel tool calls per assistant turn -- the
- * previous single-slot implementation silently dropped every call but the last.
+ * Multi-tool-call streams are tracked by `index`, but tool-call starts and
+ * argument deltas are emitted as soon as they arrive so the TUI can render
+ * partial write previews before the tool executes. End events are still flushed
+ * in index order to keep multi-call turns deterministic.
  */
-export declare function translateOpenAIStream(stream: AsyncIterable<any>): AsyncIterable<StreamChunk>;
+export declare function translateOpenAIStream(stream: AsyncIterable<any>, options?: TranslateOpenAIStreamOptions): AsyncIterable<StreamChunk>;
 export {};

package/dist/provider.js

@@ -4,8 +4,25 @@
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
 import OpenAI from "openai";
+import { appendFileSync } from "node:fs";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
+import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
+// Diagnostic logger for tool-args byte-loss investigation. Activate with
+//   BUBBLE_DEBUG_TOOL_ARGS=/path/to/log.jsonl   (any writable path)
+// Each line is a JSON record describing a transition. When debugging is off,
+// the function is a no-op and free.
+const TOOL_ARGS_DEBUG_PATH = process.env.BUBBLE_DEBUG_TOOL_ARGS?.trim();
+function debugToolArgs(event) {
+    if (!TOOL_ARGS_DEBUG_PATH)
+        return;
+    try {
+        appendFileSync(TOOL_ARGS_DEBUG_PATH, JSON.stringify({ t: Date.now(), ...event }) + "\n", "utf-8");
+    }
+    catch {
+        // Diagnostic failures must not affect the model session.
+    }
+}
 export function toChatCompletionsMessage(message, options = {}) {
     const reasoningContentEcho = options.reasoningContentEcho ?? "tool_calls";
     if (message.role === "assistant") {
@@ -90,7 +107,9 @@ export function createProviderInstance(options) {
         const stream = (await client.chat.completions.create(body, {
             signal: chatOptions.abortSignal,
         }));
-        yield* translateOpenAIStream(stream);
+        yield* translateOpenAIStream(stream, {
+            toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
+        });
         yield { type: "done" };
     }
     async function complete(messages, chatOptions) {
@@ -117,19 +136,16 @@ export function createProviderInstance(options) {
     }
     return { streamChat, complete };
 }
-// Some providers (notably Fireworks-hosted Kimi) stream tool-call arguments
-// as repeated full snapshots in each delta instead of incremental chunks, so
-// a naive `+=` produces `{"x":1}{"x":1}` — not valid JSON. Parse the raw
-// stream; if it doesn't parse but contains a balanced `{…}` prefix or suffix
-// that does, use that. Empty or unsalvageable input becomes `"{}"` so the
-// downstream echo to the model is always valid JSON.
-export function normalizeToolArgs(raw) {
+export function normalizeToolArgsDetailed(raw) {
     const s = (raw ?? "").trim();
-    if (!s)
-        return "{}";
+    if (!s) {
+        debugToolArgs({ stage: "normalize", input: raw, output: "{}", reason: "empty" });
+        return { args: "{}", corrupt: false };
+    }
     try {
         JSON.parse(s);
-        return s;
+        debugToolArgs({ stage: "normalize", input: raw, output: s, reason: "passthrough" });
+        return { args: s, corrupt: false };
     }
     catch { }
     const firstBrace = extractBalancedJson(s, 0);
@@ -138,21 +154,39 @@ export function normalizeToolArgs(raw) {
             JSON.parse(firstBrace);
         }
         catch {
-            return "{}";
+            debugToolArgs({ stage: "normalize", input: raw, output: "{}", reason: "first-brace-unparseable", firstBrace });
+            return { args: "{}", corrupt: true };
         }
         // If the content after the first balanced object is another valid object
         // with the same parse, we've got a snapshot duplication — keep one copy.
         const rest = s.slice(firstBrace.length).trim();
-        if (!rest)
-            return firstBrace;
+        if (!rest) {
+            debugToolArgs({ stage: "normalize", input: raw, output: firstBrace, reason: "single-brace" });
+            return { args: firstBrace, corrupt: false };
+        }
         try {
             JSON.parse(rest);
-            return firstBrace;
+            debugToolArgs({ stage: "normalize", input: raw, output: firstBrace, reason: "snapshot-dedup", rest });
+            return { args: firstBrace, corrupt: false };
         }
         catch { }
-        return firstBrace;
+        debugToolArgs({ stage: "normalize", input: raw, output: firstBrace, reason: "trailing-junk-dropped", rest });
+        return { args: firstBrace, corrupt: false };
     }
-    return "{}";
+    debugToolArgs({ stage: "normalize", input: raw, output: "{}", reason: "no-balanced-json" });
+    return { args: "{}", corrupt: true };
+}
+export function normalizeToolArgs(raw) {
+    return normalizeToolArgsDetailed(raw).args;
+}
+function resolveToolArgsMergeMode(providerId, baseURL) {
+    const id = providerId.toLowerCase();
+    const url = baseURL.toLowerCase();
+    // Fireworks-hosted Kimi has been observed to stream cumulative snapshots
+    // rather than OpenAI-style argument deltas.
+    if (id === "fireworks" || url.includes("fireworks.ai"))
+        return "snapshot";
+    return "delta";
 }
 function extractBalancedJson(s, start) {
     if (s[start] !== "{")
@@ -189,14 +223,21 @@ function extractBalancedJson(s, start) {
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
- * Multi-tool-call streams are buffered by `index` and emitted in index order at
- * `finish_reason === "tool_calls"`, so the agent layer always sees a clean
- * (isStart -> args -> isEnd) sequence per call. This matters for providers like
- * Kimi K2.5 that emit several parallel tool calls per assistant turn -- the
- * previous single-slot implementation silently dropped every call but the last.
+ * Multi-tool-call streams are tracked by `index`, but tool-call starts and
+ * argument deltas are emitted as soon as they arrive so the TUI can render
+ * partial write previews before the tool executes. End events are still flushed
+ * in index order to keep multi-call turns deterministic.
  */
-export async function* translateOpenAIStream(stream) {
+export async function* translateOpenAIStream(stream, options = {}) {
     const toolCalls = new Map();
+    const textFilter = createProviderProtocolArtifactFilter();
+    const toolArgsMergeMode = options.toolArgsMergeMode ?? "delta";
+    // DeepSeek (and some inference re-hosts) sometimes deliver reasoning twice:
+    // once via a dedicated `reasoning_content` / `thinking` field, and again
+    // embedded as `<think>...</think>` inside `delta.content`. Track whether we
+    // have seen the dedicated channel; if yes, strip <think> blocks from text
+    // silently instead of yielding a second reasoning_delta.
+    let hasDedicatedReasoningChannel = false;
     function* flushToolCalls() {
         if (toolCalls.size === 0)
             return;
@@ -204,13 +245,37 @@ export async function* translateOpenAIStream(stream) {
         for (const [, entry] of sorted) {
             if (!entry.id || !entry.name)
                 continue;
-            const args = normalizeToolArgs(entry.args);
-            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
-            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: args, isStart: false, isEnd: false };
-            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: false, isEnd: true };
+            if (!entry.started) {
+                yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
+                entry.started = true;
+                if (entry.args) {
+                    yield { type: "tool_call", id: entry.id, name: entry.name, arguments: entry.args, isStart: false, isEnd: false };
+                }
+            }
+            const normalized = normalizeToolArgsDetailed(entry.args);
+            debugToolArgs({ stage: "flush-end", id: entry.id, name: entry.name, entryArgs: entry.args, finalArgs: normalized.args, corrupt: normalized.corrupt });
+            yield {
+                type: "tool_call",
+                id: entry.id,
+                name: entry.name,
+                arguments: "",
+                argumentsFull: normalized.args,
+                argumentsCorrupt: normalized.corrupt || undefined,
+                isStart: false,
+                isEnd: true,
+            };
         }
         toolCalls.clear();
     }
+    function* startToolCallIfReady(entry) {
+        if (entry.started || !entry.id || !entry.name)
+            return;
+        entry.started = true;
+        yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
+        if (entry.args) {
+            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: entry.args, isStart: false, isEnd: false };
+        }
+    }
     for await (const chunk of stream) {
         const delta = chunk.choices?.[0]?.delta;
         const usage = chunk.usage;
@@ -231,21 +296,26 @@ export async function* translateOpenAIStream(stream) {
         }
         const reasoning = delta?.reasoning ?? delta?.thinking ?? delta?.reasoning_content;
         if (reasoning) {
+            hasDedicatedReasoningChannel = true;
             yield { type: "reasoning_delta", content: reasoning };
         }
         if (delta?.content) {
             const thinkMatch = delta.content.match(/<think>([\s\S]*?)<\/think>/);
             if (thinkMatch) {
-                if (thinkMatch[1]) {
+                if (thinkMatch[1] && !hasDedicatedReasoningChannel) {
                     yield { type: "reasoning_delta", content: thinkMatch[1] };
                 }
                 const remaining = delta.content.replace(/<think>[\s\S]*?<\/think>/, "");
-                if (remaining) {
-                    yield { type: "text", content: remaining };
+                const cleaned = textFilter.push(remaining);
+                if (cleaned) {
+                    yield { type: "text", content: cleaned };
                 }
             }
             else {
-                yield { type: "text", content: delta.content };
+                const cleaned = textFilter.push(delta.content);
+                if (cleaned) {
+                    yield { type: "text", content: cleaned };
+                }
             }
         }
         if (delta?.tool_calls) {
@@ -253,15 +323,29 @@ export async function* translateOpenAIStream(stream) {
                 const idx = typeof tc.index === "number" ? tc.index : 0;
                 let entry = toolCalls.get(idx);
                 if (!entry) {
-                    entry = { id: "", name: "", args: "" };
+                    entry = { id: "", name: "", args: "", started: false };
                     toolCalls.set(idx, entry);
                 }
                 if (tc.id)
                     entry.id = tc.id;
                 if (tc.function?.name)
                     entry.name = tc.function.name;
-                if (typeof tc.function?.arguments === "string")
-                    entry.args += tc.function.arguments;
+                yield* startToolCallIfReady(entry);
+                if (typeof tc.function?.arguments === "string" && tc.function.arguments) {
+                    debugToolArgs({ stage: "raw-chunk", id: entry.id, name: entry.name, idx, raw: tc.function.arguments });
+                    const merged = mergeToolArgumentDelta(entry.args, tc.function.arguments, toolArgsMergeMode);
+                    entry.args = merged.args;
+                    if (entry.started && merged.delta) {
+                        yield {
+                            type: "tool_call",
+                            id: entry.id,
+                            name: entry.name,
+                            arguments: merged.delta,
+                            isStart: false,
+                            isEnd: false,
+                        };
+                    }
+                }
             }
         }
         const finishReason = chunk.choices?.[0]?.finish_reason;
@@ -269,5 +353,36 @@ export async function* translateOpenAIStream(stream) {
             yield* flushToolCalls();
         }
     }
+    const remainingText = textFilter.flush();
+    if (remainingText) {
+        yield { type: "text", content: remainingText };
+    }
     yield* flushToolCalls();
 }
+function mergeToolArgumentDelta(current, incoming, mode) {
+    if (!current) {
+        debugToolArgs({ stage: "merge", branch: "empty-current", current, incoming, args: incoming, delta: incoming });
+        return { args: incoming, delta: incoming };
+    }
+    if (!incoming) {
+        debugToolArgs({ stage: "merge", branch: "empty-incoming", current, incoming, args: current, delta: "" });
+        return { args: current, delta: "" };
+    }
+    if (mode === "snapshot") {
+        // Snapshot streams repeat the current full argument buffer. Only treat a
+        // chunk as duplicate when it is exactly equal, or as growth when it carries
+        // the current buffer as a prefix. A suffix match is not enough: the next
+        // legitimate delta can be a single trailing character like "0".
+        if (incoming === current) {
+            debugToolArgs({ stage: "merge", branch: "snapshot-dup", current, incoming, args: current, delta: "" });
+            return { args: current, delta: "" };
+        }
+        if (incoming.startsWith(current)) {
+            const delta = incoming.slice(current.length);
+            debugToolArgs({ stage: "merge", branch: "snapshot-grow", current, incoming, args: incoming, delta });
+            return { args: incoming, delta };
+        }
+    }
+    debugToolArgs({ stage: "merge", branch: mode === "delta" ? "delta-append" : "snapshot-fallback-concat", current, incoming, args: current + incoming, delta: incoming });
+    return { args: current + incoming, delta: incoming };
+}

package/dist/session-log.js

@@ -193,6 +193,8 @@ function normalizeMessageToEntries(message, id, timestamp) {
         }
         case "tool":
             return [{ id, type: "tool_result", message, timestamp }];
+        case "meta":
+            return [];
         case "system":
             return [{
                     id,
@@ -241,7 +243,7 @@ function pruneIncompleteTail(messages) {
     let sawNonUserInCurrentTurn = false;
     for (let i = 0; i < messages.length; i++) {
         const message = messages[i];
-        if (message.role === "system")
+        if (message.role === "system" || message.role === "meta")
             continue;
         if (message.role === "user") {
             currentTurnStart = i;

package/dist/system-prompt.d.ts

@@ -30,5 +30,7 @@ export interface SystemPromptOptions {
     skills?: SkillSummary[];
     /** Prompt-visible memory guidance and summaries */
     memoryPrompt?: string;
+    /** Durable child-agent profile prompt used for subagents. */
+    agentProfilePrompt?: string;
 }
 export declare function buildSystemPrompt(options?: SystemPromptOptions): string;

package/dist/tools/agent-lifecycle.d.ts

@@ -0,0 +1,6 @@
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createSpawnAgentTool(): ToolRegistryEntry;
+export declare function createWaitAgentTool(): ToolRegistryEntry;
+export declare function createSendInputTool(): ToolRegistryEntry;
+export declare function createCloseAgentTool(): ToolRegistryEntry;
+export declare function createAgentLifecycleTools(): ToolRegistryEntry[];