zidane 1.6.6 → 1.6.8

package/dist/{agent-0Tafyla0.d.ts → agent-CXMcPke1.d.ts}

@@ -127,6 +127,35 @@ interface ChildRunStats {
     task: string;
     stats: AgentStats;
 }
+/** Base context for tool execution hooks */
+interface ToolHookContext {
+    turnId: string;
+    callId: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/** Base context for MCP tool hooks */
+interface McpToolHookContext {
+    turnId: string;
+    callId: string;
+    server: string;
+    tool: string;
+    input: Record<string, unknown>;
+}
+/** Base context for session hooks */
+interface SessionHookContext {
+    sessionId: string;
+}
+/** Base context for spawn hooks */
+interface SpawnHookContext {
+    id: string;
+    task: string;
+}
+/** Context for stream hooks */
+interface StreamHookContext {
+    turnId: string;
+}
+type SessionEndStatus = 'completed' | 'aborted' | 'error';
 
 interface AnthropicParams {
     apiKey?: string;
@@ -239,6 +268,10 @@ interface ToolContext {
     hooks: Hookable<AgentHooks>;
     /** The harness config for this agent (tools available to the agent) */
     harness: HarnessConfig;
+    /** Turn ID that requested this tool call */
+    turnId: string;
+    /** Tool call ID from the model */
+    callId: string;
 }
 interface ToolDef {
     spec: ToolSpec;
@@ -506,43 +539,29 @@ interface AgentHooks {
         usage: TurnUsage;
         message: SessionTurn;
     }) => void;
-    'stream:text': (ctx: {
+    'stream:text': (ctx: StreamHookContext & {
         delta: string;
         text: string;
-        turnId: string;
     }) => void;
-    'stream:end': (ctx: {
+    'stream:end': (ctx: StreamHookContext & {
         text: string;
-        turnId: string;
     }) => void;
-    'stream:thinking': (ctx: {
+    'stream:thinking': (ctx: StreamHookContext & {
         delta: string;
         thinking: string;
-        turnId: string;
     }) => void;
-    'tool:before': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
+    'tool:gate': (ctx: ToolHookContext & {
+        block: boolean;
+        reason: string;
     }) => void;
-    'tool:after': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
+    'tool:before': (ctx: ToolHookContext) => void;
+    'tool:after': (ctx: ToolHookContext & {
         result: string;
     }) => void;
-    'tool:error': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
+    'tool:error': (ctx: ToolHookContext & {
         error: Error;
     }) => void;
-    'tool:gate': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
-        block: boolean;
-        reason: string;
-    }) => void;
-    'tool:transform': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
+    'tool:transform': (ctx: ToolHookContext & {
         result: string;
         isError: boolean;
     }) => void;
@@ -552,14 +571,9 @@ interface AgentHooks {
     'steer:inject': (ctx: {
         message: string;
     }) => void;
+    'spawn:before': (ctx: SpawnHookContext) => void;
     'spawn:complete': (ctx: ChildRunStats) => void;
-    'spawn:before': (ctx: {
-        id: string;
-        task: string;
-    }) => void;
-    'spawn:error': (ctx: {
-        id: string;
-        task: string;
+    'spawn:error': (ctx: SpawnHookContext & {
         error: Error;
     }) => void;
     'mcp:connect': (ctx: {
@@ -574,21 +588,18 @@ interface AgentHooks {
     'mcp:close': (ctx: {
         name: string;
     }) => void;
-    'mcp:tool:before': (ctx: {
-        server: string;
-        tool: string;
-        input: Record<string, unknown>;
+    'mcp:tool:gate': (ctx: McpToolHookContext & {
+        block: boolean;
+        reason: string;
+    }) => void;
+    'mcp:tool:before': (ctx: McpToolHookContext) => void;
+    'mcp:tool:after': (ctx: McpToolHookContext & {
+        result: string;
     }) => void;
-    'mcp:tool:after': (ctx: {
-        server: string;
-        tool: string;
-        input: Record<string, unknown>;
+    'mcp:tool:transform': (ctx: McpToolHookContext & {
         result: string;
     }) => void;
-    'mcp:tool:error': (ctx: {
-        server: string;
-        tool: string;
-        input: Record<string, unknown>;
+    'mcp:tool:error': (ctx: McpToolHookContext & {
         error: Error;
     }) => void;
     'skills:resolve': (ctx: {
@@ -614,29 +625,23 @@ interface AgentHooks {
     }) => void;
     'agent:abort': (ctx: object) => void;
     'agent:done': (ctx: AgentStats) => void;
-    'session:start': (ctx: {
-        sessionId: string;
+    'session:start': (ctx: SessionHookContext & {
         runId: string;
         prompt: string;
     }) => void;
-    'session:end': (ctx: {
-        sessionId: string;
+    'session:end': (ctx: SessionHookContext & {
         runId: string;
-        status: 'completed' | 'aborted' | 'error';
+        status: SessionEndStatus;
         turnRange: [number, number];
     }) => void;
-    'session:turns': (ctx: {
-        sessionId: string;
+    'session:turns': (ctx: SessionHookContext & {
         count: number;
     }) => void;
-    'session:meta': (ctx: {
-        sessionId: string;
+    'session:meta': (ctx: SessionHookContext & {
         key: string;
         value: unknown;
     }) => void;
-    'session:save': (ctx: {
-        sessionId: string;
-    }) => void;
+    'session:save': (ctx: SessionHookContext) => void;
 }
 interface AgentOptions {
     /** Harness (tools + system prompt). Defaults to a no-tools harness if omitted. */
@@ -674,4 +679,4 @@ interface Agent {
 }
 declare function createAgent({ harness: harnessOption, provider, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }: AgentOptions): Agent;
 
-export { cerebras as $, type Agent as A, type TurnResult as B, type CerebrasParams as C, type TurnUsage as D, autoDetectAndConvert as E, connectMcpServers as F, createAgent as G, type Harness as H, type ImageContent as I, createMemoryStore as J, createRemoteStore as K, createSession as L, type McpConnection as M, createSqliteStore as N, type OpenRouterParams as O, type Provider as P, defineHarness as Q, type RemoteStoreOptions as R, type Session as S, type ThinkingLevel as T, fromAnthropic as U, fromOpenAI as V, loadSession as W, noTools as X, toAnthropic as Y, toOpenAI as Z, anthropic as _, type AgentBehavior as a, openrouter as a0, _default as a1, basicTools as a2, resultToString as a3, type AgentHooks as b, type AgentOptions as c, type AgentRunOptions as d, type AgentStats as e, type AnthropicParams as f, type ChildRunStats as g, type CreateSessionOptions as h, type HarnessConfig as i, type McpServerConfig as j, type SessionContentBlock as k, type SessionData as l, type SessionMessage as m, type SessionRun as n, type SessionStore as o, type SessionTurn as p, type SqliteStoreOptions as q, type StreamCallbacks as r, type StreamOptions as s, type ToolCall as t, type ToolContext as u, type ToolDef as v, type ToolExecutionMode as w, type ToolMap as x, type ToolResult as y, type ToolSpec as z };
+export { fromOpenAI as $, type Agent as A, type ToolDef as B, type CerebrasParams as C, type ToolExecutionMode as D, type ToolHookContext as E, type ToolMap as F, type ToolResult as G, type Harness as H, type ImageContent as I, type ToolSpec as J, type TurnResult as K, type TurnUsage as L, type McpConnection as M, autoDetectAndConvert as N, type OpenRouterParams as O, type Provider as P, connectMcpServers as Q, type RemoteStoreOptions as R, type Session as S, type ThinkingLevel as T, createAgent as U, createMemoryStore as V, createRemoteStore as W, createSession as X, createSqliteStore as Y, defineHarness as Z, fromAnthropic as _, type AgentBehavior as a, loadSession as a0, noTools as a1, toAnthropic as a2, toOpenAI as a3, anthropic as a4, cerebras as a5, openrouter as a6, _default as a7, basicTools as a8, resultToString as a9, type AgentHooks as b, type AgentOptions as c, type AgentRunOptions as d, type AgentStats as e, type AnthropicParams as f, type ChildRunStats as g, type CreateSessionOptions as h, type HarnessConfig as i, type McpServerConfig as j, type McpToolHookContext as k, type SessionContentBlock as l, type SessionData as m, type SessionEndStatus as n, type SessionHookContext as o, type SessionMessage as p, type SessionRun as q, type SessionStore as r, type SessionTurn as s, type SpawnHookContext as t, type SqliteStoreOptions as u, type StreamCallbacks as v, type StreamHookContext as w, type StreamOptions as x, type ToolCall as y, type ToolContext as z };

package/dist/{chunk-NNMWWSBY.js → chunk-5LOHDFK3.js}

@@ -53,15 +53,23 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
             description: tool.description || "",
             inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
           },
-          execute: async (input, _ctx) => {
-            await hooks?.callHook("mcp:tool:before", { server: config.name, tool: tool.name, input });
+          execute: async (input, ctx) => {
+            const { turnId, callId } = ctx;
+            const gateCtx = { turnId, callId, server: config.name, tool: tool.name, input, block: false, reason: "MCP tool execution was blocked" };
+            await hooks?.callHook("mcp:tool:gate", gateCtx);
+            if (gateCtx.block)
+              return `Blocked: ${gateCtx.reason}`;
+            await hooks?.callHook("mcp:tool:before", { turnId, callId, server: config.name, tool: tool.name, input });
             try {
               const result = await client.callTool({ name: tool.name, arguments: input });
-              const output = resultToString(result.content);
-              await hooks?.callHook("mcp:tool:after", { server: config.name, tool: tool.name, input, result: output });
+              let output = resultToString(result.content);
+              const transformCtx = { turnId, callId, server: config.name, tool: tool.name, input, result: output };
+              await hooks?.callHook("mcp:tool:transform", transformCtx);
+              output = transformCtx.result;
+              await hooks?.callHook("mcp:tool:after", { turnId, callId, server: config.name, tool: tool.name, input, result: output });
               return output;
             } catch (err) {
-              await hooks?.callHook("mcp:tool:error", { server: config.name, tool: tool.name, input, error: err });
+              await hooks?.callHook("mcp:tool:error", { turnId, callId, server: config.name, tool: tool.name, input, error: err });
               throw err;
             }
           }

package/dist/{chunk-F4BVVP67.js → chunk-GCALAOLD.js}

@@ -1,6 +1,6 @@
 import {
   connectMcpServers
-} from "./chunk-NNMWWSBY.js";
+} from "./chunk-5LOHDFK3.js";
 import {
   buildCatalog,
   interpolateShellCommands,
@@ -504,7 +504,7 @@ async function executeTurn(ctx, turn) {
     }
     return { ended: true, turnId, usage: result.usage };
   }
-  const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, result.toolCalls) : await executeToolsSequential(ctx, result.toolCalls);
+  const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, result.toolCalls, turnId) : await executeToolsSequential(ctx, result.toolCalls, turnId);
   const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
   ctx.turns.push({
     id: await ctx.generateTurnId(),
@@ -515,23 +515,24 @@ async function executeTurn(ctx, turn) {
   });
   return { ended: false, turnId, usage: result.usage };
 }
-async function executeSingleTool(ctx, call) {
+async function executeSingleTool(ctx, call, turnId) {
   const toolDef = ctx.tools[call.name];
-  const gateCtx = { name: call.name, input: call.input, block: false, reason: "Tool execution was blocked" };
+  const callId = call.id;
+  const gateCtx = { turnId, callId, name: call.name, input: call.input, block: false, reason: "Tool execution was blocked" };
   await ctx.hooks.callHook("tool:gate", gateCtx);
   if (gateCtx.block) {
-    return { result: { id: call.id, content: `Blocked: ${gateCtx.reason}` } };
+    return { result: { id: callId, content: `Blocked: ${gateCtx.reason}` } };
   }
   if (!toolDef) {
     const err = new Error(`Unknown tool: ${call.name}`);
-    await ctx.hooks.callHook("tool:error", { name: call.name, input: call.input, error: err });
-    return { result: { id: call.id, content: `Tool error: ${err.message}` } };
+    await ctx.hooks.callHook("tool:error", { turnId, callId, name: call.name, input: call.input, error: err });
+    return { result: { id: callId, content: `Tool error: ${err.message}` } };
   }
   const validation = validateToolArgs(call.input, toolDef.spec.inputSchema);
   if (!validation.valid) {
-    return { result: { id: call.id, content: `Validation error: ${validation.error}` } };
+    return { result: { id: callId, content: `Validation error: ${validation.error}` } };
   }
-  await ctx.hooks.callHook("tool:before", { name: call.name, input: call.input });
+  await ctx.hooks.callHook("tool:before", { turnId, callId, name: call.name, input: call.input });
   let output;
   let isError = false;
   try {
@@ -541,22 +542,24 @@ async function executeSingleTool(ctx, call) {
       execution: ctx.execution,
       handle: ctx.handle,
       hooks: ctx.hooks,
-      harness: ctx.harness
+      harness: ctx.harness,
+      turnId,
+      callId
     };
     output = await toolDef.execute(call.input, toolCtx);
   } catch (err) {
-    await ctx.hooks.callHook("tool:error", { name: call.name, input: call.input, error: err });
+    await ctx.hooks.callHook("tool:error", { turnId, callId, name: call.name, input: call.input, error: err });
     output = `Tool error: ${err.message}`;
     isError = true;
   }
-  const transformCtx = { name: call.name, input: call.input, result: output, isError };
+  const transformCtx = { turnId, callId, name: call.name, input: call.input, result: output, isError };
   await ctx.hooks.callHook("tool:transform", transformCtx);
   output = transformCtx.result;
   isError = transformCtx.isError;
-  await ctx.hooks.callHook("tool:after", { name: call.name, input: call.input, result: output });
-  return { result: { id: call.id, content: output } };
+  await ctx.hooks.callHook("tool:after", { turnId, callId, name: call.name, input: call.input, result: output });
+  return { result: { id: callId, content: output } };
 }
-async function executeToolsSequential(ctx, toolCalls) {
+async function executeToolsSequential(ctx, toolCalls, turnId) {
   const results = [];
   for (const call of toolCalls) {
     if (ctx.signal.aborted)
@@ -585,13 +588,13 @@ async function executeToolsSequential(ctx, toolCalls) {
       });
       return [];
     }
-    const { result } = await executeSingleTool(ctx, call);
+    const { result } = await executeSingleTool(ctx, call, turnId);
     results.push(result);
   }
   return results;
 }
-async function executeToolsParallel(ctx, toolCalls) {
-  const executions = toolCalls.map((call) => executeSingleTool(ctx, call));
+async function executeToolsParallel(ctx, toolCalls, turnId) {
+  const executions = toolCalls.map((call) => executeSingleTool(ctx, call, turnId));
   const settled = await Promise.all(executions);
   return settled.map((s) => s.result);
 }

package/dist/{chunk-KG63Q5KF.js → chunk-Z2NZSEBZ.js}

@@ -4,7 +4,7 @@ import {
   shell,
   spawn,
   writeFile
-} from "./chunk-F4BVVP67.js";
+} from "./chunk-GCALAOLD.js";
 
 // src/harnesses/basic.ts
 var basicTools = { shell, readFile, writeFile, listFiles };

package/dist/harnesses.d.ts

@@ -1,4 +1,4 @@
 import 'hookable';
-export { H as Harness, i as HarnessConfig, u as ToolContext, v as ToolDef, x as ToolMap, a1 as basic, a2 as basicTools, Q as defineHarness, X as noTools } from './agent-0Tafyla0.js';
+export { H as Harness, i as HarnessConfig, z as ToolContext, B as ToolDef, F as ToolMap, a7 as basic, a8 as basicTools, Z as defineHarness, a1 as noTools } from './agent-CXMcPke1.js';
 import './types-CKXAp41h.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/harnesses.js

@@ -3,9 +3,9 @@ import {
   basic_default,
   defineHarness,
   noTools
-} from "./chunk-KG63Q5KF.js";
-import "./chunk-F4BVVP67.js";
-import "./chunk-NNMWWSBY.js";
+} from "./chunk-Z2NZSEBZ.js";
+import "./chunk-GCALAOLD.js";
+import "./chunk-5LOHDFK3.js";
 import "./chunk-4C6Y56CC.js";
 export {
   basic_default as basic,

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { A as Agent, a as AgentBehavior, b as AgentHooks, c as AgentOptions, d as AgentRunOptions, e as AgentStats, h as CreateSessionOptions, H as Harness, i as HarnessConfig, I as ImageContent, M as McpConnection, j as McpServerConfig, R as RemoteStoreOptions, S as Session, k as SessionContentBlock, l as SessionData, m as SessionMessage, n as SessionRun, o as SessionStore, p as SessionTurn, q as SqliteStoreOptions, T as ThinkingLevel, u as ToolContext, v as ToolDef, w as ToolExecutionMode, x as ToolMap, D as TurnUsage, E as autoDetectAndConvert, F as connectMcpServers, G as createAgent, J as createMemoryStore, K as createRemoteStore, L as createSession, N as createSqliteStore, Q as defineHarness, U as fromAnthropic, V as fromOpenAI, W as loadSession, X as noTools, Y as toAnthropic, Z as toOpenAI } from './agent-0Tafyla0.js';
+export { A as Agent, a as AgentBehavior, b as AgentHooks, c as AgentOptions, d as AgentRunOptions, e as AgentStats, h as CreateSessionOptions, H as Harness, i as HarnessConfig, I as ImageContent, M as McpConnection, j as McpServerConfig, k as McpToolHookContext, R as RemoteStoreOptions, S as Session, l as SessionContentBlock, m as SessionData, n as SessionEndStatus, o as SessionHookContext, p as SessionMessage, q as SessionRun, r as SessionStore, s as SessionTurn, t as SpawnHookContext, u as SqliteStoreOptions, w as StreamHookContext, T as ThinkingLevel, z as ToolContext, B as ToolDef, D as ToolExecutionMode, E as ToolHookContext, F as ToolMap, L as TurnUsage, N as autoDetectAndConvert, Q as connectMcpServers, U as createAgent, V as createMemoryStore, W as createRemoteStore, X as createSession, Y as createSqliteStore, Z as defineHarness, _ as fromAnthropic, $ as fromOpenAI, a0 as loadSession, a1 as noTools, a2 as toAnthropic, a3 as toOpenAI } from './agent-CXMcPke1.js';
 import { f as SpawnConfig, b as ExecutionContext } from './types-CKXAp41h.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, c as ExecutionHandle, S as SkillConfig, d as SkillResource, e as SkillsConfig } from './types-CKXAp41h.js';
 export { S as SandboxProvider, c as createSandboxContext } from './sandbox-DZn3ybp_.js';
 export { buildCatalog, defineSkill, discoverSkills, interpolateShellCommands, mergeSkillsConfig, parseSkillFile, resolveSkills, validateSkillName, writeSkillToDisk, writeSkillsToDisk } from './skills.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-Bm1ihQ_K.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-BUUQxLIp.js';
 import 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';
 

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   defineHarness,
   noTools
-} from "./chunk-KG63Q5KF.js";
+} from "./chunk-Z2NZSEBZ.js";
 import {
   createAgent,
   createDockerContext,
@@ -10,10 +10,10 @@ import {
   createSandboxContext,
   createSpawnTool,
   spawn
-} from "./chunk-F4BVVP67.js";
+} from "./chunk-GCALAOLD.js";
 import {
   connectMcpServers
-} from "./chunk-NNMWWSBY.js";
+} from "./chunk-5LOHDFK3.js";
 import {
   createMemoryStore,
   createRemoteStore,

package/dist/mcp.d.ts

@@ -1,4 +1,4 @@
 import 'hookable';
-export { M as McpConnection, j as McpServerConfig, F as connectMcpServers, a3 as resultToString } from './agent-0Tafyla0.js';
+export { M as McpConnection, j as McpServerConfig, Q as connectMcpServers, a9 as resultToString } from './agent-CXMcPke1.js';
 import '@modelcontextprotocol/sdk/client/index.js';
 import './types-CKXAp41h.js';

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   connectMcpServers,
   resultToString
-} from "./chunk-NNMWWSBY.js";
+} from "./chunk-5LOHDFK3.js";
 export {
   connectMcpServers,
   resultToString

package/dist/providers.d.ts

@@ -1,4 +1,4 @@
-export { f as AnthropicParams, C as CerebrasParams, O as OpenRouterParams, P as Provider, r as StreamCallbacks, s as StreamOptions, t as ToolCall, y as ToolResult, z as ToolSpec, B as TurnResult, _ as anthropic, $ as cerebras, a0 as openrouter } from './agent-0Tafyla0.js';
+export { f as AnthropicParams, C as CerebrasParams, O as OpenRouterParams, P as Provider, v as StreamCallbacks, x as StreamOptions, y as ToolCall, G as ToolResult, J as ToolSpec, K as TurnResult, a4 as anthropic, a5 as cerebras, a6 as openrouter } from './agent-CXMcPke1.js';
 import 'hookable';
 import './types-CKXAp41h.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/session.d.ts

@@ -1,4 +1,4 @@
-export { h as CreateSessionOptions, R as RemoteStoreOptions, S as Session, k as SessionContentBlock, l as SessionData, m as SessionMessage, n as SessionRun, o as SessionStore, p as SessionTurn, q as SqliteStoreOptions, E as autoDetectAndConvert, J as createMemoryStore, K as createRemoteStore, L as createSession, N as createSqliteStore, U as fromAnthropic, V as fromOpenAI, W as loadSession, Y as toAnthropic, Z as toOpenAI } from './agent-0Tafyla0.js';
+export { h as CreateSessionOptions, R as RemoteStoreOptions, S as Session, l as SessionContentBlock, m as SessionData, p as SessionMessage, q as SessionRun, r as SessionStore, s as SessionTurn, u as SqliteStoreOptions, N as autoDetectAndConvert, V as createMemoryStore, W as createRemoteStore, X as createSession, Y as createSqliteStore, _ as fromAnthropic, $ as fromOpenAI, a0 as loadSession, a2 as toAnthropic, a3 as toOpenAI } from './agent-CXMcPke1.js';
 import 'hookable';
 import './types-CKXAp41h.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/{spawn-Bm1ihQ_K.d.ts → spawn-BUUQxLIp.d.ts}

@@ -1,4 +1,4 @@
-import { v as ToolDef, i as HarnessConfig, e as AgentStats } from './agent-0Tafyla0.js';
+import { B as ToolDef, i as HarnessConfig, e as AgentStats } from './agent-CXMcPke1.js';
 
 /**
  * Interaction tool — lets the agent request structured input from the outside world.

package/dist/tools.d.ts

@@ -1,5 +1,5 @@
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-Bm1ihQ_K.js';
-import { v as ToolDef } from './agent-0Tafyla0.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-BUUQxLIp.js';
+import { B as ToolDef } from './agent-CXMcPke1.js';
 export { V as ValidationResult, v as validateToolArgs } from './validation-DOY_k7lW.js';
 import 'hookable';
 import './types-CKXAp41h.js';

package/dist/tools.js

@@ -7,8 +7,8 @@ import {
   spawn,
   validateToolArgs,
   writeFile
-} from "./chunk-F4BVVP67.js";
-import "./chunk-NNMWWSBY.js";
+} from "./chunk-GCALAOLD.js";
+import "./chunk-5LOHDFK3.js";
 import "./chunk-4C6Y56CC.js";
 export {
   createInteractionTool,

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-export { A as Agent, a as AgentBehavior, b as AgentHooks, c as AgentOptions, d as AgentRunOptions, e as AgentStats, f as AnthropicParams, C as CerebrasParams, g as ChildRunStats, h as CreateSessionOptions, H as Harness, i as HarnessConfig, I as ImageContent, M as McpConnection, j as McpServerConfig, O as OpenRouterParams, P as Provider, R as RemoteStoreOptions, S as Session, k as SessionContentBlock, l as SessionData, m as SessionMessage, n as SessionRun, o as SessionStore, p as SessionTurn, q as SqliteStoreOptions, r as StreamCallbacks, s as StreamOptions, T as ThinkingLevel, t as ToolCall, u as ToolContext, v as ToolDef, w as ToolExecutionMode, x as ToolMap, y as ToolResult, z as ToolSpec, B as TurnResult, D as TurnUsage } from './agent-0Tafyla0.js';
+export { A as Agent, a as AgentBehavior, b as AgentHooks, c as AgentOptions, d as AgentRunOptions, e as AgentStats, f as AnthropicParams, C as CerebrasParams, g as ChildRunStats, h as CreateSessionOptions, H as Harness, i as HarnessConfig, I as ImageContent, M as McpConnection, j as McpServerConfig, k as McpToolHookContext, O as OpenRouterParams, P as Provider, R as RemoteStoreOptions, S as Session, l as SessionContentBlock, m as SessionData, n as SessionEndStatus, o as SessionHookContext, p as SessionMessage, q as SessionRun, r as SessionStore, s as SessionTurn, t as SpawnHookContext, u as SqliteStoreOptions, v as StreamCallbacks, w as StreamHookContext, x as StreamOptions, T as ThinkingLevel, y as ToolCall, z as ToolContext, B as ToolDef, D as ToolExecutionMode, E as ToolHookContext, F as ToolMap, G as ToolResult, J as ToolSpec, K as TurnResult, L as TurnUsage } from './agent-CXMcPke1.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, b as ExecutionContext, c as ExecutionHandle, S as SkillConfig, d as SkillResource, e as SkillsConfig, f as SpawnConfig } from './types-CKXAp41h.js';
 export { S as SandboxProvider } from './sandbox-DZn3ybp_.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-Bm1ihQ_K.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-BUUQxLIp.js';
 export { V as ValidationResult } from './validation-DOY_k7lW.js';
 import 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,