octaflow 0.32.0 → 0.34.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 |
@@ -215,7 +216,9 @@ next to what your steps actually do.
 | 🚑 | **Crash recovery** — a step whose worker died is re-queued while its attempt budget lasts |
 | 💓 | **Heartbeats** — a long step proves it is alive, so a dead one is caught in seconds, not minutes |
 | 🔭 | **Observability** — lifecycle events (run history), per-step spans, and `createMeterObserver` turning the events into OpenTelemetry-style metrics — all pluggable, all structural |
-| 🤖 | **AI add-on** — instrumented models, token/cost capture, quota, daily rollups, a `usage` sink that books each step into `@octabits-io/metering` (the paid APIs around the model in the same table, priced at read time), refusal-aware models, lenient JSON from local models (`withJsonRepair`), a vendor's refusal explained by key and hint (`explainProviderError`), a per-run circuit breaker, a connection test (`testProvider`) |
+| 🤖 | **AI add-on** — instrumented models, token/cost capture, quota, daily rollups, a `usage` sink that books each step into `@octabits-io/metering` (the paid APIs around the model in the same table, priced at read time), refusal-aware models, lenient JSON from local models (`withJsonRepair`), a vendor's refusal explained by key and hint (`explainProviderError`), a per-run circuit breaker, a connection test (`testProvider`), Ollama's native API as language and embedding models (`createOllama` in `octaflow/ai/providers`: `num_ctx`, thinking and `keep_alive` per model or per call, no dependency) |
+| 🗂️ | **Model providers an administrator manages** — `createModelProviders` (`octaflow/ai`): providers as rows, each with its kind, server, region, a key that crosses a cipher seam, and its models with declared capabilities (temperature, JSON mode, vision, video, tools, embedding); `createPgModelProviderStore` + `modelProviderDdl` (`octaflow/postgres`), `modelProviderColumns` (`octaflow/drizzle`); `createModelResolver` (`octaflow/ai/providers`) builds the AI SDK model from a row, shapes each call to what the model declares, hands the host its `destination` for the disclosure guard, and rebuilds after a write |
+| 🏃 | **Model runners** — a model the app cannot reach, served by a process that connects *out*: a provider row of kind `runner` carries tags instead of a URL, a runner registered with a token (`octaflow/ai/runner`: `createModelRunnerHub`, shown once, kept as a hash) subscribes with its tags, claims the calls by long-poll through `@octabits-io/server/fetch/octaflow`'s `createModelRunnerHandler` and posts the answers back; the mailbox is two tables (`createPgModelRunnerStore` + `modelRunnerDdl`, `modelRunnerColumns` + `modelRunnerRequestColumns`) whose rows live only while a call is in flight; nobody online fails the call at once, so the breaker trips and the probe answers in milliseconds |
 | 🧱 | **Pluggable everything** — `WorkflowStore`, `Dispatcher`, `StepGate`, `FlowObserver`, hooks |
 
 ---
@@ -248,9 +251,10 @@ pnpm add ai @ai-sdk/provider
 
 ### The Postgres tables
 
-`octaflow/postgres` owns five tables and ships their DDL: `flowStoreDdl()` (`flow_workflow`,
-`flow_workflow_step`), `flowEventDdl()` (`flow_step_event`) and `flowGateDdl()`
-(`flow_rate_bucket`, `flow_step_lease`). Each is idempotent `CREATE TABLE IF NOT EXISTS`, takes
+`octaflow/postgres` owns eight tables and ships their DDL: `flowStoreDdl()` (`flow_workflow`,
+`flow_workflow_step`), `flowEventDdl()` (`flow_step_event`), `flowGateDdl()`
+(`flow_rate_bucket`, `flow_step_lease`), `modelProviderDdl()` (`model_provider`) and
+`modelRunnerDdl()` (`model_runner`, `model_runner_request`). Each is idempotent `CREATE TABLE IF NOT EXISTS`, takes
 a `schema`, and is meant to be pasted into your own migration system; `applySchema(pool, ddl)`
 is the dev and test shortcut.
 
@@ -268,8 +272,9 @@ column set, so a host on Drizzle declares it in its own schema and drizzle-kit o
 migration. Where the store's queries are one SQL statement by nature — every one of octaflow's
 is — `./drizzle` ships the columns only, and the store stays the SQL one. So
 `octaflow/drizzle` exports `flowWorkflowColumns`, `flowWorkflowStepColumns`,
-`flowStepEventColumns`, `flowRateBucketColumns` and `flowStepLeaseColumns` (`drizzle-orm` an
-optional peer) and nothing that runs a query. The foreign keys, the composite keys, the unique
+`flowStepEventColumns`, `flowRateBucketColumns`, `flowStepLeaseColumns`, `modelProviderColumns`,
+`modelRunnerColumns` and `modelRunnerRequestColumns` (`drizzle-orm` an optional peer) and
+nothing that runs a query. The foreign keys, the composite keys, the unique
 constraint and the indexes are yours to declare on the `pgTable`; each column set's doc lists
 the ones its DDL creates, and two of them the store relies on:
 
@@ -313,6 +318,56 @@ The store stays plain SQL, bound to the `schema` you hand `createPgWorkflowStore
 declare the tables under the same schema and names. A test in the package holds every column
 set and its DDL equal, column for column: a column added to one side alone fails the build.
 
+### Model runners — a model that connects out
+
+A model the app cannot reach: a laptop with the model loaded for a demo, a GPU box behind
+someone's firewall, a machine that is only on when it is needed. The runner never opens a
+port. It connects *out* to the app with a token, subscribes with its tags, claims the model
+calls that carry those tags and posts the answers back — the shape of a self-hosted CI
+runner. The mailbox is Postgres, because the call runs in the worker and the door the runner
+knocks on runs in the API; a request row lives only while the call is in flight.
+
+```ts
+// the app — once, beside the providers
+import { createModelRunnerHub } from 'octaflow/ai/runner';
+import { createPgModelRunnerStore } from 'octaflow/postgres';
+
+const runners = createModelRunnerHub({ store: createPgModelRunnerStore({ executor }) });
+const resolver = createModelResolver({ providers, runners, wrap });
+
+// an administrator: the provider row carries tags, the runner gets its token once
+await providers.save({ id: 'mac', kind: 'runner', label: 'The Mac', region: 'self-hosted', tags: ['qwen'], models: [{ id: 'qwen3:32b', settings: { numCtx: 16_384 } }] });
+const { token } = (await runners.registerRunner({ id: 'dani-mac', label: "Dani's Mac", tags: ['qwen', 'mac'] })).value;
+
+// the API: the door, behind the host's rate limit
+import { createModelRunnerHandler } from '@octabits-io/server/fetch/octaflow';
+export const POST = compose(withErrorMapping())(createModelRunnerHandler({ prefix: '/api/model-runner', hub: runners }));
+
+// the runner, on the machine with the model
+import { createHttpRunnerClient, runModelRunner } from 'octaflow/ai/runner';
+import { createOllama } from 'octaflow/ai/providers';
+await runModelRunner({
+  client: createHttpRunnerClient({ url: 'https://app.example/api/model-runner', token }),
+  backend: createOllama({ baseUrl: 'http://localhost:11434' }),
+});
+```
+
+A runner may claim a request when it has **every tag** of the request — the provider row's
+tags — as a CI job's labels must all be on the runner. A call with nobody online for its
+tags fails at once with `provider_unreachable`, so `withCircuitBreaker` trips and
+`testProvider` reports it in milliseconds instead of a timeout; whether another provider is
+tried is the host's resolver's choice, through the same disclosure gate. A claim lasts 30 s
+without a heartbeat; an expired claim is requeued once and failed the second time. The
+region is the administrator's declaration about where runners with these tags are, as for
+every provider, and the disclosure gate reads it the same way.
+
+The wire is the AI SDK's own call and answer as JSON — binary file data as base64, a URL
+restored on the other side — so the runner's backend is any `LanguageModelV4`: `createOllama`
+from this package, or `@ai-sdk/openai-compatible` for mlx_lm.server, vLLM and llama.cpp. The
+first version answers whole: `streamText` over a runner model works, emitted as one text
+block when the answer is there. Files reach the runner as bytes, since the runner model
+declares no URL support and the SDK downloads on the app's side. Embeddings go the same way.
+
 ---
 
 ---

package/dist/ai/index.d.ts

@@ -1,8 +1,9 @@
-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-D0XhoTkE.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-C46TPBEg.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-_rio4ykx.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 { C as modelProviderInputSchema, S as modelEntrySchema, _ as StoredModelProvider, a as ModelCapabilities, b as maskModelProvider, c as ModelProvider, d as ModelProviderError, f as ModelProviderInput, g as ModelProviders, h as ModelProviderStore, i as MODEL_PROVIDER_REGIONS, l as ModelProviderChange, m as ModelProviderRegion, n as MODEL_JSON_MODES, o as ModelEntry, p as ModelProviderKind, r as MODEL_PROVIDER_KINDS, s as ModelJsonMode, t as CreateModelProvidersOptions, u as ModelProviderCipher, v as createInMemoryModelProviderStore, x as modelCapabilitiesSchema, y as createModelProviders } from "../model-providers-DQU57vAf.js";
 import { z } from "zod";
 import { ToolSet } from "ai";
 import { EmbeddingModelV4, LanguageModelV4, LanguageModelV4Usage, SharedV4ProviderMetadata } from "@ai-sdk/provider";
@@ -866,4 +867,152 @@ export declare function withJsonRepair(model: LanguageModelV4, options?: JsonRep
  */
 export declare function addUsage(a: LanguageModelV4Usage, b: LanguageModelV4Usage): LanguageModelV4Usage;
 //#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 };
+//#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, CreateModelProvidersOptions, 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, MODEL_JSON_MODES, MODEL_PROVIDER_KINDS, MODEL_PROVIDER_REGIONS, ModelCapabilities, ModelEntry, ModelJsonMode, ModelProvider, ModelProviderChange, ModelProviderCipher, ModelProviderError, ModelProviderInput, ModelProviderKind, ModelProviderRegion, ModelProviderStore, ModelProviders, 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, StoredModelProvider, createCircuitBreaker, createInMemoryModelProviderStore, createModelProviders, embeddingDimensionsFor, explainProviderError, isFatalProviderError, isProviderError, isSubprocessorResidency, maskKeys, maskModelProvider, modelCapabilitiesSchema, modelEntrySchema, modelProviderInputSchema, resolveEndpointResidency, testOllamaModel, testProvider, withCircuitBreaker };