zidane 1.5.2 → 1.6.0

package/dist/{chunk-XMFQK35S.js → chunk-VRAZJES3.js}

@@ -1,110 +1,87 @@
 import {
-  connectMcpServers,
-  init_mcp
-} from "./chunk-26LIQARN.js";
+  connectMcpServers
+} from "./chunk-YTZOORAP.js";
 import {
   buildCatalog,
-  init_catalog,
-  init_interpolate,
-  init_resolve,
   interpolateShellCommands,
   mergeSkillsConfig,
   resolveSkills
-} from "./chunk-PRNQ7DXE.js";
-import {
-  __esm,
-  __export,
-  __toCommonJS
-} from "./chunk-PNKVD2UK.js";
+} from "./chunk-3K5D27BF.js";
 
 // src/tools/list-files.ts
-var listFiles;
-var init_list_files = __esm({
-  "src/tools/list-files.ts"() {
-    "use strict";
-    listFiles = {
-      spec: {
-        name: "list_files",
-        description: "List files and directories at the given path (relative to project root).",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: 'Relative directory path (default: ".")' }
-          },
-          required: []
-        }
+var listFiles = {
+  spec: {
+    name: "list_files",
+    description: "List files and directories at the given path (relative to project root).",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: 'Relative directory path (default: ".")' }
       },
-      async execute({ path }, ctx) {
-        try {
-          const entries = await ctx.execution.listFiles(ctx.handle, path || ".");
-          return entries.join("\n") || "(empty directory)";
-        } catch {
-          return `Directory not found: ${path}`;
-        }
-      }
-    };
+      required: []
+    }
+  },
+  async execute({ path }, ctx) {
+    try {
+      const entries = await ctx.execution.listFiles(ctx.handle, path || ".");
+      return entries.join("\n") || "(empty directory)";
+    } catch {
+      return `Directory not found: ${path}`;
+    }
   }
-});
+};
 
 // src/tools/read-file.ts
-var readFile;
-var init_read_file = __esm({
-  "src/tools/read-file.ts"() {
-    "use strict";
-    readFile = {
-      spec: {
-        name: "read_file",
-        description: "Read the contents of a file at the given path (relative to project root).",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Relative file path" }
-          },
-          required: ["path"]
-        }
+var readFile = {
+  spec: {
+    name: "read_file",
+    description: "Read the contents of a file at the given path (relative to project root).",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative file path" }
       },
-      async execute({ path }, ctx) {
-        try {
-          return await ctx.execution.readFile(ctx.handle, path);
-        } catch {
-          return `File not found: ${path}`;
-        }
-      }
-    };
+      required: ["path"]
+    }
+  },
+  async execute({ path }, ctx) {
+    try {
+      return await ctx.execution.readFile(ctx.handle, path);
+    } catch {
+      return `File not found: ${path}`;
+    }
   }
-});
+};
 
 // src/tools/shell.ts
-var shell;
-var init_shell = __esm({
-  "src/tools/shell.ts"() {
-    "use strict";
-    shell = {
-      spec: {
-        name: "shell",
-        description: "Execute a shell command and return stdout+stderr. Runs in the project root.",
-        input_schema: {
-          type: "object",
-          properties: {
-            command: { type: "string", description: "The shell command to run" }
-          },
-          required: ["command"]
-        }
+var shell = {
+  spec: {
+    name: "shell",
+    description: "Execute a shell command and return stdout+stderr. Runs in the project root.",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to run" }
       },
-      async execute({ command }, ctx) {
-        const result = await ctx.execution.exec(ctx.handle, command);
-        if (result.exitCode === 0) {
-          return result.stdout || "(no output)";
-        }
-        return `Exit code ${result.exitCode}
+      required: ["command"]
+    }
+  },
+  async execute({ command }, ctx) {
+    const result = await ctx.execution.exec(ctx.handle, command);
+    if (result.exitCode === 0) {
+      return result.stdout || "(no output)";
+    }
+    return `Exit code ${result.exitCode}
 ${result.stdout}
 ${result.stderr}`.trim();
-      }
-    };
   }
-});
+};
+
+// src/agent.ts
+import { createHooks } from "hookable";
 
 // src/contexts/docker.ts
+var SINGLE_QUOTE_RE = /'/g;
 function createDockerContext(config) {
   let counter = 0;
   const containers = /* @__PURE__ */ new Map();
@@ -231,19 +208,13 @@ function createDockerContext(config) {
   };
   return ctx;
 }
-var SINGLE_QUOTE_RE;
-var init_docker = __esm({
-  "src/contexts/docker.ts"() {
-    "use strict";
-    SINGLE_QUOTE_RE = /'/g;
-  }
-});
 
 // src/contexts/process.ts
 import { exec as execCb } from "child_process";
 import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
 import { dirname, resolve } from "path";
 import { promisify } from "util";
+var execAsync = promisify(execCb);
 function createProcessContext(config) {
   let counter = 0;
   const handles = /* @__PURE__ */ new Map();
@@ -299,13 +270,6 @@ function createProcessContext(config) {
     }
   };
 }
-var execAsync;
-var init_process = __esm({
-  "src/contexts/process.ts"() {
-    "use strict";
-    execAsync = promisify(execCb);
-  }
-});
 
 // src/contexts/sandbox.ts
 function createSandboxContext(provider) {
@@ -351,67 +315,6 @@ function createSandboxContext(provider) {
     }
   };
 }
-var init_sandbox = __esm({
-  "src/contexts/sandbox.ts"() {
-    "use strict";
-  }
-});
-
-// src/contexts/index.ts
-var init_contexts = __esm({
-  "src/contexts/index.ts"() {
-    "use strict";
-    init_docker();
-    init_process();
-    init_sandbox();
-  }
-});
-
-// src/harnesses/basic.ts
-function getSpawn() {
-  if (!_spawn) {
-    _spawn = (init_spawn(), __toCommonJS(spawn_exports)).spawn;
-  }
-  return _spawn;
-}
-var basicTools, _spawn, spawnProxy, basic_default;
-var init_basic = __esm({
-  "src/harnesses/basic.ts"() {
-    "use strict";
-    init_harnesses();
-    init_tools();
-    basicTools = { shell, readFile, writeFile: writeFile2, listFiles };
-    spawnProxy = {
-      get spec() {
-        return getSpawn().spec;
-      },
-      execute(input, ctx) {
-        return getSpawn().execute(input, ctx);
-      }
-    };
-    basic_default = defineHarness({
-      name: "basic",
-      system: "You are a helpful assistant with access to shell, file reading, file writing, directory listing, and sub-agent spawning tools. Use them to accomplish tasks in the project directory.",
-      tools: { ...basicTools, spawn: spawnProxy }
-    });
-  }
-});
-
-// src/harnesses/index.ts
-function defineHarness(config) {
-  return config;
-}
-var noTools;
-var init_harnesses = __esm({
-  "src/harnesses/index.ts"() {
-    init_basic();
-    noTools = defineHarness({
-      name: "none",
-      system: "You are a helpful assistant.",
-      tools: {}
-    });
-  }
-});
 
 // src/tools/validation.ts
 function validateToolArgs(input, schema) {
@@ -423,11 +326,6 @@ function validateToolArgs(input, schema) {
   }
   return { valid: true };
 }
-var init_validation = __esm({
-  "src/tools/validation.ts"() {
-    "use strict";
-  }
-});
 
 // src/loop.ts
 function turnsToMessages(turns) {
@@ -448,6 +346,7 @@ async function runLoop(ctx) {
     totalIn += result.usage.input;
     totalOut += result.usage.output;
     turnUsages.push(result.usage);
+    await ctx.hooks.callHook("usage", { turn, turnId: result.turnId, usage: result.usage, totalIn, totalOut });
     if (ctx.signal.aborted) {
       await ctx.hooks.callHook("agent:abort", {});
       break;
@@ -458,6 +357,7 @@ async function runLoop(ctx) {
       const steerUserMsg = ctx.provider.userMessage(steerMsg);
       ctx.turns.push({
         id: await ctx.generateTurnId(),
+        runId: ctx.runId,
         role: steerUserMsg.role,
         content: steerUserMsg.content,
         createdAt: Date.now()
@@ -471,13 +371,14 @@ async function runLoop(ctx) {
         const followUpMsg = ctx.provider.userMessage(followUp);
         ctx.turns.push({
           id: await ctx.generateTurnId(),
+          runId: ctx.runId,
           role: followUpMsg.role,
           content: followUpMsg.content,
           createdAt: Date.now()
         });
         continue;
       }
-      const stats2 = { totalIn, totalOut, turns: turn + 1, elapsed: Date.now() - startTime, turnUsage: turnUsages };
+      const stats2 = { totalIn, totalOut, turns: turn + 1, elapsed: Date.now() - startTime, turnUsage: turnUsages, output: result.output };
       await ctx.hooks.callHook("agent:done", stats2);
       return stats2;
     }
@@ -515,40 +416,87 @@ async function executeTurn(ctx, turn) {
       }
     );
   } catch (err) {
-    await ctx.hooks.callHook("turn:after", { turn, turnId, usage: { input: 0, output: 0 } });
+    const errorTurn = {
+      id: turnId,
+      runId: ctx.runId,
+      role: "assistant",
+      content: currentText ? [{ type: "text", text: currentText }] : [],
+      usage: { input: 0, output: 0 },
+      createdAt: Date.now()
+    };
+    ctx.turns.push(errorTurn);
+    await ctx.hooks.callHook("turn:after", { turn, turnId, usage: errorTurn.usage, message: errorTurn });
     throw err;
   }
   if (currentText) {
     await ctx.hooks.callHook("stream:end", { text: currentText, turnId, blockIndex });
     blockIndex++;
   }
-  await ctx.hooks.callHook("turn:after", { turn, turnId, usage: result.usage });
-  if (result.done) {
-    ctx.turns.push({
-      id: turnId,
-      role: "assistant",
-      content: result.assistantMessage?.content ?? [{ type: "text", text: currentText }],
-      usage: result.usage,
-      createdAt: Date.now()
-    });
-    return { ended: true, usage: result.usage };
-  }
-  ctx.turns.push({
+  const assistantTurn = {
     id: turnId,
+    runId: ctx.runId,
     role: "assistant",
-    content: result.assistantMessage.content,
+    content: result.done ? result.assistantMessage?.content ?? [{ type: "text", text: currentText }] : result.assistantMessage.content,
     usage: result.usage,
     createdAt: Date.now()
-  });
+  };
+  ctx.turns.push(assistantTurn);
+  await ctx.hooks.callHook("turn:after", { turn, turnId, usage: result.usage, message: assistantTurn });
+  if (result.done) {
+    if (ctx.schema && !ctx.signal.aborted) {
+      const outputSpec = {
+        name: "__output__",
+        description: "Return the final structured output matching the required schema.",
+        input_schema: ctx.schema
+      };
+      const schemaResult = await ctx.provider.stream(
+        {
+          model: ctx.model,
+          system: ctx.system,
+          tools: ctx.provider.formatTools([outputSpec]),
+          messages: turnsToMessages(ctx.turns),
+          maxTokens: ctx.maxTokens ?? 16384,
+          signal: ctx.signal,
+          toolChoice: { type: "tool", name: "__output__" }
+        },
+        { onText: () => {
+        } }
+      );
+      const output = schemaResult.toolCalls.find((tc) => tc.name === "__output__")?.input;
+      if (output) {
+        await ctx.hooks.callHook("output", { output, schema: ctx.schema });
+      }
+      const schemaTurn = {
+        id: await ctx.generateTurnId(),
+        runId: ctx.runId,
+        role: "assistant",
+        content: schemaResult.assistantMessage.content,
+        usage: schemaResult.usage,
+        createdAt: Date.now()
+      };
+      ctx.turns.push(schemaTurn);
+      return {
+        ended: true,
+        turnId,
+        usage: {
+          input: result.usage.input + schemaResult.usage.input,
+          output: result.usage.output + schemaResult.usage.output
+        },
+        output
+      };
+    }
+    return { ended: true, turnId, usage: result.usage };
+  }
   const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, result.toolCalls) : await executeToolsSequential(ctx, result.toolCalls);
   const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
   ctx.turns.push({
     id: await ctx.generateTurnId(),
+    runId: ctx.runId,
     role: toolResultMsg.role,
     content: toolResultMsg.content,
     createdAt: Date.now()
   });
-  return { ended: false, usage: result.usage };
+  return { ended: false, turnId, usage: result.usage };
 }
 async function executeSingleTool(ctx, call) {
   const toolDef = ctx.tools[call.name];
@@ -605,6 +553,7 @@ async function executeToolsSequential(ctx, toolCalls) {
       const toolResultMsg = ctx.provider.toolResultsMessage(results);
       ctx.turns.push({
         id: await ctx.generateTurnId(),
+        runId: ctx.runId,
         role: toolResultMsg.role,
         content: toolResultMsg.content,
         createdAt: Date.now()
@@ -612,6 +561,7 @@ async function executeToolsSequential(ctx, toolCalls) {
       const steerUserMsg = ctx.provider.userMessage(steerMsg);
       ctx.turns.push({
         id: await ctx.generateTurnId(),
+        runId: ctx.runId,
         role: steerUserMsg.role,
         content: steerUserMsg.content,
         createdAt: Date.now()
@@ -628,16 +578,19 @@ async function executeToolsParallel(ctx, toolCalls) {
   const settled = await Promise.all(executions);
   return settled.map((s) => s.result);
 }
-var init_loop = __esm({
-  "src/loop.ts"() {
-    "use strict";
-    init_validation();
-  }
-});
 
 // src/agent.ts
-import { createHooks } from "hookable";
-function createAgent({ harness: harnessOption, provider, toolExecution = "sequential", enableTools = true, execution, mcpServers, session, skills: agentSkills, maxTurns: agentMaxTurns, maxTokens: agentMaxTokens, thinkingBudget: agentThinkingBudget, _mcpConnector }) {
+var noTools = { name: "none", system: "You are a helpful assistant.", tools: {} };
+function resolveBehavior(harnessBehavior, agentBehavior, runBehavior) {
+  return {
+    toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? harnessBehavior?.toolExecution ?? "sequential",
+    maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns ?? harnessBehavior?.maxTurns,
+    maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens ?? harnessBehavior?.maxTokens,
+    thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget ?? harnessBehavior?.thinkingBudget,
+    schema: runBehavior?.schema ?? agentBehavior?.schema ?? harnessBehavior?.schema
+  };
+}
+function createAgent({ harness: harnessOption, provider, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
   const hooks = createHooks();
   const harness = harnessOption ?? noTools;
   const executionContext = execution ?? createProcessContext();
@@ -729,18 +682,16 @@ function createAgent({ harness: harnessOption, provider, toolExecution = "sequen
     }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const maxTurns = options.maxTurns ?? agentMaxTurns;
-    const maxTokens = options.maxTokens ?? agentMaxTokens;
-    const thinkingBudget = options.thinkingBudget ?? agentThinkingBudget;
+    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema } = resolveBehavior(harness.behavior, agentBehavior, options.behavior);
     let system = options.system || harness.system || "You are a helpful assistant.";
     if (skillsCatalog) {
       system = `${system}
 
 ${skillsCatalog}`;
     }
-    const harnessTools = enableTools ? mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools : {};
+    const baseTools = options.tools !== void 0 ? options.tools : mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools;
     const tools = {};
-    for (const tool of Object.values(harnessTools)) {
+    for (const tool of Object.values(baseTools)) {
       tools[tool.spec.name] = tool;
     }
     const toolSpecs = Object.values(tools).map(
@@ -750,17 +701,19 @@ ${skillsCatalog}`;
         input_schema: t.spec.input_schema
       })
     );
-    const formattedTools = enableTools ? provider.formatTools(toolSpecs) : [];
+    const formattedTools = toolSpecs.length > 0 ? provider.formatTools(toolSpecs) : [];
     const turns = [];
     const isResume = session && session.turns.length > 0 && session.runs.length > 0;
     if (isResume) {
       turns.push(...session.turns);
     }
+    const runTurnStart = turns.length;
     if (options.system) {
       await hooks.callHook("system:before", { system: options.system });
       const systemUserMsg = provider.userMessage(options.system);
       turns.push({
         id: crypto.randomUUID(),
+        runId,
         role: systemUserMsg.role,
         content: systemUserMsg.content,
         createdAt: Date.now()
@@ -768,6 +721,7 @@ ${skillsCatalog}`;
       const systemAckMsg = provider.assistantMessage("Understood. I will proceed with these instructions above the rest of my system prompt.");
       turns.push({
         id: crypto.randomUUID(),
+        runId,
         role: systemAckMsg.role,
         content: systemAckMsg.content,
         createdAt: Date.now()
@@ -776,6 +730,7 @@ ${skillsCatalog}`;
     const promptMsg = provider.userMessage(options.prompt, options.images);
     turns.push({
       id: crypto.randomUUID(),
+      runId,
       role: promptMsg.role,
       content: promptMsg.content,
       createdAt: Date.now()
@@ -808,10 +763,12 @@ ${skillsCatalog}`;
         steeringQueue,
         followUpQueue,
         turns,
+        runId,
         generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID(),
         maxTurns,
         maxTokens,
-        thinkingBudget
+        thinkingBudget,
+        schema
       });
       const finalStats = {
         ...stats,
@@ -824,7 +781,7 @@ ${skillsCatalog}`;
           if (run2)
             await session.updateRun(run2);
           await session.updateStatus("idle");
-          await hooks.callHook("session:end", { sessionId: session.id, runId, status: "aborted" });
+          await hooks.callHook("session:end", { sessionId: session.id, runId, status: "aborted", turnRange: [runTurnStart, turns.length - 1] });
         }
         await hooks.callHook("agent:done", finalStats);
         return finalStats;
@@ -849,7 +806,7 @@ ${skillsCatalog}`;
         if (run2)
           await session.updateRun(run2);
         await session.updateStatus("completed");
-        await hooks.callHook("session:end", { sessionId: session.id, runId, status: "completed" });
+        await hooks.callHook("session:end", { sessionId: session.id, runId, status: "completed", turnRange: [runTurnStart, turns.length - 1] });
       }
       await hooks.callHook("agent:done", finalStats);
       return finalStats;
@@ -861,7 +818,7 @@ ${skillsCatalog}`;
           if (run2)
             await session.updateRun(run2);
           await session.updateStatus("idle");
-          await hooks.callHook("session:end", { sessionId: session.id, runId, status: "aborted" });
+          await hooks.callHook("session:end", { sessionId: session.id, runId, status: "aborted", turnRange: [runTurnStart, turns.length - 1] });
         }
         const stats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: 0 };
         await hooks.callHook("agent:done", stats);
@@ -873,7 +830,7 @@ ${skillsCatalog}`;
         if (run2)
           await session.updateRun(run2);
         await session.updateStatus("error");
-        await hooks.callHook("session:end", { sessionId: session.id, runId, status: "error" });
+        await hooks.callHook("session:end", { sessionId: session.id, runId, status: "error", turnRange: [runTurnStart, turns.length - 1] });
       }
       throw err;
     } finally {
@@ -954,25 +911,8 @@ ${skillsCatalog}`;
     meta: provider.meta
   };
 }
-var init_agent = __esm({
-  "src/agent.ts"() {
-    "use strict";
-    init_contexts();
-    init_harnesses();
-    init_loop();
-    init_mcp();
-    init_catalog();
-    init_interpolate();
-    init_resolve();
-  }
-});
 
 // src/tools/spawn.ts
-var spawn_exports = {};
-__export(spawn_exports, {
-  createSpawnTool: () => createSpawnTool,
-  spawn: () => spawn
-});
 function extractText(message) {
   if (!message || typeof message !== "object")
     return "";
@@ -1073,71 +1013,38 @@ function createSpawnTool(options = {}) {
     }
   };
 }
-var spawn;
-var init_spawn = __esm({
-  "src/tools/spawn.ts"() {
-    "use strict";
-    init_agent();
-    spawn = createSpawnTool();
-  }
-});
+var spawn = createSpawnTool();
 
 // src/tools/write-file.ts
-var writeFile2;
-var init_write_file = __esm({
-  "src/tools/write-file.ts"() {
-    "use strict";
-    writeFile2 = {
-      spec: {
-        name: "write_file",
-        description: "Write content to a file. Creates parent directories if needed.",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Relative file path" },
-            content: { type: "string", description: "File content to write" }
-          },
-          required: ["path", "content"]
-        }
+var writeFile2 = {
+  spec: {
+    name: "write_file",
+    description: "Write content to a file. Creates parent directories if needed.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative file path" },
+        content: { type: "string", description: "File content to write" }
       },
-      async execute({ path, content }, ctx) {
-        await ctx.execution.writeFile(ctx.handle, path, content);
-        return `Wrote ${content.length} bytes to ${path}`;
-      }
-    };
-  }
-});
-
-// src/tools/index.ts
-var init_tools = __esm({
-  "src/tools/index.ts"() {
-    init_list_files();
-    init_read_file();
-    init_shell();
-    init_spawn();
-    init_validation();
-    init_write_file();
+      required: ["path", "content"]
+    }
+  },
+  async execute({ path, content }, ctx) {
+    await ctx.execution.writeFile(ctx.handle, path, content);
+    return `Wrote ${content.length} bytes to ${path}`;
   }
-});
+};
 
 export {
   createDockerContext,
   createProcessContext,
   createSandboxContext,
-  init_contexts,
+  validateToolArgs,
+  createAgent,
   listFiles,
   readFile,
   shell,
   createSpawnTool,
   spawn,
-  validateToolArgs,
-  writeFile2 as writeFile,
-  init_tools,
-  basicTools,
-  basic_default,
-  defineHarness,
-  noTools,
-  init_harnesses,
-  createAgent,
-  init_agent
+  writeFile2 as writeFile
 };