@undefineds.co/xpod 0.4.19 → 0.4.25

package/dist/api/runs/ManagedRunWorker.js

@@ -6,6 +6,8 @@ const AgentRuntimeTypes_1 = require("./AgentRuntimeTypes");
 const schema_1 = require("./schema");
 const store_1 = require("./store");
 const types_2 = require("../workspace/types");
+const RunCancellation_1 = require("./RunCancellation");
+const RunApproval_1 = require("./RunApproval");
 const RUN_WAITING_STATUSES = new Set([
     schema_1.RunStatus.WAITING_INPUT,
     schema_1.RunStatus.WAITING_RUNNER,
@@ -50,50 +52,80 @@ class ManagedRunWorker {
             config: runtimeConfig,
             context,
         });
-        for await (const event of this.runtimeDriver.start({
-            runId: run.id,
-            threadId: thread.id,
-            prompt,
-            conversation,
-            retrievedContext,
-            config: runtimeConfig,
-            authBindingId: this.authBindingIdFromRun(run),
-            context: context,
-        })) {
-            const cancellation = await this.checkCancellation(run, context);
-            if (cancellation) {
-                assistantItem.status = 'incomplete';
-                assistantItem.content = [{ type: 'output_text', text: fullText }];
-                await this.store.saveItem(threadRef, assistantItem, context);
-                return { runId, status: cancellation };
-            }
-            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' || event.type === 'tool_call' || event.type === 'waiting_runner') {
-                const terminalStatus = await this.handleRuntimeControlEvent(event, run, assistantItem, threadRef, context, fullText);
-                if (terminalStatus) {
-                    return { runId, status: terminalStatus };
+        const cancellationMonitor = await (0, RunCancellation_1.monitorRunCancellation)({ store: this.store, runId: run.id, context });
+        const finishCancellation = async () => {
+            const status = await this.checkCancellation(run, context);
+            if (!status)
+                return undefined;
+            assistantItem.status = 'incomplete';
+            assistantItem.content = [{ type: 'output_text', text: fullText }];
+            await this.store.saveItem(threadRef, assistantItem, context);
+            return { runId, status };
+        };
+        try {
+            if (cancellationMonitor.error)
+                throw cancellationMonitor.error;
+            const initialCancellation = await finishCancellation();
+            if (initialCancellation)
+                return initialCancellation;
+            for await (const event of this.runtimeDriver.start({
+                signal: cancellationMonitor.signal,
+                runId: run.id,
+                threadId: thread.id,
+                prompt,
+                conversation,
+                retrievedContext,
+                config: runtimeConfig,
+                authBindingId: this.authBindingIdFromRun(run),
+                context: context,
+            })) {
+                const cancelled = await finishCancellation();
+                if (cancelled)
+                    return cancelled;
+                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;
                 }
-                continue;
+                if (event.type === 'auth_required' || event.type === 'tool_call' || event.type === 'waiting_runner') {
+                    const terminalStatus = await this.handleRuntimeControlEvent(event, run, assistantItem, threadRef, context, fullText);
+                    if (terminalStatus) {
+                        return { runId, status: terminalStatus };
+                    }
+                    continue;
+                }
+                runtimeError = event.message;
+                await this.appendRunStep(run, schema_1.XpodRunStepType.ERROR, context, {
+                    message: event.message,
+                });
+                break;
             }
-            runtimeError = event.message;
-            await this.appendRunStep(run, schema_1.XpodRunStepType.ERROR, context, {
-                message: event.message,
-            });
-            break;
         }
-        assistantItem.status = runtimeError ? 'incomplete' : 'completed';
-        assistantItem.content = [{ type: 'output_text', text: fullText }];
-        await this.store.saveItem(threadRef, assistantItem, context);
+        catch (error) {
+            if (cancellationMonitor.error)
+                throw cancellationMonitor.error;
+            const cancelled = await finishCancellation();
+            if (cancelled)
+                return cancelled;
+            throw error;
+        }
+        finally {
+            cancellationMonitor.dispose();
+        }
+        if (cancellationMonitor.error)
+            throw cancellationMonitor.error;
+        const cancelled = await finishCancellation();
+        if (cancelled)
+            return cancelled;
         const finalStatus = runtimeError ? schema_1.RunStatus.FAILED : schema_1.RunStatus.COMPLETED;
         await this.finishRun(run, finalStatus, context, runtimeError);
-        return { runId, status: finalStatus };
+        assistantItem.status = run.status === schema_1.RunStatus.COMPLETED ? 'completed' : 'incomplete';
+        assistantItem.content = [{ type: 'output_text', text: fullText }];
+        await this.store.saveItem(threadRef, assistantItem, context);
+        return { runId, status: run.status };
     }
     async retrieveRunContext(input) {
         const retrieved = await this.contextRetriever?.retrieve(input);
@@ -154,11 +186,8 @@ class ManagedRunWorker {
         if (!latest.cancelRequestedAt) {
             return undefined;
         }
+        run.cancelRequestedAt = latest.cancelRequestedAt;
         await this.finishRun(run, schema_1.RunStatus.CANCELLED, context, 'Run cancellation requested');
-        await this.appendRunStep(run, schema_1.XpodRunStepType.CANCELLED, context, {
-            message: 'Run cancelled',
-            data: { status: schema_1.RunStatus.CANCELLED },
-        });
         return schema_1.RunStatus.CANCELLED;
     }
     async loadExecutionInput(runId, context) {
@@ -302,11 +331,30 @@ class ManagedRunWorker {
                     arguments: event.arguments,
                 },
             });
+            const thread = await this.store.loadThread(threadRef, context);
+            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',
+                metadata: { runId: run.id, assistantItemId: assistantItem.id },
+                created_at: (0, types_1.nowTimestamp)(),
+            };
+            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 },
+            };
             assistantItem.status = 'incomplete';
             assistantItem.content = [{ type: 'output_text', text: fullText }];
             await this.store.saveItem(threadRef, assistantItem, context);
             await this.finishRun(run, schema_1.RunStatus.WAITING_INPUT, context, `Tool call ${event.name} requires steering`);
-            return schema_1.RunStatus.WAITING_INPUT;
+            return run.status;
         }
         if (event.type === 'waiting_runner') {
             await this.appendRunStep(run, schema_1.XpodRunStepType.WAITING_RUNNER, context, {
@@ -317,7 +365,7 @@ class ManagedRunWorker {
             assistantItem.content = [{ type: 'output_text', text: fullText }];
             await this.store.saveItem(threadRef, assistantItem, context);
             await this.finishRun(run, schema_1.RunStatus.WAITING_RUNNER, context, event.message);
-            return schema_1.RunStatus.WAITING_RUNNER;
+            return run.status;
         }
         return undefined;
     }
@@ -328,6 +376,9 @@ class ManagedRunWorker {
         run.heartbeatAt = now;
         run.updatedAt = now;
         await this.store.saveRun(run, context);
+        await (0, RunApproval_1.updateRunApprovalSession)(this.store, run, run.status === schema_1.RunStatus.CANCELLED ? 'completed' : 'active', context);
+        if (run.status === schema_1.RunStatus.CANCELLED || run.cancelRequestedAt !== undefined)
+            return;
         await this.appendRunStep(run, schema_1.XpodRunStepType.STARTED, context, {
             message: 'Run started',
         });
@@ -342,6 +393,9 @@ class ManagedRunWorker {
         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, RUN_WAITING_STATUSES.has(status) ? 'paused' : status === schema_1.RunStatus.FAILED ? 'error' : 'completed', context);
         await this.appendRunStep(run, this.stepTypeForStatus(status), context, {
             message: error ?? `Run ${status}`,
             data: { status },
@@ -371,7 +425,7 @@ class ManagedRunWorker {
                 createdAt,
             }),
             runId: run.id,
-            run: this.resolveRunResource(run, context),
+            run: run.id,
             type,
             message: options.message,
             data: options.data,
@@ -444,35 +498,6 @@ class ManagedRunWorker {
         }
         return thread;
     }
-    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;
-        }
-    }
 }
 exports.ManagedRunWorker = ManagedRunWorker;
 //# sourceMappingURL=ManagedRunWorker.js.map

package/dist/api/runs/PiAgentRuntimeDriver.d.ts

@@ -1,3 +1,4 @@
+import type { PodAccessFetchProvider } from '../ai-gateway/pod/OwnerPodAccess';
 import { type SolidFS, type SolidFsProjection } from '../../solidfs';
 import type { RdfSearchIndexingService } from '../service/RdfSearchIndexingService';
 import type { RdfSearchReconciliationRepository } from '../../search/RdfSearchReconciliationRepository';
@@ -5,6 +6,19 @@ import type { AgentRuntimeEvent } from './AgentRuntimeTypes';
 import type { RunExecutionBackend, RunExecutionInput } from './RunExecutionBackend';
 type PiSdk = typeof import('@mariozechner/pi-coding-agent');
 export interface PiAgentRuntimeDriverOptions {
+    /** Gateway transport bound by the host runtime; canonical client configuration stays unchanged. */
+    gatewayTransport?: {
+        canonicalBaseUrl: string;
+        baseUrl: string;
+        socketPath?: string;
+    };
+    /** The runtime's canonical Pod authority and storage root, captured at API startup. */
+    podWorkspaceMapping?: {
+        baseUrl: string;
+        rootFilePath: string;
+    };
+    /** Shared authenticated Pod access; hydration and sync remain in the host process. */
+    podAccess?: PodAccessFetchProvider;
     /**
      * local: run pi's full Agent Loop in the API process.
      * cloud: run the entire pi Agent Loop in a sandboxed worker process.
@@ -41,9 +55,11 @@ export interface PiAgentRuntimeDriverOptions {
 export declare class PiAgentRuntimeDriver implements RunExecutionBackend {
     private readonly options;
     private static sdkPromise?;
+    private readonly logger;
     private readonly git;
     private readonly warmRuntimes;
     private readonly solidfs;
+    private readonly podWorkspaceMapping?;
     constructor(options?: PiAgentRuntimeDriverOptions);
     private createDefaultSolidFsSyncer;
     start(input: RunExecutionInput): AsyncIterable<AgentRuntimeEvent>;
@@ -77,12 +93,28 @@ export declare class PiAgentRuntimeDriver implements RunExecutionBackend {
     private createSessionManager;
     private resolveSessionDir;
     private resolveWorkerPath;
+    private workerReadonlyPaths;
     private workerEnv;
     private extractText;
     private formatError;
+    /**
+     * Record a failed assistant turn with allowlisted wire facts only.
+     *
+     * The provider `errorMessage` can contain credentials, prompts, or response bodies, so it never
+     * leaves this method. What is kept is enough to place the failure: the protocol/provider/model
+     * and a stable coarse classification derived from the shape of the message (never its text).
+     */
+    private logAssistantFailure;
     private startupErrorToEvent;
     private logWorkspaceRollbackError;
     private loadPiSdk;
 }
+/**
+ * Coarse classification of a provider failure, derived only from the shape of the message.
+ *
+ * Never returns any part of the message text: it exists so an operator can tell an auth failure
+ * from a rate limit from a transport problem without reading a body that may hold credentials.
+ */
+export declare function classifyAssistantFailure(errorMessage: unknown): string;
 export declare const PI_AGENT_WORKER_EVENT_PREFIX = "XPOD_AGENT_EVENT ";
 export {};