@jaypie/mcp 0.8.175 → 0.8.176

package/dist/assets.js

@@ -55,11 +55,11 @@ function getMcpAssetPaths() {
  */
 function getMcpBuildInfo() {
     return {
-        commit: "a3ee062e"
+        commit: "92677918"
             ,
-        version: "0.8.175"
+        version: "0.8.176"
             ,
-        versionString: "@jaypie/mcp@0.8.175#a3ee062e"
+        versionString: "@jaypie/mcp@0.8.176#92677918"
             ,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/mcp",
-  "version": "0.8.175",
+  "version": "0.8.176",
   "description": "Jaypie MCP",
   "repository": {
     "type": "git",

package/release-notes/jaypie/1.2.112.md

@@ -0,0 +1,9 @@
+---
+version: 1.2.112
+date: 2026-09-27
+summary: Pulls @jaypie/llm 1.3.53
+---
+
+## Changes
+
+- **`@jaypie/llm` 1.3.53**: per-attempt `timeout` aborts a stalled provider request and falls back, instead of waiting out undici's 300 s headers timeout (#595).

package/release-notes/llm/1.3.53.md

@@ -0,0 +1,18 @@
+---
+version: 1.3.53
+date: 2026-09-27
+summary: Per-attempt timeout aborts a stalled provider request and falls back instead of waiting out undici's 300 s headers timeout
+---
+
+## Changes
+
+- New `timeout` option on `operate()`/`stream()` and on each fallback entry: a per-attempt deadline in milliseconds (#595). A stalled attempt is aborted and throws `LlmTimeoutError`, which extends `LlmTransientError` (status 504, `timeoutMs`)
+- Down a fallback chain, a timeout moves to the next entry at once; on a single model or the linger pass it retries on the transient budget with the same deadline. It never surfaces as `LlmAbortError`, so the chain does not stop
+- `stream()` applies `timeout` as an idle timeout, restarted by every chunk and paused while the consumer holds one
+- A fallback entry's `timeout` replaces the call's for that entry; `false` disables it. No default applies
+- The Google adapter now forwards the attempt signal to its requests. Previously it dropped the signal, so neither a caller abort nor a retry teardown cancelled an in-flight Gemini call
+- `LlmTimeoutError` is exported from `@jaypie/llm`
+
+## Testing
+
+- `npm run test -w packages/llm`: new specs cover the RetryExecutor deadline, OperateLoop and StreamLoop timeouts (including an adapter that swallows the abort), chain fall-over on a timeout, entry-level overrides, and Google signal forwarding

package/release-notes/mcp/0.8.176.md

@@ -0,0 +1,9 @@
+---
+version: 0.8.176
+date: 2026-09-27
+summary: llm skill documents the per-attempt timeout
+---
+
+## Changes
+
+- **`llm` skill**: new "Attempt Timeout" section under Fallback Providers; Cancellation notes Google now honors the signal.

package/release-notes/testkit/1.2.78.md

@@ -0,0 +1,9 @@
+---
+version: 1.2.78
+date: 2026-09-27
+summary: Re-exports LlmTimeoutError from the llm mock
+---
+
+## Changes
+
+- `LlmTimeoutError` re-exported from `@jaypie/llm` alongside the other `LlmError` classes.

package/skills/llm.md

@@ -779,6 +779,7 @@ for await (const chunk of Llm.stream(input, {
 
 - A caller abort is terminal and is never retried. `operate()` rejects with `LlmAbortError` (`category: "aborted"`, status 499); `stream()` yields an error chunk with the same status, then its final `done` chunk.
 - An already-aborted signal fails before the first request goes out.
+- Every provider forwards the signal to its request, Google included.
 - Abandoning a `stream()` generator (`break`, `return`, or a thrown error in the consumer) aborts the upstream request on teardown, with or without a `signal`.
 - The exchange envelope still settles on an abort, carrying the partial usage and history with `status: "incomplete"`.
 
@@ -828,6 +829,27 @@ const response = await llm.operate(input, {
 });
 ```
 
+### Attempt Timeout
+
+`timeout` sets a per-attempt deadline in milliseconds. Without it, a provider that accepts the connection but never answers holds the chain until the runtime gives up (undici waits 300 s for response headers). A stalled attempt is aborted and throws `LlmTimeoutError` (a `LlmTransientError`, status 504, with `timeoutMs`):
+
+```typescript
+const response = await llm.operate(input, {
+  fallback: [
+    { provider: "openai", model: LLM.MODEL.SOL },
+    { provider: "anthropic", model: LLM.MODEL.OPUS, timeout: 180_000 },
+  ],
+  timeout: 60_000,
+});
+```
+
+- Down a chain, a timeout moves to the next entry at once. On a single model or the linger pass it retries on the transient budget, each retry with the same deadline.
+- A timeout is never an `LlmAbortError`: the caller's `signal` still owns cancellation.
+- An entry's own `timeout` replaces the call's for that entry; `false` disables it.
+- `stream()` treats `timeout` as an idle timeout: it restarts with every chunk and pauses while the consumer holds one. A stall after partial output yields an error chunk.
+- No default applies; unset means no deadline. Size it above the slowest legitimate non-streaming response (long reasoning runs take minutes).
+- `Llm.ocr` keeps `timeout` as the LlamaParse job deadline.
+
 ### Fallback Response Metadata
 
 ```typescript