@undefineds.co/xpod 0.4.20 → 0.4.27

package/dist/api/tasks/TaskMaterializer.d.ts

@@ -2,7 +2,7 @@ import type { ChatKitStore, StoreContext } from '../chatkit/store';
 import type { ThreadItem } from '../chatkit/types';
 import type { RunContextRetriever, RunExecutionBackend } from '../runs/RunExecutionBackend';
 import { type RunRecordData, type RunStore } from '../runs/store';
-import { type TaskRecordData } from './store';
+import type { TaskRecordData } from './store';
 import type { AiConnectionsInvocationKeyIssuer } from '../ai-gateway/auth/AiConnectionsInvocationKeyIssuer';
 export interface MaterializedTaskRun {
     task: TaskRecordData;
@@ -21,6 +21,7 @@ export declare class TaskMaterializer<TContext = StoreContext> {
     private readonly store;
     private readonly executionBackend;
     private readonly executeRuns;
+    private readonly continuation;
     private readonly contextRetriever?;
     private readonly aiConnectionInvocationKeyIssuer?;
     private readonly requireAiConnectionsInvocationKeyIssuer;
@@ -28,6 +29,8 @@ export declare class TaskMaterializer<TContext = StoreContext> {
     materialize(input: {
         task: TaskRecordData;
         context: TContext;
+        /** Return the persisted Run while the existing runner executes it. */
+        background?: boolean;
         trigger: {
             kind: 'once' | 'interval' | 'cron' | 'event' | 'manual';
             scheduledFor?: number;
@@ -36,6 +39,7 @@ export declare class TaskMaterializer<TContext = StoreContext> {
         };
     }): Promise<MaterializedTaskRun>;
     private withInvocationAiConnections;
+    resumeClientToolOutput(run: RunRecordData, itemId: string, output: string, approval: string, context: TContext): Promise<boolean>;
     private executeRun;
     private retrieveRunContext;
     private ensureThread;
@@ -58,8 +62,5 @@ export declare class TaskMaterializer<TContext = StoreContext> {
     private resolveTaskThreadParentKey;
     private parseThreadResource;
     private extractThreadId;
-    private resolveTaskResource;
-    private resolveRunResource;
-    private resolvePodBaseUrl;
     private hasSaveTask;
 }

package/dist/api/tasks/TaskMaterializer.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskMaterializer = void 0;
+const TaskResumeDiagnostics_1 = require("./TaskResumeDiagnostics");
+const RunCancellation_1 = require("../runs/RunCancellation");
+const global_logger_factory_1 = require("global-logger-factory");
+const RunApproval_1 = require("../runs/RunApproval");
+const RunStateCenter_1 = require("../runs/RunStateCenter");
+const cron_1 = require("./cron");
 const types_1 = require("../chatkit/types");
 const InngestRunExecutionBackend_1 = require("../runs/InngestRunExecutionBackend");
 const schema_1 = require("../runs/schema");
@@ -8,21 +14,23 @@ const store_1 = require("../runs/store");
 const AgentRuntimeTypes_1 = require("../runs/AgentRuntimeTypes");
 const types_2 = require("../workspace/types");
 const schema_2 = require("./schema");
-const store_2 = require("./store");
 class TaskMaterializer {
     constructor(options) {
         this.store = options.store;
         this.executionBackend = options.executionBackend ?? new InngestRunExecutionBackend_1.InngestRunExecutionBackend();
         this.executeRuns = options.executeRuns ?? true;
+        this.continuation = new RunStateCenter_1.RunStateCenter({ store: options.store, enableAgentRuntime: true,
+            executionBackend: this.executionBackend, contextRetriever: options.contextRetriever });
         this.contextRetriever = options.contextRetriever;
         this.aiConnectionInvocationKeyIssuer = options.aiConnectionInvocationKeyIssuer;
         this.requireAiConnectionsInvocationKeyIssuer = options.requireAiConnectionsInvocationKeyIssuer ?? false;
     }
     async materialize(input) {
         const { task, context, trigger } = input;
-        if (task.status !== schema_2.TaskStatus.ACTIVE) {
+        if (task.status !== schema_2.TaskStatus.ACTIVE && !(trigger.kind === 'manual' && task.status === schema_2.TaskStatus.BLOCKED)) {
             throw new Error(`Task ${task.id} is not active`);
         }
+        const executionContext = this.executeRuns ? await this.withInvocationAiConnections(context) : context;
         const threadRef = this.threadRefFromTask(task);
         const thread = await this.ensureThread(task, context);
         const prompt = this.buildPrompt(task, trigger);
@@ -34,26 +42,40 @@ class TaskMaterializer {
         if (task.triggerKind === schema_2.TaskTriggerKind.ONCE) {
             task.nextRunAt = undefined;
         }
-        else if (task.triggerKind === schema_2.TaskTriggerKind.INTERVAL) {
+        else if (trigger.kind !== 'manual' && task.triggerKind === schema_2.TaskTriggerKind.INTERVAL) {
             task.nextRunAt = this.computeNextIntervalRunAt(task, task.lastRunAt);
         }
-        else if (task.triggerKind === schema_2.TaskTriggerKind.CRON) {
+        else if (trigger.kind !== 'manual' && task.triggerKind === schema_2.TaskTriggerKind.CRON) {
             task.nextRunAt = this.computeNextCronRunAt(task, task.lastRunAt);
         }
         if (this.hasSaveTask(this.store)) {
             await this.store.saveTask(task, context);
         }
         if (this.executeRuns) {
-            const executionContext = await this.withInvocationAiConnections(context);
-            const assistant = await this.executeRun({ task, thread, run, userMessage, context: executionContext });
-            if (task.triggerKind === schema_2.TaskTriggerKind.ONCE) {
-                task.status = run.status === schema_1.RunStatus.COMPLETED ? schema_2.TaskStatus.COMPLETED : schema_2.TaskStatus.FAILED;
-                task.updatedAt = (0, types_1.nowTimestamp)();
-                if (this.hasSaveTask(this.store)) {
-                    await this.store.saveTask(task, context);
+            const execute = async () => {
+                const assistant = await this.executeRun({ task, thread, run, userMessage, context: executionContext });
+                if (task.triggerKind === schema_2.TaskTriggerKind.ONCE) {
+                    task.status = run.status === schema_1.RunStatus.COMPLETED ? schema_2.TaskStatus.COMPLETED : schema_2.TaskStatus.FAILED;
+                    task.updatedAt = (0, types_1.nowTimestamp)();
+                    if (this.hasSaveTask(this.store)) {
+                        await this.store.saveTask(task, context);
+                    }
                 }
+                return { task, run, assistant };
+            };
+            if (input.background) {
+                const accepted = { task: { ...task }, run: { ...run } };
+                void execute().catch(async (error) => {
+                    try {
+                        await this.finishRun(run, schema_1.RunStatus.FAILED, executionContext, String(error));
+                    }
+                    catch (persistenceError) {
+                        (0, global_logger_factory_1.getLoggerFor)(this).error(`Unable to persist background Run failure: ${String(persistenceError)}`);
+                    }
+                });
+                return accepted;
             }
-            return { task, run, assistant };
+            return execute();
         }
         if (task.triggerKind === schema_2.TaskTriggerKind.ONCE) {
             task.status = schema_2.TaskStatus.COMPLETED;
@@ -76,91 +98,149 @@ class TaskMaterializer {
             aiConnection: await this.aiConnectionInvocationKeyIssuer.issue(context),
         };
     }
+    async resumeClientToolOutput(run, itemId, output, approval, context) {
+        const executionContext = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('invocation_issue', () => this.withInvocationAiConnections(context));
+        const prepared = await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('continuation_prepare', async () => {
+            const prepared = await this.continuation.prepareClientToolOutput({
+                threadRef: (0, types_1.toThreadRef)({ thread_id: run.thread }), itemId, output, context: executionContext,
+            });
+            if (prepared)
+                prepared.claim.item.metadata = { ...prepared.claim.item.metadata, approval };
+            return prepared;
+        });
+        if (!prepared)
+            return false;
+        let completed = false;
+        try {
+            await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('continuation_complete', async () => {
+                for await (const _event of this.continuation.completePreparedClientToolOutput(prepared, executionContext)) { /* Durable state is the result. */ }
+            });
+            completed = true;
+            return true;
+        }
+        finally {
+            if (!completed)
+                await (0, TaskResumeDiagnostics_1.withTaskResumeStage)('continuation_release', () => this.continuation.releaseClientToolOutput(prepared, executionContext));
+        }
+    }
     async executeRun(input) {
         const { task, thread, run, userMessage, context } = input;
         const runtimeConfig = (0, AgentRuntimeTypes_1.withInvocationAiConnections)(this.buildRuntimeConfig(task), context);
         const threadRef = this.threadRefFromTask(task);
         const assistantItem = await this.createAssistantMessage(thread, context);
         await this.store.addThreadItem(threadRef, assistantItem, context);
-        await this.markRunStarted(run, context);
+        if (!await this.markRunStarted(run, context)) {
+            assistantItem.status = 'incomplete';
+            await this.store.saveItem(threadRef, assistantItem, context);
+            return assistantItem;
+        }
         let fullText = '';
         let runtimeError;
         const prompt = run.prompt ?? task.prompt;
-        const conversation = await this.loadConversation(threadRef, userMessage.id, context);
-        const retrievedContext = await this.retrieveRunContext({
-            runId: run.id,
-            threadId: thread.id,
-            prompt,
-            conversation,
-            config: runtimeConfig,
-            context,
-        });
-        for await (const event of this.executionBackend.start({
-            runId: run.id,
-            threadId: thread.id,
-            prompt,
-            conversation,
-            retrievedContext,
-            config: runtimeConfig,
-            authBindingId: task.authBinding?.id,
-            context: context,
-        })) {
-            if (event.type === 'text') {
-                fullText += event.text;
-                await this.appendRunStep(run, schema_1.XpodRunStepType.TEXT_DELTA, context, {
-                    message: event.text,
-                    data: { delta: event.text },
-                });
-                continue;
-            }
-            if (event.type === 'auth_required') {
-                await this.appendRunStep(run, schema_1.XpodRunStepType.AUTH_REQUIRED, context, {
-                    message: event.message,
-                    data: {
-                        method: event.method,
-                        url: event.url,
-                        options: event.options,
-                    },
-                });
-                continue;
-            }
-            if (event.type === 'tool_call') {
-                await this.appendRunStep(run, schema_1.XpodRunStepType.TOOL_CALL, context, {
-                    message: event.name,
-                    data: {
-                        requestId: event.requestId,
-                        name: event.name,
-                        arguments: event.arguments,
-                    },
-                });
-                await this.finishRun(run, schema_1.RunStatus.WAITING_INPUT, context, `Tool call ${event.name} requires steering`);
-                assistantItem.status = 'incomplete';
-                assistantItem.content = [{ type: 'output_text', text: fullText }];
-                await this.store.saveItem(threadRef, assistantItem, context);
-                return assistantItem;
-            }
-            if (event.type === 'waiting_runner') {
+        let monitor;
+        try {
+            const conversation = await this.loadConversation(threadRef, userMessage.id, context);
+            const retrievedContext = await this.retrieveRunContext({
+                runId: run.id,
+                threadId: thread.id,
+                prompt,
+                conversation,
+                config: runtimeConfig,
+                context,
+            });
+            monitor = await (0, RunCancellation_1.monitorRunCancellation)({ store: this.store, runId: run.id, context });
+            for await (const event of this.executionBackend.start({
+                signal: monitor.signal,
+                runId: run.id,
+                threadId: thread.id,
+                prompt,
+                conversation,
+                retrievedContext,
+                config: runtimeConfig,
+                authBindingId: task.authBinding?.id,
+                context: context,
+            })) {
+                const latest = await this.store.loadRun(run.id, context);
+                if (latest.cancelRequestedAt) {
+                    run.cancelRequestedAt = latest.cancelRequestedAt;
+                    break;
+                }
+                if (event.type === 'text') {
+                    fullText += event.text;
+                    await this.appendRunStep(run, schema_1.XpodRunStepType.TEXT_DELTA, context, {
+                        message: event.text,
+                        data: { delta: event.text },
+                    });
+                    continue;
+                }
+                if (event.type === 'auth_required') {
+                    await this.appendRunStep(run, schema_1.XpodRunStepType.AUTH_REQUIRED, context, {
+                        message: event.message,
+                        data: {
+                            method: event.method,
+                            url: event.url,
+                            options: event.options,
+                        },
+                    });
+                    continue;
+                }
+                if (event.type === 'tool_call') {
+                    await this.appendRunStep(run, schema_1.XpodRunStepType.TOOL_CALL, context, {
+                        message: event.name,
+                        data: {
+                            requestId: event.requestId,
+                            name: event.name,
+                            arguments: event.arguments,
+                        },
+                    });
+                    const toolItem = {
+                        id: this.store.generateItemId('client_tool_call', thread, context), thread_id: thread.id,
+                        type: 'client_tool_call', name: event.name, arguments: event.arguments,
+                        call_id: event.requestId, status: 'pending', created_at: (0, types_1.nowTimestamp)(),
+                        metadata: { runId: run.id, assistantItemId: assistantItem.id },
+                    };
+                    await this.store.addThreadItem(threadRef, toolItem, context);
+                    await (0, RunApproval_1.persistRunApproval)({ store: this.store, run, event, context });
+                    run.metadata = { ...run.metadata, assistantItemId: assistantItem.id,
+                        waitingTool: { itemId: toolItem.id, requestId: event.requestId, name: event.name } };
+                    await this.finishRun(run, schema_1.RunStatus.WAITING_INPUT, context, `Tool call ${event.name} requires steering`);
+                    assistantItem.status = 'incomplete';
+                    assistantItem.content = [{ type: 'output_text', text: fullText }];
+                    await this.store.saveItem(threadRef, assistantItem, context);
+                    return assistantItem;
+                }
+                if (event.type === 'waiting_runner') {
+                    runtimeError = event.message;
+                    await this.appendRunStep(run, schema_1.XpodRunStepType.WAITING_RUNNER, context, {
+                        message: event.message,
+                        data: { workspace: event.workspace },
+                    });
+                    await this.finishRun(run, schema_1.RunStatus.WAITING_RUNNER, context, event.message);
+                    assistantItem.status = 'incomplete';
+                    assistantItem.content = [{ type: 'output_text', text: fullText }];
+                    await this.store.saveItem(threadRef, assistantItem, context);
+                    return assistantItem;
+                }
                 runtimeError = event.message;
-                await this.appendRunStep(run, schema_1.XpodRunStepType.WAITING_RUNNER, context, {
+                await this.appendRunStep(run, schema_1.XpodRunStepType.ERROR, context, {
                     message: event.message,
-                    data: { workspace: event.workspace },
                 });
-                await this.finishRun(run, schema_1.RunStatus.WAITING_RUNNER, context, event.message);
-                assistantItem.status = 'incomplete';
-                assistantItem.content = [{ type: 'output_text', text: fullText }];
-                await this.store.saveItem(threadRef, assistantItem, context);
-                return assistantItem;
+                break;
             }
-            runtimeError = event.message;
-            await this.appendRunStep(run, schema_1.XpodRunStepType.ERROR, context, {
-                message: event.message,
-            });
-            break;
         }
-        assistantItem.status = runtimeError ? 'incomplete' : 'completed';
+        catch (error) {
+            if (!monitor?.signal.aborted)
+                runtimeError = String(error);
+        }
+        finally {
+            monitor?.dispose();
+        }
+        if (monitor?.error)
+            runtimeError = `Unable to read execution state: ${String(monitor.error)}`;
         assistantItem.content = [{ type: 'output_text', text: fullText }];
-        await this.store.saveItem(threadRef, assistantItem, context);
         await this.finishRun(run, runtimeError ? schema_1.RunStatus.FAILED : schema_1.RunStatus.COMPLETED, context, runtimeError);
+        assistantItem.status = run.status === schema_1.RunStatus.COMPLETED ? 'completed' : 'incomplete';
+        await this.store.saveItem(threadRef, assistantItem, context);
         return assistantItem;
     }
     async retrieveRunContext(input) {
@@ -187,7 +267,7 @@ class TaskMaterializer {
                 created_at: now,
                 updated_at: now,
                 metadata: {
-                    task: this.resolveTaskResource(task, context),
+                    task: task.id,
                     runtime: {
                         workspace: task.workspace,
                         runner: this.parseRunner(task.runner),
@@ -208,7 +288,7 @@ class TaskMaterializer {
                 parentKey: taskParentKey,
                 createdAt: now,
             }),
-            task: this.resolveTaskResource(task, context),
+            task: task.id,
             thread: task.thread,
             workspace: task.workspace,
             status: schema_1.RunStatus.QUEUED,
@@ -246,9 +326,15 @@ class TaskMaterializer {
         run.startedAt = now;
         run.updatedAt = now;
         await this.store.saveRun(run, context);
+        if (run.cancelRequestedAt || run.status === schema_1.RunStatus.CANCELLED) {
+            await this.finishRun(run, schema_1.RunStatus.CANCELLED, context);
+            return false;
+        }
+        await (0, RunApproval_1.updateRunApprovalSession)(this.store, run, 'active', context);
         await this.appendRunStep(run, schema_1.XpodRunStepType.STARTED, context, {
             message: 'Task run started',
         });
+        return true;
     }
     async finishRun(run, status, context, error) {
         const now = (0, types_1.nowTimestamp)();
@@ -257,6 +343,9 @@ class TaskMaterializer {
         run.updatedAt = now;
         run.error = error;
         await this.store.saveRun(run, context);
+        status = run.status;
+        error = run.error;
+        await (0, RunApproval_1.updateRunApprovalSession)(this.store, run, status === 'waiting_input' || status === 'waiting_runner' ? 'paused' : status === 'failed' ? 'error' : 'completed', context);
         await this.appendRunStep(run, this.stepTypeForStatus(status), context, {
             message: error ?? `Run ${status}`,
             data: { status },
@@ -289,7 +378,7 @@ class TaskMaterializer {
                 createdAt,
             }),
             runId: run.id,
-            run: this.resolveRunResource(run, context),
+            run: run.id,
             type,
             message: options.message,
             data: options.data,
@@ -379,12 +468,7 @@ class TaskMaterializer {
         return from + task.intervalSeconds;
     }
     computeNextCronRunAt(task, from) {
-        const firstField = task.cron?.trim().split(/\s+/)[0];
-        const everyMinuteMatch = firstField?.match(/^\*\/(\d+)$/);
-        if (everyMinuteMatch) {
-            return from + Math.max(1, Number(everyMinuteMatch[1])) * 60;
-        }
-        return from + 60;
+        return (0, cron_1.nextCronOccurrence)(task.cron ?? '', from);
     }
     threadRefFromTask(task) {
         const parsed = this.parseThreadResource(task.thread);
@@ -440,42 +524,6 @@ class TaskMaterializer {
         }
         return thread;
     }
-    resolveTaskResource(task, context) {
-        const podBaseUrl = this.resolvePodBaseUrl(context);
-        if (podBaseUrl) {
-            return (0, store_2.resolveTaskResource)(podBaseUrl, task.id);
-        }
-        return (0, store_2.resolveTaskUrn)(task.id);
-    }
-    resolveRunResource(run, context) {
-        const podBaseUrl = this.resolvePodBaseUrl(context);
-        if (podBaseUrl) {
-            return (0, store_1.resolveDataResource)(podBaseUrl, run.id);
-        }
-        return (0, store_1.resolveRunUrn)(run.id);
-    }
-    resolvePodBaseUrl(context) {
-        const auth = context.auth;
-        const webId = typeof auth?.webId === 'string' ? auth.webId : undefined;
-        if (!webId) {
-            return undefined;
-        }
-        try {
-            const url = new URL(webId);
-            url.hash = '';
-            url.search = '';
-            const normalizedPath = url.pathname.replace(/\/+$/, '');
-            if (!normalizedPath.endsWith('/profile/card')) {
-                return undefined;
-            }
-            const podPath = normalizedPath.slice(0, -'/profile/card'.length) || '/';
-            url.pathname = podPath;
-            return url.toString().replace(/\/$/, '');
-        }
-        catch {
-            return undefined;
-        }
-    }
     hasSaveTask(value) {
         return typeof value.saveTask === 'function';
     }

package/dist/api/tasks/TaskResumeDiagnostics.d.ts

@@ -0,0 +1,28 @@
+/** Fixed resume boundaries, never derived from error prose or caller metadata. */
+export declare const TASK_RESUME_STAGES: readonly ["route_request", "route_validation", "route_run_read", "run_read", "approval_validation", "checkpoint_validation", "task_lookup", "task_auth_restore", "invocation_issue", "continuation_prepare", "continuation_complete", "continuation_release", "run_result_read"];
+export type TaskResumeStage = typeof TASK_RESUME_STAGES[number];
+export declare function getTaskResumeStage(error: unknown): TaskResumeStage | undefined;
+/** First inner boundary wins; frozen errors and original throw semantics are preserved. */
+export declare function withTaskResumeStage<T>(stage: TaskResumeStage, operation: () => Promise<T>): Promise<T>;
+export declare const TASK_RESUME_ERROR_TYPES: readonly ["error", "type_error", "range_error", "syntax_error", "non_error"];
+export type TaskResumeErrorType = typeof TASK_RESUME_ERROR_TYPES[number];
+export declare function getTaskResumeErrorType(error: unknown): TaskResumeErrorType;
+export declare const TASK_RESUME_FAILURE_NAMES: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
+export declare const TASK_RESUME_FAILURE_CODES: readonly ["ENOSPC", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "EACCES", "ERR_INVALID_URL"];
+export declare const TASK_RESUME_SITE_MODULES: readonly ["api/runs/RunStateCenter", "api/runs/InngestRunExecutionBackend", "api/runs/ConditionalResourceDocument", "api/runs/RunApproval", "api/runs/RunCancellation", "api/runs/ManagedRunWorker", "api/runs/store", "api/chatkit/pod-store", "api/tasks/TaskMaterializer", "api/tasks/TaskService", "api/handlers/TaskHandler"];
+export interface TaskResumeFailure {
+    name: typeof TASK_RESUME_FAILURE_NAMES[number];
+    code?: typeof TASK_RESUME_FAILURE_CODES[number];
+    causeCode?: typeof TASK_RESUME_FAILURE_CODES[number];
+    site?: {
+        module: typeof TASK_RESUME_SITE_MODULES[number];
+        line: number;
+        column: number;
+        coordinate: 'compiled_js' | 'source_ts';
+        kind: 'first_project_frame';
+    };
+}
+/** The same strict schema is used for HTTP evidence; unknown fields are never copied. */
+export declare function selectTaskResumeFailure(value: unknown): TaskResumeFailure | undefined;
+/** Attribution only: a whitelisted project frame may be a caller of an external origin. */
+export declare function getTaskResumeFailure(error: unknown): TaskResumeFailure | undefined;

package/dist/api/tasks/TaskResumeDiagnostics.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_RESUME_SITE_MODULES = exports.TASK_RESUME_FAILURE_CODES = exports.TASK_RESUME_FAILURE_NAMES = exports.TASK_RESUME_ERROR_TYPES = exports.TASK_RESUME_STAGES = void 0;
+exports.getTaskResumeStage = getTaskResumeStage;
+exports.withTaskResumeStage = withTaskResumeStage;
+exports.getTaskResumeErrorType = getTaskResumeErrorType;
+exports.selectTaskResumeFailure = selectTaskResumeFailure;
+exports.getTaskResumeFailure = getTaskResumeFailure;
+const node_util_1 = require("node:util");
+/** Fixed resume boundaries, never derived from error prose or caller metadata. */
+exports.TASK_RESUME_STAGES = [
+    'route_request', 'route_validation', 'route_run_read', 'run_read', 'approval_validation',
+    'checkpoint_validation', 'task_lookup', 'task_auth_restore', 'invocation_issue',
+    'continuation_prepare', 'continuation_complete', 'continuation_release', 'run_result_read',
+];
+const stages = new WeakMap();
+function getTaskResumeStage(error) {
+    return error instanceof Error ? stages.get(error) : undefined;
+}
+/** First inner boundary wins; frozen errors and original throw semantics are preserved. */
+async function withTaskResumeStage(stage, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof Error && exports.TASK_RESUME_STAGES.includes(stage) && !stages.has(error))
+            stages.set(error, stage);
+        throw error;
+    }
+}
+exports.TASK_RESUME_ERROR_TYPES = ['error', 'type_error', 'range_error', 'syntax_error', 'non_error'];
+function getTaskResumeErrorType(error) {
+    if (error instanceof TypeError)
+        return 'type_error';
+    if (error instanceof RangeError)
+        return 'range_error';
+    if (error instanceof SyntaxError)
+        return 'syntax_error';
+    return error instanceof Error ? 'error' : 'non_error';
+}
+exports.TASK_RESUME_FAILURE_NAMES = ['Error', 'TypeError', 'RangeError', 'SyntaxError',
+    'ReferenceError', 'EvalError', 'URIError', 'AggregateError'];
+exports.TASK_RESUME_FAILURE_CODES = ['ENOSPC', 'ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT',
+    'ENOTFOUND', 'EACCES', 'ERR_INVALID_URL'];
+exports.TASK_RESUME_SITE_MODULES = [
+    'api/runs/RunStateCenter', 'api/runs/InngestRunExecutionBackend', 'api/runs/ConditionalResourceDocument',
+    'api/runs/RunApproval', 'api/runs/RunCancellation', 'api/runs/ManagedRunWorker', 'api/runs/store',
+    'api/chatkit/pod-store', 'api/tasks/TaskMaterializer', 'api/tasks/TaskService', 'api/handlers/TaskHandler',
+];
+function ownValue(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && 'value' in descriptor ? descriptor.value : undefined;
+}
+function allowed(value, values) {
+    return typeof value === 'string' && values.some(entry => entry === value);
+}
+function coordinate(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 && value <= 1_000_000;
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+}
+/** The same strict schema is used for HTTP evidence; unknown fields are never copied. */
+function selectTaskResumeFailure(value) {
+    try {
+        if (!record(value) || Object.keys(value).some(key => !['name', 'code', 'causeCode', 'site'].includes(key)))
+            return undefined;
+        const name = ownValue(value, 'name');
+        if (!allowed(name, exports.TASK_RESUME_FAILURE_NAMES))
+            return undefined;
+        const result = { name };
+        for (const key of ['code', 'causeCode']) {
+            const code = ownValue(value, key);
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                if (!allowed(code, exports.TASK_RESUME_FAILURE_CODES))
+                    return undefined;
+                result[key] = code;
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(value, 'site')) {
+            const site = ownValue(value, 'site');
+            if (!record(site) || Object.keys(site).some(key => !['module', 'line', 'column', 'coordinate', 'kind'].includes(key)))
+                return undefined;
+            const module = ownValue(site, 'module');
+            const line = ownValue(site, 'line');
+            const column = ownValue(site, 'column');
+            const location = ownValue(site, 'coordinate');
+            if (!allowed(module, exports.TASK_RESUME_SITE_MODULES) || !coordinate(line) || !coordinate(column)
+                || !allowed(location, ['compiled_js', 'source_ts']) || ownValue(site, 'kind') !== 'first_project_frame')
+                return undefined;
+            result.site = { module, line, column, coordinate: location, kind: 'first_project_frame' };
+        }
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Attribution only: a whitelisted project frame may be a caller of an external origin. */
+function getTaskResumeFailure(error) {
+    try {
+        if (!node_util_1.types.isNativeError(error))
+            return undefined;
+        const native = error;
+        const name = native instanceof TypeError ? 'TypeError'
+            : native instanceof RangeError ? 'RangeError' : native instanceof SyntaxError ? 'SyntaxError'
+                : native instanceof ReferenceError ? 'ReferenceError' : native instanceof EvalError ? 'EvalError'
+                    : native instanceof URIError ? 'URIError' : native instanceof AggregateError ? 'AggregateError' : 'Error';
+        const result = { name };
+        const code = ownValue(native, 'code');
+        if (allowed(code, exports.TASK_RESUME_FAILURE_CODES))
+            result.code = code;
+        const cause = ownValue(native, 'cause');
+        const causeCode = node_util_1.types.isNativeError(cause) ? ownValue(cause, 'code') : undefined;
+        if (allowed(causeCode, exports.TASK_RESUME_FAILURE_CODES))
+            result.causeCode = causeCode;
+        for (const field of ['message', 'name']) {
+            const descriptor = Object.getOwnPropertyDescriptor(native, field);
+            if (descriptor && (!('value' in descriptor) || typeof descriptor.value !== 'string'
+                || descriptor.value.length > 8192 || /[\r\n]/.test(descriptor.value)))
+                return result;
+        }
+        const stack = ownValue(native, 'stack');
+        if (typeof stack !== 'string' || stack.length > 8192)
+            return result;
+        // Ignore the message line; parse only bounded V8/Bun frame lines, never eval or user paths.
+        for (const frame of stack.split('\n').slice(1, 17)) {
+            const match = /^\s+at (?:async )?(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)* \()?((?:file:\/\/)?\/app\/(dist|src)\/(api\/[A-Za-z0-9/_-]+)\.(js|ts)):(\d{1,7}):(\d{1,7})\)?$/.exec(frame);
+            if (frame.includes('(') !== frame.endsWith(')'))
+                continue;
+            if (!match || (match[2] === 'dist' ? match[4] !== 'js' : match[4] !== 'ts'))
+                continue;
+            const module = match[3];
+            const line = Number(match[5]);
+            const column = Number(match[6]);
+            if (!allowed(module, exports.TASK_RESUME_SITE_MODULES) || !coordinate(line) || !coordinate(column))
+                continue;
+            result.site = { module, line, column, coordinate: match[2] === 'dist' ? 'compiled_js' : 'source_ts', kind: 'first_project_frame' };
+            break;
+        }
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=TaskResumeDiagnostics.js.map