npm - @archal/cli - Versions diffs - 0.7.6 → 0.7.7 - Mend

@archal/cli 0.7.6 → 0.7.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/harnesses/_lib/model-configs.mjs CHANGED Viewed

@@ -164,7 +164,7 @@ const MODEL_REGISTRY = {
       maxContextWindow: 1047576,
       supportsStreaming: true,
     },
-    defaults: { maxTokens: 32768, temperature: 0.0 },
+    defaults: { maxTokens: 32768 },
     benchmarkStatus: 'untested',
   },
@@ -329,7 +329,7 @@ const FAMILY_DEFAULTS = {
   'gpt-4o':        { maxTokens: 32768, temperature: 0.2 },
   'gpt-4o-mini':   { maxTokens: 32768, temperature: 0.2 },
   'gpt-4.1':       { maxTokens: 65536, temperature: 0.2 },
-  'gpt-5.1':       { maxTokens: 32768, temperature: 0.2 },
+  'gpt-5.1':       { maxTokens: 32768 },
   'o1':            { maxTokens: 65536, reasoningEffort: 'medium' },
   'o1-mini':       { maxTokens: 32768, reasoningEffort: 'medium' },
   'o3-mini':       { maxTokens: 32768, reasoningEffort: 'medium' },

package/harnesses/_lib/providers.mjs CHANGED Viewed

@@ -217,8 +217,9 @@ export function extractTokenUsage(provider, body) {
     case 'openai': {
       const usage = body.usage ?? {};
       return {
-        inputTokens: usage.prompt_tokens ?? 0,
-        outputTokens: usage.completion_tokens ?? 0,
+        // Responses API uses input_tokens/output_tokens; Chat Completions uses prompt/completion tokens.
+        inputTokens: usage.input_tokens ?? usage.prompt_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? usage.completion_tokens ?? 0,
       };
     }
     default:
@@ -269,11 +270,9 @@ export function formatToolsForProvider(provider, mcpTools) {
     case 'openai':
       return mcpTools.map((t) => ({
         type: 'function',
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.inputSchema,
-        },
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema,
       }));
     case 'anthropic':
       return mcpTools.map((t) => ({
@@ -414,25 +413,58 @@ async function callAnthropic(model, apiKey, messages, tools) {
   };
 }
+function isGpt5SeriesModel(model) {
+  return model.startsWith('gpt-5');
+}
+function shouldSendOpenAiTemperature(model) {
+  return !isReasoningModel(model) && !isGpt5SeriesModel(model);
+}
+function normalizeOpenAiConversation(messages) {
+  if (Array.isArray(messages)) {
+    return {
+      input: messages,
+      previousResponseId: undefined,
+    };
+  }
+  if (!messages || typeof messages !== 'object') {
+    return {
+      input: [],
+      previousResponseId: undefined,
+    };
+  }
+  return {
+    input: Array.isArray(messages.input) ? messages.input : [],
+    previousResponseId: typeof messages.previousResponseId === 'string'
+      ? messages.previousResponseId
+      : undefined,
+  };
+}
 async function callOpenAi(model, apiKey, messages, tools) {
   const baseUrl = resolveBaseUrl('openai');
-  const url = `${baseUrl}/chat/completions`;
+  const url = `${baseUrl}/responses`;
   const config = getModelConfig(model);
-  const reasoning = isReasoningModel(model);
+  const conversation = normalizeOpenAiConversation(messages);
+  const reqBody = {
+    model,
+    input: conversation.input,
+    max_output_tokens: config.maxTokens,
+  };
-  const reqBody = { model, messages };
+  if (conversation.previousResponseId) {
+    reqBody.previous_response_id = conversation.previousResponseId;
+  }
-  // Reasoning models use max_completion_tokens and reasoning_effort, not temperature
-  if (reasoning) {
-    reqBody.max_completion_tokens = config.maxTokens;
-    if (config.reasoningEffort) {
-      reqBody.reasoning_effort = config.reasoningEffort;
-    }
-  } else {
-    reqBody.max_completion_tokens = config.maxTokens;
-    if (config.temperature !== undefined) {
-      reqBody.temperature = config.temperature;
-    }
+  if (config.reasoningEffort && (isReasoningModel(model) || isGpt5SeriesModel(model))) {
+    reqBody.reasoning = { effort: config.reasoningEffort };
+  }
+  // GPT-5 series rejects temperature in many variants; never send it for gpt-5*.
+  if (shouldSendOpenAiTemperature(model) && config.temperature !== undefined) {
+    reqBody.temperature = config.temperature;
   }
   if (tools && tools.length > 0) {
@@ -556,15 +588,30 @@ function parseAnthropicToolCalls(response) {
 }
 function parseOpenAiToolCalls(response) {
-  const message = response.choices?.[0]?.message;
-  if (!message?.tool_calls?.length) return null;
-  return message.tool_calls.map((tc) => ({
-    id: tc.id,
-    name: tc.function.name,
-    arguments: typeof tc.function.arguments === 'string'
-      ? JSON.parse(tc.function.arguments)
-      : tc.function.arguments ?? {},
-  }));
+  const output = Array.isArray(response.output) ? response.output : [];
+  const calls = [];
+  for (const item of output) {
+    if (item?.type !== 'function_call') continue;
+    let parsedArguments = {};
+    if (typeof item.arguments === 'string' && item.arguments.trim()) {
+      try {
+        parsedArguments = JSON.parse(item.arguments);
+      } catch {
+        parsedArguments = { _raw: item.arguments };
+      }
+    } else if (item.arguments && typeof item.arguments === 'object') {
+      parsedArguments = item.arguments;
+    }
+    calls.push({
+      id: item.call_id ?? item.id ?? `${item.name ?? 'tool'}-${Date.now()}`,
+      name: item.name,
+      arguments: parsedArguments,
+    });
+  }
+  return calls.length > 0 ? calls : null;
 }
 /**
@@ -587,7 +634,24 @@ export function getResponseText(provider, responseOrWrapper) {
       return textBlocks.join('') || null;
     }
     case 'openai': {
-      return response.choices?.[0]?.message?.content ?? null;
+      if (typeof response.output_text === 'string' && response.output_text.trim()) {
+        return response.output_text;
+      }
+      const output = Array.isArray(response.output) ? response.output : [];
+      const chunks = [];
+      for (const item of output) {
+        if (item?.type === 'output_text' && typeof item.text === 'string') {
+          chunks.push(item.text);
+          continue;
+        }
+        if (item?.type !== 'message' || !Array.isArray(item.content)) continue;
+        for (const part of item.content) {
+          if ((part?.type === 'output_text' || part?.type === 'text') && typeof part.text === 'string') {
+            chunks.push(part.text);
+          }
+        }
+      }
+      return chunks.join('') || null;
     }
     default:
       return null;
@@ -599,10 +663,6 @@ export function getResponseText(provider, responseOrWrapper) {
  * Returns the model's internal reasoning (Anthropic thinking blocks,
  * Gemini thinking parts) or null if none.
  *
- * Note: OpenAI Chat Completions API does NOT expose reasoning content.
- * Reasoning tokens are hidden. Only the Responses API (not used here)
- * can surface reasoning summaries.
- *
  * @param {'gemini' | 'anthropic' | 'openai'} provider
  * @param {object} responseOrWrapper
  * @returns {string | null}
@@ -618,9 +678,19 @@ export function getThinkingContent(provider, responseOrWrapper) {
       return blocks.length > 0 ? blocks.join('\n') : null;
     }
     case 'openai': {
-      // Chat Completions API does not expose reasoning content.
-      // OpenAI reasoning tokens are hidden by design.
-      return null;
+      const output = Array.isArray(response.output) ? response.output : [];
+      const summaries = [];
+      for (const item of output) {
+        if (item?.type !== 'reasoning') continue;
+        if (Array.isArray(item.summary)) {
+          for (const summary of item.summary) {
+            if (typeof summary?.text === 'string' && summary.text.trim()) {
+              summaries.push(summary.text);
+            }
+          }
+        }
+      }
+      return summaries.length > 0 ? summaries.join('\n') : null;
     }
     case 'gemini': {
       const parts = response.candidates?.[0]?.content?.parts ?? [];
@@ -648,7 +718,7 @@ export function getStopReason(provider, responseOrWrapper) {
     case 'anthropic':
       return response.stop_reason ?? null;
     case 'openai':
-      return response.choices?.[0]?.finish_reason ?? null;
+      return parseOpenAiToolCalls(response) ? 'tool_calls' : (response.status ?? response.incomplete_details?.reason ?? null);
     default:
       return null;
   }
@@ -681,16 +751,22 @@ export function buildInitialMessages(provider, systemPrompt, task, model) {
         messages: [{ role: 'user', content: task }],
       };
     case 'openai': {
+      let input;
       if (!supportsSystem || !systemPrompt) {
         // Reasoning models (o1, o3, o4) don't support system prompts.
         // Merge system prompt into user message.
         const combined = systemPrompt ? systemPrompt + '\n\n' + task : task;
-        return [{ role: 'user', content: combined }];
+        input = [{ role: 'user', content: combined }];
+      } else {
+        input = [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: task },
+        ];
       }
-      return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: task },
-      ];
+      return {
+        input,
+        previousResponseId: undefined,
+      };
     }
     default:
       return [
@@ -718,7 +794,13 @@ export function appendAssistantResponse(provider, messages, responseOrWrapper) {
       return messages;
     }
     case 'openai': {
-      messages.push(response.choices?.[0]?.message ?? { role: 'assistant', content: '' });
+      if (Array.isArray(messages)) {
+        const text = getResponseText('openai', response);
+        messages.push({ role: 'assistant', content: text ?? '' });
+        return messages;
+      }
+      messages.previousResponseId = response.id ?? messages.previousResponseId;
+      messages.input = [];
       return messages;
     }
     default:
@@ -751,13 +833,30 @@ export function appendToolResults(provider, messages, toolCalls, results) {
       return messages;
     }
     case 'openai': {
+      const toolOutputs = [];
       for (let i = 0; i < toolCalls.length; i++) {
-        messages.push({
-          role: 'tool',
-          tool_call_id: toolCalls[i].id,
-          content: results[i],
+        const output = typeof results[i] === 'string'
+          ? results[i]
+          : JSON.stringify(results[i]);
+        toolOutputs.push({
+          type: 'function_call_output',
+          call_id: toolCalls[i].id,
+          output,
         });
       }
+      if (Array.isArray(messages)) {
+        for (let i = 0; i < toolCalls.length; i++) {
+          messages.push({
+            role: 'tool',
+            tool_call_id: toolCalls[i].id,
+            content: toolOutputs[i].output,
+          });
+        }
+        return messages;
+      }
+      messages.input = toolOutputs;
       return messages;
     }
     default:
@@ -829,7 +928,7 @@ export async function callLlmWithMessages(provider, model, apiKey, messagesOrWra
     };
   }
-  // Gemini and OpenAI use flat message arrays
+  // Gemini uses flat message arrays; OpenAI accepts either arrays or wrapper state.
   return callLlm(provider, model, apiKey, messagesOrWrapper, tools);
 }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@archal/cli",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Pre-deployment testing for AI agents",
   "type": "module",
   "main": "dist/index.js",