@hifullmoon/aicommit 2.2.3 → 2.4.0

package/src/main.js

@@ -6,9 +6,7 @@ import chalk from 'chalk';
 import { parseArgs } from './cli.js';
 import { getProjectRoot, loadConfig } from './config.js';
 import {
-  getStagedDiff,
   getChangedFiles,
-  getDiffStats,
   getBranch,
   gitCommit,
   stripLockFileContent,
@@ -21,7 +19,16 @@ import {
   getIndexFingerprint,
   createIndexTransaction,
   protectSensitiveDiff,
+  unifiedArg,
 } from './git.js';
+import {
+  captureChanges,
+  needsAnalysis,
+  analysisConfig,
+  analyzeChanges,
+  summarizeChanges,
+} from './change-analysis.js';
+import { cleanupGitSpools } from './git-spool.js';
 import { generateCommitMessage } from './api.js';
 import {
   statusColor,
@@ -41,7 +48,13 @@ import {
   stringifyConfigRedacted,
   redactSensitiveUrl,
 } from './utils.js';
-import { abortSplit, applySplitPlan, resumeSplit, splitFlow } from './split.js';
+import {
+  abortSplit,
+  applySplitPlan,
+  resumeSplit,
+  splitFlow,
+  getStagedChangedFiles,
+} from './split.js';
 import { runModelTask } from './generation-ui.js';
 import { runSetup } from './setup.js';
 import { detectProviderType } from './providers.js';
@@ -50,6 +63,7 @@ import { runDoctor } from './doctor.js';
 import { runConfigCommand } from './config-command.js';
 import { generateCompletion } from './completion.js';
 import { runPolicyCommand } from './policy-command.js';
+import { runUpdate } from './update.js';
 import {
   applyCommitlintPolicy,
   collectRepositoryContext,
@@ -97,6 +111,7 @@ async function runMain() {
     dryRun,
     yes,
     setup,
+    update,
     doctor,
     configAction,
     policyAction,
@@ -113,10 +128,12 @@ async function runMain() {
     return { exitReason: 'completion' };
   }
   const machineOutput = output === 'json';
-  if (machineOutput && !yes && !doctor && !configAction && !policyAction) {
+  if (machineOutput && !yes && !doctor && !configAction && !policyAction && !update) {
     throw fail(ERROR_CATEGORIES.CONFIG, '--output=json requires --yes for commit and split flows.');
   }
 
+  if (update) return runUpdate({ machineOutput, debug });
+
   // The setup wizard is a standalone flow — no git repo, diff, or loaded
   // config required.
   if (setup) {
@@ -353,8 +370,7 @@ async function runMain() {
     indexTransaction ||= createIndexTransaction(projectRoot);
     return indexTransaction;
   };
-  let diff = getStagedDiff(projectRoot, config.diffContextLines);
-  if (!diff) {
+  if (!getChangedFiles(projectRoot).length) {
     // Nothing staged. But git diff --staged is also empty for unstaged work
     // and untracked files — surface what git status actually shows instead of
     // falsely claiming there's nothing to commit.
@@ -425,7 +441,14 @@ async function runMain() {
 
     try {
       beginIndexTransaction();
-      runGit(toStage ? ['add', '--', ...toStage] : ['add', '-A'], projectRoot);
+      runGit(
+        toStage
+          ? ['--literal-pathspecs', 'add', '--pathspec-from-file=-', '--pathspec-file-nul']
+          : ['add', '-A'],
+        projectRoot,
+        false,
+        toStage ? toStage.join('\0') + '\0' : undefined,
+      );
       indexTransaction.markOwned();
     } catch (err) {
       indexTransaction?.restore({ force: true });
@@ -439,8 +462,7 @@ async function runMain() {
       });
     }
 
-    diff = getStagedDiff(projectRoot, config.diffContextLines);
-    if (!diff) {
+    if (!getChangedFiles(projectRoot).length) {
       console.log('\n  ' + chalk.yellow('✗ Nothing staged — no diff to commit.\n'));
       throw fail(ERROR_CATEGORIES.GIT_STATE, 'Nothing staged; no diff to commit.', {
         reported: true,
@@ -451,7 +473,14 @@ async function runMain() {
   // Re-read the final diff between two complete-index fingerprints so the
   // prompt is guaranteed to describe one stable staged snapshot.
   const plannedIndexFingerprint = getIndexFingerprint(projectRoot);
-  diff = getStagedDiff(projectRoot, config.diffContextLines);
+  const changedFiles = getChangedFiles(projectRoot);
+  const captured = captureChanges(
+    [['diff', unifiedArg(config.diffContextLines), '--staged']],
+    projectRoot,
+    getStagedChangedFiles(projectRoot),
+    config,
+  );
+  const diff = captured.diff || '';
   if (getIndexFingerprint(projectRoot) !== plannedIndexFingerprint) {
     console.log(
       '\n  ' + chalk.red('✗ The staged changes are being modified concurrently; commit aborted.\n'),
@@ -463,8 +492,7 @@ async function runMain() {
     );
   }
 
-  const stats = getDiffStats(diff);
-  const changedFiles = getChangedFiles(projectRoot);
+  const stats = captured.stats;
   const branch = getBranch(projectRoot);
   const stageIcon = chalk.green('staged');
   const changeStr = chalk.green(`+${stats.additions}`) + '  ' + chalk.red(`-${stats.deletions}`);
@@ -495,7 +523,9 @@ async function runMain() {
   // Protect common secrets before any repository content leaves the machine.
   // The protected diff affects only the model request, never the actual index.
   const protectedInput = protectSensitiveDiff(diff);
+  protectedInput.findings = [...new Set([...protectedInput.findings, ...captured.findings])];
   let diffForModel = diff;
+  let protectAnalysis = true;
   if (protectedInput.findings.length) {
     warnings.push('Sensitive data was detected and protected before the provider request.');
     console.log('\n  ' + chalk.yellow.bold('⚠ Potential sensitive data detected:'));
@@ -513,33 +543,47 @@ async function runMain() {
               description:
                 'Omit sensitive files/private keys and redact detected credential values',
             },
-            { name: 'Cancel', value: 'cancel', description: 'Do not send repository content' },
             {
               name: 'Send original diff',
               value: 'original',
               description: 'Send the unredacted content to the configured provider',
             },
+            { name: 'Cancel', value: 'cancel', description: 'Do not send repository content' },
           ],
         });
     if (sensitiveAction === 'cancel') {
       return finishCancelled();
     }
     if (sensitiveAction === 'protect') diffForModel = protectedInput.diff;
+    if (sensitiveAction === 'original') protectAnalysis = false;
   }
 
-  // Prepare the diff the model sees (computed once — it doesn't change across
-  // regenerations): lock-file and stripFiles contents are stubbed (they carry
-  // no commit intent) and oversized diffs are condensed to a --stat summary
-  // plus truncated hunks, so token spend stays proportional to what the
-  // model needs.
+  // Small changes keep the existing prompt. Large changes use a local
+  // inventory by default; exhaustive model analysis is an explicit opt-in.
+  const large = needsAnalysis(captured, config);
   const strippedDiff = stripLockFileContent(diffForModel, config.stripFiles);
-  const { diff: modelDiff, truncated } = condenseDiff(
-    strippedDiff,
-    config.maxDiffChars,
-    getDiffStat(projectRoot),
-    config.maxFileDiffChars,
-  );
-  if (truncated) {
+  let { diff: modelDiff, truncated } = large
+    ? { diff: '', truncated: false }
+    : condenseDiff(
+        strippedDiff,
+        config.maxDiffChars,
+        getDiffStat(projectRoot),
+        config.maxFileDiffChars,
+      );
+  let analysis;
+  let analyzedFacts;
+  let generationConfig = config;
+  if (large) {
+    generationConfig = analysisConfig(config);
+    console.log(
+      chalk.dim(
+        generationConfig.largeChange?.strategy === 'deep'
+          ? `  Large change: analyzing all ${changedFiles.length} files in bounded chunks.`
+          : `  Large change: building a local inventory of ${changedFiles.length} files with bounded excerpts.`,
+      ),
+    );
+  }
+  if (truncated && !large) {
     warnings.push('The diff was condensed to fit the configured provider input limit.');
     console.log(
       chalk.dim(
@@ -571,8 +615,41 @@ async function runMain() {
         machineOutput,
         cancelMessage: 'Commit cancelled.',
         failureMessage: 'API call failed',
-        task: (stream) =>
-          generateCommitMessage(config, modelDiff, regenerateCount, message, stream),
+        task: async (stream) => {
+          if (large && !analysis) {
+            analyzedFacts ||= await analyzeChanges(
+              generationConfig,
+              captured,
+              protectAnalysis,
+              null,
+              ({ completedChunks }) =>
+                console.error(`  Analysis: ${completedChunks} chunks completed`),
+            );
+            modelDiff =
+              analyzedFacts.summary ||
+              (await summarizeChanges(generationConfig, analyzedFacts.facts));
+            analysis = analyzedFacts;
+            console.error(
+              `  Coverage: ${analysis.coverage.analyzedFiles} files analyzed; ${analysis.coverage.sampledFiles || 0} representative excerpts; ${analysis.coverage.metadataOnlyFiles} metadata only.`,
+            );
+            if (analysis.coverage.strategy === 'auto')
+              warnings.push(
+                'Large changes were summarized locally with selected excerpts; content was not fully analyzed.',
+              );
+          }
+          const result = await generateCommitMessage(
+            generationConfig,
+            modelDiff,
+            regenerateCount,
+            message,
+            stream,
+          );
+          if (large) {
+            result.usage = generationConfig.analysisBudget.snapshot().usage;
+            result.elapsed = generationConfig.analysisBudget.snapshot().elapsedMs;
+          }
+          return result;
+        },
         successMessage(result) {
           let done = `Generated in ${chalk.bold(formatMs(result.elapsed))}`;
           if (result.usage) done += chalk.dim(`  · tokens: ${formatUsage(result.usage)}`);
@@ -693,6 +770,13 @@ async function runMain() {
       usage,
       warnings,
       exitReason: 'dry_run',
+      ...(analysis
+        ? {
+            data: {
+              analysis: { ...analysis.coverage, ...generationConfig.analysisBudget.snapshot() },
+            },
+          }
+        : {}),
       committed: false,
       edited: wasEdited,
       rewrites: regenerateCount + automaticCorrectionCount,
@@ -732,6 +816,13 @@ async function runMain() {
       usage,
       warnings,
       exitReason: 'success',
+      ...(analysis
+        ? {
+            data: {
+              analysis: { ...analysis.coverage, ...generationConfig.analysisBudget.snapshot() },
+            },
+          }
+        : {}),
       committed: true,
       edited: wasEdited,
       rewrites: regenerateCount + automaticCorrectionCount,
@@ -763,5 +854,7 @@ export async function main() {
       edited: false,
       rewrites: 0,
     };
+  } finally {
+    cleanupGitSpools();
   }
 }

package/src/model-client.js

@@ -0,0 +1,403 @@
+import { stream as streamPi } from '@earendil-works/pi-ai/api/openai-completions';
+import { getProviderAdapter, normalizeUsage } from './providers.js';
+import { ERROR_CATEGORIES, fail } from './errors.js';
+import { completionEvent, normalizeEventStream } from './provider-response.js';
+import { estimateTokens } from './analysis-budget.js';
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+const DEFAULT_RETRY_POLICY = Object.freeze({
+  maxAttempts: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 5000,
+});
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const RETRYABLE_NETWORK_CODES = new Set([
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'EHOSTUNREACH',
+  'ENETUNREACH',
+  'EPIPE',
+  'UND_ERR_CONNECT_TIMEOUT',
+  'UND_ERR_SOCKET',
+]);
+
+function secureEndpoint(apiUrl) {
+  const endpoint = new URL(apiUrl);
+  const loopback =
+    endpoint.hostname === 'localhost' ||
+    endpoint.hostname === '127.0.0.1' ||
+    endpoint.hostname.startsWith('127.') ||
+    endpoint.hostname === '[::1]';
+  if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:' && loopback)) {
+    throw new Error(
+      'Refusing insecure API endpoint: use HTTPS, or HTTP only for localhost/loopback.',
+    );
+  }
+  return endpoint;
+}
+
+function retryPolicy(value = {}) {
+  return {
+    maxAttempts: value?.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts,
+    baseDelayMs: value?.baseDelayMs ?? DEFAULT_RETRY_POLICY.baseDelayMs,
+    maxDelayMs: value?.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs,
+    sleep:
+      value?.sleep ??
+      ((delayMs) =>
+        new Promise((resolve) => {
+          globalThis.setTimeout(resolve, delayMs);
+        })),
+    now: value?.now ?? (() => Date.now()),
+  };
+}
+
+function retryAfterMs(value, now) {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
+  const date = Date.parse(value);
+  if (Number.isNaN(date)) return null;
+  return Math.max(0, date - now());
+}
+
+function networkFailure(err) {
+  if (err instanceof TypeError) return true;
+  return RETRYABLE_NETWORK_CODES.has(err?.code) || RETRYABLE_NETWORK_CODES.has(err?.cause?.code);
+}
+
+function timeoutError(err, timeout) {
+  if (err?.name !== 'TimeoutError' && err?.name !== 'AbortError') return null;
+  return new Error(
+    `Request timed out after ${Math.round(timeout / 1000)}s — the model took too long to respond. ` +
+      `Raise "timeoutMs" in your config if this keeps happening.`,
+  );
+}
+
+async function fetchWithRetry(
+  apiUrl,
+  init,
+  timeout,
+  configuredPolicy,
+  consume,
+  beforeAttempt = null,
+) {
+  const policy = retryPolicy(configuredPolicy);
+  let attempt = 0;
+
+  while (attempt < policy.maxAttempts) {
+    attempt += 1;
+    beforeAttempt?.();
+    let response;
+    try {
+      response = await fetch(apiUrl, {
+        ...init,
+        signal: init.signal
+          ? AbortSignal.any([init.signal, AbortSignal.timeout(timeout)])
+          : AbortSignal.timeout(timeout),
+      });
+    } catch (err) {
+      const wrappedTimeout = timeoutError(err, timeout);
+      if (wrappedTimeout) throw wrappedTimeout;
+      if (!networkFailure(err) || attempt >= policy.maxAttempts) throw err;
+      const delay = Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
+      await policy.sleep(delay);
+      continue;
+    }
+
+    if (response.ok) {
+      try {
+        return { value: await consume(response), attempts: attempt };
+      } catch (err) {
+        const wrappedTimeout = timeoutError(err, timeout);
+        if (wrappedTimeout) throw wrappedTimeout;
+        // Once the provider has accepted a generation request, replaying it is
+        // unsafe: the first request may already have completed and been billed
+        // even though its response body was interrupted locally.
+        throw err;
+      }
+    }
+    if (RETRYABLE_STATUS.has(response.status) && attempt < policy.maxAttempts) {
+      const requestedDelay = retryAfterMs(response.headers.get('retry-after'), policy.now);
+      if (requestedDelay !== null && requestedDelay > policy.maxDelayMs) {
+        await response.body?.cancel().catch(() => {});
+        throw new Error(
+          `HTTP ${response.status}: provider requested a retry after ${Math.ceil(
+            requestedDelay / 1000,
+          )}s, exceeding the configured retry.maxDelayMs limit.`,
+        );
+      }
+      const delay =
+        requestedDelay ?? Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
+      await response.body?.cancel().catch(() => {});
+      await policy.sleep(delay);
+      continue;
+    }
+
+    const errText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errText.slice(0, 400)}`);
+  }
+
+  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 = {
+    ...rest,
+    stream: false,
+    options: { temperature, num_predict: max_tokens, ...options },
+  };
+  if (/\/api\/generate\/?$/i.test(new URL(apiUrl).pathname)) {
+    // /generate accepts a prompt, not the messages array used by /chat.
+    body.system = body.messages
+      .filter((m) => m.role === 'system')
+      .map((m) => m.content)
+      .join('\n\n');
+    body.prompt = body.messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => `${m.role}: ${m.content}`)
+      .join('\n\n');
+    delete body.messages;
+  }
+  return body;
+}
+
+function transport(config, adapter, state) {
+  return async (_sdkUrl, init) => {
+    try {
+      const headers = new globalThis.Headers(init.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}`);
+      else headers.delete('Authorization');
+      let payload = JSON.parse(init.body);
+      if (adapter.nativeOllama) payload = nativeOllamaPayload(payload, config.apiUrl);
+      else if (config.extraBody?.stream === false) {
+        payload.stream = false;
+        delete payload.stream_options;
+      }
+      const result = await fetchWithRetry(
+        config.apiUrl,
+        {
+          ...init,
+          headers,
+          body: JSON.stringify(payload),
+          redirect: 'error',
+        },
+        config.timeoutMs || DEFAULT_TIMEOUT_MS,
+        config.analysisBudget
+          ? {
+              ...config.retry,
+              sleep: async (ms) => {
+                if (ms >= config.analysisBudget.remainingMs())
+                  throw new Error('Analysis timed out during retry backoff.');
+                await new Promise((resolve) => {
+                  setTimeout(resolve, ms);
+                });
+              },
+            }
+          : config.retry,
+        async (response) => {
+          if (
+            (response.headers.get('content-type') || '').toLowerCase().includes('text/event-stream')
+          )
+            return normalizeEventStream(response);
+          let data;
+          try {
+            data = await response.json();
+          } catch (err) {
+            if (err instanceof SyntaxError)
+              throw fail(ERROR_CATEGORIES.RESPONSE_FORMAT, 'Provider returned invalid JSON.', {
+                cause: err,
+              });
+            throw err;
+          }
+          const event = completionEvent(data);
+          state.raw = data;
+          return new Response(`data: ${JSON.stringify(event)}\n\ndata: [DONE]\n\n`, {
+            headers: { 'Content-Type': 'text/event-stream' },
+          });
+        },
+        config.analysisBudget
+          ? () => {
+              state.ticket = config.analysisBudget.reserve(
+                config.analysisInputTokens,
+                config.analysisOutputTokens,
+              );
+            }
+          : null,
+      );
+      state.attempts = result.attempts;
+      return result.value;
+    } catch (err) {
+      state.error = err;
+      throw err;
+    }
+  };
+}
+
+export async function requestGeneration(config, request) {
+  secureEndpoint(config.apiUrl);
+  if (config.analysisBudget) {
+    config = {
+      ...config,
+      analysisInputTokens: estimateTokens(JSON.stringify(request.messages)),
+      analysisOutputTokens: request.maxTokens,
+      timeoutMs: Math.max(
+        1,
+        Math.min(config.timeoutMs || DEFAULT_TIMEOUT_MS, config.analysisBudget.remainingMs()),
+      ),
+    };
+  }
+  const adapter = getProviderAdapter(config);
+  const options = adapter.options({
+    ...request,
+    extraBody: config.extraBody,
+    reasoning: request.reasoning ?? config.reasoning,
+  });
+  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.
+    apiKey: config.apiKey || 'aicommit-keyless',
+    headers: adapter.headers,
+    env: {},
+    maxRetries: 0,
+    timeoutMs: config.timeoutMs || DEFAULT_TIMEOUT_MS,
+    signal: config.analysisBudget
+      ? AbortSignal.any([controller.signal, config.analysisBudget.signal])
+      : controller.signal,
+    fetch: transport(config, adapter, state),
+  });
+  let result;
+  try {
+    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.type === 'done') result = event.message;
+    }
+  } 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;
+  config.analysisBudget?.settle(state.ticket, usage);
+  return {
+    provider: adapter.id,
+    model: result.responseModel || result.model,
+    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.
+    raw: state.raw || {
+      model: result.responseModel || result.model,
+      choices: [
+        { message: { content, reasoning_content: reasoning }, finish_reason: finishReason },
+      ],
+      usage: usage
+        ? {
+            prompt_tokens: usage.inputTokens,
+            completion_tokens: usage.outputTokens,
+            total_tokens: usage.totalTokens,
+          }
+        : null,
+    },
+    piMessage: result,
+    capabilities: adapter.capabilities,
+    attempts: state.attempts,
+    latencyMs: performance.now() - startedAt,
+  };
+}