@inneranimalmedia/agentsam-sdk 2.6.0 → 2.6.1

package/src/providers/ollama-chat.js

@@ -0,0 +1,148 @@
+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 toolsForOllama(tools = []) {
+  return tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description || '',
+      parameters: tool.parameters || { type: 'object', properties: {} },
+    },
+  }));
+}
+function callsFromMessage(message = {}) {
+  return (message.tool_calls || []).map((call, index) => ({
+    call_id: call.id || `ocall_${index + 1}_${clean(call.function?.name)}`,
+    name: call.function?.name,
+    arguments: typeof call.function?.arguments === 'string'
+      ? call.function.arguments
+      : JSON.stringify(call.function?.arguments || {}),
+  }));
+}
+
+export function createOllamaChatAdapter(options = {}) {
+  const fetchImpl = options.fetchImpl || fetch;
+  const endpoint = clean(options.endpoint || process.env.OLLAMA_BASE_URL || 'http://127.0.0.1:11434').replace(/\/$/, '');
+
+  async function send(messages, params = {}) {
+    const record = params.modelRecord || options.modelRecord;
+    if (!record || record.provider !== 'ollama') throw new Error('ollama_model_record_required');
+    const emitFn = params.emit || options.emit;
+    const model = record.provider_model_id;
+    emit(emitFn, 'model.started', { provider: 'ollama', model, reasoning_effort: 'auto', requested_service_tier: 'local' }, params.runId);
+
+    let response;
+    try {
+      response = await fetchImpl(endpoint + '/api/chat', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          stream: false,
+          messages,
+          ...(params.tools?.length ? { tools: toolsForOllama(params.tools) } : {}),
+          ...(Number(params.maxOutputTokens) > 0 ? { options: { num_predict: Number(params.maxOutputTokens) } } : {}),
+        }),
+      });
+      if (!response.ok) throw new Error(`Ollama HTTP ${response.status}`);
+    } catch (error) {
+      const diagnostic = diagnosticFromError(error, { source: 'ollama', kind: 'provider_error' });
+      emit(emitFn, 'error.observed', diagnostic, params.runId);
+      emit(emitFn, 'run.failed', { stage: 'model', provider: 'ollama', model, error: diagnostic }, params.runId);
+      throw error;
+    }
+
+    const data = await response.json();
+    const message = data.message || { role: 'assistant', content: '' };
+    const delta = {
+      input_tokens: integer(data.prompt_eval_count),
+      output_tokens: integer(data.eval_count),
+      cached_input_tokens: 0,
+      cache_write_tokens: 0,
+      reasoning_tokens: 0,
+    };
+    const base = params.cumulativeUsage || {};
+    const usageSnapshot = createUsageSnapshot({
+      current_context: { input_tokens: delta.input_tokens, window_tokens: Number(record.context_window) || 0 },
+      cumulative: {
+        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),
+        cache_write_tokens: integer(base.cache_write_tokens),
+        reasoning_tokens: integer(base.reasoning_tokens),
+      },
+      estimate_kind: 'provider',
+    });
+    emit(emitFn, 'usage.snapshot', usageSnapshot, params.runId);
+    emit(emitFn, 'model.completed', { provider: 'ollama', model, status: data.done ? 'completed' : 'partial', requested_service_tier: 'local', actual_service_tier: 'local' }, params.runId);
+
+    return Object.freeze({
+      provider: 'ollama',
+      model,
+      response_id: null,
+      status: data.done ? 'completed' : 'partial',
+      output_text: String(message.content || ''),
+      tool_calls: Object.freeze(callsFromMessage(message)),
+      usage_delta: Object.freeze(delta),
+      usage_snapshot: usageSnapshot,
+      cost: null,
+      provider_state: Object.freeze({ messages: [...messages, message] }),
+      requested_service_tier: 'local',
+      actual_service_tier: 'local',
+      raw: data,
+    });
+  }
+
+  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.push({ 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('ollama_provider_state_required');
+    const toolMessages = (params.toolOutputs || []).map((row) => ({
+      role: 'tool',
+      content: typeof row.output === 'string' ? row.output : JSON.stringify(row.output ?? null),
+    }));
+    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('ollama_provider_state_required');
+    const emitFn = params.emit || options.emit;
+    const startedAt = Date.now();
+    emit(emitFn, 'context.compaction.started', { provider: 'ollama', 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 messages = [];
+    if (params.instructions) messages.push({ role: 'system', content: String(params.instructions) });
+    messages.push({ role: 'user', content: 'Prior conversation continuation summary:' });
+    messages.push({ role: 'assistant', content: summaryText });
+    const compactState = Object.freeze({ messages });
+    emit(emitFn, 'context.compaction.completed', {
+      provider: 'ollama', 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: 'ollama', output: Object.freeze([]), provider_state: compactState, summary_text: summaryText, usage: summary.usage_delta || null });
+  }
+
+  return Object.freeze({ provider: 'ollama', create, continueWithToolOutputs, compact });
+}

package/src/providers/openai-responses.js

@@ -5,8 +5,14 @@ import { createOpenAIHttpError, diagnosticFromError } from '../errors/index.js';
 const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
 
 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 integer(value) {
+  const n = Number(value ?? 0);
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0;
+}
+function optionalSignal(timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return undefined;
+  return typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout(Math.floor(timeoutMs)) : undefined;
+}
 function normalizeServiceTier(value, requested = 'default') {
   const tier = clean(value).toLowerCase();
   if (tier === 'priority') return 'fast';
@@ -14,6 +20,38 @@ function normalizeServiceTier(value, requested = 'default') {
   return tier;
 }
 
+function historyItems(input) {
+  if (input == null) return [];
+  if (Array.isArray(input)) return structuredClone(input);
+  if (typeof input === 'string') return [{ role: 'user', content: input }];
+  return [structuredClone(input)];
+}
+
+function xaiCompactionHistory(params = {}, response = {}) {
+  const prior = Array.isArray(params.providerState?.compaction_input)
+    ? structuredClone(params.providerState.compaction_input)
+    : [];
+  const current = historyItems(params.input);
+  const currentAlreadyStartsWithPrior = prior.length > 0
+    && current.length >= prior.length
+    && JSON.stringify(current.slice(0, prior.length)) === JSON.stringify(prior);
+  if (prior.length) {
+    return [
+      ...(currentAlreadyStartsWithPrior ? [] : prior),
+      ...current,
+      ...structuredClone(response.output || []),
+    ];
+  }
+  const prefix = clean(params.instructions)
+    ? [{ role: 'system', content: String(params.instructions) }]
+    : [];
+  return [
+    ...prefix,
+    ...current,
+    ...structuredClone(response.output || []),
+  ];
+}
+
 export function extractOpenAIOutputText(response = {}) {
   if (typeof response.output_text === 'string') return response.output_text;
   const chunks = [];
@@ -27,13 +65,15 @@ export function extractOpenAIOutputText(response = {}) {
 }
 
 export function extractOpenAIFunctionCalls(response = {}) {
-  return (response.output || []).filter((item) => item?.type === 'function_call').map((item) => Object.freeze({
-    id: item.id || null,
-    call_id: item.call_id,
-    name: item.name,
-    arguments: item.arguments || '{}',
-    status: item.status || null,
-  }));
+  return (response.output || [])
+    .filter((item) => item?.type === 'function_call')
+    .map((item) => Object.freeze({
+      id: item.id || null,
+      call_id: item.call_id,
+      name: item.name,
+      arguments: item.arguments || '{}',
+      status: item.status || null,
+    }));
 }
 
 function usageParts(response = {}) {
@@ -47,20 +87,12 @@ function usageParts(response = {}) {
   };
 }
 
-function errorMessage(body, status) {
-  return body?.error?.message || body?.message || `OpenAI Responses API returned HTTP ${status}`;
-}
-
-function optionalSignal(timeoutMs) {
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return undefined;
-  if (typeof AbortSignal?.timeout !== 'function') return undefined;
-  return AbortSignal.timeout(Math.floor(timeoutMs));
-}
-
 function normalizeTools(tools = []) {
   if (!Array.isArray(tools)) throw new TypeError('tools must be an array');
   return tools.map((tool) => {
-    if (tool?.type !== 'function' || !clean(tool.name)) throw new TypeError('OpenAI adapter tools must be Responses function tool descriptors');
+    if (tool?.type !== 'function' || !clean(tool.name)) {
+      throw new TypeError('OpenAI-compatible adapter tools must be Responses function tool descriptors');
+    }
     return {
       type: 'function',
       name: clean(tool.name),
@@ -72,11 +104,23 @@ function normalizeTools(tools = []) {
   });
 }
 
-function assertRuntimeConfig(model, reasoningEffort, serviceTier) {
-  const record = getModelRecord(model);
-  if (!record || record.provider !== 'openai') throw new RangeError(`unsupported OpenAI model catalog entry: ${model}`);
-  if (!record.reasoning_efforts.includes(reasoningEffort)) throw new RangeError(`unsupported reasoning effort for ${record.provider_model_id}: ${reasoningEffort}`);
-  if (!record.service_tiers.includes(serviceTier)) throw new RangeError(`unsupported service tier for ${record.provider_model_id}: ${serviceTier}`);
+function assertRuntimeConfig(model, reasoningEffort, serviceTier, explicitRecord, expectedProvider) {
+  const record = explicitRecord || getModelRecord(model);
+  if (!record || record.provider !== expectedProvider) {
+    throw new RangeError(`unsupported ${expectedProvider} model record: ${model}`);
+  }
+  const reasoning = Array.isArray(record.reasoning_efforts) && record.reasoning_efforts.length
+    ? record.reasoning_efforts
+    : ['auto'];
+  const tiers = Array.isArray(record.service_tiers) && record.service_tiers.length
+    ? record.service_tiers
+    : ['default'];
+  if (reasoningEffort !== 'auto' && !reasoning.includes(reasoningEffort)) {
+    throw new RangeError(`unsupported reasoning effort for ${record.provider_model_id}: ${reasoningEffort}`);
+  }
+  if (!tiers.includes(serviceTier)) {
+    throw new RangeError(`unsupported service tier for ${record.provider_model_id}: ${serviceTier}`);
+  }
   return record;
 }
 
@@ -85,21 +129,38 @@ function emitEvent(emit, type, payload, meta = {}) {
   emit(createAgentEvent(type, payload, meta));
 }
 
+function genericHttpError(providerId, response, parsed, rawText) {
+  const error = new Error(
+    clean(parsed?.error?.message || parsed?.message) ||
+    `${providerId} Responses API returned HTTP ${response.status}`,
+  );
+  error.status = response.status;
+  error.provider = providerId;
+  error.body = parsed;
+  error.rawText = rawText;
+  return error;
+}
+
 export function createOpenAIResponsesAdapter(options = {}) {
-  const apiKey = clean(options.apiKey || process.env.OPENAI_API_KEY);
+  const providerId = clean(options.providerId || 'openai').toLowerCase();
+  const apiKey = clean(
+    options.apiKey ||
+    (providerId === 'openai' ? process.env.OPENAI_API_KEY : providerId === 'grok' ? process.env.XAI_API_KEY : ''),
+  );
   const baseUrl = clean(options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
   const fetchImpl = options.fetchImpl || fetch;
   const defaultEmit = options.emit;
   const timeoutMs = options.timeoutMs;
 
   async function request(pathname, body, runtime = {}) {
-    if (!apiKey) throw new Error('OPENAI_API_KEY is required for OpenAI Responses execution');
+    if (!apiKey) throw new Error(`${providerId}_api_key_required`);
     const response = await fetchImpl(`${baseUrl}${pathname}`, {
       method: 'POST',
       headers: { authorization: `Bearer ${apiKey}`, 'content-type': 'application/json' },
       body: JSON.stringify(body),
       signal: optionalSignal(runtime.timeoutMs ?? timeoutMs),
     });
+
     let rawText = '';
     let parsed = null;
     if (typeof response.text === 'function') {
@@ -113,49 +174,67 @@ export function createOpenAIResponsesAdapter(options = {}) {
         rawText = JSON.stringify(parsed ?? null);
       } catch {
         parsed = null;
-        rawText = '';
       }
     }
+
     if (!response.ok) {
-      throw createOpenAIHttpError({
-        status: response.status,
-        body: parsed,
-        rawText,
-        headers: response.headers,
-        requestedServiceTier: body?.service_tier,
-      });
+      if (providerId === 'openai') {
+        throw createOpenAIHttpError({
+          status: response.status,
+          body: parsed,
+          rawText,
+          headers: response.headers,
+          requestedServiceTier: body?.service_tier,
+        });
+      }
+      throw genericHttpError(providerId, response, parsed, rawText);
     }
+
     return Object.freeze({
       data: parsed ?? {},
       http: Object.freeze({
         status: response.status,
-        request_id: clean(response.headers?.get?.('x-request-id') || response.headers?.get?.('openai-request-id')) || null,
+        request_id: clean(
+          response.headers?.get?.('x-request-id') ||
+          response.headers?.get?.('openai-request-id'),
+        ) || null,
         ray_id: clean(response.headers?.get?.('cf-ray')) || null,
       }),
     });
   }
 
   async function create(params = {}) {
-    const modelRecord = getModelRecord(params.model);
+    const suppliedRecord = params.modelRecord || options.modelRecord || null;
+    const modelRecord = suppliedRecord || getModelRecord(params.model);
     const model = modelRecord?.provider_model_id || clean(params.model);
-    const reasoningEffort = clean(params.reasoningEffort || params.reasoning_effort || 'low');
+    const reasoningEffort = clean(params.reasoningEffort || params.reasoning_effort || 'auto');
     const serviceTier = clean(params.serviceTier || params.service_tier || 'default');
-    const record = assertRuntimeConfig(model, reasoningEffort, serviceTier);
+    const record = assertRuntimeConfig(model, reasoningEffort, serviceTier, modelRecord, providerId);
     const emit = params.emit || defaultEmit;
     const meta = { runId: params.runId, sequence: params.sequence };
     const tools = normalizeTools(params.tools || []);
+    const previousResponseId = clean(params.previousResponseId || params.providerState?.previous_response_id);
+    const requestInput = providerId === 'grok'
+      && !previousResponseId
+      && Array.isArray(params.providerState?.compaction_input)
+      && params.providerState.compaction_input.length
+      ? [...structuredClone(params.providerState.compaction_input), ...historyItems(params.input)]
+      : params.input ?? '';
+
     const body = {
       model,
-      input: params.input ?? '',
-      reasoning: { effort: reasoningEffort },
-      service_tier: serviceTier,
+      input: requestInput,
+      ...(reasoningEffort !== 'auto' ? { reasoning: { effort: reasoningEffort } } : {}),
+      ...(providerId === 'openai' || serviceTier !== 'default' ? { service_tier: serviceTier } : {}),
       store: params.store !== false,
       truncation: 'disabled',
       parallel_tool_calls: params.parallelToolCalls !== false,
       ...(clean(params.instructions) ? { instructions: String(params.instructions) } : {}),
       ...(tools.length ? { tools } : {}),
-      ...(clean(params.previousResponseId) ? { previous_response_id: clean(params.previousResponseId) } : {}),
-      ...(Number.isInteger(params.maxOutputTokens) && params.maxOutputTokens > 0 ? { max_output_tokens: params.maxOutputTokens } : {}),
+      ...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
+      ...(Number.isInteger(params.maxOutputTokens) && params.maxOutputTokens > 0
+        ? { max_output_tokens: params.maxOutputTokens }
+        : {}),
       ...(clean(params.promptCacheKey) ? { prompt_cache_key: clean(params.promptCacheKey) } : {}),
       ...(params.promptCacheOptions ? { prompt_cache_options: params.promptCacheOptions } : {}),
       ...(params.metadata ? { metadata: params.metadata } : {}),
@@ -163,7 +242,10 @@ export function createOpenAIResponsesAdapter(options = {}) {
     };
 
     emitEvent(emit, 'model.started', {
-      provider: 'openai', model, reasoning_effort: reasoningEffort, requested_service_tier: serviceTier,
+      provider: providerId,
+      model,
+      reasoning_effort: reasoningEffort,
+      requested_service_tier: serviceTier,
     }, meta);
 
     let response;
@@ -173,17 +255,22 @@ export function createOpenAIResponsesAdapter(options = {}) {
       response = result.data;
       http = result.http;
     } catch (error) {
-      const diagnostic = diagnosticFromError(error, { source: 'openai', kind: 'provider_error' });
+      const diagnostic = diagnosticFromError(error, { source: providerId, kind: 'provider_error' });
       emitEvent(emit, 'error.observed', diagnostic, meta);
-      emitEvent(emit, 'run.failed', { stage: 'model', provider: 'openai', model, error: diagnostic }, meta);
+      emitEvent(emit, 'run.failed', { stage: 'model', provider: providerId, model, error: diagnostic }, meta);
       throw error;
     }
 
     const delta = usageParts(response);
     const actualServiceTier = normalizeServiceTier(response.service_tier, serviceTier);
-    const cost = calculateModelCost(record, { ...delta, estimate_kind: 'provider' }, { serviceTier: actualServiceTier });
+    const cost = record.pricing
+      ? calculateModelCost(record, { ...delta, estimate_kind: 'provider' }, { serviceTier: actualServiceTier })
+      : null;
     const usageSnapshot = createUsageSnapshot({
-      current_context: { input_tokens: delta.input_tokens, window_tokens: record.context_window },
+      current_context: {
+        input_tokens: delta.input_tokens,
+        window_tokens: Number(record.context_window) || 0,
+      },
       cumulative: params.cumulativeUsage ? {
         input_tokens: integer(params.cumulativeUsage.input_tokens) + delta.input_tokens,
         output_tokens: integer(params.cumulativeUsage.output_tokens) + delta.output_tokens,
@@ -195,18 +282,30 @@ export function createOpenAIResponsesAdapter(options = {}) {
     });
 
     emitEvent(emit, 'usage.snapshot', usageSnapshot, meta);
-    emitEvent(emit, 'cost.snapshot', cost, meta);
+    if (cost) emitEvent(emit, 'cost.snapshot', cost, meta);
     emitEvent(emit, 'model.completed', {
-      provider: 'openai', model, response_id: response.id, status: response.status,
-      request_id: http?.request_id || null, ray_id: http?.ray_id || null,
-      requested_service_tier: serviceTier, actual_service_tier: actualServiceTier,
+      provider: providerId,
+      model,
+      response_id: response.id,
+      status: response.status,
+      request_id: http?.request_id || null,
+      ray_id: http?.ray_id || null,
+      requested_service_tier: serviceTier,
+      actual_service_tier: actualServiceTier,
     }, meta);
 
+    const providerState = providerId === 'grok'
+      ? Object.freeze({
+          previous_response_id: response.id || null,
+          compaction_input: xaiCompactionHistory(params, response),
+        })
+      : Object.freeze({ previous_response_id: response.id || null });
+
     return Object.freeze({
-      provider: 'openai',
+      provider: providerId,
       model,
-      response_id: response.id,
-      status: response.status,
+      response_id: response.id || null,
+      status: response.status || 'completed',
       request_id: http?.request_id || null,
       ray_id: http?.ray_id || null,
       output_text: extractOpenAIOutputText(response),
@@ -214,6 +313,7 @@ export function createOpenAIResponsesAdapter(options = {}) {
       usage_delta: Object.freeze(delta),
       usage_snapshot: usageSnapshot,
       cost,
+      provider_state: providerState,
       requested_service_tier: serviceTier,
       actual_service_tier: actualServiceTier,
       raw: response,
@@ -221,7 +321,7 @@ export function createOpenAIResponsesAdapter(options = {}) {
   }
 
   async function continueWithToolOutputs(params = {}) {
-    const previousResponseId = clean(params.previousResponseId);
+    const previousResponseId = clean(params.previousResponseId || params.providerState?.previous_response_id);
     if (!previousResponseId) throw new TypeError('previousResponseId is required');
     const outputs = (params.toolOutputs || []).map((row) => {
       const callId = clean(row.call_id || row.callId);
@@ -234,20 +334,43 @@ export function createOpenAIResponsesAdapter(options = {}) {
   }
 
   async function compact(params = {}) {
-    const modelRecord = getModelRecord(params.model);
+    if (providerId !== 'openai' && providerId !== 'grok') throw new Error(`native_compaction_unavailable:${providerId}`);
+    const modelRecord = params.modelRecord || options.modelRecord || getModelRecord(params.model);
     const model = modelRecord?.provider_model_id || clean(params.model);
-    if (!modelRecord || modelRecord.provider !== 'openai') throw new RangeError(`unsupported OpenAI model catalog entry: ${params.model}`);
+    if (!modelRecord || modelRecord.provider !== providerId) {
+      throw new RangeError(`unsupported ${providerId} model record: ${params.model}`);
+    }
+
     const emit = params.emit || defaultEmit;
     const meta = { runId: params.runId, sequence: params.sequence };
-    const body = {
+    const previousResponseId = clean(params.previousResponseId || params.providerState?.previous_response_id);
+    const xaiHistory = Array.isArray(params.providerState?.compaction_input)
+      ? structuredClone(params.providerState.compaction_input)
+      : [];
+    if (providerId === 'grok' && !xaiHistory.length) {
+      throw new Error('xai_compaction_history_unavailable');
+    }
+    const body = providerId === 'grok'
+      ? {
+          model,
+          input: xaiHistory,
+        }
+      : {
+          model,
+          ...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
+          ...(params.input != null ? { input: params.input } : {}),
+          ...(clean(params.instructions) ? { instructions: String(params.instructions) } : {}),
+          ...(clean(params.promptCacheKey) ? { prompt_cache_key: clean(params.promptCacheKey) } : {}),
+          ...(params.promptCacheOptions ? { prompt_cache_options: params.promptCacheOptions } : {}),
+        };
+
+    const compactStartedAt = Date.now();
+    emitEvent(emit, 'context.compaction.started', {
+      provider: providerId,
       model,
-      ...(clean(params.previousResponseId) ? { previous_response_id: clean(params.previousResponseId) } : {}),
-      ...(params.input != null ? { input: params.input } : {}),
-      ...(clean(params.instructions) ? { instructions: String(params.instructions) } : {}),
-      ...(clean(params.promptCacheKey) ? { prompt_cache_key: clean(params.promptCacheKey) } : {}),
-      ...(params.promptCacheOptions ? { prompt_cache_options: params.promptCacheOptions } : {}),
-    };
-    emitEvent(emit, 'context.compaction.started', { provider: 'openai', model, previous_response_id: body.previous_response_id || null }, meta);
+      previous_response_id: previousResponseId || null,
+    }, meta);
+
     let response;
     let http;
     try {
@@ -255,21 +378,49 @@ export function createOpenAIResponsesAdapter(options = {}) {
       response = result.data;
       http = result.http;
     } catch (error) {
-      const diagnostic = diagnosticFromError(error, { source: 'openai', kind: 'provider_error' });
+      const diagnostic = diagnosticFromError(error, { source: providerId, kind: 'provider_error' });
       emitEvent(emit, 'error.observed', diagnostic, meta);
-      emitEvent(emit, 'run.failed', { stage: 'compaction', provider: 'openai', model, error: diagnostic }, meta);
+      emitEvent(emit, 'run.failed', { stage: 'compaction', provider: providerId, model, error: diagnostic }, meta);
       throw error;
     }
+
+    const compactUsage = usageParts(response);
+    const compactCost = modelRecord.pricing
+      ? calculateModelCost(modelRecord, { ...compactUsage, estimate_kind: 'provider' }, { serviceTier: 'default' })
+      : null;
+    if (compactCost) emitEvent(emit, 'cost.snapshot', compactCost, meta);
     emitEvent(emit, 'context.compaction.completed', {
-      provider: 'openai', model, compaction_id: response.id, usage: response.usage || null,
-      request_id: http?.request_id || null, ray_id: http?.ray_id || null,
+      provider: providerId,
+      model,
+      compaction_id: response.id,
+      usage: response.usage || null,
+      tokens_before: Number(params.tokensBefore || compactUsage.input_tokens || 0),
+      tokens_after: Number(compactUsage.output_tokens || 0),
+      duration_ms: Date.now() - compactStartedAt,
+      request_id: http?.request_id || null,
+      ray_id: http?.ray_id || null,
     }, meta);
+
     return Object.freeze({
-      provider: 'openai', model, compaction_id: response.id,
-      request_id: http?.request_id || null, ray_id: http?.ray_id || null,
-      output: Object.freeze(response.output || []), usage: response.usage || null, raw: response,
+      provider: providerId,
+      model,
+      compaction_id: response.id,
+      request_id: http?.request_id || null,
+      ray_id: http?.ray_id || null,
+      output: Object.freeze(response.output || []),
+      provider_state: providerId === 'grok'
+        ? Object.freeze({ previous_response_id: null, compaction_input: structuredClone(response.output || []) })
+        : Object.freeze({ previous_response_id: null }),
+      usage: response.usage || null,
+      cost: compactCost,
+      raw: response,
     });
   }
 
-  return Object.freeze({ provider: 'openai', create, continueWithToolOutputs, compact });
+  return Object.freeze({
+    provider: providerId,
+    create,
+    continueWithToolOutputs,
+    ...(['openai', 'grok'].includes(providerId) ? { compact } : {}),
+  });
 }

package/src/repository/index.js

@@ -1,4 +1,16 @@
 export { repositorySnapshot } from '../capabilities/repository-snapshot.js';
-export { buildMerkleTree, diffTrees, readSnapshot, saveSnapshot, validateSnapshot } from '../lib/merkle/index.js';
-export { resolveGitContext, tryResolveGitContext, normalizeGitRemote } from '../lib/git-context.js';
+export { buildMerkleTree, diffTrees, readSnapshot, saveSnapshot, validateSnapshot } from '../../packages/agentsam-repository/src/merkle/index.js';
+export { resolveGitContext, tryResolveGitContext, normalizeGitRemote } from '../../packages/agentsam-repository/src/git-context.js';
 export { buildRetrievalPlan, createContextPack } from '../knowledge/index.js';
+export {
+  COMPANY_REPOSITORY_GRAPH_SCHEMA_VERSION,
+  REPOSITORY_STATUSES,
+  REPOSITORY_CONTRACT_TYPES,
+  REPOSITORY_CONTRACT_STATUSES,
+  REPOSITORY_DEPENDENCY_TYPES,
+  REPOSITORY_DEPENDENCY_CRITICALITIES,
+  REPOSITORY_FAILURE_POLICIES,
+  createRepositoryIdentity,
+  createRepositoryContract,
+  createRepositoryDependency,
+} from '../../packages/agentsam-repository/src/contracts.js';

package/src/rpc/generated/common_grpc_pb.js

@@ -0,0 +1 @@
+// GENERATED CODE -- NO SERVICES IN PROTO