zidane 1.1.5 → 1.2.0

package/dist/providers.js

@@ -1,3 +1,16 @@
+import {
+  assistantMessage,
+  buildAssistantContent,
+  consumeSSE,
+  formatTools,
+  fromAnthropic,
+  toAnthropic,
+  toOAIMessages,
+  toolResultsMessage,
+  userMessage
+} from "./chunk-LS57GDAV.js";
+import "./chunk-PNKVD2UK.js";
+
 // src/providers/anthropic.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
@@ -47,31 +60,30 @@ function anthropic() {
     },
     userMessage(content, images) {
       if (images && images.length > 0) {
-        const blocks = [
-          ...images.map((img) => ({
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: img.source.media_type,
+        return {
+          role: "user",
+          content: [
+            ...images.map((img) => ({
+              type: "image",
+              mediaType: img.source.media_type,
               data: img.source.data
-            }
-          })),
-          { type: "text", text: content }
-        ];
-        return { role: "user", content: blocks };
+            })),
+            { type: "text", text: content }
+          ]
+        };
       }
-      return { role: "user", content };
+      return { role: "user", content: [{ type: "text", text: content }] };
     },
     assistantMessage(content) {
-      return { role: "assistant", content };
+      return { role: "assistant", content: [{ type: "text", text: content }] };
     },
     toolResultsMessage(results) {
       return {
         role: "user",
         content: results.map((r) => ({
           type: "tool_result",
-          tool_use_id: r.id,
-          content: r.content
+          callId: r.id,
+          output: r.content
         }))
       };
     },
@@ -82,8 +94,8 @@ function anthropic() {
       if (isOAuth) {
         system = `You are Claude Code, Anthropic's official CLI for Claude.`;
         messages.unshift(
-          { role: "user", content: options.system },
-          { role: "assistant", content: "Understood. I will proceed with these instructions above the rest of my system prompt." }
+          { role: "user", content: [{ type: "text", text: options.system }] },
+          { role: "assistant", content: [{ type: "text", text: "Understood. I will proceed with these instructions above the rest of my system prompt." }] }
         );
       }
       const params = {
@@ -91,7 +103,7 @@ function anthropic() {
         max_tokens: options.maxTokens ?? 16384,
         system,
         tools: options.tools,
-        messages,
+        messages: messages.map((m) => toAnthropic(m)),
         stream: true
       };
       if (thinking !== "off") {
@@ -113,152 +125,20 @@ function anthropic() {
       const response = await s.finalMessage();
       const toolCalls = response.content.filter((b) => b.type === "tool_use").map((b) => ({ id: b.id, name: b.name, input: b.input }));
       return {
-        assistantMessage: response.content,
+        assistantMessage: fromAnthropic({ role: "assistant", content: response.content }),
         text,
         toolCalls,
         done: response.stop_reason === "end_turn" || toolCalls.length === 0,
-        usage: { input: response.usage.input_tokens, output: response.usage.output_tokens }
-      };
-    }
-  };
-}
-
-// src/providers/openai-compat.ts
-var TOOL_RESULTS_TAG = "__zidane_tool_results__";
-var ASSISTANT_TOOL_CALLS_TAG = "__zidane_assistant_tc__";
-function convertImageContent(img) {
-  return {
-    type: "image_url",
-    image_url: { url: `data:${img.source.media_type};base64,${img.source.data}` }
-  };
-}
-async function consumeSSE(response, callbacks, signal) {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let text = "";
-  let finishReason = "stop";
-  let usage = { input: 0, output: 0 };
-  const tcMap = /* @__PURE__ */ new Map();
-  try {
-    while (true) {
-      if (signal?.aborted)
-        break;
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.startsWith("data: "))
-          continue;
-        const data = line.slice(6).trim();
-        if (data === "[DONE]")
-          continue;
-        let chunk;
-        try {
-          chunk = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        const choice = chunk.choices?.[0];
-        if (!choice)
-          continue;
-        if (choice.finish_reason)
-          finishReason = choice.finish_reason;
-        if (choice.delta?.content) {
-          text += choice.delta.content;
-          callbacks.onText(choice.delta.content);
+        usage: {
+          input: response.usage.input_tokens,
+          output: response.usage.output_tokens,
+          cacheCreation: response.usage.cache_creation_input_tokens ?? void 0,
+          cacheRead: response.usage.cache_read_input_tokens ?? void 0
         }
-        if (choice.delta?.tool_calls) {
-          for (const tc of choice.delta.tool_calls) {
-            const existing = tcMap.get(tc.index);
-            if (existing) {
-              if (tc.function?.arguments)
-                existing.args += tc.function.arguments;
-            } else {
-              tcMap.set(tc.index, {
-                id: tc.id || `call_${tc.index}`,
-                name: tc.function?.name || "",
-                args: tc.function?.arguments || ""
-              });
-            }
-          }
-        }
-        if (chunk.usage)
-          usage = { input: chunk.usage.prompt_tokens, output: chunk.usage.completion_tokens };
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const toolCalls = Array.from(tcMap.values()).map((tc) => ({
-    id: tc.id,
-    name: tc.name,
-    input: tc.args ? JSON.parse(tc.args) : {}
-  }));
-  return { text, toolCalls, finishReason, usage };
-}
-function toOAIMessages(system, messages) {
-  const out = [{ role: "system", content: system }];
-  for (const msg of messages) {
-    const c = msg.content;
-    if (c?._tag === TOOL_RESULTS_TAG) {
-      for (const tr of c.results) {
-        out.push({ role: "tool", tool_call_id: tr.tool_call_id, content: tr.content });
-      }
-      continue;
-    }
-    if (c?._tag === ASSISTANT_TOOL_CALLS_TAG) {
-      out.push({ role: "assistant", content: c.text || null, tool_calls: c.tool_calls });
-      continue;
-    }
-    out.push({ role: msg.role, content: msg.content });
-  }
-  return out;
-}
-function formatTools(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: { name: t.name, description: t.description, parameters: t.input_schema }
-  }));
-}
-function userMessage(content, images) {
-  if (images?.length) {
-    return {
-      role: "user",
-      content: [...images.map(convertImageContent), { type: "text", text: content }]
-    };
-  }
-  return { role: "user", content };
-}
-function assistantMessage(content) {
-  return { role: "assistant", content };
-}
-function toolResultsMessage(results) {
-  return {
-    role: "user",
-    content: {
-      _tag: TOOL_RESULTS_TAG,
-      results: results.map((r) => ({ tool_call_id: r.id, content: r.content }))
+      };
     }
   };
 }
-function buildAssistantContent(text, toolCalls) {
-  if (toolCalls.length > 0) {
-    return {
-      _tag: ASSISTANT_TOOL_CALLS_TAG,
-      text: text || null,
-      tool_calls: toolCalls.map((tc) => ({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.name, arguments: JSON.stringify(tc.input) }
-      }))
-    };
-  }
-  return text;
-}
 
 // src/providers/cerebras.ts
 var BASE_URL = "https://api.cerebras.ai/v1";

package/dist/session.d.ts

@@ -0,0 +1,167 @@
+import { b as SessionMessage, d as TurnUsage } from './types-4CFQ-6Qu.js';
+export { S as SessionContentBlock } from './types-4CFQ-6Qu.js';
+
+/**
+ * In-memory session store.
+ * Useful for development and testing. Data is lost when the process exits.
+ */
+
+declare function createMemoryStore(): SessionStore;
+
+/**
+ * Canonical SessionMessage format with converters from/to Anthropic and OpenAI-compat formats.
+ */
+
+declare function fromAnthropic(msg: {
+    role: string;
+    content: unknown;
+}): SessionMessage;
+declare function fromOpenAI(msg: {
+    role: string;
+    content: unknown;
+}): SessionMessage;
+declare function toAnthropic(msg: SessionMessage): {
+    role: string;
+    content: unknown;
+};
+declare function toOpenAI(msg: SessionMessage): {
+    role: string;
+    content: unknown;
+};
+declare function autoDetectAndConvert(msg: {
+    role: string;
+    content: unknown;
+}): SessionMessage;
+
+/**
+ * Remote session store via HTTP API.
+ *
+ * Expects a REST API with:
+ *   GET    {url}/sessions/{id}          -> SessionData | 404
+ *   PUT    {url}/sessions/{id}          -> save SessionData
+ *   DELETE {url}/sessions/{id}          -> delete
+ *   GET    {url}/sessions?agentId=&limit= -> { ids: string[] }
+ */
+
+interface RemoteStoreOptions {
+    /** Base URL of the session API */
+    url: string;
+    /** Optional headers (e.g. for authentication) */
+    headers?: Record<string, string>;
+}
+declare function createRemoteStore(options: RemoteStoreOptions): SessionStore;
+
+/**
+ * SQLite session store using Bun's built-in bun:sqlite.
+ */
+
+interface SqliteStoreOptions {
+    /** Path to the SQLite database file */
+    path: string;
+}
+declare function createSqliteStore(options: SqliteStoreOptions): SessionStore;
+
+/**
+ * Session management for agents.
+ *
+ * A session tracks identity, message history, and run metadata.
+ * Plug in any storage backend by implementing the SessionStore interface,
+ * or use one of the built-in stores: memory, sqlite, remote.
+ */
+
+interface SessionRun {
+    id: string;
+    startedAt: number;
+    endedAt?: number;
+    prompt: string;
+    status: 'running' | 'completed' | 'aborted' | 'error';
+    turns?: number;
+    tokensIn?: number;
+    tokensOut?: number;
+    error?: string;
+    /** Per-turn usage breakdown */
+    turnUsage?: TurnUsage[];
+    /** Total usage across all turns */
+    totalUsage?: TurnUsage;
+    /** Estimated cost in USD */
+    cost?: number;
+}
+interface SessionData {
+    id: string;
+    agentId?: string;
+    messages: SessionMessage[];
+    runs: SessionRun[];
+    metadata: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+}
+interface SessionStore {
+    /** Load a session by ID. Returns null if not found. */
+    load: (sessionId: string) => Promise<SessionData | null>;
+    /** Save a session (create or update). */
+    save: (session: SessionData) => Promise<void>;
+    /** Delete a session. */
+    delete: (sessionId: string) => Promise<void>;
+    /** List session IDs, optionally filtered by agentId. */
+    list: (filter?: {
+        agentId?: string;
+        limit?: number;
+    }) => Promise<string[]>;
+}
+interface Session {
+    /** Session ID */
+    readonly id: string;
+    /** Agent ID (optional label) */
+    readonly agentId?: string;
+    /** Current message history */
+    readonly messages: SessionMessage[];
+    /** All runs in this session */
+    readonly runs: SessionRun[];
+    /** Arbitrary metadata */
+    readonly metadata: Record<string, unknown>;
+    /** Start tracking a new run */
+    startRun: (runId: string, prompt: string) => void;
+    /** Mark a run as completed */
+    completeRun: (runId: string, stats: {
+        turns: number;
+        tokensIn: number;
+        tokensOut: number;
+        turnUsage?: TurnUsage[];
+        cost?: number;
+    }) => void;
+    /** Mark a run as aborted */
+    abortRun: (runId: string) => void;
+    /** Mark a run as errored */
+    errorRun: (runId: string, error: string) => void;
+    /** Append messages to the session history */
+    pushMessages: (messages: SessionMessage[]) => void;
+    /** Replace all messages (e.g. after context:transform) */
+    setMessages: (messages: SessionMessage[]) => void;
+    /** Set metadata key */
+    setMeta: (key: string, value: unknown) => void;
+    /** Persist the session to the store */
+    save: () => Promise<void>;
+    /** Serialize to SessionData */
+    toJSON: () => SessionData;
+}
+interface CreateSessionOptions {
+    /** Session ID (auto-generated if not provided) */
+    id?: string;
+    /** Agent ID label */
+    agentId?: string;
+    /** Initial metadata */
+    metadata?: Record<string, unknown>;
+    /** Storage backend (optional, enables save/load) */
+    store?: SessionStore;
+    _data?: SessionData;
+}
+/**
+ * Create a new session.
+ */
+declare function createSession(options?: CreateSessionOptions): Session;
+/**
+ * Load an existing session from a store.
+ */
+declare function loadSession(store: SessionStore, sessionId: string): Promise<Session | null>;
+
+export { type CreateSessionOptions, type RemoteStoreOptions, type Session, type SessionData, SessionMessage, type SessionRun, type SessionStore, type SqliteStoreOptions, autoDetectAndConvert, createMemoryStore, createRemoteStore, createSession, createSqliteStore, fromAnthropic, fromOpenAI, loadSession, toAnthropic, toOpenAI };

package/dist/session.js

@@ -0,0 +1,27 @@
+import {
+  createMemoryStore,
+  createRemoteStore,
+  createSession,
+  createSqliteStore,
+  loadSession
+} from "./chunk-LMSOIIAT.js";
+import {
+  autoDetectAndConvert,
+  fromAnthropic,
+  fromOpenAI,
+  toAnthropic,
+  toOpenAI
+} from "./chunk-LS57GDAV.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  autoDetectAndConvert,
+  createMemoryStore,
+  createRemoteStore,
+  createSession,
+  createSqliteStore,
+  fromAnthropic,
+  fromOpenAI,
+  loadSession,
+  toAnthropic,
+  toOpenAI
+};

package/dist/spawn-pP2grsVp.d.ts

@@ -0,0 +1,63 @@
+import { f as HarnessConfig, g as ToolDef } from './agent-DvZm8U14.js';
+import { a as AgentStats } from './types-4CFQ-6Qu.js';
+
+/**
+ * Spawn tool — create sub-agents from a parent agent.
+ *
+ * A static tool that reads provider and harness from ToolContext.
+ * Just add it to any harness's tools — no factory needed.
+ *
+ * Usage:
+ *   import { spawn } from 'zidane'
+ *
+ *   const harness = defineHarness({
+ *     name: 'orchestrator',
+ *     tools: { ...basicTools, spawn },
+ *   })
+ */
+
+interface ChildAgent {
+    id: string;
+    task: string;
+    startedAt: number;
+}
+interface SpawnToolState {
+    /** Currently running children */
+    readonly children: ReadonlyMap<string, ChildAgent>;
+    /** Aggregated stats from all completed children (returns a copy) */
+    readonly totalChildStats: Readonly<AgentStats>;
+}
+/**
+ * Static spawn tool — add directly to any harness.
+ *
+ * Reads provider and harness from ToolContext at execution time.
+ * Children get the same harness as the parent (including spawn),
+ * so sub-agents can spawn their own children.
+ */
+declare const spawn: ToolDef & SpawnToolState;
+interface SpawnToolOptions {
+    /** Maximum concurrent sub-agents (default: 3) */
+    maxConcurrent?: number;
+    /** Model override for child agents */
+    model?: string;
+    /** System prompt for child agents */
+    system?: string;
+    /** Thinking level for child agents */
+    thinking?: 'off' | 'minimal' | 'low' | 'medium' | 'high';
+    /** Override harness for children (defaults to parent's harness from ToolContext) */
+    harness?: HarnessConfig;
+    /** Called when a child agent starts */
+    onSpawn?: (child: ChildAgent) => void;
+    /** Called when a child agent completes */
+    onComplete?: (child: ChildAgent, stats: AgentStats) => void;
+}
+/**
+ * Create a configured spawn tool with custom options.
+ *
+ * For most cases, use the static `spawn` export directly.
+ * Use this factory when you need custom concurrency limits,
+ * model overrides, or lifecycle callbacks.
+ */
+declare function createSpawnTool(options?: SpawnToolOptions): ToolDef & SpawnToolState;
+
+export { type ChildAgent as C, type SpawnToolOptions as S, type SpawnToolState as a, createSpawnTool as c, spawn as s };

package/dist/tools.d.ts

@@ -0,0 +1,28 @@
+import { g as ToolDef } from './agent-DvZm8U14.js';
+export { C as ChildAgent, S as SpawnToolOptions, a as SpawnToolState, c as createSpawnTool, s as spawn } from './spawn-pP2grsVp.js';
+import 'hookable';
+import '@anthropic-ai/sdk';
+import './types-4CFQ-6Qu.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import './providers.js';
+import './session.js';
+
+declare const listFiles: ToolDef;
+
+declare const readFile: ToolDef;
+
+declare const shell: ToolDef;
+
+/**
+ * Simple tool argument validation against JSON Schema-style input_schema.
+ * Checks required fields are present; type coercion is left to the tools themselves.
+ */
+interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+declare function validateToolArgs(input: Record<string, unknown>, schema: Record<string, unknown>): ValidationResult;
+
+declare const writeFile: ToolDef;
+
+export { type ValidationResult, listFiles, readFile, shell, validateToolArgs, writeFile };

package/dist/tools.js

@@ -0,0 +1,20 @@
+import {
+  createSpawnTool,
+  listFiles,
+  readFile,
+  shell,
+  spawn,
+  validateToolArgs,
+  writeFile
+} from "./chunk-27EP7HB3.js";
+import "./chunk-26LIQARN.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  createSpawnTool,
+  listFiles,
+  readFile,
+  shell,
+  spawn,
+  validateToolArgs,
+  writeFile
+};

package/dist/types-4CFQ-6Qu.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Shared types for the agent system.
+ */
+type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high';
+interface McpServerConfig {
+    /** Display name (used for tool namespacing) */
+    name: string;
+    /** Transport type */
+    transport: 'stdio' | 'sse' | 'streamable-http';
+    /** For stdio: command to run */
+    command?: string;
+    /** For stdio: command arguments */
+    args?: string[];
+    /** For stdio: environment variables */
+    env?: Record<string, string>;
+    /** For sse/streamable-http: server URL */
+    url?: string;
+    /** Optional headers for HTTP transports */
+    headers?: Record<string, string>;
+}
+type ToolExecutionMode = 'sequential' | 'parallel';
+interface ImageContent {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+}
+type SessionContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    mediaType: string;
+    data: string;
+} | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    callId: string;
+    output: string;
+    isError?: boolean;
+} | {
+    type: 'thinking';
+    text: string;
+};
+interface SessionMessage {
+    role: 'user' | 'assistant';
+    content: SessionContentBlock[];
+}
+interface AgentRunOptions {
+    model?: string;
+    prompt: string;
+    system?: string;
+    thinking?: ThinkingLevel;
+    images?: ImageContent[];
+    /** Abort signal — when triggered, the agent stops after the current turn */
+    signal?: AbortSignal;
+}
+interface TurnUsage {
+    input: number;
+    output: number;
+    /** Tokens written to cache (Anthropic) */
+    cacheCreation?: number;
+    /** Tokens read from cache (Anthropic) */
+    cacheRead?: number;
+    /** Thinking/reasoning tokens used */
+    thinking?: number;
+    /** Cost in USD as reported by the provider (OpenRouter) */
+    cost?: number;
+}
+interface AgentStats {
+    totalIn: number;
+    totalOut: number;
+    turns: number;
+    elapsed: number;
+    /** Per-turn usage breakdown */
+    turnUsage?: TurnUsage[];
+    /** Total cost in USD (sum of per-turn costs reported by provider) */
+    cost?: number;
+    /** Stats from child agents spawned during this run */
+    children?: ChildRunStats[];
+}
+interface ChildRunStats {
+    id: string;
+    task: string;
+    stats: AgentStats;
+}
+
+export type { AgentRunOptions as A, ChildRunStats as C, ImageContent as I, McpServerConfig as M, SessionContentBlock as S, ThinkingLevel as T, AgentStats as a, SessionMessage as b, ToolExecutionMode as c, TurnUsage as d };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,
@@ -23,9 +23,21 @@
       "import": "./dist/providers.js",
       "types": "./dist/providers.d.ts"
     },
+    "./tools": {
+      "import": "./dist/tools.js",
+      "types": "./dist/tools.d.ts"
+    },
     "./harnesses": {
       "import": "./dist/harnesses.js",
       "types": "./dist/harnesses.d.ts"
+    },
+    "./mcp": {
+      "import": "./dist/mcp.js",
+      "types": "./dist/mcp.d.ts"
+    },
+    "./session": {
+      "import": "./dist/session.js",
+      "types": "./dist/session.d.ts"
     }
   },
   "main": "./dist/index.js",
@@ -44,6 +56,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.80.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "@yaelg/pi-ai": "^0.58.4",
     "chalk": "^5.6.2",
     "hookable": "^6.1.0",
@@ -52,6 +65,7 @@
   "devDependencies": {
     "@antfu/eslint-config": "^7.7.3",
     "@types/bun": "^1.3.11",
+    "@types/dockerode": "^4.0.1",
     "bumpp": "^11.0.1",
     "eslint": "^10.0.3",
     "jiti": "^2.6.1",