converse-mcp-server 4.5.3 → 4.6.1

package/src/decisionProviders/{systemOne.js → http.js}

@@ -1,14 +1,14 @@
 /**
- * System One HTTP client
+ * Decision API HTTP client
  *
- * One client for every host of the System One decision API. TypeSafe serves it
- * natively at `/v1/systemone`; OpenRouter serves the same request/response
- * schema at the same path under its own base URL, so providers differ only in
- * base URL, key, and headers.
+ * One transport for every decision host: retries, timeouts, cancellation, and
+ * error mapping. Hosts differ in URL, auth, and wire format; each provider's
+ * format (see formats.js) builds the request body and normalizes the response,
+ * so this module only moves JSON.
  *
- * Plain fetch rather than @typesafe-ai/sdk: the schema is small, the tool
- * needs its own abort signal and error mapping, and the SDK's model listing
- * breaks against OpenRouter.
+ * Plain fetch rather than vendor SDKs: the schemas are small, the tool needs
+ * its own abort signal and error mapping across hosts, and @typesafe-ai/sdk's
+ * model listing breaks against OpenRouter.
  */
 
 const DEFAULT_TIMEOUT_MS = 60_000;
@@ -19,17 +19,20 @@ const BACKOFF_MAX_MS = 5_000;
 const MAX_RETRY_AFTER_MS = 30_000;
 
 /**
- * Error from a System One call. `retryable` marks failures worth repeating or
+ * Error from a decision call. `retryable` marks failures worth repeating or
  * failing over (network, timeout, 408/429/5xx, auth); `terminal` marks request
- * faults that every host would reject the same way.
+ * faults that every host of the same model would reject the same way;
+ * `notSent` marks a request refused by a local limit check before any network
+ * call, so it is not reported as a failed request.
  */
 export class DecisionError extends Error {
-  constructor(message, { status = null, retryable = false, terminal = false, requestId = null, retryAfterMs = null } = {}) {
+  constructor(message, { status = null, retryable = false, terminal = false, notSent = false, requestId = null, retryAfterMs = null } = {}) {
     super(message);
     this.name = 'DecisionError';
     this.status = status;
     this.retryable = retryable;
     this.terminal = terminal;
+    this.notSent = notSent;
     this.requestId = requestId;
     this.retryAfterMs = retryAfterMs;
   }
@@ -55,11 +58,38 @@ function formatIssues(text) {
 }
 
 /**
- * Extract a readable message from an error body. OpenRouter wraps errors as
- * `{ error: { message } }`; TypeSafe answers `{ detail: { error_type, message } }`,
- * or `{ detail }` as a string or a list of validation issues.
+ * Workers AI embeds the model's own error as JSON inside its message
+ * (`AiError: AiError: {"error":{...,"details":{"fieldErrors":...}}} (id)`);
+ * surface the validation details instead of the raw dump.
+ */
+function describeWorkersAiError(message) {
+  const embedded = message.match(/\{.*\}/s)?.[0];
+  let inner;
+  try {
+    inner = JSON.parse(embedded).error;
+  } catch {
+    return formatIssues(message);
+  }
+  if (typeof inner?.message !== 'string') return message;
+  const fields = Object.entries(inner.details?.fieldErrors ?? {})
+    .map(([field, problems]) => `${field}: ${[].concat(problems).join(', ')}`);
+  const forms = [].concat(inner.details?.formErrors ?? []);
+  const details = [...fields, ...forms];
+  return details.length ? `${inner.message} (${details.join('; ')})` : inner.message;
+}
+
+/**
+ * Extract a readable message from an error body. OpenRouter and OpenAI wrap
+ * errors as `{ error: { message } }`; TypeSafe answers
+ * `{ detail: { error_type, message } }`, or `{ detail }` as a string or a list
+ * of validation issues; Cloudflare answers `{ errors: [{ code, message }] }`.
  */
 export function extractErrorMessage(body, rawText) {
+  if (Array.isArray(body?.errors) && body.errors.length > 0) {
+    return body.errors
+      .map((e) => (typeof e?.message === 'string' ? describeWorkersAiError(e.message) : JSON.stringify(e)))
+      .join('; ');
+  }
   if (typeof body?.detail?.message === 'string') {
     const type = body.detail.error_type ? `${body.detail.error_type}: ` : '';
     return `${type}${body.detail.message}`;
@@ -150,7 +180,7 @@ function sleep(ms, signal) {
   });
 }
 
-async function sendOnce({ url, headers, body, signal, timeoutMs }) {
+async function sendOnce({ url, headers, body, parse, signal, timeoutMs }) {
   const attemptSignal = signal
     ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
     : AbortSignal.timeout(timeoutMs);
@@ -184,8 +214,8 @@ async function sendOnce({ url, headers, body, signal, timeoutMs }) {
     const status = response.status;
     const detail = extractErrorMessage(parsed, rawText);
     const html = describeHtmlError(detail);
-    // Every host forwards to TypeSafe's edge, so a firewall block repeats on
-    // retry and on failover alike.
+    // A firewall block repeats on retry, and on failover to any host that
+    // forwards to the same upstream.
     const firewall = html?.firewall === true;
     throw new DecisionError(`HTTP ${status}: ${html ? html.message : truncate(detail)}`, {
       status,
@@ -194,42 +224,46 @@ async function sendOnce({ url, headers, body, signal, timeoutMs }) {
       requestId:
         response.headers.get('x-typesafe-request-id') ||
         response.headers.get('x-generation-id') ||
+        response.headers.get('x-request-id') ||
         html?.rayId ||
         response.headers.get('cf-ray'),
       retryAfterMs: parseRetryAfter(response.headers),
     });
   }
 
-  if (!parsed || typeof parsed.answers !== 'object' || parsed.answers === null) {
+  const result = parse(parsed);
+  if (!result || typeof result.answers !== 'object' || result.answers === null) {
     throw new DecisionError('Malformed response: missing "answers" object', { status: response.status });
   }
-  return parsed;
+  return result;
 }
 
 /**
  * POST a decision request, retrying transient failures (except auth, which
  * retrying cannot fix) with exponential backoff that honors Retry-After.
  * @param {object} params
- * @param {string} params.baseURL - Host base, e.g. https://api.typesafe.ai
+ * @param {string} params.url - Full endpoint URL
  * @param {object} params.headers - Auth and attribution headers
- * @param {object} params.body - `{ model, state, questions }`
+ * @param {object} params.body - Request body in the host's wire format
+ * @param {(body: object|null) => object} [params.parse] - Maps the response
+ *   body to `{ model, answers, usage, id }` in System One answer shapes
  * @param {AbortSignal} [params.signal] - Caller cancellation
  * @param {number} [params.timeoutMs] - Per-attempt timeout
  * @param {number} [params.maxRetries] - Retries after the first attempt
- * @returns {Promise<object>} Parsed response body
+ * @returns {Promise<object>} Normalized response
  */
-export async function callSystemOne({
-  baseURL,
+export async function callDecisionApi({
+  url,
   headers,
   body,
+  parse = (parsed) => parsed,
   signal,
   timeoutMs = DEFAULT_TIMEOUT_MS,
   maxRetries = DEFAULT_MAX_RETRIES,
 }) {
-  const url = `${baseURL.replace(/\/+$/, '')}/v1/systemone`;
   for (let attempt = 0; ; attempt++) {
     try {
-      return await sendOnce({ url, headers, body, signal, timeoutMs });
+      return await sendOnce({ url, headers, body, parse, signal, timeoutMs });
     } catch (error) {
       const authFailure = error.status === 401 || error.status === 403;
       if (!(error instanceof DecisionError) || !error.retryable || authFailure || attempt >= maxRetries) {

package/src/decisionProviders/index.js

@@ -1,97 +1,181 @@
 /**
  * Decision Providers
  *
- * Hosts of System One decision models (TypeSafe's Jev family). These are kept
+ * Hosts of decision models: OpenAI's Decisions API, TypeSafe's Jev,
+ * Cloudflare's Clef, and OpenRouter, which re-serves all three. These are kept
  * apart from the chat provider registry on purpose: a decision model takes a
  * state plus typed questions and returns probabilities, never text, so it must
  * never be reachable from `chat` routing ("auto", bare names, failover), and
  * the `decide` tool must never reach a chat model.
  *
  * Spec grammar mirrors chat routing:
- * - `auto` (or empty) — every configured provider's default, in priority order
+ * - `auto` (or empty) — each AUTO_MODELS entry on every configured host, in order
  * - `provider` / `provider:` — that provider's default model
  * - `provider:model` — that provider only
- * - `model` — every provider that serves the name, in priority order; the
- *   first is used and the rest are failover candidates
+ * - `model` — every provider that serves the model, natives first; the first
+ *   is used and the rest are failover candidates
  */
 
 import { getCustomHeaders as getOpenRouterAttributionHeaders } from '../providers/openrouter.js';
+import { callDecisionApi } from './http.js';
+import { cloudflareFormat, openaiFormat, systemOneFormat } from './formats.js';
 
-/**
- * Model catalogs map each provider's own model ID to the names that route to
- * it. OpenRouter only knows `~typesafe/jev-latest` and `typesafe/jev-1.13`
- * (it rejects `jev-1.13.0` and `jev-preview`), so native IDs are translated
- * per provider rather than by a blanket prefix rewrite.
- */
 export const DECISION_PROVIDERS = {
+  openai: {
+    name: 'openai',
+    label: 'OpenAI',
+    setup: 'set OPENAI_API_KEY',
+    defaultModel: 'gpt-6-luna',
+    format: openaiFormat,
+    endpoint: () => 'https://api.openai.com/v1/decisions',
+    headers: (config) => ({ Authorization: `Bearer ${config.apiKeys.openai}` }),
+    isAvailable: (config) => Boolean(config?.apiKeys?.openai),
+    passthrough: () => false,
+  },
   typesafe: {
     name: 'typesafe',
     label: 'TypeSafe',
-    baseURL: 'https://api.typesafe.ai',
-    apiKeyEnv: 'TYPESAFE_API_KEY',
+    setup: 'set TYPESAFE_API_KEY',
     defaultModel: 'jev-latest',
-    models: {
-      'jev-latest': ['jev', '~typesafe/jev-latest'],
-      'jev-1.13.0': ['jev-1.13', 'typesafe/jev-1.13'],
-      'jev-preview': [],
-    },
-    // TypeSafe accepts every published versioned ID, listed or not.
-    passthrough: (name) => /^jev-\d+\.\d+(\.\d+)?$/i.test(name),
+    format: systemOneFormat,
+    endpoint: () => 'https://api.typesafe.ai/v1/systemone',
     headers: (config) => ({ Authorization: `Bearer ${config.apiKeys.typesafe}` }),
     isAvailable: (config) => Boolean(config?.apiKeys?.typesafe),
+    // TypeSafe accepts every published versioned ID, listed or not.
+    passthrough: (name) => /^jev-\d+\.\d+(\.\d+)?$/i.test(name),
+  },
+  cloudflare: {
+    name: 'cloudflare',
+    label: 'Cloudflare',
+    setup: 'set CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN',
+    defaultModel: 'clef',
+    format: cloudflareFormat,
+    // Workers AI addresses the model in the path and checks that the body's
+    // bare `model` matches it.
+    endpoint: (config, model) =>
+      `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(config.providers.cloudflareaccountid)}/ai/run/@cf/cloudflare/${model}`,
+    headers: (config) => ({ Authorization: `Bearer ${config.providers.cloudflareapitoken}` }),
+    isAvailable: (config) =>
+      Boolean(config?.providers?.cloudflareaccountid && config?.providers?.cloudflareapitoken),
+    passthrough: () => false,
   },
   openrouter: {
     name: 'openrouter',
     label: 'OpenRouter',
-    baseURL: 'https://openrouter.ai/api',
-    apiKeyEnv: 'OPENROUTER_API_KEY',
-    defaultModel: '~typesafe/jev-latest',
-    models: {
-      '~typesafe/jev-latest': ['jev-latest', 'jev'],
-      'typesafe/jev-1.13': ['jev-1.13', 'jev-1.13.0'],
-    },
-    // Decision models OpenRouter adds later are reachable by full slug.
-    passthrough: (name) => name.includes('/'),
+    setup: 'set OPENROUTER_API_KEY',
+    defaultModel: 'gpt-6-luna',
+    format: systemOneFormat,
+    endpoint: () => 'https://openrouter.ai/api/v1/systemone',
     headers: (config) => ({
       Authorization: `Bearer ${config.apiKeys.openrouter}`,
       ...getOpenRouterAttributionHeaders(config),
     }),
     isAvailable: (config) => Boolean(config?.apiKeys?.openrouter),
+    // Decision models OpenRouter adds later are reachable by full slug.
+    passthrough: (name) => name.includes('/'),
   },
 };
 
-/** Failover order: the native host first, then OpenRouter. */
-export const DECISION_PROVIDER_PRIORITY = ['typesafe', 'openrouter'];
+/** Failover order: each model's native host first, then OpenRouter. */
+export const DECISION_PROVIDER_PRIORITY = ['openai', 'typesafe', 'cloudflare', 'openrouter'];
+
+/**
+ * Decision models by canonical name. `hosts` maps each provider that serves
+ * the model to that provider's own ID: OpenRouter only knows
+ * `~typesafe/jev-latest` and `typesafe/jev-1.13` (it rejects `jev-1.13.0` and
+ * `jev-preview`), so IDs are translated per host rather than by a blanket
+ * prefix rewrite. Every host ID also routes to its model. `maxImages` is how
+ * many images the model takes per call; a host also needs a format that can
+ * send them.
+ */
+export const DECISION_MODELS = {
+  'gpt-6-luna': {
+    aliases: ['luna', 'gpt-6-luna-decisions'],
+    hosts: { openai: 'gpt-6-luna', openrouter: 'openai/gpt-6-luna-decisions' },
+    // OpenAI documents no image count limit; the API enforces its own.
+    maxImages: Infinity,
+  },
+  'jev-latest': {
+    aliases: ['jev'],
+    hosts: { typesafe: 'jev-latest', openrouter: '~typesafe/jev-latest' },
+    maxImages: 0,
+  },
+  'jev-1.13': {
+    aliases: [],
+    hosts: { typesafe: 'jev-1.13.0', openrouter: 'typesafe/jev-1.13' },
+    maxImages: 0,
+  },
+  'jev-preview': {
+    aliases: [],
+    hosts: { typesafe: 'jev-preview' },
+    maxImages: 0,
+  },
+  clef: {
+    aliases: ['@cf/cloudflare/clef'],
+    hosts: { cloudflare: 'clef', openrouter: 'cloudflare/clef' },
+    maxImages: 4,
+  },
+  'clef-flash': {
+    aliases: ['@cf/cloudflare/clef-flash'],
+    hosts: { cloudflare: 'clef-flash', openrouter: 'cloudflare/clef-flash' },
+    maxImages: 4,
+  },
+};
+
+/** What `auto` tries, in order: OpenAI's model first, then Jev, then Clef. */
+export const AUTO_MODELS = ['gpt-6-luna', 'jev-latest', 'clef'];
+
+function findCanonicalModel(name) {
+  const wanted = name.toLowerCase();
+  for (const [canonical, entry] of Object.entries(DECISION_MODELS)) {
+    const names = [canonical, ...entry.aliases, ...Object.values(entry.hosts)];
+    if (names.some((n) => n.toLowerCase() === wanted)) return canonical;
+  }
+  return null;
+}
 
 /**
- * Resolve a name against one provider's catalog, then its passthrough rule.
- * @returns {string|null} The model ID to send to that provider
+ * Resolve a name on one provider: a catalog model it hosts, then its
+ * passthrough rule.
+ * @returns {{ model: string, family: string, maxImages: number }|null} The ID
+ *   to send to that provider, the model it names (hosts of one family share
+ *   failures), and how many images this host can send that model
  */
 export function findDecisionModel(provider, name) {
-  const wanted = String(name).trim().toLowerCase();
-  if (!wanted) return null;
-  for (const [id, aliases] of Object.entries(provider.models)) {
-    if (id.toLowerCase() === wanted || aliases.some((a) => a.toLowerCase() === wanted)) {
-      return id;
-    }
+  const trimmed = String(name).trim();
+  if (!trimmed) return null;
+  const canonical = findCanonicalModel(trimmed);
+  const hosted = canonical ? DECISION_MODELS[canonical].hosts[provider.name] : undefined;
+  if (hosted) {
+    const maxImages = provider.format.images ? DECISION_MODELS[canonical].maxImages : 0;
+    return { model: hosted, family: canonical, maxImages };
   }
-  return provider.passthrough(String(name).trim()) ? String(name).trim() : null;
+  return provider.passthrough(trimmed) ? { model: trimmed, family: trimmed, maxImages: 0 } : null;
 }
 
-function setupHint(provider) {
-  return `set ${provider.apiKeyEnv}`;
+function servedBy(providerName) {
+  return Object.entries(DECISION_MODELS)
+    .filter(([, entry]) => entry.hosts[providerName])
+    .map(([canonical]) => canonical);
 }
 
 function knownModels() {
-  const names = new Set();
-  for (const providerName of DECISION_PROVIDER_PRIORITY) {
-    const provider = DECISION_PROVIDERS[providerName];
-    for (const [id, aliases] of Object.entries(provider.models)) {
-      names.add(id);
-      aliases.forEach((a) => names.add(a));
-    }
-  }
-  return [...names];
+  return Object.entries(DECISION_MODELS).flatMap(([canonical, entry]) => [canonical, ...entry.aliases]);
+}
+
+function candidate(provider, found) {
+  return { providerName: provider.name, provider, ...found };
+}
+
+/** Every provider that serves a name, in priority order. */
+function hostsOf(name) {
+  return DECISION_PROVIDER_PRIORITY
+    .map((providerName) => {
+      const provider = DECISION_PROVIDERS[providerName];
+      const found = findDecisionModel(provider, name);
+      return found ? candidate(provider, found) : null;
+    })
+    .filter(Boolean);
 }
 
 function ok(candidates) {
@@ -106,21 +190,18 @@ function fail(status, error) {
  * Resolve a decision model spec into an ordered candidate list.
  * @param {string} spec - Model spec (see module grammar)
  * @param {object} config - Server configuration (for API keys)
- * @returns {{ status: 'ok'|'unknown'|'unavailable', candidates: Array<{ providerName: string, provider: object, model: string }>, error: string|null }}
+ * @returns {{ status: 'ok'|'unknown'|'unavailable', candidates: Array<{ providerName: string, provider: object, model: string, family: string }>, error: string|null }}
  */
 export function resolveDecisionModel(spec, config) {
   const raw = String(spec ?? '').trim();
   const namespaces = DECISION_PROVIDER_PRIORITY.join(', ');
 
   if (!raw || raw.toLowerCase() === 'auto') {
-    const candidates = DECISION_PROVIDER_PRIORITY
-      .map((name) => DECISION_PROVIDERS[name])
-      .filter((provider) => provider.isAvailable(config))
-      .map((provider) => ({ providerName: provider.name, provider, model: provider.defaultModel }));
+    const candidates = AUTO_MODELS.flatMap(hostsOf).filter((c) => c.provider.isAvailable(config));
     if (candidates.length === 0) {
       return fail(
         'unavailable',
-        `No decision provider is configured: ${DECISION_PROVIDER_PRIORITY.map((n) => `${n} (${setupHint(DECISION_PROVIDERS[n])})`).join('; ')}.`,
+        `No decision provider is configured: ${DECISION_PROVIDER_PRIORITY.map((n) => `${n} (${DECISION_PROVIDERS[n].setup})`).join('; ')}.`,
       );
     }
     return ok(candidates);
@@ -136,27 +217,17 @@ export function resolveDecisionModel(spec, config) {
       return fail('unknown', `Unknown decision provider "${raw.slice(0, colon)}". Providers: ${namespaces}.`);
     }
     const name = hasNamespace ? raw.slice(colon + 1).trim() : '';
-    const model = name ? findDecisionModel(provider, name) : provider.defaultModel;
-    if (!model) {
-      return fail(
-        'unknown',
-        `${provider.label} does not serve "${name}". Models: ${Object.keys(provider.models).join(', ')}.`,
-      );
+    const found = findDecisionModel(provider, name || provider.defaultModel);
+    if (!found) {
+      return fail('unknown', `${provider.label} does not serve "${name}". Models: ${servedBy(provider.name).join(', ')}.`);
     }
     if (!provider.isAvailable(config)) {
-      return fail('unavailable', `${provider.label} is not configured (${setupHint(provider)}).`);
+      return fail('unavailable', `${provider.label} is not configured (${provider.setup}).`);
     }
-    return ok([{ providerName: provider.name, provider, model }]);
+    return ok([candidate(provider, found)]);
   }
 
-  const matches = DECISION_PROVIDER_PRIORITY
-    .map((providerName) => {
-      const provider = DECISION_PROVIDERS[providerName];
-      const model = findDecisionModel(provider, raw);
-      return model ? { providerName, provider, model } : null;
-    })
-    .filter(Boolean);
-
+  const matches = hostsOf(raw);
   if (matches.length === 0) {
     return fail(
       'unknown',
@@ -167,8 +238,31 @@ export function resolveDecisionModel(spec, config) {
   if (available.length === 0) {
     return fail(
       'unavailable',
-      `"${raw}" is served by ${matches.map((m) => `${m.providerName} (${setupHint(m.provider)})`).join('; ')}, but none is configured.`,
+      `"${raw}" is served by ${matches.map((m) => `${m.providerName} (${m.provider.setup})`).join('; ')}, but none is configured.`,
     );
   }
   return ok(available);
 }
+
+/**
+ * Ask one candidate: translate the System One request into the host's wire
+ * format, send it, and map the answers back.
+ * @param {object} candidate - From resolveDecisionModel
+ * @param {object} params
+ * @param {string|object|Array} params.state
+ * @param {object} params.questions - System One question map
+ * @param {Array<{ mimeType: string, base64: string }>} [params.images]
+ * @param {object} params.config - Server configuration
+ * @param {AbortSignal} [params.signal]
+ * @returns {Promise<{ model?: string, answers: object, usage?: object, id?: string }>}
+ */
+export async function askDecisionModel(candidate, { state, questions, images = [], config, signal }) {
+  const { provider, model } = candidate;
+  return callDecisionApi({
+    url: provider.endpoint(config, model),
+    headers: provider.headers(config),
+    body: provider.format.request(model, state, questions, images),
+    parse: provider.format.parse,
+    signal,
+  });
+}

package/src/providers/anthropic.js

@@ -339,6 +339,37 @@ const SUPPORTED_MODELS = {
       'claude-sonnet-4-5',
     ],
   },
+  'claude-haiku-5-5': {
+    modelName: 'claude-haiku-5-5',
+    friendlyName: 'Claude Haiku 5.5',
+    contextWindow: 1000000, // 1M context by default - no beta header required
+    maxOutputTokens: 128000,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsWebSearch: false,
+    supportsThinking: true,
+    supportsAdaptiveThinking: true, // budget_tokens is rejected; adaptive is the only on-mode
+    timeout: 1800000,
+    supportsEffort: true,
+    effortGA: true,
+    effortTiers: EFFORT_TIERS_FULL,
+    supportsCompaction: true,
+    // No server-side refusal fallback, so `fallbacks` must not be sent
+    description:
+      'Claude Haiku 5.5 - Current Haiku: fastest and cheapest Claude for high-volume and latency-sensitive work',
+    aliases: [
+      'claude-haiku-5-5',
+      'claude-haiku-5.5',
+      'claude-5.5-haiku',
+      'claude-5-5-haiku',
+      'haiku-5.5',
+      'haiku-5-5',
+      'haiku5.5',
+      'haiku5-5',
+      'haiku',
+      'claude-haiku',
+    ],
+  },
   'claude-haiku-4-5-20251001': {
     modelName: 'claude-haiku-4-5-20251001',
     friendlyName: 'Claude Haiku 4.5',
@@ -352,7 +383,7 @@ const SUPPORTED_MODELS = {
     maxThinkingTokens: 64000,
     timeout: 900000,
     description:
-      'Claude Haiku 4.5 - Fast and intelligent model with extended thinking',
+      'Claude Haiku 4.5 - Previous Haiku generation with extended thinking',
     aliases: [
       'claude-haiku-4-5',
       'claude-4.5-haiku',
@@ -362,8 +393,6 @@ const SUPPORTED_MODELS = {
       'claude-haiku-4.5',
       'haiku4.5',
       'claude-haiku-4',
-      'haiku',
-      'claude-haiku',
     ],
   },
 };

package/src/providers/claude.js

@@ -112,6 +112,25 @@ const SUPPORTED_MODELS = {
       'sonnet-5.5',
     ],
   },
+  'claude-haiku-5-5': {
+    modelName: 'claude-haiku-5-5',
+    friendlyName: 'Claude Haiku 5.5 (via Agent SDK)',
+    contextWindow: 1000000,
+    maxOutputTokens: 128000,
+    supportsStreaming: true,
+    supportsImages: true,
+    supportsWebSearch: false,
+    timeout: 1800000,
+    description:
+      'Claude Haiku 5.5 via Agent SDK - requires claude login authentication',
+    aliases: [
+      'haiku',
+      'claude-haiku',
+      'claude-haiku-5.5',
+      'haiku-5-5',
+      'haiku-5.5',
+    ],
+  },
 };
 
 /**

package/src/providers/copilot.js

@@ -125,6 +125,18 @@ const SUPPORTED_MODELS = {
     description: 'Anthropic Claude Opus 5.5 via Copilot subscription',
     aliases: ['opus', 'claude', 'claude-opus-5-5'],
   },
+  'claude-fable-5.1': {
+    modelName: 'claude-fable-5.1',
+    friendlyName: 'Claude Fable 5.1 (via Copilot)',
+    contextWindow: 200000,
+    maxOutputTokens: 32768,
+    supportsStreaming: true,
+    supportsImages: false,
+    supportsWebSearch: false,
+    timeout: 1800000,
+    description: 'Anthropic Claude Fable 5.1 via Copilot subscription',
+    aliases: ['fable', 'claude-fable-5-1'],
+  },
   'claude-fable-5': {
     modelName: 'claude-fable-5',
     friendlyName: 'Claude Fable 5 (via Copilot)',
@@ -135,7 +147,7 @@ const SUPPORTED_MODELS = {
     supportsWebSearch: false,
     timeout: 1800000,
     description: 'Anthropic Claude Fable 5 via Copilot subscription',
-    aliases: ['fable'],
+    aliases: [],
   },
   'claude-sonnet-5.5': {
     modelName: 'claude-sonnet-5.5',
@@ -149,6 +161,18 @@ const SUPPORTED_MODELS = {
     description: 'Anthropic Claude Sonnet 5.5 via Copilot subscription',
     aliases: ['sonnet', 'claude-sonnet-5-5'],
   },
+  'claude-haiku-5.5': {
+    modelName: 'claude-haiku-5.5',
+    friendlyName: 'Claude Haiku 5.5 (via Copilot)',
+    contextWindow: 200000,
+    maxOutputTokens: 32768,
+    supportsStreaming: true,
+    supportsImages: false,
+    supportsWebSearch: false,
+    timeout: 1800000,
+    description: 'Anthropic Claude Haiku 5.5 via Copilot subscription',
+    aliases: ['haiku', 'claude-haiku-5-5'],
+  },
   'claude-sonnet-5': {
     modelName: 'claude-sonnet-5',
     friendlyName: 'Claude Sonnet 5 (via Copilot)',