@getpaseo/server 0.7.0-beta.3 → 0.7.0

package/dist/server/server/agent/agent-manager.js

@@ -1412,6 +1412,7 @@ export class AgentManager {
             }
             agent.pendingReplacement = false;
             const errorMsg = error instanceof Error ? error.message : "Failed to start turn";
+            pendingRun.start = { status: "failed", error: errorMsg };
             await this.handleStreamEvent(agent, {
                 type: "turn_failed",
                 provider: agent.provider,
@@ -1464,8 +1465,7 @@ export class AgentManager {
                 agent.pendingReplacement = false;
             }
             const turnStartedAt = new Date();
-            pendingRun.started = true;
-            pendingRun.turnId = turnId;
+            pendingRun.start = { status: "started", turnId };
             agent.activeForegroundTurnId = turnId;
             this.openActiveTurn(agent, turnId, turnStartedAt);
             agent.lifecycle = "running";
@@ -1739,7 +1739,8 @@ export class AgentManager {
             throw new Error(`Agent ${agentId} not found`);
         }
         const pendingRun = this.runs.getPendingRun(agentId);
-        if ((snapshot.lifecycle === "running" || pendingRun?.started) && !snapshot.pendingReplacement) {
+        if ((snapshot.lifecycle === "running" || pendingRun?.start.status === "started") &&
+            !snapshot.pendingReplacement) {
             return;
         }
         if (!snapshot.activeForegroundTurnId && !pendingRun && !snapshot.pendingReplacement) {
@@ -1794,12 +1795,16 @@ export class AgentManager {
                     return true;
                 }
                 const currentPendingRun = this.runs.getPendingRun(agentId);
-                if ((current.lifecycle === "running" || currentPendingRun?.started) &&
+                if ((current.lifecycle === "running" || currentPendingRun?.start.status === "started") &&
                     !current.pendingReplacement) {
                     finishOk();
                     return true;
                 }
-                if (current.lifecycle === "error" && !currentPendingRun?.started) {
+                if (currentPendingRun?.start.status === "failed") {
+                    finishErr(new Error(currentPendingRun.start.error));
+                    return true;
+                }
+                if (current.lifecycle === "error" && !currentPendingRun) {
                     finishErr(new Error(current.lastError ?? `Agent ${agentId} failed to start`));
                     return true;
                 }
@@ -1865,13 +1870,14 @@ export class AgentManager {
         if (!interruptAcknowledged) {
             return { status: settlement === "completed" ? "settled" : "refused" };
         }
-        if (settlement === "timed_out" && run.turnId) {
-            this.logger.warn({ agentId, turnId: run.turnId, kind: run.kind }, "cancelAgentRun: acknowledged turn still active after timeout, force-canceling");
+        const runTurnId = this.runs.getTurnId(agentId);
+        if (settlement === "timed_out" && runTurnId) {
+            this.logger.warn({ agentId, turnId: runTurnId, kind: run.kind }, "cancelAgentRun: acknowledged turn still active after timeout, force-canceling");
             await this.dispatchSessionEvent(agent, {
                 type: "turn_canceled",
                 provider: agent.provider,
                 reason: "interrupted",
-                turnId: run.turnId,
+                turnId: runTurnId,
             });
             await run.settledPromise;
         }
@@ -2090,7 +2096,7 @@ export class AgentManager {
             let currentStatus = initialStatus;
             let hasStarted = isAgentBusy(initialStatus) ||
                 Boolean(snapshot.activeForegroundTurnId) ||
-                Boolean(pendingForegroundRun?.started);
+                pendingForegroundRun?.start.status === "started";
             let terminalStatusOverride = null;
             let finished = false;
             // Bug #3 Fix: Declare unsubscribe and abortHandler upfront so cleanup can reference them
@@ -2395,7 +2401,7 @@ export class AgentManager {
             return;
         }
         const pendingRun = this.runs.getPendingRun(agentId);
-        if (pendingRun && !pendingRun.started) {
+        if (pendingRun?.start.status === "pending") {
             pendingRun.stagedEvents.push(event);
             return;
         }

package/dist/server/server/agent/agent-run-state.d.ts

@@ -10,8 +10,15 @@ export interface PendingForegroundRun {
     token: string;
     kind: "foreground";
     stagedEvents: AgentStreamEvent[];
-    turnId: string | null;
-    started: boolean;
+    start: {
+        status: "pending";
+    } | {
+        status: "started";
+        turnId: string;
+    } | {
+        status: "failed";
+        error: string;
+    };
     settled: boolean;
     settledPromise: Promise<void>;
     resolveSettled: () => void;
@@ -37,6 +44,7 @@ export declare class AgentRunState {
     hasPendingRun(agentId: string): boolean;
     getRun(agentId: string): TrackedAgentRun | null;
     hasRun(agentId: string): boolean;
+    getTurnId(agentId: string): string | null;
     trackAutonomousRun(agentId: string, turnId: string | null): TrackedAgentRun;
     settleTerminalRun(agentId: string, turnId: string | undefined): void;
     settleForegroundRun(agentId: string, token: string): void;

package/dist/server/server/agent/agent-run-state.js

@@ -22,6 +22,14 @@ export class AgentRunState {
     hasRun(agentId) {
         return this.runs.has(agentId);
     }
+    getTurnId(agentId) {
+        const run = this.runs.get(agentId);
+        if (!run)
+            return null;
+        if (run.kind === "autonomous")
+            return run.turnId;
+        return run.start.status === "started" ? run.start.turnId : null;
+    }
     trackAutonomousRun(agentId, turnId) {
         const current = this.runs.get(agentId);
         if (current) {
@@ -41,7 +49,8 @@ export class AgentRunState {
         if (!run) {
             return;
         }
-        if (run.kind === "foreground" && (run.turnId === null || run.turnId !== turnId)) {
+        if (run.kind === "foreground" &&
+            (run.start.status !== "started" || run.start.turnId !== turnId)) {
             return;
         }
         if (run.kind === "autonomous" &&
@@ -177,8 +186,7 @@ function createPendingForegroundRun() {
     return {
         ...createTrackedRunState(),
         kind: "foreground",
-        turnId: null,
-        started: false,
+        start: { status: "pending" },
         stagedEvents: [],
     };
 }

package/dist/server/server/agent/providers/jsonl-rpc-process.d.ts

@@ -57,6 +57,7 @@ export declare class JsonlRpcProcess {
     /** Route a complete logical frame to its consumer (response or subscriber). */
     private dispatchFrame;
     private handleResponse;
+    private handleStdinError;
     private failAll;
 }
 //# sourceMappingURL=jsonl-rpc-process.d.ts.map

package/dist/server/server/agent/providers/jsonl-rpc-process.js

@@ -52,6 +52,9 @@ export class JsonlRpcProcess {
                 this.stderrBuffer = this.stderrBuffer.slice(-STDERR_BUFFER_LIMIT);
             }
         });
+        this.child.stdin.on("error", (error) => {
+            this.handleStdinError(error);
+        });
         this.child.on("error", (error) => {
             this.failAll(error instanceof Error ? error : new Error(String(error)));
         });
@@ -103,10 +106,19 @@ export class JsonlRpcProcess {
         return this.startRequest(command, timeoutMs).promise;
     }
     send(message) {
-        if (this.disposed || this.child.stdin.destroyed || !this.child.stdin.writable) {
+        if (this.disposed) {
+            return;
+        }
+        if (this.child.stdin.destroyed || !this.child.stdin.writable) {
+            this.handleStdinError(new Error(`${this.diagnosticName} stdin is not writable`));
             return;
         }
-        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+        try {
+            this.child.stdin.write(`${JSON.stringify(message)}\n`);
+        }
+        catch (error) {
+            this.handleStdinError(error);
+        }
     }
     async close(error = new Error(`${this.diagnosticName} process is closed`)) {
         if (this.disposed)
@@ -160,6 +172,14 @@ export class JsonlRpcProcess {
         }
         pending.resolve(response.data);
     }
+    handleStdinError(error) {
+        if (this.disposed) {
+            return;
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.options.logger.warn({ err }, `${this.diagnosticName} stdin write failed`);
+        void this.close(err);
+    }
     failAll(error) {
         if (this.disposed) {
             return;

package/dist/server/server/agent/providers/omp/rpc-types.d.ts

@@ -252,8 +252,8 @@ export declare const OmpSubagentStatusSchema: z.ZodEnum<{
     running: "running";
     completed: "completed";
     failed: "failed";
-    aborted: "aborted";
     pending: "pending";
+    aborted: "aborted";
 }>;
 export declare const OmpSubagentLifecyclePayloadSchema: z.ZodObject<{
     id: z.ZodString;
@@ -277,8 +277,8 @@ export declare const OmpSubagentProgressSchema: z.ZodObject<{
         running: "running";
         completed: "completed";
         failed: "failed";
-        aborted: "aborted";
         pending: "pending";
+        aborted: "aborted";
     }>;
     description: z.ZodOptional<z.ZodString>;
     currentTool: z.ZodOptional<z.ZodUnknown>;
@@ -299,8 +299,8 @@ export declare const OmpSubagentProgressPayloadSchema: z.ZodObject<{
             running: "running";
             completed: "completed";
             failed: "failed";
-            aborted: "aborted";
             pending: "pending";
+            aborted: "aborted";
         }>;
         description: z.ZodOptional<z.ZodString>;
         currentTool: z.ZodOptional<z.ZodUnknown>;
@@ -1372,8 +1372,8 @@ export declare const OmpRuntimeEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
                 running: "running";
                 completed: "completed";
                 failed: "failed";
-                aborted: "aborted";
                 pending: "pending";
+                aborted: "aborted";
             }>;
             description: z.ZodOptional<z.ZodString>;
             currentTool: z.ZodOptional<z.ZodUnknown>;

package/dist/server/server/agent/providers/opencode-agent.js

@@ -1978,7 +1978,7 @@ function shouldSuppressOpenCodeAssistantPart(part, messageRole, state) {
 }
 function appendOpenCodeTextPart(part, messageRole, state, events) {
     if (messageRole === "user") {
-        if (!part.time?.end || !part.text || state.emittedUserMessageIds?.has(part.messageID)) {
+        if (!part.text || state.emittedUserMessageIds?.has(part.messageID)) {
             return;
         }
         state.emittedUserMessageIds?.add(part.messageID);