@perstack/core 0.0.53 → 0.0.54

package/dist/src/schemas/runtime.d.ts

@@ -0,0 +1,1317 @@
+import { z } from "zod";
+import type { Checkpoint } from "./checkpoint.js";
+import type { Expert } from "./expert.js";
+import type { ExpertMessage, InstructionMessage, Message, ToolMessage, UserMessage } from "./message.js";
+import type { PerstackConfigSkill, ReasoningBudget } from "./perstack-toml.js";
+import type { ProviderConfig } from "./provider-config.js";
+import type { Step } from "./step.js";
+import type { ToolCall } from "./tool-call.js";
+import type { ToolResult } from "./tool-result.js";
+import type { Usage } from "./usage.js";
+/** Parse an expert key into its components */
+export declare function parseExpertKey(expertKey: string): {
+    key: string;
+    name: string;
+    version?: string;
+    tag?: string;
+};
+/** Input for a run (text or interactive tool call result) */
+export interface RunInput {
+    /** Text query */
+    text?: string;
+    /** Interactive tool call result (when continuing from interactive tool) */
+    interactiveToolCallResult?: {
+        toolCallId: string;
+        toolName: string;
+        skillName: string;
+        text: string;
+    };
+}
+/** Runtime settings for an Expert run */
+export interface RunSetting {
+    /** Model name to use */
+    model: string;
+    /** Provider configuration */
+    providerConfig: ProviderConfig;
+    /** Job ID this run belongs to */
+    jobId: string;
+    /** Unique run identifier */
+    runId: string;
+    /** Expert key to run */
+    expertKey: string;
+    /** Input for the run */
+    input: RunInput;
+    /** Map of expert keys to Expert definitions */
+    experts: Record<string, Expert>;
+    /** Reasoning budget for native LLM reasoning (extended thinking). Defaults to "low". Use "none" or 0 to disable. */
+    reasoningBudget: ReasoningBudget;
+    /** Maximum retries on generation failure */
+    maxRetries: number;
+    /** Timeout per generation in milliseconds */
+    timeout: number;
+    /** Unix timestamp when run started */
+    startedAt: number;
+    /** Unix timestamp of last update */
+    updatedAt: number;
+    /** Perstack API base URL */
+    perstackApiBaseUrl: string;
+    /** Perstack API key */
+    perstackApiKey?: string;
+    /** Custom command for @perstack/base */
+    perstackBaseSkillCommand?: string[];
+    /** Environment variables to pass to skills */
+    env: Record<string, string>;
+    /** HTTP proxy URL for API requests */
+    proxyUrl?: string;
+    /** Enable verbose output for build processes */
+    verbose?: boolean;
+}
+/** Parameters for starting a run */
+export interface RunParams {
+    /** Run settings */
+    setting: RunSetting;
+    /** Optional checkpoint to resume from */
+    checkpoint?: Checkpoint;
+}
+/** Expert input type before schema transformation (skills without name, optional fields) */
+type ExpertInput = {
+    name: string;
+    version: string;
+    description?: string;
+    instruction: string;
+    skills?: Record<string, PerstackConfigSkill>;
+    delegates?: string[];
+    tags?: string[];
+};
+/** Input type for runParamsSchema (before defaults/transforms) */
+export type RunParamsInput = {
+    setting: {
+        model: string;
+        providerConfig: ProviderConfig;
+        jobId?: string;
+        runId?: string;
+        expertKey: string;
+        input: RunInput;
+        experts?: Record<string, ExpertInput>;
+        reasoningBudget?: ReasoningBudget;
+        maxRetries?: number;
+        timeout?: number;
+        startedAt?: number;
+        updatedAt?: number;
+        perstackApiBaseUrl?: string;
+        perstackApiKey?: string;
+        perstackBaseSkillCommand?: string[];
+        env?: Record<string, string>;
+        proxyUrl?: string;
+        verbose?: boolean;
+    };
+    checkpoint?: Checkpoint;
+};
+export declare const runSettingSchema: z.ZodObject<{
+    model: z.ZodString;
+    providerConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        providerName: z.ZodLiteral<"anthropic">;
+        apiKey: z.ZodString;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"google">;
+        apiKey: z.ZodString;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"openai">;
+        apiKey: z.ZodString;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"ollama">;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"azure-openai">;
+        apiKey: z.ZodString;
+        resourceName: z.ZodOptional<z.ZodString>;
+        apiVersion: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        useDeploymentBasedUrls: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"amazon-bedrock">;
+        accessKeyId: z.ZodString;
+        secretAccessKey: z.ZodString;
+        region: z.ZodString;
+        sessionToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"google-vertex">;
+        project: z.ZodOptional<z.ZodString>;
+        location: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        providerName: z.ZodLiteral<"deepseek">;
+        apiKey: z.ZodString;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>], "providerName">;
+    jobId: z.ZodString;
+    runId: z.ZodString;
+    expertKey: z.ZodString;
+    input: z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        interactiveToolCallResult: z.ZodOptional<z.ZodObject<{
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            skillName: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    experts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        instruction: z.ZodString;
+        skills: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"mcpStdioSkill">;
+            description: z.ZodOptional<z.ZodString>;
+            args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            rule: z.ZodOptional<z.ZodString>;
+            pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            command: z.ZodString;
+            packageName: z.ZodOptional<z.ZodString>;
+            requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"mcpSseSkill">;
+            description: z.ZodOptional<z.ZodString>;
+            rule: z.ZodOptional<z.ZodString>;
+            pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            endpoint: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"interactiveSkill">;
+            description: z.ZodOptional<z.ZodString>;
+            rule: z.ZodOptional<z.ZodString>;
+            tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                inputJsonSchema: z.ZodString;
+            }, z.core.$strip>>, z.ZodTransform<{
+                [k: string]: {
+                    name: string;
+                    inputJsonSchema: string;
+                    description?: string | undefined;
+                };
+            }, Record<string, {
+                inputJsonSchema: string;
+                description?: string | undefined;
+            }>>>;
+        }, z.core.$strip>], "type">>>>, z.ZodTransform<{
+            [k: string]: {
+                type: "mcpStdioSkill";
+                name: string;
+                pick: string[];
+                omit: string[];
+                command: string;
+                args: string[];
+                requiredEnv: string[];
+                description?: string | undefined;
+                rule?: string | undefined;
+                packageName?: string | undefined;
+            } | {
+                type: "mcpSseSkill";
+                name: string;
+                pick: string[];
+                omit: string[];
+                endpoint: string;
+                description?: string | undefined;
+                rule?: string | undefined;
+            } | {
+                type: "interactiveSkill";
+                name: string;
+                tools: {
+                    [k: string]: {
+                        name: string;
+                        inputJsonSchema: string;
+                        description?: string | undefined;
+                    };
+                };
+                description?: string | undefined;
+                rule?: string | undefined;
+            };
+        }, Record<string, {
+            type: "mcpStdioSkill";
+            args: string[];
+            pick: string[];
+            omit: string[];
+            command: string;
+            requiredEnv: string[];
+            description?: string | undefined;
+            rule?: string | undefined;
+            packageName?: string | undefined;
+        } | {
+            type: "mcpSseSkill";
+            pick: string[];
+            omit: string[];
+            endpoint: string;
+            description?: string | undefined;
+            rule?: string | undefined;
+        } | {
+            type: "interactiveSkill";
+            tools: {
+                [k: string]: {
+                    name: string;
+                    inputJsonSchema: string;
+                    description?: string | undefined;
+                };
+            };
+            description?: string | undefined;
+            rule?: string | undefined;
+        }>>>;
+        delegates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        minRuntimeVersion: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>>;
+        providerTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        providerSkills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"builtin">;
+            skillId: z.ZodEnum<{
+                pdf: "pdf";
+                docx: "docx";
+                pptx: "pptx";
+                xlsx: "xlsx";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"custom">;
+            name: z.ZodString;
+            definition: z.ZodString;
+        }, z.core.$strip>], "type">>>;
+        providerToolOptions: z.ZodOptional<z.ZodObject<{
+            webSearch: z.ZodOptional<z.ZodObject<{
+                maxUses: z.ZodOptional<z.ZodNumber>;
+                allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            webFetch: z.ZodOptional<z.ZodObject<{
+                maxUses: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            fileSearch: z.ZodOptional<z.ZodObject<{
+                vectorStoreIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                maxNumResults: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    reasoningBudget: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>, z.ZodNumber]>>;
+    maxRetries: z.ZodNumber;
+    timeout: z.ZodNumber;
+    startedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    perstackApiBaseUrl: z.ZodString;
+    perstackApiKey: z.ZodOptional<z.ZodString>;
+    perstackBaseSkillCommand: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    proxyUrl: z.ZodOptional<z.ZodString>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const runParamsSchema: z.ZodObject<{
+    setting: z.ZodObject<{
+        model: z.ZodString;
+        providerConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            providerName: z.ZodLiteral<"anthropic">;
+            apiKey: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"google">;
+            apiKey: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"openai">;
+            apiKey: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"ollama">;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"azure-openai">;
+            apiKey: z.ZodString;
+            resourceName: z.ZodOptional<z.ZodString>;
+            apiVersion: z.ZodOptional<z.ZodString>;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            useDeploymentBasedUrls: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"amazon-bedrock">;
+            accessKeyId: z.ZodString;
+            secretAccessKey: z.ZodString;
+            region: z.ZodString;
+            sessionToken: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"google-vertex">;
+            project: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            providerName: z.ZodLiteral<"deepseek">;
+            apiKey: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>], "providerName">;
+        jobId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        runId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        expertKey: z.ZodString;
+        input: z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+            interactiveToolCallResult: z.ZodOptional<z.ZodObject<{
+                toolCallId: z.ZodString;
+                toolName: z.ZodString;
+                skillName: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        experts: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            version: z.ZodString;
+            providerToolOptions: z.ZodOptional<z.ZodObject<{
+                webSearch: z.ZodOptional<z.ZodObject<{
+                    maxUses: z.ZodOptional<z.ZodNumber>;
+                    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                webFetch: z.ZodOptional<z.ZodObject<{
+                    maxUses: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                fileSearch: z.ZodOptional<z.ZodObject<{
+                    vectorStoreIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    maxNumResults: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            instruction: z.ZodString;
+            skills: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"mcpStdioSkill">;
+                description: z.ZodOptional<z.ZodString>;
+                args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                rule: z.ZodOptional<z.ZodString>;
+                pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                command: z.ZodString;
+                packageName: z.ZodOptional<z.ZodString>;
+                requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"mcpSseSkill">;
+                description: z.ZodOptional<z.ZodString>;
+                rule: z.ZodOptional<z.ZodString>;
+                pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                endpoint: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"interactiveSkill">;
+                description: z.ZodOptional<z.ZodString>;
+                rule: z.ZodOptional<z.ZodString>;
+                tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    description: z.ZodOptional<z.ZodString>;
+                    inputJsonSchema: z.ZodString;
+                }, z.core.$strip>>, z.ZodTransform<{
+                    [k: string]: {
+                        name: string;
+                        inputJsonSchema: string;
+                        description?: string | undefined;
+                    };
+                }, Record<string, {
+                    inputJsonSchema: string;
+                    description?: string | undefined;
+                }>>>;
+            }, z.core.$strip>], "type">>>>, z.ZodTransform<{
+                [k: string]: {
+                    type: "mcpStdioSkill";
+                    name: string;
+                    pick: string[];
+                    omit: string[];
+                    command: string;
+                    args: string[];
+                    requiredEnv: string[];
+                    description?: string | undefined;
+                    rule?: string | undefined;
+                    packageName?: string | undefined;
+                } | {
+                    type: "mcpSseSkill";
+                    name: string;
+                    pick: string[];
+                    omit: string[];
+                    endpoint: string;
+                    description?: string | undefined;
+                    rule?: string | undefined;
+                } | {
+                    type: "interactiveSkill";
+                    name: string;
+                    tools: {
+                        [k: string]: {
+                            name: string;
+                            inputJsonSchema: string;
+                            description?: string | undefined;
+                        };
+                    };
+                    description?: string | undefined;
+                    rule?: string | undefined;
+                };
+            }, Record<string, {
+                type: "mcpStdioSkill";
+                args: string[];
+                pick: string[];
+                omit: string[];
+                command: string;
+                requiredEnv: string[];
+                description?: string | undefined;
+                rule?: string | undefined;
+                packageName?: string | undefined;
+            } | {
+                type: "mcpSseSkill";
+                pick: string[];
+                omit: string[];
+                endpoint: string;
+                description?: string | undefined;
+                rule?: string | undefined;
+            } | {
+                type: "interactiveSkill";
+                tools: {
+                    [k: string]: {
+                        name: string;
+                        inputJsonSchema: string;
+                        description?: string | undefined;
+                    };
+                };
+                description?: string | undefined;
+                rule?: string | undefined;
+            }>>>;
+            delegates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            minRuntimeVersion: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>>;
+            providerTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            providerSkills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"builtin">;
+                skillId: z.ZodEnum<{
+                    pdf: "pdf";
+                    docx: "docx";
+                    pptx: "pptx";
+                    xlsx: "xlsx";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"custom">;
+                name: z.ZodString;
+                definition: z.ZodString;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>>>>, z.ZodTransform<{
+            [k: string]: {
+                key: string;
+                name: string;
+                version: string;
+                instruction: string;
+                skills: {
+                    [k: string]: {
+                        type: "mcpStdioSkill";
+                        name: string;
+                        pick: string[];
+                        omit: string[];
+                        command: string;
+                        args: string[];
+                        requiredEnv: string[];
+                        description?: string | undefined;
+                        rule?: string | undefined;
+                        packageName?: string | undefined;
+                    } | {
+                        type: "mcpSseSkill";
+                        name: string;
+                        pick: string[];
+                        omit: string[];
+                        endpoint: string;
+                        description?: string | undefined;
+                        rule?: string | undefined;
+                    } | {
+                        type: "interactiveSkill";
+                        name: string;
+                        tools: {
+                            [k: string]: {
+                                name: string;
+                                inputJsonSchema: string;
+                                description?: string | undefined;
+                            };
+                        };
+                        description?: string | undefined;
+                        rule?: string | undefined;
+                    };
+                };
+                delegates: string[];
+                tags: string[];
+                minRuntimeVersion: `v${number}.${number}`;
+                description?: string | undefined;
+                providerTools?: string[] | undefined;
+                providerSkills?: ({
+                    type: "builtin";
+                    skillId: "pdf" | "docx" | "pptx" | "xlsx";
+                } | {
+                    type: "custom";
+                    name: string;
+                    definition: string;
+                })[] | undefined;
+                providerToolOptions?: {
+                    webSearch?: {
+                        maxUses?: number | undefined;
+                        allowedDomains?: string[] | undefined;
+                    } | undefined;
+                    webFetch?: {
+                        maxUses?: number | undefined;
+                    } | undefined;
+                    fileSearch?: {
+                        vectorStoreIds?: string[] | undefined;
+                        maxNumResults?: number | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+        }, Record<string, {
+            name: string;
+            version: string;
+            instruction: string;
+            skills: {
+                [k: string]: {
+                    type: "mcpStdioSkill";
+                    name: string;
+                    pick: string[];
+                    omit: string[];
+                    command: string;
+                    args: string[];
+                    requiredEnv: string[];
+                    description?: string | undefined;
+                    rule?: string | undefined;
+                    packageName?: string | undefined;
+                } | {
+                    type: "mcpSseSkill";
+                    name: string;
+                    pick: string[];
+                    omit: string[];
+                    endpoint: string;
+                    description?: string | undefined;
+                    rule?: string | undefined;
+                } | {
+                    type: "interactiveSkill";
+                    name: string;
+                    tools: {
+                        [k: string]: {
+                            name: string;
+                            inputJsonSchema: string;
+                            description?: string | undefined;
+                        };
+                    };
+                    description?: string | undefined;
+                    rule?: string | undefined;
+                };
+            };
+            delegates: string[];
+            tags: string[];
+            minRuntimeVersion: `v${number}.${number}`;
+            description?: string | undefined;
+            providerToolOptions?: {
+                webSearch?: {
+                    maxUses?: number | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
+                webFetch?: {
+                    maxUses?: number | undefined;
+                } | undefined;
+                fileSearch?: {
+                    vectorStoreIds?: string[] | undefined;
+                    maxNumResults?: number | undefined;
+                } | undefined;
+            } | undefined;
+            providerTools?: string[] | undefined;
+            providerSkills?: ({
+                type: "builtin";
+                skillId: "pdf" | "docx" | "pptx" | "xlsx";
+            } | {
+                type: "custom";
+                name: string;
+                definition: string;
+            })[] | undefined;
+        }>>>;
+        reasoningBudget: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>, z.ZodNumber]>>>;
+        maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        startedAt: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        updatedAt: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        perstackApiBaseUrl: z.ZodDefault<z.ZodOptional<z.ZodURL>>;
+        perstackApiKey: z.ZodOptional<z.ZodString>;
+        perstackBaseSkillCommand: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        verbose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    checkpoint: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        jobId: z.ZodString;
+        runId: z.ZodString;
+        status: z.ZodEnum<{
+            init: "init";
+            proceeding: "proceeding";
+            completed: "completed";
+            stoppedByInteractiveTool: "stoppedByInteractiveTool";
+            stoppedByDelegate: "stoppedByDelegate";
+            stoppedByError: "stoppedByError";
+            stoppedByCancellation: "stoppedByCancellation";
+        }>;
+        stepNumber: z.ZodNumber;
+        messages: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"instructionMessage">;
+            contents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"textPart">;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+            cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"userMessage">;
+            contents: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"textPart">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"imageUrlPart">;
+                url: z.ZodURL;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"imageInlinePart">;
+                encodedData: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"imageBinaryPart">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"fileUrlPart">;
+                url: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"fileInlinePart">;
+                encodedData: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"fileBinaryPart">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>]>>;
+            cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"expertMessage">;
+            contents: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"textPart">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"toolCallPart">;
+                toolCallId: z.ZodString;
+                toolName: z.ZodString;
+                args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"thinkingPart">;
+                thinking: z.ZodString;
+                signature: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+            cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"toolMessage">;
+            contents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"toolResultPart">;
+                toolCallId: z.ZodString;
+                toolName: z.ZodString;
+                contents: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"textPart">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"imageInlinePart">;
+                    encodedData: z.ZodString;
+                    mimeType: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"fileInlinePart">;
+                    encodedData: z.ZodString;
+                    mimeType: z.ZodString;
+                }, z.core.$strip>]>>;
+                isError: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            cache: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>>;
+        expert: z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        delegateTo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            expert: z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strip>;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            query: z.ZodString;
+        }, z.core.$strip>>>;
+        delegatedBy: z.ZodOptional<z.ZodObject<{
+            expert: z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strip>;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            checkpointId: z.ZodString;
+            runId: z.ZodString;
+        }, z.core.$strip>>;
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            cachedInputTokens: z.ZodNumber;
+        }, z.core.$strip>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        contextWindowUsage: z.ZodOptional<z.ZodNumber>;
+        pendingToolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            skillName: z.ZodString;
+            toolName: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        partialToolResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            skillName: z.ZodString;
+            toolName: z.ZodString;
+            result: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"textPart">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"imageUrlPart">;
+                url: z.ZodURL;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"imageInlinePart">;
+                encodedData: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"imageBinaryPart">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"fileUrlPart">;
+                url: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"fileInlinePart">;
+                encodedData: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"fileBinaryPart">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"toolCallPart">;
+                toolCallId: z.ZodString;
+                toolName: z.ZodString;
+                args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"toolResultPart">;
+                toolCallId: z.ZodString;
+                toolName: z.ZodString;
+                contents: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"textPart">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"imageInlinePart">;
+                    encodedData: z.ZodString;
+                    mimeType: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"fileInlinePart">;
+                    encodedData: z.ZodString;
+                    mimeType: z.ZodString;
+                }, z.core.$strip>]>>;
+                isError: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"thinkingPart">;
+                thinking: z.ZodString;
+                signature: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>>>;
+        metadata: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        error: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            message: z.ZodString;
+            statusCode: z.ZodOptional<z.ZodNumber>;
+            isRetryable: z.ZodBoolean;
+        }, z.core.$strip>>;
+        retryCount: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Expert state events - state machine transitions during execution.
+ * All events contain deeply serializable properties for checkpoint persistence.
+ */
+type ExpertStatePayloads = {
+    startRun: {
+        initialCheckpoint: Checkpoint;
+        inputMessages: (InstructionMessage | UserMessage | ToolMessage)[];
+    };
+    /** Resume from stoppedByDelegate or stoppedByInteractiveTool */
+    resumeFromStop: {
+        checkpoint: Checkpoint;
+    };
+    /** Proceed to CallingInteractiveTools from ResumingFromStop */
+    proceedToInteractiveTools: {
+        pendingToolCalls: ToolCall[];
+        partialToolResults: ToolResult[];
+    };
+    startGeneration: {
+        messages: Message[];
+    };
+    retry: {
+        reason: string;
+        newMessages: (UserMessage | ExpertMessage | ToolMessage)[];
+        toolCalls?: ToolCall[];
+        toolResults?: ToolResult[];
+        usage: Usage;
+    };
+    callTools: {
+        newMessage: ExpertMessage;
+        toolCalls: ToolCall[];
+        usage: Usage;
+    };
+    /** Internal: MCP tools finished, proceed to delegates */
+    finishMcpTools: {
+        partialToolResults: ToolResult[];
+        pendingToolCalls: ToolCall[];
+    };
+    /** Internal: No delegates, proceed to interactive tools */
+    skipDelegates: object;
+    resolveToolResults: {
+        toolResults: ToolResult[];
+    };
+    finishToolCall: {
+        newMessages: (UserMessage | ToolMessage)[];
+    };
+    resumeToolCalls: {
+        pendingToolCalls: ToolCall[];
+        partialToolResults: ToolResult[];
+    };
+    continueToNextStep: {
+        checkpoint: Checkpoint;
+        step: Step;
+        nextCheckpoint: Checkpoint;
+    };
+    stopRunByInteractiveTool: {
+        checkpoint: Checkpoint;
+        step: Step;
+    };
+    stopRunByDelegate: {
+        checkpoint: Checkpoint;
+        step: Step;
+    };
+    stopRunByError: {
+        checkpoint: Checkpoint;
+        step: Step;
+        error: {
+            name: string;
+            message: string;
+            statusCode?: number;
+            isRetryable: boolean;
+        };
+    };
+    completeRun: {
+        checkpoint: Checkpoint;
+        step: Step;
+        text: string;
+        usage: Usage;
+    };
+};
+/**
+ * Streaming events - reasoning/result streaming during LLM generation.
+ * Moved from RuntimeEvent to RunEvent to support proper attribution in parallel runs.
+ */
+type StreamingPayloads = {
+    /** Start of reasoning stream (display hint) */
+    startStreamingReasoning: object;
+    /** Streaming reasoning delta */
+    streamReasoning: {
+        delta: string;
+    };
+    /** Reasoning stream completion (extended thinking / test-time scaling) */
+    completeStreamingReasoning: {
+        text: string;
+    };
+    /** Start of run result stream (display hint) */
+    startStreamingRunResult: object;
+    /** Streaming run result delta */
+    streamRunResult: {
+        delta: string;
+    };
+    /** Run result stream completion */
+    completeStreamingRunResult: {
+        text: string;
+    };
+};
+/** Base properties for all run events (both state and streaming) */
+export interface BaseEvent {
+    /** Unique event ID */
+    id: string;
+    /** Expert key that emitted this event */
+    expertKey: string;
+    /** Unix timestamp when event was emitted */
+    timestamp: number;
+    /** Job ID this event belongs to */
+    jobId: string;
+    /** Run ID this event belongs to */
+    runId: string;
+    /** Step number when event was emitted */
+    stepNumber: number;
+}
+/** Expert state event types (state machine transitions) */
+export type ExpertStateEventType = keyof ExpertStatePayloads;
+/** Streaming event types */
+export type StreamingEventType = keyof StreamingPayloads;
+/** All run event types (state + streaming) */
+export type EventType = ExpertStateEventType | StreamingEventType;
+/** Union type of expert state events */
+export type ExpertStateEvent = {
+    [K in ExpertStateEventType]: BaseEvent & {
+        type: K;
+    } & ExpertStatePayloads[K];
+}[ExpertStateEventType];
+/** Union type of streaming events */
+export type StreamingEvent = {
+    [K in StreamingEventType]: BaseEvent & {
+        type: K;
+    } & StreamingPayloads[K];
+}[StreamingEventType];
+/** Union type of all run events (state machine + streaming) */
+export type RunEvent = ExpertStateEvent | StreamingEvent;
+/** Extract a specific event type */
+export type EventForType<T extends EventType> = Extract<RunEvent, {
+    type: T;
+}>;
+/** Factory function to create expert state events */
+export declare function createEvent<T extends ExpertStateEventType>(type: T): (setting: RunSetting, checkpoint: Checkpoint, data: Omit<Extract<ExpertStateEvent, {
+    type: T;
+}>, "type" | "id" | "expertKey" | "timestamp" | "jobId" | "runId" | "stepNumber">) => Extract<ExpertStateEvent, {
+    type: T;
+}>;
+/** Factory function to create streaming events */
+export declare function createStreamingEvent<T extends StreamingEventType>(type: T, setting: RunSetting, checkpoint: Checkpoint, data: Omit<Extract<StreamingEvent, {
+    type: T;
+}>, "type" | "id" | "expertKey" | "timestamp" | "jobId" | "runId" | "stepNumber">): Extract<StreamingEvent, {
+    type: T;
+}>;
+export declare const startRun: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "startRun";
+} & {
+    initialCheckpoint: Checkpoint;
+    inputMessages: (InstructionMessage | UserMessage | ToolMessage)[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "startRun";
+} & {
+    initialCheckpoint: Checkpoint;
+    inputMessages: (InstructionMessage | UserMessage | ToolMessage)[];
+};
+export declare const resumeFromStop: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "resumeFromStop";
+} & {
+    checkpoint: Checkpoint;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "resumeFromStop";
+} & {
+    checkpoint: Checkpoint;
+};
+export declare const proceedToInteractiveTools: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "proceedToInteractiveTools";
+} & {
+    pendingToolCalls: ToolCall[];
+    partialToolResults: ToolResult[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "proceedToInteractiveTools";
+} & {
+    pendingToolCalls: ToolCall[];
+    partialToolResults: ToolResult[];
+};
+export declare const startGeneration: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "startGeneration";
+} & {
+    messages: Message[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "startGeneration";
+} & {
+    messages: Message[];
+};
+export declare const retry: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "retry";
+} & {
+    reason: string;
+    newMessages: (UserMessage | ExpertMessage | ToolMessage)[];
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    usage: Usage;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "retry";
+} & {
+    reason: string;
+    newMessages: (UserMessage | ExpertMessage | ToolMessage)[];
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    usage: Usage;
+};
+export declare const callTools: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "callTools";
+} & {
+    newMessage: ExpertMessage;
+    toolCalls: ToolCall[];
+    usage: Usage;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "callTools";
+} & {
+    newMessage: ExpertMessage;
+    toolCalls: ToolCall[];
+    usage: Usage;
+};
+export declare const finishMcpTools: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "finishMcpTools";
+} & {
+    partialToolResults: ToolResult[];
+    pendingToolCalls: ToolCall[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "finishMcpTools";
+} & {
+    partialToolResults: ToolResult[];
+    pendingToolCalls: ToolCall[];
+};
+export declare const skipDelegates: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "skipDelegates";
+} & object, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "skipDelegates";
+} & object;
+export declare const resolveToolResults: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "resolveToolResults";
+} & {
+    toolResults: ToolResult[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "resolveToolResults";
+} & {
+    toolResults: ToolResult[];
+};
+export declare const finishToolCall: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "finishToolCall";
+} & {
+    newMessages: (UserMessage | ToolMessage)[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "finishToolCall";
+} & {
+    newMessages: (UserMessage | ToolMessage)[];
+};
+export declare const resumeToolCalls: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "resumeToolCalls";
+} & {
+    pendingToolCalls: ToolCall[];
+    partialToolResults: ToolResult[];
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "resumeToolCalls";
+} & {
+    pendingToolCalls: ToolCall[];
+    partialToolResults: ToolResult[];
+};
+export declare const completeRun: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "completeRun";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+    text: string;
+    usage: Usage;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "completeRun";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+    text: string;
+    usage: Usage;
+};
+export declare const stopRunByInteractiveTool: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "stopRunByInteractiveTool";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "stopRunByInteractiveTool";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+};
+export declare const stopRunByDelegate: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "stopRunByDelegate";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "stopRunByDelegate";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+};
+export declare const stopRunByError: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "stopRunByError";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+    error: {
+        name: string;
+        message: string;
+        statusCode?: number;
+        isRetryable: boolean;
+    };
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "stopRunByError";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+    error: {
+        name: string;
+        message: string;
+        statusCode?: number;
+        isRetryable: boolean;
+    };
+};
+export declare const continueToNextStep: (setting: RunSetting, checkpoint: Checkpoint, data: Omit<BaseEvent & {
+    type: "continueToNextStep";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+    nextCheckpoint: Checkpoint;
+}, "id" | "type" | "jobId" | "runId" | "stepNumber" | "expertKey" | "timestamp">) => BaseEvent & {
+    type: "continueToNextStep";
+} & {
+    checkpoint: Checkpoint;
+    step: Step;
+    nextCheckpoint: Checkpoint;
+};
+/** Base properties for runtime events (infrastructure-level, no expertKey) */
+interface BaseRuntimeEvent {
+    /** Unique event ID */
+    id: string;
+    /** Unix timestamp */
+    timestamp: number;
+    /** Job ID */
+    jobId: string;
+    /** Run ID */
+    runId: string;
+}
+/** Runtime event payloads (infrastructure-level events only) */
+type RuntimeEventPayloads = {
+    initializeRuntime: {
+        runtimeVersion: string;
+        expertName: string;
+        experts: string[];
+        model: string;
+        maxRetries: number;
+        timeout: number;
+        query?: string;
+        interactiveToolCall?: {
+            toolName: string;
+            toolCallId: string;
+            text: string;
+        };
+    };
+    skillStarting: {
+        skillName: string;
+        command: string;
+        args: string[];
+    };
+    skillConnected: {
+        skillName: string;
+        serverInfo?: {
+            name: string;
+            version: string;
+        };
+        connectDurationMs?: number;
+        totalDurationMs?: number;
+        spawnDurationMs?: number;
+        handshakeDurationMs?: number;
+        toolDiscoveryDurationMs?: number;
+    };
+    skillStderr: {
+        skillName: string;
+        message: string;
+    };
+    skillDisconnected: {
+        skillName: string;
+    };
+};
+/** All runtime event types */
+export type RuntimeEventType = keyof RuntimeEventPayloads;
+/** Union type of all runtime events */
+export type RuntimeEvent = {
+    [K in RuntimeEventType]: BaseRuntimeEvent & {
+        type: K;
+    } & RuntimeEventPayloads[K];
+}[RuntimeEventType];
+/** Extract a specific runtime event type */
+export type RuntimeEventForType<T extends RuntimeEventType> = Extract<RuntimeEvent, {
+    type: T;
+}>;
+/** Factory function to create runtime events */
+export declare function createRuntimeEvent<T extends RuntimeEventType>(type: T, jobId: string, runId: string, data: Omit<RuntimeEventForType<T>, "type" | "id" | "timestamp" | "jobId" | "runId">): RuntimeEventForType<T>;
+/** Union of all Perstack events (RunEvent for state machine, RuntimeEvent for environment) */
+export type PerstackEvent = RunEvent | RuntimeEvent;
+/** Validate if a string is a valid RunEvent type (ExpertStateEvent or StreamingEvent) */
+export declare function isValidEventType(type: string): type is EventType;
+/** Validate if a string is a valid RuntimeEvent type */
+export declare function isValidRuntimeEventType(type: string): type is RuntimeEventType;
+export {};
+//# sourceMappingURL=runtime.d.ts.map