@inneranimalmedia/agentsam-sdk 2.6.0 → 2.6.1

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 });
+}

package/src/providers/factory.js

@@ -0,0 +1,69 @@
+import { createOpenAIResponsesAdapter } from './openai-responses.js';
+import { createAnthropicMessagesAdapter } from './anthropic-messages.js';
+import { createGeminiGenerateContentAdapter } from './gemini-generate-content.js';
+import { createOllamaChatAdapter } from './ollama-chat.js';
+import { createCloudflareChatAdapter } from './cloudflare-chat.js';
+
+export function createProviderAdapter(options = {}) {
+  const record = options.modelRecord;
+  if (!record?.provider) throw new TypeError('modelRecord.provider is required');
+  const provider = String(record.provider).toLowerCase();
+
+  if (provider === 'openai') {
+    return createOpenAIResponsesAdapter({
+      apiKey: options.credential?.value,
+      modelRecord: record,
+      fetchImpl: options.fetchImpl,
+      emit: options.emit,
+    });
+  }
+
+  if (provider === 'grok' || provider === 'xai') {
+    return createOpenAIResponsesAdapter({
+      providerId: 'grok',
+      baseUrl: 'https://api.x.ai/v1',
+      apiKey: options.credential?.value,
+      modelRecord: record,
+      fetchImpl: options.fetchImpl,
+      emit: options.emit,
+    });
+  }
+
+  if (provider === 'anthropic') {
+    return createAnthropicMessagesAdapter({
+      apiKey: options.credential?.value,
+      modelRecord: record,
+      fetchImpl: options.fetchImpl,
+      emit: options.emit,
+    });
+  }
+
+  if (provider === 'gemini') {
+    return createGeminiGenerateContentAdapter({
+      apiKey: options.credential?.value,
+      modelRecord: record,
+      fetchImpl: options.fetchImpl,
+      emit: options.emit,
+    });
+  }
+
+  if (provider === 'cloudflare') {
+    return createCloudflareChatAdapter({
+      credential: options.credential,
+      modelRecord: record,
+      fetchImpl: options.fetchImpl,
+      emit: options.emit,
+    });
+  }
+
+  if (provider === 'ollama') {
+    return createOllamaChatAdapter({
+      endpoint: options.endpoint,
+      modelRecord: record,
+      fetchImpl: options.fetchImpl,
+      emit: options.emit,
+    });
+  }
+
+  throw new Error(`interactive_provider_adapter_unavailable:${provider}`);
+}

package/src/providers/gemini-generate-content.js

@@ -0,0 +1,208 @@
+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 toolDeclarations(tools = []) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description || '',
+    parameters: tool.parameters || { type: 'object', properties: {} },
+  }));
+}
+function usageParts(response = {}) {
+  const usage = response.usageMetadata || {};
+  return {
+    input_tokens: integer(usage.promptTokenCount),
+    cached_input_tokens: integer(usage.cachedContentTokenCount),
+    cache_write_tokens: 0,
+    output_tokens: integer(usage.candidatesTokenCount),
+    reasoning_tokens: integer(usage.thoughtsTokenCount),
+  };
+}
+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 candidateContent(response = {}) {
+  return response?.candidates?.[0]?.content || { role: 'model', parts: [] };
+}
+function outputText(content = {}) {
+  return (content.parts || []).filter((part) => typeof part?.text === 'string').map((part) => part.text).join('');
+}
+function toolCalls(content = {}) {
+  const calls = [];
+  let index = 0;
+  for (const part of content.parts || []) {
+    if (!part?.functionCall?.name) continue;
+    index += 1;
+    calls.push({
+      call_id: `gcall_${index}_${clean(part.functionCall.name).replace(/[^A-Za-z0-9_-]/g, '_')}`,
+      name: part.functionCall.name,
+      arguments: JSON.stringify(part.functionCall.args || {}),
+    });
+  }
+  return calls;
+}
+
+export function createGeminiGenerateContentAdapter(options = {}) {
+  const apiKey = clean(options.apiKey || process.env.GEMINI_API_KEY);
+  const fetchImpl = options.fetchImpl || fetch;
+  const baseUrl = clean(options.baseUrl || 'https://generativelanguage.googleapis.com/v1beta').replace(/\/$/, '');
+
+  async function request(model, body, params = {}) {
+    if (!apiKey) throw new Error('gemini_api_key_required');
+    const url = `${baseUrl}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+    const response = await fetchImpl(url, {
+      method: 'POST',
+      headers: { '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 || `Gemini HTTP ${response.status}`);
+      error.status = response.status;
+      error.provider = 'gemini';
+      throw error;
+    }
+    return data;
+  }
+
+  async function send(contents, params = {}) {
+    const record = params.modelRecord || options.modelRecord;
+    if (!record || record.provider !== 'gemini') throw new Error('gemini_model_record_required');
+    const emitFn = params.emit || options.emit;
+    const runId = params.runId;
+    const model = record.provider_model_id;
+    const declarations = toolDeclarations(params.tools || []);
+    const body = {
+      contents,
+      ...(clean(params.instructions) ? { systemInstruction: { parts: [{ text: String(params.instructions) }] } } : {}),
+      ...(declarations.length ? { tools: [{ functionDeclarations: declarations }] } : {}),
+      generationConfig: {
+        ...(Number(params.maxOutputTokens) > 0 ? { maxOutputTokens: Number(params.maxOutputTokens) } : {}),
+      },
+    };
+
+    emit(emitFn, 'model.started', {
+      provider: 'gemini',
+      model,
+      reasoning_effort: params.reasoningEffort || 'auto',
+      requested_service_tier: 'default',
+    }, runId);
+
+    let response;
+    try {
+      response = await request(model, body, params);
+    } catch (error) {
+      const diagnostic = diagnosticFromError(error, { source: 'gemini', kind: 'provider_error' });
+      emit(emitFn, 'error.observed', diagnostic, runId);
+      emit(emitFn, 'run.failed', { stage: 'model', provider: 'gemini', model, error: diagnostic }, runId);
+      throw error;
+    }
+
+    const content = candidateContent(response);
+    const calls = toolCalls(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',
+    });
+    const cost = record.pricing ? calculateModelCost(record, delta, { serviceTier: 'default' }) : null;
+    emit(emitFn, 'usage.snapshot', usageSnapshot, runId);
+    if (cost) emit(emitFn, 'cost.snapshot', cost, runId);
+    emit(emitFn, 'model.completed', {
+      provider: 'gemini',
+      model,
+      response_id: response.responseId || null,
+      status: response?.candidates?.[0]?.finishReason || 'completed',
+      requested_service_tier: 'default',
+      actual_service_tier: 'default',
+    }, runId);
+
+    return Object.freeze({
+      provider: 'gemini',
+      model,
+      response_id: response.responseId || null,
+      status: response?.candidates?.[0]?.finishReason || 'completed',
+      output_text: outputText(content),
+      tool_calls: Object.freeze(calls),
+      usage_delta: Object.freeze(delta),
+      usage_snapshot: usageSnapshot,
+      cost,
+      provider_state: Object.freeze({
+        contents: [...contents, content],
+        pending_tools: calls.map((call) => ({ call_id: call.call_id, name: call.name })),
+      }),
+      requested_service_tier: 'default',
+      actual_service_tier: 'default',
+      raw: response,
+    });
+  }
+
+  async function create(params = {}) {
+    const prior = Array.isArray(params.providerState?.contents) ? params.providerState.contents : [];
+    const input = typeof params.input === 'string' ? params.input : JSON.stringify(params.input ?? '');
+    return send([...prior, { role: 'user', parts: [{ text: input }] }], params);
+  }
+
+  async function continueWithToolOutputs(params = {}) {
+    const prior = Array.isArray(params.providerState?.contents) ? params.providerState.contents : [];
+    const pending = Array.isArray(params.providerState?.pending_tools) ? params.providerState.pending_tools : [];
+    if (!prior.length) throw new Error('gemini_provider_state_required');
+    const byId = new Map(pending.map((row) => [row.call_id, row.name]));
+    const parts = (params.toolOutputs || []).map((row) => {
+      const callId = row.call_id || row.callId;
+      const name = byId.get(callId);
+      if (!name) throw new Error(`gemini_tool_call_unknown:${callId}`);
+      let responseValue = row.output;
+      if (typeof responseValue === 'string') {
+        try { responseValue = JSON.parse(responseValue); }
+        catch { responseValue = { output: responseValue }; }
+      }
+      return { functionResponse: { name, response: responseValue ?? {} } };
+    });
+    if (!parts.length) throw new Error('gemini_tool_outputs_required');
+    return send([...prior, { role: 'user', parts }], params);
+  }
+
+  async function compact(params = {}) {
+    const prior = Array.isArray(params.providerState?.contents) ? params.providerState.contents : [];
+    if (!prior.length) throw new Error('gemini_provider_state_required');
+    const emitFn = params.emit || options.emit;
+    const startedAt = Date.now();
+    emit(emitFn, 'context.compaction.started', { provider: 'gemini', model: params.model }, params.runId);
+    const summary = await send([...prior, {
+      role: 'user',
+      parts: [{ 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({ contents: [
+      { role: 'user', parts: [{ text: 'Prior conversation continuation summary:' }] },
+      { role: 'model', parts: [{ text: summaryText }] },
+    ], pending_tools: [] });
+    emit(emitFn, 'context.compaction.completed', {
+      provider: 'gemini', 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: 'gemini', output: Object.freeze([]), provider_state: compactState, summary_text: summaryText, usage: summary.usage_delta || null });
+  }
+
+  return Object.freeze({ provider: 'gemini', create, continueWithToolOutputs, compact });
+}

package/src/providers/index.js

@@ -3,3 +3,8 @@ export {
   extractOpenAIOutputText,
   extractOpenAIFunctionCalls,
 } from './openai-responses.js';
+export { createAnthropicMessagesAdapter } from './anthropic-messages.js';
+export { createGeminiGenerateContentAdapter } from './gemini-generate-content.js';
+export { createOllamaChatAdapter } from './ollama-chat.js';
+export { createCloudflareChatAdapter } from './cloudflare-chat.js';
+export { createProviderAdapter } from './factory.js';