(fix) responses-api support in dreamer/normalizer layers

Author: mmethodz

.gitignore

@@ -34,6 +34,9 @@ Thumbs.db
 # VS Code extension build artifacts
 *.vsix
 
+# Buildinfo files
+*.tsbuildinfo
+
 plans/
 plans/DREAMGRAPH EVENTS AND HOOKS.txt
 plans/DG - THE DREAMGRAPH CLI.txt

extensions/vscode/src/architect-llm.ts

@@ -9,11 +9,12 @@ import * as vscode from "vscode";
 import {
   buildOpenAIResponsesRequest,
   extractOpenAIResponsesRawItems,
-  extractOpenAIResponsesText,
   extractOpenAIResponsesToolCalls,
+  normalizeOpenAIResponsesResult,
   toOpenAIResponsesContent,
   translateRawToOpenAIResponses,
   usesOpenAIResponsesApi,
+  type OpenAIResponsesData,
 } from "./openai-responses-adapter";
 import {
   applySharedRequestCompaction,
@@ -791,17 +792,6 @@ export class ArchitectLlm implements vscode.Disposable {
     return projection ? projection.legacyContent : content;
   }
 
-    private _extractOpenAIResponsesText(data: {
-    output_text?: string;
-    output?: Array<Record<string, unknown>>;
-  }): string {
-    return extractOpenAIResponsesText(data);
-  }
-
-    private _extractOpenAIResponsesToolCalls(data: { output?: Array<Record<string, unknown>> }): ToolUseRequest[] {
-    return extractOpenAIResponsesToolCalls(data);
-  }
-
   private async _callOpenAIResponses(
     config: ArchitectConfig,
     messages: ArchitectMessage[],
@@ -821,16 +811,13 @@ export class ArchitectLlm implements vscode.Disposable {
 
     if (!res.ok) throw new Error(`OpenAI Responses API error (${res.status}): ${await res.text()}`);
 
-    const data = (await res.json()) as {
-      output_text?: string;
-      output?: Array<Record<string, unknown>>;
-      usage?: { input_tokens?: number; output_tokens?: number };
-    };
+    const data = (await res.json()) as OpenAIResponsesData;
+    const result = normalizeOpenAIResponsesResult(data);
 
     return {
-      content: this._maybeProjectStructuredContent(config, this._extractOpenAIResponsesText(data)),
-      promptTokens: data.usage?.input_tokens ?? 0,
-      completionTokens: data.usage?.output_tokens ?? 0,
+      content: this._maybeProjectStructuredContent(config, result.text),
+      promptTokens: result.usage?.input_tokens ?? 0,
+      completionTokens: result.usage?.output_tokens ?? 0,
       durationMs: Date.now() - start,
     };
   }
@@ -856,28 +843,19 @@ export class ArchitectLlm implements vscode.Disposable {
 
     if (!res.ok) throw new Error(`OpenAI Responses API error (${res.status}): ${await res.text()}`);
 
-    const data = (await res.json()) as {
-      output_text?: string;
-      output?: Array<Record<string, unknown>>;
-      usage?: { input_tokens?: number; output_tokens?: number };
-      status?: string;
-      incomplete_details?: { reason?: string };
-    };
-    const toolCalls = this._extractOpenAIResponsesToolCalls(data);
+    const data = (await res.json()) as OpenAIResponsesData;
+    const result = normalizeOpenAIResponsesResult(data);
+    const toolCalls = extractOpenAIResponsesToolCalls(data);
 
     return {
-      content: this._maybeProjectStructuredContent(config, this._extractOpenAIResponsesText(data)),
-      promptTokens: data.usage?.input_tokens ?? 0,
-      completionTokens: data.usage?.output_tokens ?? 0,
+      content: this._maybeProjectStructuredContent(config, result.text),
+      promptTokens: result.usage?.input_tokens ?? 0,
+      completionTokens: result.usage?.output_tokens ?? 0,
       durationMs: Date.now() - start,
       toolCalls,
       // Verbatim output[] items (incl. reasoning) for stateless replay.
       providerRawAssistant: extractOpenAIResponsesRawItems(data),
-      stopReason: toolCalls.length > 0
-        ? "tool_use"
-        : data.incomplete_details?.reason === "max_output_tokens"
-          ? "max_tokens"
-          : data.status ?? "end_turn",
+      stopReason: result.finishReason ?? "end_turn",
     };
   }
 

extensions/vscode/src/openai-responses-adapter.ts

@@ -30,9 +30,24 @@ export interface OpenAIResponsesOptions {
   structuredOutput?: boolean;
 }
 
+export interface OpenAIResponsesUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+}
+
 export interface OpenAIResponsesData {
   output_text?: string;
   output?: Array<Record<string, unknown>>;
+  usage?: OpenAIResponsesUsage;
+  status?: string;
+  incomplete_details?: { reason?: string };
+}
+
+export interface OpenAIResponsesResult {
+  text: string;
+  finishReason?: string;
+  usage?: OpenAIResponsesUsage;
 }
 
 type ArchitectMessageContent = ArchitectMessage["content"];
@@ -312,6 +327,22 @@ export function extractOpenAIResponsesText(data: OpenAIResponsesData): string {
   return out;
 }
 
+export function normalizeOpenAIResponsesResult(data: OpenAIResponsesData): OpenAIResponsesResult {
+  const text = extractOpenAIResponsesText(data);
+  const toolCalls = extractOpenAIResponsesToolCalls(data);
+  const finishReason = toolCalls.length > 0
+    ? "tool_use"
+    : data.incomplete_details?.reason === "max_output_tokens"
+      ? "max_tokens"
+      : data.status;
+
+  return {
+    text,
+    finishReason,
+    usage: data.usage,
+  };
+}
+
 export function extractOpenAIResponsesToolCalls(data: OpenAIResponsesData): ToolUseRequest[] {
   const toolCalls: ToolUseRequest[] = [];
 

extensions/vscode/src/test/openai-responses-adapter.test.ts

@@ -4,6 +4,7 @@ import {
   buildOpenAIResponsesRequest,
   extractOpenAIResponsesText,
   extractOpenAIResponsesToolCalls,
+  normalizeOpenAIResponsesResult,
   translateRawToOpenAIResponses,
   usesOpenAIResponsesApi,
 } from '../openai-responses-adapter';
@@ -166,6 +167,40 @@ test('keeps streamed sub-blocks within a single message tightly joined', () => {
   assert.equal(text, 'Step 1: reading file.');
 });
 
+test('normalizes Responses output to the provider boundary contract', () => {
+  const result = normalizeOpenAIResponsesResult({
+    output: [
+      {
+        type: 'message',
+        content: [{ type: 'output_text', text: 'Done.' }],
+      },
+    ],
+    status: 'completed',
+    usage: { input_tokens: 10, output_tokens: 4, total_tokens: 14 },
+  });
+
+  assert.deepEqual(result, {
+    text: 'Done.',
+    finishReason: 'completed',
+    usage: { input_tokens: 10, output_tokens: 4, total_tokens: 14 },
+  });
+});
+
+test('normalizes Responses tool calls as tool_use finish reason', () => {
+  const result = normalizeOpenAIResponsesResult({
+    output: [
+      { type: 'function_call', call_id: 'call_valid', name: 'read_source_code', arguments: '{"filePath":"src/a.ts"}' },
+    ],
+    status: 'completed',
+  });
+
+  assert.deepEqual(result, {
+    text: '',
+    finishReason: 'tool_use',
+    usage: undefined,
+  });
+});
+
 test('extracts function calls and hardens malformed or unknown items', () => {
   const calls = extractOpenAIResponsesToolCalls({
     output: [

src/architect/native-tool-loop.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage } from "node:http";
 import type { ArchitectLlmConfig, LlmMessage, LlmProvider } from "../cognitive/llm.js";
+import { getModelCapabilities } from "../cognitive/llm.js";
 import { mcpCallTool, mcpListTools, type McpCallResult } from "../cli/utils/mcp-call.js";
 import { logger } from "../utils/logger.js";
 
@@ -330,11 +331,12 @@ async function callOpenAiCompatibleWithTools(
   messages: NeutralMessage[],
   tools: ArchitectToolDefinition[],
 ): Promise<ToolLoopResponse> {
-  const useNewTokenParam = /^(o[1-9]|gpt-[4-9]\.[1-9]|gpt-5)/.test(config.model);
+  const capabilities = getModelCapabilities(config.provider, config.model);
+  const useNewTokenParam = /^(o[1-9]|gpt-[4-9]\.[1-9]|gpt-5)/i.test(config.model);
   const body: Record<string, unknown> = {
     model: config.model,
     messages: toOpenAiMessages(messages),
-    temperature: config.temperature,
+    ...(capabilities.supportsTemperature ? { temperature: config.temperature } : {}),
     ...(useNewTokenParam
       ? { max_completion_tokens: config.maxTokens }
       : { max_tokens: config.maxTokens }),

src/cognitive/llm.ts

@@ -66,13 +66,35 @@ export interface LlmMessage {
   content: string;
 }
 
-export interface LlmResponse {
+export interface TokenUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+
+export interface LlmResult {
   text: string;
+  finishReason?: string;
+  usage?: TokenUsage;
+}
+
+export interface LlmResponse extends LlmResult {
   model: string;
   tokensUsed?: number;
   stopReason?: string;
 }
 
+export type LlmModelApi = "chat-completions" | "responses" | "anthropic-messages" | "ollama-chat" | "mcp-sampling" | "none";
+
+export interface ModelCapabilities {
+  model: string;
+  api: LlmModelApi;
+  supportsTemperature: boolean;
+  supportsReasoningEffort: boolean;
+  supportsStructuredOutputs: boolean;
+  supportsJsonSchema: boolean;
+}
+
 /**
  * Options for LLM completion requests.
  *
@@ -256,6 +278,85 @@ class OllamaProvider implements LlmProvider {
  */
 const _jsonSchemaUnsupported = new Set<string>();
 
+const OPENAI_MODEL_CAPABILITIES: Array<{ pattern: RegExp; capabilities: Omit<ModelCapabilities, "model"> }> = [
+  {
+    pattern: /^gpt-5\.5(?:\b|[-_])/i,
+    capabilities: {
+      api: "responses",
+      supportsTemperature: false,
+      supportsReasoningEffort: true,
+      supportsStructuredOutputs: true,
+      supportsJsonSchema: true,
+    },
+  },
+  {
+    pattern: /^gpt-[4-9]\.[1-9]/i,
+    capabilities: {
+      api: "chat-completions",
+      supportsTemperature: true,
+      supportsReasoningEffort: false,
+      supportsStructuredOutputs: true,
+      supportsJsonSchema: true,
+    },
+  },
+  {
+    pattern: /^(o[1-9]|gpt-5(?:\b|[-_]))/i,
+    capabilities: {
+      api: "chat-completions",
+      supportsTemperature: false,
+      supportsReasoningEffort: true,
+      supportsStructuredOutputs: true,
+      supportsJsonSchema: true,
+    },
+  },
+];
+
+export function getModelCapabilities(provider: LlmProviderType | string, model: string): ModelCapabilities {
+  const normalizedProvider = provider.toLowerCase();
+  const normalizedModel = model.trim();
+  if (normalizedProvider === "openai") {
+    const match = OPENAI_MODEL_CAPABILITIES.find((entry) => entry.pattern.test(normalizedModel));
+    return {
+      model: normalizedModel,
+      ...(match?.capabilities ?? {
+        api: "chat-completions" as const,
+        supportsTemperature: true,
+        supportsReasoningEffort: false,
+        supportsStructuredOutputs: true,
+        supportsJsonSchema: true,
+      }),
+    };
+  }
+  if (normalizedProvider === "anthropic") {
+    return {
+      model: normalizedModel,
+      api: "anthropic-messages",
+      supportsTemperature: true,
+      supportsReasoningEffort: false,
+      supportsStructuredOutputs: false,
+      supportsJsonSchema: false,
+    };
+  }
+  if (normalizedProvider === "ollama" || normalizedProvider === "lmstudio") {
+    return {
+      model: normalizedModel,
+      api: normalizedProvider === "ollama" ? "ollama-chat" : "chat-completions",
+      supportsTemperature: true,
+      supportsReasoningEffort: false,
+      supportsStructuredOutputs: false,
+      supportsJsonSchema: false,
+    };
+  }
+  return {
+    model: normalizedModel,
+    api: normalizedProvider === "sampling" ? "mcp-sampling" : "none",
+    supportsTemperature: false,
+    supportsReasoningEffort: false,
+    supportsStructuredOutputs: false,
+    supportsJsonSchema: false,
+  };
+}
+
 /** Heuristic: error body indicates the strict json_schema form is unsupported. */
 function _isJsonSchemaUnsupportedError(status: number, body: string): boolean {
   if (status < 400 || status >= 500) return false;
@@ -303,10 +404,11 @@ class OpenAiCompatibleProvider implements LlmProvider {
     const temp = options?.temperature ?? this.defaultTemperature;
     const maxTokens = options?.maxTokens ?? this.defaultMaxTokens;
     const model = options?.model ?? this.model;
+    const capabilities = getModelCapabilities(this.name, model);
 
     // Newer OpenAI models (o1/o3/o4-mini, gpt-4.1, gpt-5.4-nano, etc.) require
     // "max_completion_tokens" instead of the legacy "max_tokens" parameter.
-    const useNewTokenParam = /^(o[1-9]|gpt-[4-9]\.[1-9]|gpt-5)/.test(model);
+    const useNewTokenParam = /^(o[1-9]|gpt-[4-9]\.[1-9]|gpt-5)/i.test(model);
 
     const downgradeKey = `${this.name}:${model}`;
     const knownUnsupported = _jsonSchemaUnsupported.has(downgradeKey);
@@ -315,7 +417,7 @@ class OpenAiCompatibleProvider implements LlmProvider {
       const body: Record<string, unknown> = {
         model,
         messages: messages.map(m => ({ role: m.role, content: m.content })),
-        temperature: temp,
+        ...(capabilities.supportsTemperature ? { temperature: temp } : {}),
         ...(useNewTokenParam
           ? { max_completion_tokens: maxTokens }
           : { max_tokens: maxTokens }),
@@ -385,11 +487,16 @@ class OpenAiCompatibleProvider implements LlmProvider {
     };
 
     const choice = data.choices?.[0];
+    const usage: TokenUsage | undefined = data.usage?.completion_tokens === undefined
+      ? undefined
+      : { outputTokens: data.usage.completion_tokens };
     return {
       text: choice?.message?.content ?? "",
       model: data.model ?? this.model,
-      tokensUsed: data.usage?.completion_tokens,
+      tokensUsed: usage?.outputTokens,
       stopReason: choice?.finish_reason,
+      finishReason: choice?.finish_reason,
+      usage,
     };
   }
 }