@firstlovecenter/ai-chat 0.1.0

package/dist/server/index.cjs

@@ -0,0 +1,1465 @@
+'use strict';
+
+var vertexSdk = require('@anthropic-ai/vertex-sdk');
+var crypto = require('crypto');
+var googleAuthLibrary = require('google-auth-library');
+
+// src/server/tools/types.ts
+var TERMINAL_TOOL_NAME = "present";
+function ok(data) {
+  return { ok: true, data };
+}
+function err(code, message) {
+  return { ok: false, error: { code, message } };
+}
+
+// src/server/agent.ts
+var DEFAULT_MAX_TOOL_TURNS = 12;
+var DEFAULT_MAX_OUTPUT_TOKENS = 4096;
+async function runAgent(input) {
+  const provider = input.provider;
+  const maxToolTurns = input.maxToolTurns ?? DEFAULT_MAX_TOOL_TURNS;
+  const maxOutputTokens = input.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+  const transcript = [];
+  transcript.push({ kind: "user", text: input.question });
+  const messages = [{ role: "user", text: input.question }];
+  const system = input.systemBlocks;
+  const toolSchemas = Object.values(input.tools).map((t) => t.schema);
+  let toolCallCount = 0;
+  let presentPayload = null;
+  for (let turn = 0; turn < maxToolTurns; turn++) {
+    const response = await provider.runTurn({
+      system,
+      tools: toolSchemas,
+      messages,
+      maxOutputTokens
+    });
+    if (response.text) {
+      transcript.push({ kind: "assistant_text", text: response.text });
+    }
+    if (response.toolCalls.length === 0) {
+      if (presentPayload) break;
+      return {
+        ok: false,
+        error: {
+          code: "AGENT_NO_PRESENT",
+          message: "The agent ended without calling present(). Try rephrasing."
+        },
+        transcript
+      };
+    }
+    messages.push({
+      role: "assistant",
+      text: response.text,
+      toolCalls: response.toolCalls,
+      providerData: response.providerData
+    });
+    const toolResults = [];
+    for (const tc of response.toolCalls) {
+      transcript.push({ kind: "tool_use", name: tc.name, input: tc.input });
+      const tool = input.tools[tc.name];
+      if (!tool) {
+        const errResult = {
+          ok: false,
+          error: { code: "UNKNOWN_TOOL", message: `Unknown tool: ${tc.name}` }
+        };
+        transcript.push({ kind: "tool_result", name: tc.name, result: errResult });
+        toolResults.push({
+          toolCallId: tc.id,
+          toolName: tc.name,
+          isError: true,
+          content: JSON.stringify(errResult.error)
+        });
+        continue;
+      }
+      const result = await tool.execute(tc.input, {
+        ...input.ctx,
+        toolCallCount
+      });
+      transcript.push({ kind: "tool_result", name: tc.name, result });
+      toolCallCount += 1;
+      if (tc.name === TERMINAL_TOOL_NAME && result.ok) {
+        if (toolCallCount < 3) {
+          const violation = {
+            code: "SELF_VERIFY_REQUIRED",
+            message: "Per FR-8.3 you must run at least one CROSS-CHECK tool call (a different metric, a different period, or a run_sql sanity-check) before present. Make that extra call now, then call present again."
+          };
+          toolResults.push({
+            toolCallId: tc.id,
+            toolName: tc.name,
+            isError: true,
+            content: JSON.stringify(violation)
+          });
+          continue;
+        }
+        presentPayload = result.data;
+        break;
+      }
+      toolResults.push({
+        toolCallId: tc.id,
+        toolName: tc.name,
+        isError: !result.ok,
+        content: JSON.stringify(result.ok ? result.data : result.error)
+      });
+    }
+    if (presentPayload) break;
+    messages.push({ role: "tool", results: toolResults });
+  }
+  if (!presentPayload) {
+    return {
+      ok: false,
+      error: {
+        code: "AGENT_TURN_LIMIT",
+        message: `Agent exceeded the ${maxToolTurns}-turn budget without calling present().`
+      },
+      transcript
+    };
+  }
+  return { ok: true, structured: presentPayload, toolCallCount, transcript };
+}
+var ClaudeToolProvider = class {
+  id = "claude";
+  client;
+  modelId;
+  constructor(opts) {
+    this.modelId = opts.modelId;
+    this.client = new vertexSdk.AnthropicVertex({
+      projectId: opts.projectId,
+      region: opts.location,
+      googleAuth: opts.auth
+    });
+    patchVertexBuildRequestSync(this.client);
+  }
+  async runTurn(input) {
+    const system = input.system.map((b) => ({
+      type: "text",
+      text: b.text,
+      ...b.cached ? { cache_control: { type: "ephemeral" } } : {}
+    }));
+    const messages = toAnthropicMessages(input.messages);
+    const response = await this.client.messages.create({
+      model: this.modelId,
+      max_tokens: input.maxOutputTokens,
+      system,
+      tools: input.tools,
+      messages
+    });
+    return fromAnthropicResponse(response);
+  }
+};
+function createClaudeProvider(opts) {
+  return new ClaudeToolProvider(opts);
+}
+function toAnthropicMessages(messages) {
+  const out = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      out.push({ role: "user", content: msg.text });
+    } else if (msg.role === "assistant") {
+      const blocks = [];
+      if (msg.text) {
+        blocks.push({ type: "text", text: msg.text });
+      }
+      for (const tc of msg.toolCalls) {
+        blocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: tc.input
+        });
+      }
+      out.push({ role: "assistant", content: blocks });
+    } else {
+      const content = msg.results.map((r) => ({
+        type: "tool_result",
+        tool_use_id: r.toolCallId,
+        is_error: r.isError,
+        content: r.content
+      }));
+      out.push({ role: "user", content });
+    }
+  }
+  return out;
+}
+function fromAnthropicResponse(response) {
+  const textParts = [];
+  const toolCalls = [];
+  for (const block of response.content) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    } else if (block.type === "tool_use") {
+      const tu = block;
+      toolCalls.push({
+        id: tu.id,
+        name: tu.name,
+        input: tu.input ?? {}
+      });
+    }
+  }
+  return {
+    text: textParts.join(""),
+    toolCalls,
+    stopReason: normalizeStopReason(response.stop_reason)
+  };
+}
+function normalizeStopReason(reason) {
+  switch (reason) {
+    case "tool_use":
+      return "tool_use";
+    case "end_turn":
+      return "end_turn";
+    case "max_tokens":
+      return "max_tokens";
+    default:
+      return "other";
+  }
+}
+var MODEL_ENDPOINTS = /* @__PURE__ */ new Set(["/v1/messages", "/v1/messages?beta=true"]);
+var VERTEX_DEFAULT_VERSION = "vertex-2023-10-16";
+function isObj(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function patchVertexBuildRequestSync(client) {
+  const proto = Object.getPrototypeOf(client);
+  const grandparent = Object.getPrototypeOf(proto);
+  proto.buildRequest = function patchedBuildRequest(options, extra) {
+    if (isObj(options.body)) {
+      options.body = { ...options.body };
+    }
+    if (isObj(options.body) && !options.body.anthropic_version) {
+      options.body.anthropic_version = VERTEX_DEFAULT_VERSION;
+    }
+    if (options.path && MODEL_ENDPOINTS.has(options.path) && options.method === "post" && isObj(options.body)) {
+      if (!this.projectId) throw new Error("AnthropicVertex: projectId is required");
+      const model = options.body.model;
+      options.body.model = void 0;
+      const stream = options.body.stream ?? false;
+      const specifier = stream ? "streamRawPredict" : "rawPredict";
+      options.path = `/projects/${this.projectId}/locations/${this.region}/publishers/anthropic/models/${model}:${specifier}`;
+    }
+    if (options.path === "/v1/messages/count_tokens" || options.path === "/v1/messages/count_tokens?beta=true" && options.method === "post") {
+      if (!this.projectId) throw new Error("AnthropicVertex: projectId is required");
+      options.path = `/projects/${this.projectId}/locations/${this.region}/publishers/anthropic/models/count-tokens:rawPredict`;
+    }
+    return grandparent.buildRequest.call(this, options, extra);
+  };
+}
+
+// src/server/providers/schema.ts
+function toGeminiSchema(schema) {
+  const out = walk(schema);
+  return out ?? { type: "object" };
+}
+function walk(node) {
+  if (Array.isArray(node)) return node.map(walk);
+  if (!isObject(node)) return node;
+  if ("const" in node) {
+    const c = node.const;
+    const inferred = inferConstType(c);
+    const next = { ...node };
+    delete next.const;
+    next.type = next.type ?? inferred;
+    next.enum = [c];
+    return walk(next);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (k === "oneOf") {
+      out.anyOf = v.map(walk);
+      continue;
+    }
+    if (k === "additionalProperties") {
+      continue;
+    }
+    if (k === "properties" && isObject(v)) {
+      const props = {};
+      for (const [pk, pv] of Object.entries(v)) {
+        props[pk] = walk(pv);
+      }
+      out.properties = props;
+      continue;
+    }
+    if (k === "items") {
+      out.items = walk(v);
+      continue;
+    }
+    if (k === "anyOf" || k === "allOf") {
+      out[k] = v.map(walk);
+      continue;
+    }
+    if (k === "enum" && Array.isArray(v)) {
+      const allStrings = v.every((x) => typeof x === "string");
+      if (allStrings) {
+        out.enum = v;
+        continue;
+      }
+      const allNumbers = v.length > 0 && v.every((x) => typeof x === "number");
+      if (allNumbers) {
+        const nums = v;
+        out.minimum = Math.min(...nums);
+        out.maximum = Math.max(...nums);
+      }
+      continue;
+    }
+    out[k] = v;
+  }
+  if (out.type === "array" && out.items === void 0) {
+    out.items = { type: "string" };
+  }
+  return out;
+}
+function inferConstType(c) {
+  if (typeof c === "string") return "string";
+  if (typeof c === "number") return Number.isInteger(c) ? "integer" : "number";
+  if (typeof c === "boolean") return "boolean";
+  return "string";
+}
+function isObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+
+// src/server/providers/gemini.ts
+var GeminiToolProvider = class {
+  id = "gemini";
+  auth;
+  projectId;
+  location;
+  modelId;
+  fetchImpl;
+  constructor(opts) {
+    this.auth = opts.auth;
+    this.projectId = opts.projectId;
+    this.location = opts.location;
+    this.modelId = opts.modelId;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  async runTurn(input) {
+    const accessToken = await this.auth.getAccessToken();
+    if (!accessToken) throw new Error("Failed to obtain GCP access token");
+    const url = `https://${vertexHost(this.location)}/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${this.modelId}:generateContent`;
+    const body = {
+      systemInstruction: {
+        parts: [{ text: input.system.map((b) => b.text).join("\n\n") }]
+      },
+      contents: toGeminiContents(input.messages),
+      tools: [
+        {
+          functionDeclarations: input.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: toGeminiSchema(t.input_schema)
+          }))
+        }
+      ],
+      toolConfig: {
+        functionCallingConfig: { mode: "AUTO" }
+      },
+      generationConfig: {
+        maxOutputTokens: input.maxOutputTokens,
+        temperature: 0
+      }
+    };
+    const res = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const detail = await safeReadText(res);
+      throw new Error(`Vertex Gemini request failed (${res.status}): ${detail}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(
+        `Vertex Gemini returned error: ${json.error.status ?? json.error.code ?? "??"} ${json.error.message ?? ""}`
+      );
+    }
+    return fromGeminiResponse(json);
+  }
+};
+function createGeminiProvider(opts) {
+  return new GeminiToolProvider(opts);
+}
+function vertexHost(location) {
+  return location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
+}
+function toGeminiContents(messages) {
+  const out = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      out.push({ role: "user", parts: [{ text: msg.text }] });
+    } else if (msg.role === "assistant") {
+      if (Array.isArray(msg.providerData?.parts)) {
+        const parts2 = msg.providerData.parts;
+        out.push({ role: "model", parts: parts2 });
+        continue;
+      }
+      const parts = [];
+      if (msg.text) parts.push({ text: msg.text });
+      for (const tc of msg.toolCalls) {
+        parts.push({ functionCall: { name: tc.name, args: tc.input } });
+      }
+      if (parts.length === 0) parts.push({ text: "" });
+      out.push({ role: "model", parts });
+    } else {
+      const parts = msg.results.map((r) => ({
+        functionResponse: {
+          name: r.toolName,
+          response: parseToolResultContent(r.content, r.isError)
+        }
+      }));
+      out.push({ role: "user", parts });
+    }
+  }
+  return out;
+}
+function parseToolResultContent(content, isError) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    parsed = content;
+  }
+  if (isError) {
+    return { error: parsed };
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return { result: parsed };
+}
+function fromGeminiResponse(json) {
+  const candidate = json.candidates?.[0];
+  const parts = candidate?.content?.parts ?? [];
+  const textParts = [];
+  const toolCalls = [];
+  let idx = 0;
+  for (const part of parts) {
+    if (typeof part.text === "string" && part.thought !== true) {
+      textParts.push(part.text);
+    } else if (part.functionCall) {
+      toolCalls.push({
+        id: `gem_${idx}_${part.functionCall.name}`,
+        name: part.functionCall.name,
+        input: part.functionCall.args ?? {}
+      });
+      idx += 1;
+    }
+  }
+  return {
+    text: textParts.join(""),
+    toolCalls,
+    stopReason: normalizeFinishReason(candidate?.finishReason, toolCalls.length > 0),
+    // Preserve the raw parts so a subsequent runTurn() echoes the
+    // assistant turn back faithfully, including any `thoughtSignature`
+    // entries thinking-mode requires.
+    providerData: { parts }
+  };
+}
+function normalizeFinishReason(reason, hasToolCalls) {
+  if (hasToolCalls) return "tool_use";
+  switch (reason) {
+    case "STOP":
+      return "end_turn";
+    case "MAX_TOKENS":
+      return "max_tokens";
+    default:
+      return reason ? "other" : "end_turn";
+  }
+}
+async function safeReadText(res) {
+  try {
+    return (await res.text()).slice(0, 500);
+  } catch {
+    return "";
+  }
+}
+
+// src/server/providers/index.ts
+var toolProviders = [
+  {
+    id: "claude",
+    label: "Claude (Vertex)",
+    description: "Anthropic Messages API hosted on GCP Vertex AI.",
+    createProvider(opts) {
+      return createClaudeProvider({
+        auth: opts.auth,
+        projectId: opts.projectId,
+        location: opts.location ?? opts.defaultLocation,
+        modelId: opts.modelIds.claude
+      });
+    }
+  },
+  {
+    id: "gemini",
+    label: "Gemini (Vertex)",
+    description: "Google Gemini hosted on GCP Vertex AI (raw generateContent).",
+    createProvider(opts) {
+      return createGeminiProvider({
+        auth: opts.auth,
+        projectId: opts.projectId,
+        location: opts.location ?? opts.defaultLocation,
+        modelId: opts.modelIds.gemini
+      });
+    }
+  }
+];
+function getToolProvider(id) {
+  return toolProviders.find((p) => p.id === id);
+}
+function vertexHost2(location) {
+  return location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
+}
+async function getAccessToken(auth) {
+  const token = await auth.getAccessToken();
+  if (!token) throw new Error("Failed to obtain GCP access token");
+  return token;
+}
+function createAnthropicVertexClient(args) {
+  const client = new vertexSdk.AnthropicVertex({
+    projectId: args.projectId,
+    region: args.location,
+    googleAuth: args.auth
+  });
+  patchVertexBuildRequestSync2(client);
+  return client;
+}
+var MODEL_ENDPOINTS2 = /* @__PURE__ */ new Set(["/v1/messages", "/v1/messages?beta=true"]);
+var VERTEX_DEFAULT_VERSION2 = "vertex-2023-10-16";
+function isObj2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function patchVertexBuildRequestSync2(client) {
+  const proto = Object.getPrototypeOf(client);
+  const grandparent = Object.getPrototypeOf(proto);
+  proto.buildRequest = function patchedBuildRequest(options, extra) {
+    if (isObj2(options.body)) {
+      options.body = { ...options.body };
+    }
+    if (isObj2(options.body) && !options.body.anthropic_version) {
+      options.body.anthropic_version = VERTEX_DEFAULT_VERSION2;
+    }
+    if (options.path && MODEL_ENDPOINTS2.has(options.path) && options.method === "post" && isObj2(options.body)) {
+      if (!this.projectId) throw new Error("AnthropicVertex: projectId is required");
+      const model = options.body.model;
+      options.body.model = void 0;
+      const stream = options.body.stream ?? false;
+      const specifier = stream ? "streamRawPredict" : "rawPredict";
+      options.path = `/projects/${this.projectId}/locations/${this.region}/publishers/anthropic/models/${model}:${specifier}`;
+    }
+    if (options.path === "/v1/messages/count_tokens" || options.path === "/v1/messages/count_tokens?beta=true" && options.method === "post") {
+      if (!this.projectId) throw new Error("AnthropicVertex: projectId is required");
+      options.path = `/projects/${this.projectId}/locations/${this.region}/publishers/anthropic/models/count-tokens:rawPredict`;
+    }
+    return grandparent.buildRequest.call(this, options, extra);
+  };
+}
+
+// src/server/narrators/claude.ts
+var NARRATIVE_SYSTEM = `You are the prose narrator for the FLC Data Intelligence agent.
+
+You receive:
+  - The user's original question.
+  - The full structured answer the agent already computed (blocks +
+    raw_numbers).
+  - One specific paragraph_brief block's topic and key_facts.
+
+Your job: write 2\u20134 short sentences (\u2264 80 words total) of natural,
+useful prose for THIS paragraph block.
+
+Rules:
+  - Use only the facts in key_facts and raw_numbers. Do not invent
+    numbers, dates, country names, or trends.
+  - Be neutral and direct. No hedging ("it appears", "perhaps").
+  - No headings, no markdown, no bullet lists. Plain prose.
+  - Reference the same numbers verbatim \u2014 if raw_numbers says
+    1234.56, say "1,234.56" or "$1,235", never "about 1.2k" if that
+    drifts.
+  - Do not begin with "Here is", "Below", "Based on the data".
+  - Stop. Do not repeat yourself.`;
+async function* streamClaudeNarration(opts) {
+  const client = createAnthropicVertexClient({
+    projectId: opts.projectId,
+    location: opts.location,
+    auth: opts.auth
+  });
+  const stream = await client.messages.stream({
+    model: opts.modelId,
+    max_tokens: 400,
+    system: NARRATIVE_SYSTEM,
+    messages: [{ role: "user", content: buildNarrativeUserMessage(opts.input) }]
+  });
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && "delta" in event && event.delta && "type" in event.delta && event.delta.type === "text_delta") {
+      yield event.delta.text;
+    }
+  }
+}
+function buildNarrativeUserMessage(input) {
+  return [
+    `User question: ${input.question}`,
+    "",
+    `Block topic: ${input.topic}`,
+    `Block key_facts:
+${input.keyFacts.map((f) => `- ${f}`).join("\n")}`,
+    "",
+    "Full structured answer (for reference; do not restate the whole thing):",
+    JSON.stringify(input.structured, null, 2)
+  ].join("\n");
+}
+
+// src/server/narrators/gemini.ts
+var NARRATIVE_SYSTEM2 = `You are the prose narrator for the FLC Data Intelligence agent.
+
+You receive:
+  - The user's original question.
+  - The full structured answer the agent already computed (blocks +
+    raw_numbers).
+  - One specific paragraph_brief block's topic and key_facts.
+
+Your job: write 2\u20134 short sentences (\u2264 80 words total) of natural,
+useful prose for THIS paragraph block.
+
+Rules:
+  - Use only the facts in key_facts and raw_numbers. Do not invent
+    numbers, dates, country names, or trends.
+  - Be neutral and direct. No hedging.
+  - No headings, no markdown, no bullet lists. Plain prose.
+  - Reference the same numbers verbatim.
+  - Do not begin with "Here is" or "Based on the data".
+  - Stop. Do not repeat yourself.`;
+async function* streamGeminiNarration(opts) {
+  const accessToken = await getAccessToken(opts.auth);
+  const url = `https://${vertexHost2(opts.location)}/v1/projects/${opts.projectId}/locations/${opts.location}/publishers/google/models/${opts.modelId}:streamGenerateContent?alt=sse`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      systemInstruction: { parts: [{ text: NARRATIVE_SYSTEM2 }] },
+      contents: [
+        {
+          role: "user",
+          parts: [{ text: buildNarrativeUserMessage(opts.input) }]
+        }
+      ],
+      generationConfig: { maxOutputTokens: 400, temperature: 0 }
+    })
+  });
+  if (!res.ok || !res.body) {
+    const detail = await safeReadText2(res);
+    throw new Error(`Vertex Gemini request failed (${res.status}): ${detail}`);
+  }
+  yield* parseGeminiSseTextDeltas(res.body);
+}
+async function safeReadText2(res) {
+  try {
+    return (await res.text()).slice(0, 500);
+  } catch {
+    return "";
+  }
+}
+async function* parseGeminiSseTextDeltas(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffered += decoder.decode(value, { stream: true });
+    let newlineIndex;
+    while ((newlineIndex = buffered.indexOf("\n")) !== -1) {
+      const line = buffered.slice(0, newlineIndex).trim();
+      buffered = buffered.slice(newlineIndex + 1);
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload) continue;
+      try {
+        const chunk = JSON.parse(payload);
+        const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+        for (const part of parts) {
+          if (typeof part.text === "string" && part.text.length > 0) {
+            yield part.text;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}
+
+// src/server/narrators/grok.ts
+var NARRATIVE_SYSTEM3 = `You are the prose narrator for the FLC Data Intelligence agent.
+
+You receive:
+  - The user's original question.
+  - The full structured answer the agent already computed (blocks +
+    raw_numbers).
+  - One specific paragraph_brief block's topic and key_facts.
+
+Your job: write 2\u20134 short sentences (\u2264 80 words total) of natural,
+useful prose for THIS paragraph block.
+
+Rules:
+  - Use only the facts in key_facts and raw_numbers. Do not invent
+    numbers, dates, country names, or trends.
+  - Be neutral and direct. No hedging.
+  - No headings, no markdown, no bullet lists. Plain prose.
+  - Reference the same numbers verbatim.
+  - Do not begin with "Here is" or "Based on the data".
+  - Stop. Do not repeat yourself.`;
+async function* streamGrokNarration(opts) {
+  const accessToken = await getAccessToken(opts.auth);
+  const url = `https://${vertexHost2(opts.location)}/v1beta1/projects/${opts.projectId}/locations/${opts.location}/endpoints/openapi/chat/completions`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: opts.modelId,
+      max_tokens: 400,
+      stream: true,
+      messages: [
+        { role: "system", content: NARRATIVE_SYSTEM3 },
+        { role: "user", content: buildNarrativeUserMessage(opts.input) }
+      ]
+    })
+  });
+  if (!res.ok || !res.body) {
+    const detail = await safeReadText3(res);
+    throw new Error(`Vertex Grok request failed (${res.status}): ${detail}`);
+  }
+  yield* parseSseDeltas(res.body);
+}
+async function safeReadText3(res) {
+  try {
+    return (await res.text()).slice(0, 500);
+  } catch {
+    return "";
+  }
+}
+async function* parseSseDeltas(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffered += decoder.decode(value, { stream: true });
+    let newlineIndex;
+    while ((newlineIndex = buffered.indexOf("\n")) !== -1) {
+      const line = buffered.slice(0, newlineIndex).trim();
+      buffered = buffered.slice(newlineIndex + 1);
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") {
+        if (payload === "[DONE]") return;
+        continue;
+      }
+      try {
+        const chunk = JSON.parse(payload);
+        const delta = chunk.choices?.[0]?.delta?.content;
+        if (typeof delta === "string" && delta.length > 0) yield delta;
+      } catch {
+      }
+    }
+  }
+}
+
+// src/server/narrators/index.ts
+function getNarrator(id) {
+  switch (id) {
+    case "claude":
+      return streamClaudeNarration;
+    case "gemini":
+      return streamGeminiNarration;
+    case "grok":
+      return streamGrokNarration;
+    default: {
+      const _exhaustive = id;
+      throw new Error(`Unknown narrator id: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+// src/server/routes/agent-custom.ts
+var NARRATOR_IDS = /* @__PURE__ */ new Set([
+  "claude",
+  "gemini",
+  "grok"
+]);
+function isNarratorId(value) {
+  return NARRATOR_IDS.has(value);
+}
+function jsonError(status, code, message) {
+  return new Response(JSON.stringify({ error: { code, message } }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function defaultGenerateSessionId() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+}
+function pickNarratorModelId(vertex, narratorId) {
+  if (narratorId === "claude") return vertex.modelIds.claude;
+  if (narratorId === "gemini") return vertex.modelIds.gemini;
+  const extra = vertex.modelIds;
+  if (typeof extra.grok === "string" && extra.grok.length > 0) {
+    return extra.grok;
+  }
+  throw new Error(
+    "Narrator 'grok' selected but VertexPort.modelIds.grok is not pinned."
+  );
+}
+function createAgentCustomRoutes(ctx) {
+  const { persistence, auth, scope, tools, vertex, logger, hooks } = ctx;
+  return {
+    /** Next.js-compatible POST handler. */
+    POST: async (req) => {
+      if (hooks?.onRequest) {
+        const short = await hooks.onRequest(req);
+        if (short) return short;
+      }
+      const authResult = await auth.requireAuth(req);
+      if (!authResult.ok) return authResult.response;
+      const { scope: callerScope, userId } = authResult;
+      if (hooks?.onAuthenticated) {
+        const short = await hooks.onAuthenticated({
+          req,
+          scope: callerScope,
+          userId
+        });
+        if (short) return short;
+      }
+      const body = await req.json().catch(() => null);
+      const question = typeof body?.question === "string" ? body.question.trim() : "";
+      if (!question) {
+        return jsonError(
+          400,
+          "VALIDATION_FAILED",
+          "question must be a non-empty string."
+        );
+      }
+      const rawChatSessionId = body?.chatSessionId;
+      const incomingChatSessionId = typeof rawChatSessionId === "number" && Number.isInteger(rawChatSessionId) ? rawChatSessionId : null;
+      const aiSettings = await persistence.getAiSettings();
+      let chatSessionId;
+      if (incomingChatSessionId !== null) {
+        const owned = await persistence.getSession(incomingChatSessionId, userId);
+        if (!owned) {
+          return jsonError(404, "NOT_FOUND", "Chat session not found.");
+        }
+        chatSessionId = owned.id;
+      } else {
+        const created = await persistence.createSession({
+          userId,
+          title: question.slice(0, 200)
+        });
+        chatSessionId = created.id;
+      }
+      await persistence.appendMessage({
+        sessionId: chatSessionId,
+        role: "user",
+        question
+      });
+      const sessionId = hooks?.generateSessionId ? await hooks.generateSessionId({
+        scope: callerScope,
+        userId,
+        chatSessionId: incomingChatSessionId
+      }) : defaultGenerateSessionId();
+      const scopeSummary = await scope.buildScopeSummary(callerScope);
+      const scopeLabel = await scope.resolveScopeLabel(callerScope);
+      const toolContext = {
+        scope: callerScope,
+        sessionId,
+        scopeSummary,
+        toolCallCount: 0
+      };
+      const systemBlocks = await tools.buildSystemBlocks(toolContext);
+      const def = getToolProvider(aiSettings.toolProvider);
+      if (!def) {
+        return jsonError(
+          400,
+          "INVALID_PROVIDER",
+          `Unknown tool provider in ai_settings: ${aiSettings.toolProvider}`
+        );
+      }
+      const provider = def.createProvider({
+        auth: vertex.auth,
+        projectId: vertex.projectId,
+        defaultLocation: vertex.defaultLocation,
+        modelIds: vertex.modelIds,
+        location: aiSettings.gcpLocation
+      });
+      let narratorId;
+      if (ctx.resolveNarratorId) {
+        narratorId = await ctx.resolveNarratorId(callerScope);
+      } else if (isNarratorId(aiSettings.toolProvider)) {
+        narratorId = aiSettings.toolProvider;
+      } else {
+        return jsonError(
+          400,
+          "INVALID_NARRATOR",
+          `Cannot derive narrator from tool provider: ${aiSettings.toolProvider}`
+        );
+      }
+      const stream = new ReadableStream({
+        async start(controller) {
+          const encoder = new TextEncoder();
+          let closed = false;
+          const send = (event, data) => {
+            if (closed) return;
+            try {
+              controller.enqueue(
+                encoder.encode(
+                  `event: ${event}
+data: ${JSON.stringify(data)}
+
+`
+                )
+              );
+            } catch {
+            }
+          };
+          const persistedBlocks = [];
+          const persistedProse = {};
+          let persistedError = null;
+          let sessionStarted = false;
+          try {
+            if (hooks?.onSessionStart) {
+              await hooks.onSessionStart({
+                scope: callerScope,
+                sessionId,
+                userId
+              });
+            }
+            sessionStarted = true;
+            send("meta", { chatSessionId, scopeLabel });
+            const agentResult = await runAgent({
+              question,
+              ctx: toolContext,
+              tools: tools.tools,
+              systemBlocks,
+              provider
+            });
+            if (!agentResult.ok) {
+              persistedError = agentResult.error;
+              send("error", agentResult.error);
+              send("done", {});
+              return;
+            }
+            const { structured } = agentResult;
+            let narratorModelId = null;
+            const narratorFn = getNarrator(narratorId);
+            for (let i = 0; i < structured.blocks.length; i++) {
+              const block = structured.blocks[i];
+              persistedBlocks[i] = block;
+              send("block", { index: i, ...block });
+              if (block.kind === "paragraph_brief") {
+                persistedProse[i] = "";
+                try {
+                  if (narratorModelId === null) {
+                    narratorModelId = pickNarratorModelId(vertex, narratorId);
+                  }
+                  for await (const token of narratorFn({
+                    auth: vertex.auth,
+                    projectId: vertex.projectId,
+                    location: aiSettings.gcpLocation,
+                    modelId: narratorModelId,
+                    input: {
+                      question,
+                      structured,
+                      topic: block.topic,
+                      keyFacts: block.key_facts,
+                      blockIndex: i
+                    }
+                  })) {
+                    persistedProse[i] += token;
+                    send("prose", { block_index: i, delta: token });
+                  }
+                } catch (e) {
+                  const fallback = block.key_facts.join(". ") + ".";
+                  persistedProse[i] = fallback;
+                  send("prose", {
+                    block_index: i,
+                    delta: block.key_facts.join(". ")
+                  });
+                  send("prose", { block_index: i, delta: "." });
+                  send("error", {
+                    code: "NARRATOR_FAILED",
+                    message: `Prose stream failed (${e.message}); fell back to key facts.`
+                  });
+                }
+              }
+            }
+            send("done", {});
+          } catch (e) {
+            const message = e.message ?? "Internal error";
+            persistedError = { code: "INTERNAL", message };
+            logger?.error?.(
+              { chatSessionId, sessionId, err: message },
+              "[agent-custom] stream errored"
+            );
+            try {
+              controller.enqueue(
+                encoder.encode(
+                  `event: error
+data: ${JSON.stringify({ code: "INTERNAL", message })}
+
+`
+                )
+              );
+              controller.enqueue(encoder.encode(`event: done
+data: {}
+
+`));
+            } catch {
+            }
+          } finally {
+            if (hooks?.onSessionEnd) {
+              const cause = req.signal.aborted ? "abort" : persistedError ? "error" : "complete";
+              try {
+                await hooks.onSessionEnd({
+                  scope: callerScope,
+                  sessionId,
+                  userId,
+                  cause
+                });
+              } catch (err2) {
+                logger?.warn?.(
+                  {
+                    chatSessionId,
+                    sessionId,
+                    sessionStarted,
+                    err: err2.message
+                  },
+                  "[agent-custom] onSessionEnd hook failed"
+                );
+              }
+            }
+            try {
+              await persistence.appendMessage({
+                sessionId: chatSessionId,
+                role: "assistant",
+                blocks: persistedBlocks.length ? persistedBlocks : null,
+                prose: Object.keys(persistedProse).length ? persistedProse : null,
+                errorJson: persistedError
+              });
+            } catch (err2) {
+              logger?.warn?.(
+                { chatSessionId, sessionId, err: err2.message },
+                "[agent-custom] failed to persist assistant turn"
+              );
+            }
+            try {
+              closed = true;
+              controller.close();
+            } catch {
+            }
+          }
+        }
+      });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Cache-Control": "no-cache, no-transform",
+          Connection: "keep-alive"
+        }
+      });
+    }
+  };
+}
+
+// src/server/routes/chat-sessions.ts
+var DEFAULT_TITLE = "New chat";
+var TITLE_MAX = 200;
+var STATUS_BY_CODE = {
+  UNAUTHORIZED: 401,
+  NOT_FOUND: 404,
+  VALIDATION_FAILED: 400,
+  INTERNAL: 500
+};
+function apiError(code, message) {
+  return Response.json(
+    { error: { code, message, details: {} } },
+    { status: STATUS_BY_CODE[code] }
+  );
+}
+function okJson(data) {
+  return Response.json(data);
+}
+function serializeSession(s) {
+  return {
+    id: s.id,
+    title: s.title,
+    createdAt: s.createdAt ? s.createdAt.toISOString() : null,
+    updatedAt: s.updatedAt ? s.updatedAt.toISOString() : null
+  };
+}
+function parseSessionId(raw) {
+  const id = Number(raw);
+  if (!Number.isInteger(id) || id <= 0) return null;
+  return id;
+}
+function createChatSessionsRoutes(ctx) {
+  const { persistence, auth, logger, hooks } = ctx;
+  async function gate(req) {
+    if (hooks?.onRequest) {
+      const r = await hooks.onRequest(req);
+      if (r) return { short: r };
+    }
+    const authed = await auth.requireAuth(req);
+    if (!authed.ok) return { short: authed.response };
+    if (hooks?.onAuthenticated) {
+      const r = await hooks.onAuthenticated({
+        req,
+        scope: authed.scope,
+        userId: authed.userId
+      });
+      if (r) return { short: r };
+    }
+    return { ok: true, scope: authed.scope, userId: authed.userId };
+  }
+  const list = {
+    /**
+     * `GET /api/chat/sessions` — caller's recent sessions, newest first,
+     * capped at 100. Response: `{ sessions: [{ id, title, createdAt, updatedAt }] }`.
+     */
+    GET: async (req) => {
+      try {
+        const g = await gate(req);
+        if ("short" in g) return g.short;
+        const rows = await persistence.listSessionsForUser(g.userId, { limit: 100 });
+        return okJson({ sessions: rows.map(serializeSession) });
+      } catch (err2) {
+        logger?.error("[chat-sessions] list.GET failed", err2);
+        const msg = err2 instanceof Error ? err2.message : "Internal error";
+        return apiError("INTERNAL", msg);
+      }
+    },
+    /**
+     * `POST /api/chat/sessions` — body `{ title?: string }`. Trims and caps
+     * title at 200 chars; defaults to "New chat" when blank.
+     * Response: `{ session: { id, title, createdAt, updatedAt } }`.
+     */
+    POST: async (req) => {
+      try {
+        const g = await gate(req);
+        if ("short" in g) return g.short;
+        const body = await req.json().catch(() => ({}));
+        const rawTitle = typeof body.title === "string" ? body.title.trim() : "";
+        const title = rawTitle ? rawTitle.slice(0, TITLE_MAX) : DEFAULT_TITLE;
+        const created = await persistence.createSession({ userId: g.userId, title });
+        return okJson({ session: serializeSession(created) });
+      } catch (err2) {
+        logger?.error("[chat-sessions] list.POST failed", err2);
+        const msg = err2 instanceof Error ? err2.message : "Internal error";
+        return apiError("INTERNAL", msg);
+      }
+    }
+  };
+  const detail = {
+    /**
+     * `GET /api/chat/sessions/[id]` — session metadata + ordered messages.
+     * 404 when the id doesn't exist or doesn't belong to the caller (we never
+     * differentiate the two, to avoid leaking the id space).
+     * Response: `{ session: { id, title, createdAt, updatedAt },
+     *             messages: [{ id, role, question, blocks, prose, errorJson, createdAt }] }`.
+     */
+    GET: async (req, params) => {
+      try {
+        const g = await gate(req);
+        if ("short" in g) return g.short;
+        const id = parseSessionId(params.id);
+        if (id === null) return apiError("NOT_FOUND", "Chat session not found.");
+        const meta = await persistence.getSession(id, g.userId);
+        if (!meta) return apiError("NOT_FOUND", "Chat session not found.");
+        const messages = await persistence.listMessagesForSession(id, g.userId);
+        return okJson({
+          session: serializeSession(meta),
+          messages: messages.map((m) => ({
+            id: m.id,
+            role: m.role,
+            question: m.question,
+            blocks: m.blocks,
+            prose: m.prose,
+            errorJson: m.errorJson,
+            createdAt: m.createdAt ? m.createdAt.toISOString() : null
+          }))
+        });
+      } catch (err2) {
+        logger?.error("[chat-sessions] detail.GET failed", err2);
+        const msg = err2 instanceof Error ? err2.message : "Internal error";
+        return apiError("INTERNAL", msg);
+      }
+    },
+    /**
+     * `PATCH /api/chat/sessions/[id]` — rename. Body `{ title: string }`,
+     * trimmed and capped at 200 chars. Response: `{ ok: true }`.
+     */
+    PATCH: async (req, params) => {
+      try {
+        const g = await gate(req);
+        if ("short" in g) return g.short;
+        const id = parseSessionId(params.id);
+        if (id === null) return apiError("NOT_FOUND", "Chat session not found.");
+        const meta = await persistence.getSession(id, g.userId);
+        if (!meta) return apiError("NOT_FOUND", "Chat session not found.");
+        const body = await req.json().catch(() => ({}));
+        if (typeof body.title !== "string") {
+          return apiError("VALIDATION_FAILED", "title must be a string.");
+        }
+        const trimmed = body.title.trim();
+        if (!trimmed) {
+          return apiError("VALIDATION_FAILED", "title must not be empty.");
+        }
+        await persistence.updateSession(id, g.userId, {
+          title: trimmed.slice(0, TITLE_MAX)
+        });
+        return okJson({ ok: true });
+      } catch (err2) {
+        logger?.error("[chat-sessions] detail.PATCH failed", err2);
+        const msg = err2 instanceof Error ? err2.message : "Internal error";
+        return apiError("INTERNAL", msg);
+      }
+    },
+    /**
+     * `DELETE /api/chat/sessions/[id]` — drop session and its messages.
+     * Response: `{ ok: true }`.
+     */
+    DELETE: async (req, params) => {
+      try {
+        const g = await gate(req);
+        if ("short" in g) return g.short;
+        const id = parseSessionId(params.id);
+        if (id === null) return apiError("NOT_FOUND", "Chat session not found.");
+        const meta = await persistence.getSession(id, g.userId);
+        if (!meta) return apiError("NOT_FOUND", "Chat session not found.");
+        await persistence.deleteSession(id, g.userId);
+        return okJson({ ok: true });
+      } catch (err2) {
+        logger?.error("[chat-sessions] detail.DELETE failed", err2);
+        const msg = err2 instanceof Error ? err2.message : "Internal error";
+        return apiError("INTERNAL", msg);
+      }
+    }
+  };
+  return { list, detail };
+}
+
+// src/server/routes/admin-settings.ts
+var VALID_LOCATIONS = ["us-east5", "global"];
+function isStringRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function toWire(settings) {
+  return {
+    tool_provider: settings.toolProvider,
+    gcp_location: settings.gcpLocation,
+    chat_interface: settings.chatInterface,
+    updated_at: settings.updatedAt ? settings.updatedAt.toISOString() : null,
+    updated_by_user_id: settings.updatedByUserId
+  };
+}
+function createAdminSettingsRoutes(ctx) {
+  const { persistence, auth, toolProviders: toolProviders2, chatInterfaces, logger, hooks } = ctx;
+  async function GET(req) {
+    if (hooks?.onRequest) {
+      const short = await hooks.onRequest(req);
+      if (short) return short;
+    }
+    const result = await auth.requireAuth(req);
+    if (!result.ok) return result.response;
+    if (hooks?.onAuthenticated) {
+      const short = await hooks.onAuthenticated({
+        req,
+        scope: result.scope,
+        userId: result.userId
+      });
+      if (short) return short;
+    }
+    if (!auth.isSuperAdmin(result.scope)) {
+      return jsonResponse(
+        { error: "forbidden", message: "Only super admins can read AI settings." },
+        403
+      );
+    }
+    const settings = await persistence.getAiSettings();
+    return jsonResponse(toWire(settings));
+  }
+  async function PATCH(req) {
+    if (hooks?.onRequest) {
+      const short = await hooks.onRequest(req);
+      if (short) return short;
+    }
+    const result = await auth.requireAuth(req);
+    if (!result.ok) return result.response;
+    if (hooks?.onAuthenticated) {
+      const short = await hooks.onAuthenticated({
+        req,
+        scope: result.scope,
+        userId: result.userId
+      });
+      if (short) return short;
+    }
+    if (!auth.isSuperAdmin(result.scope)) {
+      return jsonResponse(
+        { error: "forbidden", message: "Only super admins can change AI settings." },
+        403
+      );
+    }
+    const body = await req.json().catch(() => null);
+    if (!isStringRecord(body)) {
+      return jsonResponse({ error: "invalid_body", message: "Body must be JSON." }, 400);
+    }
+    const patch = {};
+    if ("tool_provider" in body) {
+      const v = body.tool_provider;
+      const validIds = toolProviders2.map((p) => p.id);
+      if (typeof v !== "string" || !validIds.includes(v)) {
+        return jsonResponse({ error: "invalid_tool_provider" }, 400);
+      }
+      patch.toolProvider = v;
+    }
+    if ("gcp_location" in body) {
+      const v = body.gcp_location;
+      if (typeof v !== "string" || !VALID_LOCATIONS.includes(v)) {
+        return jsonResponse({ error: "invalid_gcp_location" }, 400);
+      }
+      patch.gcpLocation = v;
+    }
+    if ("chat_interface" in body) {
+      const v = body.chat_interface;
+      const validIds = chatInterfaces.map((i) => i.id);
+      if (typeof v !== "string" || !validIds.includes(v)) {
+        return jsonResponse({ error: "invalid_chat_interface" }, 400);
+      }
+      patch.chatInterface = v;
+    }
+    if (patch.toolProvider === void 0 && patch.gcpLocation === void 0 && patch.chatInterface === void 0) {
+      return jsonResponse(
+        {
+          error: "empty_patch",
+          message: "Body must set at least one of tool_provider, gcp_location, chat_interface."
+        },
+        400
+      );
+    }
+    try {
+      const updated = await persistence.updateAiSettings(patch, result.userId);
+      return jsonResponse(toWire(updated));
+    } catch (err2) {
+      logger?.error("admin-settings PATCH failed", err2);
+      throw err2;
+    }
+  }
+  return { GET, PATCH };
+}
+
+// src/server/configure.ts
+var BUILTIN_CHAT_INTERFACE_IDS = ["custom", "vercel"];
+function configureAiChat(opts) {
+  const toolProviders2 = [
+    ...toolProviders,
+    ...opts.extraToolProviders ?? []
+  ];
+  const getProvider = (id) => toolProviders2.find((p) => p.id === id) ?? getToolProvider(id);
+  const chatInterfaces = opts.chatInterfaces ?? BUILTIN_CHAT_INTERFACE_IDS.map((id) => ({ id }));
+  const runAgentBound = async ({
+    question,
+    ctx,
+    providerId,
+    location,
+    maxToolTurns,
+    maxOutputTokens
+  }) => {
+    const settings = await opts.persistence.getAiSettings();
+    const def = getProvider(providerId ?? settings.toolProvider);
+    if (!def) {
+      throw new Error(
+        `Unknown tool provider '${providerId ?? settings.toolProvider}'. Registered: ${toolProviders2.map((p) => p.id).join(", ")}.`
+      );
+    }
+    const provider = def.createProvider({
+      auth: opts.vertex.auth,
+      projectId: opts.vertex.projectId,
+      defaultLocation: opts.vertex.defaultLocation,
+      modelIds: opts.vertex.modelIds,
+      location: location ?? settings.gcpLocation
+    });
+    const systemBlocks = await opts.tools.buildSystemBlocks(ctx);
+    const input = {
+      question,
+      ctx,
+      tools: opts.tools.tools,
+      systemBlocks,
+      provider,
+      maxToolTurns,
+      maxOutputTokens
+    };
+    return runAgent(input);
+  };
+  const sharedHooks = opts.hooks ? {
+    onRequest: opts.hooks.onRequest,
+    onAuthenticated: opts.hooks.onAuthenticated
+  } : void 0;
+  const agentCustom = createAgentCustomRoutes({
+    persistence: opts.persistence,
+    auth: opts.auth,
+    scope: opts.scope,
+    tools: opts.tools,
+    vertex: opts.vertex,
+    logger: opts.logger,
+    resolveNarratorId: opts.resolveNarratorId,
+    hooks: opts.hooks
+  });
+  const chatSessions = createChatSessionsRoutes({
+    persistence: opts.persistence,
+    auth: opts.auth,
+    logger: opts.logger,
+    hooks: sharedHooks
+  });
+  const adminSettings = createAdminSettingsRoutes({
+    persistence: opts.persistence,
+    auth: opts.auth,
+    toolProviders: toolProviders2,
+    chatInterfaces,
+    logger: opts.logger,
+    hooks: sharedHooks
+  });
+  return {
+    runAgent: runAgentBound,
+    routes: { agentCustom, chatSessions, adminSettings },
+    registries: { toolProviders: toolProviders2, chatInterfaces }
+  };
+}
+
+Object.defineProperty(exports, "GoogleAuth", {
+  enumerable: true,
+  get: function () { return googleAuthLibrary.GoogleAuth; }
+});
+exports.BUILTIN_CHAT_INTERFACE_IDS = BUILTIN_CHAT_INTERFACE_IDS;
+exports.DEFAULT_MAX_OUTPUT_TOKENS = DEFAULT_MAX_OUTPUT_TOKENS;
+exports.DEFAULT_MAX_TOOL_TURNS = DEFAULT_MAX_TOOL_TURNS;
+exports.TERMINAL_TOOL_NAME = TERMINAL_TOOL_NAME;
+exports.configureAiChat = configureAiChat;
+exports.err = err;
+exports.getToolProvider = getToolProvider;
+exports.ok = ok;
+exports.runAgent = runAgent;
+exports.toolProviders = toolProviders;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map