@getpaseo/server 0.7.0-beta.3 → 0.7.1

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/claude/model-manifest.d.ts

@@ -12,11 +12,17 @@ export declare const CLAUDE_MODEL_MANIFEST: readonly [{
     readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
     readonly supportsThinkingDisabled: true;
     readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-fable-5-1";
+    readonly label: "Fable 5.1";
+    readonly description: "Fable 5.1 · Most powerful model";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
 }, {
     readonly id: "claude-fable-5";
     readonly aliases: readonly ["claude-fable-5[1m]"];
     readonly label: "Fable 5";
-    readonly description: "Fable 5 · Most powerful model";
+    readonly description: "Fable 5 · Previous release";
     readonly minimumClaudeCodeVersion: "2.1.169";
     readonly contextWindowMaxTokens: 1000000;
     readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];

package/dist/server/server/agent/providers/claude/model-manifest.js

@@ -24,12 +24,19 @@ export const CLAUDE_MODEL_MANIFEST = [
         supportsThinkingDisabled: true,
         supportsFastMode: true,
     },
+    {
+        id: "claude-fable-5-1",
+        label: "Fable 5.1",
+        description: "Fable 5.1 · Most powerful model",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+    },
     {
         id: "claude-fable-5",
         // COMPAT(claudeFable5OneMillionId): added in v0.3.0, remove after 2027-02-06 once pre-v0.3.0 app preferences are outside support.
         aliases: ["claude-fable-5[1m]"],
         label: "Fable 5",
-        description: "Fable 5 · Most powerful model",
+        description: "Fable 5 · Previous release",
         minimumClaudeCodeVersion: "2.1.169",
         contextWindowMaxTokens: 1000000,
         effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
@@ -254,7 +261,7 @@ export function normalizeClaudeManifestModelId(value) {
     if (singleSegmentMatch) {
         return normalizeSingleSegmentClaudeModelId(singleSegmentMatch[1], singleSegmentMatch[2], trimmed.toLowerCase().includes("[1m]"));
     }
-    const runtimeMatch = trimmed.match(/^(?:claude[-_ ])?(opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(?:\[1m\])?(?:[-_ ]+\d{8})?(?:\[1m\])?$/i);
+    const runtimeMatch = trimmed.match(/^(?:claude[-_ ])?(fable|opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(?:\[1m\])?(?:[-_ ]+\d{8})?(?:\[1m\])?$/i);
     if (!runtimeMatch) {
         return null;
     }
@@ -281,7 +288,7 @@ export function normalizeClaudeRuntimeModelId(value) {
             return normalizedModelId;
         }
     }
-    const runtimeMatch = trimmed.match(/claude[-_ ](opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(\[1m\])?/i);
+    const runtimeMatch = trimmed.match(/claude[-_ ](fable|opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(\[1m\])?/i);
     if (!runtimeMatch) {
         return null;
     }
@@ -309,7 +316,15 @@ function normalizeSingleSegmentClaudeModelId(familyValue, major, hasOneMillionCo
 function normalizeMajorMinorClaudeModelId(familyValue, major, minor, hasOneMillionContext) {
     const family = familyValue.toLowerCase();
     const suffix = hasOneMillionContext ? "[1m]" : "";
-    const candidate = `claude-${family}-${major}-${minor}${suffix}`;
-    return isClaudeManifestModelId(candidate) ? candidate : null;
+    const candidates = [
+        `claude-${family}-${major}-${minor}${suffix}`,
+        `claude-${family}-${major}-${minor}`,
+    ];
+    for (const candidate of candidates) {
+        if (isClaudeManifestModelId(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
 }
 //# sourceMappingURL=model-manifest.js.map

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);