agent-accelerator 0.1.0 → 0.3.0

package/src/agent/agent.ts

@@ -5,13 +5,30 @@ import type { ContentPart } from "../types/message.ts";
 import { AgentResponse, type StreamEvent } from "../types/response.ts";
 import { AssistantMessageEventStream } from "../streaming/event-stream.ts";
 import { AgentContext } from "./context.ts";
-import { resolveModel } from "../ai-sdk/registry.ts";
+import { resolveModel } from "../providers/registry.ts";
 import { buildAgentTools, createSubagentSpawnTool } from "./delegation.ts";
+import { convert_document_to_markdown } from "../utils/documents.ts";
 import { runAgentLoop, streamAgentLoop } from "./loop.ts";
 import { createSessionId } from "../utils/session.ts";
+import { getSubAgentTrace, subscribeToSubAgent, listSubAgentTraceIds, type SubAgentTrace } from "./delegation.ts";
+import { saveSessionDir, saveSessionFile } from "../session/store.ts";
 import { getModel, getSubModel } from "../utils/env.ts";
-import { validateModelThinking } from "../models/catalog.ts";
-import { resolveEffectiveThinking } from "../ai-sdk/options.ts";
+import { validateModelThinking, ensureModelCatalogFresh } from "../models/catalog.ts";
+import { buildSessionData, type PersistedAgentSession, type SessionTotals,} from "../session/store.ts";
+import { SessionTelemetry } from "../session/store.ts";
+
+/**
+ * Resolves a per-run thinking override without mutating agent config.
+ */
+export function resolveEffectiveThinking(
+  base?: ThinkingConfig,
+  overrideLevel?: string
+): ThinkingConfig | undefined {
+  if (!overrideLevel) return base;
+  if (overrideLevel === "none") return { enabled: false, level: "none", budgetTokens: 0 };
+  if (overrideLevel === "dynamic") return { enabled: true, level: "dynamic", budgetTokens: -1 };
+  return { enabled: true, level: overrideLevel as ThinkingConfig["level"] };
+}
 
 /** Thrown when dynamic sub-agent spawning is enabled without an explicit model. */
 export class SubAgentModelError extends Error {
@@ -91,6 +108,8 @@ export class Agent {
   readonly cacheConfig?: CacheConfig;
   /** Provider service tier. */
   readonly serviceTier?: ServiceTier;
+  /** Convert `file` parts client-side for pdf-incapable models. */
+  readonly bypassInputFileModality: boolean;
   /** Maximum model/tool turns per run. */
   readonly maxTurns: number;
   /** Session ID used for history and cache affinity. */
@@ -105,6 +124,8 @@ export class Agent {
   readonly context: AgentContext;
   /** Whether history is cleared around each run. */
   readonly stateless: boolean;
+  /** Durable persistence target: session file rewritten after every step. */
+  readonly persistConfig?: { dir?: string; file?: string };
 
   /**
    * Creates an agent and registers its model, tools, cache, and delegation settings.
@@ -182,8 +203,15 @@ export class Agent {
     this.apiKey = (rawModel as any)?.apiKey || config.apiKey;
     this.baseUrl = (rawModel as any)?.baseUrl || config.baseUrl;
     this.customHeaders = config.headers;
-    this.maxTurns = config.maxTurns ?? 10;
+    this.maxTurns =
+      config.maxTurns === undefined || config.maxTurns === 0 || config.maxTurns === Infinity
+        ? Infinity
+        : Number.isFinite(config.maxTurns as number)
+          ? Math.max(1, Math.floor(config.maxTurns as number))
+          : Infinity;
     this.sessionId = config.sessionId || config.cache?.sessionId || createSessionId();
+    (this as any).subagentTraces = {};
+    this.persistConfig = config.persist;
 
     // DX4: single thinkingLevel flag — also inherit from ModelProviderInstance when omitted
     const mpThinking = (rawModel as any)?.thinkingLevel;
@@ -198,6 +226,7 @@ export class Agent {
     const initialCachedId = (this.cacheConfig as any)?.cachedContentId;
 
     this.serviceTier = config.serviceTier;
+    this.bypassInputFileModality = config.bypassInputFileModality ?? false;
     this.stateless = config.stateless ?? false;
 
     // Tools registration
@@ -225,6 +254,10 @@ export class Agent {
       }
     }
 
+    if (this.bypassInputFileModality && !this.tools["convert_document_to_markdown"]) {
+      this.tools["convert_document_to_markdown"] = convert_document_to_markdown;
+    }
+
     if (this.dynamicSubagents?.enabled === true) {
       if (!this.subagentModel) {
         throw new SubAgentModelError(
@@ -287,7 +320,179 @@ export class Agent {
     this.context.systemPrompt = this.getFullInstructions();
   }
 
+  /**
+   * Returns a snapshot of one sub-agent worker's trace by tracking id
+   * (`SUBAGENT-NAME-{32hex}` or the raw 32-hex suffix). Sees live running
+   * state: steps appear as the worker acts, not just after it finishes.
+   *
+   * @example `const trace = agent.track("RAM-RESEARCH-AGENT-9f2c…");`
+   */
+  track(trackingId: string): SubAgentTrace | undefined {
+    if (!trackingId) return undefined;
+    try {
+      const own = (this as any).subagentTraces as Record<string, SubAgentTrace> | undefined;
+      const hit = own?.[trackingId];
+      if (hit) return { ...hit, steps: hit.steps.map((s) => ({ ...s })) };
+    } catch {}
+    return getSubAgentTrace(trackingId);
+  }
+
+  /** Lists TrackingIDs of worker traces visible to this agent (deduped). */
+  listTrackedSubAgents(): string[] {
+    const rawOf = (id: string): string => {
+      const tail = id.split("-").pop() ?? "";
+      return /^[0-9a-f]{32}$/.test(tail) ? tail : id;
+    };
+    const seen = new Set<string>();
+    const out: string[] = [];
+    for (const id of [...Object.keys((this as any).subagentTraces ?? {}), ...listSubAgentTraceIds()]) {
+      const raw = rawOf(id);
+      if (!seen.has(raw)) {
+        seen.add(raw);
+        out.push(raw);
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Subscribes to live updates of one worker trace. The callback fires on
+   * every logged step; returns an unsubscribe fn.
+   *
+   * @example `const off = agent.subscribeToSubAgent(id, (t) => render(t));`
+   */
+  subscribeToSubAgent(trackingId: string, fn: (trace: SubAgentTrace) => void): () => void {
+    return subscribeToSubAgent(trackingId, fn);
+  }
+
+  /**
+   * Rewrites the configured session file now (when `persist` is set).
+   * Called automatically after every step during runs; safe to call
+   * manually. Never throws.
+   */
+  persistNow(): void {
+    const cfg = this.persistConfig;
+    if (!cfg || (!cfg.dir && !cfg.file)) return;
+    try {
+      if (cfg.dir) saveSessionDir(cfg.dir, this as any, null);
+      else if (cfg.file) saveSessionFile(cfg.file, this as any, null);
+    } catch {}
+  }
+
+  /** Merges completed worker metadata (incl. steps) into this agent's trace registry. */
+  private mergeSubagentTraces(subagents: Array<{ trackingId?: string; name: string; sessionId?: string; parentSessionId?: string; task: string; steps?: SubAgentTrace["steps"]; [k: string]: unknown }>): void {
+    if (!subagents || subagents.length === 0) return;
+    const rawOf = (id?: string): string | undefined => {
+      if (!id) return undefined;
+      const tail = id.split("-").pop() ?? "";
+      return /^[0-9a-f]{32}$/.test(tail) ? tail : id;
+    };
+    try {
+      const registry = ((this as any).subagentTraces ??= {}) as Record<string, SubAgentTrace>;
+      for (const s of subagents) {
+        const raw = rawOf(s.trackingId);
+        const key = raw || s.name;
+        const existing = registry[key] ?? (raw ? registry[s.trackingId ?? ""] : undefined);
+        if (existing) {
+          existing.status = "done";
+          if (s.steps && s.steps.length > 0 && existing.steps.length === 0) {
+            existing.steps = s.steps.map((x) => ({ ...x }));
+          }
+          if (raw && !registry[raw]) registry[raw] = existing;
+        } else if (raw) {
+          registry[raw] = {
+            trackingId: raw,
+            name: s.name,
+            sessionId: s.sessionId || "",
+            parentSessionId: s.parentSessionId || this.sessionId,
+            status: "done",
+            task: s.task,
+            turns: 0,
+            steps: (s.steps ?? []).map((x) => ({ ...x })),
+          };
+        }
+      }
+    } catch {}
+  }
+
+  /**
+   * Exports this agent's conversation + config as a storable session snapshot.
+   * Pair with `importSession` / `loadSessionFile` / `saveSessionFile`.
+   *
+   * @example `saveSessionFile(".session.json", agent, telemetry)`
+   */
+  exportSession(telemetry?: SessionTelemetry | SessionTotals | null): PersistedAgentSession {
+    return buildSessionData(this as any, telemetry);
+  }
+
+  /**
+   * Restores conversation + config from `exportSession` / `loadSessionFile`.
+   * Restores messages, system prompt, cached content id, sub-agent traces,
+   * and (when present) session id, model, thinking level, instructions,
+   * cache, and worker model. No-ops on nullish input.
+   *
+   * @example `const saved = loadSessionFile(".session.json"); if (saved) agent.importSession(saved);`
+   */
+  importSession(data?: PersistedAgentSession | null): void {
+    if (!data) return;
+    if (data.sessionId) (this as any).sessionId = data.sessionId;
+    if ((data as any).parentSessionId) (this as any).parentSessionId = (data as any).parentSessionId;
+    if ((data as any).subagents && typeof (data as any).subagents === "object") {
+      try {
+        (this as any).subagentTraces = JSON.parse(JSON.stringify((data as any).subagents));
+      } catch {
+        (this as any).subagentTraces = { ...((data as any).subagents as object) };
+      }
+    }
+    if (data.model) (this as any).modelStringOrSpec = data.model;
+    if (data.thinkingLevel) {
+      const lvl = String(data.thinkingLevel);
+      (this as any).thinkingConfig =
+        lvl === "none"
+          ? { enabled: false, level: "none", budgetTokens: 0 }
+          : lvl === "dynamic"
+            ? { enabled: true, level: "dynamic", budgetTokens: -1 }
+            : { enabled: true, level: lvl };
+    }
+    if (typeof data.instructions === "string") this.instructions = data.instructions;
+    if (data.cache) {
+      (this as any).cacheConfig = {
+        ...this.cacheConfig,
+        ...data.cache,
+        sessionId: data.sessionId ?? this.sessionId,
+      };
+    }
+    if (data.subagentModel) {
+      (this as any).subagentModel = data.subagentModel;
+      const dyn = (this as any).dynamicSubagents;
+      if (dyn) dyn.model = data.subagentModel;
+    }
+    try {
+      const g: any = globalThis as any;
+      this.context.messages = Array.isArray(data.messages)
+        ? (typeof g.structuredClone === "function"
+            ? g.structuredClone(data.messages)
+            : JSON.parse(JSON.stringify(data.messages)))
+        : [];
+    } catch {
+      this.context.messages = Array.isArray(data.messages) ? [...data.messages] : [];
+    }
+    this.context.thoughtSignatures = [];
+    if (data.systemPrompt) {
+      this.context.systemPrompt = data.systemPrompt;
+    } else {
+      this.context.systemPrompt = this.getFullInstructions();
+    }
+    this.context.cachedContentId =
+      data.cachedContentId ?? (this.cacheConfig as any)?.cachedContentId;
+  }
+
   private prepareTurn(prompt: string | ContentPart[], options?: AgentRunOptions): void {
+    if (Array.isArray(prompt) && prompt.length === 0) {
+      throw new Error(
+        "[Agent Accelerator] Prompt cannot be empty: pass a non-empty string or at least one content part."
+      );
+    }
     if (this.stateless) {
       this.context.messages = [];
       this.context.thoughtSignatures = [];
@@ -317,10 +522,26 @@ export class Agent {
    * Runs one or more model/tool turns and resolves to a normalized AgentResponse.
    * @example `const response = await agent.run("Summarize this document");`
    */
+  run(
+    prompt: string | ContentPart[],
+    options: AgentRunOptions & { stream: true } & (
+      | { onDelta: NonNullable<AgentRunOptions["onDelta"]> }
+      | { onThinkingDelta: NonNullable<AgentRunOptions["onThinkingDelta"]> }
+      | { onEvent: NonNullable<AgentRunOptions["onEvent"]> }
+    )
+  ): Promise<AgentResponse> & AsyncIterable<StreamEvent>;
+  run(
+    prompt: string | ContentPart[],
+    options: AgentRunOptions & { stream: true }
+  ): AssistantMessageEventStream;
   run(
     prompt: string | ContentPart[],
     options?: AgentRunOptions
-  ): Promise<AgentResponse> & AssistantMessageEventStream {
+  ): Promise<AgentResponse>;
+  run(
+    prompt: string | ContentPart[],
+    options?: AgentRunOptions
+  ): Promise<AgentResponse> | AssistantMessageEventStream {
     const isStream = options?.stream === true;
     if (isStream) {
       const hasCallbacks = !!(options?.onDelta || options?.onThinkingDelta || options?.onEvent);
@@ -343,44 +564,52 @@ export class Agent {
       return s;
     }
 
-    const resolved = resolveModel(this.modelStringOrSpec);
-    const effectiveLevel = options?.thinkingLevel || this.thinkingConfig?.level;
-    if (effectiveLevel) {
-      validateModelThinking(resolved.provider.id, resolved.modelId, effectiveLevel);
-    }
-    this.prepareTurn(prompt, options);
-
-    const providerOptions = {
-      apiKey: this.apiKey,
-      baseUrl: this.baseUrl,
-      headers: { ...(this.customHeaders ?? {}), ...(options?.headers ?? {}) },
-      thinking: resolveEffectiveThinking(this.thinkingConfig, options?.thinkingLevel),
-      cache: this.stateless
-        ? { sessionId: options?.sessionId || this.sessionId }
-        : { ...this.cacheConfig, sessionId: options?.sessionId || this.sessionId },
-      serviceTier: this.serviceTier,
-      sessionId: options?.sessionId || this.sessionId,
-    };
+    return (async (): Promise<AgentResponse> => {
+      // Refresh the catalog BEFORE thinking validation so levels are checked
+      // against live data instead of a possibly-empty cold cache.
+      await ensureModelCatalogFresh();
+      const resolved = resolveModel(this.modelStringOrSpec);
+      const effectiveLevel = options?.thinkingLevel || this.thinkingConfig?.level;
+      if (effectiveLevel) {
+        validateModelThinking(resolved.provider.id, resolved.modelId, effectiveLevel);
+      }
+      this.prepareTurn(prompt, options);
+      this.persistNow();
+
+      const providerOptions = {
+        apiKey: this.apiKey,
+        baseUrl: this.baseUrl,
+        headers: { ...(this.customHeaders ?? {}), ...(options?.headers ?? {}) },
+        thinking: resolveEffectiveThinking(this.thinkingConfig, options?.thinkingLevel),
+        cache: this.stateless
+          ? { sessionId: options?.sessionId || this.sessionId }
+          : { ...this.cacheConfig, sessionId: options?.sessionId || this.sessionId },
+        serviceTier: this.serviceTier,
+        sessionId: options?.sessionId || this.sessionId,
+      };
 
-    const loopConfig = {
-      agentName: this.name,
-      provider: resolved.provider,
-      modelId: resolved.modelId,
-      context: this.context,
-      tools: this.tools,
-      options: providerOptions,
-      runOptions: options,
-      maxTurns: this.maxTurns,
-    };
+      const loopConfig = {
+        agentName: this.name,
+        provider: resolved.provider,
+        modelId: resolved.modelId,
+        context: this.context,
+        tools: this.tools,
+        options: providerOptions,
+        runOptions: options,
+        maxTurns: this.maxTurns,
+        bypassInputFileModality: this.bypassInputFileModality,
+        onProgress: () => this.persistNow(),
+      };
 
-    const promise = runAgentLoop(loopConfig).then((res) => {
+      const res = await runAgentLoop(loopConfig);
+      this.mergeSubagentTraces(res.subagents as any);
+      this.persistNow();
       if (this.stateless) {
         this.context.messages = [];
         this.context.thoughtSignatures = [];
       }
       return res;
-    });
-    return promise as any;
+    })();
   }
 
   /**
@@ -409,10 +638,16 @@ export class Agent {
       }
       const stringStream: any = {
         [Symbol.asyncIterator]: async function* () {
-          for await (const chunk of stream) {
-            if (chunk.type === "text_delta" && chunk.delta) {
-              yield chunk.delta;
+          try {
+            for await (const chunk of stream) {
+              if (chunk.type === "text_delta" && chunk.delta) {
+                yield chunk.delta;
+              }
             }
+          } finally {
+            // Breaking out early must stop the underlying provider stream
+            // instead of leaving the HTTP connection running in the background.
+            stream.cancel();
           }
         },
         result: () => stream.result(),
@@ -428,7 +663,7 @@ export class Agent {
       return stringStream;
     }
 
-    return this.run(prompt, runOpts);
+    return this.run(prompt, runOpts) as any;
   }
 
   /**
@@ -450,6 +685,7 @@ export class Agent {
       validateModelThinking(resolved.provider.id, resolved.modelId, effectiveLevel);
     }
     this.prepareTurn(prompt, options);
+    this.persistNow();
 
     const providerOptions = {
       apiKey: this.apiKey,
@@ -472,9 +708,17 @@ export class Agent {
       options: providerOptions,
       runOptions: options,
       maxTurns: this.maxTurns,
+      bypassInputFileModality: this.bypassInputFileModality,
+      onProgress: () => this.persistNow(),
     };
 
     const s = streamAgentLoop(loopConfig);
+    s.result().then((res) => {
+      try {
+        this.mergeSubagentTraces(res.subagents as any);
+        this.persistNow();
+      } catch {}
+    }).catch(() => {});
     if (this.stateless) {
       s.result().then(() => {
         this.context.messages = [];
@@ -483,8 +727,32 @@ export class Agent {
     }
     // Wire one-liner callbacks so `stream:true` + onDelta is enough — no manual for-await needed
     if (options?.wrapThinking) {
-      // Auto-wrap reasoning as <think>\n...\n</think>\n\n per-turn — clean boundaries across multi-turn agent runs
+      // Auto-wrap reasoning as <think>…</think> per-turn — clean boundaries across multi-turn agent runs.
+      //
+      // Display-only whitespace hygiene (cache-safe): provider thought
+      // summaries routinely carry edge blank lines (observed `"...\n\n\n"`),
+      // and the wrapper itself adds newlines around the span. Without care
+      // this renders as blank lines after `<think>`, double blanks between
+      // sections, and a stray blank line before `</think>`. The buffering
+      // below touches ONLY the presented strings/callback args and synthetic
+      // tag events — never provider accumulation, AgentContext history, or
+      // request bodies — so prefix-cache affinity is untouched.
+      //
+      // Trailing-newline buffering: each chunk's trailing `\n` run is
+      // withheld and prepended to the next chunk (or dropped at close), so
+      // emitted display text never ends with `\n` and `</think>` never gets
+      // a preceding blank line. Interior breaks are preserved (collapsed to
+      // a single blank line at most).
       let isThinking = false;
+      let emittedAny = false;
+      let pendingNewlines = "";
+      // True once text has been emitted without a trailing newline: the next
+      // <think> open tag then needs its own leading newline, otherwise it
+      // glues onto the streamed text mid-line. False at stream start and
+      // after every tag (both end with newlines), preserving the exact
+      // "<think>\n...\n</think>\n\n" contract for thinking-first streams.
+      let needThinkNewline = false;
+      const collapseBlankLines = (s: string): string => s.replace(/\n{3,}/g, "\n\n");
       const userOnThinking = options.onThinkingDelta;
       const userOnDelta = options.onDelta;
       const userOnEvent = options.onEvent;
@@ -493,7 +761,10 @@ export class Agent {
       const openThink = (e?: any) => {
         if (!isThinking) {
           isThinking = true;
-          const tag = "<think>\n";
+          emittedAny = false;
+          pendingNewlines = "";
+          const tag = (needThinkNewline ? "\n" : "") + "<think>\n";
+          needThinkNewline = false;
           if (userOnThinking) userOnThinking(tag, e);
           else if (userOnDelta) userOnDelta(tag, e as any);
         }
@@ -502,20 +773,54 @@ export class Agent {
       const closeThink = (e?: any) => {
         if (isThinking) {
           isThinking = false;
-          const close = "\n</think>\n\n";
+          // Drop any withheld trailing newlines: the span ends cleanly and
+          // the tag supplies its own line breaks. Empty spans still close.
+          pendingNewlines = "";
+          const close = emittedAny ? "\n</think>\n\n" : "</think>\n\n";
+          emittedAny = false;
           if (userOnThinking) userOnThinking(close, e);
           else if (userOnDelta) userOnDelta(close, e as any);
         }
       };
 
+      /** Buffers one raw thinking chunk, returning the display string to
+       * emit now (`""` when nothing displayable yet). Mutates the event in
+       * place so manual `for-await` consumers see the same clean text; safe
+       * because loop context derives from the provider result, not these
+       * outer events. */
+      const bufferThinkingEvent = (e: any): string => {
+        const raw: string = e.thinkingDelta ?? "";
+        let chunk = collapseBlankLines(pendingNewlines + raw);
+        pendingNewlines = "";
+        if (!emittedAny) {
+          chunk = chunk.replace(/^\n+/, "");
+        }
+        if (!chunk) return "";
+        const m = chunk.match(/\n+$/);
+        if (m) {
+          pendingNewlines = m[0];
+          chunk = chunk.slice(0, -m[0].length);
+          if (!chunk) return "";
+        }
+        emittedAny = true;
+        e.thinkingDelta = chunk;
+        if (typeof e.partialThinking === "string") {
+          e.partialThinking = collapseBlankLines(e.partialThinking);
+        }
+        return chunk;
+      };
+
       if (userOnThinking || userOnDelta) {
         s.on("thinking_delta", (e: any) => {
           openThink(e);
-          if (userOnThinking) userOnThinking(e.thinkingDelta!, e);
-          else if (userOnDelta) userOnDelta(e.thinkingDelta!, e as any);
+          const chunk = bufferThinkingEvent(e);
+          if (!chunk) return;
+          if (userOnThinking) userOnThinking(chunk, e);
+          else if (userOnDelta) userOnDelta(chunk, e as any);
         });
         s.on("text_delta", (e: any) => {
           closeThink(e);
+          needThinkNewline = !((e.delta ?? "").endsWith("\n"));
           if (userOnDelta) userOnDelta(e.delta!, e);
           else if (userOnThinking) userOnThinking(e.delta!, e as any);
         });
@@ -528,48 +833,55 @@ export class Agent {
           closeThink(e || ({ type: "done" } as any));
         });
       } else {
-        // No callbacks but wrapThinking true — still emit tags as events for manual iteration
+        // No callbacks but wrapThinking true — still emit tags as events for manual iteration.
+        // Same display hygiene as above (in-place event normalization is safe:
+        // loop context derives from the provider result, not outer events).
+        const closeSynthetic = () => {
+          if (isThinking) {
+            isThinking = false;
+            pendingNewlines = "";
+            const tag = emittedAny ? "\n</think>\n\n" : "</think>\n\n";
+            emittedAny = false;
+            s.push({ type: "thinking_delta", thinkingDelta: tag, __synthetic: true } as any);
+          }
+        };
         s.on("thinking_delta", (e: any) => {
+          // Ignore our own synthetic tags: push() redelivers events to
+          // listeners synchronously, so without this guard the handler
+          // re-enters on every tag it emits (duplicate <think> spans and
+          // mutated queued events).
+          if ((e as any).__synthetic) return;
           if (!isThinking) {
             isThinking = true;
-            s.push({ type: "thinking_delta", thinkingDelta: "<think>\n" } as any);
+            emittedAny = false;
+            pendingNewlines = "";
+            const openTag = (needThinkNewline ? "\n" : "") + "<think>\n";
+            needThinkNewline = false;
+            s.push({ type: "thinking_delta", thinkingDelta: openTag, __synthetic: true } as any);
+          }
+          const chunk = bufferThinkingEvent(e);
+          if (!chunk) {
+            e.thinkingDelta = "";
           }
         });
         s.on("text_delta", (e: any) => {
-          if (isThinking) {
-            isThinking = false;
-            s.push({ type: "thinking_delta", thinkingDelta: "\n</think>\n\n" } as any);
-          }
+          closeSynthetic();
+          needThinkNewline = !((e.delta ?? "").endsWith("\n"));
         });
         s.on("tool_call_start" as any, () => {
-          if (isThinking) {
-            isThinking = false;
-            s.push({ type: "thinking_delta", thinkingDelta: "\n</think>\n\n" } as any);
-          }
+          closeSynthetic();
         });
         s.on("tool_call_complete" as any, () => {
-          if (isThinking) {
-            isThinking = false;
-            s.push({ type: "thinking_delta", thinkingDelta: "\n</think>\n\n" } as any);
-          }
+          closeSynthetic();
         });
         s.on("tool_result" as any, () => {
-          if (isThinking) {
-            isThinking = false;
-            s.push({ type: "thinking_delta", thinkingDelta: "\n</think>\n\n" } as any);
-          }
+          closeSynthetic();
         });
         s.on("subagent_complete" as any, () => {
-          if (isThinking) {
-            isThinking = false;
-            s.push({ type: "thinking_delta", thinkingDelta: "\n</think>\n\n" } as any);
-          }
+          closeSynthetic();
         });
         s.on("done", () => {
-          if (isThinking) {
-            isThinking = false;
-            s.push({ type: "thinking_delta", thinkingDelta: "\n</think>\n\n" } as any);
-          }
+          closeSynthetic();
         });
         if (userOnEvent) s.on("*", userOnEvent as any);
       }
@@ -584,7 +896,7 @@ export class Agent {
 
 /** Normalizes the public `thinkingLevel` flag into provider-neutral thinking settings. */
 export function normalizeThinking(config: AgentConfig, fallbackLevel?: string): ThinkingConfig | undefined {
-  // DX4: only thinkingLevel, values: none, dynamic, minimal, low, medium, high, xhigh
+  // DX4: only thinkingLevel, values: none, dynamic, minimal, low, medium, high, xhigh, max
   const rawLevel = config.thinkingLevel ?? fallbackLevel;
   const level = rawLevel as ThinkingLevel | undefined;
 
@@ -598,7 +910,7 @@ export function normalizeThinking(config: AgentConfig, fallbackLevel?: string):
       const provStr = typeof rawModel === "object" && rawModel?.provider ? rawModel.provider : modelStr.includes("/") ? modelStr.split("/")[0] : "";
       const actualModelId = modelStr.includes("/") ? modelStr.split("/").slice(1).join("/") : modelStr;
       if (actualModelId) {
-        validateModelThinking(provStr || "opencode", actualModelId, level);
+        validateModelThinking(provStr || "openrouter", actualModelId, level);
       }
     } catch (e) {
       throw e;

package/src/agent/context.ts

@@ -96,6 +96,7 @@ export class AgentContext {
           arguments: tc.arguments,
           rawArguments: tc.rawArguments,
           thoughtSignature: tc.thoughtSignature || (!thinkingSig && !textSig ? thoughtSignature : undefined),
+          callId: tc.callId,
         });
       }
     }