@cydm/pie 2.7.1 → 2.7.3

package/dist/builtin/skills/computer-use-axi/computer-use-axi-runtime.js

@@ -84,7 +84,7 @@ function computerUseOwnerFromEnv(env = process.env) {
 
 // vendor/computer-use-axi/src/broker-protocol.ts
 var BROKER_PROTOCOL_VERSION = 1;
-var BROKER_ENGINE_VERSION = 1;
+var BROKER_ENGINE_VERSION = 2;
 var BROKER_PACKAGE_VERSION = "0.5.1-pie.1";
 var BROKER_MAX_FRAME_BYTES = 4 * 1024 * 1024;
 var BROKER_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
@@ -352,6 +352,7 @@ async function callBroker(options) {
         type: "request",
         protocolVersion: brokerProtocol,
         requestId: options.requestId,
+        generation: options.generation,
         ownerId: options.ownerId,
         executionId: options.executionId,
         command: options.command,
@@ -417,12 +418,14 @@ Commands:
   browser launch [--url U]
   browser navigate --state S --url U
   browser eval --state S --expr '<JavaScript>'
+  permissions setup|recheck  macOS: register/open Settings, or restart helper and check
   status  Show the local broker status (never starts one)
   stop    Stop the local broker and release processes it owns
 
 Options:
   --json          Print { content, details, isError } as JSON
-  --request-id ID Reuse an id to retrieve the same result (at-most-once)
+  --request-id ID Retrieve the same result within its original broker generation
+  --generation G Pin request/result retrieval to a broker generation (use with reused IDs)
   --owner ID      Opaque session identity (defaults to the standalone namespace)
   --help, -h      Show this help
 
@@ -526,6 +529,11 @@ function buildCommand(args) {
     usageError(`unknown browser subcommand '${sub}' (expected launch | navigate | eval)`);
   }
   switch (args.command) {
+    case "permissions": {
+      const mode = args.rest[0];
+      if (mode !== "setup" && mode !== "recheck") usageError("permissions requires setup | recheck");
+      return { command: "permissions", params: { mode } };
+    }
     case "status":
       return { command: "status", params: {} };
     case "stop":
@@ -655,6 +663,7 @@ async function main() {
       ownerId: ownerId === COMPUTER_USE_STANDALONE_OWNER ? ownerId : ownerId,
       executionId,
       requestId,
+      generation: optionalFlag(args, "--generation"),
       cwd: process.cwd(),
       budgetMs,
       spawnIfMissing: !control

package/dist/chunks/{chunk-XUROMYTT.js → chunk-E5JQ5SVA.js}

@@ -1890,6 +1890,10 @@ var NodeHttpClient = class {
     let tieredBodyByteSeen = false;
     let tierMarkBodyByte = null;
     let requestTimeoutError;
+    const setTimeoutKind = (error, kind) => {
+      if (!error) return;
+      error.timeoutKind = kind;
+    };
     const clearTieredFirstByteTimer = () => {
       if (tieredFirstByteTimer !== void 0) {
         clearTimeout(tieredFirstByteTimer);
@@ -1933,6 +1937,7 @@ var NodeHttpClient = class {
               res.on("timeout", () => {
                 if (res.readableEnded || res.complete) return;
                 requestTimeoutError = new Error(`Request timeout (stream idle) after ${tieredStreamIdleTimeoutMs}ms`);
+                setTimeoutKind(requestTimeoutError, "stream_idle");
                 logHttp("WARN", `Request [${reqTag}] stream idle timeout`, { idleTimeoutMs: tieredStreamIdleTimeoutMs });
                 req.destroy(requestTimeoutError);
               });
@@ -2178,6 +2183,7 @@ var NodeHttpClient = class {
       if (!tieredStreamTimeout) {
         req.on("timeout", () => {
           requestTimeoutError = new Error("Request timeout");
+          setTimeoutKind(requestTimeoutError, "total");
           logHttp("ERROR", `Request [${reqTag}] timeout`);
           req.destroy(requestTimeoutError);
         });
@@ -2186,6 +2192,7 @@ var NodeHttpClient = class {
         tieredFirstByteTimer = setTimeout(() => {
           tieredFirstByteTimer = void 0;
           requestTimeoutError = new Error(`Request timeout (first byte) after ${tieredFirstByteTimeoutMs}ms`);
+          setTimeoutKind(requestTimeoutError, "first_byte");
           logHttp("WARN", `Request [${reqTag}] first byte timeout`, { firstByteTimeoutMs: tieredFirstByteTimeoutMs });
           req.destroy(requestTimeoutError);
         }, tieredFirstByteTimeoutMs);
@@ -3368,6 +3375,10 @@ function buildBaseOptions(model, options, apiKey) {
     sessionId: options?.sessionId,
     headers: options?.headers,
     timeoutMs: options?.timeoutMs,
+    firstResponseTimeoutMs: options?.firstResponseTimeoutMs,
+    streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
+    requestTimeoutMs: options?.requestTimeoutMs,
+    connectionIdleTimeoutMs: options?.connectionIdleTimeoutMs,
     onPayload: options?.onPayload,
     onTransportDiagnostic: options?.onTransportDiagnostic,
     onTransportLifecycle: options?.onTransportLifecycle,
@@ -4887,7 +4898,10 @@ function getResponsesCompat(model) {
     supportsStore: compat.supportsStore ?? true,
     supportsReasoningEffort: compat.supportsReasoningEffort ?? true,
     supportsEncryptedReasoning: compat.supportsEncryptedReasoning ?? true,
-    responsesContinuation: compat.responsesContinuation ?? false
+    responsesContinuation: compat.responsesContinuation ?? false,
+    supportsReasoningSummary: compat.supportsReasoningSummary ?? false,
+    reasoningSummary: compat.reasoningSummary ?? "auto",
+    timeoutReplay: compat.timeoutReplay ?? false
   };
 }
 
@@ -5074,6 +5088,10 @@ function buildResponsesRequest(model, context, options, compat = getResponsesCom
   if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
     params.reasoning = { effort: options.reasoningEffort };
   }
+  if (model.reasoning && compat.supportsReasoningSummary && compat.reasoningSummary !== "none") {
+    params.reasoning = params.reasoning ?? {};
+    params.reasoning.summary = compat.reasoningSummary;
+  }
   if (compat.supportsEncryptedReasoning && model.reasoning) {
     params.include = ["reasoning.encrypted_content"];
   }
@@ -5606,6 +5624,8 @@ function monotonicNow() {
 // ../../packages/ai/src/providers/responses/responses-sse.ts
 var DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS = 3 * 60 * 1e3;
+var REASONING_STREAM_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+var REASONING_FIRST_BYTE_TIMEOUT_MS = 5 * 60 * 1e3;
 function parseSSEDataLine2(line) {
   const trimmed = line.trim();
   if (!trimmed || trimmed.startsWith(":")) return null;
@@ -5635,16 +5655,19 @@ function explicitBudget(value, field) {
   }
   return value;
 }
-function resolveSSEBudgets(options) {
+function resolveSSEBudgets(options, model) {
   const firstResponse = explicitBudget(options?.firstResponseTimeoutMs, "firstResponseTimeoutMs");
   const streamIdle = explicitBudget(options?.streamIdleTimeoutMs, "streamIdleTimeoutMs");
   const requestTimeoutMs = explicitBudget(options?.requestTimeoutMs, "requestTimeoutMs");
   explicitBudget(options?.connectionIdleTimeoutMs, "connectionIdleTimeoutMs");
+  const reasoning = model.reasoning === true;
+  const defaultFirstByte = reasoning ? REASONING_FIRST_BYTE_TIMEOUT_MS : DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS;
+  const defaultIdle = reasoning ? REASONING_STREAM_IDLE_TIMEOUT_MS : DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS;
   if (firstResponse !== void 0 || streamIdle !== void 0) {
     return {
       http: {
-        firstByteTimeoutMs: firstResponse ?? DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
-        streamIdleTimeoutMs: streamIdle ?? DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
+        firstByteTimeoutMs: firstResponse ?? defaultFirstByte,
+        streamIdleTimeoutMs: streamIdle ?? defaultIdle
       },
       requestTimeoutMs
     };
@@ -5652,8 +5675,8 @@ function resolveSSEBudgets(options) {
   if (options?.timeoutMs !== void 0) return { http: { timeoutMs: options.timeoutMs }, requestTimeoutMs };
   return {
     http: {
-      firstByteTimeoutMs: DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
-      streamIdleTimeoutMs: DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
+      firstByteTimeoutMs: defaultFirstByte,
+      streamIdleTimeoutMs: defaultIdle
     },
     requestTimeoutMs
   };
@@ -5674,6 +5697,7 @@ function streamResponsesSSE(model, context, options) {
     let totalTimer;
     let internalTimeout;
     let localFailure = false;
+    let providerRejected = false;
     const requestAbort = new AbortController();
     const onUserAbort = () => requestAbort.abort();
     const clearTotalTimer = () => {
@@ -5701,7 +5725,7 @@ function streamResponsesSSE(model, context, options) {
     try {
       let resolved;
       try {
-        resolved = resolveSSEBudgets(options);
+        resolved = resolveSSEBudgets(options, model);
       } catch (error) {
         localFailure = true;
         throw error;
@@ -5767,6 +5791,7 @@ function streamResponsesSSE(model, context, options) {
       });
       if (!response.ok) {
         const errorBody = await response.text().catch(() => "");
+        providerRejected = true;
         throw new Error(`API error ${response.status}: ${errorBody}`);
       }
       if (!response.readSSELines) {
@@ -5824,13 +5849,26 @@ function streamResponsesSSE(model, context, options) {
       const message = reducer.message;
       const userAborted = options?.signal?.aborted === true;
       message.stopReason = userAborted ? "aborted" : "error";
+      const adapterTimeoutKind = error instanceof Error ? error.timeoutKind : void 0;
+      if (!internalTimeout && (adapterTimeoutKind === "first_byte" || adapterTimeoutKind === "stream_idle")) {
+        internalTimeout = adapterTimeoutKind === "first_byte" ? "first_response" : "stream_idle";
+      }
       message.errorMessage = internalTimeout ? `Responses request timeout (${internalTimeout}) after ${Math.round(monotonicNow() - startedAt)}ms` : error instanceof Error ? error.message : JSON.stringify(error);
-      if (submitted || localFailure) message.retryable = false;
+      const compat = getResponsesCompat(model);
+      const streamLost = !internalTimeout && submitted && !localFailure && !providerRejected && message.stopReason === "error";
+      if (internalTimeout && compat.timeoutReplay) {
+        message.replayEligible = true;
+        message.replayClass = internalTimeout;
+      } else if (streamLost && compat.timeoutReplay) {
+        message.replayEligible = true;
+        message.replayClass = receivedMessageCount === 0 ? "stream_lost" : "stream_lost_partial";
+      }
+      if ((submitted || localFailure) && !(streamLost && receivedMessageCount === 0)) message.retryable = false;
       phase = "cleanup";
       lifecycle({
         timeoutKind: internalTimeout,
-        retryAllowed: !submitted && !userAborted && !localFailure,
-        retryDecision: submitted ? "not_retryable_after_submission" : localFailure ? "local_configuration_error" : "not_submitted",
+        retryAllowed: !userAborted && !localFailure && message.retryable !== false,
+        retryDecision: streamLost ? receivedMessageCount === 0 ? message.replayEligible ? "replay_exempt_stream_lost" : "stream_lost_no_evidence" : message.replayEligible ? "replay_exempt_after_submission" : "not_retryable_after_submission" : submitted ? "not_retryable_after_submission" : localFailure ? "local_configuration_error" : "not_submitted",
         cancelSource: userAborted ? "user" : internalTimeout ? "internal_timeout" : "none",
         cleanupOutcome: "request_abandoned"
       });
@@ -5851,6 +5889,8 @@ var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
 var DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_CONNECTION_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var REASONING_FIRST_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
+var REASONING_STREAM_IDLE_TIMEOUT_MS2 = 5 * 60 * 1e3;
 var ITERATOR_CLEANUP_TIMEOUT_MS = 1e3;
 function explicitBudget2(value, field) {
   if (value === void 0) return void 0;
@@ -5859,16 +5899,17 @@ function explicitBudget2(value, field) {
   }
   return value;
 }
-function resolveBudgets(options) {
+function resolveBudgets(options, model) {
   const firstResponse = explicitBudget2(options?.firstResponseTimeoutMs, "firstResponseTimeoutMs");
   const streamIdle = explicitBudget2(options?.streamIdleTimeoutMs, "streamIdleTimeoutMs");
   const requestTimeout = explicitBudget2(options?.requestTimeoutMs, "requestTimeoutMs");
   const connectionIdle = explicitBudget2(options?.connectionIdleTimeoutMs, "connectionIdleTimeoutMs");
   const legacy = options?.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : void 0;
+  const reasoning = model.reasoning === true;
   return {
     connectTimeoutMs: legacy ?? DEFAULT_CONNECT_TIMEOUT_MS,
-    firstResponseTimeoutMs: firstResponse ?? legacy ?? DEFAULT_FIRST_RESPONSE_TIMEOUT_MS,
-    streamIdleTimeoutMs: streamIdle ?? legacy ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+    firstResponseTimeoutMs: firstResponse ?? legacy ?? (reasoning ? REASONING_FIRST_RESPONSE_TIMEOUT_MS : DEFAULT_FIRST_RESPONSE_TIMEOUT_MS),
+    streamIdleTimeoutMs: streamIdle ?? legacy ?? (reasoning ? REASONING_STREAM_IDLE_TIMEOUT_MS2 : DEFAULT_STREAM_IDLE_TIMEOUT_MS),
     requestTimeoutMs: requestTimeout,
     connectionIdleTimeoutMs: connectionIdle ?? DEFAULT_CONNECTION_IDLE_TIMEOUT_MS
   };
@@ -5937,7 +5978,7 @@ function streamResponsesWS(model, context, options) {
   }
   let budgets;
   try {
-    budgets = resolveBudgets(options);
+    budgets = resolveBudgets(options, model);
   } catch (error) {
     reducer.message.stopReason = "error";
     reducer.message.errorMessage = error instanceof Error ? error.message : String(error);
@@ -5966,6 +6007,7 @@ function streamResponsesWS(model, context, options) {
     let requestTimer;
     let totalTimer;
     let receiveCleanupFailed = false;
+    const compat = getResponsesCompat(model);
     let cleanupCancelSource;
     const requestAbort = new AbortController();
     const publish = (event) => {
@@ -6081,7 +6123,9 @@ function streamResponsesWS(model, context, options) {
           cancelSource: "internal_timeout",
           retryAllowed: !sent,
           retryDecision,
-          submissionAttempted: sent
+          submissionAttempted: sent,
+          // L2 diagnostic surface: this timeout qualifies for bounded replay.
+          ...compat.timeoutReplay && sent ? { replayExempt: true } : {}
         });
         requestAbort.abort();
       }, timeoutMs);
@@ -6273,9 +6317,21 @@ function streamResponsesWS(model, context, options) {
         message.stopReason = userAborted || ownerDisposed ? "aborted" : "error";
         const cause = timedOut ? `Responses request timeout (${timedOut}) after ${ageMs()}ms` : error instanceof Error ? error.message : String(error);
         message.errorMessage = cause;
+        const streamLost = !timedOut && message.stopReason === "error";
+        if (timedOut && compat.timeoutReplay) {
+          message.replayEligible = true;
+          message.replayClass = timedOut;
+        } else if (streamLost && compat.timeoutReplay) {
+          message.replayEligible = true;
+          message.replayClass = receivedMessageCount === 0 ? "stream_lost" : "stream_lost_partial";
+        }
         if (sent) {
-          message.retryable = false;
-          retryDecision = "not_retryable_after_submission";
+          if (streamLost && receivedMessageCount === 0) {
+            retryDecision = message.replayEligible ? "replay_exempt_stream_lost" : "stream_lost_no_evidence";
+          } else {
+            message.retryable = false;
+            if (!timedOut) retryDecision = message.replayEligible ? "replay_exempt_after_submission" : "not_retryable_after_submission";
+          }
         }
         cleanupCancelSource = userAborted ? "user" : timedOut ? "internal_timeout" : ownerDisposed ? "owner_disposal" : "none";
         stream.push({ type: "error", reason: message.stopReason, error: message });
@@ -6297,7 +6353,7 @@ function streamResponsesWS(model, context, options) {
         terminalAccepted: finished,
         timeoutKind: timedOut,
         submissionAttempted: sent,
-        retryAllowed: !finished && !sent && reducer.message.stopReason !== "aborted" && reducer.message.retryable !== false,
+        retryAllowed: !finished && reducer.message.stopReason !== "aborted" && reducer.message.retryable !== false,
         cancelSource,
         retryDecision,
         cleanupOutcome