converse-mcp-server 4.5.2 → 4.6.0

package/.env.example

@@ -57,8 +57,15 @@ ABLITERATION_API_KEY=your_abliteration_api_key_here
 # Get your TypeSafe API key from: https://typesafe.ai
 # Enables the decide tool's native host for Jev decision models. Without it,
 # decide reaches Jev through OPENROUTER_API_KEY instead.
+# (OPENAI_API_KEY above also enables decide's default model, gpt-6-luna.)
 TYPESAFE_API_KEY=your_typesafe_api_key_here
 
+# Cloudflare Workers AI: the decide tool's native host for the Clef decision
+# models (clef, clef-flash). The token needs Workers AI permission. Without
+# these, decide reaches Clef through OPENROUTER_API_KEY instead.
+CLOUDFLARE_ACCOUNT_ID=your_cloudflare_account_id_here
+CLOUDFLARE_API_TOKEN=your_cloudflare_api_token_here
+
 # ============================================
 # Codex Configuration (Optional)
 # ============================================

package/README.md

@@ -187,7 +187,7 @@ Cancel running asynchronous operations when needed.
 
 ### 4. Decide Tool
 
-Ask a System One decision model (TypeSafe's Jev) typed questions about a state and get calibrated answers instead of text: a yes probability (`noul`), a chosen option with per-option probabilities (`choice`), or a rubric position with per-level probabilities (`score`). Batch many questions into one call; they are judged in parallel against the same state. Needs `TYPESAFE_API_KEY` or `OPENROUTER_API_KEY` (TypeSafe first, falling back to OpenRouter).
+Ask a decision model (OpenAI's `gpt-6-luna`, TypeSafe's Jev, or Cloudflare's Clef) typed questions about a state and get calibrated answers instead of text: a yes probability (`noul`), a chosen option with per-option probabilities (`choice`), or a rubric position with per-level probabilities (`score`). Batch many questions into one call; they are judged in parallel against the same state. Needs any of `OPENAI_API_KEY`, `TYPESAFE_API_KEY`, `CLOUDFLARE_ACCOUNT_ID` + `CLOUDFLARE_API_TOKEN`, or `OPENROUTER_API_KEY`; each model runs on its native host first and falls back to OpenRouter. `model: "auto"` tries `gpt-6-luna`, then `jev-latest`, then `clef`. Pass `images` to judge pictures with `gpt-6-luna` or Clef.
 
 ```javascript
 {
@@ -280,7 +280,8 @@ SUMMARIZATION_MODEL=gpt-5-nano        # Default: gpt-5-nano
 - **claude-opus-4-5** / **claude-opus-4-1**: Legacy Opus models with extended thinking (64K / 32K output)
 - **claude-sonnet-5-5** (aliases: `sonnet`, `sonnet-5.5`): Current Sonnet with adaptive thinking and effort (1M context, 128K output)
 - **claude-sonnet-4-6** (alias: `sonnet-4.6`): Previous Sonnet generation with adaptive thinking (64K output)
-- **claude-haiku-4-5** (alias: `haiku`): Fast and intelligent for simple queries (64K output)
+- **claude-haiku-5-5** (aliases: `haiku`, `haiku-5.5`): Current Haiku, fastest and cheapest Claude, with adaptive thinking and effort (1M context, 128K output)
+- **claude-haiku-4-5** (alias: `haiku-4.5`): Previous Haiku generation with extended thinking (64K output)
 
 ### Mistral Models
 
@@ -337,6 +338,7 @@ Claude via the Claude Agent SDK. `claude` uses its default model (Opus 5.5, or `
 - **claude-opus-5-5** (default; aliases: `opus`, `claude-opus`, `opus-5.5`), **claude-opus-5** (`opus-5`)
 - **claude-fable-5-1** (aliases: `fable`, `claude-fable`, `fable-5.1`), **claude-fable-5** (`fable-5`)
 - **claude-sonnet-5-5** (aliases: `sonnet`, `claude-sonnet`, `sonnet-5.5`)
+- **claude-haiku-5-5** (aliases: `haiku`, `claude-haiku`, `haiku-5.5`)
 - Uses Claude Code CLI authentication (`claude login`) - no API key needed
 - Direct filesystem access from working directory
 
@@ -345,7 +347,7 @@ Claude via the Claude Agent SDK. `claude` uses its default model (Opus 5.5, or `
 Reach these only with the `copilot:` namespace (e.g. `copilot:gpt-6.1-sol`) — Copilot never serves bare model names. `copilot` alone uses GPT-6.1 Sol, or `COPILOT_DEFAULT_MODEL`. Uses your GitHub Copilot subscription (`gh auth login`) - no API key needed:
 
 - **OpenAI**: `gpt-6.1-sol` (aliases: `gpt-6`, `gpt-6.1`, `gpt-5`, `sol`), `gpt-6-sol`, `gpt-6-luna` (alias: `luna`), `gpt-5.6-sol` (alias: `gpt-5.6`), `gpt-5.6-terra`, `gpt-5.6-luna` (all support `reasoning_effort`)
-- **Anthropic**: `claude-opus-5.5` (aliases: `opus`, `claude`), `claude-fable-5` (alias: `fable`), `claude-sonnet-5.5` (alias: `sonnet`), `claude-sonnet-5`, `claude-opus-5`, `claude-opus-4.8`
+- **Anthropic**: `claude-opus-5.5` (aliases: `opus`, `claude`), `claude-fable-5.1` (alias: `fable`), `claude-fable-5`, `claude-sonnet-5.5` (alias: `sonnet`), `claude-haiku-5.5` (alias: `haiku`), `claude-sonnet-5`, `claude-opus-5`, `claude-opus-4.8`
 - **Google**: `gemini-3.1-pro-preview` (aliases: `gemini`, `gemini-3.1-pro`), `gemini-3.8-flash` (aliases: `gemini-3.8`, `flash-3.8`), `gemini-3.5-flash` (alias: `gemini-flash`)
 
 ## 📚 Help & Documentation

package/docs/API.md

@@ -368,7 +368,7 @@ Only jobs in a `queued` or `running` state can be cancelled; already-completed,
 
 ## Decide Tool
 
-**Description**: Ask a System One decision model (TypeSafe's Jev family) typed questions about a state. Decision models return calibrated probabilities, never text, so they have their own tool and their own providers: `chat` routing never reaches them, and `decide` never reaches a chat model.
+**Description**: Ask a decision model (OpenAI's `gpt-6-luna`, TypeSafe's Jev, Cloudflare's Clef) typed questions about a state. Decision models return calibrated probabilities, never text, so they have their own tool and their own providers: `chat` routing never reaches them, and `decide` never reaches a chat model. Requests and answers use TypeSafe's System One schema for every model; providers whose API differs translate it.
 
 ### Request Schema
 
@@ -390,7 +390,8 @@ Only jobs in a `queued` or `running` state can be cancelled; already-completed,
       }
     },
     "model": { "type": "string", "description": "Default: \"auto\"" },
-    "files": { "type": "array", "items": { "type": "string" } }
+    "files": { "type": "array", "items": { "type": "string" } },
+    "images": { "type": "array", "items": { "type": "string" } }
   },
   "required": ["questions"],
   "additionalProperties": false
@@ -399,30 +400,50 @@ Only jobs in a `queued` or `running` state can be cancelled; already-completed,
 
 - **`state`**: the material to judge. An object with descriptively named fields works best; use an array for sequences such as chat messages. Optional when `files` is given.
 - **`questions`**: named questions, each judged in parallel and in isolation against the same state. The name is your own label and becomes the answer key. Batching many questions into one call adds almost no latency or cost.
-- **`files`**: text files added to the state as `{ "files": { "<path>": "<content>" } }`. When `state` is also given, it moves to `input`. Line ranges (`file.txt{10:50}`) are supported; images are rejected.
+- **`files`**: text files added to the state as `{ "files": { "<path>": "<content>" } }`. When `state` is also given, it moves to `input`. Line ranges (`file.txt{10:50}`) are supported; image files belong in `images`.
+- **`images`**: PNG, JPEG or WebP images judged together with the state, as file paths or base64 data URLs; `state` is optional when images are given. Only `gpt-6-luna` (OpenAI) and `clef` / `clef-flash` (Cloudflare) take images, so `auto` skips other models and naming a text-only model is rejected before sending. OpenAI receives the state and images as one user message. Clef takes at most 4 images, and Cloudflare rejects a request whose size estimate (one token per 4 characters, base64 included) exceeds its 65,536-token window, so Clef images must total about 180 KB; `decide` checks this locally and suggests downscaling. OpenRouter routes are text only.
 
 | Type | `criteria` | Answer |
 |---|---|---|
 | `noul` | Optional `{ "true": "...", "false": "..." }` | `noul`: probability 0..1 of yes |
 | `choice` | Required `{ "<option>": "description" \| null }`, 2–255 options | `choice`, per-option `probabilities`, `confidence` |
-| `score` | Required ordered array of levels, lowest first, 2–10 levels | `score` (probability-weighted level position), `legend`, per-level `probabilities`, `confidence` |
+| `score` | Required ordered array of levels, lowest first, 2–10 levels; each a description or `{ "label": "...", "description": ... }` | `score` (probability-weighted level position), `legend`, per-level `probabilities`, `confidence` |
 
 `instructions` and criteria descriptions may be objects or arrays that bundle reference data with the question; refer to their fields by `` `name` `` in the text. Questions are validated before any request is sent.
 
+A labeled score level (`{ "label": "Very angry", "description": "Hostile, threatening to leave" }`) keeps a short name apart from its full description. OpenAI receives the pair as-is; System One hosts (TypeSafe, Cloudflare, OpenRouter) take one description per level, so they receive `"label: description"`. Either way the answer's `legend` shows the labels.
+
+Any answer from `gpt-6-luna` may be `{ "type": "refusal" }` instead of a value, shown as `- name (refusal): the model declined to answer`. Treat it as unanswered, never as a no. Jev and Clef have no refusal answer and always return a value.
+
 ### Models and Providers
 
-| Provider | Key | Models |
-|---|---|---|
-| `typesafe` (native, `https://api.typesafe.ai/v1/systemone`) | `TYPESAFE_API_KEY` | `jev-latest`, `jev-1.13.0` (alias `jev-1.13`), `jev-preview`, any versioned `jev-X.Y.Z` |
-| `openrouter` (`https://openrouter.ai/api/v1/systemone`) | `OPENROUTER_API_KEY` | `~typesafe/jev-latest` (alias `jev-latest`), `typesafe/jev-1.13` (aliases `jev-1.13`, `jev-1.13.0`), any `vendor/model` slug |
+| Model | Aliases | Native host | OpenRouter slug |
+|---|---|---|---|
+| `gpt-6-luna` | `luna`, `gpt-6-luna-decisions` | `openai` | `openai/gpt-6-luna-decisions` |
+| `jev-latest` | `jev` | `typesafe` (`jev-latest`) | `~typesafe/jev-latest` |
+| `jev-1.13` | `jev-1.13.0` | `typesafe` (`jev-1.13.0`) | `typesafe/jev-1.13` |
+| `jev-preview` | | `typesafe` | not served |
+| `clef` | `@cf/cloudflare/clef` | `cloudflare` | `cloudflare/clef` |
+| `clef-flash` | `@cf/cloudflare/clef-flash` | `cloudflare` | `cloudflare/clef-flash` |
+
+| Provider | Endpoint | Configuration | Wire format |
+|---|---|---|---|
+| `openai` | `POST https://api.openai.com/v1/decisions` | `OPENAI_API_KEY` | OpenAI Decisions (translated) |
+| `typesafe` | `POST https://api.typesafe.ai/v1/systemone` | `TYPESAFE_API_KEY` | System One; also any versioned `jev-X.Y.Z` |
+| `cloudflare` | `POST https://api.cloudflare.com/client/v4/accounts/{account}/ai/run/@cf/cloudflare/{model}` | `CLOUDFLARE_ACCOUNT_ID` + `CLOUDFLARE_API_TOKEN` (Workers AI permission) | System One in the Workers AI envelope |
+| `openrouter` | `POST https://openrouter.ai/api/v1/systemone` | `OPENROUTER_API_KEY` | System One; also any `vendor/model` slug |
+
+- `auto` (default): `gpt-6-luna`, then `jev-latest`, then `clef`, each on every configured host (native first, then OpenRouter).
+- A model name goes to every configured provider that serves it, native first, and each provider receives its own model ID.
+- `provider` alone uses that provider's default (`openai` and `openrouter`: `gpt-6-luna`; `typesafe`: `jev-latest`; `cloudflare`: `clef`). `provider:model` pins one provider, e.g. `cloudflare:clef-flash` or `openrouter:jev-latest`.
+
+OpenAI's Decisions API takes the same three kinds of question in its own schema, and only strings for the input and instructions. `decide` translates: object or array `state` and `instructions` are sent as JSON text, `noul` becomes a predicate whose `true`/`false` criteria are appended to the instructions, choice options and score levels become `choices` and `levels` arrays, and answers are mapped back to System One shapes.
 
-- `auto` (default): TypeSafe's default model, falling back to OpenRouter's.
-- A bare name such as `jev-1.13` goes to every configured provider that serves it, native first, and each provider receives its own model ID. OpenRouter does not serve `jev-preview` or patch-level IDs other than those listed above.
-- `typesafe:jev-1.13.0` or `openrouter:~typesafe/jev-latest` pins one provider.
+Clef accepts at most 64 questions per call, named with letters, digits, `_`, `.` and `-` (up to 100 characters); `decide` checks this before sending.
 
-Each provider call retries timeouts, 408, 429 and 5xx with backoff, honoring `Retry-After`. Auth failures, exhausted retries and malformed responses fall back to the next provider. A 400/422 request fault stops immediately, because every host would reject it the same way.
+Each provider call retries timeouts, 408, 429 and 5xx with backoff, honoring `Retry-After`. Auth failures, exhausted retries and malformed responses fall back to the next candidate. A 400/422 request fault skips the remaining hosts of the same model, which would reject it the same way, but `auto` still moves on to its next model.
 
-TypeSafe's API sits behind a Cloudflare firewall that rejects some request bodies containing SQL-injection or shell-command patterns (for example `-- ; DROP TABLE`, or a quoted `'...; DROP TABLE ...;'`) with a 403 before the model sees them. This applies through OpenRouter too, since it forwards to the same edge. `decide` reports it as `Blocked by typesafe.ai's Cloudflare firewall before reaching the model (Ray ID …)` and stops without retrying or falling back. Treat a block as an unanswered question, not as a decision, and report the Ray ID to TypeSafe.
+TypeSafe's API sits behind a Cloudflare firewall that rejects some request bodies containing SQL-injection or shell-command patterns (for example `-- ; DROP TABLE`, or a quoted `'...; DROP TABLE ...;'`) with a 403 before the model sees them. This applies to Jev through OpenRouter too, since it forwards to the same edge. `decide` reports it as `Blocked by typesafe.ai's Cloudflare firewall before reaching the model (Ray ID …)` and does not retry Jev on another host. Treat a block as an unanswered question, not as a decision, and report the Ray ID to TypeSafe.
 
 ### Example Usage
 
@@ -466,11 +487,11 @@ Decision · typesafe/jev-1.13-20260917 via OpenRouter · 394 input tokens · $0.
 ```
 ````
 
-`usage.cost` is reported by OpenRouter only (`null` from TypeSafe). A fallback is noted under the summary line.
+`usage.cost` is reported by OpenRouter only (`null` from the native hosts). A fallback is noted under the summary line.
 
 ### Usage Guidance
 
-Jev reads questions literally and is weak at counting, arithmetic, date comparison, and multi-hop reasoning; do those in code and ask narrow, atomic questions. Split compound judgments into separate questions and combine them in code. Treat low `confidence` as a signal to escalate to a generative model or a human. Limits: text only, about 64k tokens per request and 32k for the state plus the longest single question.
+Decision models read questions literally and are weak at counting, arithmetic, date comparison, and multi-hop reasoning; do those in code and ask narrow, atomic questions. Split compound judgments into separate questions and combine them in code. Treat low `confidence` as a signal to escalate to a generative model or a human. Limits: Jev is text only and takes about 64k tokens per request and 32k for the state plus the longest single question; Clef has a 65,536-token context.
 
 ## Supported Models
 
@@ -527,9 +548,10 @@ Provide models as plain name strings in the `models` array. Each entry is `auto`
 | `claude-opus-4-5-20251101`, `claude-opus-4-1-20250805` | `opus-4.5`, `opus-4.1` | 200K | 64K / 32K | Earlier Opus tiers |
 | `claude-sonnet-5-5` | `sonnet`, `sonnet-5.5`, `claude-sonnet` | 1M | 128K | Current Sonnet, adaptive thinking + effort, compaction |
 | `claude-sonnet-4-6` | `sonnet-4.6` | 200K (1M beta) | 64K | Previous Sonnet, adaptive thinking |
-| `claude-haiku-4-5-20251001` | `haiku`, `haiku-4.5` | 200K | 64K | Fast and intelligent |
+| `claude-haiku-5-5` | `haiku`, `haiku-5.5`, `claude-haiku` | 1M | 128K | Current Haiku, adaptive thinking + effort, compaction |
+| `claude-haiku-4-5-20251001` | `haiku-4.5` | 200K | 64K | Previous Haiku, extended thinking |
 
-Models with adaptive thinking control depth via `reasoning_effort`, which is passed by name to Anthropic's `effort` parameter and clamped to what each model accepts: Opus 5.5, Sonnet 5.5, Fable 5, Opus 5, Opus 4.8, and Opus 4.7 take `low`–`max`; Opus 4.6 and Sonnet 4.6 lack `xhigh` (it becomes `max`); Opus 4.5 tops out at `high`. `none` and `minimal` become `low` everywhere. System prompts are automatically cached for 1 hour; cache stats appear in response metadata as `cache_creation_input_tokens` / `cache_read_input_tokens`.
+Models with adaptive thinking control depth via `reasoning_effort`, which is passed by name to Anthropic's `effort` parameter and clamped to what each model accepts: Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5, Opus 5, Opus 4.8, and Opus 4.7 take `low`–`max`; Opus 4.6 and Sonnet 4.6 lack `xhigh` (it becomes `max`); Opus 4.5 tops out at `high`. `none` and `minimal` become `low` everywhere. System prompts are automatically cached for 1 hour; cache stats appear in response metadata as `cache_creation_input_tokens` / `cache_read_input_tokens`.
 
 ### Mistral Models
 
@@ -592,7 +614,7 @@ All three are uncensored ("abliterated") reasoning models using Abliteration's O
 **Claude** is available through the Claude Agent SDK, using Claude Code CLI authentication instead of an API key:
 
 - **Model**: `claude` (namespaces: `claude`, `claude-code`, `claude-sdk`) — defaults to Claude Opus 5.5 (`claude-opus-5-5`), or `CLAUDE_DEFAULT_MODEL`
-- **Model selection**: `claude-opus-5-5` (`opus`, `claude-opus`, `opus-5.5`), `claude-opus-5` (`opus-5`), `claude-fable-5-1` (`fable`, `claude-fable`, `fable-5.1`), `claude-fable-5` (`fable-5`), `claude-sonnet-5-5` (`sonnet`, `claude-sonnet`, `sonnet-5.5`), e.g. `claude:opus`, `claude:fable`, `claude:sonnet`. Other names are rejected with suggestions.
+- **Model selection**: `claude-opus-5-5` (`opus`, `claude-opus`, `opus-5.5`), `claude-opus-5` (`opus-5`), `claude-fable-5-1` (`fable`, `claude-fable`, `fable-5.1`), `claude-fable-5` (`fable-5`), `claude-sonnet-5-5` (`sonnet`, `claude-sonnet`, `sonnet-5.5`), `claude-haiku-5-5` (`haiku`, `claude-haiku`, `haiku-5.5`), e.g. `claude:opus`, `claude:fable`, `claude:sonnet`, `claude:haiku`. Other names are rejected with suggestions.
 - **Authentication**: `claude login` — no `ANTHROPIC_API_KEY` needed
 - **Availability**: the Claude Agent SDK is installed and `~/.claude/.credentials.json` exists (`$CLAUDE_CONFIG_DIR` when set), or `CLAUDE_CODE_OAUTH_TOKEN`/`ANTHROPIC_API_KEY` is in the environment; on macOS the Keychain login is assumed. An expired login is caught at call time and bare-name/`auto` routing fails over.
 - **Permissions**: runs with `bypassPermissions`
@@ -633,7 +655,7 @@ agy
 Reach these only with the `copilot:` namespace (also `github-copilot:`, `copilot-sdk:`; e.g. `copilot:gpt-6.1-sol`) — Copilot never serves bare model names. `copilot` alone uses GPT-6.1 Sol, or `COPILOT_DEFAULT_MODEL`. Available when the Copilot SDK is installed; uses your GitHub Copilot subscription (`gh auth login`) — no API key needed:
 
 - **OpenAI**: `gpt-6.1-sol` (aliases: `gpt-6`, `gpt-6.1`, `gpt-5`, `sol`), `gpt-6-sol`, `gpt-6-luna` (alias: `luna`), `gpt-5.6-sol` (alias: `gpt-5.6`), `gpt-5.6-terra`, `gpt-5.6-luna` (all accept `reasoning_effort`)
-- **Anthropic**: `claude-opus-5.5` (aliases: `opus`, `claude`), `claude-fable-5` (alias: `fable`), `claude-sonnet-5.5` (alias: `sonnet`), `claude-sonnet-5`, `claude-opus-5`, `claude-opus-4.8`
+- **Anthropic**: `claude-opus-5.5` (aliases: `opus`, `claude`), `claude-fable-5.1` (alias: `fable`), `claude-fable-5`, `claude-sonnet-5.5` (alias: `sonnet`), `claude-haiku-5.5` (alias: `haiku`), `claude-sonnet-5`, `claude-opus-5`, `claude-opus-4.8`
 - **Google**: `gemini-3.1-pro-preview` (aliases: `gemini`, `gemini-3.1-pro`), `gemini-3.8-flash` (aliases: `gemini-3.8`, `flash-3.8`), `gemini-3.5-flash` (alias: `gemini-flash`)
 - Any other `copilot:<id>` is rejected with suggestions
 
@@ -836,6 +858,8 @@ DEEPSEEK_API_KEY=...
 OPENROUTER_API_KEY=sk-or-...
 ABLITERATION_API_KEY=ak_...
 TYPESAFE_API_KEY=...            # decide tool only
+CLOUDFLARE_ACCOUNT_ID=...       # decide tool only (Clef), with CLOUDFLARE_API_TOKEN
+CLOUDFLARE_API_TOKEN=...
 ```
 
 **MCP client configuration:**

package/docs/PROVIDERS.md

@@ -57,7 +57,8 @@ This guide documents all supported AI providers in the Converse MCP Server and t
   - `claude-sonnet-5-5` (aliases `sonnet`, `sonnet-5.5`, `claude-sonnet`) - Current Sonnet: speed and capability for everyday coding and agentic work; adaptive thinking, effort `low`–`max` (1M context, 128K output)
   - `claude-sonnet-4-6` (alias `sonnet-4.6`) - Previous Sonnet generation with adaptive thinking (64K output)
   - `claude-sonnet-4-5-20250929` - Legacy Sonnet (64K output)
-  - `claude-haiku-4-5-20251001` (alias `haiku`) - Fast and intelligent with extended thinking (64K output)
+  - `claude-haiku-5-5` (aliases `haiku`, `haiku-5.5`, `claude-haiku`) - Current Haiku: fastest and cheapest Claude for high-volume and latency-sensitive work; adaptive thinking, effort `low`–`max` (1M context, 128K output)
+  - `claude-haiku-4-5-20251001` (alias `haiku-4.5`) - Previous Haiku generation with extended thinking (64K output)
 
 ### Mistral
 - **API Key Format**: 32+ character string
@@ -229,7 +230,8 @@ agy
   - `claude-fable-5-1` (aliases: `fable`, `claude-fable`, `fable-5.1`) - Claude Fable 5.1 (`claude:fable`)
   - `claude-fable-5` (alias: `fable-5`) - Claude Fable 5.0
   - `claude-sonnet-5-5` (aliases: `sonnet`, `claude-sonnet`, `sonnet-5.5`) - Claude Sonnet 5.5 (`claude:sonnet`)
-  - Names outside this catalog are rejected with suggestions (e.g. `claude:haiku` suggests `anthropic:haiku`)
+  - `claude-haiku-5-5` (aliases: `haiku`, `claude-haiku`, `haiku-5.5`) - Claude Haiku 5.5 (`claude:haiku`)
+  - Names outside this catalog are rejected with suggestions (e.g. `claude:sonnet-4.6` suggests `anthropic:sonnet-4.6`)
 
 **Key Features:**
 - **Subscription Access**: Uses your Claude subscription instead of API credits
@@ -242,7 +244,7 @@ agy
 **Differences from Anthropic API Provider:**
 - **Authentication**: Claude Code login vs `ANTHROPIC_API_KEY`
 - **Billing**: Claude subscription vs pay-per-use API
-- **Model Routing**: `claude` and `claude:<model>` → SDK provider; `anthropic:<model>` → API provider; bare names both serve as the same model (`opus`, `sonnet`, `claude-opus-5-5`, `claude-opus-5`, `claude-sonnet-5-5`, `claude-fable-5`) → SDK first, then the API on authentication/availability failure; bare names only the API serves (e.g., `haiku`, `sonnet-4.6`) → API provider. Bare `fable` is Fable 5.1 on the SDK but Fable 5 on the API, so it does not fail over between them.
+- **Model Routing**: `claude` and `claude:<model>` → SDK provider; `anthropic:<model>` → API provider; bare names both serve as the same model (`opus`, `sonnet`, `haiku`, `claude-opus-5-5`, `claude-opus-5`, `claude-sonnet-5-5`, `claude-haiku-5-5`, `claude-fable-5`) → SDK first, then the API on authentication/availability failure; bare names only the API serves (e.g., `haiku-4.5`, `sonnet-4.6`) → API provider. Bare `fable` is Fable 5.1 on the SDK but Fable 5 on the API, so it does not fail over between them.
 - **Permissions**: The SDK runs with `bypassPermissions`, and bare names and `auto` reach it whenever it is available. Use `anthropic:<model>` to keep a request on the plain API.
 
 ### GitHub Copilot SDK
@@ -254,7 +256,7 @@ agy
 - **Supported Models** (namespace-only: reach them with `copilot:`, `github-copilot:` or `copilot-sdk:`, e.g. `copilot:gpt-6.1-sol`; Copilot never serves bare model names):
   - `copilot` - GPT-6.1 Sol, or `COPILOT_DEFAULT_MODEL`
   - OpenAI: `gpt-6.1-sol` (aliases: `gpt-6`, `gpt-6.1`, `gpt-5`, `sol`), `gpt-6-sol`, `gpt-6-luna` (alias: `luna`), `gpt-5.6-sol` (alias: `gpt-5.6`), `gpt-5.6-terra`, `gpt-5.6-luna`
-  - Anthropic: `claude-opus-5.5` (aliases: `opus`, `claude`; Copilot Pro+/Max/Business/Enterprise), `claude-fable-5` (alias: `fable`), `claude-sonnet-5.5` (alias: `sonnet`), `claude-sonnet-5`, `claude-opus-5`, `claude-opus-4.8`
+  - Anthropic: `claude-opus-5.5` (aliases: `opus`, `claude`; Copilot Pro+/Max/Business/Enterprise), `claude-fable-5.1` (alias: `fable`), `claude-fable-5`, `claude-sonnet-5.5` (alias: `sonnet`), `claude-haiku-5.5` (alias: `haiku`), `claude-sonnet-5`, `claude-opus-5`, `claude-opus-4.8`
   - Google: `gemini-3.1-pro-preview` (aliases: `gemini`, `gemini-3.1-pro`), `gemini-3.8-flash` (aliases: `gemini-3.8`, `flash-3.8`), `gemini-3.5-flash` (alias: `gemini-flash`)
 - **Reasoning**: The GPT-6 and GPT-5.6 tiers accept `reasoning_effort` (clamped onto Copilot's `low`–`xhigh`).
 - **Unknown IDs**: Any other `copilot:<id>` is rejected with suggestions; only the IDs and aliases above are accepted.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converse-mcp-server",
-  "version": "4.5.2",
+  "version": "4.6.0",
   "description": "Converse MCP Server - Converse with other LLMs with chat and consensus tools",
   "type": "module",
   "main": "src/index.js",
@@ -93,22 +93,22 @@
     ".env.example"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.288",
-    "@anthropic-ai/sdk": "^0.131.0",
-    "@github/copilot-sdk": "^1.0.16",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.293",
+    "@anthropic-ai/sdk": "^0.132.0",
+    "@github/copilot-sdk": "^1.0.17",
     "@google/genai": "^2.27.0",
     "@lydell/node-pty": "1.2.0-beta.15",
     "@mistralai/mistralai": "^2.7.0",
-    "@modelcontextprotocol/sdk": "^1.32.0",
-    "@openai/codex-sdk": "^0.160.0",
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@openai/codex-sdk": "^0.161.0",
     "cors": "^2.8.6",
-    "dotenv": "^18.0.5",
+    "dotenv": "^18.0.6",
     "express": "^5.2.1",
     "lru-cache": "^11.5.3",
-    "nanoid": "^6.0.1",
-    "openai": "^7.27.0",
+    "nanoid": "^6.0.2",
+    "openai": "^7.30.0",
     "p-limit": "^7.3.3",
-    "vite": "^8.3.2"
+    "vite": "^8.3.3"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^5.0.3",

package/src/config.js

@@ -241,6 +241,18 @@ const CONFIG_SCHEMA = {
       description:
         'Optional OpenRouter attribution title, sent as the canonical X-OpenRouter-Title header',
     },
+    // Cloudflare Workers AI (Clef decision models for the decide tool)
+    CLOUDFLARE_ACCOUNT_ID: {
+      type: 'string',
+      required: false,
+      description: 'Cloudflare account ID for Workers AI (decide tool: Clef)',
+    },
+    CLOUDFLARE_API_TOKEN: {
+      type: 'string',
+      required: false,
+      secret: true,
+      description: 'Cloudflare API token with Workers AI access (decide tool: Clef)',
+    },
     OPENROUTER_DYNAMIC_MODELS: {
       type: 'boolean',
       default: false,
@@ -688,6 +700,9 @@ export async function loadConfig() {
     // API-key providers require keys; SDK-based providers (codex, claude, gemini-cli, copilot)
     // work via subscription auth — check if their packages are actually installed
     const availableKeys = Object.keys(config.apiKeys);
+    if (config.providers.cloudflareaccountid && config.providers.cloudflareapitoken) {
+      availableKeys.push('cloudflare');
+    }
     const hasVertexAI =
       config.providers.googlegenaiusevertexai &&
       config.providers.googlecloudproject &&
@@ -721,7 +736,7 @@ export async function loadConfig() {
 
     if (availableKeys.length === 0 && !hasVertexAI && !hasSdkProvider) {
       errors.push(
-        'At least one API key must be configured: OPENAI_API_KEY, XAI_API_KEY, GOOGLE_API_KEY, GEMINI_API_KEY, ANTHROPIC_API_KEY, MISTRAL_API_KEY, DEEPSEEK_API_KEY, OPENROUTER_API_KEY, ABLITERATION_API_KEY, or TYPESAFE_API_KEY. Alternatively, configure Google Vertex AI or use an SDK-based provider (codex, claude, copilot) or the Antigravity CLI (gemini-cli).',
+        'At least one API key must be configured: OPENAI_API_KEY, XAI_API_KEY, GOOGLE_API_KEY, GEMINI_API_KEY, ANTHROPIC_API_KEY, MISTRAL_API_KEY, DEEPSEEK_API_KEY, OPENROUTER_API_KEY, ABLITERATION_API_KEY, TYPESAFE_API_KEY, or CLOUDFLARE_ACCOUNT_ID with CLOUDFLARE_API_TOKEN. Alternatively, configure Google Vertex AI or use an SDK-based provider (codex, claude, copilot) or the Antigravity CLI (gemini-cli).',
       );
     }
 

package/src/decisionProviders/formats.js

@@ -0,0 +1,229 @@
+/**
+ * Decision wire formats
+ *
+ * The `decide` tool speaks System One: a `state`, a map of typed questions
+ * (`noul` / `choice` / `score`), and a map of answers. Each format turns that
+ * into one host's request body and maps the host's response back to System One
+ * answer shapes, so the tool formats every host's answers the same way.
+ *
+ * Every format returns `{ model, answers, usage, id }` from `parse`.
+ * `request(model, state, questions, images)` receives images as
+ * `{ mimeType, base64 }`; `images: true` marks formats that can send them.
+ */
+
+import { DecisionError } from './http.js';
+
+function asText(value) {
+  return typeof value === 'string' ? value : JSON.stringify(value);
+}
+
+function dataUrl(image) {
+  return `data:${image.mimeType};base64,${image.base64}`;
+}
+
+/**
+ * A score level given as `{ label, description? }` rather than a single
+ * description. OpenAI's levels take that pair natively; System One only takes
+ * one description per level.
+ */
+export function isLabeledLevel(level) {
+  return level !== null && typeof level === 'object' && !Array.isArray(level) && 'label' in level;
+}
+
+function flattenLevel(level) {
+  if (!isLabeledLevel(level)) return level;
+  return level.description === undefined ? level.label : `${level.label}: ${asText(level.description)}`;
+}
+
+/** Rewrite labeled score levels into System One's one-description form. */
+function toSystemOneQuestions(questions) {
+  return Object.fromEntries(
+    Object.entries(questions).map(([name, question]) =>
+      question.type === 'score' && question.criteria.some(isLabeledLevel)
+        ? [name, { ...question, criteria: question.criteria.map(flattenLevel) }]
+        : [name, question],
+    ),
+  );
+}
+
+/**
+ * TypeSafe and OpenRouter serve System One natively. Jev is text only, and
+ * OpenRouter's image routing for other decision models is unverified, so this
+ * format sends no images.
+ */
+export const systemOneFormat = {
+  images: false,
+  request: (model, state, questions) => ({ model, state, questions: toSystemOneQuestions(questions) }),
+  parse: (body) => body,
+};
+
+// Cloudflare rejects requests outside these bounds; checking first turns a
+// nested validation dump into a clear message.
+const CLEF_MAX_QUESTIONS = 64;
+const CLEF_QUESTION_ID = /^[A-Za-z0-9_.-]{1,100}$/;
+const CLEF_MAX_IMAGE_BYTES = 4 * 1024 * 1024;
+const CLEF_MAX_TOTAL_IMAGE_BYTES = 8 * 1024 * 1024;
+// Workers AI rejects a request whose estimated size exceeds the context
+// window before running it, estimating one token per four characters of the
+// body including base64 image data, though far fewer tokens are billed.
+const CLEF_CONTEXT_TOKENS = 65536;
+const CLEF_CHARS_PER_ESTIMATED_TOKEN = 4;
+
+function decodedBytes(image) {
+  return Math.floor((image.base64.length * 3) / 4);
+}
+
+function checkClefImages(images, state, questions) {
+  const sizes = images.map(decodedBytes);
+  const tooLarge = sizes.findIndex((bytes) => bytes > CLEF_MAX_IMAGE_BYTES);
+  if (tooLarge !== -1) {
+    throw new DecisionError(`Clef accepts images up to 4 MiB each; image ${tooLarge + 1} is ${(sizes[tooLarge] / 1048576).toFixed(1)} MiB.`, { terminal: true });
+  }
+  if (sizes.reduce((a, b) => a + b, 0) > CLEF_MAX_TOTAL_IMAGE_BYTES) {
+    throw new DecisionError('Clef accepts at most 8 MiB of images per call.', { terminal: true });
+  }
+  const chars = images.reduce((n, image) => n + dataUrl(image).length, 0) + asText(state ?? '').length + JSON.stringify(questions).length;
+  const estimate = Math.ceil(chars / CLEF_CHARS_PER_ESTIMATED_TOKEN);
+  if (estimate > CLEF_CONTEXT_TOKENS) {
+    throw new DecisionError(
+      `Cloudflare estimates this request at ~${estimate} tokens (4 base64 characters per token), over Clef's ${CLEF_CONTEXT_TOKENS}-token window. ` +
+      'Downscale or recompress the images (about 180 KB in total fits), or use gpt-6-luna.',
+      { terminal: true },
+    );
+  }
+}
+
+/**
+ * Cloudflare Workers AI runs Clef with the System One request and answer
+ * shapes, wrapped in its `{ result, success, errors }` envelope. Clef adds up
+ * to four embedded images; `state` stays required, but may be empty when the
+ * images are the whole input.
+ */
+export const cloudflareFormat = {
+  images: true,
+  request(model, state, questions, images = []) {
+    const ids = Object.keys(questions);
+    if (ids.length > CLEF_MAX_QUESTIONS) {
+      throw new DecisionError(`Clef accepts at most ${CLEF_MAX_QUESTIONS} questions per call (got ${ids.length}).`, { terminal: true });
+    }
+    const bad = ids.filter((id) => !CLEF_QUESTION_ID.test(id));
+    if (bad.length) {
+      throw new DecisionError(
+        `Clef question names may use only letters, digits, "_", ".", and "-" (max 100 characters): ${bad.join(', ')}.`,
+        { terminal: true },
+      );
+    }
+    const body = { model, state: state ?? '', questions: toSystemOneQuestions(questions) };
+    if (images.length === 0) return body;
+    checkClefImages(images, state, questions);
+    return { ...body, images: images.map(dataUrl) };
+  },
+  parse(body) {
+    if (body?.success === false) {
+      const detail = (body.errors || []).map((e) => e?.message || JSON.stringify(e)).join('; ');
+      throw new DecisionError(`Cloudflare reported failure: ${detail || 'no details'}`, { retryable: true });
+    }
+    return body?.result ?? body;
+  },
+};
+
+/**
+ * OpenAI's predicates take no criteria, so a noul question's true/false
+ * descriptions become part of its instructions.
+ */
+function predicateInstructions(question) {
+  const instructions = asText(question.instructions);
+  if (!question.criteria) return instructions;
+  return `${instructions}\n\nAnswer true if: ${asText(question.criteria.true)}\nAnswer false if: ${asText(question.criteria.false)}`;
+}
+
+function toOpenAIQuestion(name, question) {
+  if (question.type === 'noul') {
+    return { type: 'predicate', name, instructions: predicateInstructions(question) };
+  }
+  if (question.type === 'choice') {
+    return {
+      type: 'choice',
+      name,
+      instructions: asText(question.instructions),
+      choices: Object.entries(question.criteria).map(([value, description]) =>
+        description === null || description === undefined ? { value } : { value, description: asText(description) },
+      ),
+    };
+  }
+  return {
+    type: 'score',
+    name,
+    instructions: asText(question.instructions),
+    levels: question.criteria.map((level) => {
+      if (!isLabeledLevel(level)) return { label: asText(level) };
+      return level.description === undefined
+        ? { label: level.label }
+        : { label: level.label, description: asText(level.description) };
+    }),
+  };
+}
+
+function fromOpenAIAnswer(answer) {
+  const { type, name: _name, ...rest } = answer;
+  if (type === 'predicate') {
+    return { type: 'noul', noul: answer.probability };
+  }
+  if (type === 'choice') {
+    return {
+      type: 'choice',
+      choice: answer.choice,
+      probabilities: Object.fromEntries((answer.probabilities || []).map((p) => [p.value, p.probability])),
+      confidence: answer.confidence,
+    };
+  }
+  if (type === 'score') {
+    const levels = answer.probabilities || [];
+    return {
+      type: 'score',
+      score: answer.score,
+      legend: Object.fromEntries(levels.map((p) => [String(p.value), p.label])),
+      probabilities: Object.fromEntries(levels.map((p) => [String(p.value), p.probability])),
+      confidence: answer.confidence,
+    };
+  }
+  return { type, ...rest };
+}
+
+/**
+ * OpenAI's Decisions API (`POST /v1/decisions`) asks the same three kinds of
+ * question in its own schema: string `input` instead of `state`, a question
+ * array with `name`, `predicate` for `noul`, `choices` and `levels` arrays,
+ * and answers as an array with probability lists. It only accepts strings for
+ * `input` and `instructions`, so structured values are sent as JSON text.
+ * Images turn `input` into one user message of text and `input_image` parts.
+ */
+export const openaiFormat = {
+  images: true,
+  request(model, state, questions, images = []) {
+    const input = images.length === 0
+      ? asText(state)
+      : [{
+        role: 'user',
+        content: [
+          ...(state === undefined ? [] : [{ type: 'input_text', text: asText(state) }]),
+          ...images.map((image) => ({ type: 'input_image', image_url: dataUrl(image) })),
+        ],
+      }];
+    return {
+      model,
+      input,
+      questions: Object.entries(questions).map(([name, question]) => toOpenAIQuestion(name, question)),
+    };
+  },
+  parse(body) {
+    if (!Array.isArray(body?.answers)) return body;
+    const answers = Object.fromEntries(body.answers.map((answer) => [answer.name, fromOpenAIAnswer(answer)]));
+    return {
+      model: body.model,
+      answers,
+      usage: body.usage ? { input_tokens: body.usage.input_tokens, output_tokens: body.usage.output_tokens } : undefined,
+      ...(body.id ? { id: body.id } : {}),
+    };
+  },
+};