@runtypelabs/sdk 4.10.0 → 4.12.0

package/dist/index.d.ts

@@ -4520,6 +4520,131 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/assets/{assetId}/extend": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Extend preview expiry
+         * @description Re-up a preview page's expiration, keeping the same URL. Defaults to the caller's current plan TTL; pass `expiresInSeconds` to choose a shorter lifetime (the plan TTL is a hard ceiling — longer requests are clamped). Works on live previews and on previews that have already expired (expired pages keep their stored content; only serving is blocked). Applies to preview-rendering assets created by `publish_page` — download assets are not time-gated at the serving layer and cannot be extended.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Asset ID (e.g. "asset_01k…"). A trailing file extension (".html") is ignored. */
+                    assetId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description New lifetime in seconds (positive integer). Capped at the plan's preview TTL — shorter is honored, longer is clamped. Omit for the plan default. */
+                        expiresInSeconds?: number;
+                    } & {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            responses: {
+                /** @description Expiry extended */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description The asset ID that was extended. */
+                            assetId: string;
+                            /** @description New expiration timestamp (ISO 8601). null = permanent (plan grants no-expiry previews). */
+                            expiresAt: string | null;
+                            /** @description Seconds until the new expiration. null = permanent. */
+                            expiresIn: number | null;
+                            /** @enum {string} */
+                            rendering: "preview";
+                            /** @description The public URL of the asset (unchanged by extension). */
+                            url: string;
+                        };
+                    };
+                };
+                /** @description Asset is not a preview asset */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Asset not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Stored content no longer exists */
+                410: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Asset storage not configured */
+                503: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/assets/{orgId}/{assetId}": {
         parameters: {
             query?: never;
@@ -5446,6 +5571,7 @@ interface paths {
                                 maxMessagesPerSession: number | null;
                                 name: string | null;
                                 pinToVersion: string | null;
+                                productSurfaceId?: string | null;
                                 rateLimitPerHour: number | null;
                                 rateLimitPerMinute: number | null;
                                 sessionIdleTimeoutMinutes: number | null;
@@ -5557,6 +5683,7 @@ interface paths {
                                 maxMessagesPerSession: number | null;
                                 name: string | null;
                                 pinToVersion: string | null;
+                                productSurfaceId?: string | null;
                                 rateLimitPerHour: number | null;
                                 rateLimitPerMinute: number | null;
                                 sessionIdleTimeoutMinutes: number | null;
@@ -5673,6 +5800,7 @@ interface paths {
                                 maxMessagesPerSession: number | null;
                                 name: string | null;
                                 pinToVersion: string | null;
+                                productSurfaceId?: string | null;
                                 rateLimitPerHour: number | null;
                                 rateLimitPerMinute: number | null;
                                 sessionIdleTimeoutMinutes: number | null;
@@ -5790,6 +5918,7 @@ interface paths {
                                 maxMessagesPerSession: number | null;
                                 name: string | null;
                                 pinToVersion: string | null;
+                                productSurfaceId?: string | null;
                                 rateLimitPerHour: number | null;
                                 rateLimitPerMinute: number | null;
                                 sessionIdleTimeoutMinutes: number | null;
@@ -21179,7 +21308,7 @@ interface paths {
                         /** @enum {string} */
                         status?: "draft" | "active" | "paused";
                         /** @enum {string} */
-                        type: "chat" | "mcp" | "mcp_code" | "api" | "webhook" | "schedule" | "a2a" | "email" | "slack" | "sms" | "imessage" | "discord" | "whatsapp" | "telegram" | "hosted-page";
+                        type: "chat" | "mcp" | "mcp_code" | "api" | "webhook" | "schedule" | "a2a" | "email" | "slack" | "sms" | "imessage" | "discord" | "whatsapp" | "telegram" | "hosted-page" | "chrome_extension";
                     };
                 };
             };
@@ -31958,6 +32087,7 @@ interface paths {
                             description: string | null;
                             id: string;
                             isActive: boolean;
+                            lastModifiedSource?: string | null;
                             name: string;
                             organizationId: string | null;
                             parametersSchema?: {
@@ -32295,7 +32425,7 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/tools/flows/{flowId}/convert-to-tool": {
+    "/v1/tools/ensure": {
         parameters: {
             query?: never;
             header?: never;
@@ -32305,60 +32435,48 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Convert flow to tool
-         * @description Create a flow-type tool from an existing flow, generating its parameters schema from the flow steps.
+         * Ensure tool (config-as-code converge)
+         * @description Idempotently converge a repo-defined tool definition onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the tool or update it when the canonical content hash differs. The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), and onConflict: "overwrite" to converge over dashboard/API edits. Tools have no version snapshots, so there is no publish option.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path: {
-                    flowId: string;
-                };
+                path?: never;
                 cookie?: never;
             };
             requestBody?: {
                 content: {
                     "application/json": {
-                        [key: string]: unknown;
+                        contentHash?: string;
+                        definition?: {
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            description: string;
+                            name: string;
+                            parametersSchema: {
+                                [key: string]: unknown;
+                            };
+                            /** @enum {string} */
+                            toolType: "flow" | "custom" | "external" | "graphql" | "mcp" | "local" | "subagent";
+                        };
+                        dryRun?: boolean;
+                        expectedRemoteHash?: string;
+                        name: string;
+                        /** @enum {string} */
+                        onConflict?: "error" | "overwrite";
                     };
                 };
             };
             responses: {
-                /** @description Created tool */
+                /** @description Converge result: unchanged | created | updated | definitionRequired (hash miss — retry with the full definition) | plan (dryRun) */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": {
-                            config: {
-                                [key: string]: unknown;
-                            } | null;
-                            createdAt: string;
-                            description: string | null;
-                            id: string;
-                            isActive: boolean;
-                            name: string;
-                            organizationId: string | null;
-                            parametersSchema?: {
-                                [key: string]: unknown;
-                            };
-                            toolType: string;
-                            updatedAt: string;
-                            userId: string;
-                            validation?: {
-                                warnings: {
-                                    code: string;
-                                    column?: number;
-                                    line?: number;
-                                    message: string;
-                                    /** @enum {string} */
-                                    severity: "error" | "warning";
-                                    suggestion?: string;
-                                }[];
-                            };
-                        };
+                        "application/json": components["schemas"]["ToolEnsureResponse"];
                     };
                 };
                 /** @description Validation error */
@@ -32388,13 +32506,22 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
-                /** @description Flow not found */
-                404: {
+                /** @description Conflict: external_modification (last write was not ensure; pass onConflict: "overwrite") or remote_changed (expectedRemoteHash guard) */
+                409: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Error"];
+                        "application/json": components["schemas"]["ToolEnsureConflict"];
+                    };
+                };
+                /** @description Submitted contentHash does not match the server-recomputed canonical hash */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ToolEnsureHashMismatch"];
                     };
                 };
                 /** @description Internal server error */
@@ -32414,7 +32541,7 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/tools/sandbox/cf-sandbox/deploy": {
+    "/v1/tools/flows/{flowId}/convert-to-tool": {
         parameters: {
             query?: never;
             header?: never;
@@ -32424,14 +32551,16 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Deploy Runtype Sandbox
-         * @description Deploy code to a persistent Runtype Sandbox container and return a preview URL.
+         * Convert flow to tool
+         * @description Create a flow-type tool from an existing flow, generating its parameters schema from the flow steps.
          */
         post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path?: never;
+                path: {
+                    flowId: string;
+                };
                 cookie?: never;
             };
             requestBody?: {
@@ -32442,19 +32571,40 @@ interface paths {
                 };
             };
             responses: {
-                /** @description Sandbox deployment result */
+                /** @description Created tool */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
                         "application/json": {
-                            error?: string;
-                            output?: string;
-                            previewUrl?: string;
-                            sandboxId: string;
-                            stage?: string;
-                            status: string;
+                            config: {
+                                [key: string]: unknown;
+                            } | null;
+                            createdAt: string;
+                            description: string | null;
+                            id: string;
+                            isActive: boolean;
+                            lastModifiedSource?: string | null;
+                            name: string;
+                            organizationId: string | null;
+                            parametersSchema?: {
+                                [key: string]: unknown;
+                            };
+                            toolType: string;
+                            updatedAt: string;
+                            userId: string;
+                            validation?: {
+                                warnings: {
+                                    code: string;
+                                    column?: number;
+                                    line?: number;
+                                    message: string;
+                                    /** @enum {string} */
+                                    severity: "error" | "warning";
+                                    suggestion?: string;
+                                }[];
+                            };
                         };
                     };
                 };
@@ -32485,6 +32635,15 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
+                /** @description Flow not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
                 /** @description Internal server error */
                 500: {
                     headers: {
@@ -32502,40 +32661,35 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/tools/sandbox/cf-sandbox/{sandboxId}": {
+    "/v1/tools/pull": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
-        put?: never;
-        post?: never;
         /**
-         * Cleanup Runtype Sandbox
-         * @description Cleanup a deployed Runtype Sandbox container.
+         * Pull tool definition (config-as-code)
+         * @description Return the canonical config-as-code definition and provenance for a tool by name — the absorb-drift direction of the ensure protocol. The contentHash is recomputed from the live tool state, so it is accurate even immediately after a dashboard edit.
          */
-        delete: {
+        get: {
             parameters: {
-                query?: never;
-                header?: never;
-                path: {
-                    sandboxId: string;
+                query: {
+                    name: string;
                 };
+                header?: never;
+                path?: never;
                 cookie?: never;
             };
             requestBody?: never;
             responses: {
-                /** @description Sandbox cleaned up */
+                /** @description Canonical definition + provenance */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": {
-                            success: boolean;
-                        };
+                        "application/json": components["schemas"]["ToolPullResponse"];
                     };
                 };
                 /** @description Unauthorized */
@@ -32556,6 +32710,15 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
+                /** @description No tool with that name in the account scope */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
                 /** @description Internal server error */
                 500: {
                     headers: {
@@ -32567,12 +32730,15 @@ interface paths {
                 };
             };
         };
+        put?: never;
+        post?: never;
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/tools/sandbox/deploy": {
+    "/v1/tools/sandbox/cf-sandbox/deploy": {
         parameters: {
             query?: never;
             header?: never;
@@ -32582,8 +32748,166 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Deploy Daytona sandbox
-         * @description Deploy code to a persistent Daytona sandbox and return a preview URL.
+         * Deploy Runtype Sandbox
+         * @description Deploy code to a persistent Runtype Sandbox container and return a preview URL.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            responses: {
+                /** @description Sandbox deployment result */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error?: string;
+                            output?: string;
+                            previewUrl?: string;
+                            sandboxId: string;
+                            stage?: string;
+                            status: string;
+                        };
+                    };
+                };
+                /** @description Validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/tools/sandbox/cf-sandbox/{sandboxId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Cleanup Runtype Sandbox
+         * @description Cleanup a deployed Runtype Sandbox container.
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    sandboxId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Sandbox cleaned up */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            success: boolean;
+                        };
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/tools/sandbox/deploy": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Deploy Daytona sandbox
+         * @description Deploy code to a persistent Daytona sandbox and return a preview URL.
          */
         post: {
             parameters: {
@@ -32861,6 +33185,7 @@ interface paths {
                             description: string | null;
                             id: string;
                             isActive: boolean;
+                            lastModifiedSource?: string | null;
                             name: string;
                             organizationId: string | null;
                             parametersSchema?: {
@@ -32953,6 +33278,7 @@ interface paths {
                             description: string | null;
                             id: string;
                             isActive: boolean;
+                            lastModifiedSource?: string | null;
                             name: string;
                             organizationId: string | null;
                             parametersSchema?: {
@@ -33584,7 +33910,9 @@ interface paths {
                             features: {
                                 dashboardAssistantModel: string;
                                 enableAgentSkills: boolean;
+                                enableChromeSurface: boolean;
                                 enableDashboardAssistant: boolean;
+                                enableRuntypeApps: boolean;
                                 productGeneratorModel: string;
                             };
                             id: string;
@@ -34240,6 +34568,8 @@ interface components {
             lastModifiedSource: string | null;
             updatedAt: string | null;
             versionId: string | null;
+            /** @description Present only when a raw tool_… reference could not be emitted as a portable tool:<name> (the tool was deleted, or its name is shadowed by an older same-named tool). Those references are left as raw ids, which the ensure surface rejects; each warning explains how to fix it. */
+            warnings?: string[];
         };
         AgentSSEEvent: {
             agentId: string;
@@ -35378,6 +35708,8 @@ interface components {
             lastModifiedSource: string | null;
             updatedAt: string | null;
             versionId: string | null;
+            /** @description Present only when a raw tool_… reference could not be emitted as a portable tool:<name> (the tool was deleted, or its name is shadowed by an older same-named tool). Those references are left as raw ids, which the ensure surface rejects; each warning explains how to fix it. */
+            warnings?: string[];
         };
         FlowSSEEvent: {
             executionContext?: {
@@ -35776,6 +36108,58 @@ interface components {
             skillVersionId: string;
             status: string;
         };
+        ToolEnsureConflict: {
+            /** @enum {string} */
+            code: "external_modification" | "remote_changed";
+            currentHash?: string | null;
+            error: string;
+            lastModifiedSource?: string;
+            modifiedAt?: string | null;
+        };
+        ToolEnsureHashMismatch: {
+            /** @enum {string} */
+            code: "content_hash_mismatch";
+            /** @description The server-computed canonical hash of the submitted definition. */
+            contentHash: string;
+            error: string;
+        };
+        ToolEnsureResponse: {
+            /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
+            contentHash: string;
+            /** @enum {string} */
+            result: "unchanged" | "created" | "updated";
+            toolId: string;
+        } | {
+            /** @enum {string} */
+            result: "definitionRequired";
+        } | {
+            changedKeys: string[];
+            /** @enum {string} */
+            changes: "none" | "create" | "update";
+            contentHash: string;
+            remoteHash?: string;
+            /** @enum {string} */
+            result: "plan";
+            toolId?: string;
+        };
+        ToolPullResponse: {
+            contentHash: string;
+            definition: {
+                config: {
+                    [key: string]: unknown;
+                };
+                description: string;
+                name: string;
+                parametersSchema: {
+                    [key: string]: unknown;
+                };
+                /** @enum {string} */
+                toolType: "flow" | "custom" | "external" | "graphql" | "mcp" | "local" | "subagent";
+            };
+            lastModifiedSource: string | null;
+            toolId: string;
+            updatedAt: string | null;
+        };
         UpdateUserProfileResponse: {
             email?: string;
             firstName?: string;
@@ -37181,6 +37565,77 @@ interface BulkEditResponse {
     data: BulkEditResult[];
     recordIds?: number[];
 }
+/** A single unified step-level execution result for a record. */
+interface RecordStepResult {
+    id: string;
+    userId: string;
+    organizationId: string | null;
+    batchExecutionId: string | null;
+    executionSessionId: string | null;
+    flowId: string | null;
+    flowVersionId: string | null;
+    recordId: string | null;
+    recordName: string | null;
+    recordMetadata?: JsonValue | null;
+    stepId: string | null;
+    stepType: string;
+    stepName: string;
+    order: number | null;
+    status: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    durationMs: number | null;
+    outputPreview: string | null;
+    stepConfig?: JsonValue | null;
+    inputVariables?: JsonValue | null;
+    resolvedPrompt?: string | null;
+    modelUsed?: string | null;
+    promptTokens?: number | null;
+    completionTokens?: number | null;
+    totalTokens?: number | null;
+    estimatedCost?: string | null;
+    errorMessage?: string | null;
+    retryCount?: number | null;
+    createdAt: string;
+}
+/** Query parameters for {@link RecordsEndpoint.getStepResults}. */
+interface RecordStepResultsParams {
+    flowId?: string;
+    batchId?: string;
+    status?: string;
+    from?: string;
+    to?: string;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+/** Paginated response from {@link RecordsEndpoint.getStepResults}. */
+interface RecordStepResultsResponse {
+    data: RecordStepResult[];
+    pagination: {
+        limit: number;
+        offset: number;
+        returned: number;
+        hasMore: boolean;
+    };
+}
+/** Per-model cost line within a {@link RecordCostAggregation}. */
+interface RecordCostModelBreakdown {
+    model: string;
+    cost: number;
+    tokens: number;
+    count: number;
+}
+/** Aggregated cost breakdown for a record from {@link RecordsEndpoint.getCosts}. */
+interface RecordCostAggregation {
+    totalCost: number;
+    totalTokens: number;
+    promptTokens: number;
+    completionTokens: number;
+    executionCount: number;
+    modelBreakdown: RecordCostModelBreakdown[];
+}
 type ProviderApiKey = paths['/v1/provider-keys']['get']['responses'][200]['content']['application/json']['providerKeys'][number];
 /**
  * Provider enum for creating a provider key, derived from the generated OpenAPI
@@ -38084,6 +38539,13 @@ interface FlowPullResult {
     lastModifiedSource: string | null;
     updatedAt: string | null;
     versionId: string | null;
+    /**
+     * Present only when a raw `tool_…` reference could not be emitted as a
+     * portable `tool:<name>` (the tool was deleted, or its name is shadowed by an
+     * older same-named tool). Those references are left as raw ids — which
+     * `defineFlow`/`ensure` reject — so each warning explains how to fix it.
+     */
+    warnings?: string[];
 }
 /** A 409 from the ensure protocol (external_modification or remote_changed). */
 declare class FlowEnsureConflictError extends Error {
@@ -39654,6 +40116,13 @@ interface AgentPullResult {
     lastModifiedSource: string | null;
     updatedAt: string | null;
     versionId: string | null;
+    /**
+     * Present only when a raw `tool_…` reference could not be emitted as a
+     * portable `tool:<name>` (the tool was deleted, or its name is shadowed by an
+     * older same-named tool). Those references are left as raw ids — which
+     * `defineAgent`/`ensure` reject — so each warning explains how to fix it.
+     */
+    warnings?: string[];
 }
 /** A 409 from the ensure protocol (external_modification or remote_changed). */
 declare class AgentEnsureConflictError extends Error {
@@ -39710,6 +40179,190 @@ declare class AgentsNamespace {
     private request;
 }
 
+/**
+ * Tool config-as-code: `defineTool`, `tools.ensure`, `tools.pull`.
+ *
+ * The deploy-time convergence postcondition for saved tools: "make the
+ * platform's definition of this tool match this object; no-op if it already
+ * does." Identity is name + account scope (the API key's org, else personal);
+ * environment is whichever API the client points at. `ensure` never deletes,
+ * and renaming a definition orphans the old tool and creates a new one.
+ *
+ * Wire protocol (POST /v1/tools/ensure — APQ-shaped, both APQ scars fixed):
+ *   1. Hash-only probe `{ name, contentHash }`. A match is
+ *      `{ result: 'unchanged' }`; a miss is a NORMAL 200
+ *      `{ result: 'definitionRequired' }`, never an error.
+ *   2. On a miss, retry with the full `definition`. The server recomputes the
+ *      canonical hash itself and returns it on every response — this SDK
+ *      echoes the server's hash (memoized per client instance) rather than
+ *      trusting its own serialization.
+ *
+ * Unlike agents/flows, tools have NO version snapshots: there is no
+ * `release: 'publish'` option and no `versionId` on the result.
+ *
+ * The content hash is the canonical tool hash (`computeToolContentHash` —
+ * mirrored from `packages/shared/src/utils/tool-content-hash.ts`; this package
+ * is dependency-free by convention) over `{ toolType, description,
+ * parametersSchema, config }`. `name` is identity, not content, so it is
+ * excluded from the hash.
+ *
+ * See docs/adr/0003-agent-config-as-code-ensure.md for the design rationale.
+ */
+
+/** Canonical normalized form of a tool definition (name excluded — identity). */
+declare function normalizeToolDefinition(definition: ToolContentInput): {
+    toolType: string;
+    description?: string;
+    parametersSchema: Record<string, unknown>;
+    config: Record<string, unknown>;
+};
+/** SHA-256 (hex) over the canonical normalized tool definition. */
+declare function computeToolContentHash(definition: ToolContentInput): Promise<string>;
+interface ToolContentInput {
+    description?: string | null;
+    toolType: string;
+    parametersSchema?: Record<string, unknown> | null;
+    config?: Record<string, unknown> | null;
+}
+/** The tool types `ensure` accepts (mirrors the server's CreateToolSchema). */
+type ToolDefinitionType = 'flow' | 'custom' | 'external' | 'graphql' | 'mcp' | 'local' | 'subagent';
+/** `defineTool` input: identity (name) + the convergeable content fields. */
+interface DefineToolInput {
+    name: string;
+    description: string;
+    toolType: ToolDefinitionType;
+    parametersSchema: Record<string, unknown>;
+    config: Record<string, unknown>;
+}
+/** The canonical (wire) definition produced by `defineTool`. */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    toolType: ToolDefinitionType;
+    parametersSchema: Record<string, unknown>;
+    config: Record<string, unknown>;
+}
+/**
+ * Pure-local declarative constructor for a tool definition. No I/O. Validates
+ * structure and rejects unknown fields. Deep validation (custom-tool code
+ * preflight, {{secret:KEY}} reference rules) happens server-side at ensure
+ * time, mirroring the create/update routes.
+ *
+ * @example
+ * ```typescript
+ * const weather = defineTool({
+ *   name: 'Weather Lookup',
+ *   description: 'Fetch the current weather for a city',
+ *   toolType: 'external',
+ *   parametersSchema: {
+ *     type: 'object',
+ *     properties: { city: { type: 'string' } },
+ *     required: ['city'],
+ *   },
+ *   config: { url: 'https://api.example.com/weather?q={{city}}', method: 'GET' },
+ * })
+ * ```
+ */
+declare function defineTool(input: DefineToolInput): ToolDefinition;
+interface EnsureToolOptions {
+    /** Plan without writing (the CI drift gate). Sends the full definition. */
+    dryRun?: boolean;
+    /**
+     * What to do when the tool's last write came from the dashboard/API rather
+     * than ensure. Default 'error' (HTTP 409 → ToolEnsureConflictError).
+     */
+    onConflict?: 'error' | 'overwrite';
+    /**
+     * TOCTOU guard binding a dry run to its apply: the write only proceeds if
+     * the remote still hashes to this value (409 remote_changed otherwise).
+     */
+    expectedRemoteHash?: string;
+    /** Implies dryRun; throws ToolDriftError unless the plan is 'none'. */
+    expectNoChanges?: boolean;
+}
+interface EnsureToolConverged {
+    result: 'unchanged' | 'created' | 'updated';
+    toolId: string;
+    /** The server-computed canonical hash (echo this — never your own). */
+    contentHash: string;
+}
+interface EnsureToolPlan {
+    result: 'plan';
+    changes: 'none' | 'create' | 'update';
+    changedKeys: string[];
+    contentHash: string;
+    remoteHash?: string;
+    toolId?: string;
+}
+type EnsureToolResult = EnsureToolConverged | EnsureToolPlan;
+interface ToolPullResult {
+    toolId: string;
+    definition: ToolDefinition;
+    contentHash: string;
+    lastModifiedSource: string | null;
+    updatedAt: string | null;
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+declare class ToolEnsureConflictError extends Error {
+    readonly code: 'external_modification' | 'remote_changed';
+    readonly lastModifiedSource?: string;
+    readonly modifiedAt?: string | null;
+    readonly currentHash?: string | null;
+    constructor(body: {
+        error?: string;
+        code: 'external_modification' | 'remote_changed';
+        lastModifiedSource?: string;
+        modifiedAt?: string | null;
+        currentHash?: string | null;
+    });
+}
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+declare class ToolDriftError extends Error {
+    readonly plan: EnsureToolPlan;
+    constructor(plan: EnsureToolPlan);
+}
+
+/**
+ * ToolsNamespace — config-as-code operations for saved tools.
+ *
+ * `tools.ensure` is the deploy-time, non-executing converge (create-or-update a
+ * tool by name + account scope); `tools.pull` is the absorb-drift direction.
+ * Both delegate to the implementation in `tools-ensure.ts`.
+ */
+
+declare class ToolsNamespace {
+    private getClient;
+    constructor(getClient: () => RuntypeClient$1);
+    /**
+     * Idempotently converge a `defineTool` definition onto the platform.
+     * Hash-first: the steady state is one tiny probe request. Creates or updates
+     * the saved tool; never deletes. Identity is name + account scope.
+     *
+     * @example
+     * ```typescript
+     * const weather = defineTool({
+     *   name: 'Weather Lookup',
+     *   description: 'Fetch the current weather for a city',
+     *   toolType: 'external',
+     *   parametersSchema: { type: 'object', properties: { city: { type: 'string' } } },
+     *   config: { url: 'https://api.example.com/weather', method: 'GET' },
+     * })
+     *
+     * // Converge (CI/deploy).
+     * const result = await Runtype.tools.ensure(weather)
+     *
+     * // PR drift gate.
+     * await Runtype.tools.ensure(weather, { expectNoChanges: true })
+     * ```
+     */
+    ensure(definition: ToolDefinition, options?: EnsureToolOptions): Promise<EnsureToolResult>;
+    /**
+     * Pull the canonical definition + provenance for a tool by name — the
+     * absorb-drift direction of the ensure protocol.
+     */
+    pull(name: string): Promise<ToolPullResult>;
+}
+
 /**
  * Runtype - The unified SDK client for building and executing flows, batches, evals, and prompts
  *
@@ -39985,6 +40638,32 @@ declare class Runtype {
      * ```
      */
     static get agents(): AgentsNamespace;
+    /**
+     * Tools namespace - Tool config-as-code (define / ensure / pull)
+     *
+     * @example
+     * ```typescript
+     * import { defineTool, Runtype } from '@runtypelabs/sdk'
+     *
+     * const weather = defineTool({
+     *   name: 'Weather Lookup',
+     *   description: 'Fetch the current weather for a city',
+     *   toolType: 'external',
+     *   parametersSchema: { type: 'object', properties: { city: { type: 'string' } } },
+     *   config: { url: 'https://api.example.com/weather', method: 'GET' },
+     * })
+     *
+     * // Converge at deploy time (idempotent; one tiny probe in steady state)
+     * await Runtype.tools.ensure(weather)
+     *
+     * // CI drift gate
+     * await Runtype.tools.ensure(weather, { expectNoChanges: true })
+     *
+     * // Absorb a dashboard edit back into the repo
+     * const { definition } = await Runtype.tools.pull('Weather Lookup')
+     * ```
+     */
+    static get tools(): ToolsNamespace;
 }
 
 /**
@@ -40235,6 +40914,8 @@ interface RunTaskStateSlice {
     isCreationTask?: boolean;
     /** For creation tasks: allowed write root (e.g. "public/"). Writes must stay under this path. */
     outputRoot?: string;
+    /** Number of consecutive sessions with no tool actions (the stall-detection counter) */
+    consecutiveEmptySessions?: number;
     sessions: Array<{
         actionKeys?: string[];
         hadTextOutput?: boolean;
@@ -40310,11 +40991,40 @@ interface WorkflowPhase {
     /** Return true if the agent's TASK_COMPLETE claim should be accepted in this phase */
     canAcceptCompletion?: (state: RunTaskStateSlice, trace: RunTaskToolTraceSlice) => boolean;
 }
+/**
+ * Escalation policy for consecutive sessions with no tool actions.
+ *
+ * Every threshold counts the same `consecutiveEmptySessions` counter used for
+ * stall detection: a session is empty when it performed no write, read,
+ * discovery, or verification tool action. Text-only narration ("I'll create
+ * the files now") does NOT reset the counter — a model that narrates intent
+ * without calling tools still escalates here, even though phase-level
+ * `buildRecoveryMessage` conditions keyed on `hadTextOutput` would not fire.
+ */
+interface WorkflowStallPolicy {
+    /**
+     * Inject a generic recovery nudge into the next session after N consecutive
+     * empty sessions, when the current phase's buildRecoveryMessage returns
+     * nothing. Unset = no workflow-level nudge (legacy behavior).
+     */
+    nudgeAfter?: number;
+    /**
+     * Set `state.stallEscalationRequested` when the counter reaches N, signaling
+     * the caller (via onSession) to restart with a fallback model. The SDK only
+     * raises the signal — model switching is the caller's responsibility.
+     * Unset = never signal.
+     */
+    escalateModelAfter?: number;
+    /** Stop the run with status 'stalled' after N consecutive empty sessions (default 3). */
+    stopAfter?: number;
+}
 interface WorkflowDefinition {
     /** Workflow name for logging/debugging */
     name: string;
     /** Ordered list of phases */
     phases: WorkflowPhase[];
+    /** Escalation policy for consecutive sessions with no tool actions */
+    stallPolicy?: WorkflowStallPolicy;
     /** Classify the user message into a variant (e.g. 'create' vs 'modify') */
     classifyVariant?: (message: string) => string | undefined;
     /** Generate bootstrap context before the first session */
@@ -40475,6 +41185,15 @@ declare class RecordsEndpoint {
         fromDate?: string;
         toDate?: string;
     }): Promise<any[]>;
+    /**
+     * Get unified step-level execution results for a record, with filtering and
+     * pagination.
+     */
+    getStepResults(id: string, params?: RecordStepResultsParams): Promise<RecordStepResultsResponse>;
+    /**
+     * Get the aggregated cost breakdown (by model) for a record's executions.
+     */
+    getCosts(id: string): Promise<RecordCostAggregation>;
     /**
      * Delete a specific result for a record
      */
@@ -41752,6 +42471,12 @@ interface RunTaskState {
      * when that window re-crosses the threshold. 0/undefined = no compaction yet.
      */
     contextWindowBaseIndex?: number;
+    /**
+     * Set when the workflow's stallPolicy.escalateModelAfter threshold is reached.
+     * Callers observe this in onSession and may restart with a fallback model.
+     * Cleared as soon as a session performs tool actions again.
+     */
+    stallEscalationRequested?: boolean;
     /** Arbitrary bag for workflow-specific data */
     workflowState?: Record<string, unknown>;
 }
@@ -41808,6 +42533,20 @@ type RunTaskOnContextNotice = (event: RunTaskContextNoticeEvent) => void | Promi
 /**
  * Options for `agents.runTask()`
  */
+/**
+ * Storage seam for hot-tail tool-output offloads. Given a large tool result
+ * the SDK has already decided to offload (above its inline threshold), the
+ * recorder persists the content however it likes and returns the reference
+ * string to splice into the send view in place of the raw output. Return
+ * `undefined` to decline and let the SDK fall back to its built-in store.
+ */
+type RunTaskOffloadRecorder = (details: {
+    toolCallId: string;
+    toolName: string;
+    content: string;
+}) => {
+    reference: string;
+} | undefined;
 interface RunTaskOptions {
     /** The user message / task instruction for the agent */
     message: string;
@@ -41860,6 +42599,18 @@ interface RunTaskOptions {
     onContextNotice?: RunTaskOnContextNotice;
     /** Saved workflow state to seed a resumed or restarted marathon run */
     resumeState?: RunTaskResumeState;
+    /**
+     * Optional storage seam for hot-tail tool-output offloads. When supplied,
+     * `offloadToolResult` delegates persistence to the recorder instead of the
+     * built-in `.runtype/marathons/<slug>/tool-outputs/` fallback, and returns
+     * the recorder's reference in place of the file-pointer marker. The CLI
+     * backs this with its content-addressed ledger store so the 500–100k char
+     * band becomes a first-class ledger citizen (content-addressed, hashed,
+     * `read_offloaded_output`-resolvable, deduped). Returning `undefined` (or
+     * throwing) falls back to the built-in store. A future server-side artifact
+     * upload plugs into this same seam.
+     */
+    offloadRecorder?: RunTaskOffloadRecorder;
     /** How tool results are stored in message history for continuation.
      *  'hot-tail' (default): recent results inline, older offloaded to disk.
      *  'observation-mask': recent results inline, older replaced with placeholder.
@@ -43952,6 +44703,227 @@ declare const STEP_TYPE_TO_METHOD: {
     readonly 'memory-summary': "memorySummary";
 };
 
+/**
+ * Named workflow hook registry.
+ *
+ * Workflow configs (the data form compiled by `compileWorkflowConfig`) can
+ * reference behavior by name instead of carrying functions: `builtin:*` names
+ * are reserved for the hooks that power the default workflow, and consumers
+ * register their own under a custom namespace (e.g. `acme:my-completion`).
+ *
+ * Every hook declares which SLOT KIND it implements so a config that wires a
+ * hook into the wrong slot fails at load/compile time with an actionable
+ * error — not mid-marathon. Hook misfires in this system don't crash, they
+ * stall, which is the worst failure mode to debug.
+ */
+
+interface WorkflowHookSignatures {
+    /** WorkflowPhase.buildInstructions — used verbatim (no header is added) */
+    instructions: (state: RunTaskStateSlice) => string;
+    /** WorkflowPhase.buildToolGuidance */
+    toolGuidance: (state: RunTaskStateSlice) => string[];
+    /** WorkflowPhase.isComplete */
+    completion: (ctx: WorkflowContext) => boolean;
+    /** WorkflowPhase.buildTransitionSummary */
+    transitionSummary: (state: RunTaskStateSlice, nextPhaseName: string) => string;
+    /** WorkflowPhase.interceptToolCall — may only narrow (block); returning undefined never overrides an outer deny */
+    intercept: (toolName: string, args: Record<string, unknown>, ctx: WorkflowContext) => string | undefined;
+    /** WorkflowPhase.buildRecoveryMessage */
+    recovery: (state: RunTaskStateSlice) => string | undefined;
+    /** WorkflowPhase.shouldForceEndTurn */
+    forceEndTurn: (snapshot: LocalToolExecutionLoopSnapshotSlice, ctx: WorkflowContext) => string | undefined;
+    /** WorkflowPhase.canAcceptCompletion */
+    acceptCompletion: (state: RunTaskStateSlice, trace: RunTaskToolTraceSlice) => boolean;
+    /** WorkflowDefinition.classifyVariant */
+    classify: (message: string) => string | undefined;
+    /** WorkflowDefinition.generateBootstrapContext */
+    bootstrap: (message: string, localTools: Record<string, LocalToolDefinition> | undefined, variant?: string) => Promise<string | undefined>;
+    /** WorkflowDefinition.buildCandidateBlock */
+    candidateBlock: (state: RunTaskStateSlice) => string;
+}
+type WorkflowHookKind = keyof WorkflowHookSignatures;
+interface WorkflowHookEntry<K extends WorkflowHookKind = WorkflowHookKind> {
+    kind: K;
+    fn: WorkflowHookSignatures[K];
+}
+/**
+ * A string is a hook reference iff it full-matches `<namespace>:<id>` with
+ * both segments lowercase [a-z0-9_-]. Inline prose (multi-word strings,
+ * paths, sentences) never matches, so config slots can accept either form.
+ */
+declare function isWorkflowHookRef(value: unknown): value is string;
+/**
+ * Register a custom workflow hook. The `builtin:` namespace is reserved —
+ * "replacing" a builtin means pointing the config slot at your own hook, not
+ * mutating the registry, so a shipped default config keeps a stable meaning.
+ * Re-registering an existing custom name overwrites it (last write wins
+ * within one process, e.g. plugin reload).
+ */
+declare function registerWorkflowHook<K extends WorkflowHookKind>(name: string, entry: WorkflowHookEntry<K>): void;
+/** Resolve a hook by name, validating the slot kind. Throws actionable errors. */
+declare function resolveWorkflowHook<K extends WorkflowHookKind>(name: string, expectedKind: K): WorkflowHookSignatures[K];
+/** List registered hooks (name + kind) for error messages and tooling. */
+declare function listWorkflowHooks(): Array<{
+    name: string;
+    kind: WorkflowHookKind;
+}>;
+/** Test seam: remove a custom hook (builtin entries cannot be removed). */
+declare function unregisterWorkflowHook(name: string): boolean;
+
+/**
+ * Declarative workflow configs and the compiler that turns them into a
+ * `WorkflowDefinition`.
+ *
+ * This is the single compile path for marathon workflows-as-data: the CLI
+ * playbook loader parses YAML/JSON into a `WorkflowConfig` and delegates here,
+ * and the shipped default workflow is itself a `WorkflowConfig`
+ * (`defaultWorkflowConfig` in default-workflow.ts) compiled through the same
+ * function — so playbooks and the default cannot drift in semantics.
+ *
+ * Each behavior slot accepts either INLINE DATA (strings, declarative
+ * criteria, policy rules) or a HOOK REFERENCE (`"<namespace>:<id>"`, see
+ * hook-registry.ts) resolved against the registry with slot-kind validation
+ * at compile time.
+ *
+ * The compiler is environment-free: no fs, no YAML, no glob library. Glob
+ * matching for policy rules is injected via `WorkflowCompileDeps` (the CLI
+ * passes micromatch); configs that use glob policies without a matcher fail
+ * at compile time with an actionable error.
+ */
+
+declare const DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS = 2;
+/** A `"<namespace>:<id>"` reference into the workflow hook registry. */
+type WorkflowHookRef = string;
+interface WorkflowCompletionCriteriaConfig {
+    /** Built-in criteria type, or a 'completion' hook reference */
+    type: 'evidence' | 'sessions' | 'planWritten' | 'never' | WorkflowHookRef;
+    minReadFiles?: number;
+    minSessions?: number;
+}
+/**
+ * Every behavior slot accepts inline data, a hook reference, or — for configs
+ * authored in TypeScript (module playbooks, programmatic use) — a plain
+ * function with the slot's hook signature. Functions never round-trip through
+ * JSON/YAML, so declarative playbooks are unaffected.
+ */
+type WorkflowSlot<K extends keyof WorkflowHookSignatures, Inline = never> = Inline | WorkflowHookRef | WorkflowHookSignatures[K];
+interface WorkflowRecoveryConfig {
+    /** Inject after N consecutive empty sessions (default 2) */
+    afterEmptySessions?: number;
+    /** Recovery message; supports {{key}} interpolation from run state (e.g. {{planPath}}) */
+    message: string;
+}
+/**
+ * Declarative policy for narrowing runtime behavior.
+ * Cannot override global denies (e.g. secret paths). Precedence: global deny > workflow deny > config narrowing.
+ */
+interface WorkflowPolicyConfig {
+    /** Glob patterns for allowed read paths (e.g. ["src/**", "docs/**"]). If set, reads outside these are blocked. */
+    allowedReadGlobs?: string[];
+    /** Glob patterns for allowed write paths. If set, writes outside these are blocked. */
+    allowedWriteGlobs?: string[];
+    /** Tool names to block (e.g. ["write_file", "search_repo"]). */
+    blockedTools?: string[];
+    /** Require verification before TASK_COMPLETE (consumed by the runner, not the compiler). */
+    requireVerification?: boolean;
+    /** Block discovery tools (search_repo, glob_files, tree_directory, list_directory). */
+    blockDiscoveryTools?: boolean;
+    /** Require plan to be written before any non-plan writes. */
+    requirePlanBeforeWrite?: boolean;
+    /** For creation tasks: allowed write root (e.g. "public/"). Consumed by the runner via state.outputRoot. */
+    outputRoot?: string;
+}
+interface WorkflowMilestoneConfig {
+    name: string;
+    description?: string;
+    /**
+     * Inline instructions (interpolated, with a "--- Workflow Phase ---" header
+     * added), an 'instructions' hook reference, or a function (both used verbatim).
+     */
+    instructions: WorkflowSlot<'instructions', string>;
+    /** Inline guidance lines, a 'toolGuidance' hook reference, or a function. Policy-derived guidance is appended either way. */
+    toolGuidance?: WorkflowSlot<'toolGuidance', string[]>;
+    /** Declarative criteria object, or a 'completion' predicate function */
+    completionCriteria?: WorkflowCompletionCriteriaConfig | WorkflowHookSignatures['completion'];
+    /**
+     * Inline boolean, an 'acceptCompletion' hook reference or function, or absent.
+     * NOTE: absent means the slot is omitted from the compiled phase — the SDK
+     * then ACCEPTS completion by default. Loaders that want reject-by-default
+     * (the playbook behavior) must set `false` explicitly before compiling.
+     */
+    canAcceptCompletion?: WorkflowSlot<'acceptCompletion', boolean>;
+    /** Inline recovery (triggered on the consecutive-empty-sessions counter), a 'recovery' hook reference, or a function */
+    recovery?: WorkflowSlot<'recovery', WorkflowRecoveryConfig>;
+    /** Inline summary (supports {{key}} + {{nextPhase}}), a 'transitionSummary' hook reference, or a function */
+    transitionSummary?: WorkflowSlot<'transitionSummary', string>;
+    /** An 'intercept' hook reference or function; runs after the policy intercept and can only narrow further */
+    intercept?: WorkflowSlot<'intercept'>;
+    /** A 'forceEndTurn' hook reference or function */
+    forceEndTurn?: WorkflowSlot<'forceEndTurn'>;
+    /** Per-milestone model override (consumed by the runner, not the compiler) */
+    model?: string;
+    /** Per-milestone fallback models (consumed by the runner, not the compiler) */
+    fallbackModels?: unknown[];
+}
+interface WorkflowConfig {
+    name: string;
+    description?: string;
+    stallPolicy?: WorkflowStallPolicy;
+    policy?: WorkflowPolicyConfig;
+    /** A 'classify' hook reference or function */
+    classifyVariant?: WorkflowSlot<'classify'>;
+    /** A 'bootstrap' hook reference or function */
+    bootstrap?: WorkflowSlot<'bootstrap'>;
+    /** A 'candidateBlock' hook reference or function */
+    candidateBlock?: WorkflowSlot<'candidateBlock'>;
+    milestones: WorkflowMilestoneConfig[];
+    /** Runner-level passthrough (verification requirements); ignored by the compiler */
+    verification?: {
+        required: boolean;
+        commands?: string[];
+    };
+    /** Runner-level passthrough (extra rules text); ignored by the compiler */
+    rules?: string;
+}
+/**
+ * A module playbook's default export: either a workflow config directly, or a
+ * factory that receives the registration API and returns one. The API is
+ * INJECTED so hooks land in the loading process's registry instance even when
+ * the playbook module would resolve a different copy of @runtypelabs/sdk.
+ */
+type WorkflowConfigFactory = (api: {
+    registerWorkflowHook: typeof registerWorkflowHook;
+}) => WorkflowConfig | Promise<WorkflowConfig>;
+/**
+ * Identity helper for TypeScript playbooks — exists purely for type inference
+ * (the `defineConfig` pattern). Optional: a plain object/function export with
+ * the same shape works identically, so playbook modules don't need
+ * @runtypelabs/sdk installed at runtime.
+ */
+declare function definePlaybook<T extends WorkflowConfig | WorkflowConfigFactory>(playbook: T): T;
+interface WorkflowCompileDeps {
+    /**
+     * Glob matcher for policy allowedReadGlobs / allowedWriteGlobs (the CLI
+     * passes micromatch). Required at compile time when the config uses glob
+     * policies; other configs compile without it.
+     */
+    matchPathGlobs?: (path: string, globs: string[]) => boolean;
+}
+declare function interpolateWorkflowTemplate(template: string, state: RunTaskStateSlice): string;
+/**
+ * Generate tool-guidance lines from the policy block so the model is told
+ * what the interceptor enforces. Guidance and enforcement compile from the
+ * same config, so they cannot drift — a silently-enforced constraint teaches
+ * the model that tools "don't work" instead of what the actual rule is.
+ */
+declare function buildPolicyGuidance(policy?: WorkflowPolicyConfig): string[];
+/**
+ * Compile a declarative workflow config into a WorkflowDefinition.
+ * Hook references are resolved (and kind-validated) eagerly, so a bad
+ * reference fails here — at load time — with an actionable error.
+ */
+declare function compileWorkflowConfig(config: WorkflowConfig, deps?: WorkflowCompileDeps): WorkflowDefinition;
+
 /**
  * Default marathon workflow: research → planning → execution.
  *
@@ -43960,6 +44932,23 @@ declare const STEP_TYPE_TO_METHOD: {
  * via the `workflowVariant` / `isCreationTask` flags on state.
  */
 
+/**
+ * Register the default workflow's behaviors as `builtin:*` hooks. Idempotent.
+ * Importing this module (or anything that pulls in `defaultWorkflow`) calls it
+ * automatically; loaders that compile configs without importing the default
+ * workflow (e.g. the CLI playbook loader) must call it explicitly before
+ * `compileWorkflowConfig` so `builtin:*` references resolve.
+ */
+declare function ensureDefaultWorkflowHooks(): void;
+/**
+ * The default workflow expressed as a declarative config over `builtin:*`
+ * hooks. This is the same shape the CLI playbook loader compiles, so a user
+ * playbook can reuse any slice of the default by referencing the same hooks
+ * (e.g. keep `builtin:research-guard` but supply custom execution
+ * instructions). The heuristic logic stays in this file as named builtins;
+ * the composition is data.
+ */
+declare const defaultWorkflowConfig: WorkflowConfig;
 declare const defaultWorkflow: WorkflowDefinition;
 
 /**
@@ -44003,6 +44992,36 @@ declare const deployWorkflow: WorkflowDefinition;
 
 declare const gameWorkflow: WorkflowDefinition;
 
+/**
+ * Helpers for WorkflowDefinition.stallPolicy: what happens when an agent
+ * produces consecutive sessions with no tool actions.
+ *
+ * All thresholds count the run-level `consecutiveEmptySessions` counter (a
+ * session is empty when it performed no write/read/discovery/verification
+ * tool action), so narration-only sessions escalate here even though they
+ * carry text output. Absent policy values preserve the legacy behavior:
+ * no nudge, no escalation signal, stop after 3.
+ */
+
+declare const DEFAULT_STALL_STOP_AFTER = 3;
+/** Resolve how many consecutive empty sessions end the run as 'stalled'. */
+declare function resolveStallStopAfter(policy?: WorkflowStallPolicy): number;
+/**
+ * Whether to raise the model-escalation signal for this empty-session count.
+ * Fires exactly once per stall episode (when the counter reaches the
+ * threshold), so a caller that cannot escalate is not re-signaled every
+ * subsequent empty session.
+ */
+declare function shouldRequestModelEscalation(policy: WorkflowStallPolicy | undefined, consecutiveEmptySessions: number): boolean;
+/** Whether the workflow-level empty-session nudge should be injected. */
+declare function shouldInjectEmptySessionNudge(policy: WorkflowStallPolicy | undefined, consecutiveEmptySessions: number): boolean;
+/**
+ * Generic recovery nudge used when a phase has no buildRecoveryMessage of its
+ * own (or it returned nothing). Targets the narration-without-tool-calls
+ * failure mode directly.
+ */
+declare function buildEmptySessionNudge(consecutiveEmptySessions: number): string;
+
 /**
  * Utility functions shared between workflow phase handlers and AgentsEndpoint.
  *
@@ -44020,4 +45039,4 @@ declare function getLikelySupportingCandidatePaths(bestCandidatePath: string | u
 declare function getDefaultPlanPath(taskName: string): string;
 declare function sanitizeTaskSlug(taskName: string): string;
 
-export { type Agent, type AgentApprovalCompleteEvent, type AgentApprovalStartEvent, type AgentCompleteEvent, type AgentDefinition, type AgentDefinitionConfig, AgentDriftError, AgentEnsureConflictError, type AgentErrorEvent, type AgentEvent, type AgentEventType, type AgentExecuteRequest, type AgentExecuteResponse, type AgentIterationCompleteEvent, type AgentIterationStartEvent, type AgentMediaEvent, type AgentMessage, type AgentPausedEvent, type AgentPingEvent, type AgentPullResult, type AgentReflectionEvent, type AgentRuntimeToolDefinition, type AgentStartEvent, type AgentStreamCallbacks, type AgentStreamEvent, type AgentSubagentConfig, type AgentToolCompleteEvent, type AgentToolDeltaEvent, type AgentToolInputCompleteEvent, type AgentToolInputDeltaEvent, type AgentToolStartEvent, type AgentTurnCompleteEvent, type AgentTurnDeltaEvent, type AgentTurnStartEvent, type AgentVersionDetail, type AgentVersionListItem, type AgentVersionPublishResponse, AgentVersionsEndpoint, type AgentVersionsListResponse, AgentsEndpoint, AgentsNamespace, AnalyticsEndpoint, type ApiClient, type ApiKey, ApiKeysEndpoint, type ApiResponse, type App, type AppManifest, type AppVersion, type ApplyGeneratedProposalOptions, type ApplyGeneratedProposalResult, AppsEndpoint, type AttachRuntimeToolsOptions, type BaseAgentEvent, BatchBuilder, type BatchClient, type BatchListParams, type BatchOptions, type BatchRequest, type BatchResult, type BatchScheduleConfig, type BatchStatus, BatchesNamespace, BillingEndpoint, type BillingSpendAnalyticsParams, type BindSkillInput, type BuiltInTool, type BulkEditCondition, type BulkEditRequest, type BulkEditResponse, type BulkEditResult, ChatEndpoint, ClientBatchBuilder, type ClientConfig, type ClientConversation, ClientEvalBuilder, ClientFlowBuilder, type ClientToken, type ClientTokenConfig, type ClientTokenEnvironment, type ClientTokenVersionPin, ClientTokensEndpoint, type ClientToolDefinition, type ClientWidgetTheme, type ConditionalStepConfig$1 as ConditionalStepConfig, type ContextErrorHandling, type ContextFallback, ContextTemplatesEndpoint, type Conversation, type ConversationListItem, type ConversationListParams, type ConversationMessage, type ConversationSource, ConversationsEndpoint, type ConversationsListResponse, type CreateApiKeyRequest, type CreateAppRequest, type CreateClientTokenRequest, type CreateClientTokenResponse, type CreateConversationRequest, type CreateFlowRequest, type CreateModelConfigRequest, type CreatePromptData, type CreatePromptRequest, type CreateProviderKeyRequest, type CreateRecordRequest, type CreateScheduleRequest, type CreateSecretRequest, type CreateToolRequest, type CustomMCPServer, type CustomMCPServerAuth, type CustomToolConfig, type DefineAgentInput, type DefineFlowInput, type DeployCfSandboxRequest, type DeployCfSandboxResponse, type DeploySandboxRequest, type DeploySandboxResponse, type DiscoveredModel, type DispatchClient, DispatchEndpoint, type DispatchEnvironment, type DispatchEvent, type DispatchOptions$1 as DispatchOptions, type DispatchRequest, type EnsureAgentConverged, type EnsureAgentOptions, type EnsureAgentPlan, type EnsureAgentResult, type EnsureFlowConverged, type EnsureFlowOptions, type EnsureFlowPlan, type EnsureFlowResult, type ErrorHandlingMode, EvalBuilder, type EvalClient, EvalEndpoint, type EvalListParams, type EvalOptions, type EvalRecord, type EvalRequest, type EvalResult, type EvalRunConfig, EvalRunner, type EvalStatus, EvalsNamespace, type ExecuteToolRequest, type ExecuteToolResponse, type ExternalAgentContext, type ExternalToolConfig, type FallbackFailEvent, type FallbackStartEvent, type FallbackSuccessEvent, type FallbackTrigger, type FallbackTriggerType, type FallbacksExhaustedEvent, type FallbacksInitiatedEvent, type FetchGitHubStepConfig$1 as FetchGitHubStepConfig, type FetchUrlStepConfig$1 as FetchUrlStepConfig, type FieldFormat, type FileContentPart, type Flow, type FlowAttachment, FlowBuilder, type FlowCompleteEvent, type FlowConfig$1 as FlowConfig, type FlowDefinition, type FlowDefinitionStep, FlowDriftError, FlowEnsureConflictError, type FlowErrorEvent, type FlowFallback, type FlowListItem, type FlowPausedEvent, type FlowPullResult, FlowResult, type FlowStartEvent, type FlowStep, type FlowStepDefinition, type FlowStepType, FlowStepsEndpoint, type FlowStreamEvent, type FlowSummary, type FlowToolConfig, type FlowValidationClient, type FlowValidationIssue, type FlowValidationResult, type FlowVersionDetail, type FlowVersionListItem, type FlowVersionPublishResponse, FlowVersionsEndpoint, type FlowVersionsListResponse, FlowsEndpoint, FlowsNamespace, type GenerateEmbeddingStepConfig$1 as GenerateEmbeddingStepConfig, type GeneratedRuntimeToolGateDecision, type GeneratedRuntimeToolGateOptions, type ImageContentPart, type Integration, type IntegrationTool, IntegrationsEndpoint, type IntegrationsListResponse, type JSONSchema, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, LEDGER_ARTIFACT_LINE_PREFIX, type ListConversationsResponse, type ListParams, type LocalToolConfig, type LocalToolDefinition, type LocalToolExecutionCompleteEvent, type LocalToolExecutionLoopSnapshotSlice, type LocalToolExecutionStartEvent, type LogEntry, type LogQueryParams, type LogQueryResponse, type LogQueryResult, type LogStatsParams, type LogStatsResponse, type LogStatsResult, LogsEndpoint, type Message$1 as Message, type MessageContent, type MessageFallback, type Metadata, type ModelConfig, ModelConfigsEndpoint, type ModelFallback, type ModelOverride, type ModelUsageDetail, type ModelUsageQueryParams, type ModelUsageResponse, type ModelUsageSummary, type ModelUsageTimeSeries, type PaginationResponse, type Prompt$1 as Prompt, type PromptErrorHandling, type PromptFallback, type PromptListParams, type PromptRunOptions, PromptRunner, type PromptStepConfig$1 as PromptStepConfig, PromptsEndpoint, PromptsNamespace, type ProviderApiKey, type ProviderKeyModel, ProviderKeysEndpoint, type ReasoningConfig, type ReasoningContentPart, type ReasoningValue, type RecordConfig$1 as RecordConfig, type RecordFilter, type RecordFilterCondition, type RecordFilterGroup, type RecordFilterOperator, type RecordListItem, type RecordListParams, RecordsEndpoint, type RetrieveRecordStepConfig$1 as RetrieveRecordStepConfig, type RetryFallback, type RunTaskContextBudgetBreakdown, type RunTaskContextCompactionEvent, type RunTaskContextCompactionStrategy, type RunTaskContextNoticeEvent, type RunTaskContextSummaryEntry, type RunTaskContinuation, type RunTaskOnContextCompaction, type RunTaskOnContextNotice, type RunTaskOnSession, type RunTaskOptions, type RunTaskResult, type RunTaskResumeState, type RunTaskSessionSummary, type RunTaskState, type RunTaskStateSlice, type RunTaskStatus, type RunTaskToolTraceSlice, type RuntimeCustomToolConfig, type RuntimeExternalToolConfig, type RuntimeFlowToolConfig, type RuntimeLocalToolConfig, type RuntimeSubagentToolConfig, type RuntimeTool, type RuntimeToolConfig, Runtype, type AgentSkillBinding as RuntypeAgentSkillBinding, RuntypeApiError, RuntypeClient, type ConditionalStepConfig as RuntypeConditionalStepConfig, type RuntypeConfig, type FetchGitHubStepConfig as RuntypeFetchGitHubStepConfig, type FetchUrlStepConfig as RuntypeFetchUrlStepConfig, RuntypeFlowBuilder, type FlowConfig as RuntypeFlowConfig, type GenerateEmbeddingStepConfig as RuntypeGenerateEmbeddingStepConfig, type Message as RuntypeMessage, type ModelOverride$1 as RuntypeModelOverride, type Prompt as RuntypePrompt, type PromptStepConfig as RuntypePromptStepConfig, type RuntypeRecord, type RecordConfig as RuntypeRecordConfig, type RetrieveRecordStepConfig as RuntypeRetrieveRecordStepConfig, type SearchStepConfig as RuntypeSearchStepConfig, type SendEmailStepConfig as RuntypeSendEmailStepConfig, type SendEventStepConfig as RuntypeSendEventStepConfig, type SendStreamStepConfig as RuntypeSendStreamStepConfig, type SendTextStepConfig as RuntypeSendTextStepConfig, type SetVariableStepConfig as RuntypeSetVariableStepConfig, type Skill as RuntypeSkill, type SkillCapabilities as RuntypeSkillCapabilities, type SkillFrontmatter as RuntypeSkillFrontmatter, type SkillManifest as RuntypeSkillManifest, type SkillProposal as RuntypeSkillProposal, type SkillRuntypeExtensions as RuntypeSkillRuntypeExtensions, type SkillVersion as RuntypeSkillVersion, type TransformDataStepConfig as RuntypeTransformDataStepConfig, type UpsertFlowConfig as RuntypeUpsertFlowConfig, type UpsertRecordStepConfig as RuntypeUpsertRecordStepConfig, type VectorSearchStepConfig as RuntypeVectorSearchStepConfig, type WaitUntilStepConfig as RuntypeWaitUntilStepConfig, STEP_FIELD_REGISTRY, STEP_TYPE_TO_METHOD, type Schedule, type ScheduleExecutionOptions, type ScheduleListParams, type ScheduleMessage, type ScheduleMessageSet, type ScheduleMessages, type ScheduleMutationResponse, type ScheduleRun, type ScheduleRunNowResponse, type ScheduleStatusResponse, type ScheduleTarget, type ScheduleTrigger, SchedulesEndpoint, type SearchStepConfig$1 as SearchStepConfig, type Secret, type SecretCheckResponse, type SecretDeleteResponse, type SecretSetupUrlRequest, type SecretSetupUrlResponse, SecretsEndpoint, type SendEmailStepConfig$1 as SendEmailStepConfig, type SendEventStepConfig$1 as SendEventStepConfig, type SendStreamStepConfig$1 as SendStreamStepConfig, type SendTextStepConfig$1 as SendTextStepConfig, type SetVariableStepConfig$1 as SetVariableStepConfig, type SkillListPage, type SkillListPagination, type SkillListParams, type SkillManifestInput, type SkillMarkdownInput, type SkillOrigin, type SkillProposalStatus, SkillProposalsNamespace, type SkillStatus, type SkillTrustLevel, type SkillVersionStatus, type SkillWithVersion, type SkillWriteInput, SkillsNamespace, type SlackInstallRequest, type StepCompleteEvent, type StepDeltaEvent, type StepFallback, type StepFieldMeta, type StepStartEvent, type StepWaitingLocalEvent, type StreamCallbacks, type StreamEvent, type StreamEventOf, type SubagentToolConfig, type Surface, type SurfaceListParams, SurfacesEndpoint, type TextContentPart, type Tool, type ToolConfig, type ToolWithValidation, type ToolsConfig, ToolsEndpoint, type TransformDataStepConfig$1 as TransformDataStepConfig, type UpdateAppRequest, type UpdateClientTokenRequest, type UpdateConversationRequest, type UpdatePromptData, type UpdateProviderKeyRequest, type UpdateScheduleRequest, type UpdateSecretRequest, type UpdateToolRequest, type UpdatedFlow, type UpsertFlowConfig$1 as UpsertFlowConfig, type UpsertOptions, type UpsertRecordStepConfig$1 as UpsertRecordStepConfig, type UserProfile, UsersEndpoint, type VectorSearchStepConfig$1 as VectorSearchStepConfig, type VersionType, type WaitUntilStepConfig$1 as WaitUntilStepConfig, type WorkflowContext, type WorkflowDefinition, type WorkflowPhase, applyGeneratedRuntimeToolProposalToDispatchRequest, attachRuntimeToolsToDispatchRequest, buildGeneratedRuntimeToolGateOutput, buildLedgerOffloadReference, buildSendViewOffloadMarker, computeAgentContentHash, computeFlowContentHash, createClient, createExternalTool, defaultWorkflow, defineAgent, defineFlow, deployWorkflow, evaluateGeneratedRuntimeToolProposal, extractDeclaredToolResultChars, gameWorkflow, getDefaultPlanPath, getLikelySupportingCandidatePaths, isDiscoveryToolName, isMarathonArtifactPath, isPreservationSensitiveTask, normalizeAgentDefinition, normalizeCandidatePath, parseFinalBuffer, parseLedgerArtifactRelativePath, parseOffloadedOutputId, parseSSEChunk, processStream, sanitizeTaskSlug, streamEvents };
+export { type Agent, type AgentApprovalCompleteEvent, type AgentApprovalStartEvent, type AgentCompleteEvent, type AgentDefinition, type AgentDefinitionConfig, AgentDriftError, AgentEnsureConflictError, type AgentErrorEvent, type AgentEvent, type AgentEventType, type AgentExecuteRequest, type AgentExecuteResponse, type AgentIterationCompleteEvent, type AgentIterationStartEvent, type AgentMediaEvent, type AgentMessage, type AgentPausedEvent, type AgentPingEvent, type AgentPullResult, type AgentReflectionEvent, type AgentRuntimeToolDefinition, type AgentStartEvent, type AgentStreamCallbacks, type AgentStreamEvent, type AgentSubagentConfig, type AgentToolCompleteEvent, type AgentToolDeltaEvent, type AgentToolInputCompleteEvent, type AgentToolInputDeltaEvent, type AgentToolStartEvent, type AgentTurnCompleteEvent, type AgentTurnDeltaEvent, type AgentTurnStartEvent, type AgentVersionDetail, type AgentVersionListItem, type AgentVersionPublishResponse, AgentVersionsEndpoint, type AgentVersionsListResponse, AgentsEndpoint, AgentsNamespace, AnalyticsEndpoint, type ApiClient, type ApiKey, ApiKeysEndpoint, type ApiResponse, type App, type AppManifest, type AppVersion, type ApplyGeneratedProposalOptions, type ApplyGeneratedProposalResult, AppsEndpoint, type AttachRuntimeToolsOptions, type BaseAgentEvent, BatchBuilder, type BatchClient, type BatchListParams, type BatchOptions, type BatchRequest, type BatchResult, type BatchScheduleConfig, type BatchStatus, BatchesNamespace, BillingEndpoint, type BillingSpendAnalyticsParams, type BindSkillInput, type BuiltInTool, type BulkEditCondition, type BulkEditRequest, type BulkEditResponse, type BulkEditResult, ChatEndpoint, ClientBatchBuilder, type ClientConfig, type ClientConversation, ClientEvalBuilder, ClientFlowBuilder, type ClientToken, type ClientTokenConfig, type ClientTokenEnvironment, type ClientTokenVersionPin, ClientTokensEndpoint, type ClientToolDefinition, type ClientWidgetTheme, type ConditionalStepConfig$1 as ConditionalStepConfig, type ContextErrorHandling, type ContextFallback, ContextTemplatesEndpoint, type Conversation, type ConversationListItem, type ConversationListParams, type ConversationMessage, type ConversationSource, ConversationsEndpoint, type ConversationsListResponse, type CreateApiKeyRequest, type CreateAppRequest, type CreateClientTokenRequest, type CreateClientTokenResponse, type CreateConversationRequest, type CreateFlowRequest, type CreateModelConfigRequest, type CreatePromptData, type CreatePromptRequest, type CreateProviderKeyRequest, type CreateRecordRequest, type CreateScheduleRequest, type CreateSecretRequest, type CreateToolRequest, type CustomMCPServer, type CustomMCPServerAuth, type CustomToolConfig, DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS, DEFAULT_STALL_STOP_AFTER, type DefineAgentInput, type DefineFlowInput, type DefineToolInput, type DeployCfSandboxRequest, type DeployCfSandboxResponse, type DeploySandboxRequest, type DeploySandboxResponse, type DiscoveredModel, type DispatchClient, DispatchEndpoint, type DispatchEnvironment, type DispatchEvent, type DispatchOptions$1 as DispatchOptions, type DispatchRequest, type EnsureAgentConverged, type EnsureAgentOptions, type EnsureAgentPlan, type EnsureAgentResult, type EnsureFlowConverged, type EnsureFlowOptions, type EnsureFlowPlan, type EnsureFlowResult, type EnsureToolConverged, type EnsureToolOptions, type EnsureToolPlan, type EnsureToolResult, type ErrorHandlingMode, EvalBuilder, type EvalClient, EvalEndpoint, type EvalListParams, type EvalOptions, type EvalRecord, type EvalRequest, type EvalResult, type EvalRunConfig, EvalRunner, type EvalStatus, EvalsNamespace, type ExecuteToolRequest, type ExecuteToolResponse, type ExternalAgentContext, type ExternalToolConfig, type FallbackFailEvent, type FallbackStartEvent, type FallbackSuccessEvent, type FallbackTrigger, type FallbackTriggerType, type FallbacksExhaustedEvent, type FallbacksInitiatedEvent, type FetchGitHubStepConfig$1 as FetchGitHubStepConfig, type FetchUrlStepConfig$1 as FetchUrlStepConfig, type FieldFormat, type FileContentPart, type Flow, type FlowAttachment, FlowBuilder, type FlowCompleteEvent, type FlowConfig$1 as FlowConfig, type FlowDefinition, type FlowDefinitionStep, FlowDriftError, FlowEnsureConflictError, type FlowErrorEvent, type FlowFallback, type FlowListItem, type FlowPausedEvent, type FlowPullResult, FlowResult, type FlowStartEvent, type FlowStep, type FlowStepDefinition, type FlowStepType, FlowStepsEndpoint, type FlowStreamEvent, type FlowSummary, type FlowToolConfig, type FlowValidationClient, type FlowValidationIssue, type FlowValidationResult, type FlowVersionDetail, type FlowVersionListItem, type FlowVersionPublishResponse, FlowVersionsEndpoint, type FlowVersionsListResponse, FlowsEndpoint, FlowsNamespace, type GenerateEmbeddingStepConfig$1 as GenerateEmbeddingStepConfig, type GeneratedRuntimeToolGateDecision, type GeneratedRuntimeToolGateOptions, type ImageContentPart, type Integration, type IntegrationTool, IntegrationsEndpoint, type IntegrationsListResponse, type JSONSchema, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, LEDGER_ARTIFACT_LINE_PREFIX, type ListConversationsResponse, type ListParams, type LocalToolConfig, type LocalToolDefinition, type LocalToolExecutionCompleteEvent, type LocalToolExecutionLoopSnapshotSlice, type LocalToolExecutionStartEvent, type LogEntry, type LogQueryParams, type LogQueryResponse, type LogQueryResult, type LogStatsParams, type LogStatsResponse, type LogStatsResult, LogsEndpoint, type Message$1 as Message, type MessageContent, type MessageFallback, type Metadata, type ModelConfig, ModelConfigsEndpoint, type ModelFallback, type ModelOverride, type ModelUsageDetail, type ModelUsageQueryParams, type ModelUsageResponse, type ModelUsageSummary, type ModelUsageTimeSeries, type PaginationResponse, type Prompt$1 as Prompt, type PromptErrorHandling, type PromptFallback, type PromptListParams, type PromptRunOptions, PromptRunner, type PromptStepConfig$1 as PromptStepConfig, PromptsEndpoint, PromptsNamespace, type ProviderApiKey, type ProviderKeyModel, ProviderKeysEndpoint, type ReasoningConfig, type ReasoningContentPart, type ReasoningValue, type RecordConfig$1 as RecordConfig, type RecordCostAggregation, type RecordCostModelBreakdown, type RecordFilter, type RecordFilterCondition, type RecordFilterGroup, type RecordFilterOperator, type RecordListItem, type RecordListParams, type RecordStepResult, type RecordStepResultsParams, type RecordStepResultsResponse, RecordsEndpoint, type RetrieveRecordStepConfig$1 as RetrieveRecordStepConfig, type RetryFallback, type RunTaskContextBudgetBreakdown, type RunTaskContextCompactionEvent, type RunTaskContextCompactionStrategy, type RunTaskContextNoticeEvent, type RunTaskContextSummaryEntry, type RunTaskContinuation, type RunTaskOffloadRecorder, type RunTaskOnContextCompaction, type RunTaskOnContextNotice, type RunTaskOnSession, type RunTaskOptions, type RunTaskResult, type RunTaskResumeState, type RunTaskSessionSummary, type RunTaskState, type RunTaskStateSlice, type RunTaskStatus, type RunTaskToolTraceSlice, type RuntimeCustomToolConfig, type RuntimeExternalToolConfig, type RuntimeFlowToolConfig, type RuntimeLocalToolConfig, type RuntimeSubagentToolConfig, type RuntimeTool, type RuntimeToolConfig, Runtype, type AgentSkillBinding as RuntypeAgentSkillBinding, RuntypeApiError, RuntypeClient, type ConditionalStepConfig as RuntypeConditionalStepConfig, type RuntypeConfig, type FetchGitHubStepConfig as RuntypeFetchGitHubStepConfig, type FetchUrlStepConfig as RuntypeFetchUrlStepConfig, RuntypeFlowBuilder, type FlowConfig as RuntypeFlowConfig, type GenerateEmbeddingStepConfig as RuntypeGenerateEmbeddingStepConfig, type Message as RuntypeMessage, type ModelOverride$1 as RuntypeModelOverride, type Prompt as RuntypePrompt, type PromptStepConfig as RuntypePromptStepConfig, type RuntypeRecord, type RecordConfig as RuntypeRecordConfig, type RetrieveRecordStepConfig as RuntypeRetrieveRecordStepConfig, type SearchStepConfig as RuntypeSearchStepConfig, type SendEmailStepConfig as RuntypeSendEmailStepConfig, type SendEventStepConfig as RuntypeSendEventStepConfig, type SendStreamStepConfig as RuntypeSendStreamStepConfig, type SendTextStepConfig as RuntypeSendTextStepConfig, type SetVariableStepConfig as RuntypeSetVariableStepConfig, type Skill as RuntypeSkill, type SkillCapabilities as RuntypeSkillCapabilities, type SkillFrontmatter as RuntypeSkillFrontmatter, type SkillManifest as RuntypeSkillManifest, type SkillProposal as RuntypeSkillProposal, type SkillRuntypeExtensions as RuntypeSkillRuntypeExtensions, type SkillVersion as RuntypeSkillVersion, type TransformDataStepConfig as RuntypeTransformDataStepConfig, type UpsertFlowConfig as RuntypeUpsertFlowConfig, type UpsertRecordStepConfig as RuntypeUpsertRecordStepConfig, type VectorSearchStepConfig as RuntypeVectorSearchStepConfig, type WaitUntilStepConfig as RuntypeWaitUntilStepConfig, STEP_FIELD_REGISTRY, STEP_TYPE_TO_METHOD, type Schedule, type ScheduleExecutionOptions, type ScheduleListParams, type ScheduleMessage, type ScheduleMessageSet, type ScheduleMessages, type ScheduleMutationResponse, type ScheduleRun, type ScheduleRunNowResponse, type ScheduleStatusResponse, type ScheduleTarget, type ScheduleTrigger, SchedulesEndpoint, type SearchStepConfig$1 as SearchStepConfig, type Secret, type SecretCheckResponse, type SecretDeleteResponse, type SecretSetupUrlRequest, type SecretSetupUrlResponse, SecretsEndpoint, type SendEmailStepConfig$1 as SendEmailStepConfig, type SendEventStepConfig$1 as SendEventStepConfig, type SendStreamStepConfig$1 as SendStreamStepConfig, type SendTextStepConfig$1 as SendTextStepConfig, type SetVariableStepConfig$1 as SetVariableStepConfig, type SkillListPage, type SkillListPagination, type SkillListParams, type SkillManifestInput, type SkillMarkdownInput, type SkillOrigin, type SkillProposalStatus, SkillProposalsNamespace, type SkillStatus, type SkillTrustLevel, type SkillVersionStatus, type SkillWithVersion, type SkillWriteInput, SkillsNamespace, type SlackInstallRequest, type StepCompleteEvent, type StepDeltaEvent, type StepFallback, type StepFieldMeta, type StepStartEvent, type StepWaitingLocalEvent, type StreamCallbacks, type StreamEvent, type StreamEventOf, type SubagentToolConfig, type Surface, type SurfaceListParams, SurfacesEndpoint, type TextContentPart, type Tool, type ToolConfig, type ToolDefinition, type ToolDefinitionType, ToolDriftError, ToolEnsureConflictError, type ToolPullResult, type ToolWithValidation, type ToolsConfig, ToolsEndpoint, ToolsNamespace, type TransformDataStepConfig$1 as TransformDataStepConfig, type UpdateAppRequest, type UpdateClientTokenRequest, type UpdateConversationRequest, type UpdatePromptData, type UpdateProviderKeyRequest, type UpdateScheduleRequest, type UpdateSecretRequest, type UpdateToolRequest, type UpdatedFlow, type UpsertFlowConfig$1 as UpsertFlowConfig, type UpsertOptions, type UpsertRecordStepConfig$1 as UpsertRecordStepConfig, type UserProfile, UsersEndpoint, type VectorSearchStepConfig$1 as VectorSearchStepConfig, type VersionType, type WaitUntilStepConfig$1 as WaitUntilStepConfig, type WorkflowCompileDeps, type WorkflowCompletionCriteriaConfig, type WorkflowConfig, type WorkflowConfigFactory, type WorkflowContext, type WorkflowDefinition, type WorkflowHookEntry, type WorkflowHookKind, type WorkflowHookRef, type WorkflowHookSignatures, type WorkflowMilestoneConfig, type WorkflowPhase, type WorkflowPolicyConfig, type WorkflowRecoveryConfig, type WorkflowSlot, type WorkflowStallPolicy, applyGeneratedRuntimeToolProposalToDispatchRequest, attachRuntimeToolsToDispatchRequest, buildEmptySessionNudge, buildGeneratedRuntimeToolGateOutput, buildLedgerOffloadReference, buildPolicyGuidance, buildSendViewOffloadMarker, compileWorkflowConfig, computeAgentContentHash, computeFlowContentHash, computeToolContentHash, createClient, createExternalTool, defaultWorkflow, defaultWorkflowConfig, defineAgent, defineFlow, definePlaybook, defineTool, deployWorkflow, ensureDefaultWorkflowHooks, evaluateGeneratedRuntimeToolProposal, extractDeclaredToolResultChars, gameWorkflow, getDefaultPlanPath, getLikelySupportingCandidatePaths, interpolateWorkflowTemplate, isDiscoveryToolName, isMarathonArtifactPath, isPreservationSensitiveTask, isWorkflowHookRef, listWorkflowHooks, normalizeAgentDefinition, normalizeCandidatePath, normalizeToolDefinition, parseFinalBuffer, parseLedgerArtifactRelativePath, parseOffloadedOutputId, parseSSEChunk, processStream, registerWorkflowHook, resolveStallStopAfter, resolveWorkflowHook, sanitizeTaskSlug, shouldInjectEmptySessionNudge, shouldRequestModelEscalation, streamEvents, unregisterWorkflowHook };