skyloom 1.13.6 → 1.13.8

package/src/core/hooks.ts

@@ -0,0 +1,126 @@
+/**
+ * Hooks — user-configured shell commands at tool-execution lifecycle points.
+ *
+ * Unlike prompts or memory, hooks are *enforced*: they run regardless of what
+ * the model decides. A pre_tool hook exiting non-zero blocks the call.
+ *
+ * config.yaml:
+ *   hooks:
+ *     session_start:
+ *       - "echo session up"
+ *     pre_tool:
+ *       - matcher: "run_bash|delete_file"     # regex on tool name
+ *         command: "./scripts/guard.sh"        # non-zero exit blocks the tool
+ *     post_tool:
+ *       - matcher: "write_file|edit_file"
+ *         command: "npx prettier --write \"$SKY_FILE\""
+ *
+ * Hook env: SKY_TOOL (tool name), SKY_ARGS (args JSON), SKY_FILE (path arg
+ * if present), SKY_AGENT (agent name).
+ */
+
+import { spawnSync } from 'child_process';
+import { getLogger } from './logger';
+
+const log = getLogger('hooks');
+
+export interface HookSpec {
+  matcher?: string;
+  command: string;
+}
+
+export interface Hooks {
+  sessionStart: string[];
+  preTool: HookSpec[];
+  postTool: HookSpec[];
+}
+
+const HOOK_TIMEOUT_MS = 30_000;
+
+function normalizeSpecs(raw: any): HookSpec[] {
+  if (!Array.isArray(raw)) return [];
+  const out: HookSpec[] = [];
+  for (const item of raw) {
+    if (typeof item === 'string' && item.trim()) out.push({ command: item });
+    else if (item && typeof item.command === 'string' && item.command.trim()) {
+      out.push({ matcher: typeof item.matcher === 'string' ? item.matcher : undefined, command: item.command });
+    }
+  }
+  return out;
+}
+
+export function loadHooks(config: any): Hooks {
+  const h: any = config?.hooks || {};
+  return {
+    sessionStart: normalizeSpecs(h.session_start).map(s => s.command),
+    preTool: normalizeSpecs(h.pre_tool),
+    postTool: normalizeSpecs(h.post_tool),
+  };
+}
+
+export function matches(spec: HookSpec, toolName: string): boolean {
+  if (!spec.matcher) return true;
+  try {
+    return new RegExp(spec.matcher).test(toolName);
+  } catch {
+    return spec.matcher === toolName;
+  }
+}
+
+function hookEnv(toolName: string, args: Record<string, any>, agent: string): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    SKY_TOOL: toolName,
+    SKY_ARGS: JSON.stringify(args ?? {}).slice(0, 8000),
+    SKY_FILE: String(args?.path ?? args?.file ?? args?.file_path ?? ''),
+    SKY_AGENT: agent,
+  };
+}
+
+function runHook(command: string, env: NodeJS.ProcessEnv): { code: number; output: string } {
+  const r = spawnSync(command, { shell: true, encoding: 'utf-8', timeout: HOOK_TIMEOUT_MS, env });
+  const output = `${r.stdout || ''}${r.stderr || ''}`.trim().slice(0, 1000);
+  return { code: r.error ? 1 : (r.status ?? 1), output };
+}
+
+/**
+ * Run matching pre_tool hooks. The first non-zero exit blocks the call.
+ */
+export function runPreToolHooks(
+  hooks: Hooks,
+  toolName: string,
+  args: Record<string, any>,
+  agent: string
+): { allowed: boolean; reason: string } {
+  for (const spec of hooks.preTool) {
+    if (!matches(spec, toolName)) continue;
+    const { code, output } = runHook(spec.command, hookEnv(toolName, args, agent));
+    if (code !== 0) {
+      log.warn('pre_tool_hook_blocked', { tool: toolName, hook: spec.command, code });
+      return { allowed: false, reason: output || `hook exited ${code}` };
+    }
+  }
+  return { allowed: true, reason: '' };
+}
+
+/** Run matching post_tool hooks (best-effort; failures only logged). */
+export function runPostToolHooks(
+  hooks: Hooks,
+  toolName: string,
+  args: Record<string, any>,
+  agent: string
+): void {
+  for (const spec of hooks.postTool) {
+    if (!matches(spec, toolName)) continue;
+    const { code, output } = runHook(spec.command, hookEnv(toolName, args, agent));
+    if (code !== 0) log.warn('post_tool_hook_failed', { tool: toolName, hook: spec.command, code, output });
+  }
+}
+
+/** Run session_start hooks once at system construction. */
+export function runSessionStartHooks(hooks: Hooks): void {
+  for (const command of hooks.sessionStart) {
+    const { code, output } = runHook(command, process.env);
+    if (code !== 0) log.warn('session_start_hook_failed', { hook: command, code, output });
+  }
+}

package/src/core/icons.ts

@@ -1,53 +1,53 @@
-/**
- * Agent icon system — dynamic status indicators.
- *
- * Each agent is identified by its display name with color styling.
- * During processing, agent spinners provide dynamic status.
- */
-
-import * as path from 'path';
-
-const ICONS_DIR = path.resolve(__dirname, '..', 'assets', 'icons');
-
-export const AGENT_COLORS: Record<string, string> = {
-  fog: 'bright_white',
-  rain: 'blue',
-  frost: 'cyan',
-  snow: 'bright_white',
-  dew: 'green',
-  fair: '#FFD700',
-};
-
-export const AGENT_EMOJI: Record<string, string> = {
-  fog: '≋',
-  rain: '⸽',
-  frost: '✱',
-  snow: '❉',
-  dew: '∘',
-  fair: '☼',
-};
-
-/**
- * Return the filesystem path to an agent's SVG icon file.
- */
-export function svgPath(name: string): string {
-  return path.join(ICONS_DIR, `${name}.svg`);
-}
-
-/**
- * Return the plain-text icon for an agent.
- *
- * Used in dashboards, prompts, logs, and any UI where SVG can't render.
- * The glyphs are deliberately chosen from Unicode blocks that render
- * as monochrome text on virtually every terminal.
- *
- *   fog  ≋  three wavy lines — drifting mist
- *   rain ⸽  six vertical dots — falling rain streaks
- *   frost ✱  pointed asterisk — frost crystal
- *   snow ❉  balloon-spoked star — snowflake
- *   dew  ∘  ring — dewdrop
- *   fair ☼  sun with rays — clear sky
- */
-export function iconText(name: string): string {
-  return AGENT_EMOJI[name] ?? name;
-}
+/**
+ * Agent icon system — dynamic status indicators.
+ *
+ * Each agent is identified by its display name with color styling.
+ * During processing, agent spinners provide dynamic status.
+ */
+
+import * as path from 'path';
+
+const ICONS_DIR = path.resolve(__dirname, '..', 'assets', 'icons');
+
+export const AGENT_COLORS: Record<string, string> = {
+  fog: 'bright_white',
+  rain: 'blue',
+  frost: 'cyan',
+  snow: 'bright_white',
+  dew: 'green',
+  fair: '#FFD700',
+};
+
+export const AGENT_EMOJI: Record<string, string> = {
+  fog: '≋',
+  rain: '⸽',
+  frost: '✱',
+  snow: '❉',
+  dew: '∘',
+  fair: '☼',
+};
+
+/**
+ * Return the filesystem path to an agent's SVG icon file.
+ */
+export function svgPath(name: string): string {
+  return path.join(ICONS_DIR, `${name}.svg`);
+}
+
+/**
+ * Return the plain-text icon for an agent.
+ *
+ * Used in dashboards, prompts, logs, and any UI where SVG can't render.
+ * The glyphs are deliberately chosen from Unicode blocks that render
+ * as monochrome text on virtually every terminal.
+ *
+ *   fog  ≋  three wavy lines — drifting mist
+ *   rain ⸽  six vertical dots — falling rain streaks
+ *   frost ✱  pointed asterisk — frost crystal
+ *   snow ❉  balloon-spoked star — snowflake
+ *   dew  ∘  ring — dewdrop
+ *   fair ☼  sun with rays — clear sky
+ */
+export function iconText(name: string): string {
+  return AGENT_EMOJI[name] ?? name;
+}

package/src/core/index.ts

@@ -1,37 +1,37 @@
-/**
- * Skyloom Core Module Exports
- */
-
-export * from './constants';
-export * from './schemas';
-export * from './logger';
-export * from './config';
-export * from './tool';
-export * from './circuit_breaker';
-export * from './bus';
-export * from './cache';
-export * from './memory';
-export * from './middleware';
-export * from './llm';
-export * from './mcp';
-export { matchPipeline, buildTasksFromPipeline, listPipelines, getPipelineByName, matchAllPipelines, validateDAG, topologicalSort, type Pipeline, type PipelineStep } from './pipelines';
-export * from './semantic';
-export * from './icons';
-export * from './checkpoint';
-export * from './workspace';
-export * from './profile';
-export * from './tool_router';
-export * from './agent_helpers';
-export * from './skill';
-export * from './router';
-export * from './agent';
-export * from './factory';
-export * from './security';
-export * from './learn';
-export * from './longdoc';
-export * from './filter';
-export * from './estimate';
-export * from './arbitrate';
-
-// Version — read from package.json
-export const VERSION = (() => { try { return require('../../package.json').version; } catch { return '1.6.0'; } })();
+/**
+ * Skyloom Core Module Exports
+ */
+
+export * from './constants';
+export * from './schemas';
+export * from './logger';
+export * from './config';
+export * from './tool';
+export * from './circuit_breaker';
+export * from './bus';
+export * from './cache';
+export * from './memory';
+export * from './middleware';
+export * from './llm';
+export * from './mcp';
+export { matchPipeline, buildTasksFromPipeline, listPipelines, getPipelineByName, matchAllPipelines, validateDAG, topologicalSort, type Pipeline, type PipelineStep } from './pipelines';
+export * from './semantic';
+export * from './icons';
+export * from './checkpoint';
+export * from './workspace';
+export * from './profile';
+export * from './tool_router';
+export * from './agent_helpers';
+export * from './skill';
+export * from './router';
+export * from './agent';
+export * from './factory';
+export * from './security';
+export * from './learn';
+export * from './longdoc';
+export * from './filter';
+export * from './estimate';
+export * from './arbitrate';
+
+// Version — read from package.json
+export const VERSION = (() => { try { return require('../../package.json').version; } catch { return '1.6.0'; } })();

package/src/core/learn.ts

@@ -1,146 +1,146 @@
-/**
- * 持续学习模块 — post-task review + experience recording.
- *
- * After each task, the agent writes a structured review.
- * Failed attempts are indexed for similarity search to avoid repetition.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { USER_CONFIG_DIR } from "./config";
-import { getLogger } from "./logger";
-
-const log = getLogger("learn");
-
-/* ── Data types ── */
-export interface TaskReview {
-  ts: string;
-  agent: string;
-  goal: string;
-  success: boolean;
-  durationMs: number;
-  toolCalls: string[];
-  errorMsg?: string;
-  rootCause?: string;
-  improvement?: string;
-}
-
-export interface ExperienceEntry {
-  id: string;
-  pattern: string;       // What went wrong (key for similarity search)
-  solution: string;      // What fixed it
-  frequency: number;     // How often this pattern repeats
-  lastSeen: string;
-}
-
-/* ── Persistence ── */
-const reviewDir = path.join(USER_CONFIG_DIR, "reviews");
-const expFile = path.join(USER_CONFIG_DIR, "experiences.json");
-const reviewDir_ = reviewDir; // for closure
-
-function ensureDir() { if (!fs.existsSync(reviewDir_)) fs.mkdirSync(reviewDir_, { recursive: true }); }
-
-/* ═══════════════════════════════════════
-   Task Review Recording
-   ═══════════════════════════════════════ */
-export function recordReview(review: TaskReview): void {
-  ensureDir();
-  const file = path.join(reviewDir_, `${review.ts.slice(0, 10)}_${review.agent}.jsonl`);
-  const line = JSON.stringify(review);
-  fs.appendFileSync(file, line + "\n");
-  log.debug("review_recorded", { agent: review.agent, success: review.success });
-
-  // If failed, also record as experience
-  if (!review.success && review.errorMsg) {
-    recordExperience(review.errorMsg, review.rootCause || "unknown", review.improvement || "no improvement noted");
-  }
-}
-
-/* ═══════════════════════════════════════
-   Experience Recording (for failure patterns)
-   ═══════════════════════════════════════ */
-function loadExperiences(): ExperienceEntry[] {
-  try {
-    if (fs.existsSync(expFile)) return JSON.parse(fs.readFileSync(expFile, "utf-8"));
-  } catch { /* ignore */ }
-  return [];
-}
-
-function saveExperiences(entries: ExperienceEntry[]): void {
-  ensureDir();
-  fs.writeFileSync(expFile, JSON.stringify(entries, null, 2), "utf-8");
-}
-
-export function recordExperience(errorPattern: string, rootCause: string, solution: string): void {
-  const entries = loadExperiences();
-  const normalized = errorPattern.toLowerCase().slice(0, 200);
-
-  // Check for existing similar pattern (simple substring match)
-  const existing = entries.find(e => e.pattern.toLowerCase().includes(normalized.slice(0, 50)) || normalized.includes(e.pattern.toLowerCase().slice(0, 50)));
-  if (existing) {
-    existing.frequency++;
-    existing.lastSeen = new Date().toISOString();
-    if (solution && solution !== "no improvement noted") existing.solution = solution;
-  } else {
-    entries.push({
-      id: Math.random().toString(36).slice(2, 10),
-      pattern: errorPattern.slice(0, 200),
-      solution,
-      frequency: 1,
-      lastSeen: new Date().toISOString(),
-    });
-  }
-
-  // Keep top 100 experiences, sorted by frequency
-  entries.sort((a, b) => b.frequency - a.frequency);
-  if (entries.length > 100) entries.splice(100);
-  saveExperiences(entries);
-}
-
-/* ═══════════════════════════════════════
-   Query experiences
-   ═══════════════════════════════════════ */
-export function queryExperiences(problem: string, limit: number = 3): ExperienceEntry[] {
-  const entries = loadExperiences();
-  const lower = problem.toLowerCase();
-  return entries
-    .filter(e => {
-      const plow = e.pattern.toLowerCase();
-      // Simple token overlap scoring
-      const tokens = lower.split(/\s+/).filter(t => t.length > 2);
-      const matches = tokens.filter(t => plow.includes(t));
-      return matches.length >= 2;
-    })
-    .sort((a, b) => b.frequency - a.frequency)
-    .slice(0, limit);
-}
-
-/* ═══════════════════════════════════════
-   Format experiences for system prompt injection
-   ═══════════════════════════════════════ */
-export function formatExperiencesForPrompt(problem: string): string {
-  const exps = queryExperiences(problem);
-  if (!exps.length) return "";
-  const lines = ["## 历史教训（从经验库检索）", "以下是与当前任务相关的过往失败案例，请避免重复："];
-  for (const e of exps) {
-    lines.push(`- **模式**: ${e.pattern.slice(0, 120)}`);
-    lines.push(`  **解决**: ${e.solution.slice(0, 200)} (出现 ${e.frequency} 次)`);
-  }
-  return lines.join("\n");
-}
-
-/* ═══════════════════════════════════════
-   Generate a structured review after task completion
-   ═══════════════════════════════════════ */
-export function generateReview(
-  agent: string, goal: string, success: boolean, durationMs: number,
-  toolCalls: string[], errorMsg?: string
-): TaskReview {
-  return {
-    ts: new Date().toISOString(),
-    agent, goal, success, durationMs, toolCalls,
-    errorMsg,
-    rootCause: errorMsg ? "auto-detected failure" : undefined,
-    improvement: errorMsg ? "review error and adjust approach" : undefined,
-  };
-}
+/**
+ * 持续学习模块 — post-task review + experience recording.
+ *
+ * After each task, the agent writes a structured review.
+ * Failed attempts are indexed for similarity search to avoid repetition.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { USER_CONFIG_DIR } from "./config";
+import { getLogger } from "./logger";
+
+const log = getLogger("learn");
+
+/* ── Data types ── */
+export interface TaskReview {
+  ts: string;
+  agent: string;
+  goal: string;
+  success: boolean;
+  durationMs: number;
+  toolCalls: string[];
+  errorMsg?: string;
+  rootCause?: string;
+  improvement?: string;
+}
+
+export interface ExperienceEntry {
+  id: string;
+  pattern: string;       // What went wrong (key for similarity search)
+  solution: string;      // What fixed it
+  frequency: number;     // How often this pattern repeats
+  lastSeen: string;
+}
+
+/* ── Persistence ── */
+const reviewDir = path.join(USER_CONFIG_DIR, "reviews");
+const expFile = path.join(USER_CONFIG_DIR, "experiences.json");
+const reviewDir_ = reviewDir; // for closure
+
+function ensureDir() { if (!fs.existsSync(reviewDir_)) fs.mkdirSync(reviewDir_, { recursive: true }); }
+
+/* ═══════════════════════════════════════
+   Task Review Recording
+   ═══════════════════════════════════════ */
+export function recordReview(review: TaskReview): void {
+  ensureDir();
+  const file = path.join(reviewDir_, `${review.ts.slice(0, 10)}_${review.agent}.jsonl`);
+  const line = JSON.stringify(review);
+  fs.appendFileSync(file, line + "\n");
+  log.debug("review_recorded", { agent: review.agent, success: review.success });
+
+  // If failed, also record as experience
+  if (!review.success && review.errorMsg) {
+    recordExperience(review.errorMsg, review.rootCause || "unknown", review.improvement || "no improvement noted");
+  }
+}
+
+/* ═══════════════════════════════════════
+   Experience Recording (for failure patterns)
+   ═══════════════════════════════════════ */
+function loadExperiences(): ExperienceEntry[] {
+  try {
+    if (fs.existsSync(expFile)) return JSON.parse(fs.readFileSync(expFile, "utf-8"));
+  } catch { /* ignore */ }
+  return [];
+}
+
+function saveExperiences(entries: ExperienceEntry[]): void {
+  ensureDir();
+  fs.writeFileSync(expFile, JSON.stringify(entries, null, 2), "utf-8");
+}
+
+export function recordExperience(errorPattern: string, rootCause: string, solution: string): void {
+  const entries = loadExperiences();
+  const normalized = errorPattern.toLowerCase().slice(0, 200);
+
+  // Check for existing similar pattern (simple substring match)
+  const existing = entries.find(e => e.pattern.toLowerCase().includes(normalized.slice(0, 50)) || normalized.includes(e.pattern.toLowerCase().slice(0, 50)));
+  if (existing) {
+    existing.frequency++;
+    existing.lastSeen = new Date().toISOString();
+    if (solution && solution !== "no improvement noted") existing.solution = solution;
+  } else {
+    entries.push({
+      id: Math.random().toString(36).slice(2, 10),
+      pattern: errorPattern.slice(0, 200),
+      solution,
+      frequency: 1,
+      lastSeen: new Date().toISOString(),
+    });
+  }
+
+  // Keep top 100 experiences, sorted by frequency
+  entries.sort((a, b) => b.frequency - a.frequency);
+  if (entries.length > 100) entries.splice(100);
+  saveExperiences(entries);
+}
+
+/* ═══════════════════════════════════════
+   Query experiences
+   ═══════════════════════════════════════ */
+export function queryExperiences(problem: string, limit: number = 3): ExperienceEntry[] {
+  const entries = loadExperiences();
+  const lower = problem.toLowerCase();
+  return entries
+    .filter(e => {
+      const plow = e.pattern.toLowerCase();
+      // Simple token overlap scoring
+      const tokens = lower.split(/\s+/).filter(t => t.length > 2);
+      const matches = tokens.filter(t => plow.includes(t));
+      return matches.length >= 2;
+    })
+    .sort((a, b) => b.frequency - a.frequency)
+    .slice(0, limit);
+}
+
+/* ═══════════════════════════════════════
+   Format experiences for system prompt injection
+   ═══════════════════════════════════════ */
+export function formatExperiencesForPrompt(problem: string): string {
+  const exps = queryExperiences(problem);
+  if (!exps.length) return "";
+  const lines = ["## 历史教训（从经验库检索）", "以下是与当前任务相关的过往失败案例，请避免重复："];
+  for (const e of exps) {
+    lines.push(`- **模式**: ${e.pattern.slice(0, 120)}`);
+    lines.push(`  **解决**: ${e.solution.slice(0, 200)} (出现 ${e.frequency} 次)`);
+  }
+  return lines.join("\n");
+}
+
+/* ═══════════════════════════════════════
+   Generate a structured review after task completion
+   ═══════════════════════════════════════ */
+export function generateReview(
+  agent: string, goal: string, success: boolean, durationMs: number,
+  toolCalls: string[], errorMsg?: string
+): TaskReview {
+  return {
+    ts: new Date().toISOString(),
+    agent, goal, success, durationMs, toolCalls,
+    errorMsg,
+    rootCause: errorMsg ? "auto-detected failure" : undefined,
+    improvement: errorMsg ? "review error and adjust approach" : undefined,
+  };
+}

package/src/core/llm.ts

@@ -690,10 +690,10 @@ export class LLMClient {
         let usage: UsageStats = { promptTokens: 0, completionTokens: 0 };
 
         if (isAnthropic) {
-          const r = await this.callAnthropic(model, messages, tools, temperature, maxTokens);
+          const r = await this.callAnthropic(model, messages, tools, temperature, maxTokens, agentName);
           content = r.content; toolCalls = r.toolCalls; usage = r.usage;
         } else {
-          const r = await this.callOpenAI(model, messages, tools, temperature, maxTokens);
+          const r = await this.callOpenAI(model, messages, tools, temperature, maxTokens, agentName);
           content = r.content; toolCalls = r.toolCalls; usage = r.usage;
         }
 
@@ -714,9 +714,9 @@ export class LLMClient {
   }
 
   private async callOpenAI(
-    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number
+    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number, agentName?: string
   ): Promise<{ content: string; toolCalls: ToolCall[]; usage: UsageStats }> {
-    const apiKey = this.getApiKey(m);
+    const apiKey = this.getApiKey(m, agentName);
     const baseUrl = this.getBaseUrl(m);
     const body: Record<string, unknown> = { model: m, messages, temperature: temp ?? 0.7, max_tokens: maxTok ?? 4096 };
     if (tools?.length) {
@@ -731,9 +731,9 @@ export class LLMClient {
   }
 
   private async callAnthropic(
-    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number
+    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number, agentName?: string
   ): Promise<{ content: string; toolCalls: ToolCall[]; usage: UsageStats }> {
-    const apiKey = this.getApiKey("anthropic");
+    const apiKey = this.getApiKey("anthropic", agentName);
     const body: Record<string, unknown> = { model: m, max_tokens: maxTok ?? 4096, messages: messages.filter(msg => msg.role !== "system"), temperature: temp ?? 0.7 };
     const sys = messages.find(msg => msg.role === "system"); if (sys) body.system = sys.content;
     if (tools?.length) {
@@ -754,7 +754,13 @@ export class LLMClient {
     return { type: "object", properties: props, ...(required.length > 0 ? { required } : {}) };
   }
 
-  private getApiKey(model: string): string {
+  private getApiKey(model: string, agentName?: string): string {
+    // 0. Per-agent override (agents.<name>.api_key) beats everything
+    if (agentName) {
+      const agentKey = (this.config.agents as any)?.[agentName]?.api_key;
+      if (agentKey) return String(agentKey);
+    }
+
     let provider = "openai"; const [pr] = splitProvider(model); if (pr) provider = pr;
     else { const l = model.toLowerCase(); if (l.includes("claude")) provider = "anthropic"; else if (l.includes("deepseek")) provider = "deepseek"; else if (l.includes("groq")) provider = "groq"; else if (l.includes("openrouter")) provider = "openrouter"; else if (l.includes("gemini")) provider = "gemini"; }
     const envMap = getProviderEnvMap();
@@ -802,7 +808,7 @@ export class LLMClient {
    * emitted once complete. Usage comes from the final `stream_options` chunk.
    */
   private async *callOpenAIStream(
-    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number, signal?: AbortSignal
+    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number, signal?: AbortSignal, agentName?: string
   ): AsyncGenerator<StreamEvent> {
     const apiKey = this.getApiKey(m);
     const baseUrl = this.getBaseUrl(m);
@@ -884,7 +890,7 @@ export class LLMClient {
     let started = false;
     let usage: UsageStats = { promptTokens: 0, completionTokens: 0 };
     try {
-      for await (const ev of this.callOpenAIStream(model, messages, tools, temperature, maxTokens, signal)) {
+      for await (const ev of this.callOpenAIStream(model, messages, tools, temperature, maxTokens, signal, agentName)) {
         if (ev.type === "content" || ev.type === "tool_call") started = true;
         if (ev.type === "done" && ev.usage) usage = ev.usage;
         yield ev;