@golba98/codexa 1.0.3 → 1.0.5

package/src/core/providerRuntime/claudeCodeDiscoveryDebug.ts

@@ -0,0 +1,55 @@
+import { resolveClaudeExecutable } from "../executables/claudeExecutable.js";
+import { runCommand } from "../process/CommandRunner.js";
+import {
+  claudeCodeModelsToProviderModels,
+  discoverClaudeCodeCapabilities,
+  discoverModelsFromClaudePackageMetadata,
+} from "./claudeCodeDiscovery.js";
+
+async function main(): Promise<void> {
+  const cwd = process.cwd();
+  const resolvedCommand = await resolveClaudeExecutable({ cwd });
+  const versionResult = await runCommand({
+    executable: resolvedCommand,
+    args: ["--version"],
+    cwd,
+    timeoutMs: 5_000,
+  }).result;
+  const packageMetadata = discoverModelsFromClaudePackageMetadata(resolvedCommand);
+  const discovery = await discoverClaudeCodeCapabilities({ cwd });
+  const normalized = claudeCodeModelsToProviderModels(discovery.models);
+
+  const report = {
+    claudeCommand: resolvedCommand,
+    claudeBinaryPath: packageMetadata?.sourcePath ?? resolvedCommand,
+    claudeVersion: versionResult.status === "completed" && versionResult.exitCode === 0
+      ? versionResult.stdout.trim()
+      : null,
+    discoverySourceUsed: discovery.modelSource,
+    packageMetadataSource: packageMetadata?.sourcePath ?? null,
+    rawDiscoveredModelEntries: packageMetadata?.rawModelIds ?? [],
+    normalizedModelEntries: normalized.map((model) => ({
+      id: model.modelId,
+      label: model.label,
+      family: model.family,
+      version: model.version,
+      canonicalId: model.canonicalId,
+      source: model.source,
+      isFallback: model.isFallback,
+      discoveryKind: model.discoveryKind,
+    })),
+    fallbackReason: discovery.modelSource === "fallback"
+      ? discovery.diagnostics ?? { reason: "No Claude Code command, package metadata, settings, or config model source returned versioned models." }
+      : null,
+  };
+
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+}
+
+try {
+  await main();
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`debug:claude-models failed: ${message}\n`);
+  process.exit(1);
+}

package/src/core/providerRuntime/contextMetadata.ts

@@ -67,14 +67,9 @@ const KNOWN_CONTEXT_REGISTRY: Record<string, KnownContextRegistryEntry> = {
   // Exact documented Anthropic model IDs only. Provider aliases such as
   // "haiku" remain unknown unless configured or discovered by CLI metadata.
   // Source: https://docs.anthropic.com/en/docs/about-claude/models
-  "anthropic:claude-opus-4-7": {
-    contextLength: 200_000,
-    sourceUrl: "https://docs.anthropic.com/en/docs/about-claude/models",
-    note: "Anthropic documented context window for this exact model ID.",
-  },
-  "anthropic:claude-sonnet-4-6": {
-    contextLength: 200_000,
-    sourceUrl: "https://docs.anthropic.com/en/docs/about-claude/models",
+  "anthropic:claude-sonnet-4-6": {
+    contextLength: 200_000,
+    sourceUrl: "https://docs.anthropic.com/en/docs/about-claude/models",
     note: "Anthropic documented context window for this exact model ID.",
   },
   "anthropic:claude-haiku-4-5": {
@@ -149,16 +144,9 @@ const KNOWN_CONTEXT_REGISTRY: Record<string, KnownContextRegistryEntry> = {
   },
 };
 
-// Short alias IDs used by ANTHROPIC_FALLBACK_MODELS → canonical versioned IDs in the registry.
-const ANTHROPIC_MODEL_ALIAS_MAP: Record<string, string> = {
-  opus:   "claude-opus-4-7",
-  sonnet: "claude-sonnet-4-6",
-  haiku:  "claude-haiku-4-5",
-};
-
-// Normalise OpenAI/Codex model IDs to lowercase-dashed form before registry lookup.
-// Handles display-label variants like "GPT-5 Codex" → "gpt-5-codex".
-function normalizeOpenAIModelId(modelId: string): string {
+// Normalise OpenAI/Codex model IDs to lowercase-dashed form before registry lookup.
+// Handles display-label variants like "GPT-5 Codex" → "gpt-5-codex".
+function normalizeOpenAIModelId(modelId: string): string {
   return modelId.toLowerCase().replace(/\s+/g, "-");
 }
 
@@ -333,12 +321,12 @@ function resolveFromConfig(
   };
 }
 
-function resolveFromKnownRegistry(providerId: ProviderId, modelId: string): ModelContextMetadata | null {
-  const lookupId = providerId === "anthropic"
-    ? (ANTHROPIC_MODEL_ALIAS_MAP[modelId] ?? modelId)
-    : providerId === "openai"
-      ? normalizeOpenAIModelId(modelId)
-      : modelId;
+function resolveFromKnownRegistry(providerId: ProviderId, modelId: string): ModelContextMetadata | null {
+  const lookupId = providerId === "anthropic"
+    ? modelId
+    : providerId === "openai"
+      ? normalizeOpenAIModelId(modelId)
+      : modelId;
   const entry = KNOWN_CONTEXT_REGISTRY[`${providerId}:${lookupId}`];
   if (!entry) return null;
   return {

package/src/core/providerRuntime/local.ts

@@ -1,4 +1,6 @@
 import { sanitizeTerminalOutput } from "../terminal/terminalSanitize.js";
+import { runAgentLoop, type AgentChatMessage, type AgentChatResponse } from "../agent/loop.js";
+import { parseOpenAiToolCalls } from "../agent/protocol.js";
 import type { BackendRunHandlers } from "../providers/types.js";
 import type { ProviderWorkspaceOverride } from "../providerLauncher/types.js";
 import type {
@@ -456,21 +458,110 @@ function getCachedSelectedModel(config: LocalProviderConfig, routeModel: string)
   return selectFallbackLocalModel(config, discoveredIds) ?? routeModel;
 }
 
-function extractNonStreamingText(body: unknown): string {
-  if (typeof body !== "object" || body === null) return "";
-  const choices = (body as { choices?: unknown }).choices;
-  if (!Array.isArray(choices)) return "";
-  return choices
-    .map((choice) => {
-      if (typeof choice !== "object" || choice === null) return "";
-      const message = (choice as { message?: { content?: unknown }; text?: unknown }).message;
-      if (typeof message?.content === "string") return message.content;
-      const text = (choice as { text?: unknown }).text;
-      return typeof text === "string" ? text : "";
-    })
-    .join("")
-    .trim();
-}
+interface LocalResponseDiagnostics {
+  choiceCount: number;
+  finishReasons: string[];
+  recognizedFields: string[];
+  topLevelKeys: string[];
+}
+
+interface ExtractedLocalResponse extends AgentChatResponse {
+  diagnostics: LocalResponseDiagnostics;
+}
+
+function textFromContent(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(textFromContent).join("");
+  if (!isRecord(value)) return "";
+
+  // OpenAI-compatible servers commonly emit content as typed parts, such as
+  // { type: "text", text: "..." } or { type: "output_text", text: "..." }.
+  if (typeof value.text === "string") return value.text;
+  if (typeof value.content === "string" || Array.isArray(value.content)) {
+    return textFromContent(value.content);
+  }
+  if ((value.type === "text" || value.type === "output_text") && typeof value.value === "string") {
+    return value.value;
+  }
+  return "";
+}
+
+function messageFieldText(message: Record<string, unknown>, fields: readonly string[], recognizedFields: Set<string>): string {
+  for (const field of fields) {
+    const text = textFromContent(message[field]);
+    if (text.trim()) {
+      recognizedFields.add(`message.${field}`);
+      return text;
+    }
+  }
+  return "";
+}
+
+function extractNonStreamingResponse(body: unknown): ExtractedLocalResponse {
+  const topLevelKeys = isRecord(body) ? Object.keys(body).sort() : [];
+  const choices = isRecord(body) && Array.isArray(body.choices) ? body.choices : [];
+  const recognizedFields = new Set<string>();
+  const finishReasons: string[] = [];
+  const toolCalls = choices.flatMap((choice) => {
+    if (!isRecord(choice)) return [];
+    if (typeof choice.finish_reason === "string") finishReasons.push(choice.finish_reason);
+    const message = isRecord(choice.message) ? choice.message : null;
+    return message ? parseOpenAiToolCalls(message.tool_calls) : [];
+  });
+
+  const content: string[] = [];
+  const reasoning: string[] = [];
+  for (const choice of choices) {
+    if (!isRecord(choice)) continue;
+    const message = isRecord(choice.message) ? choice.message : null;
+    const messageContent = message
+      ? messageFieldText(message, ["content"], recognizedFields)
+      : "";
+    const legacyText = textFromContent(choice.text);
+    if (legacyText.trim()) recognizedFields.add("choice.text");
+    const answer = messageContent || legacyText;
+    if (answer.trim()) {
+      content.push(answer);
+      continue;
+    }
+
+    const reasoningText = message
+      ? messageFieldText(message, ["reasoning_content", "reasoning", "analysis"], recognizedFields)
+      : "";
+    const choiceReasoning = !reasoningText
+      ? messageFieldText(choice, ["reasoning_content", "reasoning", "analysis"], recognizedFields)
+      : "";
+    if ((reasoningText || choiceReasoning).trim()) {
+      reasoning.push(reasoningText || choiceReasoning);
+    }
+  }
+
+  return {
+    // Reasoning is a fallback only. A response with both fields should show its
+    // final answer, while reasoning-only servers still produce useful text.
+    text: (content.length > 0 ? content : reasoning).join("").trim(),
+    ...(toolCalls.length > 0 ? { toolCalls } : {}),
+    diagnostics: {
+      choiceCount: choices.length,
+      finishReasons: [...new Set(finishReasons)],
+      recognizedFields: [...recognizedFields].sort(),
+      topLevelKeys,
+    },
+  };
+}
+
+function emptyResponseError(config: LocalProviderConfig, model: string, diagnostics: LocalResponseDiagnostics): Error {
+  const finishReasons = diagnostics.finishReasons.length > 0 ? diagnostics.finishReasons.join(", ") : "none";
+  const fields = diagnostics.recognizedFields.length > 0 ? diagnostics.recognizedFields.join(", ") : "none";
+  const keys = diagnostics.topLevelKeys.length > 0 ? diagnostics.topLevelKeys.join(", ") : "none";
+  return new Error([
+    "Local OpenAI-compatible API returned no assistant text.",
+    `Endpoint: ${config.baseUrl}/chat/completions`,
+    `Model: ${model}`,
+    `Response details: choices=${diagnostics.choiceCount}; finish_reason=${finishReasons}; recognized_fields=${fields}; top_level_keys=${keys}.`,
+    "Check the local server response format or retry the prompt.",
+  ].join("\n"));
+}
 
 function parseStreamDelta(line: string): string | null {
   const trimmed = line.trim();
@@ -521,18 +612,19 @@ async function postLocalChatCompletion(options: {
   request: ProviderChatRequest;
   config: LocalProviderConfig;
   stream: boolean;
+  messages?: readonly AgentChatMessage[];
   fetchImpl: FetchImpl;
   signal?: AbortSignal;
   handlers: BackendRunHandlers;
   capProfile: import("./capabilityProfile.js").ModelCapabilityProfile;
-}): Promise<string> {
+}): Promise<AgentChatResponse> {
   const model = getCachedSelectedModel(options.config, options.request.route.modelId);
   const includeSystemPrompt = options.capProfile.supportsSystemPrompt !== false;
-  const messages = [
+  const messages: readonly AgentChatMessage[] = options.messages ?? [
     ...(includeSystemPrompt && options.request.projectInstructions?.content
-      ? [{ role: "system", content: options.request.projectInstructions.content }]
+      ? [{ role: "system" as const, content: options.request.projectInstructions.content }]
       : []),
-    { role: "user", content: options.request.prompt },
+    { role: "user" as const, content: options.request.prompt },
   ];
   const response = await options.fetchImpl(`${options.config.baseUrl}/chat/completions`, {
     method: "POST",
@@ -560,11 +652,15 @@ async function postLocalChatCompletion(options: {
   }
 
   if (options.stream) {
-    return readStreamingResponse(response, options.handlers);
+    return { text: await readStreamingResponse(response, options.handlers) };
   }
 
-  const parsed = JSON.parse(await response.text()) as unknown;
-  return extractNonStreamingText(parsed);
+  const parsed = JSON.parse(await response.text()) as unknown;
+  const extracted = extractNonStreamingResponse(parsed);
+  if (!extracted.text.trim() && (extracted.toolCalls?.length ?? 0) === 0) {
+    throw emptyResponseError(options.config, model, extracted.diagnostics);
+  }
+  return extracted;
 }
 
 function isModelNotLoadedError(status: number, body: string): boolean {
@@ -589,42 +685,24 @@ export async function runLocalOpenAiCompatible(
     providerConfig: request.localConfig ?? configuredOverride,
     rawMetadata: rawMeta,
   });
-  const streamingSupported = capProfile.supportsStreaming !== false;
-
-  if (streamingSupported) {
-    try {
-      const streamed = await postLocalChatCompletion({
+  const text = await runAgentLoop({
+    request,
+    handlers,
+    includeSystemPrompt: capProfile.supportsSystemPrompt !== false,
+    signal: options.signal,
+    sendMessages: async (messages) =>
+      postLocalChatCompletion({
         request,
         config,
-        stream: true,
+        messages,
+        stream: false,
         fetchImpl,
         signal: options.signal,
         handlers,
         capProfile,
-      });
-      if (streamed) return streamed;
-    } catch (error) {
-      if (options.signal?.aborted) throw error;
-      handlers.onProgress?.({
-        id: "local-stream-fallback",
-        source: "stderr",
-        text: "Local streaming request failed; retrying without streaming.",
-      });
-    }
-  }
-
-  const text = await postLocalChatCompletion({
-    request,
-    config,
-    stream: false,
-    fetchImpl,
-    signal: options.signal,
-    handlers,
-    capProfile,
+      }),
   });
-  if (!text) {
-    throw new Error("Local OpenAI-compatible API returned no assistant text.");
-  }
+  if (!text) throw new Error("Local OpenAI-compatible API returned no assistant text after tool execution.");
   handlers.onAssistantDelta?.(text);
   return text;
 }