torus-ai 0.1.0

package/dist/index.js

@@ -0,0 +1,733 @@
+// src/tools.ts
+function tool(name, description, inputSchema, handler) {
+  return { name, description, inputSchema, handler };
+}
+function createSdkMcpServer(opts) {
+  return { kind: "sdk-mcp", name: opts.name, version: opts.version ?? "1.0.0", tools: opts.tools };
+}
+var ToolRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  /** Built-ins register under their bare name (no namespace). */
+  addBuiltins(defs) {
+    for (const d of defs) this.map.set(d.name, d);
+    return this;
+  }
+  /** SDK MCP server tools register as mcp__<server>__<tool>. */
+  addServer(server) {
+    for (const t of server.tools) this.map.set(`mcp__${server.name}__${t.name}`, t);
+    return this;
+  }
+  has(fullName) {
+    return this.map.has(fullName);
+  }
+  list() {
+    return [...this.map.entries()].map(([fullName, def]) => ({ fullName, def }));
+  }
+  /** Tool schemas to hand the model, optionally filtered to a stage's allowlist. */
+  schemas(filter) {
+    return this.list().filter((t) => !filter || filter(t.fullName)).map((t) => ({ name: t.fullName, description: t.def.description, inputSchema: t.def.inputSchema }));
+  }
+  async execute(fullName, input, ctx) {
+    const def = this.map.get(fullName);
+    if (!def) return { content: `Unknown tool: ${fullName}`, isError: true };
+    try {
+      return await def.handler(input, ctx);
+    } catch (err) {
+      return { content: `Tool ${fullName} threw: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/permissions.ts
+function matchesAllow(name, patterns) {
+  return patterns.some((p) => {
+    if (p === "*") return true;
+    if (p.endsWith("*")) return name.startsWith(p.slice(0, -1));
+    return p === name;
+  });
+}
+var PermissionEngine = class {
+  cfg;
+  constructor(cfg = {}) {
+    this.cfg = cfg;
+  }
+  async check(name, input) {
+    const { allowedTools, disallowedTools, canUseTool } = this.cfg;
+    if (disallowedTools && matchesAllow(name, disallowedTools)) {
+      return { behavior: "deny", message: `${name} is in disallowedTools.` };
+    }
+    const onAllowlist = allowedTools ? matchesAllow(name, allowedTools) : true;
+    if (canUseTool) return canUseTool(name, input);
+    if (onAllowlist) return { behavior: "allow" };
+    return {
+      behavior: "deny",
+      message: `${name} is not in allowedTools and no canUseTool callback is set.`
+    };
+  }
+};
+
+// src/loop.ts
+var counter = 0;
+var genId = () => `tu_${++counter}`;
+async function* runLoop(opts) {
+  const { provider, registry, permissions, system, messages, toolContext } = opts;
+  const maxTurns = opts.maxTurns ?? 8;
+  const tools = registry.schemas(opts.toolFilter);
+  let turns = 0;
+  let finalText = "";
+  while (turns < maxTurns) {
+    turns++;
+    const res = await provider.generate({ system, messages, tools });
+    for (const b of res.content) if (b.type === "tool_use" && !b.id) b.id = genId();
+    messages.push({ role: "assistant", content: res.content });
+    for (const b of res.content) {
+      if (b.type === "text" && b.text.trim()) {
+        yield { type: "assistant_text", text: b.text, stage: opts.stage };
+      }
+    }
+    if (res.stopReason !== "tool_use") {
+      finalText = res.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
+      return { finalText, turns, messages };
+    }
+    const toolResults = [];
+    for (const b of res.content) {
+      if (b.type !== "tool_use") continue;
+      yield { type: "tool_use", name: b.name, input: b.input, stage: opts.stage };
+      const decision = await permissions.check(b.name, b.input);
+      if (decision.behavior === "deny") {
+        yield { type: "permission_denied", name: b.name, message: decision.message, stage: opts.stage };
+        toolResults.push({
+          type: "tool_result",
+          toolUseId: b.id,
+          content: `Permission denied: ${decision.message}`,
+          isError: true
+        });
+        continue;
+      }
+      const input = decision.updatedInput ?? b.input;
+      const result = await registry.execute(b.name, input, toolContext);
+      yield {
+        type: "tool_result",
+        name: b.name,
+        content: result.content,
+        isError: !!result.isError,
+        stage: opts.stage
+      };
+      toolResults.push({
+        type: "tool_result",
+        toolUseId: b.id,
+        content: result.content,
+        isError: result.isError
+      });
+    }
+    messages.push({ role: "user", content: toolResults });
+  }
+  return { finalText: finalText || "[max turns reached]", turns, messages };
+}
+
+// src/pipeline.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/context.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var estimateTokens = (s) => Math.ceil(s.length / 4);
+async function readIfExists(path) {
+  if (!existsSync(path)) return null;
+  return readFile(path, "utf8");
+}
+function relativeName(root, path) {
+  return path.replace(root, "").replace(/^[\\/]/, "").replace(/\\/g, "/");
+}
+async function loadStageContext(workspaceDir, contract) {
+  const parts = [];
+  const files = [];
+  const push = async (label, path) => {
+    const text = await readIfExists(path);
+    if (text == null) return;
+    const src = relativeName(workspaceDir, path);
+    parts.push(`<context layer="${label}" src="${src}">
+${text.trim()}
+</context>`);
+    files.push(src);
+  };
+  await push("0 identity", join(workspaceDir, "AGENT.md"));
+  await push("1 routing", join(workspaceDir, "CONTEXT.md"));
+  await push("2 contract", contract.contractPath);
+  for (const input of contract.inputs) {
+    const abs = join(contract.stageDir, input.path);
+    await push(input.layer === 3 ? "3 reference" : "4 working", abs);
+  }
+  const system = parts.join("\n\n");
+  return { system, files, tokensEstimated: estimateTokens(system) };
+}
+
+// src/builtins.ts
+import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname, relative, resolve } from "path";
+function safeResolve(workspaceDir, p) {
+  const root = resolve(workspaceDir);
+  const full = resolve(root, p);
+  const rel = relative(root, full);
+  if (rel.startsWith("..") || resolve(root, rel) !== full) {
+    throw new Error(`Path escapes workspace: ${p}`);
+  }
+  return full;
+}
+var readFileTool = tool(
+  "read_file",
+  "Read a UTF-8 text file relative to the workspace root.",
+  { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+  async (input, ctx) => {
+    const full = safeResolve(ctx.workspaceDir, input.path);
+    return { content: await readFile2(full, "utf8") };
+  }
+);
+var writeFileTool = tool(
+  "write_file",
+  "Write a UTF-8 text file relative to the workspace root (creates parent dirs).",
+  {
+    type: "object",
+    properties: { path: { type: "string" }, content: { type: "string" } },
+    required: ["path", "content"]
+  },
+  async (input, ctx) => {
+    const full = safeResolve(ctx.workspaceDir, input.path);
+    await mkdir(dirname(full), { recursive: true });
+    await writeFile(full, input.content, "utf8");
+    return { content: `Wrote ${input.content.length} chars to ${input.path}` };
+  }
+);
+var listDirTool = tool(
+  "list_dir",
+  "List entries of a directory relative to the workspace root.",
+  { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+  async (input, ctx) => {
+    const full = safeResolve(ctx.workspaceDir, input.path);
+    const entries = await readdir(full, { withFileTypes: true });
+    return { content: entries.map((e) => e.isDirectory() ? e.name + "/" : e.name).join("\n") };
+  }
+);
+var builtinTools = [readFileTool, writeFileTool, listDirTool];
+
+// src/subagents.ts
+import { readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+function section(body, name) {
+  const re = new RegExp(`(?:^|\\n)##\\s+${name}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, "i");
+  const m = body.match(re);
+  return m ? m[1].trim() : "";
+}
+function parseContract(name, stageDir, contractPath, body) {
+  const order = parseInt(name.slice(0, 2), 10) || 0;
+  const inputs = [];
+  for (const line of section(body, "Inputs").split("\n")) {
+    const m = line.match(/Layer\s+([34])\b.*?:\s*([^\s#]+)\s*(?:#\s*(.*))?$/i);
+    if (m) inputs.push({ layer: Number(m[1]), path: m[2], note: m[3]?.trim() });
+  }
+  const outputs = [];
+  for (const line of section(body, "Outputs").split("\n")) {
+    const m = line.match(/-\s*([A-Za-z0-9._-]+\.(?:md|json|txt))/);
+    if (m) outputs.push(m[1]);
+  }
+  const toolsRaw = section(body, "Tools");
+  const tools = toolsRaw ? toolsRaw.split(/[\n,]/).map((s) => s.replace(/^[-*]\s*/, "").trim()).filter(Boolean) : [];
+  return {
+    name,
+    order,
+    stageDir,
+    contractPath,
+    inputs,
+    process: section(body, "Process"),
+    outputs,
+    tools
+  };
+}
+async function loadStages(workspaceDir) {
+  const stagesRoot = join2(workspaceDir, "stages");
+  const entries = await readdir2(stagesRoot, { withFileTypes: true });
+  const dirs = entries.filter((e) => e.isDirectory() && /^\d{2}_/.test(e.name)).map((e) => e.name).sort();
+  const contracts = [];
+  for (const name of dirs) {
+    const stageDir = join2(stagesRoot, name);
+    const contractPath = join2(stageDir, "CONTEXT.md");
+    const body = await readFile3(contractPath, "utf8");
+    contracts.push(parseContract(name, stageDir, contractPath, body));
+  }
+  return contracts;
+}
+
+// src/pipeline.ts
+async function* runPipeline(opts) {
+  const registry = new ToolRegistry().addBuiltins(builtinTools);
+  for (const s of opts.mcpServers ?? []) registry.addServer(s);
+  const budget = opts.contextBudgetTokens ?? 8e3;
+  const stages = await loadStages(opts.workspaceDir);
+  for (const stage of stages) {
+    yield { type: "stage_start", stage: stage.name };
+    const ctx = await loadStageContext(opts.workspaceDir, stage);
+    yield { type: "context_loaded", stage: stage.name, tokensEstimated: ctx.tokensEstimated, files: ctx.files };
+    if (ctx.tokensEstimated > budget) {
+      yield {
+        type: "assistant_text",
+        stage: stage.name,
+        text: `\u26A0 context ~${ctx.tokensEstimated} tok exceeds budget ${budget} \u2014 trim this stage's Inputs (ICM principle 3).`
+      };
+    }
+    const perm = new PermissionEngine({
+      allowedTools: stage.tools,
+      // [] ⇒ a pure prose transform, no tools offered
+      disallowedTools: opts.permissions?.disallowedTools,
+      canUseTool: opts.permissions?.canUseTool
+    });
+    const toolFilter = (n) => stage.tools.some((p) => p.endsWith("*") ? n.startsWith(p.slice(0, -1)) : p === n);
+    const userPrompt = `Execute this stage.
+
+## Process
+${stage.process}
+
+Produce: ${stage.outputs.join(", ") || "a single markdown artifact"}.`;
+    const messages = [{ role: "user", content: [{ type: "text", text: userPrompt }] }];
+    const result = yield* runLoop({
+      provider: opts.provider,
+      registry,
+      permissions: perm,
+      system: ctx.system,
+      messages,
+      toolFilter,
+      toolContext: { workspaceDir: opts.workspaceDir, stageDir: stage.stageDir },
+      maxTurns: opts.maxTurnsPerStage,
+      stage: stage.name
+    });
+    const outDir = join3(stage.stageDir, "output");
+    await mkdir2(outDir, { recursive: true });
+    const primary = stage.outputs[0] ?? "output.md";
+    const path = join3(outDir, primary);
+    await writeFile2(path, result.finalText + "\n", "utf8");
+    yield { type: "stage_output", stage: stage.name, artifact: primary, path };
+    yield { type: "result", stage: stage.name, finalText: result.finalText, turns: result.turns };
+    const proceed = opts.reviewGate ? await opts.reviewGate(stage, [{ artifact: primary, path, text: result.finalText }]) : true;
+    if (!proceed) return;
+  }
+}
+
+// src/providers/mock.ts
+var MockProvider = class {
+  name = "mock";
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  async generate(req) {
+    const alreadyUsedTool = req.messages.some(
+      (m) => m.content.some((b) => b.type === "tool_use")
+    );
+    if (req.tools.length > 0 && !alreadyUsedTool) {
+      const t = req.tools[0];
+      return {
+        stopReason: "tool_use",
+        content: [{ type: "tool_use", id: "", name: t.name, input: this.sampleInput(t) }]
+      };
+    }
+    return { stopReason: "end_turn", content: [{ type: "text", text: this.synthesize(req) }] };
+  }
+  sampleInput(t) {
+    const props = t.inputSchema.properties ?? {};
+    const topic = "the requested topic";
+    const out = {};
+    for (const [k, v] of Object.entries(props)) {
+      out[k] = v.type === "number" ? 3 : v.type === "boolean" ? true : k === "path" ? "shared/notes.md" : topic;
+    }
+    return out;
+  }
+  synthesize(req) {
+    const toolData = req.messages.flatMap((m) => m.content).filter((b) => b.type === "tool_result").map((b) => b.content).join("\n");
+    const contract = extractLayer(req.system, "2 contract");
+    const label = this.opts.label ? ` ${this.opts.label}` : "";
+    const lines = [
+      `<!-- mock model output${label} -->`,
+      "",
+      "## Result",
+      "",
+      "Produced by the Torus MockProvider \u2014 proof that layered context \u2192",
+      "agent loop \u2192 output handoff works end to end. Replace with AnthropicProvider",
+      "for real generation."
+    ];
+    if (toolData) {
+      lines.push("", "### Tool-sourced material", "", "```", toolData.slice(0, 600), "```");
+    }
+    if (contract) {
+      lines.push("", "### Stage focus (read from the Layer 2 contract)", "", firstLines(contract, 6));
+    }
+    return lines.join("\n");
+  }
+};
+function extractLayer(system, layer) {
+  const m = system.match(new RegExp(`<context layer="${layer}"[^>]*>([\\s\\S]*?)</context>`));
+  return m ? m[1].trim() : "";
+}
+function firstLines(s, n) {
+  return s.split("\n").slice(0, n).join("\n");
+}
+
+// src/router.ts
+var CHEAP_MODEL = "claude-haiku-4-5";
+var EXPENSIVE_MODEL = "claude-sonnet-4-6";
+var GEMINI_CHEAP_MODEL = "gemini-2.5-flash-lite";
+var GEMINI_EXPENSIVE_MODEL = "gemini-2.5-pro";
+var SIMPLE_KEYWORDS = [
+  "hello",
+  "hi ",
+  "hey",
+  "thanks",
+  "thank you",
+  "yes",
+  "no",
+  "format",
+  "json",
+  "yaml",
+  "uppercase",
+  "lowercase",
+  "capitalize",
+  "translate",
+  "spell",
+  "reverse",
+  "echo",
+  "greeting"
+];
+var estimateTokens2 = (s) => Math.ceil(s.length / 4);
+function fastHeuristic(prompt) {
+  const tokens = estimateTokens2(prompt);
+  const lower = prompt.toLowerCase();
+  if (tokens <= 30 && SIMPLE_KEYWORDS.some((k) => lower.includes(k))) return "SIMPLE";
+  if (tokens >= 400) return "COMPLEX";
+  return null;
+}
+var JUDGE_SYSTEM = 'You are a routing classifier. Decide whether a user query needs a powerful model or can be handled by a small, fast one. Classify as SIMPLE (greetings, formatting, short factual lookups, simple rewrites, single-step tasks) or COMPLEX (multi-step reasoning, coding, analysis, planning, nuanced judgment). Respond ONLY with the required JSON: {"complexity": "SIMPLE" | "COMPLEX"}.';
+var COMPLEXITY_SCHEMA = {
+  type: "object",
+  properties: { complexity: { type: "string", enum: ["SIMPLE", "COMPLEX"] } },
+  required: ["complexity"],
+  additionalProperties: false
+};
+function parseComplexity(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.complexity === "SIMPLE" || parsed.complexity === "COMPLEX") return parsed.complexity;
+  } catch {
+  }
+  const m = text.toUpperCase().match(/\b(SIMPLE|COMPLEX)\b/);
+  if (m) return m[1];
+  throw new Error(`judge returned unparseable complexity: ${text.slice(0, 80)}`);
+}
+var sharedAnthropic;
+async function getAnthropic(opts) {
+  if (opts.client) return opts.client;
+  if (sharedAnthropic) return sharedAnthropic;
+  const mod = await import("@anthropic-ai/sdk").catch(() => {
+    throw new Error("Anthropic judge needs @anthropic-ai/sdk (npm i @anthropic-ai/sdk).");
+  });
+  const Anthropic = mod.default ?? mod.Anthropic;
+  sharedAnthropic = new Anthropic({ apiKey: opts.apiKey ?? process.env.ANTHROPIC_API_KEY });
+  return sharedAnthropic;
+}
+async function judgeComplexity(prompt, opts = {}) {
+  const client = await getAnthropic(opts);
+  const res = await client.messages.create({
+    model: opts.judgeModel ?? CHEAP_MODEL,
+    max_tokens: 64,
+    system: JUDGE_SYSTEM,
+    output_config: { format: { type: "json_schema", schema: COMPLEXITY_SCHEMA } },
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = res.content.find((b) => b.type === "text")?.text ?? "";
+  return parseComplexity(text);
+}
+var sharedGemini;
+async function getGemini(opts) {
+  if (opts.client) return opts.client;
+  if (sharedGemini) return sharedGemini;
+  const mod = await import("@google/genai").catch(() => {
+    throw new Error("Gemini judge needs @google/genai (npm i @google/genai).");
+  });
+  const GoogleGenAI = mod.GoogleGenAI;
+  sharedGemini = new GoogleGenAI({
+    apiKey: opts.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY
+  });
+  return sharedGemini;
+}
+async function judgeComplexityGemini(prompt, opts = {}) {
+  const client = await getGemini(opts);
+  const res = await client.models.generateContent({
+    model: opts.judgeModel ?? GEMINI_CHEAP_MODEL,
+    contents: prompt,
+    config: {
+      systemInstruction: JUDGE_SYSTEM,
+      responseMimeType: "application/json",
+      responseSchema: {
+        type: "object",
+        properties: { complexity: { type: "string", enum: ["SIMPLE", "COMPLEX"] } },
+        required: ["complexity"]
+      }
+    }
+  });
+  return parseComplexity(res.text ?? "");
+}
+async function classifyWith(prompt, judge, opts) {
+  return fastHeuristic(prompt) ?? judge(prompt, opts);
+}
+function classifyComplexity(prompt, opts = {}) {
+  return classifyWith(prompt, judgeComplexity, opts);
+}
+function classifyComplexityGemini(prompt, opts = {}) {
+  return classifyWith(prompt, judgeComplexityGemini, opts);
+}
+async function routeWith(prompt, cfg, opts) {
+  let model = cfg.expensiveModel;
+  try {
+    const complexity = await classifyWith(prompt, cfg.judge, opts);
+    model = complexity === "SIMPLE" ? cfg.cheapModel : cfg.expensiveModel;
+  } catch (err) {
+    console.warn(
+      `[router] classification failed \u2014 defaulting to expensive model. Reason: ${err.message}`
+    );
+    model = cfg.expensiveModel;
+  }
+  record(model, model === cfg.cheapModel);
+  return model;
+}
+function selectModel(prompt, opts = {}) {
+  return routeWith(prompt, { cheapModel: CHEAP_MODEL, expensiveModel: EXPENSIVE_MODEL, judge: judgeComplexity }, opts);
+}
+function selectGeminiModel(prompt, opts = {}) {
+  return routeWith(
+    prompt,
+    { cheapModel: GEMINI_CHEAP_MODEL, expensiveModel: GEMINI_EXPENSIVE_MODEL, judge: judgeComplexityGemini },
+    opts
+  );
+}
+var cheapCount = 0;
+var expensiveCount = 0;
+function record(model, isCheap) {
+  if (isCheap) cheapCount++;
+  else expensiveCount++;
+  const total = cheapCount + expensiveCount;
+  const pct = (n) => (n / total * 100).toFixed(0);
+  console.log(
+    `[router] \u2192 ${isCheap ? "CHEAP" : "EXPENSIVE"} (${model})  |  cheap ${pct(cheapCount)}% / expensive ${pct(expensiveCount)}%  (n=${total})`
+  );
+}
+function getRoutingStats() {
+  const total = cheapCount + expensiveCount;
+  return {
+    cheap: cheapCount,
+    expensive: expensiveCount,
+    total,
+    cheapPct: total ? cheapCount / total * 100 : 0,
+    expensivePct: total ? expensiveCount / total * 100 : 0
+  };
+}
+function latestUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "user") continue;
+    const text = m.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
+    if (text) return text;
+  }
+  return "";
+}
+
+// src/providers/anthropic.ts
+var AnthropicProvider = class {
+  name = "anthropic";
+  client;
+  model;
+  maxTokens;
+  apiKey;
+  route;
+  constructor(opts = {}) {
+    this.model = opts.model ?? "claude-sonnet-4-6";
+    this.maxTokens = opts.maxTokens ?? 2048;
+    this.apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    this.route = opts.route ?? false;
+  }
+  async ensureClient() {
+    if (this.client) return;
+    const mod = await import("@anthropic-ai/sdk").catch(() => {
+      throw new Error(
+        "AnthropicProvider needs the @anthropic-ai/sdk package: run `npm i @anthropic-ai/sdk`."
+      );
+    });
+    const Anthropic = mod.default ?? mod.Anthropic;
+    this.client = new Anthropic({ apiKey: this.apiKey });
+  }
+  async generate(req) {
+    await this.ensureClient();
+    const model = this.route ? await selectModel(latestUserText(req.messages), {
+      client: this.client,
+      apiKey: this.apiKey
+    }) : this.model;
+    const res = await this.client.messages.create({
+      model,
+      max_tokens: this.maxTokens,
+      system: req.system,
+      tools: req.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.inputSchema
+      })),
+      messages: req.messages.map(toApiMessage)
+    });
+    const content = res.content.map((b) => {
+      if (b.type === "tool_use") return { type: "tool_use", id: b.id, name: b.name, input: b.input };
+      return { type: "text", text: b.type === "text" ? b.text : "" };
+    });
+    const stopReason = res.stop_reason === "tool_use" ? "tool_use" : "end_turn";
+    return { content, stopReason };
+  }
+};
+function toApiMessage(m) {
+  return {
+    role: m.role,
+    content: m.content.map((b) => {
+      if (b.type === "text") return { type: "text", text: b.text };
+      if (b.type === "tool_use") return { type: "tool_use", id: b.id, name: b.name, input: b.input };
+      return { type: "tool_result", tool_use_id: b.toolUseId, content: b.content, is_error: b.isError };
+    })
+  };
+}
+
+// src/providers/gemini.ts
+var GeminiProvider = class {
+  name = "gemini";
+  client;
+  model;
+  apiKey;
+  route;
+  constructor(opts = {}) {
+    this.model = opts.model ?? "gemini-2.5-flash";
+    this.apiKey = opts.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+    this.route = opts.route ?? false;
+  }
+  async ensureClient() {
+    if (this.client) return;
+    const mod = await import("@google/genai").catch(() => {
+      throw new Error("GeminiProvider needs the @google/genai package: run `npm i @google/genai`.");
+    });
+    const GoogleGenAI = mod.GoogleGenAI;
+    this.client = new GoogleGenAI({ apiKey: this.apiKey });
+  }
+  async generate(req) {
+    await this.ensureClient();
+    const model = this.route ? await selectGeminiModel(latestUserText(req.messages), {
+      client: this.client,
+      apiKey: this.apiKey
+    }) : this.model;
+    const idToName = toolUseNames(req.messages);
+    const config = {};
+    if (req.system) config.systemInstruction = req.system;
+    if (req.tools.length) {
+      config.tools = [
+        {
+          functionDeclarations: req.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema
+          }))
+        }
+      ];
+    }
+    const res = await this.client.models.generateContent({
+      model,
+      contents: req.messages.map((m) => toGeminiContent(m, idToName)),
+      config
+    });
+    const content = [];
+    const text = res.text;
+    if (text && text.trim()) content.push({ type: "text", text });
+    const calls = res.functionCalls ?? [];
+    for (const fc of calls) {
+      content.push({ type: "tool_use", id: fc.id ?? "", name: fc.name, input: fc.args ?? {} });
+    }
+    if (content.length === 0) content.push({ type: "text", text: "" });
+    return { content, stopReason: calls.length ? "tool_use" : "end_turn" };
+  }
+};
+function toolUseNames(messages) {
+  const map = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    for (const b of m.content) {
+      if (b.type === "tool_use") map.set(b.id, b.name);
+    }
+  }
+  return map;
+}
+function toGeminiContent(m, idToName) {
+  const role = m.role === "assistant" ? "model" : "user";
+  const parts = m.content.map((b) => {
+    if (b.type === "text") return { text: b.text };
+    if (b.type === "tool_use") return { functionCall: { id: b.id, name: b.name, args: b.input } };
+    return {
+      functionResponse: {
+        id: b.toolUseId,
+        name: idToName.get(b.toolUseId) ?? b.toolUseId,
+        response: b.isError ? { error: b.content } : { result: b.content }
+      }
+    };
+  });
+  return { role, parts };
+}
+
+// src/index.ts
+async function* query(prompt, options) {
+  const registry = new ToolRegistry();
+  if (options.includeBuiltins ?? true) registry.addBuiltins(builtinTools);
+  for (const s of options.mcpServers ?? []) registry.addServer(s);
+  const messages = [{ role: "user", content: [{ type: "text", text: prompt }] }];
+  const result = yield* runLoop({
+    provider: options.provider,
+    registry,
+    permissions: new PermissionEngine(options.permissions ?? {}),
+    system: options.system ?? "You are a helpful agent.",
+    messages,
+    toolContext: { workspaceDir: options.workspaceDir ?? process.cwd() },
+    maxTurns: options.maxTurns
+  });
+  yield { type: "result", finalText: result.finalText, turns: result.turns };
+}
+export {
+  AnthropicProvider,
+  CHEAP_MODEL,
+  EXPENSIVE_MODEL,
+  GEMINI_CHEAP_MODEL,
+  GEMINI_EXPENSIVE_MODEL,
+  GeminiProvider,
+  MockProvider,
+  PermissionEngine,
+  ToolRegistry,
+  builtinTools,
+  classifyComplexity,
+  classifyComplexityGemini,
+  createSdkMcpServer,
+  fastHeuristic,
+  getRoutingStats,
+  judgeComplexity,
+  judgeComplexityGemini,
+  latestUserText,
+  listDirTool,
+  loadStageContext,
+  loadStages,
+  matchesAllow,
+  parseContract,
+  query,
+  readFileTool,
+  runLoop,
+  runPipeline,
+  selectGeminiModel,
+  selectModel,
+  tool,
+  writeFileTool
+};
+//# sourceMappingURL=index.js.map