@ekairos/events 1.22.4-beta.development.0

package/README.md

@@ -0,0 +1,115 @@
+# @ekairos/events
+
+Context-first durable execution runtime for Ekairos.
+
+## Surface
+
+- `createContext`, `context`, `ContextEngine`
+- `createAiSdkReactor`, `createScriptedReactor`
+- `useContext`
+- `eventsDomain`
+- `getContextRuntime`, `getContextEnv`, `registerContextEnv`
+
+## Runtime model
+
+- `event_contexts`
+- `event_items`
+- `event_executions`
+- `event_steps`
+- `event_parts`
+- `event_trace_events`
+- `event_trace_runs`
+- `event_trace_spans`
+
+The aggregate is `context`. Executions, steps, parts, and items are scoped to a context.
+
+## Canonical Parts
+
+`event_parts` is the canonical content model for produced output.
+
+Rules:
+
+- `event_parts.part` is the source of truth for replay and inspection.
+- `event_items.content.parts` on output items is maintained as a compatibility mirror and is deprecated as a replay source.
+- Provider/model-specific values must live under `metadata`, never as first-class semantic fields.
+
+Canonical part kinds:
+
+- `content`
+- `reasoning`
+- `source`
+- `tool-call`
+- `tool-result`
+
+Each canonical part stores a `content` array. The entries inside that array define the payload type:
+
+- `text`
+- `file`
+- `json`
+- `source-url`
+- `source-document`
+
+Example tool result:
+
+```ts
+{
+  type: "tool-result",
+  toolCallId: "call_123",
+  toolName: "inspectCanvasRegion",
+  state: "output-available",
+  content: [
+    {
+      type: "text",
+      text: "Zoomed crop of the requested region.",
+    },
+    {
+      type: "file",
+      mediaType: "image/png",
+      filename: "inspect-region.png",
+      data: "iVBORw0KGgoAAAANSUhEUgAA...",
+    },
+  ],
+  metadata: {
+    provider: {
+      itemId: "fc_041cb...",
+    },
+  },
+}
+```
+
+The AI SDK bridge projects canonical parts to:
+
+- assistant messages with text/file/reasoning/source/tool-call parts
+- tool messages with `tool-result` or `tool-error`
+
+That means multipart tool outputs are replayed from `event_parts` instead of relying on the deprecated output-item mirror.
+
+## Install
+
+```bash
+pnpm add @ekairos/events
+```
+
+## Example
+
+```ts
+import { createContext, createAiSdkReactor } from "@ekairos/events";
+
+type Env = { orgId: string };
+
+export const supportContext = createContext<Env>("support.agent")
+  .context((stored, env) => ({
+    orgId: env.orgId,
+    ...stored.content,
+  }))
+  .narrative(() => "You are a precise assistant.")
+  .actions(() => ({}))
+  .reactor(createAiSdkReactor())
+  .build();
+```
+
+## Notes
+
+- Public continuity is context-based.
+- Provider-specific IDs such as `providerContextId` may still exist when an upstream provider requires them.
+- Runtime wiring for stores lives under `@ekairos/events/runtime`.

package/dist/codex.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import type { ContextEnvironment } from "./context.config.js";
+import type { ContextModelInit, ContextOptions, ContextReactParams, ContextShouldContinueArgs, ContextTool } from "./context.engine.js";
+import type { ContextKey } from "./context.registry.js";
+import type { StoredContext, ContextItem } from "./context.store.js";
+import type { ContextInstance } from "./context.js";
+export declare const DEFAULT_CODEX_TOOL_NAME = "codex";
+export declare const DEFAULT_CODEX_MODEL = "openai/gpt-5.2";
+export type CodexContextRuntimeMode = "local" | "remote" | "sandbox";
+export type CodexContextReasoningLevel = "off" | "low" | "medium" | "high";
+export type CodexContextRuntime = {
+    appServerUrl?: string;
+    repoPath?: string;
+    contextId?: string;
+    mode?: CodexContextRuntimeMode;
+    model?: string;
+    approvalPolicy?: string;
+    sandboxPolicy?: Record<string, unknown>;
+};
+export type CodexContextEnv = ContextEnvironment & {
+    sessionId: string;
+    runtime?: CodexContextRuntime;
+    reasoningLevel?: CodexContextReasoningLevel;
+    model?: string;
+};
+export type CodexToolInput = {
+    instruction: string;
+    files?: Array<{
+        url?: string;
+        path?: string;
+        mediaType?: string;
+        fileId?: string;
+    }>;
+};
+export type CodexToolOutput = {
+    contextId: string;
+    turnId: string;
+    assistantText: string;
+    reasoningText: string;
+    diff: string;
+    toolParts: any[];
+};
+export declare const codexToolInputSchema: z.ZodObject<{
+    instruction: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CodexExecuteArgs<Context, Env extends CodexContextEnv = CodexContextEnv> = {
+    context: StoredContext<Context>;
+    env: Env;
+    input: CodexToolInput;
+    toolName: string;
+};
+export type CodexContextBuilderConfig<Context, Env extends CodexContextEnv = CodexContextEnv> = {
+    key: ContextKey;
+    context: (context: StoredContext<Context>, env: Env) => Promise<Context> | Context;
+    executeCodex: (args: CodexExecuteArgs<Context, Env>) => Promise<CodexToolOutput>;
+    narrative?: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
+    system?: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
+    actions?: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
+    model?: ContextModelInit | ((context: StoredContext<Context>, env: Env) => ContextModelInit);
+    shouldContinue?: (args: ContextShouldContinueArgs<Context, Env>) => Promise<boolean> | boolean;
+    toolName?: string;
+    toolDescription?: string;
+    opts?: ContextOptions<Context, Env>;
+};
+export type CodexContextBuilder<Context, Env extends CodexContextEnv = CodexContextEnv> = {
+    key: ContextKey;
+    react(triggerEvent: ContextItem, params: ContextReactParams<Env>): Promise<{
+        contextId: string;
+        context: StoredContext<Context>;
+        triggerEventId: string;
+        reactionEventId: string;
+        executionId: string;
+    }>;
+    stream(triggerEvent: ContextItem, params: ContextReactParams<Env>): Promise<{
+        contextId: string;
+        context: StoredContext<Context>;
+        triggerEventId: string;
+        reactionEventId: string;
+        executionId: string;
+    }>;
+    register(): void;
+    config(): unknown;
+    build(): ContextInstance<Context, Env>;
+};
+export declare function buildDefaultCodexNarrative(content: unknown): string;
+export declare function didCodexToolExecute(event: Pick<{
+    content: any;
+}, "content">, toolName?: string): boolean;
+export declare function createCodexContextBuilder<Context, Env extends CodexContextEnv = CodexContextEnv>(config: CodexContextBuilderConfig<Context, Env>): CodexContextBuilder<Context, Env>;

package/dist/codex.js

@@ -0,0 +1,91 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { createContext } from "./context.js";
+import { didToolExecute } from "./context.toolcalls.js";
+export const DEFAULT_CODEX_TOOL_NAME = "codex";
+export const DEFAULT_CODEX_MODEL = "openai/gpt-5.2";
+export const codexToolInputSchema = z.object({
+    instruction: z
+        .string()
+        .describe("The coding instruction to execute for this request."),
+    files: z
+        .array(z.object({
+        url: z.string().optional(),
+        path: z.string().optional(),
+        mediaType: z.string().optional(),
+        fileId: z.string().optional(),
+    }))
+        .optional(),
+});
+function toRecord(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    return value;
+}
+function toString(value) {
+    if (typeof value !== "string")
+        return "";
+    return value.trim();
+}
+export function buildDefaultCodexNarrative(content) {
+    const record = toRecord(content);
+    const sessionId = toString(record.sessionId);
+    const repoUrl = toString(record.repoUrl);
+    const branchName = toString(record.branchName);
+    return [
+        "You are Codex running as an Ekairos Context.",
+        "",
+        "Execution style:",
+        "- Execute real coding work via the `codex` action.",
+        "- Keep answers concrete and implementation-oriented.",
+        "- Preserve repository and branch continuity across turns.",
+        "",
+        "Context:",
+        `- Session: ${sessionId || "unknown"}`,
+        `- Repository: ${repoUrl || "unknown"}`,
+        `- Branch: ${branchName || "unknown"}`,
+    ].join("\n");
+}
+export function didCodexToolExecute(event, toolName = DEFAULT_CODEX_TOOL_NAME) {
+    return didToolExecute(event, toolName);
+}
+export function createCodexContextBuilder(config) {
+    const toolName = config.toolName ?? DEFAULT_CODEX_TOOL_NAME;
+    const toolDescription = config.toolDescription ??
+        "Run the coding request using a Codex app server and stream output.";
+    const narrative = config.narrative ??
+        config.system ??
+        ((ctx) => buildDefaultCodexNarrative(ctx?.content));
+    const model = config.model ??
+        ((_ctx, env) => (typeof env.model === "string" && env.model.trim()) || DEFAULT_CODEX_MODEL);
+    const shouldContinue = config.shouldContinue ??
+        ((args) => !didToolExecute(args.reactionEvent, toolName));
+    let builder = createContext(config.key)
+        .context(config.context)
+        .narrative(narrative)
+        .actions(async (ctx, env) => {
+        const additional = config.actions ? await config.actions(ctx, env) : {};
+        if (Object.prototype.hasOwnProperty.call(additional, toolName)) {
+            throw new Error(`createCodexContextBuilder: action "${toolName}" is reserved for Codex.`);
+        }
+        return {
+            ...additional,
+            [toolName]: tool({
+                description: toolDescription,
+                inputSchema: codexToolInputSchema,
+                execute: async (input) => await config.executeCodex({
+                    context: ctx,
+                    env,
+                    input,
+                    toolName,
+                }),
+            }),
+        };
+    })
+        .model(model)
+        .shouldContinue(shouldContinue);
+    if (config.opts) {
+        builder = builder.opts(config.opts);
+    }
+    return builder;
+}

package/dist/context.builder.d.ts

@@ -0,0 +1,62 @@
+import type { ContextEnvironment } from "./context.config.js";
+import type { ContextSkillPackage } from "./context.skill.js";
+import { ContextEngine, type ContextModelInit, type ContextOptions, type ContextTool, type ShouldContinue, type ContextShouldContinueArgs, type ContextReactParams } from "./context.engine.js";
+import type { ContextReactor } from "./context.reactor.js";
+import type { ContextItem, StoredContext } from "./context.store.js";
+import { type ContextKey } from "./context.registry.js";
+export interface ContextConfig<Context, Env extends ContextEnvironment = ContextEnvironment> {
+    context: (context: StoredContext<Context>, env: Env) => Promise<Context> | Context;
+    expandEvents?: (events: ContextItem[], context: StoredContext<Context>, env: Env) => Promise<ContextItem[]> | ContextItem[];
+    narrative: (context: StoredContext<Context>, env: Env) => Promise<string> | string;
+    skills?: (context: StoredContext<Context>, env: Env) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
+    actions: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
+    /**
+     * @deprecated Use `actions()` instead.
+     */
+    tools?: (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
+    model?: ContextModelInit | ((context: StoredContext<Context>, env: Env) => ContextModelInit);
+    reactor?: ContextReactor<Context, Env>;
+    shouldContinue?: (args: ContextShouldContinueArgs<Context, Env>) => Promise<ShouldContinue> | ShouldContinue;
+    opts?: ContextOptions<Context, Env>;
+}
+export type ContextInstance<Context, Env extends ContextEnvironment = ContextEnvironment> = ContextEngine<Context, Env> & {
+    readonly __config: ContextConfig<Context, Env>;
+    readonly __contextKey?: ContextKey;
+};
+export declare function context<Context, Env extends ContextEnvironment = ContextEnvironment>(config: ContextConfig<Context, Env>): ContextInstance<Context, Env>;
+type AnyContextInitializer<Env extends ContextEnvironment> = (context: StoredContext<any>, env: Env) => Promise<any> | any;
+type InferContextFromInitializer<I extends AnyContextInitializer<any>> = Awaited<ReturnType<I>>;
+type BuilderSystemPrompt<Context, Env extends ContextEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<string> | string;
+type BuilderSkills<Context, Env extends ContextEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
+type BuilderTools<Context, Env extends ContextEnvironment> = (context: StoredContext<Context>, env: Env) => Promise<Record<string, ContextTool>> | Record<string, ContextTool>;
+type BuilderExpandEvents<Context, Env extends ContextEnvironment> = (events: ContextItem[], context: StoredContext<Context>, env: Env) => Promise<ContextItem[]> | ContextItem[];
+type BuilderShouldContinue<Context, Env extends ContextEnvironment> = (args: ContextShouldContinueArgs<Context, Env>) => Promise<ShouldContinue> | ShouldContinue;
+type BuilderModel<Context, Env extends ContextEnvironment> = ContextModelInit | ((context: StoredContext<Context>, env: Env) => ContextModelInit);
+export type RegistrableContextBuilder = {
+    key: ContextKey;
+    register: () => void;
+};
+type FluentContextBuilder<Context, Env extends ContextEnvironment> = {
+    key: ContextKey;
+    expandEvents(fn: BuilderExpandEvents<Context, Env>): FluentContextBuilder<Context, Env>;
+    narrative(fn: BuilderSystemPrompt<Context, Env>): FluentContextBuilder<Context, Env>;
+    system(fn: BuilderSystemPrompt<Context, Env>): FluentContextBuilder<Context, Env>;
+    skills(fn: BuilderSkills<Context, Env>): FluentContextBuilder<Context, Env>;
+    actions(fn: BuilderTools<Context, Env>): FluentContextBuilder<Context, Env>;
+    tools(fn: BuilderTools<Context, Env>): FluentContextBuilder<Context, Env>;
+    model(model: BuilderModel<Context, Env>): FluentContextBuilder<Context, Env>;
+    reactor(reactor: ContextReactor<Context, Env>): FluentContextBuilder<Context, Env>;
+    shouldContinue(fn: BuilderShouldContinue<Context, Env>): FluentContextBuilder<Context, Env>;
+    opts(opts: ContextOptions<Context, Env>): FluentContextBuilder<Context, Env>;
+    react(triggerEvent: ContextItem, params: ContextReactParams<Env>): ReturnType<ContextEngine<Context, Env>["react"]>;
+    stream(triggerEvent: ContextItem, params: ContextReactParams<Env>): ReturnType<ContextEngine<Context, Env>["react"]>;
+    register(): void;
+    config(): ContextConfig<Context, Env>;
+    build(): ContextInstance<Context, Env>;
+};
+type CreateContextEntry<Env extends ContextEnvironment> = {
+    context<Initializer extends AnyContextInitializer<Env>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env>;
+    initialize<Initializer extends AnyContextInitializer<Env>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env>;
+};
+export declare function createContext<Env extends ContextEnvironment = ContextEnvironment>(key: ContextKey): CreateContextEntry<Env>;
+export {};

package/dist/context.builder.js

@@ -0,0 +1,143 @@
+import { ContextEngine, } from "./context.engine.js";
+import { registerContext } from "./context.registry.js";
+function isDynamicModelSelector(model) {
+    return typeof model === "function" && model.length >= 1;
+}
+export function context(config) {
+    class FunctionalContext extends ContextEngine {
+        constructor() {
+            super(config.opts, config.reactor);
+            this.__config = config;
+        }
+        async initialize(contextValue, env) {
+            return config.context(contextValue, env);
+        }
+        async expandEvents(events, contextValue, env) {
+            if (config.expandEvents)
+                return config.expandEvents(events, contextValue, env);
+            return super.expandEvents(events, contextValue, env);
+        }
+        async buildSystemPrompt(contextValue, env) {
+            if (config.narrative)
+                return config.narrative(contextValue, env);
+            throw new Error("Context config is missing narrative()");
+        }
+        async buildSkills(contextValue, env) {
+            if (config.skills)
+                return config.skills(contextValue, env);
+            return [];
+        }
+        async buildTools(contextValue, env) {
+            if (config.actions)
+                return config.actions(contextValue, env);
+            if (config.tools)
+                return config.tools(contextValue, env);
+            throw new Error("Context config is missing actions()");
+        }
+        getModel(contextValue, env) {
+            if (isDynamicModelSelector(config.model))
+                return config.model(contextValue, env);
+            return config.model ?? super.getModel(contextValue, env);
+        }
+        async shouldContinue(args) {
+            if (config.shouldContinue)
+                return config.shouldContinue(args);
+            return true;
+        }
+    }
+    const instance = new FunctionalContext();
+    return Object.assign(instance, { __config: config });
+}
+function assertConfigComplete(config) {
+    if (!config.context) {
+        throw new Error("createContext: you must define context() before building the Context.");
+    }
+    if (!config.narrative) {
+        throw new Error("createContext: you must define narrative() before building the Context.");
+    }
+    if (!config.actions && !config.tools) {
+        throw new Error("createContext: you must define actions() before building the Context.");
+    }
+}
+export function createContext(key) {
+    const initializeBuilder = (initializer) => {
+        const typedInitializer = (ctx, env) => initializer(ctx, env);
+        const fluentState = {
+            context: typedInitializer,
+        };
+        let cached = null;
+        const getOrBuild = () => {
+            assertConfigComplete(fluentState);
+            if (!cached) {
+                const config = fluentState;
+                cached = Object.assign(context(config), { __contextKey: key });
+                registerContext(key, () => cached);
+            }
+            return cached;
+        };
+        const builder = {
+            key,
+            expandEvents(fn) {
+                fluentState.expandEvents = fn;
+                return builder;
+            },
+            narrative(narrative) {
+                fluentState.narrative = narrative;
+                return builder;
+            },
+            system(system) {
+                fluentState.narrative = system;
+                return builder;
+            },
+            skills(skillsFactory) {
+                fluentState.skills = skillsFactory;
+                return builder;
+            },
+            actions(actionsFactory) {
+                fluentState.actions = actionsFactory;
+                return builder;
+            },
+            tools(toolsFactory) {
+                fluentState.actions = toolsFactory;
+                return builder;
+            },
+            model(model) {
+                fluentState.model = model;
+                return builder;
+            },
+            reactor(reactor) {
+                fluentState.reactor = reactor;
+                return builder;
+            },
+            shouldContinue(fn) {
+                fluentState.shouldContinue = fn;
+                return builder;
+            },
+            opts(options) {
+                fluentState.opts = options;
+                return builder;
+            },
+            react(triggerEvent, params) {
+                return getOrBuild().react(triggerEvent, params);
+            },
+            stream(triggerEvent, params) {
+                return builder.react(triggerEvent, params);
+            },
+            register() {
+                getOrBuild();
+            },
+            config() {
+                assertConfigComplete(fluentState);
+                return fluentState;
+            },
+            build() {
+                return getOrBuild();
+            },
+        };
+        return builder;
+    };
+    return {
+        context: initializeBuilder,
+        initialize: initializeBuilder,
+    };
+}

package/dist/context.config.d.ts

@@ -0,0 +1,9 @@
+import type { ContextStore } from "./context.store.js";
+import type { ConcreteDomain } from "@ekairos/domain";
+export type ContextEnvironment = Record<string, unknown>;
+export type ContextRuntime = {
+    store: ContextStore;
+    db: any;
+    domain?: ConcreteDomain<any, any>;
+};
+export declare function coerceContextRuntime(value: any): Promise<ContextRuntime>;

package/dist/context.config.js

@@ -0,0 +1,30 @@
+const runtimeByDb = new WeakMap();
+export async function coerceContextRuntime(value) {
+    if (!value) {
+        throw new Error("Context runtime resolver returned no value.");
+    }
+    if (typeof value === "object" && value.store) {
+        return value;
+    }
+    const dbCandidate = typeof value === "object" && value !== null && "db" in value
+        ? value.db
+        : value;
+    if (!dbCandidate) {
+        throw new Error("Context runtime resolver did not provide a database or store.");
+    }
+    if (typeof dbCandidate === "object" && dbCandidate !== null) {
+        const cached = runtimeByDb.get(dbCandidate);
+        if (cached)
+            return cached;
+    }
+    const { InstantStore } = await import("./stores/instant.store.js");
+    const runtime = {
+        store: new InstantStore(dbCandidate),
+        db: dbCandidate,
+        domain: typeof value === "object" ? value.domain : undefined,
+    };
+    if (typeof dbCandidate === "object" && dbCandidate !== null) {
+        runtimeByDb.set(dbCandidate, runtime);
+    }
+    return runtime;
+}

package/dist/context.contract.d.ts

@@ -0,0 +1,47 @@
+export type Transition<From extends string, To extends string> = {
+    from: From;
+    to: To;
+};
+export declare const CONTEXT_STATUSES: readonly ["open_idle", "open_streaming", "closed"];
+export type ContextStatus = (typeof CONTEXT_STATUSES)[number];
+export declare const EXECUTION_STATUSES: readonly ["executing", "completed", "failed"];
+export type ExecutionStatus = (typeof EXECUTION_STATUSES)[number];
+export declare const STEP_STATUSES: readonly ["running", "completed", "failed"];
+export type StepStatus = (typeof STEP_STATUSES)[number];
+export declare const STEP_KINDS: readonly ["message", "action_execute", "action_result"];
+export type StepKind = (typeof STEP_KINDS)[number];
+export declare const ITEM_STATUSES: readonly ["stored", "pending", "completed"];
+export type ItemStatus = (typeof ITEM_STATUSES)[number];
+export declare const ITEM_TYPES: readonly ["input", "output"];
+export type ItemType = (typeof ITEM_TYPES)[number];
+export declare const CHANNELS: readonly ["web", "whatsapp", "email"];
+export type Channel = (typeof CHANNELS)[number];
+export declare const TRACE_EVENT_KINDS: readonly ["workflow.run", "workflow.step", "context.run", "context.lifecycle", "context.execution", "context.item", "context.review", "context.step", "context.part", "context.llm"];
+export type TraceEventKind = (typeof TRACE_EVENT_KINDS)[number];
+export declare const STREAM_LIFECYCLE_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish"];
+export declare const STREAM_TEXT_CHUNK_TYPES: readonly ["chunk.text_start", "chunk.text_delta", "chunk.text_end"];
+export declare const STREAM_REASONING_CHUNK_TYPES: readonly ["chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end"];
+export declare const STREAM_ACTION_CHUNK_TYPES: readonly ["chunk.action_input_start", "chunk.action_input_delta", "chunk.action_input_available", "chunk.action_output_available", "chunk.action_output_error"];
+export declare const STREAM_SOURCE_CHUNK_TYPES: readonly ["chunk.source_url", "chunk.source_document", "chunk.file"];
+export declare const STREAM_METADATA_CHUNK_TYPES: readonly ["chunk.message_metadata", "chunk.response_metadata"];
+export declare const STREAM_ERROR_CHUNK_TYPES: readonly ["chunk.error", "chunk.unknown"];
+export declare const CONTEXT_STREAM_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish", "chunk.text_start", "chunk.text_delta", "chunk.text_end", "chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end", "chunk.action_input_start", "chunk.action_input_delta", "chunk.action_input_available", "chunk.action_output_available", "chunk.action_output_error", "chunk.source_url", "chunk.source_document", "chunk.file", "chunk.message_metadata", "chunk.response_metadata", "chunk.error", "chunk.unknown"];
+export type ContextStreamChunkType = (typeof CONTEXT_STREAM_CHUNK_TYPES)[number];
+export declare function isContextStreamChunkType(value: string): value is ContextStreamChunkType;
+export type ContextTransition = Transition<"open_idle" | "open_streaming" | "closed", "open_idle" | "open_streaming" | "closed">;
+export type ExecutionTransition = Transition<"executing", "completed" | "failed">;
+export type StepTransition = Transition<"running", "completed" | "failed">;
+export type ItemTransition = Transition<"stored" | "pending", "pending" | "completed">;
+export declare const CONTEXT_TRANSITIONS: readonly ContextTransition[];
+export declare const EXECUTION_TRANSITIONS: readonly ExecutionTransition[];
+export declare const STEP_TRANSITIONS: readonly StepTransition[];
+export declare const ITEM_TRANSITIONS: readonly ItemTransition[];
+export declare function canContextTransition(from: string, to: string): boolean;
+export declare function canExecutionTransition(from: string, to: string): boolean;
+export declare function canStepTransition(from: string, to: string): boolean;
+export declare function canItemTransition(from: string, to: string): boolean;
+export declare function assertContextTransition(from: string, to: string): void;
+export declare function assertExecutionTransition(from: string, to: string): void;
+export declare function assertStepTransition(from: string, to: string): void;
+export declare function assertItemTransition(from: string, to: string): void;
+export declare function assertContextPartKey(stepId: string, idx: number, key: string): void;