zidane 1.1.5 → 1.2.0

package/dist/harnesses.d.ts

@@ -1,24 +1,7 @@
-import Anthropic from '@anthropic-ai/sdk';
-
-declare const _default: HarnessConfig;
-
-interface ToolDef {
-    spec: Anthropic.Tool;
-    execute: (input: Record<string, unknown>) => Promise<string>;
-}
-type ToolMap = Map<string, ToolDef>;
-interface HarnessConfig {
-    /** Display name for this harness */
-    name: string;
-    /** Default system prompt injected when no system is provided at run time */
-    system?: string;
-    /** Tool definitions available to the agent */
-    tools: Record<string, ToolDef>;
-}
-/**
- * Define a harness with a name, optional system prompt, and tools.
- */
-declare function defineHarness(config: HarnessConfig): HarnessConfig;
-type Harness = HarnessConfig;
-
-export { type Harness, type HarnessConfig, type ToolDef, type ToolMap, _default as basic, defineHarness };
+import '@anthropic-ai/sdk';
+import 'hookable';
+export { H as Harness, f as HarnessConfig, T as ToolContext, g as ToolDef, h as ToolMap, _ as basic, l as basicTools, k as defineHarness } from './agent-DvZm8U14.js';
+import './providers.js';
+import './types-4CFQ-6Qu.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import './session.js';

package/dist/harnesses.js

@@ -1,8 +1,13 @@
 import {
+  basicTools,
   basic_default,
   defineHarness
-} from "./chunk-ECE5USCO.js";
+} from "./chunk-34KXKPNN.js";
+import "./chunk-27EP7HB3.js";
+import "./chunk-26LIQARN.js";
+import "./chunk-PNKVD2UK.js";
 export {
   basic_default as basic,
+  basicTools,
   defineHarness
 };

package/dist/index.d.ts

@@ -1,89 +1,56 @@
-import { Hookable } from 'hookable';
-import { HarnessConfig } from './harnesses.js';
-export { Harness, ToolDef, ToolMap, defineHarness } from './harnesses.js';
-import { S as StreamOptions, M as Message, A as AgentStats, a as AgentRunOptions, P as Provider, T as ToolExecutionMode } from './index-ByJfS-kX.js';
-export { C as ContentBlock, I as ImageContent, b as ThinkingLevel } from './index-ByJfS-kX.js';
+import { S as SpawnConfig, E as ExecutionContext, a as ExecResult } from './agent-DvZm8U14.js';
+export { A as Agent, b as AgentHooks, c as AgentOptions, C as ContextCapabilities, d as ContextType, e as ExecutionHandle, H as Harness, f as HarnessConfig, M as McpConnection, T as ToolContext, g as ToolDef, h as ToolMap, i as connectMcpServers, j as createAgent, k as defineHarness } from './agent-DvZm8U14.js';
+export { CreateSessionOptions, RemoteStoreOptions, Session, SessionData, SessionRun, SessionStore, SqliteStoreOptions, autoDetectAndConvert, createMemoryStore, createRemoteStore, createSession, createSqliteStore, fromAnthropic, fromOpenAI, loadSession, toAnthropic, toOpenAI } from './session.js';
+export { C as ChildAgent, S as SpawnToolOptions, a as SpawnToolState, c as createSpawnTool, s as spawn } from './spawn-pP2grsVp.js';
+export { A as AgentRunOptions, a as AgentStats, I as ImageContent, M as McpServerConfig, S as SessionContentBlock, b as SessionMessage, T as ThinkingLevel, c as ToolExecutionMode, d as TurnUsage } from './types-4CFQ-6Qu.js';
+import 'hookable';
 import '@anthropic-ai/sdk';
+import '@modelcontextprotocol/sdk/client/index.js';
+import './providers.js';
 
 /**
- * Agent creation and state management.
+ * Docker execution context.
+ *
+ * Runs tools inside a Docker container via dockerode.
+ * Full isolation with configurable resource limits.
+ *
+ * Requires `dockerode` as an optional peer dependency.
  */
 
-interface AgentHooks {
-    'system:before': (ctx: {
-        system: string;
-    }) => void;
-    'turn:before': (ctx: {
-        turn: number;
-        options: StreamOptions;
-    }) => void;
-    'turn:after': (ctx: {
-        turn: number;
-        usage: {
-            input: number;
-            output: number;
-        };
-    }) => void;
-    'stream:text': (ctx: {
-        delta: string;
-        text: string;
-    }) => void;
-    'stream:end': (ctx: {
-        text: string;
-    }) => void;
-    'tool:before': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
-    }) => void;
-    'tool:after': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
-        result: string;
-    }) => void;
-    'tool:error': (ctx: {
-        name: string;
-        input: Record<string, unknown>;
-        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>;
-        result: string;
-        isError: boolean;
-    }) => void;
-    'context:transform': (ctx: {
-        messages: Message[];
-    }) => void;
-    'steer:inject': (ctx: {
-        message: string;
-    }) => void;
-    'agent:abort': (ctx: object) => void;
-    'agent:done': (ctx: AgentStats) => void;
-}
-interface AgentOptions {
-    harness: HarnessConfig;
-    provider: Provider;
-    /** Tool execution mode: 'sequential' (default) or 'parallel' */
-    toolExecution?: ToolExecutionMode;
-}
-interface Agent {
-    hooks: Hookable<AgentHooks>;
-    run: (options: AgentRunOptions) => Promise<AgentStats>;
-    abort: () => void;
-    steer: (message: string) => void;
-    followUp: (message: string) => void;
-    waitForIdle: () => Promise<void>;
-    reset: () => void;
-    readonly isRunning: boolean;
-    readonly messages: Message[];
-    meta: Record<string, unknown>;
+declare function createDockerContext(config?: SpawnConfig): ExecutionContext;
+
+/**
+ * In-process execution context.
+ *
+ * Runs everything in the current Node/Bun process.
+ * No isolation — fastest, used as the default.
+ */
+
+declare function createProcessContext(config?: SpawnConfig): ExecutionContext;
+
+/**
+ * Remote sandbox execution context.
+ *
+ * Offloads execution to a remote sandbox API (e.g. Rivet, E2B).
+ * Specific providers implement the SandboxProvider interface.
+ */
+
+interface SandboxProvider {
+    name: string;
+    spawn: (config: SpawnConfig) => Promise<{
+        id: string;
+        cwd: string;
+    }>;
+    exec: (sandboxId: string, command: string, options?: {
+        cwd?: string;
+        env?: Record<string, string>;
+        timeout?: number;
+    }) => Promise<ExecResult>;
+    readFile: (sandboxId: string, path: string) => Promise<string>;
+    writeFile: (sandboxId: string, path: string, content: string) => Promise<void>;
+    listFiles: (sandboxId: string, path: string) => Promise<string[]>;
+    destroy: (sandboxId: string) => Promise<void>;
 }
-declare function createAgent({ harness, provider, toolExecution }: AgentOptions): Agent;
+declare function createSandboxContext(provider: SandboxProvider): ExecutionContext;
 
-export { type Agent, type AgentHooks, type AgentOptions, AgentRunOptions, AgentStats, HarnessConfig, ToolExecutionMode, createAgent };
+export { ExecResult, ExecutionContext, type SandboxProvider, SpawnConfig, createDockerContext, createProcessContext, createSandboxContext };

package/dist/index.js

@@ -1,261 +1,57 @@
 import {
   defineHarness
-} from "./chunk-ECE5USCO.js";
-
-// src/agent.ts
-import { createHooks } from "hookable";
-
-// src/tools/validation.ts
-function validateToolArgs(input, schema) {
-  const required = schema.required ?? [];
-  for (const field of required) {
-    if (!(field in input) || input[field] === void 0 || input[field] === null) {
-      return { valid: false, error: `Missing required field: ${field}` };
-    }
-  }
-  return { valid: true };
-}
-
-// src/loop.ts
-async function runLoop(ctx) {
-  let totalIn = 0;
-  let totalOut = 0;
-  const startTime = Date.now();
-  const maxTurns = 50;
-  for (let turn = 0; turn < maxTurns; turn++) {
-    if (ctx.signal.aborted) {
-      await ctx.hooks.callHook("agent:abort", {});
-      break;
-    }
-    const result = await executeTurn(ctx, turn);
-    totalIn += result.usage.input;
-    totalOut += result.usage.output;
-    if (ctx.signal.aborted) {
-      await ctx.hooks.callHook("agent:abort", {});
-      break;
-    }
-    if (ctx.steeringQueue.length > 0) {
-      const steerMsg = ctx.steeringQueue.shift();
-      await ctx.hooks.callHook("steer:inject", { message: steerMsg });
-      ctx.messages.push(ctx.provider.userMessage(steerMsg));
-      continue;
-    }
-    if (result.ended) {
-      if (ctx.followUpQueue.length > 0) {
-        const followUp = ctx.followUpQueue.shift();
-        await ctx.hooks.callHook("steer:inject", { message: followUp });
-        ctx.messages.push(ctx.provider.userMessage(followUp));
-        continue;
-      }
-      return { totalIn, totalOut, turns: turn + 1, elapsed: Date.now() - startTime };
-    }
-  }
-  const stats = { totalIn, totalOut, turns: maxTurns, elapsed: Date.now() - startTime };
-  await ctx.hooks.callHook("agent:done", stats);
-  return stats;
-}
-async function executeTurn(ctx, turn) {
-  const streamOptions = {
-    model: ctx.model,
-    system: ctx.system,
-    tools: ctx.formattedTools,
-    messages: ctx.messages,
-    maxTokens: 16384,
-    thinking: ctx.thinking,
-    signal: ctx.signal
-  };
-  await ctx.hooks.callHook("context:transform", { messages: ctx.messages });
-  await ctx.hooks.callHook("turn:before", { turn, options: streamOptions });
-  let currentText = "";
-  const result = await ctx.provider.stream(
-    streamOptions,
-    {
-      onText(delta) {
-        currentText += delta;
-        ctx.hooks.callHook("stream:text", { delta, text: currentText });
-      }
-    }
-  );
-  if (currentText) {
-    await ctx.hooks.callHook("stream:end", { text: currentText });
-  }
-  await ctx.hooks.callHook("turn:after", { turn, usage: result.usage });
-  if (result.done) {
-    return { ended: true, usage: result.usage };
-  }
-  ctx.messages.push({ role: "assistant", content: result.assistantMessage });
-  const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, result.toolCalls) : await executeToolsSequential(ctx, result.toolCalls);
-  ctx.messages.push(ctx.provider.toolResultsMessage(toolResults));
-  return { ended: false, usage: result.usage };
-}
-async function executeSingleTool(ctx, call) {
-  const toolDef = ctx.tools[call.name];
-  const gateCtx = { 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}` }, steered: false };
-  }
-  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}` }, steered: false };
-  }
-  const validation = validateToolArgs(call.input, toolDef.spec.input_schema);
-  if (!validation.valid) {
-    return { result: { id: call.id, content: `Validation error: ${validation.error}` }, steered: false };
-  }
-  await ctx.hooks.callHook("tool:before", { name: call.name, input: call.input });
-  let output;
-  let isError = false;
-  try {
-    output = await toolDef.execute(call.input);
-  } catch (err) {
-    await ctx.hooks.callHook("tool:error", { 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 };
-  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 }, steered: false };
-}
-async function executeToolsSequential(ctx, toolCalls) {
-  const results = [];
-  for (const call of toolCalls) {
-    if (ctx.signal.aborted)
-      break;
-    if (ctx.steeringQueue.length > 0) {
-      const steerMsg = ctx.steeringQueue.shift();
-      await ctx.hooks.callHook("steer:inject", { message: steerMsg });
-      for (const skipped of toolCalls.slice(toolCalls.indexOf(call))) {
-        results.push({ id: skipped.id, content: "Skipped: steering message received" });
-      }
-      ctx.messages.push(ctx.provider.toolResultsMessage(results));
-      ctx.messages.push(ctx.provider.userMessage(steerMsg));
-      return [];
-    }
-    const { result } = await executeSingleTool(ctx, call);
-    results.push(result);
-  }
-  return results;
-}
-async function executeToolsParallel(ctx, toolCalls) {
-  const executions = toolCalls.map((call) => executeSingleTool(ctx, call));
-  const settled = await Promise.all(executions);
-  return settled.map((s) => s.result);
-}
+} from "./chunk-34KXKPNN.js";
+import {
+  createAgent,
+  createDockerContext,
+  createProcessContext,
+  createSandboxContext,
+  createSpawnTool,
+  init_agent,
+  init_contexts,
+  spawn
+} from "./chunk-27EP7HB3.js";
+import {
+  connectMcpServers,
+  init_mcp
+} from "./chunk-26LIQARN.js";
+import {
+  createMemoryStore,
+  createRemoteStore,
+  createSession,
+  createSqliteStore,
+  loadSession
+} from "./chunk-LMSOIIAT.js";
+import {
+  autoDetectAndConvert,
+  fromAnthropic,
+  fromOpenAI,
+  toAnthropic,
+  toOpenAI
+} from "./chunk-LS57GDAV.js";
+import "./chunk-PNKVD2UK.js";
 
-// src/agent.ts
-function createAgent({ harness, provider, toolExecution = "sequential" }) {
-  const hooks = createHooks();
-  let abortController;
-  let running = false;
-  let idleResolve;
-  let idlePromise;
-  const steeringQueue = [];
-  const followUpQueue = [];
-  let conversationMessages = [];
-  async function run(options) {
-    if (running) {
-      throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
-    }
-    running = true;
-    abortController = new AbortController();
-    idlePromise = new Promise((resolve) => {
-      idleResolve = resolve;
-    });
-    const thinking = options.thinking ?? "off";
-    const model = options.model ?? provider.meta.defaultModel;
-    const system = options.system || harness.system || "You are a helpful assistant.";
-    const tools = harness.tools;
-    const toolSpecs = Object.values(tools).map(
-      (t) => ({
-        name: t.spec.name,
-        description: t.spec.description || "",
-        input_schema: t.spec.input_schema
-      })
-    );
-    const formattedTools = provider.formatTools(toolSpecs);
-    const messages = [];
-    if (options.system) {
-      await hooks.callHook("system:before", { system: options.system });
-      messages.push(provider.userMessage(options.system));
-      messages.push(provider.assistantMessage("Understood. I will proceed with these instructions above the rest of my system prompt."));
-    }
-    messages.push(provider.userMessage(options.prompt, options.images));
-    conversationMessages = messages;
-    try {
-      const stats = await runLoop({
-        provider,
-        hooks,
-        tools,
-        toolSpecs,
-        formattedTools,
-        model,
-        system,
-        thinking,
-        toolExecution,
-        signal: abortController.signal,
-        steeringQueue,
-        followUpQueue,
-        messages
-      });
-      await hooks.callHook("agent:done", stats);
-      return stats;
-    } catch (err) {
-      if (abortController.signal.aborted) {
-        const stats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: 0 };
-        await hooks.callHook("agent:done", stats);
-        return stats;
-      }
-      throw err;
-    } finally {
-      running = false;
-      abortController = void 0;
-      steeringQueue.length = 0;
-      followUpQueue.length = 0;
-      idleResolve?.();
-      idlePromise = void 0;
-      idleResolve = void 0;
-    }
-  }
-  function abort() {
-    abortController?.abort();
-  }
-  function steer(message) {
-    steeringQueue.push(message);
-  }
-  function followUpFn(message) {
-    followUpQueue.push(message);
-  }
-  function waitForIdle() {
-    return idlePromise ?? Promise.resolve();
-  }
-  function reset() {
-    conversationMessages = [];
-    steeringQueue.length = 0;
-    followUpQueue.length = 0;
-  }
-  return {
-    hooks,
-    run,
-    abort,
-    steer,
-    followUp: followUpFn,
-    waitForIdle,
-    reset,
-    get isRunning() {
-      return running;
-    },
-    get messages() {
-      return conversationMessages;
-    },
-    meta: provider.meta
-  };
-}
+// src/index.ts
+init_agent();
+init_contexts();
+init_mcp();
 export {
+  autoDetectAndConvert,
+  connectMcpServers,
   createAgent,
-  defineHarness
+  createDockerContext,
+  createMemoryStore,
+  createProcessContext,
+  createRemoteStore,
+  createSandboxContext,
+  createSession,
+  createSpawnTool,
+  createSqliteStore,
+  defineHarness,
+  fromAnthropic,
+  fromOpenAI,
+  loadSession,
+  spawn,
+  toAnthropic,
+  toOpenAI
 };

package/dist/mcp.d.ts

@@ -0,0 +1,7 @@
+import 'hookable';
+export { M as McpConnection, i as connectMcpServers, r as resultToString } from './agent-DvZm8U14.js';
+export { M as McpServerConfig } from './types-4CFQ-6Qu.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@anthropic-ai/sdk';
+import './providers.js';
+import './session.js';

package/dist/mcp.js

@@ -0,0 +1,11 @@
+import {
+  connectMcpServers,
+  init_mcp,
+  resultToString
+} from "./chunk-26LIQARN.js";
+import "./chunk-PNKVD2UK.js";
+init_mcp();
+export {
+  connectMcpServers,
+  resultToString
+};

package/dist/providers.d.ts

@@ -1 +1,65 @@
-export { M as Message, P as Provider, c as StreamCallbacks, S as StreamOptions, d as ToolCall, e as ToolResult, f as ToolSpec, g as TurnResult, h as anthropic, i as cerebras, o as openrouter } from './index-ByJfS-kX.js';
+import { b as SessionMessage, T as ThinkingLevel, I as ImageContent, d as TurnUsage } from './types-4CFQ-6Qu.js';
+
+declare function anthropic(): Provider;
+
+declare function cerebras(defaultModel?: string): Provider;
+
+declare function openrouter(defaultModel?: string): Provider;
+
+interface ToolSpec {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResult {
+    id: string;
+    content: string;
+}
+interface StreamCallbacks {
+    onText: (delta: string) => void;
+}
+interface TurnResult {
+    /** Full assistant turn as a SessionMessage */
+    assistantMessage: SessionMessage;
+    /** Text content blocks concatenated */
+    text: string;
+    /** Tool calls requested by the model */
+    toolCalls: ToolCall[];
+    /** Whether the model wants to stop */
+    done: boolean;
+    usage: TurnUsage;
+}
+interface StreamOptions {
+    model: string;
+    system: string;
+    tools: unknown[];
+    messages: SessionMessage[];
+    maxTokens: number;
+    /** Thinking/reasoning level (optional, default: off) */
+    thinking?: ThinkingLevel;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+}
+interface Provider {
+    readonly name: string;
+    readonly meta: {
+        defaultModel: string;
+    } & Record<string, unknown>;
+    /** Format tool specs for this provider */
+    formatTools: (tools: ToolSpec[]) => unknown[];
+    /** Create a user message (text or with images) */
+    userMessage: (content: string, images?: ImageContent[]) => SessionMessage;
+    /** Create an assistant message (for priming) */
+    assistantMessage: (content: string) => SessionMessage;
+    /** Create a tool results message to send back */
+    toolResultsMessage: (results: ToolResult[]) => SessionMessage;
+    /** Stream a turn, calling onText for each text delta */
+    stream: (options: StreamOptions, callbacks: StreamCallbacks) => Promise<TurnResult>;
+}
+
+export { type Provider, type StreamCallbacks, type StreamOptions, type ToolCall, type ToolResult, type ToolSpec, type TurnResult, anthropic, cerebras, openrouter };