@cybernetyx1/atlasflow-runtime 0.1.0

package/dist/channel-Dv3Hv1ee.d.ts

@@ -0,0 +1,634 @@
+import * as v from 'valibot';
+import { GenericSchema, InferOutput } from 'valibot';
+import { b as SandboxFactory, C as Command } from './command-kxrqWIH7.js';
+import { M as ModelConfig, n as Message, T as ThinkingLevel, C as CacheRetention, E as EventBus, U as Usage, o as PromptImage, P as PersistenceAdapter, A as AtlasEvent, R as RunRecord } from './index-UFTgKRK4.js';
+
+/**
+ * The AgentEngine seam — the single swap boundary for the model/agentic layer.
+ *
+ * pi-ai implements this today (engine-pi.ts). Nothing outside the adapter
+ * imports pi-ai. When we replace pi-ai with our own agentic loop, we implement
+ * this same interface and swap one reference in runtime.ts — every harness,
+ * session, tool, and event keeps working unchanged. Keep this vendor-free.
+ */
+
+type ToolChoice = "auto" | "required" | "none";
+interface ToolApprovalPolicy {
+    required: true;
+    reason?: string;
+}
+interface EngineTool {
+    name: string;
+    description: string;
+    /** JSON Schema object describing the tool's arguments. */
+    parameters: Record<string, unknown>;
+    /** Human approval required before the tool side effect executes. */
+    approval?: ToolApprovalPolicy;
+    execute: (args: Record<string, unknown>, signal?: AbortSignal) => Promise<string>;
+}
+interface EngineRunInput {
+    model: ModelConfig;
+    instructions?: string;
+    messages: Message[];
+    tools: EngineTool[];
+    thinkingLevel?: ThinkingLevel;
+    toolChoice?: ToolChoice;
+    /** Explicit API key for this model's provider; overrides env resolution. */
+    apiKey?: string;
+    /**
+     * Environment to resolve provider credentials from (e.g. ANTHROPIC_API_KEY,
+     * OPENAI_API_KEY). On Node this is typically process.env; on Workers it is
+     * the per-request env bindings (values may be non-string bindings — the
+     * engine only reads string entries). The engine picks the variable matching
+     * the model's provider — never a hardcoded vendor default.
+     */
+    env?: Record<string, unknown>;
+    /** Per-provider endpoint overrides (gateways, proxies, self-hosted). */
+    providers?: Record<string, {
+        baseUrl?: string;
+        headers?: Record<string, string>;
+        apiKey?: string;
+    }>;
+    signal?: AbortSignal;
+    /** Stable id for prompt caching / session affinity. */
+    sessionId?: string;
+    cacheRetention?: CacheRetention;
+}
+interface EngineRunResult {
+    appended: Message[];
+    text: string;
+    usage: Usage;
+}
+interface EngineHooks {
+    bus: EventBus;
+    runId?: string;
+    session?: string;
+}
+interface AgentEngine {
+    run(input: EngineRunInput, hooks: EngineHooks): Promise<EngineRunResult>;
+}
+
+/**
+ * Tools.
+ *
+ * Design note: authors describe parameters once as a Valibot
+ * schema; we infer the JSON Schema the model needs. No hand-written JSON Schema.
+ */
+
+interface ToolDefinition<TSchema extends GenericSchema = GenericSchema> {
+    name: string;
+    description: string;
+    parameters: TSchema;
+    /** Require an explicit human approval before this tool executes. */
+    approval?: boolean | ToolApprovalPolicy;
+    execute: (args: InferOutput<TSchema>, signal?: AbortSignal) => Promise<string> | string;
+}
+declare function defineTool<TSchema extends GenericSchema>(def: ToolDefinition<TSchema>): ToolDefinition<TSchema>;
+/**
+ * A tool whose parameters are already a JSON Schema (e.g. an MCP tool), rather
+ * than a Valibot schema. Branded so the runtime can pass it through directly.
+ */
+interface RawTool extends EngineTool {
+    readonly __atlasflowRawTool: true;
+}
+declare function rawTool(tool: EngineTool): RawTool;
+declare function isRawTool(tool: unknown): tool is RawTool;
+type AnyTool = ToolDefinition | RawTool;
+/** Lower a public ToolDefinition into the vendor-neutral EngineTool. */
+declare function resolveTool(def: ToolDefinition): EngineTool;
+/** Resolve either a Valibot-schema tool or a raw JSON-schema tool. */
+declare function resolveAnyTool(tool: AnyTool): EngineTool;
+
+/**
+ * Agent authoring API — `createAgent`. Declarative: an agent file
+ * default-exports `createAgent(initialize)`, where `initialize` returns the
+ * runtime config (optionally async, optionally reading the invocation context).
+ */
+
+interface Skill {
+    name: string;
+    description: string;
+    body: string;
+    allowedTools?: string[];
+    /** Files packaged alongside an imported SKILL.md, keyed by path relative to the skill directory. */
+    files?: Record<string, PackagedSkillFile>;
+}
+interface PackagedSkillFile {
+    kind: "text" | "binary";
+    encoding: "base64";
+    content: string;
+}
+interface AgentProfile {
+    name: string;
+    model?: ModelConfig;
+    instructions?: string;
+    tools?: ToolDefinition[];
+    thinkingLevel?: ThinkingLevel;
+}
+interface AgentRuntimeConfig {
+    name?: string;
+    description?: string;
+    /** Default model; `false` requires a per-call model override. */
+    model?: ModelConfig | false;
+    instructions?: string;
+    tools?: AnyTool[];
+    skills?: Skill[];
+    /**
+     * How authored skills are exposed to the model. "callable" preserves the
+     * historical `skill_<name>` subcall tools; "load" exposes a context-economical
+     * `load_skill` tool and an index, leaving skill bodies out of the base prompt.
+     */
+    skillLoading?: "callable" | "load";
+    /**
+     * Named personas the agent can delegate to via the built-in `task` tool:
+     * each runs in its own fresh session with its own model/instructions.
+     * (Atlas Brain terminology; `subagents` remains as a deprecated alias.)
+     */
+    personas?: AgentProfile[];
+    /** @deprecated Use `personas`. */
+    subagents?: AgentProfile[];
+    /**
+     * Declarative knowledge units (Atlas Brain "context packs"). Packs with
+     * mount "context" (default for small packs) join the system context; packs
+     * with mount "sandbox" are written into the sandbox under packs/<name>/
+     * where the built-in read/grep tools reach them.
+     */
+    contextPacks?: ContextPack[];
+    /**
+     * How context packs are exposed. "eager" preserves the historical behavior:
+     * context-mounted pack bodies join the system prompt. "lazy" exposes an index
+     * plus `load_context`, keeping bodies out of the base prompt until requested.
+     */
+    contextLoading?: "eager" | "lazy";
+    /**
+     * Binding rules (Atlas Brain normative·binding): declarative interceptors
+     * enforced at before_prompt / before_tool / after_tool. `block` stops the
+     * action with the rule's message; `warn` logs and proceeds.
+     */
+    rules?: Rule[];
+    /** Programmatic enforcement hooks (rules compile to these internally). */
+    hooks?: AgentHooks;
+    thinkingLevel?: ThinkingLevel;
+    /** Provider-neutral tool policy. Currently honored by the Workers AI binding path. */
+    toolChoice?: ToolChoice;
+    /** Execution environment; defaults to an in-memory virtual sandbox. `false` disables filesystem/shell tools. */
+    sandbox?: false | SandboxFactory;
+    /**
+     * Built-in sandbox tools (read, write, edit, bash, grep, glob, task).
+     * Enabled automatically when a sandbox is configured; `false` to opt out,
+     * or a list of names to enable a subset.
+     */
+    builtinTools?: boolean | string[];
+    /**
+     * Host-implemented commands registered into scoped just-bash operations.
+     * Use these for privileged CLIs or SDK-backed commands without exposing
+     * secrets to the sandbox environment.
+     */
+    commands?: Command[];
+    cwd?: string;
+    profile?: AgentProfile;
+    /** Validate the agent's final reply against this schema; exposed as `result`. */
+    result?: GenericSchema;
+    /**
+     * Per-provider overrides for gateways, proxies, or self-hosted endpoints:
+     * keyed by provider name (e.g. "anthropic", "openai").
+     */
+    providers?: Record<string, ProviderSettings>;
+    /** Durability for workflow runs: retry on failure, wall-clock timeout. */
+    durability?: DurabilityConfig;
+    /** Automatic context-window management; ON by default, `false` to disable. */
+    compaction?: false | CompactionConfig;
+    /** Append an autonomy directive (work without asking questions). */
+    headless?: boolean;
+    /**
+     * Release per-invocation resources created during initialization, such as
+     * request-scoped MCP connections. The runtime calls this after the run
+     * settles, including background runs kept alive with waitUntil.
+     */
+    cleanup?: () => void | Promise<void>;
+}
+interface CompactionConfig {
+    /** Compact once a session exceeds this many messages (off unless set). */
+    threshold?: number;
+    /** Compact once estimated history tokens exceed this (default 120000). */
+    thresholdTokens?: number;
+    /** Messages to keep verbatim after compaction (default 10). */
+    keepRecent?: number;
+    /** Model used to summarize; defaults to the agent's model. */
+    model?: ModelConfig;
+}
+interface ContextPackItem {
+    name: string;
+    content: string;
+}
+interface ContextPack {
+    name: string;
+    description?: string;
+    version?: string;
+    /** "context" injects into the system context; "sandbox" mounts files under packs/<name>/. */
+    mount?: "context" | "sandbox";
+    items: ContextPackItem[];
+    /** Atlas Brain trust axis — carried as metadata, never judged here. */
+    provenance?: string;
+}
+type RuleEnforcePoint = "before_prompt" | "before_tool" | "after_tool";
+interface Rule {
+    name: string;
+    enforce: RuleEnforcePoint;
+    /** Restrict tool rules to these tool names (default: all tools). */
+    tools?: string[];
+    /** Regex tested against the prompt text / JSON-encoded tool args / tool result. */
+    pattern?: string;
+    /** "block" stops the action with `message`; "warn" emits an event and proceeds. */
+    action?: "block" | "warn";
+    message: string;
+    provenance?: string;
+}
+type HookDecision = {
+    allow: true;
+} | {
+    allow: false;
+    message: string;
+};
+interface AgentHooks {
+    beforePrompt?: (text: string) => HookDecision | Promise<HookDecision>;
+    beforeTool?: (tool: string, args: Record<string, unknown>) => HookDecision | Promise<HookDecision>;
+    afterTool?: (tool: string, result: string) => HookDecision | Promise<HookDecision>;
+}
+interface ProviderSettings {
+    /** Override the provider's API base URL. */
+    baseUrl?: string;
+    /** Extra headers sent with every request to this provider. */
+    headers?: Record<string, string>;
+    /** API key for this provider (overrides env resolution). */
+    apiKey?: string;
+    /** Cloudflare account id used to expand {CLOUDFLARE_ACCOUNT_ID} in Workers AI URLs. */
+    accountId?: string;
+    /** Default API implementation for custom models from this provider. */
+    api?: string;
+    /** Custom model definitions for providers not present in pi-ai's generated catalog. */
+    models?: Record<string, ProviderModelSettings>;
+}
+interface ProviderModelSettings {
+    api?: string;
+    name?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    reasoning?: boolean;
+    thinkingLevelMap?: Record<string, string | null>;
+    input?: ("text" | "image")[];
+    cost?: Partial<{
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    }>;
+    contextWindow?: number;
+    maxTokens?: number;
+    compat?: unknown;
+}
+interface DurabilityConfig {
+    /** Max retry attempts after the first failure (default 0). */
+    retry?: number;
+    /** Per-attempt wall-clock timeout in milliseconds. */
+    timeoutMs?: number;
+}
+/**
+ * `env` carries strings (Node process.env) AND platform bindings (Cloudflare
+ * R2/D1/Vectorize/Durable Object namespaces) — type it per-agent via TEnv.
+ */
+interface AgentCreateContext<TPayload = unknown, TEnv = Record<string, unknown>> {
+    id: string;
+    env: TEnv;
+    payload?: TPayload;
+}
+type AgentInitialize<TPayload, TEnv> = (ctx: AgentCreateContext<TPayload, TEnv>) => AgentRuntimeConfig | Promise<AgentRuntimeConfig>;
+type AgentDefinition<TPayload = unknown, TEnv = Record<string, unknown>> = AgentRuntimeConfig | AgentInitialize<TPayload, TEnv>;
+interface CreatedAgent<TPayload = unknown, TEnv = Record<string, unknown>> {
+    readonly __atlasflowAgent: true;
+    initialize: AgentInitialize<TPayload, TEnv>;
+}
+declare function createAgent<TPayload = unknown, TEnv = Record<string, unknown>>(initialize: AgentInitialize<TPayload, TEnv>): CreatedAgent<TPayload, TEnv>;
+declare function defineAgent<TPayload = unknown, TEnv = Record<string, unknown>>(definition: AgentDefinition<TPayload, TEnv>): CreatedAgent<TPayload, TEnv>;
+declare function isCreatedAgent(value: unknown): value is CreatedAgent;
+declare function defineAgentProfile(profile: AgentProfile): AgentProfile;
+/** Merge a profile baseline under an explicit config (config wins). */
+declare function applyProfile(config: AgentRuntimeConfig): AgentRuntimeConfig;
+
+/**
+ * Runtime orchestrator: turn a CreatedAgent + an invocation into a result.
+ *
+ * The declarative agent config (model, instructions, tools, skills, sandbox) IS
+ * the behavior. On invocation we build the harness and drive the default
+ * session with the incoming message/payload; the agentic loop (engine) handles
+ * multi-step autonomy via tools.
+ */
+
+declare const defaultEngine: AgentEngine;
+declare function getDefaultPersistence(): PersistenceAdapter;
+interface InvokeOptions {
+    agent: CreatedAgent;
+    agentName: string;
+    instanceId: string;
+    message?: string;
+    payload?: unknown;
+    images?: PromptImage[];
+    env?: Record<string, unknown>;
+    engine?: AgentEngine;
+    persistence?: PersistenceAdapter;
+    onEvent?: (event: AtlasEvent) => void;
+    /** Explicit API key for the agent's model provider (overrides env lookup). */
+    apiKey?: string;
+    /** Use this run id instead of generating one (for dispatch/recovery). */
+    runId?: string;
+    /** Internal execution lease owner for durable/background runs. */
+    runLeaseOwner?: string;
+    /** Internal execution lease TTL. Defaults to five minutes. */
+    runLeaseTtlMs?: number;
+    /** Internal marker for replaying a stale running run during recovery. */
+    runResume?: boolean;
+    /** Wrap durable/background execution in a platform primitive such as Cloudflare runFiber(). */
+    durability?: DurableExecutionRunner;
+    /** Abort the invocation (e.g. when an HTTP client disconnects). */
+    signal?: AbortSignal;
+    /** Prepended to the agent's instructions (e.g. workspace AGENTS.md). */
+    baseInstructions?: string;
+    /** Personas available to every agent's task tool (e.g. workspace roles/). */
+    sharedPersonas?: AgentProfile[];
+    /** @deprecated Use `sharedPersonas`. */
+    sharedSubagents?: AgentProfile[];
+}
+interface DurableExecutionMeta {
+    runId: string;
+    agentName: string;
+    instanceId: string;
+    resume: boolean;
+}
+type DurableExecutionRunner = (meta: DurableExecutionMeta, run: () => Promise<void>) => Promise<void> | void;
+interface InvokeResult {
+    runId: string;
+    text: string;
+    data: unknown;
+    usage: Usage;
+}
+declare function genId(prefix: string): string;
+/**
+ * Dispatch a durable workflow run: persist a queued submission, then execute it
+ * in the background after atomically claiming the queued record. Returns once
+ * the record exists, so a poller can immediately `runs.get(runId)`. Failures
+ * are recorded on the run record.
+ *
+ * `done` resolves when the background run finishes (never rejects). On
+ * Cloudflare Workers it MUST be passed to `ctx.waitUntil`, or the runtime
+ * cancels the work as soon as the HTTP response is sent.
+ */
+declare function dispatchWorkflow(options: InvokeOptions): Promise<{
+    runId: string;
+    done: Promise<void>;
+}>;
+/**
+ * Recover interrupted runs: execute any queued submission, and handle any
+ * still-running run according to the recovery policy. Queued submissions are
+ * safe to run by default because no attempt has claimed/executed them yet.
+ * Already-running runs default to automatic replay only when the persisted
+ * journal and event log prove no side-effecting work or output happened.
+ */
+declare function recoverRuns(agents: Record<string, CreatedAgent>, opts?: {
+    persistence?: PersistenceAdapter;
+    engine?: AgentEngine;
+    env?: Record<string, unknown>;
+    leaseTtlMs?: number;
+    /**
+     * Restrict recovery to specific run ids. This is used by platform recovery
+     * callbacks that know exactly which durable execution was interrupted.
+     */
+    runIds?: string[];
+    /**
+     * Expire a matching running run's lease before attempting recovery. Use
+     * only when an external runtime signal proves the original execution died.
+     */
+    forceLeaseExpiration?: boolean;
+    /**
+     * Safe default ("auto"): replay stale agent runs only when the session
+     * journal proves the accepted input can be resumed and the event log has no
+     * tool calls, deltas, or other side-effect/output evidence. Use "replay" to
+     * force replay for explicitly idempotent agents, or "interrupt" to always
+     * terminalize stale running runs.
+     */
+    agentRecovery?: "auto" | "interrupt" | "replay";
+    /** Wrap recovered durable/background execution in a platform primitive. */
+    durability?: DurableExecutionRunner;
+}): Promise<string[]>;
+declare function invokeAgent(options: InvokeOptions): Promise<InvokeResult>;
+
+/**
+ * Authored workflows — the Atlas Brain procedural·binding primitive: a
+ * declarative sequence of steps with human GATES and persona ROLE SLOTS.
+ *
+ * Execution model: chained runs. The workflow has a parent run record holding
+ * the executor state (cursor, step results, gate decisions); every prompt or
+ * skill step executes as its own child run. Gates park the parent in
+ * "waiting_approval" — durable across restarts, resumable days later via
+ * `approveGate` (surfaced as POST /runs/:runId/approve; the Brain owns the
+ * approval UX).
+ *
+ * NOTE: "workflow" here means this authored primitive. The dispatched-run
+ * invocation mode formerly called "workflows" is now "runs" (§19/§20).
+ */
+
+declare const WorkflowStepSchema: v.VariantSchema<"kind", [v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly kind: v.LiteralSchema<"prompt", undefined>;
+    /** May reference prior steps: {{steps.<id>.text}}. */
+    readonly prompt: v.StringSchema<undefined>;
+    /** Role slot or persona name executing this step (default: workflow default persona). */
+    readonly persona: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly kind: v.LiteralSchema<"skill", undefined>;
+    /** Name of a skill in the executing persona's loadout. */
+    readonly skill: v.StringSchema<undefined>;
+    /** Input text; may reference prior steps: {{steps.<id>.text}}. */
+    readonly input: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly persona: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly kind: v.LiteralSchema<"gate", undefined>;
+    readonly title: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>], undefined>;
+declare const WorkflowDefSchema: v.ObjectSchema<{
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly steps: v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly kind: v.LiteralSchema<"prompt", undefined>;
+        /** May reference prior steps: {{steps.<id>.text}}. */
+        readonly prompt: v.StringSchema<undefined>;
+        /** Role slot or persona name executing this step (default: workflow default persona). */
+        readonly persona: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly kind: v.LiteralSchema<"skill", undefined>;
+        /** Name of a skill in the executing persona's loadout. */
+        readonly skill: v.StringSchema<undefined>;
+        /** Input text; may reference prior steps: {{steps.<id>.text}}. */
+        readonly input: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly persona: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly kind: v.LiteralSchema<"gate", undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>], undefined>, undefined>, v.MinLengthAction<({
+        id: string;
+        kind: "prompt";
+        prompt: string;
+        persona?: string | undefined;
+        model?: string | undefined;
+    } | {
+        id: string;
+        kind: "skill";
+        skill: string;
+        input?: string | undefined;
+        persona?: string | undefined;
+    } | {
+        id: string;
+        kind: "gate";
+        title: string;
+        description?: string | undefined;
+    })[], 1, undefined>]>;
+    /** Role slot → default persona name; rebindable at deploy. */
+    readonly roleSlots: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+type WorkflowStep = v.InferOutput<typeof WorkflowStepSchema>;
+type WorkflowDef = v.InferOutput<typeof WorkflowDefSchema>;
+declare function parseWorkflowDef(value: unknown): WorkflowDef;
+interface WorkflowState {
+    cursor: number;
+    results: Record<string, {
+        text: string;
+        runId?: string;
+    }>;
+    gates: Record<string, {
+        approved: boolean;
+        note?: string;
+        at: number;
+    }>;
+}
+interface WorkflowContext {
+    /** Personas executing steps: registered agents win, then profiles. */
+    agents?: Record<string, Parameters<typeof invokeAgent>[0]["agent"]>;
+    profiles?: AgentProfile[];
+    /** Default model for steps with no persona/model of their own. */
+    defaultModel?: string;
+    /**
+     * Persona executing steps that name no role slot — a persona's workflows
+     * run AS that persona (its identity, packs, rules) unless a step overrides.
+     */
+    defaultPersona?: string;
+    /** Skills resolvable by skill steps. */
+    skills?: {
+        name: string;
+        description: string;
+        body: string;
+    }[];
+    /** Deploy-time role-slot rebinding (overrides def.roleSlots). */
+    bindings?: Record<string, string>;
+    persistence?: PersistenceAdapter;
+    engine?: AgentEngine;
+    env?: Record<string, unknown>;
+    baseInstructions?: string;
+    onEvent?: InvokeOptions["onEvent"];
+}
+interface WorkflowRunResult {
+    runId: string;
+    status: "success" | "failed" | "waiting_approval";
+    /** Final step's text when status is success. */
+    text?: string;
+    /** The gate currently waiting, when status is waiting_approval. */
+    gate?: {
+        id: string;
+        title: string;
+    };
+}
+/**
+ * Start a workflow run (or resume one from persisted state). Creates the
+ * parent run record (`kind: "workflow"`), then executes steps as chained
+ * child runs until done or a gate parks it.
+ */
+declare function startWorkflow(def: WorkflowDef, ctx?: WorkflowContext, opts?: {
+    runId?: string;
+    payload?: unknown;
+}): Promise<WorkflowRunResult>;
+/** Run steps from the persisted cursor until completion or a gate. */
+declare function advanceWorkflow(def: WorkflowDef, ctx: WorkflowContext, runId: string): Promise<WorkflowRunResult>;
+/**
+ * Record a human decision on the gate a workflow is parked at, then resume
+ * (approve) or terminate (reject). Returns the post-decision result.
+ */
+declare function approveGate(def: WorkflowDef, ctx: WorkflowContext, runId: string, decision: {
+    gate: string;
+    approved: boolean;
+    note?: string;
+}): Promise<WorkflowRunResult>;
+/**
+ * Resume interrupted workflow runs after a restart: anything still "running"
+ * re-executes from its persisted cursor (the in-flight step re-runs);
+ * "waiting_approval" runs stay parked — they are waiting on a human, not us.
+ */
+declare function recoverWorkflows(defs: Record<string, WorkflowDef>, ctx?: WorkflowContext): Promise<string[]>;
+/** Find the gate a parked workflow run is waiting at. */
+declare function waitingGate(def: WorkflowDef, record: RunRecord): {
+    id: string;
+    title: string;
+} | undefined;
+
+type ChannelMode = "background" | "sync";
+interface ChannelContext {
+    channel: string;
+    request: Request;
+    url: URL;
+    env: Record<string, string | undefined>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+interface ChannelDispatch {
+    /** Stable platform thread identifier; AtlasFlow maps it to the agent session id. */
+    continuationToken: string;
+    /** Defaults to the only deployed agent when the app has exactly one agent. */
+    agent?: string;
+    message?: string;
+    payload?: unknown;
+    images?: PromptImage[];
+    runId?: string;
+    mode?: ChannelMode;
+}
+interface ChannelAccepted {
+    dispatch: ChannelDispatch;
+    response?: unknown;
+    status?: number;
+}
+type ChannelResult = Response | ChannelDispatch | ChannelAccepted;
+interface ChannelDefinition {
+    name?: string;
+    /** Defaults to /channels/<name>. Relative paths are mounted under /channels/. */
+    path?: string;
+    /** Defaults to POST. */
+    methods?: string[];
+    handle(ctx: ChannelContext): ChannelResult | Promise<ChannelResult>;
+}
+declare function defineChannel(channel: ChannelDefinition): ChannelDefinition;
+declare function isChannelDefinition(value: unknown): value is ChannelDefinition;
+interface SlackRequestSignatureOptions {
+    /** Defaults to five minutes, matching Slack's replay-window guidance. */
+    toleranceMs?: number;
+    /** Primarily for tests; defaults to Date.now(). */
+    now?: number;
+}
+declare function verifyGithubWebhookSignature(secret: string, body: string, header: string | null | undefined): Promise<boolean>;
+declare function verifySlackRequestSignature(secret: string, body: string, timestamp: string | null | undefined, signature: string | null | undefined, options?: SlackRequestSignatureOptions): Promise<boolean>;
+
+export { genId as $, type AgentEngine as A, type ToolApprovalPolicy as B, type CreatedAgent as C, type DurableExecutionRunner as D, type EngineTool as E, type WorkflowContext as F, WorkflowDefSchema as G, type HookDecision as H, type InvokeResult as I, type WorkflowRunResult as J, type WorkflowState as K, type WorkflowStep as L, advanceWorkflow as M, applyProfile as N, approveGate as O, type ProviderModelSettings as P, createAgent as Q, type Rule as R, type Skill as S, type ToolDefinition as T, defaultEngine as U, defineAgent as V, type WorkflowDef as W, defineAgentProfile as X, defineChannel as Y, defineTool as Z, dispatchWorkflow as _, type AgentProfile as a, getDefaultPersistence as a0, invokeAgent as a1, isChannelDefinition as a2, isCreatedAgent as a3, isRawTool as a4, parseWorkflowDef as a5, rawTool as a6, recoverRuns as a7, recoverWorkflows as a8, resolveAnyTool as a9, resolveTool as aa, startWorkflow as ab, verifyGithubWebhookSignature as ac, verifySlackRequestSignature as ad, waitingGate as ae, type ChannelDefinition as b, type AnyTool as c, type AgentRuntimeConfig as d, type AgentHooks as e, type RawTool as f, type ToolChoice as g, type CompactionConfig as h, type EngineRunInput as i, type EngineHooks as j, type EngineRunResult as k, type AgentCreateContext as l, type AgentDefinition as m, type ChannelAccepted as n, type ChannelContext as o, type ChannelDispatch as p, type ChannelMode as q, type ChannelResult as r, type ContextPack as s, type ContextPackItem as t, type DurabilityConfig as u, type DurableExecutionMeta as v, type InvokeOptions as w, type ProviderSettings as x, type RuleEnforcePoint as y, type SlackRequestSignatureOptions as z };