octaflow 0.31.0 → 0.33.0

package/README.md

@@ -202,6 +202,7 @@ next to what your steps actually do.
 | 💤 | **Durable sleep** — hold a step in the queue for N ms (survives restarts) |
 | 🔀 | **Conditional branching** — `when` guards skip a step and its branch; `join: 'any'` converges |
 | 🎯 | **Decisions** — typed choices with a confidence from a swappable decider (a function, a model, your own); below a threshold a person settles it |
+| 🧭 | **Case loops** — `defineCaseLoop` (`octaflow/ai`): a manager agent chooses every next move of a case, each move its own workflow ending in the same tail (result → decide → next); policy refuses a choice with its reason inside the exit's schema, a move with a step that could fail is refused at definition time, and a manager that cannot decide closes the case for a person |
 | ⏳ | **Deadlines** — a budget on a suspended step (fail, or continue with a stand-in answer) and on a whole run |
 | ♻️ | **Retry a failed run** — `retryWorkflow` resumes from the failure point; completed steps keep their output |
 | 🧹 | **Delete the runs about a record** — `purgeWorkflows({ entityRef })` cancels and deletes them with their sub-workflow runs and steps, for an erasure or a deleted record; refuses only while a step is executing |
@@ -254,6 +255,12 @@ pnpm add ai @ai-sdk/provider
 a `schema`, and is meant to be pasted into your own migration system; `applySchema(pool, ddl)`
 is the dev and test shortcut.
 
+The stores, the gate and the event sink reach the database only through the `SqlExecutor` seam
+(`query` plus a same-connection `transaction`). Three executors ship with it: `poolExecutor(pool)`
+for `pg`, `postgresJsExecutor(sql)` for a postgres.js host (`transaction` is `sql.begin`), and
+`pgliteExecutor(pglite)` for PGlite in tests. Wrap any of them to set row-level-security GUCs
+first.
+
 #### The Drizzle columns
 
 The rule for every table-owning capability on the platform: `./postgres` ships the store over

package/dist/ai/index.d.ts

@@ -1,9 +1,10 @@
-import { A as TypedStep, H as RetryPolicy, M as TypedWorkflow, bt as Result, f as Decider, j as TypedStepContext, yt as FlowErrorShape } from "../index-Du05Lnwr.js";
+import { M as TypedStepContext, N as TypedWorkflow, O as DefineStepConfig, St as Result, U as RetryPolicy, f as Decider, gt as JoinRule, j as TypedStep, xt as FlowErrorShape } from "../index-DZUO24Rz.js";
 import { n as Logger } from "../logger-BCus3AOa.js";
-import { i as BuildStepContextArgs, o as WorkflowHooks } from "../hooks-mWaAKHqn.js";
+import { i as BuildStepContextArgs, o as WorkflowHooks } from "../hooks-DHomzpiq.js";
 import { C as isSubprocessorResidency, S as embeddingDimensionsFor, _ as EmbeddingProviderMeta, a as AiProcessingRegion, b as OpenAiCompatibleProviderId, c as AiProviderModelOption, d as AiVendorResidency, f as DEFAULT_AI_PROVIDER, g as EmbeddingProviderId, h as EMBEDDING_PROVIDER_IDS, i as AiEndpointResidency, l as AiResidencyError, m as EMBEDDING_PROVIDERS, n as AI_PROVIDER_IDS, o as AiProviderId, p as DEFAULT_EMBEDDING_PROVIDER, r as AiEndpointRegion, s as AiProviderMeta, t as AI_PROVIDERS, u as AiResidencyResult, v as OPENAI_COMPATIBLE_PROVIDER, w as resolveEndpointResidency, x as OpenAiCompatibleProviderMeta, y as OPENAI_COMPATIBLE_PROVIDER_ID } from "../provider-registry-C_mOfdHH.js";
-import { A as maskKeys, C as ProviderErrorExplanation, D as explainProviderError, E as ProviderErrorPreset, O as isFatalProviderError, S as ProviderError, T as ProviderErrorPhrase, _ as ExplainProviderErrorOptions, a as OllamaProbeReport, b as PROVIDER_ERROR_REDACTED, c as ProviderProbeOptions, d as testProvider, f as CircuitBreaker, g as DEFAULT_PROVIDER_ERROR_DETAIL_LENGTH, h as withCircuitBreaker, i as OllamaProbeOptions, k as isProviderError, l as ProviderProbeReport, m as createCircuitBreaker, n as DEFAULT_PROVIDER_PROBE_PROMPT, o as ProbeableProvider, p as CircuitBreakerOptions, r as DEFAULT_PROVIDER_PROBE_TIMEOUT_MS, s as ProviderProbeFailure, t as DEFAULT_OLLAMA_PROBE_TIMEOUT_MS, u as testOllamaModel, v as FATAL_PROVIDER_ERROR_KEYS, w as ProviderErrorKey, x as PROVIDER_ERROR_STATUS, y as PROVIDER_ERROR_PHRASES } from "../provider-probe-l2Jmpuhr.js";
+import { A as maskKeys, C as ProviderErrorExplanation, D as explainProviderError, E as ProviderErrorPreset, O as isFatalProviderError, S as ProviderError, T as ProviderErrorPhrase, _ as ExplainProviderErrorOptions, a as OllamaProbeReport, b as PROVIDER_ERROR_REDACTED, c as ProviderProbeOptions, d as testProvider, f as CircuitBreaker, g as DEFAULT_PROVIDER_ERROR_DETAIL_LENGTH, h as withCircuitBreaker, i as OllamaProbeOptions, k as isProviderError, l as ProviderProbeReport, m as createCircuitBreaker, n as DEFAULT_PROVIDER_PROBE_PROMPT, o as ProbeableProvider, p as CircuitBreakerOptions, r as DEFAULT_PROVIDER_PROBE_TIMEOUT_MS, s as ProviderProbeFailure, t as DEFAULT_OLLAMA_PROBE_TIMEOUT_MS, u as testOllamaModel, v as FATAL_PROVIDER_ERROR_KEYS, w as ProviderErrorKey, x as PROVIDER_ERROR_STATUS, y as PROVIDER_ERROR_PHRASES } from "../provider-probe-BDg4c1Rk.js";
 import { z } from "zod";
+import { ToolSet } from "ai";
 import { EmbeddingModelV4, LanguageModelV4, LanguageModelV4Usage, SharedV4ProviderMetadata } from "@ai-sdk/provider";
 //#region src/ai/instrumented-model.d.ts
 export interface AccumulatedUsage {
@@ -125,35 +126,18 @@ export interface AiContext<THost = unknown> {
 //#region src/ai/define-ai-step.d.ts
 /** An AI workflow step — a flow-core `TypedStep` whose context is an `AiContext`. */
 export type AiTypedStep<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput extends Record<string, unknown> = Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}> = TypedStep<TInput, TOutput, TDeps, AiContext<THost>>;
-interface DefineAiStepConfig<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>>> {
-  type: string;
-  workflowInputSchema: z.ZodType<TInput>;
-  outputSchema: z.ZodType<TOutput>;
-  dependencies?: TDeps;
-  handler: (ctx: TypedStepContext<TInput, TDeps, AiContext<THost>>) => Promise<TOutput>;
-  /** Optional retry policy (max attempts, backoff) — e.g. for provider 429s. */
-  retry?: RetryPolicy;
-  /** Optional per-step wall-clock timeout in ms. */
-  timeoutMs?: number;
-  /** Optional durable start delay in ms — held in the queue once the step is ready. */
-  delayMs?: number;
-  /**
-   * What a terminal failure does — see `defineStep`'s `onFailure`. `{ output }`
-   * completes the step with a stand-in and the DAG carries on; the model's
-   * refusal or outage then costs one section of the result, not the run.
-   */
-  onFailure?: 'fail' | {
-    output: TOutput;
-  };
-  /** Resources the step draws on (the model, a vendor), for the admission gate — see `defineStep`. */
-  resources?: readonly string[];
-}
+/**
+ * `defineStep`'s config with the handler context fixed to `AiContext<THost>` —
+ * every option a step has (`when`, `join`, heartbeats, `onFailure`, …), so an
+ * AI step branches and converges like any other.
+ */
+export type DefineAiStepConfig<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>>, TJoin extends JoinRule = 'all'> = DefineStepConfig<TInput, TOutput, TDeps, AiContext<THost>, TJoin>;
 /**
  * Define a type-safe AI workflow step. Identical to flow-core's `defineStep`
  * except the handler context is fixed to `AiContext<THost>`, so handlers get a
  * ready-to-use `ctx.context.model` (instrumented) and `ctx.context.host`.
  */
-export declare function defineAiStep<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: DefineAiStepConfig<TInput, TOutput, THost, TDeps>): AiTypedStep<TInput, TOutput, THost, TDeps>;
+export declare function defineAiStep<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}, TJoin extends JoinRule = 'all'>(config: DefineAiStepConfig<TInput, TOutput, THost, TDeps, TJoin>): AiTypedStep<TInput, TOutput, THost, TDeps>;
 /** Build a typed AI workflow from `defineAiStep` definitions. */
 export declare function buildAiWorkflow<TInput extends Record<string, unknown>, THost = unknown, TSteps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: {
   type: string;
@@ -186,6 +170,114 @@ export interface ModelDeciderOptions {
  */
 export declare function createModelDecider<THost = unknown>(options?: ModelDeciderOptions): Decider<AiContext<THost>>;
 //#endregion
+//#region src/ai/agent.d.ts
+/** What one agent run did — persisted with the answer, never parsed. */
+export interface AgentTrace {
+  /** Model calls the loop made. */
+  rounds: number;
+  /** Tool names in the order they were called, the exit last. */
+  toolCalls: string[];
+  /** Input + output tokens across all rounds. */
+  tokens: number;
+}
+/** One way out of an agent: the model ends the run by calling it, and its arguments are the value. */
+export interface AgentExit<T = unknown> {
+  description: string;
+  schema: z.ZodType<T>;
+}
+export type AgentExits = Record<string, AgentExit<any>>;
+/** The exit an agent took, typed by its name. */
+export type AgentExitTaken<TExits extends AgentExits> = { [K in keyof TExits & string]: {
+  exit: K;
+  value: TExits[K] extends AgentExit<infer T> ? T : never;
+}; }[keyof TExits & string];
+interface AgentLimits {
+  /** The model — in a step, `ctx.context.model`, so usage lands on the step. */
+  model: LanguageModelV4;
+  system: string;
+  prompt: string;
+  /** The tools the agent works with. Their names must not collide with an exit's. */
+  tools?: ToolSet;
+  /** Most model calls before the run gives up. Default 8. */
+  maxRounds?: number;
+  /** Most input + output tokens before the run gives up. Default: no cap. */
+  maxTokens?: number;
+  /**
+   * Most output tokens per model call, passed to the AI SDK. Default: the
+   * provider's — which on a local server can be small enough to cut a
+   * thinking model off before it calls anything.
+   */
+  maxOutputTokens?: number;
+  /** Called after every round; `false` stops the run — pass the step's `heartbeat`. */
+  heartbeat?: () => Promise<boolean>;
+  abortSignal?: AbortSignal;
+  /** Passed to the AI SDK. Default 0 — the step's retry policy owns retries. */
+  maxRetries?: number;
+}
+export interface RunAgentToExitOptions<TExits extends AgentExits> extends AgentLimits {
+  exits: TExits;
+}
+export interface RunAgentOptions<TOutput> extends AgentLimits {
+  /** The answer's shape — the arguments of the one exit, `answer`. */
+  output: z.ZodType<TOutput>;
+}
+export interface AgentRun<TOutput> {
+  output: TOutput;
+  trace: AgentTrace;
+}
+/**
+ * Run one agent until it takes one of `exits`, or fails. Stopping on a limit
+ * before an exit is not retryable — the same budget would stop the same way —
+ * so the step fails, or takes its `onFailure` stand-in.
+ */
+export declare function runAgentToExit<TExits extends AgentExits>(options: RunAgentToExitOptions<TExits>): Promise<AgentExitTaken<TExits> & {
+  trace: AgentTrace;
+}>;
+/** Run one agent to a typed answer: `runAgentToExit` with the single exit `answer`. */
+export declare function runAgent<TOutput>(options: RunAgentOptions<TOutput>): Promise<AgentRun<TOutput>>;
+/** The trace as a schema — for a step output that carries one. */
+export declare const AGENT_TRACE_SCHEMA: z.ZodObject<{
+  rounds: z.ZodNumber;
+  toolCalls: z.ZodArray<z.ZodString>;
+  tokens: z.ZodNumber;
+}, z.core.$strip>;
+interface DefineAgentStepConfig<TInput extends Record<string, unknown>, TAnswer extends Record<string, unknown>, THost, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>>> {
+  type: string;
+  workflowInputSchema: z.ZodType<TInput>;
+  /** The answer's shape — the step outputs `{ answer, trace }`. */
+  answerSchema: z.ZodType<TAnswer>;
+  dependencies?: TDeps;
+  system: string;
+  /** The task, built from the workflow input and the dependencies' outputs. */
+  prompt: (ctx: TypedStepContext<TInput, TDeps, AiContext<THost>>) => string;
+  tools?: (ctx: TypedStepContext<TInput, TDeps, AiContext<THost>>) => ToolSet;
+  maxRounds?: number;
+  maxTokens?: number;
+  maxOutputTokens?: number;
+  retry?: RetryPolicy;
+  timeoutMs?: number;
+  /** See `defineStep`'s `heartbeatTimeoutMs` — every round beats. */
+  heartbeatTimeoutMs?: number;
+  /** See `defineStep`'s `onFailure`. */
+  onFailure?: 'fail' | {
+    output: {
+      answer: TAnswer;
+      trace: AgentTrace;
+    };
+  };
+  resources?: readonly string[];
+  when?: (ctx: TypedStepContext<TInput, TDeps, AiContext<THost>>) => boolean | Promise<boolean>;
+}
+/**
+ * A step that runs one agent on the step's instrumented model. Its output is
+ * `{ answer, trace }`: dependents read `ctx.deps.<key>.answer`, and the trace
+ * stays on the run for whoever reads it back.
+ */
+export declare function defineAgentStep<TInput extends Record<string, unknown>, TAnswer extends Record<string, unknown>, THost = unknown, TDeps extends Record<string, TypedStep<any, any, any, AiContext<THost>>> = {}>(config: DefineAgentStepConfig<TInput, TAnswer, THost, TDeps>): TypedStep<TInput, {
+  answer: TAnswer;
+  trace: AgentTrace;
+}, TDeps, AiContext<THost>>;
+//#endregion
 //#region src/ai/hooks.d.ts
 export interface AiModelResolver<THost = unknown> {
   /** Resolve the base (uninstrumented) model for a step. */
@@ -774,4 +866,152 @@ export declare function withJsonRepair(model: LanguageModelV4, options?: JsonRep
  */
 export declare function addUsage(a: LanguageModelV4Usage, b: LanguageModelV4Usage): LanguageModelV4Usage;
 //#endregion
+//#region src/ai/case-loop.d.ts
+/** What a move leaves for the manager: a summary, and an outcome when the move itself ends the case. */
+export type CaseMoveResult<TOutcome extends string, TResult extends Record<string, unknown>> = TResult & {
+  summary: string;
+  closes?: TOutcome;
+};
+/** One finished move, as the next moves see it. */
+export interface CaseMoveRecord<TMove extends string, TOutcome extends string, TResult extends Record<string, unknown>> {
+  no: number;
+  move: TMove;
+  /** The manager's reason for it — its exit's `why`, when the exit has one. */
+  why: string;
+  result: CaseMoveResult<TOutcome, TResult>;
+}
+/** A move's input: the case's own fields, plus where the case stands. */
+export type CaseMoveInput<TMove extends string, TOutcome extends string, TCase extends Record<string, unknown>, TResult extends Record<string, unknown>> = TCase & {
+  caseId: string;
+  move: TMove;
+  /** 1 for the first move. */
+  moveNo: number;
+  /** The manager's arguments for this move — its exit's value. */
+  brief: Record<string, any>;
+  moves: CaseMoveRecord<TMove, TOutcome, TResult>[];
+  startedAt: string;
+};
+/** The manager's choice, as `decide` outputs it. `stuck` when it could not choose within its limits. */
+export type CaseDecision<TExit extends string = string> = {
+  exit: TExit | 'stuck';
+  value: Record<string, any>;
+  /** Choices the policy refused on the way, each with its reason, de-duplicated. */
+  refusals: Array<{
+    choice: string;
+    reason: string;
+  }>;
+  trace: AgentTrace;
+};
+/** What `next` did: the case's outcome, or `continued` with the run it started. */
+export type CaseNext<TOutcome extends string = string> = {
+  outcome: TOutcome | 'continued';
+  detail: string;
+  nextWorkflowId?: number;
+};
+type Ctx<THost> = AiContext<THost>;
+type AnyStep<THost> = TypedStep<any, any, any, Ctx<THost>>;
+export interface CaseLoopConfig<TMove extends string, TOutcome extends string, TCase extends Record<string, unknown>, TResult extends Record<string, unknown>, TDecisions extends AgentExits, TFacts, THost> {
+  /** Prefix of every workflow and step type: move `write` runs as `<name>:write`, its tail as `<name>:write:decide`. */
+  name: string;
+  moves: readonly [TMove, ...TMove[]];
+  /** The case's own fields, carried by every move. */
+  case: z.ZodType<TCase>;
+  /** The move result's own fields, beside `summary` and `closes`. */
+  result: z.ZodType<TResult>;
+  /** What a result step that failed stands in with — `summary` says it failed. */
+  failedResult: TResult;
+  outcomes: readonly [TOutcome, ...TOutcome[]];
+  /** The outcome of a case whose manager could not decide — a person takes it over. */
+  stuck: NoInfer<TOutcome>;
+  /** The exits the manager may take. An exit named after a move starts it; any other must be in `closers`. */
+  decisions: TDecisions;
+  /** The exits that close the case, each turning its value into the outcome. */
+  closers?: { [K in keyof TDecisions & string]?: (value: any) => {
+    outcome: NoInfer<TOutcome>;
+    detail: string;
+  }; };
+  /** The facts the policy is checked against, read once per decision — the move's own result included. */
+  facts: (ctx: TypedStepContext<CaseMoveInput<TMove, TOutcome, TCase, TResult>, any, Ctx<THost>>, result: CaseMoveResult<TOutcome, TResult>) => Promise<TFacts> | TFacts;
+  /** The policy on one choice: a reason refuses it. */
+  refuse?: (choice: keyof TDecisions & string, value: any, facts: TFacts, input: CaseMoveInput<TMove, TOutcome, TCase, TResult>) => string | null;
+  /** The most moves a case takes; from the last one on, only `atLimit` is allowed. */
+  maxMoves: number;
+  atLimit: ReadonlyArray<keyof TDecisions & string>;
+  manager: {
+    system: string;
+    /** The case file the manager decides on. */
+    prompt: (ctx: TypedStepContext<CaseMoveInput<TMove, TOutcome, TCase, TResult>, any, Ctx<THost>>, result: CaseMoveResult<TOutcome, TResult>, facts: TFacts) => string;
+    /** Read-only tools: the manager looks things up and chooses — the moves do the work. */
+    tools?: (ctx: TypedStepContext<CaseMoveInput<TMove, TOutcome, TCase, TResult>, any, Ctx<THost>>) => ToolSet;
+    maxRounds?: number;
+    maxTokens?: number;
+    maxOutputTokens?: number;
+    resources?: readonly string[];
+    retry?: RetryPolicy;
+    heartbeatTimeoutMs?: number;
+    /** The `detail` of a case closed as `stuck`. */
+    stuckDetail?: string;
+  };
+  startMove: (host: THost, input: CaseMoveInput<TMove, TOutcome, TCase, TResult>) => Promise<number>;
+  closeCase: (host: THost, closed: {
+    caseId: string;
+    outcome: TOutcome;
+    detail: string;
+  }) => Promise<void>;
+}
+export interface CaseMoveConfig<TMove extends string, TOutcome extends string, TCase extends Record<string, unknown>, TResult extends Record<string, unknown>, THost> {
+  /** The move's own steps, by key. `result`, `decide` and `next` are the tail's. */
+  steps: Record<string, AnyStep<THost>>;
+  /** The steps `result` reads — it runs once any of them completed and the others stopped. */
+  ends: Record<string, AnyStep<THost>>;
+  /** What the move achieved. `deps` holds the outputs of the `ends` that completed. */
+  summarize: (ctx: Omit<TypedStepContext<CaseMoveInput<TMove, TOutcome, TCase, TResult>, {}, Ctx<THost>>, 'deps'> & {
+    deps: Record<string, any>;
+  }) => Promise<CaseMoveResult<TOutcome, TResult>> | CaseMoveResult<TOutcome, TResult>;
+}
+export interface CaseLoop<TMove extends string, TOutcome extends string, TCase extends Record<string, unknown>, TResult extends Record<string, unknown>, TDecisions extends AgentExits, TFacts, THost> {
+  readonly name: string;
+  readonly inputSchema: z.ZodType<CaseMoveInput<TMove, TOutcome, TCase, TResult>>;
+  readonly resultSchema: z.ZodType<CaseMoveResult<TOutcome, TResult>>;
+  readonly decisionSchema: z.ZodType<CaseDecision<keyof TDecisions & string>>;
+  /** One move as its own workflow: its steps, then the tail. Throws on a step that can end in failure. */
+  move(name: TMove, config: CaseMoveConfig<TMove, TOutcome, TCase, TResult, THost>): TypedWorkflow<CaseMoveInput<TMove, TOutcome, TCase, TResult>, Ctx<THost>>;
+  /** The policy on one choice, with the move ceiling — what `decide` holds the manager to, for a page that shows it. */
+  refusal(choice: keyof TDecisions & string, value: unknown, facts: TFacts, input: CaseMoveInput<TMove, TOutcome, TCase, TResult>): string | null;
+  /** The input of a case's first move. */
+  first(fields: TCase & {
+    caseId: string;
+    move: TMove;
+    brief?: Record<string, any>;
+    startedAt?: string;
+  }): CaseMoveInput<TMove, TOutcome, TCase, TResult>;
+}
+/**
+ * Define a case loop: a manager agent that chooses every next move, each move
+ * its own workflow ending in the same tail — see the module comment.
+ *
+ * ```ts
+ * const loop = defineCaseLoop({
+ *   name: 'move',
+ *   moves: ['open', 'investigate', 'write', 'wait'],
+ *   case: z.object({ invoice: z.string() }),
+ *   result: z.object({ mailSent: z.boolean() }),
+ *   failedResult: { mailSent: false },
+ *   outcomes: ['paid', 'unresolved'],
+ *   stuck: 'unresolved',
+ *   decisions: { investigate: …, write: …, wait: …, close: … },
+ *   closers: { close: (v) => ({ outcome: 'paid', detail: v.summary }) },
+ *   facts: async (ctx) => readBooks(ctx.workflowInput.caseId),
+ *   refuse: (choice, value, facts) => (choice === 'close' && facts.balance > 0 ? 'The balance is open.' : null),
+ *   maxMoves: 12,
+ *   atLimit: ['close'],
+ *   manager: { system: '…', prompt: (ctx, result) => caseFile(ctx.workflowInput, result) },
+ *   startMove: (host, input) => host.startMove(input),
+ *   closeCase: (host, c) => host.cases.close(c.caseId, c.outcome, c.detail),
+ * });
+ * const write = loop.move('write', { steps: { compose, approval, send }, ends: { approval, send }, summarize });
+ * ```
+ */
+export declare function defineCaseLoop<const TMove extends string, const TOutcome extends string, TCase extends Record<string, unknown>, TResult extends Record<string, unknown>, TDecisions extends AgentExits, TFacts, THost = any>(config: CaseLoopConfig<TMove, TOutcome, TCase, TResult, TDecisions, TFacts, THost>): CaseLoop<TMove, TOutcome, TCase, TResult, TDecisions, TFacts, THost>;
+//#endregion
 export { AI_PROVIDERS, AI_PROVIDER_IDS, AiEndpointRegion, AiEndpointResidency, AiProcessingRegion, AiProviderId, AiProviderMeta, AiProviderModelOption, AiResidencyError, AiResidencyResult, AiVendorResidency, CircuitBreaker, CircuitBreakerOptions, DEFAULT_AI_PROVIDER, DEFAULT_EMBEDDING_PROVIDER, DEFAULT_OLLAMA_PROBE_TIMEOUT_MS, DEFAULT_PROVIDER_ERROR_DETAIL_LENGTH, DEFAULT_PROVIDER_PROBE_PROMPT, DEFAULT_PROVIDER_PROBE_TIMEOUT_MS, EMBEDDING_PROVIDERS, EMBEDDING_PROVIDER_IDS, EmbeddingProviderId, EmbeddingProviderMeta, ExplainProviderErrorOptions, FATAL_PROVIDER_ERROR_KEYS, OPENAI_COMPATIBLE_PROVIDER, OPENAI_COMPATIBLE_PROVIDER_ID, OllamaProbeOptions, OllamaProbeReport, OpenAiCompatibleProviderId, OpenAiCompatibleProviderMeta, PROVIDER_ERROR_PHRASES, PROVIDER_ERROR_REDACTED, PROVIDER_ERROR_STATUS, ProbeableProvider, ProviderError, ProviderErrorExplanation, ProviderErrorKey, ProviderErrorPhrase, ProviderErrorPreset, ProviderProbeFailure, ProviderProbeOptions, ProviderProbeReport, createCircuitBreaker, embeddingDimensionsFor, explainProviderError, isFatalProviderError, isProviderError, isSubprocessorResidency, maskKeys, resolveEndpointResidency, testOllamaModel, testProvider, withCircuitBreaker };