@jaypie/mcp 0.8.161 → 0.8.162

package/dist/assets.js

@@ -55,11 +55,11 @@ function getMcpAssetPaths() {
  */
 function getMcpBuildInfo() {
     return {
-        commit: "89205145"
+        commit: "09240f3e"
             ,
-        version: "0.8.161"
+        version: "0.8.162"
             ,
-        versionString: "@jaypie/mcp@0.8.161#89205145"
+        versionString: "@jaypie/mcp@0.8.162#09240f3e"
             ,
     };
 }

package/package.json

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

package/release-notes/jaypie/1.2.102.md

@@ -0,0 +1,12 @@
+---
+version: 1.2.102
+date: 2026-09-18
+summary: Pulls @jaypie/llm 1.3.43
+---
+
+## Changes
+
+- **`@jaypie/llm` 1.3.43**: `Llm.question` answers typed questions in
+  TypeSafe's Jev shape, served natively by the new `typesafe` provider or
+  emulated on any provider that returns structured JSON. A per-call `model` no
+  longer follows `operate()` onto a fallback provider.

package/release-notes/llm/1.3.43.md

@@ -0,0 +1,94 @@
+---
+version: 1.3.43
+date: 2026-09-18
+summary: "Llm.question answers typed questions in TypeSafe's Jev shape, natively or emulated on any provider"
+---
+
+## Changes
+
+### New Features
+
+- `Llm.question(state, { questions })` is a fourth entry point, in TypeSafe's
+  (Jev's) shape: `noul`, `choice`, and `score` questions asked of a state,
+  answered one apiece with probabilities. Static and instance forms mirror
+  `operate`, including `model` array sugar, `fallback`, `retry`, `signal`, and
+  `user`.
+- New provider `typesafe` serves TypeSafe's System One models over
+  `POST /v1/systemone`, with match words `jev` and `typesafe` and
+  `TYPESAFE_API_KEY`. It implements `question` only: a System One model
+  generates no text, so `send` throws `NotImplementedError` and the provider
+  offers no `operate` or `stream`. The client is `fetch` against the two
+  documented routes; no SDK dependency is taken.
+- `MODEL.JEV` is `jev-1.13.0`, the versioned id the API echoes on every
+  response. The `jev-latest` and `jev-preview` aliases still route to the
+  provider through the match words. `COST["jev-1.13.0"]` is $0.042 input and
+  $0 output, which TypeSafe bills for answers.
+- Every other provider answers the same call through an emulator: one
+  structured `operate()` call at `temperature: 0` and `turns: 1`, asking for
+  the full distribution, from which choice (argmax), score
+  (probability-weighted level index), and confidence are derived. A chain can
+  mix the two, so a rate-limited or unreachable Jev falls through to a
+  traditional model without the caller's request or response shape changing.
+- The response carries `emulated`. When it is `true`, `probabilities` are
+  model-reported (normalized in code) and `confidence` is Jaypie's normalized
+  peak probability, `(max(p) - 1/n) / (1 - 1/n)`, exported as
+  `peakConfidence` alongside `normalizeDistribution`. TypeSafe has not
+  published its own formula; normalized peak reproduces both documented
+  examples and a live Jev call within rounding, and is replaced by TypeSafe's
+  when it publishes.
+- TypeSafe's question limits (1 to 255 choice options, 2 to 10 ordered score
+  levels, non-empty instructions, `noul` criteria restricted to `true` and
+  `false`) are validated at the entry point for **every** provider, so a
+  question that validates is answerable anywhere in a chain. A violation
+  throws `BadRequestError` naming the question id.
+
+### Mistral: dated ids, OCR 4.1, and the CI shard restored
+
+- `MODEL.MISTRAL.LARGE` and `MODEL.MISTRAL.SMALL` name the dated ids
+  `mistral-large-2512` and `mistral-small-2603` in place of the `-latest`
+  aliases they resolved to. Prices are unchanged ($0.5/$1.5 and $0.15/$0.6,
+  cached input at 10%), and `COST[MODEL.MISTRAL.LARGE]` now hits rather than
+  missing by design: the catalog no longer names an alias.
+- `MODEL.MISTRAL.OCR` moves to `mistral-ocr-4-1`. It stays unpriced in `COST`
+  because it bills per page ($4 per 1000 pages, $0.4 cached), which
+  `LlmModelCost` cannot express. Verified live against `POST /v1/ocr`.
+- Mistral is a CI capability-matrix shard again, and `mistral-large-2512`
+  rejoins the live matrix. Both were dropped while the account's tier answered
+  every capability with "This model is not available in your subscription
+  tier"; on the upgraded tier both cataloged models pass all seven cells
+  (verified 2026-09-19).
+
+### Bug Fixes
+
+- The Anthropic hot spec streamed with `max_tokens: 64`. The 5-family models
+  open a response with a thinking block, so the budget was spent before any
+  text delta arrived and `streams text deltas` failed for Fable 5.1, Opus 5,
+  and Sonnet 5. The budget now accommodates the thinking block and the test
+  stops reading at the first text delta.
+- A per-call `model` no longer follows `operate()` onto a fallback provider.
+  `operate(input, { model: ["gpt-5.6-luna", "claude-haiku-4-5"] })` sent the
+  primary model id to the fallback, asking Anthropic for an OpenAI model. Each
+  fallback now runs the model its own chain entry names.
+
+### Internal
+
+- The primary-then-chain loop moves to `src/util/runWithFallback.ts` and
+  serves both `operate` and `question`. Exchange settlement stays in
+  `operate`; `question` emits no exchange in this release.
+- `MODEL.JEV` is excluded from the live capability matrix: a System One model
+  implements neither `operate()` nor `send()`, so every cell would fail by
+  construction.
+
+## Testing
+
+- Live, 2026-09-18 (`npm run test:llm:question`): all three question types
+  against `jev-1.13.0` natively and against `claude-haiku-4-5` and
+  `gpt-5.6-luna` by emulation, plus a chain falling from an unknown Jev model
+  to emulation. 4 of 4 passed, with the three models agreeing on every answer
+  (choice `billing`; noul 0.97, 0.92, 0.98; score 1.86, 1.60, 1.83 on a 0 to 2
+  scale).
+- New unit coverage for validation, the emulator (prompt, schema,
+  normalization, argmax, weighted score, confidence against TypeSafe's
+  documented examples), `Llm.question` fallback behavior, the TypeSafe client's
+  status-to-error mapping, and provider routing. A hot spec exercises both
+  live routes when `TYPESAFE_API_KEY` is set.

package/release-notes/mcp/0.8.162.md

@@ -0,0 +1,15 @@
+---
+version: 0.8.162
+date: 2026-09-18
+summary: Document Llm.question and the TypeSafe provider in the llm skill
+---
+
+## Changes
+
+### Documentation
+
+- `skills/llm.md` gains a "Questions (Jev Shape)" section: the three question
+  types and their answers, the response fields, what `emulated` means for
+  `confidence`, and how chains mix native and emulated providers.
+- The providers table carries a `typesafe` row, and the environment block
+  carries `TYPESAFE_API_KEY`.

package/release-notes/testkit/1.2.75.md

@@ -0,0 +1,12 @@
+---
+version: 1.2.75
+date: 2026-09-18
+summary: Mock Llm.question and the TypeSafe provider
+---
+
+## Changes
+
+- `Llm.question` (static, instance, and on the inner provider) resolves a
+  mock question response with one `choice` answer and `emulated: false`.
+- New mocks: `TypeSafeProvider`, `TypeSafeClient`, `LlmQuestionType`,
+  `normalizeDistribution`, and `peakConfidence`.

package/skills/llm.md

@@ -41,6 +41,7 @@ the alias rather than the id it currently resolves to. Read the id off
 | xAI | "xai", "grok" | `MODEL.GROK` |
 | Meta | "muse" (plus the exact name `meta` and a `meta:` prefix) | `MODEL.MUSE_SPARK` |
 | Bedrock | "amazon.nova", "anthropic.claude", "meta.llama", "deepseek.", "google.gemma", "moonshotai.", "openai.gpt-oss", … | `MODEL.NOVA_PRO` |
+| TypeSafe | "jev", "typesafe" | `MODEL.JEV` |
 
 The provider name for Gemini models is `"google"` — `"gemini"` is accepted as a deprecated alias.
 
@@ -48,6 +49,8 @@ Mistral's family names mostly do not contain the substring "mistral" (`ministral
 
 "meta" is deliberately not a Meta match word: `meta.llama-*` is a Bedrock id and `meta-llama/*` an OpenRouter route. Muse Spark ids resolve on "muse"; use the `meta:` prefix to force the Meta Model API for any other id.
 
+TypeSafe serves System One models (Jev), which answer typed questions and generate no text. The provider implements `question()` only: `operate()`, `send()`, and `stream()` throw. See [Questions](#questions-jev-shape).
+
 ### Model Constants
 
 - **`PROVIDER.<name>.DEFAULT`** — the single default model per provider (above), used when no `model` is given.
@@ -401,6 +404,87 @@ jsonSchemaToNaturalSchema({
 
 `naturalSchemaToJsonSchema` is lossless — Natural Schema is a strict subset of JSON Schema. `jsonSchemaToNaturalSchema` is lossy: JSON Schema constraints, descriptions, defaults, unions, and optionality have no Natural Schema equivalent and are dropped. It never throws; every dropped keyword is logged at `log.debug` with the keyword name and JSON path.
 
+## Questions (Jev Shape)
+
+`Llm.question(state, { questions })` asks typed questions about a body of
+text and returns one typed answer each, with probabilities. The request and
+response shapes are TypeSafe's, so a question written once is answered the
+same way by every provider: TypeSafe's System One models (Jev) answer
+natively, and every other provider answers through an emulator that rigs up
+one structured `operate()` call. Traditional models fit the question shape;
+the question shape does not bend to fit them.
+
+```typescript
+import { Llm, LLM } from "@jaypie/llm";
+
+const { answers, emulated } = await Llm.question(ticket, {
+  model: [LLM.MODEL.JEV, LLM.MODEL.HAIKU], // native first, emulated if Jev is down
+  questions: {
+    department: {
+      type: "choice",
+      instructions: "Which team should handle this?",
+      criteria: {
+        billing: "Charges, invoices, refunds",
+        sales: null, // the option name speaks for itself
+        technical: "Bugs, outages",
+      },
+    },
+    is_urgent: { type: "noul", instructions: "Does this convey urgency?" },
+    frustration: {
+      type: "score",
+      instructions: "How frustrated is the customer?",
+      criteria: ["Calm", "Frustrated", "Very angry"], // 2 to 10, lowest first
+    },
+  },
+});
+
+answers.department; // { type: "choice", choice: "billing", confidence: 0.98, probabilities: {...} }
+answers.is_urgent;  // { type: "noul", noul: 0.94 }
+answers.frustration; // { type: "score", score: 1.7, confidence: 0.56, legend: {...}, probabilities: {...} }
+```
+
+### Question Types
+
+| Type | Criteria | Answer |
+|------|----------|--------|
+| `noul` | optional `{ true, false }` descriptions | `{ type, noul }` — probability 0 to 1, no confidence: the number is the degree of belief |
+| `choice` | `Record<option, description \| null>`, 1 to 255 options | `{ type, choice, confidence, probabilities }` — `choice` is the argmax, `probabilities` keyed by option name |
+| `score` | ordered `string[]`, 2 to 10 levels lowest first | `{ type, score, confidence, legend, probabilities }` — `score` is the probability-weighted level index, `legend` and `probabilities` keyed by level index as a string |
+
+`instructions` and every criteria value accept a string, an object, or an
+array. `state` accepts the same three and is text only: no files, no images,
+no conversation. Question ids are the caller's and never reach the model.
+TypeSafe's limits are enforced on every provider at the entry point, so a
+question that validates works anywhere in a chain; a violation throws
+`BadRequestError` naming the question id.
+
+### Response
+
+```typescript
+{
+  answers,          // Record<question id, answer>
+  emulated,         // false when a System One model answered natively
+  fallbackAttempts, // providers tried (1 = primary only)
+  fallbackUsed,
+  model,            // the versioned id that served the request
+  provider,
+  responses,        // raw provider payloads
+  usage,            // LlmUsage, same shape operate() reports
+}
+```
+
+`emulated: true` marks an answer a traditional model produced. Its
+`probabilities` are model-reported (normalized in code) and its `confidence`
+is a Jaypie statistic over them — normalized peak probability,
+`(max(p) - 1/n) / (1 - 1/n)`, exported as `peakConfidence` — not a calibrated
+System One output. Threshold on it knowing that.
+
+Chains work exactly as they do for `operate()`: `model` accepts a
+preference-ordered array, `fallback` accepts explicit entries or `false`, and
+an attempt with somewhere left to go skips the rate-limit wait. A provider
+that can neither `question` nor `operate` counts as a failed attempt and the
+chain moves on.
+
 ## Conversation History
 
 Continue conversations across calls:
@@ -649,6 +733,7 @@ OPENAI_API_KEY      # Required for OpenAI
 OPENROUTER_API_KEY  # Required for OpenRouter
 XAI_API_KEY         # Required for xAI (Grok)
 META_API_KEY        # Required for Meta (Muse Spark); MODEL_API_KEY is read as a fallback
+TYPESAFE_API_KEY    # Required for TypeSafe (Jev); emulated questions use the answering provider's key
 ```
 
 Keys are resolved via `getEnvSecret()` which supports AWS Secrets Manager.