@theokit/sdk 2.29.0 → 3.0.0

package/dist/{cron-yJoNUZxe.d.cts → cron-C2jWAvlQ.d.cts}

@@ -1,5 +1,6 @@
-import { C as CustomTool, M as ModelSelection, a7 as SDKUserMessage, a9 as SendOptions, b as Run, G as GenerateOptions, l as GenerateRunResult, V as RunToCompletionOptions, W as RunToCompletionResult, S as SDKMessage, ag as StreamToCompletionResult, a as McpServerConfig, P as Processor } from './run-q_P0vHlY.cjs';
 import * as zod from 'zod';
+import { ZodType } from 'zod';
+import { C as CustomTool, M as ModelSelection, a7 as SDKUserMessage, a9 as SendOptions, b as Run, G as GenerateOptions, k as GenerateRunResult, V as RunToCompletionOptions, W as RunToCompletionResult, S as SDKMessage, ag as StreamToCompletionResult, a as McpServerConfig, P as Processor, r as MessageOrigin } from './run-CLXKMRgq.cjs';
 
 /**
  * Fork primitive public type contracts (T1.2, ADRs D110-D114).
@@ -803,7 +804,7 @@ interface ConversationStorageAdapter {
  *
  * @public
  */
-interface Skill {
+interface Skill$1 {
     name: string;
     description: string;
     /** Absolute path to the discovered `SKILL.md`. */
@@ -824,7 +825,7 @@ interface Skill {
  */
 
 /** A code-defined skill (from {@link createSkill}) — a {@link Skill} plus its inline body. */
-interface InlineSkill extends Skill {
+interface InlineSkill extends Skill$1 {
     /** The skill body/instructions (inline skills carry it here instead of a SKILL.md file). */
     instructions: string;
     /**
@@ -844,11 +845,11 @@ interface CreateSkillSpec {
     /** SE21 — supporting documents (filename → content), like a filesystem skill's `references/`. */
     references?: Record<string, string>;
 }
-/**
- * Build an {@link InlineSkill} from a code spec. Fails fast on an empty `name`/`description`
- * (error-handling.md). The synthetic `source` (`inline://<name>`) marks it as file-less.
- */
-declare function createSkill(spec: CreateSkillSpec): InlineSkill;
+/** SE36 — `Skill.create` replaces `createSkill` (ADR 0015). @public */
+declare class Skill {
+    private constructor();
+    static create(spec: CreateSkillSpec): InlineSkill;
+}
 
 /**
  * Context manager backend.
@@ -1161,6 +1162,13 @@ interface BasePlugin {
     name: string;
     version: string;
 }
+/**
+ * Identity helper for plugin authors. TS-only convenience — preserves
+ * inferred type without forcing manual `Plugin` annotation.
+ *
+ * @public
+ */
+declare function definePlugin<P extends Plugin>(p: P): P;
 type Plugin = (BasePlugin & {
     kind: "general";
     register: (ctx: PluginContext) => void | Promise<void>;
@@ -1171,13 +1179,10 @@ type Plugin = (BasePlugin & {
     kind: "memory";
     createProvider: MemoryProviderFactory;
 });
-/**
- * Identity helper for plugin authors. TS-only convenience — preserves
- * inferred type without forcing manual `Plugin` annotation.
- *
- * @public
- */
-declare function definePlugin<P extends Plugin>(p: P): P;
+/** SE36 — `Plugin.create` replaces `definePlugin` (ADR 0015). Const-companion (the `Plugin` type alias blocks a class of the same name); `create` is the generic `definePlugin`. @public */
+declare const Plugin: {
+    create: typeof definePlugin;
+};
 
 /**
  * Which on-disk settings layers a local agent loads.
@@ -2108,6 +2113,345 @@ interface ListResult<T> {
     nextCursor?: string;
 }
 
+/**
+ * Public type contract for `Workflow.create / .run / .resume` (Adoption
+ * Roadmap #5; ADRs D230-D248).
+ *
+ * Step types form a discriminated union by `kind`. Helper factory functions
+ * (`fn()`, `agentStep()`) live in `workflow.ts` and hide the discriminator
+ * from end users.
+ *
+ * @public
+ */
+
+type Step = FnStep | AgentStep | ParallelStep | BranchStep | ForeachStep | DowhileStep | SleepStep | SuspendStep;
+/** A pure function step. */
+interface FnStep {
+    readonly kind: "fn";
+    readonly id: string;
+    readonly fn: (input: unknown, ctx: StepContext) => Promise<unknown> | unknown;
+    readonly inputSchema?: ZodType;
+    readonly outputSchema?: ZodType;
+    readonly retry?: RetryPolicy;
+    /** D238 — slot reserved; runtime throws if engine not yet implemented. */
+    readonly compensate?: (input: unknown, output: unknown, error: Error) => Promise<void> | void;
+}
+/** An agent.send-driven step. */
+interface AgentStep {
+    readonly kind: "agent";
+    readonly id: string;
+    readonly agent: SDKAgent;
+    readonly promptTemplate: string | ((input: unknown) => string);
+    readonly retry?: RetryPolicy;
+    /**
+     * SE3 — provenance stamped onto this step's `agent.send()` (forwarded to
+     * `RunResult.origin`). Squad sets `{ kind: "peer", from: "agent-<i-1>" }` on
+     * every step after the first so a peer-driven turn is attributable.
+     */
+    readonly origin?: MessageOrigin;
+}
+/** N concurrent branches, each its own mini-step-list. */
+interface ParallelStep {
+    readonly kind: "parallel";
+    readonly id: string;
+    readonly branches: ReadonlyArray<ReadonlyArray<Step>>;
+    readonly concurrency?: number;
+    readonly errorPolicy?: "fail-fast" | "collect";
+}
+/** First-match-wins predicates + optional fallback. */
+interface BranchStep {
+    readonly kind: "branch";
+    readonly id: string;
+    readonly predicates: ReadonlyArray<readonly [(input: unknown) => boolean | Promise<boolean>, ReadonlyArray<Step>]>;
+    readonly fallback?: ReadonlyArray<Step>;
+}
+/** Map a step over an upstream array output. */
+interface ForeachStep {
+    readonly kind: "foreach";
+    readonly id: string;
+    /** ID of an upstream top-level step whose output is iterable. */
+    readonly iterableFrom: string;
+    readonly step: Step;
+    readonly concurrency?: number;
+}
+/** Loop a step until condFn returns false. */
+interface DowhileStep {
+    readonly kind: "dowhile";
+    readonly id: string;
+    readonly step: Step;
+    readonly condFn: (output: unknown, iteration: number) => boolean | Promise<boolean>;
+    readonly maxIterations?: number;
+}
+/** Pause for a fixed duration. */
+interface SleepStep {
+    readonly kind: "sleep";
+    readonly id: string;
+    readonly durationMs: number;
+}
+/** Standalone explicit suspend point. */
+interface SuspendStep {
+    readonly kind: "suspend";
+    readonly id: string;
+    readonly payloadSchema?: ZodType;
+}
+/** D237 — retry policy applied per fn/agent step. */
+interface RetryPolicy {
+    /** Total attempts (MIN 1, MAX 20). `1` = no retry. */
+    readonly maxAttempts: number;
+    readonly initialBackoffMs?: number;
+    readonly backoffCoefficient?: number;
+    readonly maximumBackoffMs?: number;
+    readonly nonRetryableErrors?: ReadonlyArray<string>;
+}
+/** D247 — context handed to every step.fn. */
+interface StepContext {
+    readonly runId: string;
+    readonly signal: AbortSignal;
+    readonly log: {
+        debug: (msg: string, attrs?: Record<string, unknown>) => void;
+        info: (msg: string, attrs?: Record<string, unknown>) => void;
+        warn: (msg: string, attrs?: Record<string, unknown>) => void;
+    };
+    /** Pause the workflow; resume via `Workflow.resume({...})`. */
+    readonly suspend: (payload?: unknown) => Promise<never>;
+    /**
+     * SE29 — the workflow's shared state (from `WorkflowOptions.initialState`,
+     * mutated by {@link setState}), visible to every subsequent step in the run.
+     * `undefined` when no `initialState`/`setState` has run. Persisted across
+     * suspend/resume.
+     */
+    readonly state: unknown;
+    /**
+     * SE29 — update the shared state for subsequent steps. Validated against
+     * `WorkflowOptions.stateSchema` when set (a mismatch throws
+     * {@link WorkflowStateError}, which fails the step/run — Rule 8).
+     */
+    readonly setState: (next: unknown) => void;
+}
+interface StepResult {
+    readonly stepId: string;
+    readonly kind: Step["kind"];
+    readonly status: "completed" | "failed" | "skipped" | "suspended";
+    readonly attempts: number;
+    readonly durationMs: number;
+    readonly output?: unknown;
+    readonly error?: {
+        name: string;
+        message: string;
+    };
+}
+interface WorkflowRun<TOutput = unknown> {
+    readonly id: string;
+    readonly name: string;
+    readonly status: "running" | "completed" | "failed" | "suspended" | "cancelled";
+    readonly output?: TOutput;
+    readonly error?: {
+        name: string;
+        message: string;
+    };
+    readonly startedAt: number;
+    readonly endedAt?: number;
+    readonly stepResults: ReadonlyArray<StepResult>;
+}
+/**
+ * SE28 — a step-level workflow event emitted by `Workflow.stream()` as top-level
+ * steps run. Coarse-grained (one event per top-level step; nested
+ * parallel/branch/foreach emit as their single wrapping step), distinct from the
+ * token-delta agent stream. Discriminate on `type`.
+ *
+ * @public
+ */
+type WorkflowEvent = {
+    readonly type: "step_started";
+    readonly stepId: string;
+} | {
+    readonly type: "step_completed";
+    readonly stepId: string;
+    readonly output: unknown;
+} | {
+    readonly type: "step_failed";
+    readonly stepId: string;
+    readonly error: {
+        readonly name: string;
+        readonly message: string;
+    };
+} | {
+    readonly type: "workflow_suspended";
+    readonly stepId: string;
+} | {
+    readonly type: "workflow_completed";
+};
+/**
+ * SE28 — the async iterator returned by `Workflow.stream()`. Yields
+ * {@link WorkflowEvent}s in execution order; `result` resolves to the same
+ * terminal {@link WorkflowRun} the `run()` path returns (the authoritative
+ * outcome — the stream ends when the run terminates).
+ *
+ * @public
+ */
+type WorkflowStream<TOutput = unknown> = AsyncIterableIterator<WorkflowEvent> & {
+    readonly result: Promise<WorkflowRun<TOutput>>;
+};
+interface WorkflowPersistenceOptions {
+    readonly backend: "memory" | "json";
+    /** Required for `backend: "json"`. */
+    readonly dir?: string;
+}
+interface WorkflowOptions {
+    readonly name: string;
+    readonly persistence?: WorkflowPersistenceOptions;
+    /**
+     * SE27 — Zod schema for the WHOLE workflow's input. When set, `run(input)`
+     * validates `input` BEFORE step 1; a mismatch yields `status: "failed"` with a
+     * typed {@link WorkflowInputError} in `error` (fail-fast, no step runs, no
+     * silent coerce). Absent ⇒ no whole-workflow input validation (unchanged).
+     */
+    readonly inputSchema?: ZodType;
+    /**
+     * SE27 — Zod schema for the workflow's final output. When set, the terminal
+     * `completed` output is validated before `WorkflowRun.output` is populated; a
+     * mismatch yields `status: "failed"` with a typed {@link WorkflowOutputError}.
+     * Only validated on the `completed` path (suspended/failed runs skip it).
+     */
+    readonly outputSchema?: ZodType;
+    /**
+     * SE29 — Zod schema for the workflow's shared state (see `StepContext.state` /
+     * `setState`). When set, `initialState` and every `setState(next)` are
+     * validated against it (a mismatch throws {@link WorkflowStateError}). When
+     * `initialState` is absent, `state` starts as `undefined` and validation fires
+     * on the first `setState` call.
+     */
+    readonly stateSchema?: ZodType;
+    /**
+     * SE29 — the initial shared state, seeded onto `StepContext.state` before
+     * step 1. Validated against `stateSchema` when both are set. Persisted across
+     * suspend/resume.
+     */
+    readonly initialState?: unknown;
+    /** Internal — minted at `.commit()`. Not user-facing. */
+    readonly workflowId?: string;
+}
+interface WorkflowRunOptions {
+    readonly signal?: AbortSignal;
+    /** Override run ID for deterministic resume (advanced; default = mintRunId). */
+    readonly runId?: string;
+    /**
+     * Opt-in Task wrapping (ADRs D363, D374). Registers the workflow run
+     * as a `Task` (kind="workflow") with a `wf-` namespaced id (D368,
+     * EC-5). The task transitions terminal when `Workflow.run` resolves.
+     *
+     * Auto-id: `wf-{runId}`.
+     *
+     * @public
+     */
+    readonly task?: true | {
+        id?: string;
+        meta?: Record<string, unknown>;
+    };
+}
+interface WorkflowResumeOptions<TI = unknown> {
+    readonly runId: string;
+    readonly workflow: {
+        run: (input: TI, opts?: WorkflowRunOptions) => Promise<WorkflowRun>;
+    };
+    readonly payload?: unknown;
+    readonly signal?: AbortSignal;
+}
+
+/**
+ * Public `Workflow` class — declarative multi-step orchestration over
+ * `Agent.send`, `Handoff`, `Agent.batch` and friends (Adoption Roadmap #5;
+ * ADRs D230-D248).
+ *
+ * Usage:
+ *
+ *   import { Agent } from "@theokit/sdk";
+ *   import { Workflow, fn, agentStep } from "@theokit/sdk/workflow";
+ *
+ *   const classifier = await Agent.create({ ... });
+ *   const wf = Workflow.create({ name: "demo" })
+ *     .then(fn("validate", (input: { id: string }) => {
+ *       if (!input.id) throw new Error("missing id");
+ *       return input;
+ *     }))
+ *     .then(agentStep("classify", classifier, (i) => `Classify: ${JSON.stringify(i)}`))
+ *     .commit();
+ *
+ *   const run = await wf.run({ id: "x" });
+ *   console.log(run.status, run.output);
+ *
+ * @public
+ */
+
+declare class WorkflowBuilder<TInput = unknown, TOutput = unknown> {
+    private readonly options;
+    private readonly _steps;
+    private _committed;
+    then<TO = unknown>(step: Step): WorkflowBuilder<TInput, TO>;
+    parallel(branches: ReadonlyArray<ReadonlyArray<Step>>, opts?: {
+        id?: string;
+        concurrency?: number;
+        errorPolicy?: "fail-fast" | "collect";
+    }): WorkflowBuilder<TInput, unknown[]>;
+    branch(predicates: BranchStep["predicates"], opts?: {
+        id?: string;
+        fallback?: ReadonlyArray<Step>;
+    }): WorkflowBuilder<TInput, unknown>;
+    foreach(iterableFrom: string, step: Step, opts?: {
+        id?: string;
+        concurrency?: number;
+    }): WorkflowBuilder<TInput, unknown[]>;
+    dowhile(step: Step, condFn: DowhileStep["condFn"], opts?: {
+        id?: string;
+        maxIterations?: number;
+    }): WorkflowBuilder<TInput, unknown>;
+    sleep(durationMs: number, id?: string): WorkflowBuilder<TInput, TOutput>;
+    suspend(opts?: {
+        id?: string;
+        payloadSchema?: ZodType;
+    }): WorkflowBuilder<TInput, unknown>;
+    commit(): Workflow<TInput, TOutput>;
+    private validateUniqueIds;
+    private assertNotCommitted;
+}
+declare class Workflow<TInput = unknown, TOutput = unknown> {
+    private readonly _options;
+    private readonly _steps;
+    /**
+     * Construct a workflow builder. Validate options via Zod and return a
+     * `WorkflowBuilder` for fluent chaining. Call `.commit()` to obtain the
+     * immutable `Workflow`.
+     */
+    static create<TI = unknown, TO = unknown>(options: WorkflowOptions): WorkflowBuilder<TI, TO>;
+    /**
+     * Run this workflow with the given input. Returns a populated
+     * `WorkflowRun`. Errors inside a step DO NOT throw — they propagate via
+     * `run.status === "failed"`.
+     */
+    run(input: TInput, opts?: WorkflowRunOptions): Promise<WorkflowRun<TOutput>>;
+    /**
+     * SE28 — run the workflow and STREAM step-level events as they happen. Returns
+     * an async iterator of {@link WorkflowEvent}s (`step_started` / `step_completed`
+     * / `step_failed` / `workflow_suspended` / `workflow_completed`, top-level
+     * steps) plus a `result` promise resolving to the same terminal
+     * {@link WorkflowRun} `run()` returns. Iterate for progress; await `result` for
+     * the outcome. The stream ends when the run terminates.
+     *
+     * `result` is the AUTHORITATIVE terminal status. Not every terminal state has a
+     * closing event: a step failure emits `step_failed`, but an `outputSchema`
+     * rejection (SE27) or an abort ends the stream WITHOUT `workflow_completed` —
+     * always `await result` to read the final `status`. Consuming order is free:
+     * awaiting `result` without draining, or draining without awaiting `result`,
+     * both work (breaking out of `for await` stops the buffering early).
+     */
+    stream(input: TInput, opts?: WorkflowRunOptions): WorkflowStream<TOutput>;
+    /**
+     * Resume a suspended workflow from its snapshot. Throws
+     * `WorkflowSnapshotNotFoundError` if `runId` is unknown.
+     */
+    static resume<TO = unknown>(opts: WorkflowResumeOptions): Promise<WorkflowRun<TO>>;
+}
+
 /**
  * Runtime hosting a cron job. Mirrors the agent runtime split.
  *
@@ -2126,11 +2470,12 @@ type CronRuntime = "local" | "cloud";
  */
 type CronJobStatus = "scheduled" | "running" | "paused" | "errored";
 /**
- * Persistent cron-scheduled invocation of the Theo agent.
+ * Persistent cron-scheduled invocation of the Theo agent or a workflow.
  *
- * Exactly one of {@link CronJob.agent} (ephemeral agent created on each fire)
- * or {@link CronJob.agentId} (bound to an existing agent for context
- * continuity) is set.
+ * Exactly one target is set: {@link CronJob.agent} (ephemeral agent created on
+ * each fire), {@link CronJob.agentId} (bound to an existing agent for context
+ * continuity), or {@link CronJob.workflow} (a committed workflow run per fire;
+ * SE35). Agent targets carry a `message`; a workflow target carries `inputData`.
  *
  * @public
  */
@@ -2141,17 +2486,25 @@ interface CronJob {
     cron: string;
     /** IANA timezone identifier. Defaults to `"UTC"`. */
     timezone?: string;
-    /** Message sent to the agent on each fire. */
-    message: string | SDKUserMessage;
-    /** Ephemeral agent options. Mutually exclusive with `agentId`. */
+    /** Message sent to the agent on each fire. Present for agent targets; absent for a workflow target. */
+    message?: string | SDKUserMessage;
+    /** Ephemeral agent options. Mutually exclusive with `agentId`/`workflow`. */
     agent?: AgentOptions;
-    /** ID of an existing agent to reuse for context continuity. Mutually exclusive with `agent`. */
+    /** ID of an existing agent to reuse for context continuity. Mutually exclusive with `agent`/`workflow`. */
     agentId?: string;
+    /**
+     * SE35 — a committed {@link Workflow} run on each fire (`workflow.run(inputData)`).
+     * Mutually exclusive with `agent`/`agentId`. Held in-memory (local runtime only —
+     * a workflow instance cannot cross the cloud process boundary). ADR 0014.
+     */
+    workflow?: Workflow;
+    /** SE35 — input passed to `workflow.run(inputData)` on each fire. Workflow targets only. */
+    inputData?: unknown;
     /** Whether the scheduler will fire this job on schedule. */
     enabled: boolean;
     /** Current status. */
     status: CronJobStatus;
-    /** Runtime that hosts this job. Inferred from `agent`/`agentId` at create time. */
+    /** Runtime that hosts this job. Inferred from `agent`/`agentId`/`workflow` at create time (a `workflow` target is always `local`). */
     runtime: CronRuntime;
     /** Unix ms of the last successful fire, if any. */
     lastRunAt?: number;
@@ -2163,17 +2516,24 @@ interface CronJob {
 /**
  * Options for `Cron.create()`.
  *
- * Pass `agent` for an ephemeral agent created fresh on each fire, OR
- * `agentId` to reuse an existing agent (preserves conversation context across
- * fires). Setting both is a `ConfigurationError`.
+ * Pass exactly ONE target: `agent` (ephemeral agent fresh per fire), `agentId`
+ * (reuse an existing agent — preserves conversation context), or `workflow`
+ * (SE35 — run a committed workflow per fire). Agent targets REQUIRE `message`;
+ * a workflow target takes `inputData` and MUST NOT set `message`. Violations are
+ * a `ConfigurationError`.
  *
  * @public
  */
 interface CronCreateOptions {
     cron: string;
-    message: string | SDKUserMessage;
+    /** Message for an agent target. Required with `agent`/`agentId`; forbidden with `workflow`. */
+    message?: string | SDKUserMessage;
     agent?: AgentOptions;
     agentId?: string;
+    /** SE35 — a committed {@link Workflow} to run per fire. Mutually exclusive with `agent`/`agentId`. */
+    workflow?: Workflow;
+    /** SE35 — input for `workflow.run(inputData)`. Workflow targets only. */
+    inputData?: unknown;
     name?: string;
     timezone?: string;
     /** Defaults to `true`. */
@@ -2301,11 +2661,12 @@ declare class Cron {
      */
     static disable(jobId: string, _options?: CronOperationOptions): Promise<CronJob>;
     /**
-     * Manually trigger a cron job off-schedule. Returns the resulting `Run`.
+     * Manually trigger a cron job off-schedule. Returns the resulting `Run`
+     * (agent target) or `WorkflowRun` (workflow target — SE35).
      *
      * @public
      */
-    static run(jobId: string, _options?: CronRunOptions): Promise<Run>;
+    static run(jobId: string, _options?: CronRunOptions): Promise<Run | WorkflowRun>;
     /**
      * Activate the in-process scheduler for local cron jobs.
      *
@@ -2326,4 +2687,4 @@ declare class Cron {
     static status(_options?: CronStartOptions): Promise<CronSchedulerStatus>;
 }
 
-export { type CronRunOptions as $, type AgentOptions as A, type BudgetTracker as B, type CloudOptions as C, type BudgetTotal as D, type BudgetUsageEvent as E, type CloudEnv as F, type GetAgentOptions as G, type CloudRepo as H, type InlineSkill as I, type ContextBudget as J, type ContextManagerKind as K, type LocalOptions as L, type MemorySettings as M, type ContextSnapshot as N, type ObjectiveRecord as O, type ProviderRoutingSettings as P, type ContextSource as Q, type ContextSourceStatus as R, type SystemPromptResolver as S, type CreateSkillSpec as T, Cron as U, type CronCreateOptions as V, type CronGetOptions as W, type CronJob as X, type CronJobStatus as Y, type CronListOptions as Z, type CronOperationOptions as _, type AgentDefinition as a, type CronRuntime as a0, type CronSchedulerStatus as a1, type CronStartOptions as a2, type DurableGoalOptions as a3, type GoalEvent as a4, type GoalOptions as a5, type GoalResult as a6, type HookName as a7, type InvalidateCacheOptions as a8, type MemoryAdapter as a9, type SDKProvidersManager as aA, type SettingSource as aB, type SkillsResolver as aC, type SkillsResolverContext as aD, type SystemPromptContext as aE, type SystemPromptMemoryFact as aF, type SystemPromptSkillRef as aG, type TelemetrySettings as aH, createSkill as aI, definePlugin as aJ, type MemoryAdapterCapabilities as aa, type MemoryContext as ab, type MemoryFact as ac, type MemoryProviderHandle as ad, type MemoryProviderInitOptions as ae, type MemoryRevision as af, type MemoryToolSchema as ag, type MemoryTurnMessage as ah, type ObjectiveStatus as ai, type PersonalityPreset as aj, type PluginContext as ak, type PostAssistantReplyContext as al, type PreToolCallContext as am, type PreUserSendContext as an, type PreUserSendResult as ao, type ProviderCapability as ap, type ProviderRoute as aq, type RecordSessionSummaryArgs as ar, type ResolvedProviderRoute as as, type RunUntilIterator as at, type SDKAgentPlugins as au, type SDKAgentSkillDetail as av, type SDKAgentSkills as aw, type SDKArtifact as ax, type SDKContextManager as ay, type SDKPluginMetadata as az, type ContextSettings as b, type PluginsSettings as c, type SkillsSettings as d, type SDKAgent as e, type ListAgentsOptions as f, type ListResult as g, type SDKAgentInfo as h, type ListRunsOptions as i, type GetRunOptions as j, type AgentOperationOptions as k, type ProviderProfile as l, type Plugin as m, type ConversationStorageAdapter as n, type StoredMessage as o, type SessionMeta as p, type SessionMetaPatch as q, type MemoryProvider as r, type MemoryId as s, type PreToolCallDecision as t, type SDKProvider as u, type ActiveMemoryPassArgs as v, type ActiveMemoryPassResult as w, type AgentGoalConfig as x, type AgentMemory as y, type BudgetCheck as z };
+export { type CronOperationOptions as $, type AgentOptions as A, type BudgetTracker as B, type CloudOptions as C, type BudgetCheck as D, type BudgetTotal as E, type BudgetUsageEvent as F, type GetAgentOptions as G, type CloudEnv as H, type InlineSkill as I, type CloudRepo as J, type ContextBudget as K, type LocalOptions as L, type MemorySettings as M, type ContextManagerKind as N, type ObjectiveRecord as O, type ProviderRoutingSettings as P, type ContextSnapshot as Q, type ContextSource as R, type SystemPromptResolver as S, type ContextSourceStatus as T, type CreateSkillSpec as U, Cron as V, type CronCreateOptions as W, type CronGetOptions as X, type CronJob as Y, type CronJobStatus as Z, type CronListOptions as _, type AgentDefinition as a, type CronRunOptions as a0, type CronRuntime as a1, type CronSchedulerStatus as a2, type CronStartOptions as a3, type DurableGoalOptions as a4, type GoalEvent as a5, type GoalOptions as a6, type GoalResult as a7, type HookName as a8, type InvalidateCacheOptions as a9, type SDKPluginMetadata as aA, type SDKProvidersManager as aB, type SettingSource as aC, Skill as aD, type SkillsResolver as aE, type SkillsResolverContext as aF, type SystemPromptContext as aG, type SystemPromptMemoryFact as aH, type SystemPromptSkillRef as aI, type TelemetrySettings as aJ, type MemoryAdapter as aa, type MemoryAdapterCapabilities as ab, type MemoryContext as ac, type MemoryFact as ad, type MemoryProviderHandle as ae, type MemoryProviderInitOptions as af, type MemoryRevision as ag, type MemoryToolSchema as ah, type MemoryTurnMessage as ai, type ObjectiveStatus as aj, type PersonalityPreset as ak, type PluginContext as al, type PostAssistantReplyContext as am, type PreToolCallContext as an, type PreUserSendContext as ao, type PreUserSendResult as ap, type ProviderCapability as aq, type ProviderRoute as ar, type RecordSessionSummaryArgs as as, type ResolvedProviderRoute as at, type RunUntilIterator as au, type SDKAgentPlugins as av, type SDKAgentSkillDetail as aw, type SDKAgentSkills as ax, type SDKArtifact as ay, type SDKContextManager as az, type ContextSettings as b, type PluginsSettings as c, type SkillsSettings as d, type SDKAgent as e, type ListAgentsOptions as f, type ListResult as g, type SDKAgentInfo as h, type ListRunsOptions as i, type GetRunOptions as j, type AgentOperationOptions as k, type ProviderProfile as l, Plugin as m, type ConversationStorageAdapter as n, type StoredMessage as o, type SessionMeta as p, type SessionMetaPatch as q, type MemoryProvider as r, type MemoryId as s, type PreToolCallDecision as t, type StepResult as u, type SDKProvider as v, type ActiveMemoryPassArgs as w, type ActiveMemoryPassResult as x, type AgentGoalConfig as y, type AgentMemory as z };