@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.1

package/src/models/discovery.js

@@ -0,0 +1,292 @@
+import { getModelRecord } from './catalog.js';
+
+function clean(value) { return value == null ? '' : String(value).trim(); }
+function positiveInt(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+function timeoutSignal(ms = 8_000) {
+  return typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout(ms) : undefined;
+}
+function failure(error, attempted = true) {
+  return { attempted, ok: false, models: [], error: error?.message || String(error || 'unknown error') };
+}
+
+function providerReference(provider, id) {
+  if (provider !== 'anthropic') return null;
+  const million = new Set([
+    'claude-fable-5', 'claude-opus-5', 'claude-opus-4-8', 'claude-opus-4-7',
+    'claude-opus-4-6', 'claude-sonnet-5', 'claude-sonnet-4-6',
+  ]);
+  const twoHundredK = new Set([
+    'claude-opus-4-5-20251101', 'claude-sonnet-4-5-20250929', 'claude-haiku-4-5-20251001',
+  ]);
+  const contextWindow = million.has(id) ? 1_000_000 : twoHundredK.has(id) ? 200_000 : null;
+  if (!contextWindow) return null;
+  return Object.freeze({
+    model_key: `anthropic:${id}`,
+    provider: 'anthropic',
+    provider_model_id: id,
+    label: id,
+    context_window: contextWindow,
+    max_output_tokens: ['claude-opus-5', 'claude-sonnet-5'].includes(id) ? 128_000 : null,
+    reasoning_efforts: Object.freeze(['auto']),
+    service_tiers: Object.freeze(['default']),
+    capabilities: Object.freeze({ messages: true, function_calling: true, prompt_caching: true, compaction: true }),
+    source: Object.freeze({
+      url: 'https://docs.anthropic.com/en/docs/about-claude/models/overview',
+      as_of: '2026-09-17',
+    }),
+  });
+}
+
+function fallbackRecord(provider, id) {
+  const record = getModelRecord(`${provider}:${id}`) || getModelRecord(id) || providerReference(provider, id);
+  return record || null;
+}
+
+function baseRecord(provider, id, values = {}) {
+  const fallback = fallbackRecord(provider, id);
+  const contextWindow = positiveInt(values.context_window ?? values.contextWindow ?? fallback?.context_window);
+  const maxOutput = positiveInt(values.max_output_tokens ?? values.maxOutputTokens ?? fallback?.max_output_tokens);
+  return Object.freeze({
+    model_key: `${provider}:${id}`,
+    provider,
+    provider_model_id: id,
+    label: clean(values.label) || fallback?.label || id,
+    availability: 'available',
+    availability_source: 'provider_api',
+    context_window: contextWindow,
+    context_window_source: values.context_window != null || values.contextWindow != null
+      ? 'provider_api'
+      : fallback?.context_window ? 'sdk_reference' : 'unknown',
+    max_output_tokens: maxOutput,
+    max_output_tokens_source: values.max_output_tokens != null || values.maxOutputTokens != null
+      ? 'provider_api'
+      : fallback?.max_output_tokens ? 'sdk_reference' : 'unknown',
+    reasoning_efforts: Object.freeze(
+      Array.isArray(values.reasoning_efforts) && values.reasoning_efforts.length
+        ? [...values.reasoning_efforts]
+        : fallback?.reasoning_efforts ? [...fallback.reasoning_efforts] : ['auto'],
+    ),
+    service_tiers: Object.freeze(
+      Array.isArray(values.service_tiers) && values.service_tiers.length
+        ? [...values.service_tiers]
+        : fallback?.service_tiers ? [...fallback.service_tiers] : ['default'],
+    ),
+    capabilities: Object.freeze({
+      ...(fallback?.capabilities || {}),
+      ...(values.capabilities || {}),
+    }),
+    pricing: values.pricing || fallback?.pricing || null,
+    context_policy: values.context_policy || fallback?.context_policy || null,
+    batch: values.batch || fallback?.batch || null,
+    source: Object.freeze({
+      kind: 'provider_api',
+      url: clean(values.source_url) || null,
+      discovered_at: new Date().toISOString(),
+      fallback: fallback?.source || null,
+    }),
+    metadata: Object.freeze(values.metadata && typeof values.metadata === 'object' ? { ...values.metadata } : {}),
+  });
+}
+
+async function fetchJson(fetchImpl, url, init) {
+  const response = await fetchImpl(url, { ...init, signal: init?.signal || timeoutSignal() });
+  let body = null;
+  try { body = await response.json(); } catch { body = null; }
+  if (!response.ok) {
+    const message = clean(body?.error?.message || body?.message || body?.errors?.[0]?.message) || `HTTP ${response.status}`;
+    const error = new Error(message);
+    error.status = response.status;
+    throw error;
+  }
+  return body;
+}
+
+export async function discoverOpenAIModels(apiKey, fetchImpl = fetch) {
+  if (!clean(apiKey)) return failure('credential unavailable', false);
+  try {
+    const body = await fetchJson(fetchImpl, 'https://api.openai.com/v1/models', {
+      headers: { authorization: `Bearer ${clean(apiKey)}` },
+    });
+    const models = (Array.isArray(body?.data) ? body.data : [])
+      .map((row) => clean(row?.id))
+      .filter(Boolean)
+      .map((id) => baseRecord('openai', id, {
+        source_url: 'https://api.openai.com/v1/models',
+        capabilities: { responses: true },
+      }));
+    return { attempted: true, ok: true, models, error: null };
+  } catch (error) { return failure(error); }
+}
+
+export async function discoverAnthropicModels(apiKey, fetchImpl = fetch) {
+  if (!clean(apiKey)) return failure('credential unavailable', false);
+  try {
+    const body = await fetchJson(fetchImpl, 'https://api.anthropic.com/v1/models?limit=1000', {
+      headers: {
+        'x-api-key': clean(apiKey),
+        'anthropic-version': '2023-06-01',
+      },
+    });
+    const models = (Array.isArray(body?.data) ? body.data : [])
+      .map((row) => {
+        const id = clean(row?.id);
+        if (!id) return null;
+        return baseRecord('anthropic', id, {
+          label: clean(row?.display_name) || id,
+          source_url: 'https://api.anthropic.com/v1/models',
+          capabilities: { messages: true, function_calling: true, prompt_caching: true },
+          metadata: { created_at: row?.created_at || null, type: row?.type || null },
+        });
+      })
+      .filter(Boolean);
+    return { attempted: true, ok: true, models, error: null };
+  } catch (error) { return failure(error); }
+}
+
+export async function discoverGeminiModels(apiKey, fetchImpl = fetch) {
+  if (!clean(apiKey)) return failure('credential unavailable', false);
+  try {
+    const body = await fetchJson(
+      fetchImpl,
+      `https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000&key=${encodeURIComponent(clean(apiKey))}`,
+      {},
+    );
+    const models = (Array.isArray(body?.models) ? body.models : [])
+      .filter((row) => (row?.supportedGenerationMethods || []).includes('generateContent'))
+      .map((row) => {
+        const id = clean(row?.baseModelId || row?.name).replace(/^models\//, '');
+        if (!id) return null;
+        return baseRecord('gemini', id, {
+          label: clean(row?.displayName) || id,
+          context_window: positiveInt(row?.inputTokenLimit),
+          max_output_tokens: positiveInt(row?.outputTokenLimit),
+          reasoning_efforts: row?.thinking === true ? ['auto', 'low', 'medium', 'high'] : ['auto'],
+          source_url: 'https://generativelanguage.googleapis.com/v1beta/models',
+          capabilities: {
+            generate_content: true,
+            function_calling: true,
+            thinking: row?.thinking === true,
+          },
+          metadata: {
+            version: row?.version || null,
+            supported_generation_methods: row?.supportedGenerationMethods || [],
+          },
+        });
+      })
+      .filter(Boolean);
+    return { attempted: true, ok: true, models, error: null };
+  } catch (error) { return failure(error); }
+}
+
+function xaiPricing(row) {
+  const input = Number(row?.prompt_text_token_price);
+  const cached = Number(row?.cached_prompt_text_token_price);
+  const output = Number(row?.completion_text_token_price);
+  if (![input, output].every(Number.isFinite)) return null;
+  // xAI model API prices are returned in nanos per token. Convert to USD / million tokens.
+  const nanosToPerMillionUsd = (nanos) => Number.isFinite(nanos) ? nanos / 1000 : 0;
+  return Object.freeze({
+    currency: 'USD',
+    unit: 'per_million_tokens',
+    input: nanosToPerMillionUsd(input),
+    cached_input: nanosToPerMillionUsd(cached),
+    cache_write: nanosToPerMillionUsd(input),
+    output: nanosToPerMillionUsd(output),
+    thresholds: Object.freeze(
+      Number.isFinite(Number(row?.long_context_threshold))
+        ? [Object.freeze({
+            input_tokens_gt: Number(row.long_context_threshold),
+            applies_to_full_request: true,
+            multipliers: Object.freeze({
+              input: Number(row?.prompt_text_token_price_long_context) / input || 1,
+              cached_input: 1,
+              cache_write: Number(row?.prompt_text_token_price_long_context) / input || 1,
+              output: Number(row?.completion_text_token_price_long_context) / output || 1,
+            }),
+          })]
+        : [],
+    ),
+    service_tier_multipliers: Object.freeze({ default: 1 }),
+    source: 'https://api.x.ai/v1/models',
+    as_of: new Date().toISOString().slice(0, 10),
+  });
+}
+
+export async function discoverXaiModels(apiKey, fetchImpl = fetch) {
+  if (!clean(apiKey)) return failure('credential unavailable', false);
+  try {
+    const body = await fetchJson(fetchImpl, 'https://api.x.ai/v1/models', {
+      headers: { authorization: `Bearer ${clean(apiKey)}` },
+    });
+    const models = (Array.isArray(body?.data) ? body.data : [])
+      .map((row) => {
+        const id = clean(row?.id);
+        if (!id || /image|video|voice|embedding/i.test(id)) return null;
+        return baseRecord('grok', id, {
+          context_window: positiveInt(row?.context_length),
+          pricing: xaiPricing(row),
+          source_url: 'https://api.x.ai/v1/models',
+          capabilities: { responses: true, function_calling: true, prompt_caching: true },
+          metadata: {
+            aliases: row?.aliases || [],
+            created: row?.created || null,
+            owned_by: row?.owned_by || null,
+          },
+        });
+      })
+      .filter(Boolean);
+    return { attempted: true, ok: true, models, error: null };
+  } catch (error) { return failure(error); }
+}
+
+function cloudflareTaskName(task) {
+  if (typeof task === 'string') return clean(task);
+  if (task && typeof task === 'object') return clean(task.name || task.id);
+  return '';
+}
+
+export async function discoverCloudflareModels(apiToken, accountId, fetchImpl = fetch) {
+  if (!clean(apiToken)) return failure('credential unavailable', false);
+  if (!clean(accountId)) return failure('ACCOUNT_ID is required for Workers AI discovery');
+  try {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(clean(accountId))}/ai/models/search`;
+    const body = await fetchJson(fetchImpl, url, {
+      headers: { authorization: `Bearer ${clean(apiToken)}` },
+    });
+    if (body?.success === false) throw new Error(clean(body?.errors?.[0]?.message) || 'Cloudflare API error');
+    const models = (Array.isArray(body?.result) ? body.result : [])
+      .map((row) => {
+        const id = clean(row?.name);
+        const task = cloudflareTaskName(row?.task);
+        if (!id || task.toLowerCase() !== 'text generation') return null;
+        return baseRecord('cloudflare', id, {
+          label: id,
+          source_url: url,
+          capabilities: { workers_ai: true },
+          metadata: {
+            task,
+            author: clean(row?.author) || null,
+            description: clean(row?.description) || null,
+          },
+        });
+      })
+      .filter(Boolean);
+    return { attempted: true, ok: true, models, error: null, account_id: clean(accountId) };
+  } catch (error) { return failure(error); }
+}
+
+export async function discoverProviderModels(provider, credential, options = {}) {
+  const fetchImpl = options.fetchImpl || fetch;
+  switch (clean(provider).toLowerCase()) {
+    case 'openai': return discoverOpenAIModels(credential?.value, fetchImpl);
+    case 'anthropic': return discoverAnthropicModels(credential?.value, fetchImpl);
+    case 'gemini': return discoverGeminiModels(credential?.value, fetchImpl);
+    case 'grok':
+    case 'xai': return discoverXaiModels(credential?.value, fetchImpl);
+    case 'cloudflare': return discoverCloudflareModels(credential?.value, credential?.account_id, fetchImpl);
+    default: return failure(`unsupported provider: ${provider}`, false);
+  }
+}

package/src/models/index.js

@@ -0,0 +1,7 @@
+export {
+  MODEL_CATALOG_SCHEMA,
+  MODEL_CATALOG,
+  listModelCatalog,
+  getModelRecord,
+  calculateModelCost,
+} from './catalog.js';

package/src/providers/anthropic-messages.js

@@ -0,0 +1,192 @@
+import { createAgentEvent, createUsageSnapshot } from '../telemetry/index.js';
+import { calculateModelCost } from '../models/index.js';
+import { diagnosticFromError } from '../errors/index.js';
+
+function clean(value) { return value == null ? '' : String(value).trim(); }
+function integer(value) { const n = Number(value ?? 0); return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0; }
+function emit(emitFn, type, payload, runId) {
+  if (typeof emitFn === 'function') emitFn(createAgentEvent(type, payload, { runId }));
+}
+function signal(ms) {
+  return typeof AbortSignal?.timeout === 'function' && Number(ms) > 0 ? AbortSignal.timeout(Number(ms)) : undefined;
+}
+function toolsForAnthropic(tools = []) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description || '',
+    input_schema: tool.parameters || { type: 'object', properties: {} },
+  }));
+}
+function textFromContent(content = []) {
+  return content.filter((part) => part?.type === 'text').map((part) => String(part.text || '')).join('');
+}
+function callsFromContent(content = []) {
+  return content.filter((part) => part?.type === 'tool_use').map((part) => ({
+    call_id: part.id,
+    name: part.name,
+    arguments: JSON.stringify(part.input || {}),
+  }));
+}
+function usageParts(response = {}) {
+  const usage = response.usage || {};
+  return {
+    input_tokens: integer(usage.input_tokens),
+    cached_input_tokens: integer(usage.cache_read_input_tokens),
+    cache_write_tokens: integer(usage.cache_creation_input_tokens),
+    output_tokens: integer(usage.output_tokens),
+    reasoning_tokens: 0,
+  };
+}
+function cumulative(base, delta) {
+  return {
+    input_tokens: integer(base?.input_tokens) + delta.input_tokens,
+    output_tokens: integer(base?.output_tokens) + delta.output_tokens,
+    cached_input_tokens: integer(base?.cached_input_tokens) + delta.cached_input_tokens,
+    cache_write_tokens: integer(base?.cache_write_tokens) + delta.cache_write_tokens,
+    reasoning_tokens: integer(base?.reasoning_tokens),
+  };
+}
+
+export function createAnthropicMessagesAdapter(options = {}) {
+  const apiKey = clean(options.apiKey || process.env.ANTHROPIC_API_KEY);
+  const fetchImpl = options.fetchImpl || fetch;
+  const baseUrl = clean(options.baseUrl || 'https://api.anthropic.com/v1').replace(/\/$/, '');
+
+  async function request(body, params = {}) {
+    if (!apiKey) throw new Error('anthropic_api_key_required');
+    const response = await fetchImpl(baseUrl + '/messages', {
+      method: 'POST',
+      headers: {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: signal(params.timeoutMs || options.timeoutMs),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const error = new Error(data?.error?.message || data?.message || `Anthropic HTTP ${response.status}`);
+      error.status = response.status;
+      error.provider = 'anthropic';
+      throw error;
+    }
+    return data;
+  }
+
+  async function send(messages, params = {}) {
+    const record = params.modelRecord || options.modelRecord;
+    if (!record || record.provider !== 'anthropic') throw new Error('anthropic_model_record_required');
+    const emitFn = params.emit || options.emit;
+    const runId = params.runId;
+    const model = record.provider_model_id;
+    const body = {
+      model,
+      max_tokens: Number(params.maxOutputTokens) > 0 ? Number(params.maxOutputTokens) : 8192,
+      messages,
+      ...(clean(params.instructions) ? {
+        system: [{
+          type: 'text',
+          text: String(params.instructions),
+          cache_control: { type: 'ephemeral' },
+        }],
+      } : {}),
+      ...(params.tools?.length ? { tools: toolsForAnthropic(params.tools) } : {}),
+    };
+
+    emit(emitFn, 'model.started', {
+      provider: 'anthropic',
+      model,
+      reasoning_effort: params.reasoningEffort || 'auto',
+      requested_service_tier: 'default',
+    }, runId);
+
+    let response;
+    try {
+      response = await request(body, params);
+    } catch (error) {
+      const diagnostic = diagnosticFromError(error, { source: 'anthropic', kind: 'provider_error' });
+      emit(emitFn, 'error.observed', diagnostic, runId);
+      emit(emitFn, 'run.failed', { stage: 'model', provider: 'anthropic', model, error: diagnostic }, runId);
+      throw error;
+    }
+
+    const delta = usageParts(response);
+    const usageSnapshot = createUsageSnapshot({
+      current_context: { input_tokens: delta.input_tokens, window_tokens: Number(record.context_window) || 0 },
+      cumulative: cumulative(params.cumulativeUsage, delta),
+      estimate_kind: 'provider',
+    });
+    const cost = record.pricing ? calculateModelCost(record, delta, { serviceTier: 'default' }) : null;
+    if (cost) emit(emitFn, 'cost.snapshot', cost, runId);
+    emit(emitFn, 'usage.snapshot', usageSnapshot, runId);
+    emit(emitFn, 'model.completed', {
+      provider: 'anthropic',
+      model,
+      response_id: response.id || null,
+      status: response.stop_reason || 'completed',
+      requested_service_tier: 'default',
+      actual_service_tier: 'default',
+    }, runId);
+
+    const assistant = { role: 'assistant', content: response.content || [] };
+    const nextMessages = [...messages, assistant];
+    return Object.freeze({
+      provider: 'anthropic',
+      model,
+      response_id: response.id || null,
+      status: response.stop_reason || 'completed',
+      output_text: textFromContent(response.content),
+      tool_calls: Object.freeze(callsFromContent(response.content)),
+      usage_delta: Object.freeze(delta),
+      usage_snapshot: usageSnapshot,
+      cost,
+      provider_state: Object.freeze({ messages: nextMessages }),
+      requested_service_tier: 'default',
+      actual_service_tier: 'default',
+      raw: response,
+    });
+  }
+
+  async function create(params = {}) {
+    const prior = Array.isArray(params.providerState?.messages) ? params.providerState.messages : [];
+    const input = typeof params.input === 'string' ? params.input : JSON.stringify(params.input ?? '');
+    const messages = [...prior, { role: 'user', content: [{ type: 'text', text: input }] }];
+    return send(messages, params);
+  }
+
+  async function continueWithToolOutputs(params = {}) {
+    const prior = Array.isArray(params.providerState?.messages) ? params.providerState.messages : [];
+    if (!prior.length) throw new Error('anthropic_provider_state_required');
+    const content = (params.toolOutputs || []).map((row) => ({
+      type: 'tool_result',
+      tool_use_id: row.call_id || row.callId,
+      content: typeof row.output === 'string' ? row.output : JSON.stringify(row.output ?? null),
+    }));
+    if (!content.length) throw new Error('anthropic_tool_outputs_required');
+    return send([...prior, { role: 'user', content }], params);
+  }
+
+  async function compact(params = {}) {
+    const prior = Array.isArray(params.providerState?.messages) ? params.providerState.messages : [];
+    if (!prior.length) throw new Error('anthropic_provider_state_required');
+    const emitFn = params.emit || options.emit;
+    const startedAt = Date.now();
+    emit(emitFn, 'context.compaction.started', { provider: 'anthropic', model: params.model }, params.runId);
+    const summary = await send([...prior, {
+      role: 'user',
+      content: [{ type: 'text', text: 'Create a compact continuation summary of this conversation. Preserve the objective, decisions, changed files, active plan, unresolved failures, tool results that still matter, and constraints. Do not add new work.' }],
+    }], { ...params, tools: [], maxOutputTokens: Math.min(Number(params.maxOutputTokens) || 4096, 4096) });
+    const summaryText = String(summary.output_text || '').trim();
+    const compactState = Object.freeze({ messages: [{ role: 'user', content: [{ type: 'text', text: `Prior conversation continuation summary:\n${summaryText}` }] }] });
+    emit(emitFn, 'context.compaction.completed', {
+      provider: 'anthropic', model: params.model, summary_text: summaryText,
+      tokens_before: params.tokensBefore ?? null,
+      tokens_after: Math.ceil(summaryText.length / 4),
+      duration_ms: Date.now() - startedAt,
+    }, params.runId);
+    return Object.freeze({ provider: 'anthropic', output: Object.freeze([]), provider_state: compactState, summary_text: summaryText, usage: summary.usage_delta || null });
+  }
+
+  return Object.freeze({ provider: 'anthropic', create, continueWithToolOutputs, compact });
+}

package/src/providers/cloudflare-chat.js

@@ -0,0 +1,183 @@
+import { createAgentEvent, createUsageSnapshot } from '../telemetry/index.js';
+import { diagnosticFromError } from '../errors/index.js';
+
+function clean(value) { return value == null ? '' : String(value).trim(); }
+function integer(value) { const n = Number(value ?? 0); return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0; }
+function emit(emitFn, type, payload, runId) {
+  if (typeof emitFn === 'function') emitFn(createAgentEvent(type, payload, { runId }));
+}
+function toolsForChat(tools = []) {
+  return tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description || '',
+      parameters: tool.parameters || { type: 'object', properties: {} },
+    },
+  }));
+}
+function usageParts(response = {}) {
+  const usage = response.usage || {};
+  return {
+    input_tokens: integer(usage.prompt_tokens),
+    cached_input_tokens: integer(usage.prompt_tokens_details?.cached_tokens),
+    cache_write_tokens: 0,
+    output_tokens: integer(usage.completion_tokens),
+    reasoning_tokens: integer(usage.completion_tokens_details?.reasoning_tokens),
+  };
+}
+function cumulative(base, delta) {
+  return {
+    input_tokens: integer(base?.input_tokens) + delta.input_tokens,
+    output_tokens: integer(base?.output_tokens) + delta.output_tokens,
+    cached_input_tokens: integer(base?.cached_input_tokens) + delta.cached_input_tokens,
+    cache_write_tokens: integer(base?.cache_write_tokens),
+    reasoning_tokens: integer(base?.reasoning_tokens) + delta.reasoning_tokens,
+  };
+}
+function toolCalls(message = {}) {
+  return (message.tool_calls || []).map((call) => ({
+    call_id: call.id,
+    name: call.function?.name,
+    arguments: typeof call.function?.arguments === 'string'
+      ? call.function.arguments
+      : JSON.stringify(call.function?.arguments || {}),
+  }));
+}
+
+export function createCloudflareChatAdapter(options = {}) {
+  const credential = options.credential || {};
+  const apiToken = clean(credential.value || process.env.CLOUDFLARE_API_TOKEN);
+  const accountId = clean(credential.account_id || process.env.CLOUDFLARE_ACCOUNT_ID || process.env.ACCOUNT_ID);
+  const gatewayId = clean(options.gatewayId || process.env.CLOUDFLARE_AI_GATEWAY_ID || 'default');
+  const fetchImpl = options.fetchImpl || fetch;
+
+  async function request(body, params = {}) {
+    if (!apiToken) throw new Error('cloudflare_api_token_required');
+    if (!accountId) throw new Error('cloudflare_account_id_required');
+    const url = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/v1/chat/completions`;
+    const response = await fetchImpl(url, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${apiToken}`,
+        'content-type': 'application/json',
+        'cf-aig-gateway-id': gatewayId,
+      },
+      body: JSON.stringify(body),
+      signal: typeof AbortSignal?.timeout === 'function' && Number(params.timeoutMs || options.timeoutMs) > 0
+        ? AbortSignal.timeout(Number(params.timeoutMs || options.timeoutMs))
+        : undefined,
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const error = new Error(data?.error?.message || data?.errors?.[0]?.message || data?.message || `Cloudflare Workers AI HTTP ${response.status}`);
+      error.status = response.status;
+      error.provider = 'cloudflare';
+      throw error;
+    }
+    return data;
+  }
+
+  async function send(messages, params = {}) {
+    const record = params.modelRecord || options.modelRecord;
+    if (!record || record.provider !== 'cloudflare') throw new Error('cloudflare_model_record_required');
+    const emitFn = params.emit || options.emit;
+    const model = record.provider_model_id;
+    const tools = toolsForChat(params.tools || []);
+    emit(emitFn, 'model.started', { provider: 'cloudflare', model, reasoning_effort: 'auto', requested_service_tier: 'default' }, params.runId);
+
+    let response;
+    try {
+      response = await request({
+        model,
+        messages,
+        ...(tools.length ? { tools, tool_choice: 'auto' } : {}),
+        ...(Number(params.maxOutputTokens) > 0 ? { max_tokens: Number(params.maxOutputTokens) } : {}),
+      }, params);
+    } catch (error) {
+      const diagnostic = diagnosticFromError(error, { source: 'cloudflare', kind: 'provider_error' });
+      emit(emitFn, 'error.observed', diagnostic, params.runId);
+      emit(emitFn, 'run.failed', { stage: 'model', provider: 'cloudflare', model, error: diagnostic }, params.runId);
+      throw error;
+    }
+
+    const message = response?.choices?.[0]?.message || { role: 'assistant', content: '' };
+    const delta = usageParts(response);
+    const usageSnapshot = createUsageSnapshot({
+      current_context: { input_tokens: delta.input_tokens, window_tokens: Number(record.context_window) || 0 },
+      cumulative: cumulative(params.cumulativeUsage, delta),
+      estimate_kind: 'provider',
+    });
+    emit(emitFn, 'usage.snapshot', usageSnapshot, params.runId);
+    emit(emitFn, 'model.completed', {
+      provider: 'cloudflare', model, response_id: response.id || null,
+      status: response?.choices?.[0]?.finish_reason || 'completed',
+      requested_service_tier: 'default', actual_service_tier: 'default',
+    }, params.runId);
+
+    return Object.freeze({
+      provider: 'cloudflare',
+      model,
+      response_id: response.id || null,
+      status: response?.choices?.[0]?.finish_reason || 'completed',
+      output_text: typeof message.content === 'string' ? message.content : '',
+      tool_calls: Object.freeze(toolCalls(message)),
+      usage_delta: Object.freeze(delta),
+      usage_snapshot: usageSnapshot,
+      cost: null,
+      provider_state: Object.freeze({ messages: [...messages, message] }),
+      requested_service_tier: 'default',
+      actual_service_tier: 'default',
+      raw: response,
+    });
+  }
+
+  async function create(params = {}) {
+    const prior = Array.isArray(params.providerState?.messages) ? params.providerState.messages : [];
+    const messages = [...prior];
+    if (clean(params.instructions) && !messages.some((row) => row.role === 'system')) {
+      messages.unshift({ role: 'system', content: String(params.instructions) });
+    }
+    messages.push({ role: 'user', content: typeof params.input === 'string' ? params.input : JSON.stringify(params.input ?? '') });
+    return send(messages, params);
+  }
+
+  async function continueWithToolOutputs(params = {}) {
+    const prior = Array.isArray(params.providerState?.messages) ? params.providerState.messages : [];
+    if (!prior.length) throw new Error('cloudflare_provider_state_required');
+    const toolMessages = (params.toolOutputs || []).map((row) => ({
+      role: 'tool',
+      tool_call_id: row.call_id || row.callId,
+      content: typeof row.output === 'string' ? row.output : JSON.stringify(row.output ?? null),
+    }));
+    if (!toolMessages.length) throw new Error('cloudflare_tool_outputs_required');
+    return send([...prior, ...toolMessages], params);
+  }
+
+  async function compact(params = {}) {
+    const prior = Array.isArray(params.providerState?.messages) ? params.providerState.messages : [];
+    if (!prior.length) throw new Error('cloudflare_provider_state_required');
+    const emitFn = params.emit || options.emit;
+    const startedAt = Date.now();
+    emit(emitFn, 'context.compaction.started', { provider: 'cloudflare', model: params.model }, params.runId);
+    const summary = await send([...prior, {
+      role: 'user',
+      content: 'Create a compact continuation summary of this conversation. Preserve the objective, decisions, changed files, active plan, unresolved failures, tool results that still matter, and constraints. Do not add new work.',
+    }], { ...params, tools: [], maxOutputTokens: Math.min(Number(params.maxOutputTokens) || 4096, 4096) });
+    const summaryText = String(summary.output_text || '').trim();
+    const compactState = Object.freeze({ messages: [
+      ...(params.instructions ? [{ role: 'system', content: String(params.instructions) }] : []),
+      { role: 'user', content: 'Prior conversation continuation summary:' },
+      { role: 'assistant', content: summaryText },
+    ] });
+    emit(emitFn, 'context.compaction.completed', {
+      provider: 'cloudflare', model: params.model, summary_text: summaryText,
+      tokens_before: params.tokensBefore ?? null,
+      tokens_after: Math.ceil(summaryText.length / 4),
+      duration_ms: Date.now() - startedAt,
+    }, params.runId);
+    return Object.freeze({ provider: 'cloudflare', output: Object.freeze([]), provider_state: compactState, summary_text: summaryText, usage: summary.usage_delta || null, cost: null });
+  }
+
+  return Object.freeze({ provider: 'cloudflare', create, continueWithToolOutputs, compact });
+}