@golba98/codexa 1.0.2 → 1.0.4

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;
 }

package/src/core/providerRuntime/models.ts

@@ -73,16 +73,20 @@ export const GEMINI_FALLBACK_MODELS: readonly ProviderModel[] = [
   },
 ] as const;
 
+function fallbackModelDescription(family: string): string {
+  return `Claude ${family} alias — version unknown because model discovery is unavailable`;
+}
+
 export const ANTHROPIC_FALLBACK_MODELS: readonly ProviderModel[] = [
   {
     id: "opus",
     modelId: "opus",
-    label: "Opus 4.7",
-    description: "Claude Opus 4.7 - Fallback defaults",
+    label: "Claude Opus (version unknown)",
+    description: fallbackModelDescription("Opus"),
     defaultReasoningLevel: "xhigh",
     supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "xhigh", "max"]),
     source: "fallback",
-    canonicalId: "claude-opus-4-7",
+    canonicalId: "opus",
     family: "opus",
     effortSource: "fallback",
     effortVerified: false,
@@ -90,12 +94,12 @@ export const ANTHROPIC_FALLBACK_MODELS: readonly ProviderModel[] = [
   {
     id: "sonnet",
     modelId: "sonnet",
-    label: "Sonnet 4.6",
-    description: "Claude Sonnet 4.6 - Fallback defaults",
+    label: "Claude Sonnet (version unknown)",
+    description: fallbackModelDescription("Sonnet"),
     defaultReasoningLevel: "high",
     supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "max"]),
     source: "fallback",
-    canonicalId: "claude-sonnet-4-6",
+    canonicalId: "sonnet",
     family: "sonnet",
     effortSource: "fallback",
     effortVerified: false,
@@ -103,20 +107,27 @@ export const ANTHROPIC_FALLBACK_MODELS: readonly ProviderModel[] = [
   {
     id: "haiku",
     modelId: "haiku",
-    label: "Haiku 4.5",
-    description: "Claude Haiku 4.5 - Fallback defaults; effort metadata unverified",
+    label: "Claude Haiku (version unknown)",
+    description: fallbackModelDescription("Haiku"),
     defaultReasoningLevel: "medium",
     supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high"]),
     source: "fallback",
-    canonicalId: "claude-haiku-4-5",
+    canonicalId: "haiku",
     family: "haiku",
     effortSource: "fallback",
     effortVerified: false,
   },
-] as const;
+];
 
 function isRuntimeSource(source: ProviderModel["source"]): boolean {
-  return source === "discovered" || source === "claude-code" || source === "settings" || source === "config";
+  return source === "discovered"
+    || source === "claude-code"
+    || source === "claude-code-command"
+    || source === "claude-code-package"
+    || source === "claude-code-cache"
+    || source === "claude-code-config"
+    || source === "settings"
+    || source === "config";
 }
 
 export function providerModelsToCodexCapabilities(

package/src/core/providerRuntime/registry.ts

@@ -1,9 +1,10 @@
 import { codexSubprocessProvider } from "../providers/codexSubprocess.js";
 import type { BackendRunHandlers } from "../providers/types.js";
 import type { ProviderId, ProviderActiveRoute, ProviderWorkspaceOverride } from "../providerLauncher/types.js";
-import { anthropicRuntime } from "./anthropic.js";
-import { geminiRuntime } from "./gemini.js";
-import { localRuntime } from "./local.js";
+import { anthropicRuntime } from "./anthropic.js";
+import { geminiRuntime } from "./gemini.js";
+import { localRuntime } from "./local.js";
+import { antigravityRuntime, ANTIGRAVITY_DEFAULT_MODEL_ID, migrateAntigravityLegacyModelId } from "./antigravity.js";
 import {
   ANTHROPIC_FALLBACK_MODELS,
   GEMINI_DEFAULT_MODEL_ID,
@@ -71,10 +72,11 @@ function unavailableRuntime(providerId: ProviderId, label: string): ProviderRunt
 
 const PROVIDER_RUNTIMES: Record<ProviderId, ProviderRuntime> = {
   openai: openAiRuntime,
-  anthropic: anthropicRuntime,
-  google: geminiRuntime,
-  local: localRuntime,
-};
+  anthropic: anthropicRuntime,
+  google: geminiRuntime,
+  local: localRuntime,
+  antigravity: antigravityRuntime,
+};
 
 export function getProviderRuntime(providerId: ProviderId): ProviderRuntime {
   return PROVIDER_RUNTIMES[providerId];
@@ -100,11 +102,12 @@ export function discoverProviderModels(providerId: ProviderId): ProviderModelDis
 
 export async function validateProviderRouteActivation(options: {
   route: ProviderRoute;
-  workspaceRoot: string;
-  geminiCommandPath?: string | null;
-  claudeCommandPath?: string | null;
-  localConfig?: ProviderWorkspaceOverride | null;
-}): Promise<ProviderRouteValidationResult> {
+  workspaceRoot: string;
+  geminiCommandPath?: string | null;
+  claudeCommandPath?: string | null;
+  antigravityCommandPath?: string | null;
+  localConfig?: ProviderWorkspaceOverride | null;
+}): Promise<ProviderRouteValidationResult> {
   const runtime = getProviderRuntime(options.route.providerId);
   if (!runtime.routeAvailable) {
     return {
@@ -154,7 +157,7 @@ export function resolveActiveProviderRoute(options: {
   currentReasoning: string;
 }): ActiveProviderRoute {
   const configuredRoute = options.workspaceConfigActiveRoute;
-  if (configuredRoute && isProviderRoutableInCodexa(configuredRoute.providerId)) {
+  if (configuredRoute && configuredRoute.providerId !== "google" && isProviderRoutableInCodexa(configuredRoute.providerId)) {
     const route: ActiveProviderRoute = {
       providerId: configuredRoute.providerId,
       modelId: configuredRoute.modelId,
@@ -163,19 +166,36 @@ export function resolveActiveProviderRoute(options: {
       ...(configuredRoute.modelSelection ? { modelSelection: configuredRoute.modelSelection } : {}),
     };
 
-    if (route.providerId === "google" && route.modelSelection) {
-      route.modelId = resolveGeminiModelId(route.modelSelection);
-    } else if (route.providerId === "google") {
-      route.modelId = normalizeGeminiModelId(route.modelId);
-    } else if (route.providerId === "local") {
-      const discovery = discoverProviderModels("local");
-      const selectedModel = typeof discovery.diagnostics?.selectedModel === "string"
+    if (route.providerId === "google" && route.modelSelection) {
+      route.modelId = resolveGeminiModelId(route.modelSelection);
+    } else if (route.providerId === "google") {
+      route.modelId = normalizeGeminiModelId(route.modelId);
+    } else if (route.providerId === "anthropic") {
+      const discovery = discoverProviderModels("anthropic");
+      const stillAvailable = discovery.models.some((model) =>
+        model.modelId === route.modelId ||
+        model.id === route.modelId ||
+        model.canonicalId === route.modelId
+      );
+      const hasNonFallbackModels = discovery.models.some((model) => model.source !== "fallback");
+      if (discovery.status === "ready" && hasNonFallbackModels && discovery.models.length > 0 && !stillAvailable) {
+        route.modelId = discovery.models[0]!.modelId;
+      }
+    } else if (route.providerId === "local") {
+      const discovery = discoverProviderModels("local");
+      const selectedModel = typeof discovery.diagnostics?.selectedModel === "string"
         ? discovery.diagnostics.selectedModel.trim()
         : "";
-      if (discovery.status === "ready" && selectedModel) {
-        route.modelId = selectedModel;
-      }
-    }
+      if (discovery.status === "ready" && selectedModel) {
+        route.modelId = selectedModel;
+      }
+    } else if (route.providerId === "antigravity") {
+      const migrated = migrateAntigravityLegacyModelId(route.modelId);
+      route.modelId = migrated.modelId;
+      if (!route.reasoning && migrated.reasoning) {
+        route.reasoning = migrated.reasoning;
+      }
+    }
 
     return route;
   }
@@ -190,14 +210,21 @@ export function resolveActiveProviderRoute(options: {
 
 export function getDefaultRouteModel(providerId: ProviderId, currentOpenAiModel: string): string {
   if (providerId === "anthropic") {
-    return ANTHROPIC_FALLBACK_MODELS[0]?.modelId ?? "claude-sonnet-4-20250514";
+    const discovered = discoverProviderModels("anthropic");
+    if (discovered.status === "ready" && discovered.models.length > 0) {
+      return discovered.models[0].modelId;
+    }
+    return ANTHROPIC_FALLBACK_MODELS[0]?.modelId ?? "sonnet";
   }
   if (providerId === "google") {
     return GEMINI_FALLBACK_MODELS[0]?.modelId ?? GEMINI_DEFAULT_MODEL_ID;
   }
-  if (providerId === "local") {
-    const discovery = discoverProviderModels("local");
-    return discovery.models[0]?.modelId ?? "Local default";
-  }
-  return currentOpenAiModel;
-}
+  if (providerId === "local") {
+    const discovery = discoverProviderModels("local");
+    return discovery.models[0]?.modelId ?? "Local default";
+  }
+  if (providerId === "antigravity") {
+    return ANTIGRAVITY_DEFAULT_MODEL_ID;
+  }
+  return currentOpenAiModel;
+}

package/src/core/providerRuntime/types.ts

@@ -1,5 +1,5 @@
 import type { ReasoningEffortCapability } from "../models/codexModelCapabilities.js";
-import type { ProjectInstructions } from "../projectInstructions.js";
+import type { ProjectInstructions } from "../workspace/projectInstructions.js";
 import type { BackendRunHandlers } from "../providers/types.js";
 import type { ResolvedRuntimeConfig } from "../../config/runtimeConfig.js";
 export type { ResolvedRuntimeConfig };
@@ -7,10 +7,11 @@ import type { ProviderId } from "../providerLauncher/types.js";
 import type { ProviderWorkspaceOverride } from "../providerLauncher/types.js";
 
 export type ProviderBackendKind =
-  | "codex-cli-auth"
-  | "gemini-cli-auth"
-  | "claude-code-auth"
-  | "openai-api-key"
+  | "codex-cli-auth"
+  | "gemini-cli-auth"
+  | "claude-code-auth"
+  | "antigravity-cli-auth"
+  | "openai-api-key"
   | "gemini-api-key"
   | "anthropic-api-key"
   | "local-openai-compatible"
@@ -23,10 +24,13 @@ export interface ProviderModel {
   description: string | null;
   defaultReasoningLevel: string | null;
   supportedReasoningLevels: readonly ReasoningEffortCapability[] | null;
-  source?: "discovered" | "claude-code" | "settings" | "config" | "fallback";
-  canonicalId?: string;
-  family?: string;
-  effortSource?: "claude-code" | "settings" | "config" | "fallback";
+  source?: "discovered" | "claude-code" | "claude-code-command" | "claude-code-package" | "claude-code-cache" | "claude-code-config" | "settings" | "config" | "fallback";
+  canonicalId?: string;
+  family?: string;
+  version?: string;
+  isFallback?: boolean;
+  discoveryKind?: "models" | "aliases";
+  effortSource?: "claude-code" | "claude-code-command" | "claude-code-package" | "claude-code-cache" | "claude-code-config" | "settings" | "config" | "fallback";
   effortVerified?: boolean;
   raw?: unknown;
 }
@@ -58,11 +62,12 @@ export type ActiveProviderRoute = ProviderRoute;
 
 export interface ProviderRouteValidationRequest {
   route: ProviderRoute;
-  workspaceRoot: string;
-  geminiCommandPath?: string | null;
-  claudeCommandPath?: string | null;
-  localConfig?: ProviderWorkspaceOverride | null;
-}
+  workspaceRoot: string;
+  geminiCommandPath?: string | null;
+  claudeCommandPath?: string | null;
+  antigravityCommandPath?: string | null;
+  localConfig?: ProviderWorkspaceOverride | null;
+}
 
 export interface ProviderRouteValidationResult {
   status: "ready" | "not-configured";

package/src/core/providers/codexSubprocess.ts

@@ -1,8 +1,8 @@
 import { spawn } from "child_process";
 import { formatCodexLaunchError, spawnCodexProcess } from "../executables/codexExecutable.js";
-import { prepareCodexExecLaunch } from "../codexLaunch.js";
+import { prepareCodexExecLaunch } from "../codex/codexLaunch.js";
 import * as perf from "../perf/profiler.js";
-import { buildCodexPrompt } from "../codexPrompt.js";
+import { buildCodexPrompt } from "../codex/codexPrompt.js";
 import { createTerminalTitleSequenceStripper } from "../terminal/terminalTitle.js";
 import { createCodexJsonStreamParser } from "./codexJsonStream.js";
 import {

package/src/core/providers/types.ts

@@ -1,6 +1,6 @@
 import type { AvailableBackend } from "../../config/settings.js";
 import type { ResolvedRuntimeConfig } from "../../config/runtimeConfig.js";
-import type { ProjectInstructions } from "../projectInstructions.js";
+import type { ProjectInstructions } from "../workspace/projectInstructions.js";
 import type { RunProgressSource, RunToolActivity } from "../../session/types.js";
 
 export interface BackendProgressUpdate {

package/src/core/{attachments.ts → shared/attachments.ts}

@@ -1,5 +1,10 @@
-import { access, copyFile, mkdir } from "node:fs/promises";
+import { access, copyFile, mkdir, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import path from "node:path";
+import {
+  isSkippedExternalDependencyPath,
+  normalizeDiagnosticPath,
+} from "../workspace/workspaceGuard.js";
 
 export const IMAGE_EXTENSIONS = new Set([
   ".png",
@@ -44,10 +49,28 @@ export async function resolveAttachmentDestPath(
 export async function importExternalFile(
   srcPath: string,
   attachmentsDir: string,
-): Promise<string> {
+): Promise<string | null> {
+  const normalized = normalizeDiagnosticPath(srcPath);
+
+  if (isSkippedExternalDependencyPath(normalized)) {
+    return null;
+  }
+
+  try {
+    if (!existsSync(normalized)) {
+      return null;
+    }
+    const s = await stat(normalized);
+    if (!s.isFile()) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+
   await mkdir(attachmentsDir, { recursive: true });
-  const destPath = await resolveAttachmentDestPath(srcPath, attachmentsDir);
-  await copyFile(srcPath, destPath);
+  const destPath = await resolveAttachmentDestPath(normalized, attachmentsDir);
+  await copyFile(normalized, destPath);
   return destPath;
 }
 

package/src/core/{cleanupFastFail.ts → shared/cleanupFastFail.ts}

@@ -1,4 +1,4 @@
-import type { RunToolActivity } from "../session/types.js";
+import type { RunToolActivity } from "../../session/types.js";
 
 const DELETE_COMMAND_PATTERN =
   /(?:^|[\s;&|])(?:remove-item|rm|rmdir|del|erase|unlink)\b/i;

package/src/core/{hollowResponseFormat.ts → shared/hollowResponseFormat.ts}

@@ -1,4 +1,4 @@
-import type { HollowResponseResult } from "./codexPrompt.js";
+import type { HollowResponseResult } from "../codex/codexPrompt.js";
 
 const MESSAGES: Record<string, [string, string]> = {
   greeting: [