@odla-ai/ai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2002 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shape/index.ts
+function emptyUsage() {
+  return { inputTokens: 0, outputTokens: 0 };
+}
+function addUsage(into, more) {
+  into.inputTokens += more.inputTokens;
+  into.outputTokens += more.outputTokens;
+  if (more.cacheCreationTokens !== void 0) {
+    into.cacheCreationTokens = (into.cacheCreationTokens ?? 0) + more.cacheCreationTokens;
+  }
+  if (more.cacheReadTokens !== void 0) {
+    into.cacheReadTokens = (into.cacheReadTokens ?? 0) + more.cacheReadTokens;
+  }
+}
+function isTextBlock(b) {
+  return b.type === "text";
+}
+function isImageBlock(b) {
+  return b.type === "image";
+}
+function isAudioBlock(b) {
+  return b.type === "audio";
+}
+function isDocumentBlock(b) {
+  return b.type === "document";
+}
+function isToolUseBlock(b) {
+  return b.type === "tool_use";
+}
+function isToolResultBlock(b) {
+  return b.type === "tool_result";
+}
+function isThinkingBlock(b) {
+  return b.type === "thinking";
+}
+function blocksOf(content) {
+  return typeof content === "string" ? [{ type: "text", text: content }] : content;
+}
+function extractText(content) {
+  return content.filter(isTextBlock).map((b) => b.text).join("");
+}
+function extractToolUses(content) {
+  return content.filter(isToolUseBlock);
+}
+var OdlaAIError, ConfigError, AuthError, RateLimitError, CapabilityError, ContextWindowError, InvalidRequestError, ProviderError;
+var init_shape = __esm({
+  "src/shape/index.ts"() {
+    "use strict";
+    OdlaAIError = class extends Error {
+      code;
+      providerStatus;
+      retryAfter;
+      constructor(code, message, opts) {
+        super(message, opts?.cause !== void 0 ? { cause: opts.cause } : void 0);
+        this.name = new.target.name;
+        this.code = code;
+        this.providerStatus = opts?.providerStatus;
+        this.retryAfter = opts?.retryAfter;
+      }
+      toShape() {
+        return {
+          code: this.code,
+          message: this.message,
+          providerStatus: this.providerStatus,
+          retryAfter: this.retryAfter
+        };
+      }
+    };
+    ConfigError = class extends OdlaAIError {
+      constructor(message) {
+        super("config", message);
+      }
+    };
+    AuthError = class extends OdlaAIError {
+      constructor(message, opts) {
+        super("auth", message, opts);
+      }
+    };
+    RateLimitError = class extends OdlaAIError {
+      constructor(message, opts) {
+        super("rate_limit", message, opts);
+      }
+    };
+    CapabilityError = class extends OdlaAIError {
+      constructor(message) {
+        super("capability_unsupported", message);
+      }
+    };
+    ContextWindowError = class extends OdlaAIError {
+      constructor(message, opts) {
+        super("context_window", message, opts);
+      }
+    };
+    InvalidRequestError = class extends OdlaAIError {
+      constructor(message, opts) {
+        super("invalid_request", message, opts);
+      }
+    };
+    ProviderError = class extends OdlaAIError {
+      constructor(message, opts) {
+        super("provider_error", message, opts);
+      }
+    };
+  }
+});
+
+// src/providers/errors.ts
+function statusOf(err) {
+  if (err && typeof err === "object") {
+    const rec = err;
+    for (const k of ["status", "statusCode", "code"]) {
+      const v = rec[k];
+      if (typeof v === "number") return v;
+    }
+  }
+  return void 0;
+}
+function retryAfterOf(err) {
+  if (err && typeof err === "object") {
+    const headers = err.headers;
+    if (headers && typeof headers === "object") {
+      const raw = headers["retry-after"];
+      const n = typeof raw === "string" ? Number(raw) : typeof raw === "number" ? raw : NaN;
+      if (Number.isFinite(n)) return n;
+    }
+  }
+  return void 0;
+}
+function messageOf(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "unknown provider error";
+}
+function normalizeError(err, provider) {
+  if (err instanceof OdlaAIError) return err;
+  const status = statusOf(err);
+  const message = messageOf(err);
+  const tagged = `[${provider}] ${message}`;
+  if (status === 401 || status === 403) return new AuthError(tagged, { providerStatus: status, cause: err });
+  if (status === 429) {
+    return new RateLimitError(tagged, { providerStatus: status, retryAfter: retryAfterOf(err), cause: err });
+  }
+  if (status === 400 || status === 422) {
+    if (/context|token limit|too long|maximum context/i.test(message)) {
+      return new ContextWindowError(tagged, { providerStatus: status, cause: err });
+    }
+    return new InvalidRequestError(tagged, { providerStatus: status, cause: err });
+  }
+  return new ProviderError(tagged, { providerStatus: status, cause: err });
+}
+function mapProviderError(err, provider) {
+  throw normalizeError(err, provider);
+}
+var init_errors = __esm({
+  "src/providers/errors.ts"() {
+    "use strict";
+    init_shape();
+  }
+});
+
+// src/providers/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  AnthropicProvider: () => AnthropicProvider
+});
+function buildParams(spec, req, messages) {
+  const params = {
+    model: spec.nativeId,
+    max_tokens: req.maxTokens,
+    messages
+  };
+  const system = toAnthropicSystem(req.system);
+  if (system !== void 0) params.system = system;
+  const tools = buildTools(req);
+  if (tools) params.tools = tools;
+  const toolChoice = mapToolChoice(req.toolChoice);
+  if (toolChoice) params.tool_choice = toolChoice;
+  if (req.stopSequences && req.stopSequences.length > 0) params.stop_sequences = req.stopSequences;
+  if (req.temperature !== void 0 && !spec.capabilities.effort) params.temperature = req.temperature;
+  if (req.thinking === "adaptive" && spec.capabilities.thinking) params.thinking = { type: "adaptive" };
+  const outputConfig = {};
+  if (req.effort && spec.capabilities.effort) outputConfig.effort = req.effort;
+  if (req.responseFormat && spec.capabilities.structuredOutput) {
+    outputConfig.format = { type: "json_schema", schema: req.responseFormat.schema };
+  }
+  if (Object.keys(outputConfig).length > 0) params.output_config = outputConfig;
+  if (req.providerExtras) Object.assign(params, req.providerExtras);
+  return params;
+}
+function toAnthropicSystem(system) {
+  if (system === void 0) return void 0;
+  if (typeof system === "string") return system;
+  return system.map((b) => ({
+    type: "text",
+    text: b.text,
+    ...b.cacheControl ? { cache_control: { type: "ephemeral" } } : {}
+  }));
+}
+function toAnthropicMessages(req) {
+  return req.messages.map((m) => ({
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : m.content.map(anthropicBlock)
+  }));
+}
+function anthropicBlock(b) {
+  switch (b.type) {
+    case "text":
+      return {
+        type: "text",
+        text: b.text,
+        ...b.cacheControl ? { cache_control: { type: "ephemeral" } } : {}
+      };
+    case "image":
+      return {
+        type: "image",
+        source: b.source.type === "base64" ? { type: "base64", media_type: b.source.mediaType, data: b.source.data } : { type: "url", url: b.source.url }
+      };
+    case "document":
+      return {
+        type: "document",
+        source: b.source.type === "base64" ? { type: "base64", media_type: "application/pdf", data: b.source.data } : { type: "url", url: b.source.url }
+      };
+    case "tool_use":
+      return { type: "tool_use", id: b.id, name: b.name, input: b.input };
+    case "tool_result":
+      return {
+        type: "tool_result",
+        tool_use_id: b.toolUseId,
+        content: typeof b.content === "string" ? b.content : b.content.map(anthropicBlock),
+        ...b.isError ? { is_error: true } : {}
+      };
+    case "thinking":
+      return { type: "thinking", thinking: b.thinking, signature: b.signature ?? "" };
+    case "audio":
+      throw new Error("Anthropic does not support audio input");
+  }
+}
+function buildTools(req) {
+  const tools = [];
+  for (const t of req.tools ?? []) {
+    tools.push({ name: t.name, description: t.description, input_schema: t.inputSchema });
+  }
+  if (req.webSearch) tools.push({ type: "web_search_20260209", name: "web_search" });
+  return tools.length > 0 ? tools : void 0;
+}
+function mapToolChoice(tc) {
+  if (tc === void 0) return void 0;
+  if (tc === "auto") return { type: "auto" };
+  if (tc === "any") return { type: "any" };
+  if (tc === "none") return { type: "none" };
+  return { type: "tool", name: tc.name };
+}
+function mapContent(blocks) {
+  const out = [];
+  for (const b of blocks) {
+    if (b.type === "text") out.push({ type: "text", text: b.text });
+    else if (b.type === "tool_use") {
+      out.push({ type: "tool_use", id: b.id, name: b.name, input: b.input ?? {} });
+    } else if (b.type === "thinking") {
+      out.push({ type: "thinking", thinking: b.thinking, signature: b.signature });
+    }
+  }
+  return out;
+}
+function mapUsage(u) {
+  const usage = { inputTokens: u.input_tokens ?? 0, outputTokens: u.output_tokens ?? 0 };
+  if (u.cache_creation_input_tokens != null) usage.cacheCreationTokens = u.cache_creation_input_tokens;
+  if (u.cache_read_input_tokens != null) usage.cacheReadTokens = u.cache_read_input_tokens;
+  return usage;
+}
+function mapStop(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "max_tokens":
+    case "stop_sequence":
+    case "tool_use":
+    case "pause_turn":
+    case "refusal":
+      return reason;
+    default:
+      return "end_turn";
+  }
+}
+function mapStreamEvent(raw, req) {
+  switch (raw.type) {
+    case "message_start":
+      return {
+        type: "message_start",
+        message: {
+          id: raw.message.id,
+          model: req.model,
+          provider: "anthropic",
+          role: "assistant",
+          content: [],
+          usage: mapUsage(raw.message.usage)
+        }
+      };
+    case "content_block_start": {
+      const block = mapStartBlock(raw.content_block);
+      return block ? { type: "content_block_start", index: raw.index, contentBlock: block } : void 0;
+    }
+    case "content_block_delta": {
+      const d = raw.delta;
+      if (d.type === "text_delta") return { type: "content_block_delta", index: raw.index, delta: { type: "text_delta", text: d.text } };
+      if (d.type === "thinking_delta") return { type: "content_block_delta", index: raw.index, delta: { type: "thinking_delta", thinking: d.thinking } };
+      if (d.type === "input_json_delta") return { type: "content_block_delta", index: raw.index, delta: { type: "input_json_delta", partialJson: d.partial_json } };
+      return void 0;
+    }
+    case "content_block_stop":
+      return { type: "content_block_stop", index: raw.index };
+    case "message_delta":
+      return { type: "message_delta", delta: { stopReason: mapStop(raw.delta.stop_reason) }, usage: mapUsage(raw.usage) };
+    case "message_stop":
+      return { type: "message_stop" };
+    default:
+      return void 0;
+  }
+}
+function mapStartBlock(cb) {
+  if (cb.type === "text") return { type: "text", text: cb.text };
+  if (cb.type === "tool_use") return { type: "tool_use", id: cb.id, name: cb.name, input: {} };
+  if (cb.type === "thinking") return { type: "thinking", thinking: cb.thinking, signature: cb.signature };
+  return void 0;
+}
+var import_sdk, AnthropicProvider;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+    init_errors();
+    init_shape();
+    AnthropicProvider = class {
+      id = "anthropic";
+      client;
+      /** `client` may be injected (tests, custom transport); otherwise built from key. */
+      constructor(apiKey, client) {
+        this.client = client ?? new import_sdk.default({ apiKey });
+      }
+      async create(spec, req) {
+        try {
+          let messages = toAnthropicMessages(req);
+          const content = [];
+          const usage = emptyUsage();
+          let stopReason = "end_turn";
+          let id = "";
+          for (let i = 0; i < 8; i++) {
+            const res = await this.client.messages.create(
+              buildParams(spec, req, messages)
+            );
+            id = res.id;
+            addUsage(usage, mapUsage(res.usage));
+            content.push(...mapContent(res.content));
+            stopReason = mapStop(res.stop_reason);
+            if (res.stop_reason === "pause_turn") {
+              messages = [...messages, { role: "assistant", content: res.content }];
+              continue;
+            }
+            break;
+          }
+          return { id, model: req.model, provider: "anthropic", role: "assistant", content, stopReason, usage };
+        } catch (err) {
+          mapProviderError(err, "anthropic");
+        }
+      }
+      async *stream(spec, req) {
+        try {
+          const events = this.client.messages.stream(
+            buildParams(spec, req, toAnthropicMessages(req))
+          );
+          for await (const raw of events) {
+            const ev = mapStreamEvent(raw, req);
+            if (ev) yield ev;
+          }
+        } catch (err) {
+          yield { type: "error", error: normalizeError(err, "anthropic").toShape() };
+        }
+      }
+    };
+  }
+});
+
+// src/providers/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAIProvider: () => OpenAIProvider,
+  mapResponse: () => mapResponse,
+  parseArgs: () => parseArgs,
+  toOpenAIMessages: () => toOpenAIMessages
+});
+function buildParams2(spec, req, stream) {
+  const params = {
+    model: spec.nativeId,
+    messages: toOpenAIMessages(req),
+    max_completion_tokens: req.maxTokens
+  };
+  const tools = buildTools2(req);
+  if (tools) params.tools = tools;
+  const toolChoice = mapToolChoice2(req.toolChoice);
+  if (toolChoice !== void 0) params.tool_choice = toolChoice;
+  if (req.stopSequences && req.stopSequences.length > 0) params.stop = req.stopSequences;
+  if (req.temperature !== void 0 && !spec.capabilities.effort) params.temperature = req.temperature;
+  if (req.effort && spec.capabilities.effort) params.reasoning_effort = reasoningEffort(req.effort);
+  if (req.responseFormat && spec.capabilities.structuredOutput) {
+    params.response_format = {
+      type: "json_schema",
+      json_schema: { name: req.responseFormat.name ?? "response", schema: req.responseFormat.schema }
+    };
+  }
+  if (stream) {
+    params.stream = true;
+    params.stream_options = { include_usage: true };
+  }
+  if (req.providerExtras) Object.assign(params, req.providerExtras);
+  return params;
+}
+function toOpenAIMessages(req) {
+  const out = [];
+  if (req.system !== void 0) {
+    const text = typeof req.system === "string" ? req.system : req.system.map((b) => b.text).join("");
+    out.push({ role: "system", content: text });
+  }
+  for (const msg of req.messages) {
+    const blocks = typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : msg.content;
+    if (msg.role === "assistant") {
+      const textParts = [];
+      const toolCalls = [];
+      for (const b of blocks) {
+        if (b.type === "text") textParts.push(b.text);
+        else if (b.type === "tool_use") {
+          toolCalls.push({
+            id: b.id,
+            type: "function",
+            function: { name: b.name, arguments: JSON.stringify(b.input) }
+          });
+        }
+      }
+      const assistant = { role: "assistant", content: textParts.join("") || null };
+      if (toolCalls.length > 0) assistant.tool_calls = toolCalls;
+      out.push(assistant);
+      continue;
+    }
+    const toolResults = blocks.filter((b) => b.type === "tool_result");
+    for (const b of toolResults) {
+      if (b.type !== "tool_result") continue;
+      out.push({
+        role: "tool",
+        tool_call_id: b.toolUseId,
+        content: typeof b.content === "string" ? b.content : stringifyBlocks(b.content)
+      });
+    }
+    const rest = blocks.filter((b) => b.type !== "tool_result");
+    if (rest.length > 0) out.push({ role: "user", content: rest.map(userPart) });
+  }
+  return out;
+}
+function userPart(b) {
+  switch (b.type) {
+    case "text":
+      return { type: "text", text: b.text };
+    case "image":
+      return {
+        type: "image_url",
+        image_url: {
+          url: b.source.type === "url" ? b.source.url : `data:${b.source.mediaType};base64,${b.source.data}`
+        }
+      };
+    case "audio": {
+      if (b.source.type !== "base64") {
+        throw new CapabilityError("OpenAI audio input requires base64 data, not a URL.");
+      }
+      return {
+        type: "input_audio",
+        input_audio: { data: b.source.data, format: audioFormat(b.source.mediaType) }
+      };
+    }
+    default:
+      return { type: "text", text: stringifyBlocks([b]) };
+  }
+}
+function audioFormat(m) {
+  if (m === "audio/wav") return "wav";
+  if (m === "audio/mp3" || m === "audio/mpeg") return "mp3";
+  throw new CapabilityError(`OpenAI audio input supports wav and mp3, not "${m}".`);
+}
+function stringifyBlocks(blocks) {
+  return blocks.map((b) => b.type === "text" ? b.text : `[${b.type}]`).join("");
+}
+function buildTools2(req) {
+  if (!req.tools || req.tools.length === 0) return void 0;
+  return req.tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.inputSchema }
+  }));
+}
+function mapToolChoice2(tc) {
+  if (tc === void 0) return void 0;
+  if (tc === "auto") return "auto";
+  if (tc === "none") return "none";
+  if (tc === "any") return "required";
+  return { type: "function", function: { name: tc.name } };
+}
+function reasoningEffort(e) {
+  if (e === "low") return "low";
+  if (e === "medium") return "medium";
+  return "high";
+}
+function mapResponse(res, req) {
+  const choice = res.choices[0];
+  const content = [];
+  const message = choice?.message;
+  if (message?.content) content.push({ type: "text", text: message.content });
+  for (const call of message?.tool_calls ?? []) {
+    if (call.type !== "function") continue;
+    content.push({ type: "tool_use", id: call.id, name: call.function.name, input: parseArgs(call.function.arguments) });
+  }
+  return {
+    id: res.id,
+    model: req.model,
+    provider: "openai",
+    role: "assistant",
+    content,
+    stopReason: mapFinish(choice?.finish_reason),
+    usage: mapUsage2(res.usage)
+  };
+}
+function parseArgs(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function mapFinish(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "length":
+      return "max_tokens";
+    case "tool_calls":
+    case "function_call":
+      return "tool_use";
+    case "content_filter":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function mapUsage2(u) {
+  const usage = { inputTokens: u?.prompt_tokens ?? 0, outputTokens: u?.completion_tokens ?? 0 };
+  const cached = u?.prompt_tokens_details?.cached_tokens;
+  if (cached != null) usage.cacheReadTokens = cached;
+  return usage;
+}
+async function* mapStream(stream, req) {
+  let started = false;
+  let textOpen = false;
+  const toolIndex = /* @__PURE__ */ new Map();
+  let nextBlockIndex = 1;
+  let stopReason = "end_turn";
+  const usage = emptyUsage();
+  for await (const chunk of stream) {
+    if (!started) {
+      started = true;
+      yield {
+        type: "message_start",
+        message: { id: chunk.id, model: req.model, provider: "openai", role: "assistant", content: [], usage: emptyUsage() }
+      };
+    }
+    if (chunk.usage) addUsage(usage, mapUsage2(chunk.usage));
+    const choice = chunk.choices[0];
+    const delta = choice?.delta;
+    if (delta?.content) {
+      if (!textOpen) {
+        textOpen = true;
+        yield { type: "content_block_start", index: 0, contentBlock: { type: "text", text: "" } };
+      }
+      yield { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: delta.content } };
+    }
+    for (const tc of delta?.tool_calls ?? []) {
+      let blockIndex = toolIndex.get(tc.index);
+      if (blockIndex === void 0) {
+        blockIndex = nextBlockIndex++;
+        toolIndex.set(tc.index, blockIndex);
+        yield {
+          type: "content_block_start",
+          index: blockIndex,
+          contentBlock: { type: "tool_use", id: tc.id ?? "", name: tc.function?.name ?? "", input: {} }
+        };
+      }
+      if (tc.function?.arguments) {
+        yield { type: "content_block_delta", index: blockIndex, delta: { type: "input_json_delta", partialJson: tc.function.arguments } };
+      }
+    }
+    if (choice?.finish_reason) stopReason = mapFinish(choice.finish_reason);
+  }
+  if (textOpen) yield { type: "content_block_stop", index: 0 };
+  for (const blockIndex of toolIndex.values()) yield { type: "content_block_stop", index: blockIndex };
+  yield { type: "message_delta", delta: { stopReason }, usage };
+  yield { type: "message_stop" };
+}
+var import_openai2, OpenAIProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    import_openai2 = __toESM(require("openai"), 1);
+    init_errors();
+    init_shape();
+    OpenAIProvider = class {
+      id = "openai";
+      client;
+      constructor(apiKey, client) {
+        this.client = client ?? new import_openai2.default({ apiKey });
+      }
+      async create(spec, req) {
+        try {
+          const res = await this.client.chat.completions.create(
+            buildParams2(spec, req, false)
+          );
+          return mapResponse(res, req);
+        } catch (err) {
+          mapProviderError(err, "openai");
+        }
+      }
+      async *stream(spec, req) {
+        try {
+          const stream = await this.client.chat.completions.create(
+            buildParams2(spec, req, true)
+          );
+          yield* mapStream(stream, req);
+        } catch (err) {
+          yield { type: "error", error: normalizeError(err, "openai").toShape() };
+        }
+      }
+    };
+  }
+});
+
+// src/providers/google.ts
+var google_exports = {};
+__export(google_exports, {
+  GoogleProvider: () => GoogleProvider,
+  mapResponse: () => mapResponse2,
+  toContents: () => toContents
+});
+function buildParams3(spec, req) {
+  const config = { maxOutputTokens: req.maxTokens };
+  if (req.system !== void 0) {
+    config.systemInstruction = typeof req.system === "string" ? req.system : req.system.map((b) => b.text).join("");
+  }
+  if (req.temperature !== void 0) config.temperature = req.temperature;
+  if (req.stopSequences && req.stopSequences.length > 0) config.stopSequences = req.stopSequences;
+  const tools = buildTools3(req);
+  if (tools) config.tools = tools;
+  const toolConfig = mapToolChoice3(req.toolChoice);
+  if (toolConfig) config.toolConfig = toolConfig;
+  if (req.thinking === "adaptive" && spec.capabilities.thinking) {
+    config.thinkingConfig = { thinkingBudget: -1 };
+  }
+  if (req.responseFormat && spec.capabilities.structuredOutput) {
+    config.responseMimeType = "application/json";
+    config.responseSchema = req.responseFormat.schema;
+  }
+  if (req.providerExtras) Object.assign(config, req.providerExtras);
+  return { model: spec.nativeId, contents: toContents(req), config };
+}
+function toContents(req) {
+  return req.messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: (typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content).map(toPart)
+  }));
+}
+function toPart(b) {
+  switch (b.type) {
+    case "text":
+      return { text: b.text };
+    case "image":
+      if (b.source.type !== "base64") throw new CapabilityError("Google image input requires base64 data, not a URL.");
+      return { inlineData: { mimeType: b.source.mediaType, data: b.source.data } };
+    case "audio":
+      if (b.source.type !== "base64") throw new CapabilityError("Google audio input requires base64 data, not a URL.");
+      return { inlineData: { mimeType: b.source.mediaType, data: b.source.data } };
+    case "document":
+      if (b.source.type !== "base64") throw new CapabilityError("Google document input requires base64 data, not a URL.");
+      return { inlineData: { mimeType: "application/pdf", data: b.source.data } };
+    case "tool_use":
+      return { functionCall: { name: b.name, args: b.input } };
+    case "tool_result":
+      return {
+        functionResponse: {
+          // Gemini correlates by name; the canonical tool_use id is keyed to it.
+          name: b.toolUseId,
+          response: { result: typeof b.content === "string" ? b.content : stringifyBlocks2(b.content) }
+        }
+      };
+    case "thinking":
+      return { text: "" };
+  }
+}
+function stringifyBlocks2(blocks) {
+  return blocks.map((b) => b.type === "text" ? b.text : `[${b.type}]`).join("");
+}
+function buildTools3(req) {
+  const tools = [];
+  if (req.tools && req.tools.length > 0) {
+    tools.push({
+      functionDeclarations: req.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }))
+    });
+  }
+  if (req.webSearch) tools.push({ googleSearch: {} });
+  return tools.length > 0 ? tools : void 0;
+}
+function mapToolChoice3(tc) {
+  if (tc === void 0 || tc === "auto") return void 0;
+  if (tc === "none") return { functionCallingConfig: { mode: import_genai.FunctionCallingConfigMode.NONE } };
+  if (tc === "any") return { functionCallingConfig: { mode: import_genai.FunctionCallingConfigMode.ANY } };
+  return { functionCallingConfig: { mode: import_genai.FunctionCallingConfigMode.ANY, allowedFunctionNames: [tc.name] } };
+}
+function mapResponse2(res, req) {
+  const candidate = res.candidates?.[0];
+  const parts = candidate?.content?.parts ?? [];
+  const content = [];
+  let sawToolUse = false;
+  for (const p of parts) {
+    if (p.text) content.push({ type: "text", text: p.text });
+    else if (p.functionCall) {
+      sawToolUse = true;
+      const name = p.functionCall.name ?? "";
+      content.push({ type: "tool_use", id: p.functionCall.id ?? name, name, input: p.functionCall.args ?? {} });
+    }
+  }
+  return {
+    id: res.responseId ?? "",
+    model: req.model,
+    provider: "google",
+    role: "assistant",
+    content,
+    stopReason: sawToolUse ? "tool_use" : mapFinish2(candidate?.finishReason),
+    usage: mapUsage3(res)
+  };
+}
+function mapFinish2(reason) {
+  switch (reason) {
+    case "STOP":
+      return "end_turn";
+    case "MAX_TOKENS":
+      return "max_tokens";
+    case "SAFETY":
+    case "RECITATION":
+    case "BLOCKLIST":
+    case "PROHIBITED_CONTENT":
+    case "SPII":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function mapUsage3(res) {
+  const u = res.usageMetadata;
+  const usage = {
+    inputTokens: u?.promptTokenCount ?? 0,
+    outputTokens: u?.candidatesTokenCount ?? 0
+  };
+  if (u?.cachedContentTokenCount != null) usage.cacheReadTokens = u.cachedContentTokenCount;
+  return usage;
+}
+async function* mapStream2(iter, req) {
+  let started = false;
+  let textOpen = false;
+  let nextBlockIndex = 1;
+  let stopReason = "end_turn";
+  const usage = emptyUsage();
+  for await (const chunk of iter) {
+    if (!started) {
+      started = true;
+      yield {
+        type: "message_start",
+        message: { id: chunk.responseId ?? "", model: req.model, provider: "google", role: "assistant", content: [], usage: emptyUsage() }
+      };
+    }
+    const candidate = chunk.candidates?.[0];
+    for (const p of candidate?.content?.parts ?? []) {
+      if (p.text) {
+        if (!textOpen) {
+          textOpen = true;
+          yield { type: "content_block_start", index: 0, contentBlock: { type: "text", text: "" } };
+        }
+        yield { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: p.text } };
+      } else if (p.functionCall) {
+        const idx = nextBlockIndex++;
+        const name = p.functionCall.name ?? "";
+        yield { type: "content_block_start", index: idx, contentBlock: { type: "tool_use", id: p.functionCall.id ?? name, name, input: {} } };
+        yield { type: "content_block_delta", index: idx, delta: { type: "input_json_delta", partialJson: JSON.stringify(p.functionCall.args ?? {}) } };
+        yield { type: "content_block_stop", index: idx };
+        stopReason = "tool_use";
+      }
+    }
+    if (chunk.usageMetadata) {
+      const u = mapUsage3(chunk);
+      usage.inputTokens = u.inputTokens;
+      usage.outputTokens = u.outputTokens;
+      if (u.cacheReadTokens != null) usage.cacheReadTokens = u.cacheReadTokens;
+    }
+    if (candidate?.finishReason && stopReason !== "tool_use") stopReason = mapFinish2(candidate.finishReason);
+  }
+  if (textOpen) yield { type: "content_block_stop", index: 0 };
+  yield { type: "message_delta", delta: { stopReason }, usage };
+  yield { type: "message_stop" };
+}
+var import_genai, GoogleProvider;
+var init_google = __esm({
+  "src/providers/google.ts"() {
+    "use strict";
+    import_genai = require("@google/genai");
+    init_errors();
+    init_shape();
+    GoogleProvider = class {
+      id = "google";
+      client;
+      constructor(apiKey, client) {
+        this.client = client ?? new import_genai.GoogleGenAI({ apiKey });
+      }
+      async create(spec, req) {
+        try {
+          const res = await this.client.models.generateContent(buildParams3(spec, req));
+          return mapResponse2(res, req);
+        } catch (err) {
+          mapProviderError(err, "google");
+        }
+      }
+      async *stream(spec, req) {
+        try {
+          const iter = await this.client.models.generateContentStream(buildParams3(spec, req));
+          yield* mapStream2(iter, req);
+        } catch (err) {
+          yield { type: "error", error: normalizeError(err, "google").toShape() };
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AGENT_SCHEMA: () => AGENT_SCHEMA,
+  ANTHROPIC_MODELS: () => ANTHROPIC_MODELS,
+  AuthError: () => AuthError,
+  CapabilityError: () => CapabilityError,
+  ConfigError: () => ConfigError,
+  ContextWindowError: () => ContextWindowError,
+  DEFAULT_CATALOG: () => DEFAULT_CATALOG,
+  DEFAULT_SECRET_NAMES: () => DEFAULT_SECRET_NAMES,
+  GOOGLE_MODELS: () => GOOGLE_MODELS,
+  InMemoryScope: () => InMemoryScope,
+  InvalidRequestError: () => InvalidRequestError,
+  NS: () => NS,
+  OPENAI_MODELS: () => OPENAI_MODELS,
+  OdlaAIError: () => OdlaAIError,
+  OdlaDbMemory: () => OdlaDbMemory,
+  ProviderError: () => ProviderError,
+  RateLimitError: () => RateLimitError,
+  TaintError: () => TaintError,
+  addUsage: () => addUsage,
+  assertSinkAcceptsTaint: () => assertSinkAcceptsTaint,
+  blocksOf: () => blocksOf,
+  buildCatalog: () => buildCatalog,
+  chatCapabilities: () => chatCapabilities,
+  clearProviderCache: () => clearProviderCache,
+  composeSkills: () => composeSkills,
+  createApp: () => createApp,
+  emptyUsage: () => emptyUsage,
+  entityCrudSkill: () => entityCrudSkill,
+  evaluate: () => evaluate,
+  exactMatch: () => exactMatch,
+  extractText: () => extractText,
+  extractToolUses: () => extractToolUses,
+  generateLlmsTxt: () => generateLlmsTxt,
+  getProvider: () => getProvider,
+  includes: () => includes,
+  init: () => init,
+  isAudioBlock: () => isAudioBlock,
+  isDocumentBlock: () => isDocumentBlock,
+  isImageBlock: () => isImageBlock,
+  isTextBlock: () => isTextBlock,
+  isThinkingBlock: () => isThinkingBlock,
+  isToolResultBlock: () => isToolResultBlock,
+  isToolUseBlock: () => isToolUseBlock,
+  llmJudge: () => llmJudge,
+  looksLikeKey: () => looksLikeKey,
+  mintAppKey: () => mintAppKey,
+  normalizeError: () => normalizeError,
+  odlaDbKeyResolver: () => odlaDbKeyResolver,
+  persistRun: () => persistRun,
+  providersInCatalog: () => providersInCatalog,
+  provisionAgentApp: () => provisionAgentApp,
+  pushAgentSchema: () => pushAgentSchema,
+  putSecret: () => putSecret,
+  queryRuns: () => queryRuns,
+  redact: () => redact,
+  registerProvider: () => registerProvider,
+  resolveModel: () => resolveModel,
+  runAgent: () => runAgent,
+  structuredMatch: () => structuredMatch,
+  taint: () => taint,
+  toOracleTool: () => toOracleTool,
+  validateRequest: () => validateRequest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/init.ts
+init_shape();
+
+// src/shape/capabilities.ts
+init_shape();
+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/index.ts
+init_shape();
+
+// 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: AnthropicProvider2 } = await Promise.resolve().then(() => (init_anthropic(), anthropic_exports));
+      provider = new AnthropicProvider2(apiKey);
+      break;
+    }
+    case "openai": {
+      const { OpenAIProvider: OpenAIProvider2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+      provider = new OpenAIProvider2(apiKey);
+      break;
+    }
+    case "google": {
+      const { GoogleProvider: GoogleProvider2 } = await Promise.resolve().then(() => (init_google(), google_exports));
+      provider = new GoogleProvider2(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
+init_shape();
+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/index.ts
+init_shape();
+
+// 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/index.ts
+init_errors();
+
+// src/agent/loop.ts
+init_shape();
+
+// 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
+init_shape();
+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
+init_shape();
+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
+init_shape();
+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
+init_shape();
+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]
+  };
+}
+//# sourceMappingURL=index.cjs.map