@cadraos/sdk 0.3.14-p46.3 → 0.3.14

package/dist/ai-functions/server/index.d.ts

@@ -0,0 +1,334 @@
+/**
+ * AI function types (p93 — specs §4 run contract, D27 discovery, §6.5 run reads).
+ *
+ * An AI function is a published prompt in the Cadra Prompts library that makes
+ * ONE direct AI-provider call (never an agent). Callers reference it by its
+ * `functionKey` (unique per org), by prompt uuid, or — for platform features —
+ * by slot key.
+ */
+/** Output kind of an AI function. */
+type AiFunctionOutputKind = 'text' | 'json' | 'image';
+/** Parameter (prompt variable) types — specs D10 + D26d. */
+type AiFunctionParameterType = 'string' | 'text' | 'number' | 'boolean' | 'enum' | 'image';
+/** A value passed for one parameter. `image` parameters take an artifact uuid (string). */
+type AiFunctionVariableValue = string | number | boolean;
+/** Parameters (variables) for one run, keyed by parameter name. */
+type AiFunctionVariables = Record<string, AiFunctionVariableValue>;
+/** One declared parameter of a function's live (golden) version — D27a. */
+interface AiFunctionParameter {
+    name: string;
+    type: AiFunctionParameterType;
+    required: boolean;
+    defaultValue?: AiFunctionVariableValue;
+    maxLength?: number;
+    options?: string[];
+    description?: string;
+}
+/**
+ * The discovery "index" entry for one callable function — D27a. Built from the
+ * golden version snapshot; never carries prompt or system text.
+ */
+interface AiFunctionDescriptor {
+    functionKey: string;
+    title: string;
+    description?: string | null;
+    outputKind: AiFunctionOutputKind;
+    /** The live (golden) version number. */
+    liveVersion: number;
+    parameters: AiFunctionParameter[];
+    /** JSON schema of the output, for `json` functions. */
+    outputSchema?: Record<string, unknown> | null;
+}
+/** Who paid for a run (D4). */
+type AiFunctionBilledTo = 'own_key' | 'credits' | 'platform_funded';
+/** Runtime params a slot may accept per run (D26d3). */
+interface AiFunctionRuntimeParams {
+    aspect_ratio?: string;
+    image_size?: string;
+}
+/** Options for the object form `run(ref, { variables, … })`. */
+interface AiFunctionRunOptions {
+    /** Parameters for this run (sent as `variables`). */
+    variables: AiFunctionVariables;
+    /** Pin a published version number (D3d). Skips the client-side check. */
+    version?: number;
+    /** Idempotency key (uuid). Generated when omitted (D15). */
+    idempotencyKey?: string;
+    /** Slot runtime params (D26d3). */
+    params?: AiFunctionRuntimeParams;
+    /** `false` skips the client-side parameter check (D27c). Default true. */
+    validate?: boolean;
+}
+/** Options for the shorthand `run('function_key', parameters, opts)`. */
+type AiFunctionRunShorthandOptions = Omit<AiFunctionRunOptions, 'variables'>;
+/** Image produced by an `image` function. Over HTTP only `url` (presigned, 1 h) is set. */
+interface AiFunctionImage {
+    mimeType: string;
+    url?: string;
+    bytes?: Uint8Array;
+}
+/** Output of a run, by kind (§4). `TOutput` types `json`. */
+type AiFunctionOutput<TOutput = unknown> = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'json';
+    json: TOutput;
+} | {
+    type: 'image';
+    images: AiFunctionImage[];
+};
+/** Token and billing usage of a run (§4). */
+interface AiFunctionUsage {
+    promptTokens: number;
+    completionTokens: number;
+    imageCount: number;
+    billedTo: AiFunctionBilledTo;
+}
+/** Result of a successful run (§4). */
+interface AiFunctionRunResult<TOutput = unknown> {
+    /** = the run's execution uuid (usage-ledger executionUuid). */
+    executionId: string;
+    functionUuid: string;
+    version: number;
+    output: AiFunctionOutput<TOutput>;
+    usage: AiFunctionUsage;
+    latencyMs: number;
+}
+
+/**
+ * Host-app AI function slots — shared types (p93 AIF-017, specs D28).
+ *
+ * Type-only module: imported by both `@cadraos/sdk/ai-functions/server` and
+ * `@cadraos/sdk/ai-functions/react` (the panel renders the rows the server
+ * handlers return), so it must stay free of runtime code and of React.
+ */
+
+type MaybePromise<T> = T | Promise<T>;
+/** One parameter a host slot passes when it calls its function. */
+interface AiFunctionSlotParameter {
+    name: string;
+    type: AiFunctionParameterType;
+    required: boolean;
+    maxLength?: number;
+    options?: string[];
+}
+/** A place in the host app that calls an AI function (declared in host code). */
+interface AiFunctionSlot {
+    /** Stable key, e.g. `campaign_subject`. Also the store key. */
+    key: string;
+    /** Human label for the admin panel. */
+    label: string;
+    /** What the host uses it for (panel "Used for" column). */
+    usedFor?: string;
+    /** The output kind the host code expects. */
+    outputKind: AiFunctionOutputKind;
+    /** Parameters the host code passes. */
+    parameters: readonly AiFunctionSlotParameter[];
+}
+/** What a slot is bound to: a function of the host's Cadra org. */
+interface AiFunctionSlotBinding {
+    functionKey: string;
+}
+/**
+ * 4-method persistence adapter supplied by the host (e.g. Yobo: `system_config`,
+ * category `cadra_ai_functions`). Values may come back as the stored object or
+ * as its JSON string; anything unparseable reads as unset. There is NO env
+ * fallback — unset means unavailable.
+ */
+interface AiFunctionSlotStore {
+    get(key: string): MaybePromise<AiFunctionSlotBinding | string | null | undefined>;
+    set(key: string, value: AiFunctionSlotBinding): MaybePromise<void>;
+    delete(key: string): MaybePromise<void>;
+    list(): MaybePromise<Array<{
+        key: string;
+        value: AiFunctionSlotBinding | string | null | undefined;
+    }>>;
+}
+/** Why a function does not fit a slot (D16 rule applied to a D27 descriptor). */
+type AiFunctionSlotCompatIssueCode = 'function_unavailable' | 'output_kind' | 'parameter_missing' | 'parameter_type' | 'parameter_required' | 'options' | 'max_length';
+interface AiFunctionSlotCompatIssue {
+    code: AiFunctionSlotCompatIssueCode;
+    /** The parameter concerned, when there is one. */
+    parameter?: string;
+    message: string;
+}
+interface AiFunctionSlotCompatVerdict {
+    compatible: boolean;
+    issues: AiFunctionSlotCompatIssue[];
+}
+/** A function offered in a slot's picker. */
+interface AiFunctionSlotOption {
+    functionKey: string;
+    title: string;
+    liveVersion: number;
+}
+/** One row of `listSlots()` — catalog + binding + live descriptor + verdict. */
+interface AiFunctionSlotRow {
+    key: string;
+    label: string;
+    usedFor: string | null;
+    outputKind: AiFunctionOutputKind;
+    parameters: AiFunctionSlotParameter[];
+    /** The stored binding, or null when the slot is unset. */
+    binding: AiFunctionSlotBinding | null;
+    /** The bound function's live descriptor summary; null when unset or unavailable. */
+    boundFunction: (AiFunctionSlotOption & {
+        outputKind: AiFunctionOutputKind;
+    }) | null;
+    /** Compatibility of the bound function; null when the slot is unset. */
+    compat: AiFunctionSlotCompatVerdict | null;
+    /** Functions compatible with this slot (the picker's choices). */
+    options: AiFunctionSlotOption[];
+}
+/** Result of a successful `setSlot`. */
+interface AiFunctionSetSlotResult {
+    key: string;
+    functionKey: string;
+    liveVersion: number;
+}
+/**
+ * The slice of `CadraClient` the module needs — structural, so a host can pass
+ * its own `CadraClient` (any SDK copy) or a test double.
+ */
+interface AiFunctionsClientLike {
+    aiFunctions: {
+        list(): Promise<AiFunctionDescriptor[]>;
+        get(functionKey: string): Promise<AiFunctionDescriptor>;
+        run<TOutput = unknown>(functionKey: string, parameters: AiFunctionVariables, opts?: AiFunctionRunShorthandOptions): Promise<AiFunctionRunResult<TOutput>>;
+    };
+}
+/** Kinds a thrown SDK error maps to (D28). */
+type AiFunctionErrorKind = 'rate_limited' | 'unauthorized' | 'forbidden' | 'not_found' | 'timeout' | 'network' | 'upstream';
+interface AiFunctionErrorClassification {
+    kind: AiFunctionErrorKind;
+    /** HTTP status when the error carried one. */
+    status?: number;
+    /** The server's own `error.code` when present (e.g. `NO_CREDITS`). */
+    serverCode?: string;
+    /** Seconds until a rate limit resets, when reported. */
+    retryAfterSeconds?: number;
+    message: string;
+}
+
+/**
+ * Slot catalog, resolver, compatibility and handlers (p93 AIF-017, specs D28).
+ *
+ * Port of Yobo's app-local `lib/cadra/function-config.ts` semantics (60 s
+ * process-local Map cache, cleared on write) MINUS the env fallback: an unset
+ * slot is unavailable, never silently served from `process.env`.
+ */
+
+/** Base class for slot-module errors. `code` is stable; branch on it, not `instanceof`. */
+declare class AiFunctionSlotError extends Error {
+    readonly code: string;
+    readonly slotKey: string;
+    constructor(code: string, slotKey: string, message: string);
+}
+/** `runSlot` on a slot with no binding. No request was sent. */
+declare class AiFunctionSlotUnsetError extends AiFunctionSlotError {
+    constructor(slotKey: string);
+}
+/** A key that is not in the declared catalog. */
+declare class AiFunctionUnknownSlotError extends AiFunctionSlotError {
+    constructor(slotKey: string);
+}
+/** `setSlot` refused: the function's live version does not fit the slot. */
+declare class AiFunctionSlotIncompatibleError extends AiFunctionSlotError {
+    readonly functionKey: string;
+    readonly issues: AiFunctionSlotCompatIssue[];
+    constructor(slotKey: string, functionKey: string, issues: AiFunctionSlotCompatIssue[]);
+}
+/**
+ * Declare the host app's slots. Validates keys (lower_snake, unique) and
+ * parameter names, and returns the same array (frozen) so literal key types
+ * survive: `runSlot(deps, 'campaign_subject', …)`.
+ */
+declare function defineAiFunctionSlots<const T extends readonly AiFunctionSlot[]>(slots: T): T;
+/** Parse a stored value into a binding; anything else is "unset". */
+declare function parseAiFunctionSlotBinding(raw: unknown): AiFunctionSlotBinding | null;
+interface AiFunctionSlotResolver {
+    /** The binding for `key` (cached for `ttlMs`, including "unset"). */
+    get(key: string): Promise<AiFunctionSlotBinding | null>;
+    /** Store a binding and clear that key's cache. */
+    set(key: string, binding: AiFunctionSlotBinding): Promise<void>;
+    /** Remove a binding and clear that key's cache. */
+    delete(key: string): Promise<void>;
+    /** Every stored binding, read fresh from the store (admin view). */
+    list(): Promise<Map<string, AiFunctionSlotBinding>>;
+    /** Drop one key's cache entry, or all. */
+    clearCache(key?: string): void;
+}
+interface CreateAiFunctionSlotResolverOptions {
+    store: AiFunctionSlotStore;
+    /** Cache TTL in ms (default 60 000). The cache is per process. */
+    ttlMs?: number;
+}
+/**
+ * Resolve slot → binding with a process-local TTL cache. Writes through this
+ * resolver clear the cache so the writing process live-swaps; other processes
+ * pick the change up within `ttlMs`.
+ */
+declare function createAiFunctionSlotResolver(options: CreateAiFunctionSlotResolverOptions): AiFunctionSlotResolver;
+/**
+ * Does `descriptor` (a function's live version) fit `slot`? Passes iff: same
+ * output kind; every slot parameter exists with the same type (`string` ≠
+ * `text`); every REQUIRED function parameter is declared by the slot as
+ * required; enum options ⊇ the slot's; string/text effective maxLength ≥ the
+ * slot's.
+ */
+declare function checkAiFunctionSlotCompatibility(slot: Pick<AiFunctionSlot, 'outputKind' | 'parameters'>, descriptor: Pick<AiFunctionDescriptor, 'outputKind' | 'parameters'>): AiFunctionSlotCompatVerdict;
+interface AiFunctionSlotDeps {
+    client: AiFunctionsClientLike;
+    slots: readonly AiFunctionSlot[];
+    resolver: AiFunctionSlotResolver;
+}
+interface AiFunctionSlotHandlers {
+    /** Catalog + binding + live descriptor + compat verdict + compatible choices. */
+    listSlots(): Promise<AiFunctionSlotRow[]>;
+    /** Bind a slot; refuses an incompatible function (`AiFunctionSlotIncompatibleError`). */
+    setSlot(input: {
+        key: string;
+        functionKey: string;
+    }): Promise<AiFunctionSetSlotResult>;
+    /** Unbind a slot (it becomes unavailable). */
+    resetSlot(input: {
+        key: string;
+    }): Promise<{
+        key: string;
+    }>;
+    /** The org's callable functions, optionally by output kind. */
+    listFunctions(input?: {
+        outputKind?: AiFunctionDescriptor['outputKind'];
+    }): Promise<AiFunctionDescriptor[]>;
+}
+/**
+ * Framework-free async handlers. Wrap each in one router entry of the host
+ * (tRPC procedure, route handler, …) behind the host's admin permission.
+ * Errors from the SDK are rethrown untouched — map them with
+ * `classifyAiFunctionError` so a failed catalog read shows as an error, never
+ * as an empty list.
+ */
+declare function createAiFunctionSlotHandlers(deps: AiFunctionSlotDeps): AiFunctionSlotHandlers;
+/**
+ * Run the function bound to a slot. Unset ⇒ `AiFunctionSlotUnsetError` with no
+ * request. Calls use the host's Cadra API key (`public_api`, billed to that org).
+ */
+declare function runSlot<TOutput = unknown>(deps: AiFunctionSlotDeps, key: string, parameters: AiFunctionVariables, opts?: AiFunctionRunShorthandOptions): Promise<AiFunctionRunResult<TOutput>>;
+
+/**
+ * Structural SDK-error classifier (p93 AIF-017, specs D28).
+ *
+ * Reads `status` / `name` / `serverCode` off the thrown value — never
+ * `instanceof`: the SDK is often `link:`ed or duplicated in a host bundle, so
+ * class identity across module boundaries is a needless failure mode (Yobo
+ * `lib/cadra/upstream-error.ts` lesson, F55).
+ */
+
+/**
+ * Map anything an AI-function call threw to one of
+ * `rate_limited | unauthorized | forbidden | not_found | timeout | network | upstream`.
+ */
+declare function classifyAiFunctionError(error: unknown): AiFunctionErrorClassification;
+
+export { type AiFunctionDescriptor, type AiFunctionErrorClassification, type AiFunctionErrorKind, type AiFunctionOutputKind, type AiFunctionParameter, type AiFunctionParameterType, type AiFunctionRunResult, type AiFunctionSetSlotResult, type AiFunctionSlot, type AiFunctionSlotBinding, type AiFunctionSlotCompatIssue, type AiFunctionSlotCompatIssueCode, type AiFunctionSlotCompatVerdict, type AiFunctionSlotDeps, AiFunctionSlotError, type AiFunctionSlotHandlers, AiFunctionSlotIncompatibleError, type AiFunctionSlotOption, type AiFunctionSlotParameter, type AiFunctionSlotResolver, type AiFunctionSlotRow, type AiFunctionSlotStore, AiFunctionSlotUnsetError, AiFunctionUnknownSlotError, type AiFunctionVariables, type AiFunctionsClientLike, type CreateAiFunctionSlotResolverOptions, checkAiFunctionSlotCompatibility, classifyAiFunctionError, createAiFunctionSlotHandlers, createAiFunctionSlotResolver, defineAiFunctionSlots, parseAiFunctionSlotBinding, runSlot };

package/dist/ai-functions/server/index.js

@@ -0,0 +1,284 @@
+// src/ai-functions/server/slots.ts
+var AiFunctionSlotError = class extends Error {
+  code;
+  slotKey;
+  constructor(code, slotKey, message) {
+    super(message);
+    this.name = "AiFunctionSlotError";
+    this.code = code;
+    this.slotKey = slotKey;
+  }
+};
+var AiFunctionSlotUnsetError = class extends AiFunctionSlotError {
+  constructor(slotKey) {
+    super("slot_unset", slotKey, `AI function slot "${slotKey}" is not bound to a function.`);
+    this.name = "AiFunctionSlotUnsetError";
+  }
+};
+var AiFunctionUnknownSlotError = class extends AiFunctionSlotError {
+  constructor(slotKey) {
+    super("unknown_slot", slotKey, `Unknown AI function slot "${slotKey}".`);
+    this.name = "AiFunctionUnknownSlotError";
+  }
+};
+var AiFunctionSlotIncompatibleError = class extends AiFunctionSlotError {
+  functionKey;
+  issues;
+  constructor(slotKey, functionKey, issues) {
+    super(
+      "binding_incompatible",
+      slotKey,
+      `"${functionKey}" does not fit slot "${slotKey}": ` + issues.map((i) => i.message).join("; ")
+    );
+    this.name = "AiFunctionSlotIncompatibleError";
+    this.functionKey = functionKey;
+    this.issues = issues;
+  }
+};
+var SLOT_KEY_RE = /^[a-z][a-z0-9_]{1,63}$/;
+function defineAiFunctionSlots(slots) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const slot of slots) {
+    if (!SLOT_KEY_RE.test(slot.key)) {
+      throw new Error(`Invalid AI function slot key "${slot.key}" (use lower_snake_case, 2\u201364 chars).`);
+    }
+    if (seen.has(slot.key)) throw new Error(`Duplicate AI function slot key "${slot.key}".`);
+    seen.add(slot.key);
+    const names = /* @__PURE__ */ new Set();
+    for (const p of slot.parameters) {
+      if (!p.name || names.has(p.name)) {
+        throw new Error(`Slot "${slot.key}": parameter names must be non-empty and unique ("${p.name}").`);
+      }
+      names.add(p.name);
+      if (p.type === "enum" && (!p.options || p.options.length === 0)) {
+        throw new Error(`Slot "${slot.key}": enum parameter "${p.name}" needs options.`);
+      }
+    }
+  }
+  return Object.freeze(slots);
+}
+function parseAiFunctionSlotBinding(raw) {
+  let value = raw;
+  if (typeof value === "string") {
+    const t = value.trim();
+    if (!t.startsWith("{")) return null;
+    try {
+      value = JSON.parse(t);
+    } catch {
+      return null;
+    }
+  }
+  if (value && typeof value === "object") {
+    const fk = value.functionKey;
+    if (typeof fk === "string" && fk.trim()) return { functionKey: fk.trim() };
+  }
+  return null;
+}
+function createAiFunctionSlotResolver(options) {
+  const { store } = options;
+  const ttlMs = options.ttlMs ?? 6e4;
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      const now = Date.now();
+      const hit = cache.get(key);
+      if (hit && hit.expiresAt > now) return hit.value;
+      const value = parseAiFunctionSlotBinding(await store.get(key));
+      cache.set(key, { value, expiresAt: now + ttlMs });
+      return value;
+    },
+    async set(key, binding) {
+      await store.set(key, { functionKey: binding.functionKey });
+      cache.delete(key);
+    },
+    async delete(key) {
+      await store.delete(key);
+      cache.delete(key);
+    },
+    async list() {
+      const rows = await store.list();
+      const out = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const b = parseAiFunctionSlotBinding(row.value);
+        if (b) out.set(row.key, b);
+      }
+      return out;
+    },
+    clearCache(key) {
+      if (key) cache.delete(key);
+      else cache.clear();
+    }
+  };
+}
+var DEFAULT_MAX_LENGTH = { string: 2e3, text: 24e3 };
+function checkAiFunctionSlotCompatibility(slot, descriptor) {
+  const issues = [];
+  if (descriptor.outputKind !== slot.outputKind) {
+    issues.push({
+      code: "output_kind",
+      message: `returns ${descriptor.outputKind}, the slot expects ${slot.outputKind}`
+    });
+  }
+  const fnParams = new Map(descriptor.parameters.map((p) => [p.name, p]));
+  const slotParams = new Map(slot.parameters.map((p) => [p.name, p]));
+  for (const sp of slot.parameters) {
+    const fp = fnParams.get(sp.name);
+    if (!fp) {
+      issues.push({ code: "parameter_missing", parameter: sp.name, message: `has no parameter '${sp.name}'` });
+      continue;
+    }
+    if (fp.type !== sp.type) {
+      issues.push({
+        code: "parameter_type",
+        parameter: sp.name,
+        message: `parameter '${sp.name}' is ${fp.type}, the slot passes ${sp.type}`
+      });
+      continue;
+    }
+    if (sp.options && sp.options.length > 0) {
+      const have = new Set(fp.options ?? []);
+      const missing = sp.options.filter((o) => !have.has(o));
+      if (missing.length > 0) {
+        issues.push({
+          code: "options",
+          parameter: sp.name,
+          message: `parameter '${sp.name}' does not accept ${missing.map((m) => `'${m}'`).join(", ")}`
+        });
+      }
+    }
+    if (typeof sp.maxLength === "number" && (sp.type === "string" || sp.type === "text")) {
+      const effective = fp.maxLength ?? DEFAULT_MAX_LENGTH[fp.type];
+      if (typeof effective === "number" && effective < sp.maxLength) {
+        issues.push({
+          code: "max_length",
+          parameter: sp.name,
+          message: `parameter '${sp.name}' allows ${effective} characters, the slot may pass ${sp.maxLength}`
+        });
+      }
+    }
+  }
+  for (const fp of descriptor.parameters) {
+    if (!fp.required) continue;
+    const sp = slotParams.get(fp.name);
+    if (!sp || !sp.required) {
+      issues.push({
+        code: "parameter_required",
+        parameter: fp.name,
+        message: sp ? `requires '${fp.name}', which the slot passes only optionally` : `requires '${fp.name}', which the slot does not pass`
+      });
+    }
+  }
+  return { compatible: issues.length === 0, issues };
+}
+function findSlot(slots, key) {
+  const slot = slots.find((s) => s.key === key);
+  if (!slot) throw new AiFunctionUnknownSlotError(key);
+  return slot;
+}
+function toOption(d) {
+  return { functionKey: d.functionKey, title: d.title, liveVersion: d.liveVersion };
+}
+function createAiFunctionSlotHandlers(deps) {
+  const { client, slots, resolver } = deps;
+  return {
+    async listSlots() {
+      const [functions, bindings] = await Promise.all([client.aiFunctions.list(), resolver.list()]);
+      const byKey = new Map(functions.map((f) => [f.functionKey, f]));
+      return slots.map((slot) => {
+        const binding = bindings.get(slot.key) ?? null;
+        const bound = binding ? byKey.get(binding.functionKey) : void 0;
+        let compat = null;
+        if (binding) {
+          compat = bound ? checkAiFunctionSlotCompatibility(slot, bound) : {
+            compatible: false,
+            issues: [
+              {
+                code: "function_unavailable",
+                message: `'${binding.functionKey}' is not published or no longer exists`
+              }
+            ]
+          };
+        }
+        return {
+          key: slot.key,
+          label: slot.label,
+          usedFor: slot.usedFor ?? null,
+          outputKind: slot.outputKind,
+          parameters: slot.parameters.map((p) => ({ ...p })),
+          binding,
+          boundFunction: bound ? { ...toOption(bound), outputKind: bound.outputKind } : null,
+          compat,
+          options: functions.filter((f) => checkAiFunctionSlotCompatibility(slot, f).compatible).map(toOption)
+        };
+      });
+    },
+    async setSlot({ key, functionKey }) {
+      const slot = findSlot(slots, key);
+      const descriptor = await client.aiFunctions.get(functionKey);
+      const verdict = checkAiFunctionSlotCompatibility(slot, descriptor);
+      if (!verdict.compatible) {
+        throw new AiFunctionSlotIncompatibleError(key, functionKey, verdict.issues);
+      }
+      await resolver.set(key, { functionKey });
+      return { key, functionKey, liveVersion: descriptor.liveVersion };
+    },
+    async resetSlot({ key }) {
+      findSlot(slots, key);
+      await resolver.delete(key);
+      return { key };
+    },
+    async listFunctions(input) {
+      const functions = await client.aiFunctions.list();
+      return input?.outputKind ? functions.filter((f) => f.outputKind === input.outputKind) : functions;
+    }
+  };
+}
+async function runSlot(deps, key, parameters, opts) {
+  findSlot(deps.slots, key);
+  const binding = await deps.resolver.get(key);
+  if (!binding) throw new AiFunctionSlotUnsetError(key);
+  return deps.client.aiFunctions.run(binding.functionKey, parameters, opts);
+}
+
+// src/ai-functions/server/classify.ts
+function numberAt(source, key) {
+  if (!source || typeof source !== "object") return void 0;
+  const raw = source[key];
+  const n = typeof raw === "string" ? Number(raw) : raw;
+  return typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function stringAt(source, key) {
+  if (!source || typeof source !== "object") return void 0;
+  const raw = source[key];
+  return typeof raw === "string" && raw ? raw : void 0;
+}
+function classifyAiFunctionError(error) {
+  const status = numberAt(error, "status");
+  const name = stringAt(error, "name");
+  const serverCode = stringAt(error, "serverCode");
+  const message = stringAt(error, "message") ?? (typeof error === "string" ? error : "AI function call failed");
+  const details = error && typeof error === "object" ? error.details : void 0;
+  const base = {
+    ...status !== void 0 ? { status } : {},
+    ...serverCode ? { serverCode } : {},
+    message
+  };
+  if (status === 429 || name === "RateLimitError" || serverCode === "RATE_LIMITED") {
+    const retryAfterSeconds = numberAt(error, "retryAfter") ?? numberAt(details, "retryAfter") ?? numberAt(details, "retry_after");
+    return { kind: "rate_limited", ...base, ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {} };
+  }
+  if (status === 401 || name === "AuthenticationError") return { kind: "unauthorized", ...base };
+  if (status === 403 || name === "AuthorizationError") return { kind: "forbidden", ...base };
+  if (status === 404 || name === "NotFoundError") return { kind: "not_found", ...base };
+  if (name === "TimeoutError" || name === "AbortError" || status === 408 || serverCode === "TIMEOUT") {
+    return { kind: "timeout", ...base };
+  }
+  if (name === "NetworkError" || status === 0 || status === void 0 && name === "TypeError") {
+    return { kind: "network", ...base };
+  }
+  return { kind: "upstream", ...base };
+}
+
+export { AiFunctionSlotError, AiFunctionSlotIncompatibleError, AiFunctionSlotUnsetError, AiFunctionUnknownSlotError, checkAiFunctionSlotCompatibility, classifyAiFunctionError, createAiFunctionSlotHandlers, createAiFunctionSlotResolver, defineAiFunctionSlots, parseAiFunctionSlotBinding, runSlot };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map