@jaypie/mcp 0.8.182 → 0.8.184

package/dist/assets.js

@@ -55,11 +55,11 @@ function getMcpAssetPaths() {
  */
 function getMcpBuildInfo() {
     return {
-        commit: "91eb8a17"
+        commit: "9aa68f12"
             ,
-        version: "0.8.182"
+        version: "0.8.184"
             ,
-        versionString: "@jaypie/mcp@0.8.182#91eb8a17"
+        versionString: "@jaypie/mcp@0.8.184#9aa68f12"
             ,
     };
 }

package/package.json

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

package/release-notes/jaypie/1.2.118.md

@@ -0,0 +1,9 @@
+---
+version: 1.2.118
+date: 2026-10-05
+summary: Pulls @jaypie/llm 1.3.59
+---
+
+## Changes
+
+- **`@jaypie/llm` 1.3.59**: the structured-output corrective turn is taken once per run; an empty Gemini reply makes 2 requests before failing over instead of 24.

package/release-notes/jaypie/1.2.119.md

@@ -0,0 +1,9 @@
+---
+version: 1.2.119
+date: 2026-10-07
+summary: Pulls @jaypie/llm 1.3.60
+---
+
+## Changes
+
+- **`@jaypie/llm` 1.3.60**: `effort` accepts a per-model map, fallback entries take their own `effort`, and `resolveEffort` exports the native mapping.

package/release-notes/llm/1.3.59.md

@@ -0,0 +1,18 @@
+---
+version: 1.3.59
+date: 2026-10-05
+summary: The structured-output corrective turn is taken once per run instead of repeating until the turn budget runs out
+---
+
+## Changes
+
+### One corrective turn (issue #610)
+
+A `format` request answered with prose or with nothing took the corrective turn (only the `structured_output` tool offered) on every turn until `turns` ran out. With the default budget of 24, an empty Gemini reply cost 24 requests, each resending the full prompt, before the chain failed over.
+
+- The corrective turn is taken at most once per run. A second miss settles: empty content fails over as in 1.3.58, and prose completes as it did when turns ran out.
+- Applies to every adapter with a corrective turn: Fireworks, Google, and Mistral.
+
+## Testing
+
+- `OperateLoop` specs cover one corrective turn with the default budget for empty content and for prose.

package/release-notes/llm/1.3.60.md

@@ -0,0 +1,26 @@
+---
+version: 1.3.60
+date: 2026-10-07
+summary: effort accepts a per-model map, fallback entries take their own effort, and resolveEffort exports the native mapping
+---
+
+## Changes
+
+### Per-model effort (issue #612)
+
+A fallback chain mixes providers whose reasoning cost differs sharply at the same level, but `effort` was one value per call.
+
+- `effort` accepts `LlmEffortMap`. Each attempt (primary, fallback, linger pass) resolves its own level: exact model id, then `MODEL` catalog key whose value is exactly the model, then provider (or the `gemini` alias), then `default`. No match leaves the provider default.
+- Catalog keys match exact catalog values only, never name fragments, so `flash` cannot catch both Gemini Flash and GLM Flash.
+- `LlmFallbackConfig.effort` sets a single level for one entry and replaces the call's value there.
+- `LlmExchangeRequest.effort` records the level each attempt resolved.
+
+### `resolveEffort`
+
+- `resolveEffort({ model, effort, provider? })` returns `{ level, model, native, papered, provider }`, where `native` is the request fragment the adapter sends (e.g. `{ thinkingConfig: { thinkingLevel: "LOW" } }`). Undefined `native` means no level resolved or the model has no reasoning control.
+- Adapters expose `resolveEffort` and build requests from it, so the export and the wire request share one mapping.
+
+## Testing
+
+- `resolveEffort.spec.ts` covers map precedence, catalog keys, the provider alias, and native fragments per provider.
+- `OperateLoop` and `StreamLoop` specs cover map resolution and the exchange record; `Llm` specs cover per-entry effort on a fallback.

package/release-notes/mcp/0.8.183.md

@@ -0,0 +1,10 @@
+---
+version: 0.8.183
+date: 2026-10-05
+summary: Release notes for @jaypie/llm 1.3.59 and jaypie 1.2.118; llm skill documents the single corrective turn
+---
+
+## Changes
+
+- **Release notes**: `@jaypie/llm` 1.3.59 and `jaypie` 1.2.118
+- **`llm` skill**: the corrective turn is taken once per run

package/release-notes/mcp/0.8.184.md

@@ -0,0 +1,10 @@
+---
+version: 0.8.184
+date: 2026-10-07
+summary: Release notes for @jaypie/llm 1.3.60, testkit 1.2.82, and jaypie 1.2.119; llm skill documents per-model effort and resolveEffort
+---
+
+## Changes
+
+- **Release notes**: `@jaypie/llm` 1.3.60, `@jaypie/testkit` 1.2.82, and `jaypie` 1.2.119
+- **`llm` skill**: per-model effort maps, `LlmFallbackConfig.effort`, and `resolveEffort`

package/release-notes/testkit/1.2.82.md

@@ -0,0 +1,9 @@
+---
+version: 1.2.82
+date: 2026-10-07
+summary: Passes through resolveEffort from @jaypie/llm
+---
+
+## Changes
+
+- `resolveEffort` in the `@jaypie/llm` mock, passed through to the real implementation.

package/skills/llm.md

@@ -384,7 +384,7 @@ string. The operate loop first parses the text as JSON, stripping a Markdown
 code fence — this runs for every provider. If that fails, adapters that opt in
 (`supportsStructuredOutputRetry`: **Fireworks** and **Google**) take a
 corrective turn offering only the `structured_output` tool and demanding it be
-called, bounded by the `turns` budget. That turn withholds the caller's own
+called. The corrective turn is taken once per run, within the `turns` budget. That turn withholds the caller's own
 tools and does not send the schema natively, leaving one unambiguous way to
 answer.
 
@@ -1125,7 +1125,7 @@ describe("LLM Integration", () => {
 interface LlmOperateOptions {
   cache?: boolean | 0 | "5m" | "1h"; // Prompt caching (default on at 1h; false/0 disables)
   data?: Record<string, any>; // Placeholder substitution data
-  effort?: LlmEffort; // Provider-neutral reasoning effort (lowest|low|medium|high|highest)
+  effort?: LlmEffort | LlmEffortMap; // Reasoning effort (lowest|low|medium|high|highest), or a per-model map
   fallback?: LlmFallbackConfig[] | false; // Fallback provider chain
   format?: NaturalSchema | JsonObject | ZodType; // Structured output schema (natural syntax preferred)
   history?: LlmHistory; // Previous conversation
@@ -1144,6 +1144,9 @@ interface LlmFallbackConfig {
   provider: string; // Provider name (e.g., "openai", "anthropic", "google")
   model?: string; // Model to use (optional, uses provider default)
   apiKey?: string; // API key (optional, uses environment variable)
+  effort?: LlmEffort; // Effort for this entry only, replacing the call's effort
+  providerOptions?: JsonObject; // Provider-specific options for this entry only
+  timeout?: number | false; // Per-attempt deadline for this entry only
 }
 ```
 
@@ -1220,6 +1223,58 @@ erroring):
   tools natively — no emulation.
 - **Bedrock** — not yet wired; `effort` is ignored.
 
+### Per-model effort
+
+Reasoning cost differs sharply between providers at the same level, so a
+fallback chain can set `effort` per model with a map. Each attempt (primary,
+every fallback, and the linger pass) resolves its own level, first match wins:
+
+1. **Exact model id** (`"gpt-6.1-sol"`)
+2. **`MODEL` catalog key** whose value is exactly the serving model (`"sol"`
+   for `MODEL.SOL`, `"gemini_flash"`, `"fireworks.glm"`); case-insensitive,
+   any separator. Keys never match by name fragment: `"flash"` matches nothing.
+3. **Provider** (`"openai"`, `"anthropic"`, `"google"`, `"xai"`,
+   `"openrouter"`, ...) or an alias (`"gemini"` → `google`)
+4. **`default`**
+5. No match leaves the provider default untouched
+
+```typescript
+await llm.operate(input, {
+  model: "gemini-3-flash",
+  fallback: [
+    { provider: "openai", model: "gpt-6.1-sol" },
+    { provider: "anthropic", model: "claude-opus-5-5", effort: "highest" },
+  ],
+  effort: { gemini: "low", "gpt-6.1-sol": "medium", default: "high" },
+});
+```
+
+A single `LlmEffort` keeps its meaning everywhere. A fallback entry's own
+`effort` replaces the call's value (single or map) for that entry. The exchange
+records the level each attempt resolved (`LlmExchangeRequest.effort`).
+
+### `resolveEffort`
+
+`resolveEffort` returns the level a model resolves to and the request fragment
+its adapter would send (`native`), or no `native` when the model has no
+reasoning control:
+
+```typescript
+import { resolveEffort } from "@jaypie/llm";
+
+resolveEffort({ model: "gemini-3-flash", effort: "low" });
+// → { level: "low", model: "gemini-3-flash", provider: "google", papered: false,
+//     native: { thinkingConfig: { thinkingLevel: "LOW" } } }
+
+resolveEffort({ model: "claude-opus-5-5", effort: { anthropic: "high" } });
+// → { level: "high", ..., native: { output_config: { effort: "high" } } }
+```
+
+Accepts an optional `provider` when the model id alone does not route (e.g. an
+OpenRouter path). Comparing `native` across levels shows which are distinct on
+a model: `lowest` and `low` on Claude both send `{ effort: "low" }`, so one of
+the two is redundant in an effort sweep.
+
 First-class `effort` takes precedence over a raw `providerOptions.reasoning`
 (same convention as `temperature`). For control the neutral scale doesn't
 express (an exact token budget, OpenAI `none`), use `providerOptions` directly.