@odla-ai/ai 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -35,7 +35,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/shape/index.ts
+// src/shape/blocks.ts
+var init_blocks = __esm({
+  "src/shape/blocks.ts"() {
+    "use strict";
+  }
+});
+
+// src/shape/usage.ts
 function emptyUsage() {
   return { inputTokens: 0, outputTokens: 0 };
 }
@@ -49,39 +56,30 @@ function addUsage(into, more) {
     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"() {
+var init_usage = __esm({
+  "src/shape/usage.ts"() {
+    "use strict";
+  }
+});
+
+// src/shape/request.ts
+var init_request = __esm({
+  "src/shape/request.ts"() {
+    "use strict";
+  }
+});
+
+// src/shape/events.ts
+var init_events = __esm({
+  "src/shape/events.ts"() {
+    "use strict";
+  }
+});
+
+// src/shape/errors.ts
+var OdlaAIError, ConfigError, AuthError, RateLimitError, CapabilityError, ContextWindowError, InvalidRequestError, ToolInputError, CancelledError, DeadlineExceededError, ProviderError;
+var init_errors = __esm({
+  "src/shape/errors.ts"() {
     "use strict";
     OdlaAIError = class extends Error {
       code;
@@ -133,6 +131,23 @@ var init_shape = __esm({
         super("invalid_request", message, opts);
       }
     };
+    ToolInputError = class extends OdlaAIError {
+      tool;
+      constructor(message, opts) {
+        super("tool_input_invalid", message, { cause: opts?.cause });
+        this.tool = opts?.tool;
+      }
+    };
+    CancelledError = class extends OdlaAIError {
+      constructor(message = "AI request was cancelled.", opts) {
+        super("cancelled", message, opts);
+      }
+    };
+    DeadlineExceededError = class extends OdlaAIError {
+      constructor(message = "AI request deadline was exceeded.", opts) {
+        super("deadline_exceeded", message, opts);
+      }
+    };
     ProviderError = class extends OdlaAIError {
       constructor(message, opts) {
         super("provider_error", message, opts);
@@ -141,6 +156,423 @@ var init_shape = __esm({
   }
 });
 
+// src/shape/helpers.ts
+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 init_helpers = __esm({
+  "src/shape/helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/shape/json-schema-shape.ts
+function validateSchemaShape(schema, path, root, issues) {
+  if (typeof schema === "boolean") return;
+  if (!isRecord(schema)) {
+    issue(issues, path, "schema must be an object or boolean");
+    return;
+  }
+  for (const key of Object.keys(schema)) {
+    if (!SUPPORTED_KEYS.has(key)) issue(issues, path, `schema uses unsupported keyword "${key}"`);
+  }
+  if (typeof schema.$ref === "string" && resolveLocalRef(root, schema.$ref) === void 0) {
+    issue(issues, path, `schema reference "${schema.$ref}" could not be resolved`);
+  } else if (schema.$ref !== void 0 && typeof schema.$ref !== "string") {
+    issue(issues, path, "schema $ref must be a string");
+  }
+  const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+  if (schema.type !== void 0 && (types.length === 0 || !types.every((type) => typeof type === "string" && ALLOWED_TYPES.has(type)))) {
+    issue(issues, path, "schema type contains an unsupported JSON type");
+  }
+  if (schema.enum !== void 0 && !Array.isArray(schema.enum)) {
+    issue(issues, path, "schema enum must be an array");
+  }
+  if (schema.required !== void 0 && (!Array.isArray(schema.required) || !schema.required.every((key) => typeof key === "string"))) {
+    issue(issues, path, "schema required must be a string array");
+  }
+  validateConstraintShapes(schema, path, issues);
+  validateChildSchemas(schema, path, root, issues);
+}
+function validateChildSchemas(schema, path, root, issues) {
+  for (const key of ["properties", "$defs", "definitions"]) {
+    const group = schema[key];
+    if (group === void 0) continue;
+    if (!isRecord(group)) {
+      issue(issues, path, `schema ${key} must be an object`);
+      continue;
+    }
+    for (const [name, child] of Object.entries(group)) {
+      validateSchemaShape(child, `${path}.${key}.${name}`, root, issues);
+    }
+  }
+  for (const key of ["allOf", "anyOf", "oneOf"]) {
+    const group = schema[key];
+    if (group === void 0) continue;
+    if (!Array.isArray(group) || group.length === 0) {
+      issue(issues, path, `schema ${key} must be a non-empty array`);
+      continue;
+    }
+    group.forEach((child, index2) => validateSchemaShape(child, `${path}.${key}[${index2}]`, root, issues));
+  }
+  for (const key of ["items", "not", "additionalProperties"]) {
+    const child = schema[key];
+    if (child !== void 0) validateSchemaShape(child, `${path}.${key}`, root, issues);
+  }
+}
+function validateConstraintShapes(schema, path, issues) {
+  for (const key of ["minLength", "maxLength", "minItems", "maxItems", "minProperties", "maxProperties"]) {
+    const value = schema[key];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 0)) {
+      issue(issues, path, `schema ${key} must be a non-negative integer`);
+    }
+  }
+  for (const key of ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"]) {
+    const value = schema[key];
+    if (value !== void 0 && !isFiniteNumber(value)) {
+      issue(issues, path, `schema ${key} must be a finite number`);
+    }
+  }
+  if (schema.multipleOf !== void 0 && (!isFiniteNumber(schema.multipleOf) || schema.multipleOf <= 0)) {
+    issue(issues, path, "schema multipleOf must be a finite number greater than zero");
+  }
+  if (schema.uniqueItems !== void 0 && typeof schema.uniqueItems !== "boolean") {
+    issue(issues, path, "schema uniqueItems must be a boolean");
+  }
+  validatePatternShape(schema.pattern, path, issues);
+}
+function validatePatternShape(value, path, issues) {
+  if (value === void 0) return;
+  if (typeof value !== "string") {
+    issue(issues, path, "schema pattern must be a string");
+    return;
+  }
+  try {
+    new RegExp(value, "u");
+  } catch {
+    issue(issues, path, `schema pattern "${value}" is invalid`);
+  }
+}
+function resolveLocalRef(root, ref) {
+  if (ref === "#") return root;
+  if (!ref.startsWith("#/")) return void 0;
+  let current = root;
+  for (const raw of ref.slice(2).split("/")) {
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!isRecord(current) || !Object.hasOwn(current, key)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function issue(issues, path, message) {
+  issues.push({ path, message });
+}
+var ANNOTATION_KEYS, SUPPORTED_KEYS, ALLOWED_TYPES;
+var init_json_schema_shape = __esm({
+  "src/shape/json-schema-shape.ts"() {
+    "use strict";
+    ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+      "$schema",
+      "$id",
+      "$anchor",
+      "title",
+      "description",
+      "default",
+      "examples",
+      "deprecated",
+      "readOnly",
+      "writeOnly",
+      "format"
+    ]);
+    SUPPORTED_KEYS = /* @__PURE__ */ new Set([
+      ...ANNOTATION_KEYS,
+      "$ref",
+      "$defs",
+      "definitions",
+      "type",
+      "enum",
+      "const",
+      "allOf",
+      "anyOf",
+      "oneOf",
+      "not",
+      "properties",
+      "required",
+      "additionalProperties",
+      "minProperties",
+      "maxProperties",
+      "items",
+      "minItems",
+      "maxItems",
+      "uniqueItems",
+      "minLength",
+      "maxLength",
+      "pattern",
+      "minimum",
+      "maximum",
+      "exclusiveMinimum",
+      "exclusiveMaximum",
+      "multipleOf"
+    ]);
+    ALLOWED_TYPES = /* @__PURE__ */ new Set([
+      "null",
+      "boolean",
+      "object",
+      "array",
+      "number",
+      "integer",
+      "string"
+    ]);
+  }
+});
+
+// src/shape/json-schema.ts
+function validateJsonSchema(schema, value) {
+  const issues = [];
+  validateSchemaShape(schema, "$", schema, issues);
+  if (issues.length > 0) return { valid: false, issues };
+  visit(schema, value, "$", schema, issues, /* @__PURE__ */ new Set());
+  return { valid: issues.length === 0, issues };
+}
+function visit(schema, value, path, root, issues, refs) {
+  if (schema === true) return;
+  if (schema === false) {
+    issue2(issues, path, "is rejected by the schema");
+    return;
+  }
+  if (!isRecord2(schema)) {
+    issue2(issues, path, "schema must be an object or boolean");
+    return;
+  }
+  for (const key of Object.keys(schema)) {
+    if (!SUPPORTED_KEYS.has(key)) {
+      issue2(issues, path, `schema uses unsupported keyword "${key}"`);
+      return;
+    }
+  }
+  if (typeof schema.$ref === "string") {
+    const target = resolveLocalRef2(root, schema.$ref);
+    if (target === void 0) {
+      issue2(issues, path, `schema reference "${schema.$ref}" could not be resolved`);
+      return;
+    }
+    if (refs.has(schema.$ref)) {
+      issue2(issues, path, `cyclic schema reference "${schema.$ref}" is unsupported`);
+      return;
+    }
+    const nextRefs = new Set(refs);
+    nextRefs.add(schema.$ref);
+    visit(target, value, path, root, issues, nextRefs);
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => jsonEqual(candidate, value))) {
+    issue2(issues, path, "must equal one of the allowed enum values");
+  }
+  if (Object.hasOwn(schema, "const") && !jsonEqual(schema.const, value)) {
+    issue2(issues, path, "must equal the constant value");
+  }
+  if (Array.isArray(schema.allOf)) {
+    for (const child of schema.allOf) visit(child, value, path, root, issues, refs);
+  }
+  if (Array.isArray(schema.anyOf) && !schema.anyOf.some((child) => matches(child, value, root, refs))) {
+    issue2(issues, path, "must match at least one anyOf schema");
+  }
+  if (Array.isArray(schema.oneOf)) {
+    const matchesCount = schema.oneOf.filter((child) => matches(child, value, root, refs)).length;
+    if (matchesCount !== 1) issue2(issues, path, "must match exactly one oneOf schema");
+  }
+  if (schema.not !== void 0 && matches(schema.not, value, root, refs)) {
+    issue2(issues, path, "must not match the forbidden schema");
+  }
+  const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) && schema.type.every((t) => typeof t === "string") ? schema.type : void 0;
+  if (schema.type !== void 0 && !types) {
+    issue2(issues, path, "schema type must be a string or string array");
+    return;
+  }
+  if (types && !types.some((type) => isType(value, type))) {
+    issue2(issues, path, `must be ${types.join(" or ")}`);
+    return;
+  }
+  if (typeof value === "string") validateString(schema, value, path, issues);
+  if (typeof value === "number") validateNumber(schema, value, path, issues);
+  if (Array.isArray(value)) validateArray(schema, value, path, root, issues, refs);
+  if (isRecord2(value)) validateObject(schema, value, path, root, issues, refs);
+}
+function validateString(schema, value, path, issues) {
+  if (isFiniteNumber2(schema.minLength) && [...value].length < schema.minLength) issue2(issues, path, `must have at least ${schema.minLength} characters`);
+  if (isFiniteNumber2(schema.maxLength) && [...value].length > schema.maxLength) issue2(issues, path, `must have at most ${schema.maxLength} characters`);
+  if (typeof schema.pattern === "string") {
+    try {
+      if (!new RegExp(schema.pattern, "u").test(value)) issue2(issues, path, `must match pattern ${schema.pattern}`);
+    } catch {
+      issue2(issues, path, `schema pattern "${schema.pattern}" is invalid`);
+    }
+  }
+}
+function validateNumber(schema, value, path, issues) {
+  if (!Number.isFinite(value)) {
+    issue2(issues, path, "must be a finite number");
+    return;
+  }
+  if (isFiniteNumber2(schema.minimum) && value < schema.minimum) issue2(issues, path, `must be >= ${schema.minimum}`);
+  if (isFiniteNumber2(schema.maximum) && value > schema.maximum) issue2(issues, path, `must be <= ${schema.maximum}`);
+  if (isFiniteNumber2(schema.exclusiveMinimum) && value <= schema.exclusiveMinimum) issue2(issues, path, `must be > ${schema.exclusiveMinimum}`);
+  if (isFiniteNumber2(schema.exclusiveMaximum) && value >= schema.exclusiveMaximum) issue2(issues, path, `must be < ${schema.exclusiveMaximum}`);
+  if (isFiniteNumber2(schema.multipleOf) && schema.multipleOf > 0) {
+    const quotient = value / schema.multipleOf;
+    if (Math.abs(quotient - Math.round(quotient)) > Number.EPSILON * Math.max(1, Math.abs(quotient))) {
+      issue2(issues, path, `must be a multiple of ${schema.multipleOf}`);
+    }
+  }
+}
+function validateArray(schema, value, path, root, issues, refs) {
+  if (isFiniteNumber2(schema.minItems) && value.length < schema.minItems) issue2(issues, path, `must contain at least ${schema.minItems} items`);
+  if (isFiniteNumber2(schema.maxItems) && value.length > schema.maxItems) issue2(issues, path, `must contain at most ${schema.maxItems} items`);
+  if (schema.uniqueItems === true) {
+    for (let i = 0; i < value.length; i++) {
+      if (value.slice(0, i).some((other) => jsonEqual(other, value[i]))) {
+        issue2(issues, `${path}[${i}]`, "must be unique");
+        break;
+      }
+    }
+  }
+  if (schema.items !== void 0) {
+    for (let i = 0; i < value.length; i++) visit(schema.items, value[i], `${path}[${i}]`, root, issues, refs);
+  }
+}
+function validateObject(schema, value, path, root, issues, refs) {
+  const keys = Object.keys(value);
+  if (isFiniteNumber2(schema.minProperties) && keys.length < schema.minProperties) issue2(issues, path, `must contain at least ${schema.minProperties} properties`);
+  if (isFiniteNumber2(schema.maxProperties) && keys.length > schema.maxProperties) issue2(issues, path, `must contain at most ${schema.maxProperties} properties`);
+  if (schema.required !== void 0 && (!Array.isArray(schema.required) || !schema.required.every((key) => typeof key === "string"))) {
+    issue2(issues, path, "schema required must be a string array");
+    return;
+  }
+  for (const key of schema.required ?? []) {
+    if (!Object.hasOwn(value, key)) issue2(issues, childPath(path, key), "is required");
+  }
+  const properties = isRecord2(schema.properties) ? schema.properties : {};
+  for (const [key, child] of Object.entries(properties)) {
+    if (Object.hasOwn(value, key)) visit(child, value[key], childPath(path, key), root, issues, refs);
+  }
+  const extras = keys.filter((key) => !Object.hasOwn(properties, key));
+  if (schema.additionalProperties === false) {
+    for (const key of extras) issue2(issues, childPath(path, key), "is not an allowed property");
+  } else if (schema.additionalProperties !== void 0 && schema.additionalProperties !== true) {
+    for (const key of extras) visit(schema.additionalProperties, value[key], childPath(path, key), root, issues, refs);
+  }
+}
+function matches(schema, value, root, refs) {
+  const nested = [];
+  visit(schema, value, "$", root, nested, refs);
+  return nested.length === 0;
+}
+function resolveLocalRef2(root, ref) {
+  if (ref === "#") return root;
+  if (!ref.startsWith("#/")) return void 0;
+  let current = root;
+  for (const raw of ref.slice(2).split("/")) {
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!isRecord2(current) || !Object.hasOwn(current, key)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isType(value, type) {
+  switch (type) {
+    case "null":
+      return value === null;
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return isRecord2(value);
+    case "array":
+      return Array.isArray(value);
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "string":
+      return typeof value === "string";
+    default:
+      return false;
+  }
+}
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function jsonEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => jsonEqual(v, b[i]));
+  if (isRecord2(a) && isRecord2(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every((key) => Object.hasOwn(b, key) && jsonEqual(a[key], b[key]));
+  }
+  return false;
+}
+function childPath(path, key) {
+  return /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}
+function issue2(issues, path, message) {
+  issues.push({ path, message });
+}
+var init_json_schema = __esm({
+  "src/shape/json-schema.ts"() {
+    "use strict";
+    init_json_schema_shape();
+  }
+});
+
+// src/shape/index.ts
+var init_shape = __esm({
+  "src/shape/index.ts"() {
+    "use strict";
+    init_blocks();
+    init_usage();
+    init_request();
+    init_events();
+    init_errors();
+    init_helpers();
+    init_json_schema();
+  }
+});
+
 // src/providers/errors.ts
 function statusOf(err) {
   if (err && typeof err === "object") {
@@ -168,8 +600,10 @@ function messageOf(err) {
   if (typeof err === "string") return err;
   return "unknown provider error";
 }
-function normalizeError(err, provider) {
+function normalizeError(err, provider, signal) {
   if (err instanceof OdlaAIError) return err;
+  const cancellation = cancellationError(signal?.aborted ? signal.reason : err);
+  if (signal?.aborted || cancellation) return cancellation ?? new CancelledError(void 0, { cause: err });
   const status = statusOf(err);
   const message = messageOf(err);
   const tagged = `[${provider}] ${message}`;
@@ -185,21 +619,27 @@ function normalizeError(err, provider) {
   }
   return new ProviderError(tagged, { providerStatus: status, cause: err });
 }
-function mapProviderError(err, provider) {
-  throw normalizeError(err, provider);
+function mapProviderError(err, provider, signal) {
+  throw normalizeError(err, provider, signal);
 }
-var init_errors = __esm({
+function cancellationError(reason) {
+  if (reason instanceof DeadlineExceededError || reason instanceof CancelledError) return reason;
+  if (!reason || typeof reason !== "object") return void 0;
+  const rec = reason;
+  if (rec.name === "TimeoutError") return new DeadlineExceededError(void 0, { cause: reason });
+  if (rec.name === "AbortError" || rec.name === "APIUserAbortError" || rec.code === "ABORT_ERR") {
+    return new CancelledError(void 0, { cause: reason });
+  }
+  return void 0;
+}
+var init_errors2 = __esm({
   "src/providers/errors.ts"() {
     "use strict";
     init_shape();
   }
 });
 
-// src/providers/anthropic.ts
-var anthropic_exports = {};
-__export(anthropic_exports, {
-  AnthropicProvider: () => AnthropicProvider
-});
+// src/providers/anthropic/request.ts
 function buildParams(spec, req, messages) {
   const params = {
     model: spec.nativeId,
@@ -287,12 +727,33 @@ function mapToolChoice(tc) {
   if (tc === "none") return { type: "none" };
   return { type: "tool", name: tc.name };
 }
+var init_request2 = __esm({
+  "src/providers/anthropic/request.ts"() {
+    "use strict";
+  }
+});
+
+// src/providers/tool-input.ts
+function toolInput(value, provider, name) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  throw new ToolInputError(`[${provider}] tool "${name}" returned arguments that are not a JSON object.`, { tool: name });
+}
+var init_tool_input = __esm({
+  "src/providers/tool-input.ts"() {
+    "use strict";
+    init_shape();
+  }
+});
+
+// src/providers/anthropic/response.ts
 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 ?? {} });
+      out.push({ type: "tool_use", id: b.id, name: b.name, input: toolInput(b.input ?? {}, "anthropic", b.name) });
     } else if (b.type === "thinking") {
       out.push({ type: "thinking", thinking: b.thinking, signature: b.signature });
     }
@@ -318,6 +779,14 @@ function mapStop(reason) {
       return "end_turn";
   }
 }
+var init_response = __esm({
+  "src/providers/anthropic/response.ts"() {
+    "use strict";
+    init_tool_input();
+  }
+});
+
+// src/providers/anthropic/stream.ts
 function mapStreamEvent(raw, req) {
   switch (raw.type) {
     case "message_start":
@@ -359,13 +828,58 @@ function mapStartBlock(cb) {
   if (cb.type === "thinking") return { type: "thinking", thinking: cb.thinking, signature: cb.signature };
   return void 0;
 }
+var init_stream = __esm({
+  "src/providers/anthropic/stream.ts"() {
+    "use strict";
+    init_response();
+  }
+});
+
+// src/client/abort.ts
+function signalWithDeadline(signal, deadline) {
+  if (deadline === void 0) return signal;
+  if (!Number.isSafeInteger(deadline)) throw new ConfigError("deadline must be a finite integer Unix timestamp in milliseconds.");
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) {
+    const expired = new AbortController();
+    expired.abort(new DeadlineExceededError());
+    return signal ? AbortSignal.any([signal, expired.signal]) : expired.signal;
+  }
+  const timeout = AbortSignal.timeout(remaining);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const reason = signal.reason;
+  if (reason instanceof DeadlineExceededError || reason instanceof CancelledError) throw reason;
+  if (reason && typeof reason === "object" && reason.name === "TimeoutError") {
+    throw new DeadlineExceededError(void 0, { cause: reason });
+  }
+  throw new CancelledError(void 0, { cause: reason });
+}
+var init_abort = __esm({
+  "src/client/abort.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/providers/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  AnthropicProvider: () => AnthropicProvider
+});
 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_errors2();
     init_shape();
+    init_request2();
+    init_response();
+    init_stream();
+    init_abort();
     AnthropicProvider = class {
       id = "anthropic";
       client;
@@ -374,6 +888,7 @@ var init_anthropic = __esm({
         this.client = client ?? new import_sdk.default({ apiKey });
       }
       async create(spec, req) {
+        const signal = signalWithDeadline(req.signal, req.deadline);
         try {
           let messages = toAnthropicMessages(req);
           const content = [];
@@ -382,7 +897,8 @@ var init_anthropic = __esm({
           let id = "";
           for (let i = 0; i < 8; i++) {
             const res = await this.client.messages.create(
-              buildParams(spec, req, messages)
+              buildParams(spec, req, messages),
+              { signal }
             );
             id = res.id;
             addUsage(usage, mapUsage(res.usage));
@@ -396,34 +912,39 @@ var init_anthropic = __esm({
           }
           return { id, model: req.model, provider: "anthropic", role: "assistant", content, stopReason, usage };
         } catch (err) {
-          mapProviderError(err, "anthropic");
+          mapProviderError(err, "anthropic", signal);
         }
       }
       async *stream(spec, req) {
+        const signal = signalWithDeadline(req.signal, req.deadline);
         try {
           const events = this.client.messages.stream(
-            buildParams(spec, req, toAnthropicMessages(req))
+            buildParams(spec, req, toAnthropicMessages(req)),
+            { signal }
           );
           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() };
+          yield { type: "error", error: normalizeError(err, "anthropic", signal).toShape() };
         }
       }
     };
   }
 });
 
-// src/providers/openai.ts
-var openai_exports = {};
-__export(openai_exports, {
-  OpenAIProvider: () => OpenAIProvider,
-  mapResponse: () => mapResponse,
-  parseArgs: () => parseArgs,
-  toOpenAIMessages: () => toOpenAIMessages
+// src/providers/blocks.ts
+function stringifyBlocks(blocks) {
+  return blocks.map((b) => b.type === "text" ? b.text : `[${b.type}]`).join("");
+}
+var init_blocks2 = __esm({
+  "src/providers/blocks.ts"() {
+    "use strict";
+  }
 });
+
+// src/providers/openai/request.ts
 function buildParams2(spec, req, stream) {
   const params = {
     model: spec.nativeId,
@@ -520,9 +1041,6 @@ function audioFormat(m) {
   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) => ({
@@ -542,6 +1060,15 @@ function reasoningEffort(e) {
   if (e === "medium") return "medium";
   return "high";
 }
+var init_request3 = __esm({
+  "src/providers/openai/request.ts"() {
+    "use strict";
+    init_shape();
+    init_blocks2();
+  }
+});
+
+// src/providers/openai/response.ts
 function mapResponse(res, req) {
   const choice = res.choices[0];
   const content = [];
@@ -565,9 +1092,10 @@ function parseArgs(raw) {
   if (!raw) return {};
   try {
     const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
+    return toolInput(parsed, "openai", "function");
+  } catch (error) {
+    if (error instanceof ToolInputError) throw error;
+    throw new ToolInputError("[openai] tool returned malformed JSON arguments.", { cause: error });
   }
 }
 function mapFinish(reason) {
@@ -591,6 +1119,15 @@ function mapUsage2(u) {
   if (cached != null) usage.cacheReadTokens = cached;
   return usage;
 }
+var init_response2 = __esm({
+  "src/providers/openai/response.ts"() {
+    "use strict";
+    init_shape();
+    init_tool_input();
+  }
+});
+
+// src/providers/openai/stream.ts
 async function* mapStream(stream, req) {
   let started = false;
   let textOpen = false;
@@ -638,13 +1175,32 @@ async function* mapStream(stream, req) {
   yield { type: "message_delta", delta: { stopReason }, usage };
   yield { type: "message_stop" };
 }
+var init_stream2 = __esm({
+  "src/providers/openai/stream.ts"() {
+    "use strict";
+    init_shape();
+    init_response2();
+  }
+});
+
+// src/providers/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAIProvider: () => OpenAIProvider,
+  mapResponse: () => mapResponse,
+  parseArgs: () => parseArgs,
+  toOpenAIMessages: () => toOpenAIMessages
+});
 var import_openai2, OpenAIProvider;
 var init_openai = __esm({
   "src/providers/openai.ts"() {
     "use strict";
     import_openai2 = __toESM(require("openai"), 1);
-    init_errors();
-    init_shape();
+    init_errors2();
+    init_request3();
+    init_response2();
+    init_stream2();
+    init_abort();
     OpenAIProvider = class {
       id = "openai";
       client;
@@ -652,36 +1208,34 @@ var init_openai = __esm({
         this.client = client ?? new import_openai2.default({ apiKey });
       }
       async create(spec, req) {
+        const signal = signalWithDeadline(req.signal, req.deadline);
         try {
           const res = await this.client.chat.completions.create(
-            buildParams2(spec, req, false)
+            buildParams2(spec, req, false),
+            { signal }
           );
           return mapResponse(res, req);
         } catch (err) {
-          mapProviderError(err, "openai");
+          mapProviderError(err, "openai", signal);
         }
       }
       async *stream(spec, req) {
+        const signal = signalWithDeadline(req.signal, req.deadline);
         try {
           const stream = await this.client.chat.completions.create(
-            buildParams2(spec, req, true)
+            buildParams2(spec, req, true),
+            { signal }
           );
           yield* mapStream(stream, req);
         } catch (err) {
-          yield { type: "error", error: normalizeError(err, "openai").toShape() };
+          yield { type: "error", error: normalizeError(err, "openai", signal).toShape() };
         }
       }
     };
   }
 });
 
-// src/providers/google.ts
-var google_exports = {};
-__export(google_exports, {
-  GoogleProvider: () => GoogleProvider,
-  mapResponse: () => mapResponse2,
-  toContents: () => toContents
-});
+// src/providers/google/request.ts
 function buildParams3(spec, req) {
   const config = { maxOutputTokens: req.maxTokens };
   if (req.system !== void 0) {
@@ -729,16 +1283,13 @@ function toPart(b) {
         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) }
+          response: { result: typeof b.content === "string" ? b.content : stringifyBlocks(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) {
@@ -759,6 +1310,17 @@ function mapToolChoice3(tc) {
   if (tc === "any") return { functionCallingConfig: { mode: import_genai.FunctionCallingConfigMode.ANY } };
   return { functionCallingConfig: { mode: import_genai.FunctionCallingConfigMode.ANY, allowedFunctionNames: [tc.name] } };
 }
+var import_genai;
+var init_request4 = __esm({
+  "src/providers/google/request.ts"() {
+    "use strict";
+    import_genai = require("@google/genai");
+    init_shape();
+    init_blocks2();
+  }
+});
+
+// src/providers/google/response.ts
 function mapResponse2(res, req) {
   const candidate = res.candidates?.[0];
   const parts = candidate?.content?.parts ?? [];
@@ -769,7 +1331,7 @@ function mapResponse2(res, req) {
     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 ?? {} });
+      content.push({ type: "tool_use", id: p.functionCall.id ?? name, name, input: toolInput(p.functionCall.args ?? {}, "google", name) });
     }
   }
   return {
@@ -807,6 +1369,14 @@ function mapUsage3(res) {
   if (u?.cachedContentTokenCount != null) usage.cacheReadTokens = u.cachedContentTokenCount;
   return usage;
 }
+var init_response3 = __esm({
+  "src/providers/google/response.ts"() {
+    "use strict";
+    init_tool_input();
+  }
+});
+
+// src/providers/google/stream.ts
 async function* mapStream2(iter, req) {
   let started = false;
   let textOpen = false;
@@ -850,33 +1420,57 @@ async function* mapStream2(iter, req) {
   yield { type: "message_delta", delta: { stopReason }, usage };
   yield { type: "message_stop" };
 }
-var import_genai, GoogleProvider;
+var init_stream3 = __esm({
+  "src/providers/google/stream.ts"() {
+    "use strict";
+    init_shape();
+    init_response3();
+  }
+});
+
+// src/providers/google.ts
+var google_exports = {};
+__export(google_exports, {
+  GoogleProvider: () => GoogleProvider,
+  mapResponse: () => mapResponse2,
+  toContents: () => toContents
+});
+var import_genai2, GoogleProvider;
 var init_google = __esm({
   "src/providers/google.ts"() {
     "use strict";
-    import_genai = require("@google/genai");
-    init_errors();
-    init_shape();
+    import_genai2 = require("@google/genai");
+    init_errors2();
+    init_request4();
+    init_response3();
+    init_stream3();
+    init_abort();
     GoogleProvider = class {
       id = "google";
       client;
       constructor(apiKey, client) {
-        this.client = client ?? new import_genai.GoogleGenAI({ apiKey });
+        this.client = client ?? new import_genai2.GoogleGenAI({ apiKey });
       }
       async create(spec, req) {
+        const signal = signalWithDeadline(req.signal, req.deadline);
         try {
-          const res = await this.client.models.generateContent(buildParams3(spec, req));
+          const params = buildParams3(spec, req);
+          params.config = { ...params.config, abortSignal: signal };
+          const res = await this.client.models.generateContent(params);
           return mapResponse2(res, req);
         } catch (err) {
-          mapProviderError(err, "google");
+          mapProviderError(err, "google", signal);
         }
       }
       async *stream(spec, req) {
+        const signal = signalWithDeadline(req.signal, req.deadline);
         try {
-          const iter = await this.client.models.generateContentStream(buildParams3(spec, req));
+          const params = buildParams3(spec, req);
+          params.config = { ...params.config, abortSignal: signal };
+          const iter = await this.client.models.generateContentStream(params);
           yield* mapStream2(iter, req);
         } catch (err) {
-          yield { type: "error", error: normalizeError(err, "google").toShape() };
+          yield { type: "error", error: normalizeError(err, "google", signal).toShape() };
         }
       }
     };
@@ -889,11 +1483,13 @@ __export(index_exports, {
   AGENT_SCHEMA: () => AGENT_SCHEMA,
   ANTHROPIC_MODELS: () => ANTHROPIC_MODELS,
   AuthError: () => AuthError,
+  CancelledError: () => CancelledError,
   CapabilityError: () => CapabilityError,
   ConfigError: () => ConfigError,
   ContextWindowError: () => ContextWindowError,
   DEFAULT_CATALOG: () => DEFAULT_CATALOG,
   DEFAULT_SECRET_NAMES: () => DEFAULT_SECRET_NAMES,
+  DeadlineExceededError: () => DeadlineExceededError,
   GOOGLE_MODELS: () => GOOGLE_MODELS,
   InMemoryScope: () => InMemoryScope,
   InvalidRequestError: () => InvalidRequestError,
@@ -904,6 +1500,7 @@ __export(index_exports, {
   ProviderError: () => ProviderError,
   RateLimitError: () => RateLimitError,
   TaintError: () => TaintError,
+  ToolInputError: () => ToolInputError,
   addUsage: () => addUsage,
   assertSinkAcceptsTaint: () => assertSinkAcceptsTaint,
   blocksOf: () => blocksOf,
@@ -949,6 +1546,7 @@ __export(index_exports, {
   structuredMatch: () => structuredMatch,
   taint: () => taint,
   toOracleTool: () => toOracleTool,
+  validateJsonSchema: () => validateJsonSchema,
   validateRequest: () => validateRequest
 });
 module.exports = __toCommonJS(index_exports);
@@ -958,7 +1556,7 @@ init_shape();
 
 // src/shape/capabilities.ts
 init_shape();
-function chatCapabilities(overrides = {}) {
+function chatCapabilities(overrides2 = {}) {
   return {
     kind: "chat",
     textIn: true,
@@ -971,7 +1569,7 @@ function chatCapabilities(overrides = {}) {
     streaming: true,
     structuredOutput: true,
     webSearch: false,
-    ...overrides
+    ...overrides2
   };
 }
 function validateRequest(spec, req) {
@@ -1063,6 +1661,15 @@ var OPENAI_MODELS = [
     capabilities: chatCapabilities({ effort: true }),
     contextWindow: 4e5
   },
+  {
+    // Compact GPT-5.4 reasoning model (effort knob), same 400K context as the
+    // rest of the GPT-5 line. The default for odla-o11y AI triage.
+    id: "gpt-5.4-mini",
+    provider: "openai",
+    nativeId: "gpt-5.4-mini",
+    capabilities: chatCapabilities({ effort: true }),
+    contextWindow: 4e5
+  },
   {
     id: "gpt-5",
     provider: "openai",
@@ -1180,11 +1787,29 @@ function providersInCatalog(catalog) {
 }
 
 // src/providers/registry.ts
+var CLIENT_TTL_MS = 6e4;
 var cache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+var overrides = /* @__PURE__ */ new Map();
 async function getProvider(id, apiKey) {
-  const cacheKey = `${id}:${apiKey}`;
-  const existing = cache.get(cacheKey);
-  if (existing) return existing;
+  const override = overrides.get(id);
+  if (override?.apiKey === apiKey) return override.provider;
+  const fingerprint = await fingerprintKey(apiKey);
+  const existing = cache.get(id);
+  if (existing?.fingerprint === fingerprint && existing.expiresAt > Date.now()) return existing.provider;
+  if (existing) cache.delete(id);
+  const pending = inflight.get(id);
+  if (pending?.fingerprint === fingerprint) return pending.promise;
+  const promise = createProvider(id, apiKey).then((provider) => {
+    cache.set(id, { fingerprint, provider, expiresAt: Date.now() + CLIENT_TTL_MS });
+    return provider;
+  }).finally(() => {
+    if (inflight.get(id)?.promise === promise) inflight.delete(id);
+  });
+  inflight.set(id, { fingerprint, promise });
+  return promise;
+}
+async function createProvider(id, apiKey) {
   let provider;
   switch (id) {
     case "anthropic": {
@@ -1203,14 +1828,19 @@ async function getProvider(id, apiKey) {
       break;
     }
   }
-  cache.set(cacheKey, provider);
   return provider;
 }
+async function fingerprintKey(apiKey) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(apiKey));
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 function registerProvider(id, apiKey, provider) {
-  cache.set(`${id}:${apiKey}`, provider);
+  overrides.set(id, { apiKey, provider });
 }
 function clearProviderCache() {
   cache.clear();
+  inflight.clear();
+  overrides.clear();
 }
 
 // src/client/keys.ts
@@ -1281,7 +1911,9 @@ function init(opts = {}) {
       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
+      maxTokens: c.maxTokens ?? 4096,
+      signal: c.signal,
+      deadline: c.deadline
     };
     const { spec, provider } = await resolveProviderFor(model);
     validateRequest(spec, req);
@@ -1290,6 +1922,11 @@ function init(opts = {}) {
     if (!block || block.type !== "tool_use") {
       throw new ProviderError(`Model "${model}" did not return the forced tool call "${c.tool.name}".`);
     }
+    const validation = validateJsonSchema(c.tool.parameters, block.input);
+    if (!validation.valid) {
+      const detail = validation.issues.slice(0, 5).map((i) => `${i.path} ${i.message}`).join("; ");
+      throw new ToolInputError(`Tool "${c.tool.name}" returned invalid input: ${detail}`, { tool: c.tool.name });
+    }
     return { value: block.input, usage: res.usage };
   };
   const search = async (c) => {
@@ -1299,7 +1936,9 @@ function init(opts = {}) {
       system: c.system,
       messages: [{ role: "user", content: c.user }],
       webSearch: true,
-      maxTokens: c.maxTokens ?? 8192
+      maxTokens: c.maxTokens ?? 8192,
+      signal: c.signal,
+      deadline: c.deadline
     };
     const { spec, provider } = await resolveProviderFor(model);
     validateRequest(spec, req);
@@ -1328,16 +1967,20 @@ 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
 
+> EARLY ACCESS \u2014 pre-1.0. Agents work from bounded runbooks; humans approve
+> credentials, production changes, releases, and merges. APIs and exact package
+> availability can change. Review documented guarantees and limitations; this
+> software is MIT-licensed and provided without warranty.
+
 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.
+Targets Node 20+ and Cloudflare Workers. Provider adapters are runtime-lazy, but
+all provider SDKs are package dependencies. Never expose long-lived keys in a browser.
 
 ## 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
 
@@ -1351,7 +1994,8 @@ Isomorphic (Node 20+, Cloudflare Workers, browser). Provider SDKs are lazy-loade
 - \`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.extract<T>({ model, user, tool })\` \u2192 forced tool call; returns an object
+  validated against the declared JSON Schema. Unsupported assertions fail closed.
 - \`ai.search({ model, user })\` \u2192 web-search-grounded prose.
 
 ## Content blocks (multimodal)
@@ -1370,7 +2014,15 @@ audio block to a Claude model throws CapabilityError before any network call.
     // 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.
+prompt-injection gate. Personas may carry a MemoryScope. Tool inputs are schema-
+validated before handlers run. Pass signal/deadline and a run budget
+({maxInputTokens,maxOutputTokens,maxTotalTokens,maxToolCalls}) to bound follow-up
+effects and requested output. Input and total limits are post-turn ceilings:
+provider usage is unavailable before the first response, so they cannot
+tokenizer-bound the first prompt. Output and remaining-total limits cap the next
+request's maxTokens. Token limits must be positive integers; maxToolCalls may be
+zero. Budget exits pair every requested tool_use with an error tool_result before
+memory is persisted.
 
 ## Skills
 
@@ -1397,14 +2049,17 @@ 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) });
+    const ODLA_PLATFORM = "https://odla.ai";
+    const ODLA_DB_URL = "https://db.odla.ai";
+
+    // 1. Handshake: the human approves a short code at odla.ai.
+    const { token } = await requestToken({ endpoint: ODLA_PLATFORM, 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 } });
+    const { appId, appKey } = await provisionAgentApp({ endpoint: ODLA_PLATFORM, 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 db = odlaInit({ appId, adminToken: appKey, endpoint: ODLA_DB_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" });
@@ -1430,16 +2085,22 @@ env's odla-db tenant secrets, write-only for operators). One call reads both:
       platform: "https://odla.ai", appId: APP_ID, env: "prod", db });
     // ai.chat / ai.stream / ai.extract \u2014 provider/model from public-config
     // (cached ~60s, so Studio changes apply without redeploys); the key is
-    // fetched from the vault at call time via odlaDbKeyResolver.
+    // fetched from the vault via a finite-TTL odlaDbKeyResolver.
 
 The only secret the Worker carries is its odla-db app key. Rotating the LLM
-key = writing the secret again; switching provider/model = a Studio edit.
+key = writing the secret again; the default warm-isolate key TTL is 60 seconds
+and cacheVersion provides immediate invalidation. Provider SDK clients are
+fingerprinted, bounded to one generation per provider, and expire after 60
+seconds. The platform provider is enforced: models from other providers are
+absent from the facade catalog. If no default model is configured, each call
+must name a model for that provider. Only public config is shared; tenant-bound
+Ai facades are not cached globally.
 
 ## 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.
+tool_input_invalid, cancelled, deadline_exceeded, provider_error.
 
 ## Models
 
@@ -1451,10 +2112,11 @@ via buildCatalog / init({ catalog }).
 }
 
 // src/index.ts
-init_errors();
+init_errors2();
 
 // src/agent/loop.ts
 init_shape();
+init_abort();
 
 // src/agent/tools.ts
 function toOracleTool(t) {
@@ -1496,6 +2158,7 @@ function assertSinkAcceptsTaint(sink, allowed, actual) {
 
 // src/agent/loop.ts
 async function runAgent(inference, persona, input) {
+  validateRunLimits(persona.maxSteps, input.budget);
   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);
@@ -1507,21 +2170,26 @@ async function runAgent(inference, persona, input) {
   const toolCalls = [];
   const accumulatedTaint = /* @__PURE__ */ new Set(["llm_inherited"]);
   const maxSteps = persona.maxSteps ?? 8;
+  const runSignal = signalWithDeadline(input.signal, input.deadline);
   let response;
   let stoppedReason = "max_steps";
   let steps = 0;
+  let attemptedToolCalls = 0;
   while (steps < maxSteps) {
     steps++;
+    const remainingOutput = remainingOutputTokens(usage, input.budget);
     response = await inference.chat({
       model: persona.model,
       system,
       messages,
       tools: tools.length > 0 ? tools.map(toOracleTool) : void 0,
-      maxTokens: persona.maxTokens ?? 4096,
+      maxTokens: Math.min(persona.maxTokens ?? 4096, remainingOutput ?? Number.POSITIVE_INFINITY),
       effort: persona.effort,
       thinking: persona.thinking,
       temperature: persona.temperature,
-      webSearch: persona.webSearch
+      webSearch: persona.webSearch,
+      signal: runSignal,
+      deadline: input.deadline
     });
     addUsage(usage, response.usage);
     messages.push({ role: "assistant", content: response.content });
@@ -1534,8 +2202,22 @@ async function runAgent(inference, persona, input) {
       stoppedReason = "end_turn";
       break;
     }
+    if (budgetExceeded(usage, input.budget)) {
+      stoppedReason = "budget_exhausted";
+      messages.push({
+        role: "user",
+        content: toolUses.map((toolUse) => errorResult(toolUse.id, "Run budget exhausted before tool execution."))
+      });
+      break;
+    }
     const resultBlocks = [];
     for (const toolUse of toolUses) {
+      if (input.budget?.maxToolCalls !== void 0 && attemptedToolCalls >= input.budget.maxToolCalls) {
+        stoppedReason = "budget_exhausted";
+        resultBlocks.push(errorResult(toolUse.id, "Run tool-call budget exhausted before execution."));
+        continue;
+      }
+      attemptedToolCalls++;
       const def = handlerByName.get(toolUse.name);
       if (!def || !def.handler) {
         resultBlocks.push(errorResult(toolUse.id, `No local handler for tool "${toolUse.name}".`));
@@ -1543,16 +2225,26 @@ async function runAgent(inference, persona, input) {
       }
       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 };
+      const validation = validateJsonSchema(def.inputSchema, toolUse.input);
+      if (!validation.valid) {
+        const detail = validation.issues.slice(0, 5).map((i) => `${i.path} ${i.message}`).join("; ");
+        output = { content: `Tool "${toolUse.name}" input is invalid: ${detail}`, isError: true };
+      } else {
+        throwIfAborted(runSignal);
+        try {
+          output = await def.handler(toolUse.input, { taint: new Set(accumulatedTaint), signal: runSignal });
+        } catch (error) {
+          if (error instanceof CancelledError || error instanceof DeadlineExceededError) throw error;
+          throwIfAborted(runSignal);
+          output = { content: `Tool "${toolUse.name}" failed.`, 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 (stoppedReason === "budget_exhausted") break;
   }
   if (!response) throw new Error("runAgent: maxSteps must be at least 1");
   if (persona.memory) await persona.memory.append(messages.slice(runStartIndex));
@@ -1566,6 +2258,36 @@ async function runAgent(inference, persona, input) {
     stoppedReason
   };
 }
+function budgetExceeded(usage, budget) {
+  if (!budget) return false;
+  if (budget.maxInputTokens !== void 0 && usage.inputTokens >= budget.maxInputTokens) return true;
+  if (budget.maxOutputTokens !== void 0 && usage.outputTokens >= budget.maxOutputTokens) return true;
+  if (budget.maxTotalTokens !== void 0 && usage.inputTokens + usage.outputTokens >= budget.maxTotalTokens) return true;
+  return false;
+}
+function remainingOutputTokens(usage, budget) {
+  if (!budget) return void 0;
+  const remaining = [
+    budget.maxOutputTokens === void 0 ? void 0 : budget.maxOutputTokens - usage.outputTokens,
+    budget.maxTotalTokens === void 0 ? void 0 : budget.maxTotalTokens - usage.inputTokens - usage.outputTokens
+  ].filter((value) => value !== void 0);
+  return remaining.length === 0 ? void 0 : Math.max(1, Math.min(...remaining));
+}
+function validateRunLimits(maxSteps, budget) {
+  if (maxSteps !== void 0 && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
+    throw new ConfigError("persona.maxSteps must be a positive integer.");
+  }
+  if (!budget) return;
+  for (const key of ["maxInputTokens", "maxOutputTokens", "maxTotalTokens"]) {
+    const value = budget[key];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 1)) {
+      throw new ConfigError(`budget.${key} must be a positive integer.`);
+    }
+  }
+  if (budget.maxToolCalls !== void 0 && (!Number.isInteger(budget.maxToolCalls) || budget.maxToolCalls < 0)) {
+    throw new ConfigError("budget.maxToolCalls must be a non-negative integer.");
+  }
+}
 function errorResult(toolUseId, message) {
   return { type: "tool_result", toolUseId, content: message, isError: true };
 }
@@ -1870,22 +2592,32 @@ var DEFAULT_SECRET_NAMES = {
 };
 function odlaDbKeyResolver(db, opts = {}) {
   const nameFor = opts.secretName ?? ((p) => DEFAULT_SECRET_NAMES[p]);
-  const useCache = opts.cache ?? true;
+  const ttlMs = opts.cache === false ? 0 : Math.max(0, opts.ttlMs ?? 6e4);
   const cache3 = /* @__PURE__ */ new Map();
   return async (provider) => {
-    if (useCache) {
+    const version = typeof opts.cacheVersion === "function" ? opts.cacheVersion(provider) : opts.cacheVersion ?? "";
+    if (ttlMs > 0) {
       const hit = cache3.get(provider);
-      if (hit !== void 0) return hit;
+      if (hit?.version === version && hit.expiresAt > Date.now()) return hit.value;
+      cache3.delete(provider);
     }
     try {
       const key = await db.secrets.get(nameFor(provider));
-      if (useCache) cache3.set(provider, key);
+      if (ttlMs > 0) cache3.set(provider, { version, value: key, expiresAt: Date.now() + ttlMs });
       return key;
-    } catch {
-      return void 0;
+    } catch (error) {
+      if (isMissingSecret(error)) return void 0;
+      throw error;
     }
   };
 }
+function isMissingSecret(error) {
+  if (!error || typeof error !== "object") return false;
+  const rec = error;
+  if (rec.status === 404 || rec.statusCode === 404 || rec.code === "not_found") return true;
+  const message = error instanceof Error ? error.message : "";
+  return /\b404\b/.test(message);
+}
 
 // src/store/platform.ts
 init_shape();
@@ -1917,19 +2649,22 @@ async function initFromPlatform(opts) {
   const key = `${opts.platform}|${opts.appId}|${opts.env}`;
   const now = Date.now();
   const hit = ttl > 0 ? cache2.get(key) : void 0;
-  if (hit && hit.expiresAt > now) return hit.value;
-  const { provider, model } = await fetchAiConfig(opts);
-  if (hit && hit.value.provider === provider && hit.value.model === model) {
-    hit.expiresAt = now + ttl;
-    return hit.value;
-  }
+  const config = hit && hit.expiresAt > now ? hit.value : await fetchAiConfig(opts);
+  const { provider, model } = config;
+  if (ttl > 0 && (!hit || hit.expiresAt <= now)) cache2.set(key, { value: config, expiresAt: now + ttl });
+  const sourceCatalog = opts.initOptions?.catalog ?? DEFAULT_CATALOG;
+  const catalog = Object.fromEntries(
+    Object.entries(sourceCatalog).filter(([, spec]) => spec.provider === provider)
+  );
+  const defaultModel = model ?? opts.initOptions?.defaultModel;
+  if (defaultModel) resolveModel(catalog, defaultModel);
   const ai = init({
     ...opts.initOptions,
-    resolveKey: odlaDbKeyResolver(opts.db),
-    defaultModel: model ?? opts.initOptions?.defaultModel
+    catalog,
+    resolveKey: odlaDbKeyResolver(opts.db, opts.keyResolverOptions),
+    defaultModel
   });
   const value = { ai, provider, ...model ? { model } : {} };
-  if (ttl > 0) cache2.set(key, { value, expiresAt: now + ttl });
   return value;
 }