@jaypie/mcp 0.8.172 → 0.8.174

package/dist/assets.js

@@ -55,11 +55,11 @@ function getMcpAssetPaths() {
  */
 function getMcpBuildInfo() {
     return {
-        commit: "a60721ed"
+        commit: "6d3baca1"
             ,
-        version: "0.8.172"
+        version: "0.8.174"
             ,
-        versionString: "@jaypie/mcp@0.8.172#a60721ed"
+        versionString: "@jaypie/mcp@0.8.174#6d3baca1"
             ,
     };
 }

package/package.json

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

package/release-notes/jaypie/1.2.110.md

@@ -0,0 +1,9 @@
+---
+version: 1.2.110
+date: 2026-09-26
+summary: Pulls @jaypie/llm 1.3.51
+---
+
+## Changes
+
+- **`@jaypie/llm` 1.3.51**: `providerOptions` no longer leak to fallback providers; `fallback` entries accept their own `providerOptions` (#591).

package/release-notes/llm/1.3.50.md

@@ -0,0 +1,26 @@
+---
+version: 1.3.50
+date: 2026-09-25
+summary: Mistral OCR markdown inlines tables, describes images, and renders typed blocks such as signatures; Llm.ocr answers instructions and format; fallback chains fail over on any error and linger only on the primary
+---
+
+## Changes
+
+- Tables are always inline. `[tbl-0.md](tbl-0.md)` placeholders, which Mistral returns whenever `table_format` is sent, are replaced with the table content in the syntax `tables` selects
+- Every image is described. Requests carry a default `bbox_annotation_format` (`{ image_type, description }`, with signature, seal, and stamp in the enum). The description becomes the image's alt text, `![Notary seal](img-2.jpeg)`, and `LlmOcrImage` gains `annotation`, `description`, and `type`
+- Typed blocks are rendered. When OCR 4 returns `blocks`, page markdown is rebuilt from them, so a signature reads `[Signature: Jane Q Doe]` rather than a bare name. Header and footer blocks are skipped when extracted to their own fields
+- `PAGE_COST_ANNOTATED` prices annotated pages ($5 per 1,000 on `mistral-ocr-4-1`); `usage.cost` uses it unless annotation is disabled
+- `providerOptions.bbox_annotation_format` replaces the default schema, and `null` disables annotation
+- `Llm.ocr` accepts `instructions` and `format` (Natural Schema, JSON Schema, or Zod) and returns the answer on `content`. Mistral answers in the same call through `document_annotation_prompt` and `document_annotation_format`; beyond its 8-page annotation limit, and on emulated engines, one text-only `operate()` over the markdown answers instead. LlamaParse throws `NotImplementedError` before submitting, so a chain fails over
+- Mistral `document_annotation` is parsed from its JSON string before it lands on `annotations`
+- Fallback chains (`operate`, `ocr`, `question`) fail over on any error with no retry or wait, the last entry included. When the chain is spent, the primary runs once more with its full retry policy; if that fails, the call throws. Previously transient errors retried up to six times on each entry and the last entry kept its rate-limit wait
+- An explicit `retry` option on a chained call applies to the linger pass only
+- `LlmRetryOptions` gains `transient: false`, which disables transient-error retries
+- A caller abort (`LlmAbortError`) no longer falls over to the next entry
+- The Bedrock client is built with `maxAttempts: 1`, so SDK retries no longer stack under `RetryExecutor`
+
+## Testing
+
+- `npm run test -w packages/llm`: unit and Mistral hot specs pass
+- Live, 2026-09-25: Mistral classifies the notarized fixture natively; a 10-page PDF answers through `mistral-large-2512` over markdown; Haiku emulation answers bare instructions as a string and `format` as an object
+- Live, 2026-09-25: a notarized scan fixture (`test/fixtures/notarized.png`) returns an inline table, a described diagram, signature, and seal, and a `[Signature: Jane Q Doe]` block

package/release-notes/llm/1.3.51.md

@@ -0,0 +1,17 @@
+---
+version: 1.3.51
+date: 2026-09-26
+summary: providerOptions reach only the model they were written for; fallback entries carry their own providerOptions; MODEL.FIREWORKS.DEEPSEEK moves to deepseek-v4p1-flash
+---
+
+## Changes
+
+- Per-call `providerOptions` on `operate` and `ocr` reach the primary only, its linger pass included. Previously every fallback received them verbatim, so options shaped for one provider (OpenAI `reasoning`) broke a fallback on another (Gemini rejected `reasoning` in `generation_config`) and the chain provided no resilience (#591)
+- `LlmFallbackConfig` gains `providerOptions`, sent only to that entry
+- Fallbacks derived from a `model` array carry no `providerOptions`
+- `MODEL.FIREWORKS.DEEPSEEK` is now `accounts/fireworks/models/deepseek-v4p1-flash`, the same id as `DEEPSEEK_FLASH`. Fireworks withdrew `deepseek-v4-pro-0813` from serverless (404 "Model not found"); its `COST` entry stays
+
+## Testing
+
+- `npm run test -w packages/llm`: new specs cover operate (cross-provider fallback, per-entry options, linger pass) and ocr scoping
+- Fireworks hot spec passes for every catalog id, deepseek-v4p1-flash included

package/release-notes/mcp/0.8.174.md

@@ -0,0 +1,9 @@
+---
+version: 0.8.174
+date: 2026-09-26
+summary: llm skill documents providerOptions scoping across fallback chains
+---
+
+## Changes
+
+- **`llm` skill**: "Provider Options in a Chain" covers per-entry `providerOptions` on `fallback`.

package/skills/llm.md

@@ -528,7 +528,7 @@ const { emulated, markdown, pages, usage } = await Llm.ocr(
       LLM.MODEL.HAIKU, // emulated: any provider that accepts files
     ],
     pages: "1,3-5", // 1-indexed; [1, 3, 4, 5] also works
-    tables: "markdown", // or "html"
+    tables: "markdown", // table syntax; tables are always inline
   },
 );
 
@@ -541,6 +541,37 @@ usage.cost; // USD from LLM.PAGE_COST (LlamaParse: from recorded credits; emulat
 usage.tokens; // emulated only: every operate() call's usage
 ```
 
+`instructions` and `format` ask for more than transcription; the answer
+lands on `content` (an object shaped by `format`, or a string with only
+`instructions`):
+
+```typescript
+const { content, markdown } = await Llm.ocr("./scans/intake.pdf", {
+  format: {
+    category: ["deed", "invoice", "medical intake", "other"],
+    description: String,
+  },
+  instructions: "Classify the document and describe it in one sentence.",
+});
+content.category; // "medical intake"
+```
+
+Mistral answers in the same call (`document_annotation_prompt` and a strict
+`document_annotation_format`). Past its 8-page annotation limit, and on every
+emulated engine, the answer comes from one more text-only `operate()` over the
+markdown, priced into `usage`. LlamaParse does not support either option and
+fails over to the next engine in the chain. Mistral's own
+`document_annotation` surfaces parsed as `annotations`.
+
+Mistral markdown is self-contained. Tables are inlined in place of
+`[tbl-0.md](tbl-0.md)` placeholders. Every image is annotated, and its
+description becomes the alt text (`![Notary signature of Jane Doe](img-1.jpeg)`)
+and lands on `images[].description`, `.type` (`signature`, `seal`, `stamp`,
+`photo`, ...), and `.annotation`. Typed blocks are rendered, so a signature
+reads `[Signature: Jane Q Doe]` rather than a bare name. Annotation bills at
+`LLM.PAGE_COST_ANNOTATED`; replace the schema with
+`providerOptions.bbox_annotation_format` or pass `null` to disable it.
+
 Emulation sends each page alone (a PDF is trimmed to one page per call, so
 the model never numbers pages), asks for verbatim Markdown with
 `[UNCLEAR: best guess]` and `[ELEMENT: description]` markers, transcribes a
@@ -751,7 +782,7 @@ for await (const chunk of Llm.stream(input, {
 
 ## Fallback Providers
 
-Configure a chain of fallback providers that automatically retry failed calls when the primary provider fails:
+Configure a chain of fallback providers. Any error (rate limit, 5xx, network flake, bad request) moves to the next entry at once, with no retry or wait. When every entry has failed, the primary runs once more with its full retry policy; if that fails, the call throws. A caller abort (`LlmAbortError`) never falls over:
 
 ```typescript
 // Instance-level configuration
@@ -778,12 +809,29 @@ const response = await Llm.operate(input, {
 });
 ```
 
+### Provider Options in a Chain
+
+`providerOptions` belongs to the model it was written for. Per-call `providerOptions` reach the primary only (including its linger pass); a fallback receives only the `providerOptions` on its own entry, or none. Options shaped for one provider (OpenAI `reasoning`, Gemini `thinkingConfig`) would otherwise break every other provider in the chain. Prefer first-class `effort` and `temperature`, which translate per provider.
+
+```typescript
+const response = await llm.operate(input, {
+  fallback: [
+    {
+      provider: "google",
+      model: LLM.MODEL.GEMINI_FLASH,
+      providerOptions: { thinkingConfig: { thinkingBudget: 1024 } },
+    },
+  ],
+  providerOptions: { reasoning: { summary: "detailed" } }, // primary only
+});
+```
+
 ### Fallback Response Metadata
 
 ```typescript
 response.provider; // Which provider handled the request
 response.fallbackUsed; // true if a fallback was used
-response.fallbackAttempts; // Number of providers tried (1 = primary only)
+response.fallbackAttempts; // Attempts made (1 = primary only; chain length + 2 when the linger pass served it)
 ```
 
 ## Instance Usage
@@ -928,9 +976,12 @@ await Llm.operate(input, {
 });
 ```
 
-A configured fallback chain wins over waiting: moving to the next provider is
-faster than sleeping, so only the final entry in the chain keeps its rate-limit
-budget. Waits are interruptible by the caller's `signal`.
+A configured fallback chain wins over waiting. Every entry, the last included,
+fails fast on any error (`retry: { rateLimit: false, transient: false }`) so the
+next model takes over at once. When the whole chain fails, the primary runs one
+more time with the full policy (the caller's `retry` applies here) and its error
+is final. `transient: false` also works on a single call. Waits are
+interruptible by the caller's `signal`.
 
 ### Loop Stops