zidane 1.0.2 → 1.2.0

package/dist/chunk-34KXKPNN.js

@@ -0,0 +1,45 @@
+import {
+  init_spawn,
+  listFiles,
+  readFile,
+  shell,
+  spawn_exports,
+  writeFile
+} from "./chunk-27EP7HB3.js";
+import {
+  __toCommonJS
+} from "./chunk-PNKVD2UK.js";
+
+// src/harnesses/basic.ts
+var basicTools = { shell, readFile, writeFile, listFiles };
+var _spawn;
+function getSpawn() {
+  if (!_spawn) {
+    _spawn = (init_spawn(), __toCommonJS(spawn_exports)).spawn;
+  }
+  return _spawn;
+}
+var spawnProxy = {
+  get spec() {
+    return getSpawn().spec;
+  },
+  execute(input, ctx) {
+    return getSpawn().execute(input, ctx);
+  }
+};
+var 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;
+}
+
+export {
+  basicTools,
+  basic_default,
+  defineHarness
+};

package/dist/chunk-LMSOIIAT.js

@@ -0,0 +1,274 @@
+// src/session/memory.ts
+function createMemoryStore() {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    async load(sessionId) {
+      const data = sessions.get(sessionId);
+      return data ? JSON.parse(JSON.stringify(data)) : null;
+    },
+    async save(session) {
+      sessions.set(session.id, JSON.parse(JSON.stringify(session)));
+    },
+    async delete(sessionId) {
+      sessions.delete(sessionId);
+    },
+    async list(filter) {
+      let ids = Array.from(sessions.keys());
+      if (filter?.agentId) {
+        ids = ids.filter((id) => sessions.get(id)?.agentId === filter.agentId);
+      }
+      if (filter?.limit) {
+        ids = ids.slice(0, filter.limit);
+      }
+      return ids;
+    }
+  };
+}
+
+// src/session/remote.ts
+var TRAILING_SLASH = /\/$/;
+function createRemoteStore(options) {
+  const baseUrl = options.url.replace(TRAILING_SLASH, "");
+  const defaultHeaders = {
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  async function request(path, init) {
+    const url = `${baseUrl}${path}`;
+    const res = await fetch(url, {
+      ...init,
+      headers: { ...defaultHeaders, ...init?.headers }
+    });
+    return res;
+  }
+  return {
+    async load(sessionId) {
+      const res = await request(`/sessions/${encodeURIComponent(sessionId)}`);
+      if (!res.ok) {
+        if (res.status === 404)
+          return null;
+        throw new Error(`Remote session load failed: ${res.status} ${res.statusText}`);
+      }
+      return await res.json();
+    },
+    async save(session) {
+      const res = await request(`/sessions/${encodeURIComponent(session.id)}`, {
+        method: "PUT",
+        body: JSON.stringify(session)
+      });
+      if (!res.ok) {
+        throw new Error(`Remote session save failed: ${res.status} ${res.statusText}`);
+      }
+    },
+    async delete(sessionId) {
+      const res = await request(`/sessions/${encodeURIComponent(sessionId)}`, {
+        method: "DELETE"
+      });
+      if (!res.ok && res.status !== 404) {
+        throw new Error(`Remote session delete failed: ${res.status} ${res.statusText}`);
+      }
+    },
+    async list(filter) {
+      const params = new URLSearchParams();
+      if (filter?.agentId)
+        params.set("agentId", filter.agentId);
+      if (filter?.limit)
+        params.set("limit", String(filter.limit));
+      const query = params.toString();
+      const path = query ? `/sessions?${query}` : "/sessions";
+      const res = await request(path);
+      if (!res.ok) {
+        throw new Error(`Remote session list failed: ${res.status} ${res.statusText}`);
+      }
+      const body = await res.json();
+      return body.ids;
+    }
+  };
+}
+
+// src/session/sqlite.ts
+import { Database } from "bun:sqlite";
+function createSqliteStore(options) {
+  const db = new Database(options.path);
+  db.run("PRAGMA journal_mode = WAL");
+  db.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT,
+      data TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sessions_agent_id ON sessions(agent_id)`);
+  const stmtLoad = db.prepare("SELECT data FROM sessions WHERE id = ?");
+  const stmtUpsert = db.prepare(`
+    INSERT INTO sessions (id, agent_id, data, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      agent_id = excluded.agent_id,
+      data = excluded.data,
+      updated_at = excluded.updated_at
+  `);
+  const stmtDelete = db.prepare("DELETE FROM sessions WHERE id = ?");
+  const stmtList = db.prepare("SELECT id FROM sessions ORDER BY updated_at DESC");
+  const stmtListByAgent = db.prepare("SELECT id FROM sessions WHERE agent_id = ? ORDER BY updated_at DESC");
+  return {
+    async load(sessionId) {
+      const row = stmtLoad.get(sessionId);
+      if (!row)
+        return null;
+      return JSON.parse(row.data);
+    },
+    async save(session) {
+      stmtUpsert.run(
+        session.id,
+        session.agentId ?? null,
+        JSON.stringify(session),
+        session.createdAt,
+        session.updatedAt
+      );
+    },
+    async delete(sessionId) {
+      stmtDelete.run(sessionId);
+    },
+    async list(filter) {
+      let rows;
+      if (filter?.agentId) {
+        rows = stmtListByAgent.all(filter.agentId);
+      } else {
+        rows = stmtList.all();
+      }
+      const ids = rows.map((r) => r.id);
+      if (filter?.limit) {
+        return ids.slice(0, filter.limit);
+      }
+      return ids;
+    }
+  };
+}
+
+// src/session/index.ts
+function createSession(options = {}) {
+  const store = options.store;
+  const now = Date.now();
+  const data = options._data ?? {
+    id: options.id ?? generateId(),
+    agentId: options.agentId,
+    messages: [],
+    runs: [],
+    metadata: options.metadata ?? {},
+    createdAt: now,
+    updatedAt: now
+  };
+  function touch() {
+    data.updatedAt = Date.now();
+  }
+  function findRun(runId) {
+    return data.runs.find((r) => r.id === runId);
+  }
+  return {
+    get id() {
+      return data.id;
+    },
+    get agentId() {
+      return data.agentId;
+    },
+    get messages() {
+      return data.messages;
+    },
+    get runs() {
+      return data.runs;
+    },
+    get metadata() {
+      return data.metadata;
+    },
+    startRun(runId, prompt) {
+      data.runs.push({
+        id: runId,
+        startedAt: Date.now(),
+        prompt,
+        status: "running"
+      });
+      touch();
+    },
+    completeRun(runId, stats) {
+      const run = findRun(runId);
+      if (run) {
+        run.status = "completed";
+        run.endedAt = Date.now();
+        run.turns = stats.turns;
+        run.tokensIn = stats.tokensIn;
+        run.tokensOut = stats.tokensOut;
+        if (stats.turnUsage) {
+          run.turnUsage = stats.turnUsage;
+          run.totalUsage = stats.turnUsage.reduce((acc, t) => ({
+            input: acc.input + t.input,
+            output: acc.output + t.output,
+            cacheCreation: (acc.cacheCreation ?? 0) + (t.cacheCreation ?? 0) || void 0,
+            cacheRead: (acc.cacheRead ?? 0) + (t.cacheRead ?? 0) || void 0,
+            thinking: (acc.thinking ?? 0) + (t.thinking ?? 0) || void 0
+          }), { input: 0, output: 0 });
+        }
+        if (stats.cost !== void 0)
+          run.cost = stats.cost;
+      }
+      touch();
+    },
+    abortRun(runId) {
+      const run = findRun(runId);
+      if (run) {
+        run.status = "aborted";
+        run.endedAt = Date.now();
+      }
+      touch();
+    },
+    errorRun(runId, error) {
+      const run = findRun(runId);
+      if (run) {
+        run.status = "error";
+        run.endedAt = Date.now();
+        run.error = error;
+      }
+      touch();
+    },
+    pushMessages(messages) {
+      data.messages.push(...messages);
+      touch();
+    },
+    setMessages(messages) {
+      data.messages = messages;
+      touch();
+    },
+    setMeta(key, value) {
+      data.metadata[key] = value;
+      touch();
+    },
+    async save() {
+      if (!store) {
+        throw new Error("No SessionStore configured. Pass a store to createSession() to enable persistence.");
+      }
+      await store.save(data);
+    },
+    toJSON() {
+      return JSON.parse(JSON.stringify(data));
+    }
+  };
+}
+async function loadSession(store, sessionId) {
+  const loaded = await store.load(sessionId);
+  if (!loaded)
+    return null;
+  return createSession({ store, _data: loaded });
+}
+function generateId() {
+  return `ses_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export {
+  createMemoryStore,
+  createRemoteStore,
+  createSqliteStore,
+  createSession,
+  loadSession
+};

package/dist/chunk-LS57GDAV.js

@@ -0,0 +1,365 @@
+// src/providers/openai-compat.ts
+var TOOL_RESULTS_TAG = "__zidane_tool_results__";
+var ASSISTANT_TOOL_CALLS_TAG = "__zidane_assistant_tc__";
+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);
+        }
+        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,
+            cost: chunk.usage.total_cost ?? void 0
+          };
+        }
+      }
+    }
+  } 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 toolResults = msg.content.filter((b) => b.type === "tool_result");
+    const toolCalls = msg.content.filter((b) => b.type === "tool_call");
+    const textBlocks = msg.content.filter((b) => b.type === "text");
+    const imageBlocks = msg.content.filter((b) => b.type === "image");
+    if (toolResults.length > 0) {
+      for (const tr of toolResults) {
+        out.push({ role: "tool", tool_call_id: tr.callId, content: tr.output });
+      }
+      continue;
+    }
+    if (toolCalls.length > 0) {
+      const textContent = textBlocks.length > 0 ? textBlocks[0].text : null;
+      out.push({
+        role: "assistant",
+        content: textContent,
+        tool_calls: toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: JSON.stringify(tc.input) }
+        }))
+      });
+      continue;
+    }
+    if (imageBlocks.length > 0) {
+      const parts = imageBlocks.map((img) => ({
+        type: "image_url",
+        image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+      }));
+      for (const b of textBlocks) {
+        parts.push({ type: "text", text: b.text });
+      }
+      out.push({ role: msg.role, content: parts });
+      continue;
+    }
+    if (textBlocks.length === 1) {
+      out.push({ role: msg.role, content: textBlocks[0].text });
+    } else if (textBlocks.length > 1) {
+      out.push({ role: msg.role, content: textBlocks.map((b) => ({ type: "text", text: b.text })) });
+    } else {
+      out.push({ role: msg.role, content: null });
+    }
+  }
+  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((img) => ({
+          type: "image",
+          mediaType: img.source.media_type,
+          data: img.source.data
+        })),
+        { type: "text", text: content }
+      ]
+    };
+  }
+  return { role: "user", content: [{ type: "text", text: content }] };
+}
+function assistantMessage(content) {
+  return { role: "assistant", content: [{ type: "text", text: content }] };
+}
+function toolResultsMessage(results) {
+  return {
+    role: "user",
+    content: results.map((r) => ({
+      type: "tool_result",
+      callId: r.id,
+      output: r.content
+    }))
+  };
+}
+function buildAssistantContent(text, toolCalls) {
+  const content = [];
+  if (text)
+    content.push({ type: "text", text });
+  for (const tc of toolCalls) {
+    content.push({ type: "tool_call", id: tc.id, name: tc.name, input: tc.input });
+  }
+  return { role: "assistant", content };
+}
+
+// src/session/messages.ts
+function fromAnthropic(msg) {
+  const role = msg.role;
+  const content = [];
+  if (typeof msg.content === "string") {
+    content.push({ type: "text", text: msg.content });
+    return { role, content };
+  }
+  if (Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type === "text") {
+        content.push({ type: "text", text: b.text });
+      } else if (b.type === "image") {
+        const source = b.source;
+        if (source?.type === "base64") {
+          content.push({ type: "image", mediaType: source.media_type, data: source.data });
+        }
+      } else if (b.type === "tool_use") {
+        content.push({ type: "tool_call", id: b.id, name: b.name, input: b.input });
+      } else if (b.type === "tool_result") {
+        const output = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+        content.push({ type: "tool_result", callId: b.tool_use_id, output });
+      } else if (b.type === "thinking") {
+        content.push({ type: "thinking", text: b.thinking });
+      }
+    }
+  }
+  return { role, content };
+}
+function fromOpenAI(msg) {
+  const role = msg.role;
+  const content = [];
+  const c = msg.content;
+  if (c == null) {
+    return { role, content };
+  }
+  if (typeof c === "string") {
+    content.push({ type: "text", text: c });
+    return { role, content };
+  }
+  if (typeof c === "object" && c._tag === ASSISTANT_TOOL_CALLS_TAG) {
+    if (c.text) {
+      content.push({ type: "text", text: c.text });
+    }
+    if (Array.isArray(c.tool_calls)) {
+      for (const tc of c.tool_calls) {
+        const input = tc.function?.arguments ? typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments : {};
+        content.push({ type: "tool_call", id: tc.id, name: tc.function?.name ?? "", input });
+      }
+    }
+    return { role, content };
+  }
+  if (typeof c === "object" && c._tag === TOOL_RESULTS_TAG) {
+    if (Array.isArray(c.results)) {
+      for (const r of c.results) {
+        content.push({ type: "tool_result", callId: r.tool_call_id, output: r.content });
+      }
+    }
+    return { role, content };
+  }
+  if (Array.isArray(c)) {
+    for (const block of c) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type === "text") {
+        content.push({ type: "text", text: b.text });
+      } else if (b.type === "image_url") {
+        const imageUrl = b.image_url?.url;
+        if (imageUrl?.startsWith("data:")) {
+          const [meta, data] = imageUrl.slice(5).split(",", 2);
+          const mediaType = meta.replace(";base64", "");
+          content.push({ type: "image", mediaType, data });
+        }
+      }
+    }
+    return { role, content };
+  }
+  return { role, content };
+}
+function toAnthropic(msg) {
+  const blocks = msg.content.map((block) => {
+    switch (block.type) {
+      case "text":
+        return { type: "text", text: block.text };
+      case "image":
+        return { type: "image", source: { type: "base64", media_type: block.mediaType, data: block.data } };
+      case "tool_call":
+        return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+      case "tool_result":
+        return { type: "tool_result", tool_use_id: block.callId, content: block.output };
+      case "thinking":
+        return { type: "thinking", thinking: block.text };
+      default:
+        return { type: "text", text: "" };
+    }
+  });
+  if (blocks.length === 1 && blocks[0].type === "text") {
+    return { role: msg.role, content: blocks[0].text };
+  }
+  return { role: msg.role, content: blocks };
+}
+function toOpenAI(msg) {
+  const toolCalls = msg.content.filter((b) => b.type === "tool_call");
+  const toolResults = msg.content.filter((b) => b.type === "tool_result");
+  const textBlocks = msg.content.filter((b) => b.type === "text");
+  const imageBlocks = msg.content.filter((b) => b.type === "image");
+  if (toolResults.length > 0) {
+    return {
+      role: msg.role,
+      content: {
+        _tag: TOOL_RESULTS_TAG,
+        results: toolResults.map((b) => {
+          const tr = b;
+          return { tool_call_id: tr.callId, content: tr.output };
+        })
+      }
+    };
+  }
+  if (toolCalls.length > 0) {
+    const textContent = textBlocks.length > 0 ? textBlocks[0].text : null;
+    return {
+      role: msg.role,
+      content: {
+        _tag: ASSISTANT_TOOL_CALLS_TAG,
+        text: textContent,
+        tool_calls: toolCalls.map((b) => {
+          const tc = b;
+          return {
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.input) }
+          };
+        })
+      }
+    };
+  }
+  if (imageBlocks.length > 0) {
+    const parts = imageBlocks.map((b) => {
+      const img = b;
+      return { type: "image_url", image_url: { url: `data:${img.mediaType};base64,${img.data}` } };
+    });
+    for (const b of textBlocks) {
+      parts.push({ type: "text", text: b.text });
+    }
+    return { role: msg.role, content: parts };
+  }
+  if (textBlocks.length === 1) {
+    return { role: msg.role, content: textBlocks[0].text };
+  }
+  if (textBlocks.length > 1) {
+    return { role: msg.role, content: textBlocks.map((b) => ({ type: "text", text: b.text })) };
+  }
+  return { role: msg.role, content: null };
+}
+function autoDetectAndConvert(msg) {
+  const c = msg.content;
+  if (c && typeof c === "object" && typeof c._tag === "string" && c._tag.startsWith("__zidane_")) {
+    return fromOpenAI(msg);
+  }
+  if (Array.isArray(c)) {
+    for (const block of c) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type === "tool_use" || b.type === "tool_result" && "tool_use_id" in b) {
+        return fromAnthropic(msg);
+      }
+      if (b.type === "image_url") {
+        return fromOpenAI(msg);
+      }
+    }
+    return fromAnthropic(msg);
+  }
+  if (typeof c === "string") {
+    return fromAnthropic(msg);
+  }
+  return fromAnthropic(msg);
+}
+
+export {
+  consumeSSE,
+  toOAIMessages,
+  formatTools,
+  userMessage,
+  assistantMessage,
+  toolResultsMessage,
+  buildAssistantContent,
+  fromAnthropic,
+  fromOpenAI,
+  toAnthropic,
+  toOpenAI,
+  autoDetectAndConvert
+};

package/dist/chunk-PNKVD2UK.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __export,
+  __toCommonJS
+};