@odla-ai/ai 0.1.0

package/dist/index.js

@@ -0,0 +1,1122 @@
+import {
+  AuthError,
+  CapabilityError,
+  ConfigError,
+  ContextWindowError,
+  InvalidRequestError,
+  OdlaAIError,
+  ProviderError,
+  RateLimitError,
+  addUsage,
+  blocksOf,
+  emptyUsage,
+  extractText,
+  extractToolUses,
+  isAudioBlock,
+  isDocumentBlock,
+  isImageBlock,
+  isTextBlock,
+  isThinkingBlock,
+  isToolResultBlock,
+  isToolUseBlock,
+  normalizeError
+} from "./chunk-LANGYP65.js";
+
+// src/shape/capabilities.ts
+function chatCapabilities(overrides = {}) {
+  return {
+    kind: "chat",
+    textIn: true,
+    imageIn: true,
+    audioIn: false,
+    documentIn: false,
+    toolUse: true,
+    thinking: false,
+    effort: false,
+    streaming: true,
+    structuredOutput: true,
+    webSearch: false,
+    ...overrides
+  };
+}
+function validateRequest(spec, req) {
+  const caps = spec.capabilities;
+  const fail = (what) => {
+    throw new CapabilityError(
+      `Model "${spec.id}" (${spec.provider}) does not support ${what}.`
+    );
+  };
+  if (caps.kind !== "chat") fail(`chat requests (it is a "${caps.kind}" model)`);
+  for (const msg of req.messages) {
+    for (const block of blocksOf(msg.content)) {
+      if (block.type === "image" && !caps.imageIn) fail("image input");
+      if (block.type === "audio" && !caps.audioIn) fail("audio input");
+      if (block.type === "document" && !caps.documentIn) fail("document (PDF) input");
+    }
+  }
+  if (req.tools && req.tools.length > 0 && !caps.toolUse) fail("tool use");
+  if (req.webSearch && !caps.webSearch) fail("web search");
+  if (req.responseFormat && !caps.structuredOutput) fail("structured output");
+  if (req.effort && !caps.effort) fail("the effort parameter");
+  if (req.thinking === "adaptive" && !caps.thinking) fail("thinking");
+}
+
+// src/catalog/anthropic.ts
+var FRONTIER = () => chatCapabilities({
+  documentIn: true,
+  // PDF
+  thinking: true,
+  // adaptive
+  effort: true,
+  // output_config.effort
+  webSearch: true,
+  // web_search_20260209
+  audioIn: false
+  // Claude has no audio input
+});
+var ANTHROPIC_MODELS = [
+  {
+    id: "claude-opus-4-8",
+    provider: "anthropic",
+    nativeId: "claude-opus-4-8",
+    capabilities: FRONTIER(),
+    contextWindow: 1e6,
+    maxOutput: 128e3
+  },
+  {
+    id: "claude-sonnet-5",
+    provider: "anthropic",
+    nativeId: "claude-sonnet-5",
+    capabilities: FRONTIER(),
+    contextWindow: 1e6,
+    maxOutput: 128e3
+  },
+  {
+    id: "claude-fable-5",
+    provider: "anthropic",
+    nativeId: "claude-fable-5",
+    capabilities: FRONTIER(),
+    contextWindow: 1e6,
+    maxOutput: 128e3
+  },
+  {
+    // Haiku 4.5: no effort param (errors), web search needs Sonnet-4.6+, so both off.
+    id: "claude-haiku-4-5",
+    provider: "anthropic",
+    nativeId: "claude-haiku-4-5",
+    capabilities: chatCapabilities({
+      documentIn: true,
+      thinking: false,
+      effort: false,
+      webSearch: false,
+      audioIn: false
+    }),
+    contextWindow: 2e5,
+    maxOutput: 64e3
+  }
+];
+
+// src/catalog/openai.ts
+var OPENAI_MODELS = [
+  {
+    id: "gpt-5.5",
+    provider: "openai",
+    nativeId: "gpt-5.5",
+    capabilities: chatCapabilities({ effort: true }),
+    contextWindow: 4e5
+  },
+  {
+    id: "gpt-5",
+    provider: "openai",
+    nativeId: "gpt-5",
+    capabilities: chatCapabilities({ effort: true }),
+    contextWindow: 4e5
+  },
+  {
+    id: "gpt-5-mini",
+    provider: "openai",
+    nativeId: "gpt-5-mini",
+    capabilities: chatCapabilities({ effort: true }),
+    contextWindow: 4e5
+  },
+  {
+    // Non-reasoning multimodal chat (image input, no effort knob).
+    id: "gpt-4o",
+    provider: "openai",
+    nativeId: "gpt-4o",
+    capabilities: chatCapabilities(),
+    contextWindow: 128e3
+  },
+  {
+    // Audio-input model line — accepts audio, not images.
+    id: "gpt-audio",
+    provider: "openai",
+    nativeId: "gpt-audio",
+    capabilities: chatCapabilities({ imageIn: false, audioIn: true }),
+    contextWindow: 128e3
+  }
+];
+
+// src/catalog/google.ts
+var GEMINI = () => chatCapabilities({
+  audioIn: true,
+  documentIn: true,
+  thinking: true,
+  effort: true,
+  // mapped onto thinkingConfig
+  webSearch: true
+  // googleSearch grounding
+});
+var GOOGLE_MODELS = [
+  {
+    id: "gemini-2.5-pro",
+    provider: "google",
+    nativeId: "gemini-2.5-pro",
+    capabilities: GEMINI(),
+    contextWindow: 1e6
+  },
+  {
+    id: "gemini-2.5-flash",
+    provider: "google",
+    nativeId: "gemini-2.5-flash",
+    capabilities: GEMINI(),
+    contextWindow: 1e6
+  },
+  {
+    id: "gemini-2.0-flash",
+    provider: "google",
+    nativeId: "gemini-2.0-flash",
+    capabilities: chatCapabilities({
+      audioIn: true,
+      documentIn: true,
+      thinking: false,
+      effort: false,
+      webSearch: true
+    }),
+    contextWindow: 1e6
+  }
+];
+
+// src/catalog/index.ts
+function index(specs) {
+  const out = {};
+  for (const spec of specs) out[spec.id] = spec;
+  return out;
+}
+var DEFAULT_CATALOG = index([
+  ...ANTHROPIC_MODELS,
+  ...OPENAI_MODELS,
+  ...GOOGLE_MODELS
+]);
+function buildCatalog(base, extra = []) {
+  return { ...base, ...index(extra) };
+}
+function resolveModel(catalog, id) {
+  const spec = catalog[id];
+  if (!spec) {
+    const known = Object.keys(catalog).sort().join(", ");
+    throw new ConfigError(`Unknown model "${id}". Known models: ${known || "(none)"}.`);
+  }
+  return spec;
+}
+function providersInCatalog(catalog) {
+  const set = /* @__PURE__ */ new Set();
+  for (const spec of Object.values(catalog)) set.add(spec.provider);
+  return [...set];
+}
+
+// src/providers/registry.ts
+var cache = /* @__PURE__ */ new Map();
+async function getProvider(id, apiKey) {
+  const cacheKey = `${id}:${apiKey}`;
+  const existing = cache.get(cacheKey);
+  if (existing) return existing;
+  let provider;
+  switch (id) {
+    case "anthropic": {
+      const { AnthropicProvider } = await import("./anthropic-JXDXR7O7.js");
+      provider = new AnthropicProvider(apiKey);
+      break;
+    }
+    case "openai": {
+      const { OpenAIProvider } = await import("./openai-Y3OAONAU.js");
+      provider = new OpenAIProvider(apiKey);
+      break;
+    }
+    case "google": {
+      const { GoogleProvider } = await import("./google-3TFOFIQO.js");
+      provider = new GoogleProvider(apiKey);
+      break;
+    }
+  }
+  cache.set(cacheKey, provider);
+  return provider;
+}
+function registerProvider(id, apiKey, provider) {
+  cache.set(`${id}:${apiKey}`, provider);
+}
+function clearProviderCache() {
+  cache.clear();
+}
+
+// src/client/keys.ts
+async function resolveApiKey(provider, opts, forModel) {
+  let key;
+  if (opts.resolveKey) key = await opts.resolveKey(provider);
+  if (!key) key = opts.keys?.[provider];
+  if (!key) {
+    throw new ConfigError(
+      `No API key configured for provider "${provider}" (required by model "${forModel}"). Pass keys: { ${provider}: "..." } or a resolveKey() to init().`
+    );
+  }
+  return key;
+}
+function looksLikeKey(provider, key) {
+  switch (provider) {
+    case "anthropic":
+      return /^sk-ant-[a-zA-Z0-9_-]{20,}/.test(key);
+    case "openai":
+      return /^sk-(?!ant-)(?:proj-)?[a-zA-Z0-9_-]{20,}/.test(key);
+    case "google":
+      return /^AIza[0-9A-Za-z_-]{35}$/.test(key) || key.length >= 20;
+  }
+}
+function redact(text) {
+  return text.replace(/sk-ant-[a-zA-Z0-9_-]{6,}/g, "sk-ant-\u2026").replace(/sk-(?!ant-)(?:proj-)?[a-zA-Z0-9_-]{10,}/g, "sk-\u2026").replace(/\bAIza[0-9A-Za-z_-]{6,}/g, "AIza\u2026");
+}
+
+// src/client/init.ts
+function init(opts = {}) {
+  const catalog = opts.catalog ?? DEFAULT_CATALOG;
+  const pickModel = (model) => {
+    const chosen = model ?? opts.defaultModel;
+    if (!chosen) throw new ConfigError("No model specified and no defaultModel set in init().");
+    return chosen;
+  };
+  const resolveProviderFor = async (model) => {
+    const spec = resolveModel(catalog, model);
+    const injected = opts.providers?.[spec.provider];
+    if (injected) return { spec, provider: injected };
+    const key = await resolveApiKey(spec.provider, opts, model);
+    const provider = await getProvider(spec.provider, key);
+    return { spec, provider };
+  };
+  const chat = async (input) => {
+    const model = pickModel(input.model);
+    const req = { ...input, model };
+    const { spec, provider } = await resolveProviderFor(model);
+    validateRequest(spec, req);
+    return provider.create(spec, req);
+  };
+  async function* stream(input) {
+    const model = pickModel(input.model);
+    const req = { ...input, model };
+    const { spec, provider } = await resolveProviderFor(model);
+    if (!spec.capabilities.streaming) {
+      throw new CapabilityError(`Model "${model}" (${spec.provider}) does not support streaming.`);
+    }
+    validateRequest(spec, req);
+    yield* provider.stream(spec, req);
+  }
+  const extract = async (c) => {
+    const model = pickModel(c.model);
+    const req = {
+      model,
+      system: c.system,
+      messages: [{ role: "user", content: c.user }],
+      tools: [{ name: c.tool.name, description: c.tool.description ?? "", inputSchema: c.tool.parameters }],
+      toolChoice: { type: "tool", name: c.tool.name },
+      maxTokens: c.maxTokens ?? 4096
+    };
+    const { spec, provider } = await resolveProviderFor(model);
+    validateRequest(spec, req);
+    const res = await provider.create(spec, req);
+    const block = res.content.find((b) => b.type === "tool_use" && b.name === c.tool.name);
+    if (!block || block.type !== "tool_use") {
+      throw new ProviderError(`Model "${model}" did not return the forced tool call "${c.tool.name}".`);
+    }
+    return { value: block.input, usage: res.usage };
+  };
+  const search = async (c) => {
+    const model = pickModel(c.model);
+    const req = {
+      model,
+      system: c.system,
+      messages: [{ role: "user", content: c.user }],
+      webSearch: true,
+      maxTokens: c.maxTokens ?? 8192
+    };
+    const { spec, provider } = await resolveProviderFor(model);
+    validateRequest(spec, req);
+    const res = await provider.create(spec, req);
+    return { text: extractText(res.content), usage: res.usage };
+  };
+  return { catalog, chat, stream, extract, search };
+}
+
+// src/doc/llms.ts
+function capsSummary(c) {
+  const flags = ["text"];
+  if (c.imageIn) flags.push("image");
+  if (c.audioIn) flags.push("audio");
+  if (c.toolUse) flags.push("tools");
+  if (c.thinking) flags.push("thinking");
+  if (c.effort) flags.push("effort");
+  if (c.webSearch) flags.push("web-search");
+  if (c.structuredOutput) flags.push("structured");
+  return flags.join(", ");
+}
+function generateLlmsTxt(catalog = DEFAULT_CATALOG) {
+  const models = Object.values(catalog).map((s) => `- \`${s.id}\` (${s.provider}) \u2014 ${capsSummary(s.capabilities)}`).join("\n");
+  return `# @odla-ai/ai \u2014 LLM context
+
+One general-purpose interface for AI inference across Anthropic (Claude), OpenAI
+(GPT), and Google (Gemini) \u2014 text, image, and audio \u2014 plus a tool-use agent
+engine and an eval harness. Library-only: import in-process, bring your own keys.
+Isomorphic (Node 20+, Cloudflare Workers, browser). Provider SDKs are lazy-loaded.
+
+## Install
+
+    npm i @odla-ai/ai
+    # provider SDKs are peer-lazy-loaded; install those you use:
+    #   @anthropic-ai/sdk  openai  @google/genai
+    # optional, for odla-db-backed storage + secrets:
+    #   @odla-ai/db
+
+## Core call
+
+    import { init } from "@odla-ai/ai";
+    const ai = init({ keys: { anthropic: KEY, openai: KEY, google: KEY }, defaultModel: "claude-opus-4-8" });
+    const res = await ai.chat({ model: "gpt-5", messages: [{ role: "user", content: "hi" }], maxTokens: 256 });
+    // res.content: OracleContentBlock[]  (text/tool_use/thinking)
+
+- \`ai.stream(input)\` \u2192 async iterable of normalized events: message_start \u2192
+  content_block_start \u2192 content_block_delta {text_delta|thinking_delta|input_json_delta}
+  \u2192 content_block_stop \u2192 message_delta \u2192 message_stop (plus \`error\`).
+- \`ai.extract<T>({ model, user, tool })\` \u2192 forced tool call; returns a parsed object.
+- \`ai.search({ model, user })\` \u2192 web-search-grounded prose.
+
+## Content blocks (multimodal)
+
+text; image { source: base64|url }; audio { source: base64|url }; document (PDF);
+tool_use { id, name, input }; tool_result { toolUseId, content }; thinking.
+Audio input is accepted by OpenAI (\`gpt-audio\`) and Google, NOT by Claude \u2014 an
+audio block to a Claude model throws CapabilityError before any network call.
+
+## Agents
+
+    import { runAgent, type Persona, type ToolDef } from "@odla-ai/ai";
+    const add: ToolDef = { name: "add", description: "add", inputSchema: {...}, handler: (i) => ({ content: String(i.a + i.b) }) };
+    const persona: Persona = { name: "calc", model: "claude-opus-4-8", system: "...", tools: [add], maxSteps: 4 };
+    const run = await runAgent(ai, persona, { input: "what is 21+21?" });
+    // run.finalText, run.toolCalls, run.usage, run.steps, run.stoppedReason
+
+Tools may carry taint labels (outputTaint / acceptsTaint) for a CaMeL-style
+prompt-injection gate. Personas may carry a MemoryScope.
+
+## Skills
+
+A Skill = { name, instructions?, tools: ToolDef[] } is a bundle you attach to a
+persona (persona.skills); its tools merge into the model's tool list and its
+instructions into the system prompt. Turn an odla-db entity into CRUD tools:
+
+    import { entityCrudSkill } from "@odla-ai/ai";
+    const todos = entityCrudSkill({ db, entity: "todos", fields: { text: { type: "string" }, done: { type: "boolean" } }, required: ["text"] });
+    // \u2192 tools: list_todos, create_todo, update_todo (partial), delete_todo \u2014 handlers write to odla-db
+    const run = await runAgent(ai, { name: "todo-bot", model: "gpt-5", skills: [todos] }, { input: "add buy milk" });
+
+## Evals
+
+    import { evaluate, exactMatch, llmJudge } from "@odla-ai/ai";
+    const report = await evaluate({ inference: ai, model: "claude-opus-4-8", grader: exactMatch(), cases: [{ input, expected }] });
+    // graders: exactMatch, includes, structuredMatch, llmJudge; pass a persona to eval an agent.
+
+## Storage + BYO keys via odla-db (@odla-ai/db) \u2014 the handshake
+
+Follows odla-db's model. An agent never takes a platform secret; it does a
+device-authorization handshake for a scoped, revocable token, then provisions.
+
+    import { requestToken, init as odlaInit } from "@odla-ai/db";
+    import { provisionAgentApp, odlaDbKeyResolver, OdlaDbMemory, persistRun, init } from "@odla-ai/ai";
+
+    // 1. Handshake: the human supplies the endpoint and approves a short code in odla-db Studio.
+    const { token } = await requestToken({ endpoint: ODLA_URL, onCode: ({ userCode }) => show(userCode) });
+
+    // 2. Provision: create app, mint app key, push agent schema, store BYO provider keys as secrets.
+    const { appId, appKey } = await provisionAgentApp({ endpoint: ODLA_URL, token, providerKeys: { openai: OPENAI_KEY } });
+
+    // 3. Runtime: read keys from odla-db secrets; persist memory + run traces.
+    const db = odlaInit({ appId, adminToken: appKey, endpoint: ODLA_URL });
+    const ai = init({ resolveKey: odlaDbKeyResolver(db) });
+    const persona = { name: "assistant", model: "gpt-5", memory: new OdlaDbMemory({ db, sessionId: "user-42" }) };
+    const run = await runAgent(ai, persona, { input: "hello" });
+    await persistRun(run, { db, sessionId: "user-42" });
+
+Secrets are read-only from the app key (odlaDbKeyResolver \u2192 db.secrets.get); they
+are WRITTEN only with the operator/dev token via provisionAgentApp/putSecret. Keys
+are AES-GCM-encrypted at rest in odla-db and never returned to browser clients.
+
+## Errors
+
+Every error is an OdlaAIError subclass with a stable \`code\` \u2014 branch on err.code:
+config, auth, rate_limit, capability_unsupported, context_window, invalid_request,
+tool_input_invalid, provider_error.
+
+## Models
+
+${models}
+
+Model ids live in a data catalog and drift \u2014 verify against provider docs; extend
+via buildCatalog / init({ catalog }).
+`;
+}
+
+// src/agent/tools.ts
+function toOracleTool(t) {
+  return { name: t.name, description: t.description, inputSchema: t.inputSchema };
+}
+
+// src/agent/skill.ts
+function composeSkills(system, tools, skills) {
+  const composedTools = [...tools ?? []];
+  const sections = system ? [system] : [];
+  for (const skill of skills ?? []) {
+    composedTools.push(...skill.tools);
+    if (skill.instructions) sections.push(`## ${skill.name}
+${skill.instructions}`);
+  }
+  return { system: sections.length > 0 ? sections.join("\n\n") : void 0, tools: composedTools };
+}
+
+// src/agent/taint.ts
+function taint(...labels) {
+  return new Set(labels);
+}
+var TaintError = class extends OdlaAIError {
+  constructor(message) {
+    super("invalid_request", message);
+  }
+};
+function assertSinkAcceptsTaint(sink, allowed, actual) {
+  const allow = new Set(allowed);
+  for (const label of actual) {
+    if (!allow.has(label)) {
+      throw new TaintError(
+        `Tool "${sink}" refused: conversation carries taint "${label}" which is not in its allowlist [${allowed.join(", ")}].`
+      );
+    }
+  }
+}
+
+// src/agent/loop.ts
+async function runAgent(inference, persona, input) {
+  const { system, tools } = composeSkills(persona.system, persona.tools, persona.skills);
+  const handlerByName = /* @__PURE__ */ new Map();
+  for (const t of tools) if (t.handler) handlerByName.set(t.name, t);
+  const priorFromMemory = persona.memory ? await persona.memory.load() : [];
+  const startingInput = input.messages ? input.messages : input.input !== void 0 ? [{ role: "user", content: input.input }] : [];
+  const messages = [...priorFromMemory, ...startingInput];
+  const runStartIndex = messages.length - startingInput.length;
+  const usage = emptyUsage();
+  const toolCalls = [];
+  const accumulatedTaint = /* @__PURE__ */ new Set(["llm_inherited"]);
+  const maxSteps = persona.maxSteps ?? 8;
+  let response;
+  let stoppedReason = "max_steps";
+  let steps = 0;
+  while (steps < maxSteps) {
+    steps++;
+    response = await inference.chat({
+      model: persona.model,
+      system,
+      messages,
+      tools: tools.length > 0 ? tools.map(toOracleTool) : void 0,
+      maxTokens: persona.maxTokens ?? 4096,
+      effort: persona.effort,
+      thinking: persona.thinking,
+      temperature: persona.temperature,
+      webSearch: persona.webSearch
+    });
+    addUsage(usage, response.usage);
+    messages.push({ role: "assistant", content: response.content });
+    if (response.stopReason === "refusal") {
+      stoppedReason = "refusal";
+      break;
+    }
+    const toolUses = extractToolUses(response.content);
+    if (toolUses.length === 0) {
+      stoppedReason = "end_turn";
+      break;
+    }
+    const resultBlocks = [];
+    for (const toolUse of toolUses) {
+      const def = handlerByName.get(toolUse.name);
+      if (!def || !def.handler) {
+        resultBlocks.push(errorResult(toolUse.id, `No local handler for tool "${toolUse.name}".`));
+        continue;
+      }
+      if (def.acceptsTaint) assertSinkAcceptsTaint(def.name, def.acceptsTaint, accumulatedTaint);
+      let output;
+      try {
+        output = await def.handler(toolUse.input, { taint: new Set(accumulatedTaint), signal: input.signal });
+      } catch (err) {
+        output = { content: `Tool "${toolUse.name}" threw: ${err.message}`, isError: true };
+      }
+      toolCalls.push({ toolUse, output });
+      resultBlocks.push({ type: "tool_result", toolUseId: toolUse.id, content: output.content, isError: output.isError });
+      for (const label of def.outputTaint ?? []) accumulatedTaint.add(label);
+    }
+    messages.push({ role: "user", content: resultBlocks });
+  }
+  if (!response) throw new Error("runAgent: maxSteps must be at least 1");
+  if (persona.memory) await persona.memory.append(messages.slice(runStartIndex));
+  return {
+    finalText: extractText(response.content),
+    response,
+    messages,
+    usage,
+    steps,
+    toolCalls,
+    stoppedReason
+  };
+}
+function errorResult(toolUseId, message) {
+  return { type: "tool_result", toolUseId, content: message, isError: true };
+}
+
+// src/agent/memory.ts
+var InMemoryScope = class {
+  messages = [];
+  load() {
+    return [...this.messages];
+  }
+  append(messages) {
+    this.messages.push(...messages);
+  }
+  clear() {
+    this.messages = [];
+  }
+};
+
+// src/eval/harness.ts
+async function evaluate(opts) {
+  if (!opts.persona && !opts.model) {
+    throw new Error("evaluate() requires either a persona or a model.");
+  }
+  const results = await runPool(opts.cases, opts.concurrency ?? 5, (c) => runCase(opts, c));
+  const usage = emptyUsage();
+  let passed = 0;
+  for (const r of results) {
+    addUsage(usage, r.usage);
+    if (r.grade.pass) passed++;
+  }
+  const total = results.length;
+  return { total, passed, failed: total - passed, passRate: total ? passed / total : 0, results, usage };
+}
+async function runCase(opts, c) {
+  const messages = toMessages(c.input);
+  let output;
+  let response;
+  let usage;
+  if (opts.persona) {
+    const run = await runAgent(opts.inference, opts.persona, { messages });
+    output = run.finalText;
+    response = run.response;
+    usage = run.usage;
+  } else {
+    response = await opts.inference.chat({
+      model: opts.model,
+      system: opts.system,
+      messages,
+      maxTokens: opts.maxTokens ?? 1024
+    });
+    output = extractText(response.content);
+    usage = response.usage;
+  }
+  const grade = await opts.grader({ case: c, output, response });
+  return { case: c, output, grade, response, usage };
+}
+function toMessages(input) {
+  if (Array.isArray(input) && input.length > 0 && "role" in input[0]) {
+    return input;
+  }
+  return [{ role: "user", content: input }];
+}
+async function runPool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+// src/eval/graders.ts
+function exactMatch() {
+  return ({ case: c, output }) => {
+    const expected = String(c.expected ?? "").trim();
+    const pass = output.trim() === expected;
+    return { pass, reason: pass ? "exact match" : `expected "${expected}", got "${output.trim()}"` };
+  };
+}
+function includes(opts = {}) {
+  const ci = opts.caseInsensitive ?? true;
+  return ({ case: c, output }) => {
+    const needle = String(c.expected ?? "");
+    const hay = ci ? output.toLowerCase() : output;
+    const pass = hay.includes(ci ? needle.toLowerCase() : needle);
+    return { pass, reason: pass ? `contains "${needle}"` : `missing "${needle}"` };
+  };
+}
+function structuredMatch() {
+  return ({ case: c, output }) => {
+    let actual;
+    try {
+      actual = JSON.parse(stripFences(output));
+    } catch {
+      return { pass: false, reason: "output is not valid JSON" };
+    }
+    const ok = subset(c.expected, actual);
+    return { pass: ok, reason: ok ? "structural subset match" : "output is missing expected fields/values" };
+  };
+}
+function llmJudge(opts) {
+  return async ({ case: c, output }) => {
+    const rubric = typeof c.expected === "string" ? c.expected : JSON.stringify(c.expected);
+    const system = 'You are a strict evaluation judge. Decide whether the CANDIDATE output satisfies the RUBRIC. Respond with ONLY a JSON object: {"pass": boolean, "reason": string}. No prose, no code fences.' + (opts.extraGuidance ? ` ${opts.extraGuidance}` : "");
+    const user = `RUBRIC:
+${rubric}
+
+CANDIDATE:
+${output}`;
+    const res = await opts.inference.chat({
+      model: opts.model,
+      system,
+      messages: [{ role: "user", content: user }],
+      maxTokens: 512
+    });
+    const text = extractText(res.content);
+    try {
+      const verdict = JSON.parse(stripFences(text));
+      return { pass: Boolean(verdict.pass), reason: typeof verdict.reason === "string" ? verdict.reason : void 0 };
+    } catch {
+      const pass = /\bpass(ed)?\b|\btrue\b|\byes\b/i.test(text) && !/\bfail(ed)?\b|\bfalse\b|\bno\b/i.test(text);
+      return { pass, reason: `unparseable judge output: ${text.slice(0, 200)}` };
+    }
+  };
+}
+function stripFences(s) {
+  return s.replace(/^\s*```(?:json)?\s*/i, "").replace(/\s*```\s*$/i, "").trim();
+}
+function subset(expected, actual) {
+  if (expected === null || typeof expected !== "object") return expected === actual;
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual) || actual.length < expected.length) return false;
+    return expected.every((e, i) => subset(e, actual[i]));
+  }
+  if (actual === null || typeof actual !== "object" || Array.isArray(actual)) return false;
+  const a = actual;
+  return Object.entries(expected).every(([k, v]) => subset(v, a[k]));
+}
+
+// src/store/schema.ts
+var NS = {
+  conversation: "agent_conversation",
+  message: "agent_message",
+  run: "agent_run"
+};
+var AGENT_SCHEMA = {
+  entities: {
+    agent_conversation: {
+      attrs: {
+        key: { type: "string", unique: true, indexed: true, optional: false },
+        sessionId: { type: "string", unique: false, indexed: true, optional: false },
+        title: { type: "string", unique: false, indexed: false, optional: true },
+        createdAt: { type: "date", unique: false, indexed: true, optional: false },
+        updatedAt: { type: "date", unique: false, indexed: true, optional: false }
+      }
+    },
+    agent_message: {
+      attrs: {
+        key: { type: "string", unique: true, indexed: true, optional: false },
+        sessionId: { type: "string", unique: false, indexed: true, optional: false },
+        seq: { type: "number", unique: false, indexed: true, optional: false },
+        role: { type: "string", unique: false, indexed: false, optional: false },
+        content: { type: "string", unique: false, indexed: false, optional: false },
+        createdAt: { type: "date", unique: false, indexed: true, optional: false }
+      }
+    },
+    agent_run: {
+      attrs: {
+        key: { type: "string", unique: true, indexed: true, optional: false },
+        sessionId: { type: "string", unique: false, indexed: true, optional: false },
+        persona: { type: "string", unique: false, indexed: false, optional: true },
+        status: { type: "string", unique: false, indexed: true, optional: false },
+        steps: { type: "number", unique: false, indexed: false, optional: false },
+        inputTokens: { type: "number", unique: false, indexed: false, optional: false },
+        outputTokens: { type: "number", unique: false, indexed: false, optional: false },
+        finalText: { type: "string", unique: false, indexed: false, optional: true },
+        trace: { type: "json", unique: false, indexed: false, optional: false },
+        createdAt: { type: "date", unique: false, indexed: true, optional: false }
+      }
+    }
+  },
+  links: {}
+};
+
+// src/store/memory.ts
+var OdlaDbMemory = class {
+  db;
+  sessionId;
+  title;
+  msgNs;
+  convNs;
+  loadedCount = 0;
+  constructor(opts) {
+    this.db = opts.db;
+    this.sessionId = opts.sessionId;
+    this.title = opts.title;
+    this.msgNs = opts.namespaces?.message ?? NS.message;
+    this.convNs = opts.namespaces?.conversation ?? NS.conversation;
+  }
+  async load() {
+    const res = await this.db.query({
+      [this.msgNs]: { $: { where: { sessionId: this.sessionId }, order: { seq: "asc" }, limit: 1e5 } }
+    });
+    const rows = res[this.msgNs] ?? [];
+    this.loadedCount = rows.length;
+    return rows.map((r) => ({ role: r.role ?? "user", content: parseContent(r.content) }));
+  }
+  async append(messages) {
+    if (messages.length === 0) return;
+    const base = this.loadedCount;
+    const now = Date.now();
+    const ops = [
+      {
+        t: "update",
+        ns: this.convNs,
+        id: { ns: this.convNs, attr: "key", value: this.sessionId },
+        attrs: {
+          key: this.sessionId,
+          sessionId: this.sessionId,
+          ...this.title ? { title: this.title } : {},
+          ...base === 0 ? { createdAt: now } : {},
+          updatedAt: now
+        }
+      }
+    ];
+    messages.forEach((m, i) => {
+      const seq = base + i;
+      const key = `${this.sessionId}:${seq}`;
+      ops.push({
+        t: "update",
+        ns: this.msgNs,
+        id: { ns: this.msgNs, attr: "key", value: key },
+        attrs: { key, sessionId: this.sessionId, seq, role: m.role, content: JSON.stringify(m.content), createdAt: now }
+      });
+    });
+    await this.db.transact(ops, {
+      mutationId: `${this.sessionId}:append:${base}:${base + messages.length}`
+    });
+    this.loadedCount += messages.length;
+  }
+};
+function parseContent(raw) {
+  if (raw === void 0) return "";
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+// src/store/runs.ts
+async function persistRun(run, opts) {
+  const ns = opts.namespace ?? NS.run;
+  const key = opts.runId ?? `${opts.sessionId}:${Date.now()}`;
+  await opts.db.transact(
+    [
+      {
+        t: "update",
+        ns,
+        id: { ns, attr: "key", value: key },
+        attrs: {
+          key,
+          sessionId: opts.sessionId,
+          ...opts.personaName ? { persona: opts.personaName } : {},
+          status: run.stoppedReason,
+          steps: run.steps,
+          inputTokens: run.usage.inputTokens,
+          outputTokens: run.usage.outputTokens,
+          finalText: run.finalText,
+          trace: {
+            toolCalls: run.toolCalls.map((t) => ({ name: t.toolUse.name, input: t.toolUse.input, output: t.output })),
+            messages: run.messages
+          },
+          createdAt: Date.now()
+        }
+      }
+    ],
+    { mutationId: `run:${key}` }
+  );
+  return key;
+}
+async function queryRuns(opts) {
+  const ns = opts.namespace ?? NS.run;
+  const res = await opts.db.query({
+    [ns]: { $: { where: { sessionId: opts.sessionId }, order: { createdAt: "desc" }, limit: opts.limit ?? 50 } }
+  });
+  return res[ns] ?? [];
+}
+
+// src/store/keys.ts
+var DEFAULT_SECRET_NAMES = {
+  anthropic: "anthropic_api_key",
+  openai: "openai_api_key",
+  google: "google_api_key"
+};
+function odlaDbKeyResolver(db, opts = {}) {
+  const nameFor = opts.secretName ?? ((p) => DEFAULT_SECRET_NAMES[p]);
+  const useCache = opts.cache ?? true;
+  const cache2 = /* @__PURE__ */ new Map();
+  return async (provider) => {
+    if (useCache) {
+      const hit = cache2.get(provider);
+      if (hit !== void 0) return hit;
+    }
+    try {
+      const key = await db.secrets.get(nameFor(provider));
+      if (useCache) cache2.set(provider, key);
+      return key;
+    } catch {
+      return void 0;
+    }
+  };
+}
+
+// src/store/provision.ts
+async function post(ctx, path, body) {
+  const f = ctx.fetch ?? fetch;
+  const res = await f(`${ctx.endpoint.replace(/\/$/, "")}${path}`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${ctx.token}`, "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw errorFor(res.status, await safeText(res), path);
+  return await res.json().catch(() => ({}));
+}
+async function postWithKey(ctx, path, appKey, body) {
+  const f = ctx.fetch ?? fetch;
+  const res = await f(`${ctx.endpoint.replace(/\/$/, "")}${path}`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${appKey}`, "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw errorFor(res.status, await safeText(res), path);
+  return await res.json().catch(() => ({}));
+}
+async function createApp(ctx, opts = {}) {
+  const body = {};
+  if (opts.appId) body.appId = opts.appId;
+  if (opts.name) body.name = opts.name;
+  const json = await post(ctx, "/admin/apps", body);
+  const appId = json.appId ?? json.id ?? json.app?.appId ?? opts.appId;
+  if (!appId) throw new ProviderError("[odla-db] createApp: response did not include an appId");
+  return appId;
+}
+async function mintAppKey(ctx, appId) {
+  const json = await post(ctx, `/admin/apps/${encodeURIComponent(appId)}/keys`, {});
+  const key = json.key;
+  if (!key) throw new ProviderError("[odla-db] mintAppKey: response did not include a key");
+  return key;
+}
+async function pushAgentSchema(ctx, appId, appKey) {
+  await postWithKey(ctx, `/app/${encodeURIComponent(appId)}/schema`, appKey, { schema: AGENT_SCHEMA });
+}
+async function putSecret(ctx, appId, name, value) {
+  await post(ctx, `/admin/apps/${encodeURIComponent(appId)}/secrets`, { name, value });
+}
+async function provisionAgentApp(opts) {
+  const ctx = { endpoint: opts.endpoint, token: opts.token, fetch: opts.fetch };
+  const appId = await createApp(ctx, { appId: opts.appId, name: opts.appName });
+  const appKey = await mintAppKey(ctx, appId);
+  if (opts.pushSchema !== false) {
+    await pushAgentSchema({ endpoint: opts.endpoint, fetch: opts.fetch }, appId, appKey);
+  }
+  const nameFor = opts.secretName ?? ((p) => DEFAULT_SECRET_NAMES[p]);
+  for (const [provider, value] of Object.entries(opts.providerKeys ?? {})) {
+    if (!value) continue;
+    await putSecret(ctx, appId, nameFor(provider), value);
+  }
+  return { appId, appKey };
+}
+function errorFor(status, text, path) {
+  const msg = redact(`[odla-db] ${path} \u2192 ${status} ${text}`.trim());
+  if (status === 401 || status === 403) return new AuthError(msg, { providerStatus: status });
+  if (status === 501) return new ConfigError(`${msg} (secrets/feature not enabled on the odla-db worker)`);
+  if (status === 400) return new ConfigError(msg);
+  return new ProviderError(msg, { providerStatus: status });
+}
+async function safeText(res) {
+  try {
+    return (await res.text()).slice(0, 300);
+  } catch {
+    return "";
+  }
+}
+
+// src/store/crud.ts
+function entityCrudSkill(opts) {
+  const { db, entity, fields } = opts;
+  const singular = opts.singular ?? entity.replace(/s$/, "");
+  const plural = opts.plural ?? entity;
+  const idField = opts.idField ?? "id";
+  const genId = opts.genId ?? (() => globalThis.crypto.randomUUID());
+  const stampAttr = opts.stampCreatedAt === void 0 ? "createdAt" : opts.stampCreatedAt;
+  const order = opts.order ?? { createdAt: "asc" };
+  const fieldNames = Object.keys(fields);
+  const pickFields = (input) => {
+    const out = {};
+    for (const k of fieldNames) if (k in input && input[k] !== void 0) out[k] = input[k];
+    return out;
+  };
+  const ok = (obj) => ({ content: JSON.stringify(obj) });
+  const listTool = {
+    name: `list_${plural}`,
+    description: `List ${plural}. Optionally filter by exact field values and/or limit the count.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        filter: { type: "object", description: `Exact-match filters, e.g. { "done": false }`, additionalProperties: true },
+        limit: { type: "number", description: "Max rows to return." }
+      }
+    },
+    handler: async (input) => {
+      const filter = input.filter ?? void 0;
+      const limit = typeof input.limit === "number" ? input.limit : void 0;
+      const $ = { order };
+      if (filter && Object.keys(filter).length > 0) $.where = filter;
+      if (limit !== void 0) $.limit = limit;
+      const res = await db.query({ [entity]: { $ } });
+      return ok({ [plural]: res[entity] ?? [] });
+    }
+  };
+  const createTool = {
+    name: `create_${singular}`,
+    description: `Create a new ${singular}.`,
+    inputSchema: { type: "object", properties: fields, ...opts.required ? { required: opts.required } : {} },
+    handler: async (input) => {
+      const id = genId();
+      const attrs = pickFields(input);
+      if (stampAttr) attrs[stampAttr] = Date.now();
+      await db.transact([{ t: "update", ns: entity, id, attrs }]);
+      return ok({ id, created: true });
+    }
+  };
+  const updateTool = {
+    name: `update_${singular}`,
+    description: `Update fields of an existing ${singular} by ${idField}. Only the fields you pass change.`,
+    inputSchema: {
+      type: "object",
+      properties: { [idField]: { type: "string", description: `The ${singular}'s id.` }, ...fields },
+      required: [idField]
+    },
+    handler: async (input) => {
+      const id = String(input[idField] ?? "");
+      if (!id) return { content: `Missing "${idField}".`, isError: true };
+      const attrs = pickFields(input);
+      if (Object.keys(attrs).length === 0) return { content: "No fields to update.", isError: true };
+      await db.transact([{ t: "update", ns: entity, id, attrs }]);
+      return ok({ id, updated: true });
+    }
+  };
+  const deleteTool = {
+    name: `delete_${singular}`,
+    description: `Delete a ${singular} by ${idField}.`,
+    inputSchema: { type: "object", properties: { [idField]: { type: "string" } }, required: [idField] },
+    handler: async (input) => {
+      const id = String(input[idField] ?? "");
+      if (!id) return { content: `Missing "${idField}".`, isError: true };
+      const op = { t: "delete", ns: entity, id };
+      await db.transact([op]);
+      return ok({ id, deleted: true });
+    }
+  };
+  const guidance = `Manage ${plural} in the database. Use list_${plural} to read (optionally filtered), create_${singular} to add, update_${singular} to change fields (e.g. mark done), and delete_${singular} to remove. Always confirm the current list with list_${plural} before updating or deleting so you use the right id.` + (opts.instructions ? `
+${opts.instructions}` : "");
+  return {
+    name: opts.name ?? `${entity} management`,
+    instructions: guidance,
+    tools: [listTool, createTool, updateTool, deleteTool]
+  };
+}
+export {
+  AGENT_SCHEMA,
+  ANTHROPIC_MODELS,
+  AuthError,
+  CapabilityError,
+  ConfigError,
+  ContextWindowError,
+  DEFAULT_CATALOG,
+  DEFAULT_SECRET_NAMES,
+  GOOGLE_MODELS,
+  InMemoryScope,
+  InvalidRequestError,
+  NS,
+  OPENAI_MODELS,
+  OdlaAIError,
+  OdlaDbMemory,
+  ProviderError,
+  RateLimitError,
+  TaintError,
+  addUsage,
+  assertSinkAcceptsTaint,
+  blocksOf,
+  buildCatalog,
+  chatCapabilities,
+  clearProviderCache,
+  composeSkills,
+  createApp,
+  emptyUsage,
+  entityCrudSkill,
+  evaluate,
+  exactMatch,
+  extractText,
+  extractToolUses,
+  generateLlmsTxt,
+  getProvider,
+  includes,
+  init,
+  isAudioBlock,
+  isDocumentBlock,
+  isImageBlock,
+  isTextBlock,
+  isThinkingBlock,
+  isToolResultBlock,
+  isToolUseBlock,
+  llmJudge,
+  looksLikeKey,
+  mintAppKey,
+  normalizeError,
+  odlaDbKeyResolver,
+  persistRun,
+  providersInCatalog,
+  provisionAgentApp,
+  pushAgentSchema,
+  putSecret,
+  queryRuns,
+  redact,
+  registerProvider,
+  resolveModel,
+  runAgent,
+  structuredMatch,
+  taint,
+  toOracleTool,
+  validateRequest
+};
+//# sourceMappingURL=index.js.map