@hifullmoon/aicommit 2.6.6 → 2.6.8

package/src/model-client.js

@@ -1,4 +1,4 @@
-import { stream as streamPi } from '@earendil-works/pi-ai/api/openai-completions';
+import OpenAI from 'openai';
 import { getProviderAdapter, normalizeUsage } from './providers.js';
 import { ERROR_CATEGORIES, fail } from './errors.js';
 import { completionEvent, normalizeEventStream } from './provider-response.js';
@@ -141,40 +141,6 @@ async function fetchWithRetry(
   throw new Error('Provider request exhausted its retry budget.');
 }
 
-function piContext(messages, model) {
-  return {
-    systemPrompt:
-      messages
-        .filter((m) => m.role === 'system')
-        .map((m) => m.content)
-        .join('\n\n') || undefined,
-    messages: messages
-      .filter((m) => m.role !== 'system')
-      .map((message) => {
-        if (message.role === 'user') return { ...message, timestamp: Date.now() };
-        if (message.role !== 'assistant')
-          throw new Error(`Unsupported generation message role: ${message.role}`);
-        return {
-          role: 'assistant',
-          content: [{ type: 'text', text: message.content }],
-          api: model.api,
-          provider: model.provider,
-          model: model.id,
-          stopReason: 'stop',
-          usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-          },
-          timestamp: Date.now(),
-        };
-      }),
-  };
-}
-
 function nativeOllamaPayload(payload, apiUrl) {
   const { max_tokens, temperature, stream_options: _streamOptions, options, ...rest } = payload;
   const body = {
@@ -200,7 +166,13 @@ function nativeOllamaPayload(payload, apiUrl) {
 function transport(config, adapter, state) {
   return async (_sdkUrl, init) => {
     try {
-      const headers = new globalThis.Headers(init.headers);
+      // Build outbound headers from application-owned values: SDK headers can
+      // include arbitrary credentials from OPENAI_CUSTOM_HEADERS.
+      const headers = new globalThis.Headers({
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        ...adapter.headers,
+      });
       // Never let SDK defaults resolve a different credential or follow a redirect
       // carrying repository content to an endpoint the user did not configure.
       if (config.apiKey) headers.set('Authorization', `Bearer ${config.apiKey}`);
@@ -271,6 +243,77 @@ function transport(config, adapter, state) {
   };
 }
 
+function requestPayload(adapter, request, options) {
+  const system = request.messages
+    .filter((message) => message.role === 'system')
+    .map((message) => message.content)
+    .join('\n\n');
+  const messages = request.messages
+    .filter((message) => message.role !== 'system')
+    .map((message) => {
+      if (!['user', 'assistant'].includes(message.role))
+        throw new Error(`Unsupported generation message role: ${message.role}`);
+      return {
+        role: message.role,
+        content: message.content,
+        ...((adapter.id === 'deepseek' ||
+          adapter.model.requiresReasoningContentOnAssistantMessages) &&
+        adapter.model.reasoning &&
+        message.role === 'assistant'
+          ? { reasoning_content: '' }
+          : {}),
+      };
+    });
+  if (system) messages.unshift({ role: 'system', content: system });
+  const payload = {
+    model: adapter.model.id,
+    messages,
+    stream: true,
+    [adapter.capabilities.tokenBudget === 'max_completion_tokens'
+      ? 'max_completion_tokens'
+      : 'max_tokens']: options.maxTokens,
+    ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+  };
+  const model = adapter.model;
+  const effort = options.reasoningEffort;
+  const mapped = model.thinkingLevelMap?.[effort] ?? effort;
+  if (model.reasoning) {
+    if (adapter.id === 'deepseek') {
+      if (effort) payload.thinking = { type: 'enabled' };
+      else if (model.thinkingLevelMap?.off !== null) payload.thinking = { type: 'disabled' };
+      if (effort) payload.reasoning_effort = mapped;
+    } else if (adapter.id === 'openrouter') {
+      if (effort) payload.reasoning = { effort: mapped };
+      else if (model.thinkingLevelMap?.off !== null)
+        payload.reasoning = { effort: model.thinkingLevelMap?.off ?? 'none' };
+    } else if (adapter.id === 'openai') {
+      if (effort) payload.reasoning_effort = mapped;
+      else if (typeof model.thinkingLevelMap?.off === 'string')
+        payload.reasoning_effort = model.thinkingLevelMap.off;
+    }
+  }
+  options.onPayload(payload);
+  return payload;
+}
+
+function generationError(err, state, config) {
+  if (err.category) return err;
+  const cause = state.error || err;
+  if (cause.category) return cause;
+  const timeout = timeoutError(cause, config.timeoutMs || DEFAULT_TIMEOUT_MS);
+  if (timeout || /timed out|timeout/i.test(cause.message))
+    return fail(ERROR_CATEGORIES.NETWORK, timeout?.message || cause.message, { cause });
+  if (networkFailure(cause) || /socket|network|fetch failed|terminated|econn/i.test(cause.message))
+    return fail(ERROR_CATEGORIES.NETWORK, cause.message, { cause });
+  if (cause instanceof SyntaxError)
+    return fail(
+      ERROR_CATEGORIES.RESPONSE_FORMAT,
+      `Provider returned invalid JSON: ${cause.message}`,
+      { cause },
+    );
+  return cause;
+}
+
 export async function requestGeneration(config, request) {
   secureEndpoint(config.apiUrl);
   if (config.analysisBudget) {
@@ -293,97 +336,111 @@ export async function requestGeneration(config, request) {
   const state = { attempts: 0, raw: null, error: null };
   const startedAt = performance.now();
   const controller = new AbortController();
-  const events = streamPi(adapter.model, piContext(request.messages, adapter.model), {
-    ...options,
-    // Pi's transport requires a key even for a keyless server. The placeholder
-    // never leaves the process: transport installs only the resolved config key.
+  // An explicit key prevents SDK environment credential discovery. The transport
+  // removes this placeholder and sends only the resolved AICommit credential.
+  const client = new OpenAI({
     apiKey: config.apiKey || 'aicommit-keyless',
-    headers: adapter.headers,
-    env: {},
+    organization: null,
+    project: null,
+    logLevel: 'off',
+    baseURL: adapter.model.baseUrl,
+    defaultHeaders: adapter.headers,
     maxRetries: 0,
-    timeoutMs: config.timeoutMs || DEFAULT_TIMEOUT_MS,
-    signal: config.analysisBudget
-      ? AbortSignal.any([controller.signal, config.analysisBudget.signal])
-      : controller.signal,
+    timeout: config.timeoutMs || DEFAULT_TIMEOUT_MS,
     fetch: transport(config, adapter, state),
   });
-  let result;
+  let content = '';
+  let reasoningText = '';
+  let responseModel = config.modelId;
+  let reportedUsage = null;
+  let finishReason = null;
   try {
+    const events = await client.chat.completions.create(requestPayload(adapter, request, options), {
+      signal: config.analysisBudget
+        ? AbortSignal.any([controller.signal, config.analysisBudget.signal])
+        : controller.signal,
+    });
     for await (const event of events) {
-      if (event.type === 'thinking_delta') request.stream?.onReasoningDelta?.(event.delta);
-      if (event.type === 'error') {
-        if (state.error) throw state.error;
-        const message = event.error.errorMessage || 'Provider request failed.';
-        if (/without finish_reason/.test(message))
-          throw fail(
-            ERROR_CATEGORIES.RESPONSE_FORMAT,
-            'Streaming response ended before the provider sent a finish_reason. The partial response was discarded; retry the request.',
-          );
-        if (/timed out|timeout/i.test(message))
-          throw fail(
-            ERROR_CATEGORIES.NETWORK,
-            `Request timed out after ${Math.round((config.timeoutMs || DEFAULT_TIMEOUT_MS) / 1000)}s — the model took too long to respond. Raise "timeoutMs" in your config if this keeps happening.`,
-          );
-        if (/socket|network|fetch failed|terminated|econn/i.test(message))
-          throw fail(ERROR_CATEGORIES.NETWORK, message);
-        if (/JSON|Unexpected token/i.test(message))
-          throw fail(
-            ERROR_CATEGORIES.RESPONSE_FORMAT,
-            `Provider returned invalid JSON: ${message}`,
-          );
-        throw fail(ERROR_CATEGORIES.PROVIDER, `Provider request failed: ${message}`);
+      if (event.model) responseModel = event.model;
+      if (event.usage) reportedUsage = event.usage;
+      const choice = event.choices?.find((value) => (value.index ?? 0) === 0);
+      if (!choice) continue;
+      if (!event.usage && choice.usage) reportedUsage = choice.usage;
+      const delta = choice.delta;
+      if (typeof delta?.content === 'string') content += delta.content;
+      if (typeof delta?.reasoning_content === 'string' && delta.reasoning_content) {
+        reasoningText += delta.reasoning_content;
+        request.stream?.onReasoningDelta?.(delta.reasoning_content);
+      }
+      if (choice.finish_reason != null) {
+        finishReason = choice.finish_reason;
+        if (!['stop', 'end', 'length', 'tool_calls', 'function_call'].includes(finishReason))
+          throw fail(ERROR_CATEGORIES.PROVIDER, `Provider finish_reason: ${finishReason}`);
       }
-      if (event.type === 'done') result = event.message;
     }
+    // The SDK treats an AbortError as the end of iteration. An interrupted
+    // response must still fail, even if a finish marker arrived before it.
+    if (events.controller.signal.aborted)
+      throw fail(ERROR_CATEGORIES.NETWORK, 'Provider response stream was aborted.');
+    if (finishReason === null)
+      throw fail(
+        ERROR_CATEGORIES.RESPONSE_FORMAT,
+        'Streaming response ended before the provider sent a finish_reason. The partial response was discarded; retry the request.',
+      );
+  } catch (err) {
+    throw generationError(err, state, config);
   } finally {
     controller.abort();
   }
-  if (!result)
-    throw fail(
-      ERROR_CATEGORIES.RESPONSE_FORMAT,
-      'Provider returned an invalid response: no completed generation.',
-    );
-  const content = result.content
-    .filter((block) => block.type === 'text')
-    .map((block) => block.text)
-    .join('');
-  const reasoning =
-    result.content
-      .filter((block) => block.type === 'thinking')
-      .map((block) => block.thinking)
-      .filter(Boolean)
-      .join('\n') || null;
   const usage = state.raw
-    ? normalizeUsage(state.raw.usage || state.raw)
-    : result.usage.totalTokens ||
-        result.usage.input ||
-        result.usage.output ||
-        result.usage.cacheRead ||
-        result.usage.cacheWrite
-      ? {
-          inputTokens: result.usage.input + result.usage.cacheRead + result.usage.cacheWrite,
-          outputTokens: result.usage.output,
-          totalTokens: result.usage.totalTokens,
-        }
-      : null;
-  const finishReason =
-    state.raw?.choices?.[0]?.finish_reason ??
-    state.raw?.stop_reason ??
-    state.raw?.done_reason ??
-    result.rawStopReason ??
-    result.stopReason;
+    ? normalizeUsage(state.raw.usage || state.raw.choices?.[0]?.usage || state.raw)
+    : normalizeUsage(reportedUsage);
+  const reasoning = reasoningText || null;
+  const cacheRead =
+    reportedUsage?.prompt_tokens_details?.cached_tokens ??
+    reportedUsage?.prompt_cache_hit_tokens ??
+    reportedUsage?.cached_tokens ??
+    0;
+  const cacheWrite = reportedUsage?.prompt_tokens_details?.cache_write_tokens || 0;
+  const blocks = [];
+  if (content) blocks.push({ type: 'text', text: content });
+  if (reasoning) blocks.push({ type: 'thinking', thinking: reasoning });
+  // Retain the previous public result shape for callers during the SDK migration.
+  const assistantMessage = {
+    role: 'assistant',
+    api: 'openai-completions',
+    provider: adapter.id,
+    model: config.modelId,
+    responseModel,
+    content: blocks,
+    usage: {
+      input: Math.max(0, (usage?.inputTokens || 0) - cacheRead - cacheWrite),
+      output: usage?.outputTokens || 0,
+      cacheRead,
+      cacheWrite,
+      totalTokens: usage?.totalTokens || 0,
+    },
+    stopReason: ['tool_calls', 'function_call'].includes(finishReason)
+      ? 'toolUse'
+      : finishReason === 'end'
+        ? 'stop'
+        : finishReason,
+    timestamp: Date.now(),
+  };
   config.analysisBudget?.settle(state.ticket, usage);
   return {
     provider: adapter.id,
-    model: result.responseModel || result.model,
+    model: responseModel,
     content,
     reasoning,
     usage,
-    finishReason,
-    // Preserve callAPI's Chat Completions-shaped compatibility return. Pi's full
-    // normalized message is also available for future protocol-specific callers.
+    finishReason:
+      state.raw?.choices?.[0]?.finish_reason ??
+      state.raw?.stop_reason ??
+      state.raw?.done_reason ??
+      finishReason,
     raw: state.raw || {
-      model: result.responseModel || result.model,
+      model: responseModel,
       choices: [
         { message: { content, reasoning_content: reasoning }, finish_reason: finishReason },
       ],
@@ -395,7 +452,7 @@ export async function requestGeneration(config, request) {
           }
         : null,
     },
-    piMessage: result,
+    piMessage: assistantMessage,
     capabilities: adapter.capabilities,
     attempts: state.attempts,
     latencyMs: performance.now() - startedAt,

package/src/provider-response.js

@@ -31,7 +31,7 @@ export function completionEvent(data) {
     );
   const choice = data.choices?.[0];
   const message = choice?.message ?? data.message;
-  const usage = normalizeUsage(data.usage || data);
+  const usage = normalizeUsage(data.usage || choice?.usage || data);
   const finish = choice?.finish_reason ?? data.stop_reason ?? data.done_reason ?? 'stop';
   return {
     model: data.model,
@@ -60,7 +60,7 @@ export function completionEvent(data) {
   };
 }
 
-// Keep provider stop aliases out of Pi's error branch so the business recovery
+// Keep provider stop aliases out of the error branch so the business recovery
 // path receives a truncated result. Unknown and safety-related reasons stay intact.
 function normalizeFinishReason(reason) {
   if (['max_tokens', 'max_output_tokens', 'token_limit'].includes(reason)) return 'length';
@@ -110,7 +110,18 @@ function miniMaxIncrement(value, state) {
 }
 
 function normalizeChunk(value, miniMaxChoices = null) {
-  if (!value || !Array.isArray(value.choices)) return value;
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    (value.choices !== undefined && !Array.isArray(value.choices)) ||
+    value.choices?.some((choice) => !choice || typeof choice !== 'object' || Array.isArray(choice))
+  )
+    throw fail(
+      ERROR_CATEGORIES.RESPONSE_FORMAT,
+      'Provider returned an invalid streaming response: expected an object with a choices array.',
+    );
+  if (!value.choices) return value;
   for (const choice of value.choices) {
     if (!choice || typeof choice !== 'object') continue;
     choice.finish_reason = normalizeFinishReason(choice.finish_reason);
@@ -133,14 +144,14 @@ function normalizeChunk(value, miniMaxChoices = null) {
     } else {
       choice.delta = { ...delta, reasoning_content: reasoning };
     }
-    // Retain reasoning_details for Pi's replay metadata while also exposing all
+    // Retain reasoning_details metadata while also exposing all
     // its textual segments as ordinary thinking deltas, including legacy shapes.
   }
   return value;
 }
 
 // eventsource-parser handles UTF-8-decoded SSE framing; this boundary adjusts
-// only vendor fields. Pi still owns model-result assembly and finish validation.
+// only vendor fields. The client assembles results and validates completion.
 // Web Stream piping preserves backpressure, cancellation and body read errors.
 export function normalizeEventStream(response, provider = '') {
   if (!response.body)
@@ -169,6 +180,11 @@ export function normalizeEventStream(response, provider = '') {
                 { cause },
               );
             }
+            if (value?.error || event.event === 'error')
+              throw fail(
+                ERROR_CATEGORIES.PROVIDER,
+                `Provider request failed: ${textValue(value?.error?.message ?? value?.message) || JSON.stringify(value)}`,
+              );
             data = JSON.stringify(normalizeChunk(value, miniMaxChoices));
           }
           controller.enqueue(

package/src/providers.js

@@ -1,7 +1,27 @@
-import { clampThinkingLevel, getSupportedThinkingLevels } from '@earendil-works/pi-ai';
-import { OPENAI_MODELS } from '@earendil-works/pi-ai/providers/openai.models';
-import { DEEPSEEK_MODELS } from '@earendil-works/pi-ai/providers/deepseek.models';
-import { OPENROUTER_MODELS } from '@earendil-works/pi-ai/providers/openrouter.models';
+import modelCapabilities from './model-capabilities.json' with { type: 'json' };
+
+function getSupportedThinkingLevels(model) {
+  if (!model.reasoning) return ['off'];
+  return ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    return mapped !== null && (!['xhigh', 'max'].includes(level) || mapped !== undefined);
+  });
+}
+
+function clampThinkingLevel(model, level) {
+  const levels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+  const supported = getSupportedThinkingLevels(model);
+  if (supported.includes(level)) return level;
+  const index = levels.indexOf(level);
+  return (
+    levels.slice(index).find((candidate) => supported.includes(candidate)) ??
+    levels
+      .slice(0, index)
+      .reverse()
+      .find((candidate) => supported.includes(candidate)) ??
+    'off'
+  );
+}
 export const PROVIDER_TYPES = Object.freeze([
   'openai',
   'openrouter',
@@ -86,15 +106,17 @@ export function normalizeUsage(usage) {
   return Object.keys(normalized).length ? normalized : null;
 }
 
-// Read Pi's bundled catalog locally. Credentials and network model discovery remain
+// Read the local capability snapshot. Credentials and network model discovery remain
 // outside this layer; a configured model ID need not be present in the catalog.
 function catalogModel(provider, modelId) {
-  if (provider === 'openai') {
-    return OPENAI_MODELS[modelId] || OPENAI_MODELS[modelId.replace(/-codex$/, '')];
-  }
-  if (provider === 'deepseek') return DEEPSEEK_MODELS[modelId];
-  if (provider === 'openrouter') return OPENROUTER_MODELS[modelId];
-  return undefined;
+  const models = modelCapabilities.providers[provider];
+  if (!models) return undefined;
+  const id = Object.hasOwn(models, modelId)
+    ? modelId
+    : provider === 'openai'
+      ? modelId.replace(/-codex$/, '')
+      : modelId;
+  return Object.hasOwn(models, id) ? modelCapabilities.profiles[models[id]] : undefined;
 }
 
 export function isOpenAIReasoningModel(modelId = '') {
@@ -139,8 +161,7 @@ function resolveEffort(provider, model, reasoning) {
   return level === 'off' ? undefined : level;
 }
 
-// The application selects a Pi model and applies only configuration compatibility
-// overrides. Pi owns message conversion, model effort mapping and wire protocols.
+// Keep vendor parameter mappings separate from the OpenAI SDK transport.
 export function getProviderAdapter({ apiUrl, providerType = '', modelId = '' }) {
   const provider = detectProviderType(apiUrl, providerType);
   const nativeOllama =
@@ -151,28 +172,14 @@ export function getProviderAdapter({ apiUrl, providerType = '', modelId = '' })
   const model = {
     ...known,
     id: modelId,
-    name: known?.name || modelId,
     api: 'openai-completions',
     provider,
     // The transport pins the full configured URL, including nonstandard proxy paths.
     baseUrl: endpoint(apiUrl)?.origin || '',
     reasoning:
       known?.reasoning ?? (openAIReasoning || ['deepseek', 'openrouter'].includes(provider)),
-    input: ['text'],
-    cost: known?.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     contextWindow: known?.contextWindow || 128000,
     maxTokens: known?.maxTokens || 16384,
-    compat: {
-      ...(known?.api === 'openai-completions' ? known.compat : {}),
-      supportsStore: false,
-      supportsDeveloperRole: false,
-      supportsReasoningEffort: ['openai', 'deepseek', 'openrouter'].includes(provider),
-      supportsUsageInStreaming: provider === 'openai',
-      supportsFinishReason: true,
-      maxTokensField: tokenField,
-      thinkingFormat:
-        provider === 'deepseek' ? 'deepseek' : provider === 'openrouter' ? 'openrouter' : 'openai',
-    },
   };
   const capabilities = Object.freeze({
     streaming: !nativeOllama,
@@ -200,9 +207,8 @@ export function getProviderAdapter({ apiUrl, providerType = '', modelId = '' })
         temperature:
           openAIReasoning || (provider === 'deepseek' && mode === 'on') ? undefined : temperature,
         reasoningEffort,
-        cacheRetention: 'none',
         onPayload(payload) {
-          // Pi's absent effort means "off"; AICommit's auto means server defaults.
+          // Auto preserves server defaults; explicit modes take precedence over extras.
           const reasoningKeys = ['thinking', 'reasoning', 'reasoning_effort'];
           const mapped = Object.fromEntries(
             reasoningKeys