ampcode-connector 0.1.12 → 0.1.14

package/README.md

@@ -10,6 +10,8 @@ bunx ampcode-connector          # start
 
 Requires [Bun](https://bun.sh) 1.3+. Config at `./config.yaml` or `~/.config/ampcode-connector/config.yaml` — see [`config.example.yaml`](config.example.yaml).
 
+`setup` writes `amp.url` to Amp's canonical settings file (`~/.config/amp/settings.json`, or `AMP_SETTINGS_FILE` if set). Amp tokens are stored in `~/.local/share/amp/secrets.json`.
+
 ## License
 
 [MIT](LICENSE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Proxy AmpCode through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
   "license": "MIT",
   "repository": {

package/src/cli/setup.ts

@@ -1,6 +1,6 @@
 /** Auto-configure Amp CLI to route through ampcode-connector. */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { loadConfig } from "../config/config.ts";
@@ -10,14 +10,26 @@ import * as status from "./status.ts";
 const AMP_SECRETS_DIR = join(homedir(), ".local", "share", "amp");
 const AMP_SECRETS_PATH = join(AMP_SECRETS_DIR, "secrets.json");
 
-const AMP_SETTINGS_PATHS = [
-  join(homedir(), ".config", "amp", "settings.json"),
-  join(homedir(), ".amp", "settings.json"),
-];
+const AMP_SETTINGS_PATH = join(homedir(), ".config", "amp", "settings.json");
+const AMP_LEGACY_SETTINGS_PATH = join(homedir(), ".amp", "settings.json");
 
-function ampSettingsPaths(): string[] {
+function ampSettingsPath(): string {
   const envPath = process.env.AMP_SETTINGS_FILE;
-  return envPath ? [envPath] : AMP_SETTINGS_PATHS;
+  return envPath || AMP_SETTINGS_PATH;
+}
+
+function warnLegacySettingsFile(): void {
+  if (process.env.AMP_SETTINGS_FILE || !existsSync(AMP_LEGACY_SETTINGS_PATH)) return;
+  try {
+    if (lstatSync(AMP_LEGACY_SETTINGS_PATH).isSymbolicLink()) return;
+  } catch {
+    return;
+  }
+
+  line(
+    `${s.yellow}!${s.reset} Legacy settings file detected at ${s.dim}${AMP_LEGACY_SETTINGS_PATH}${s.reset}. ` +
+      `Prefer a single source of truth at ${s.dim}${AMP_SETTINGS_PATH}${s.reset}.`,
+  );
 }
 
 function readJson(path: string): Record<string, unknown> {
@@ -88,14 +100,15 @@ export async function setup(): Promise<void> {
   line(`${s.bold}ampcode-connector setup${s.reset}`);
   line();
 
-  // Step 1: Configure amp.url in all settings files
-  for (const settingsPath of ampSettingsPaths()) {
-    const settings = readJson(settingsPath);
-    if (settings["amp.url"] === proxyUrl) continue;
+  // Step 1: Configure amp.url in canonical settings file
+  const settingsPath = ampSettingsPath();
+  const settings = readJson(settingsPath);
+  if (settings["amp.url"] !== proxyUrl) {
     settings["amp.url"] = proxyUrl;
     writeJson(settingsPath, settings);
   }
-  line(`${s.green}ok${s.reset} amp.url = ${s.cyan}${proxyUrl}${s.reset}`);
+  line(`${s.green}ok${s.reset} amp.url = ${s.cyan}${proxyUrl}${s.reset}  ${s.dim}${settingsPath}${s.reset}`);
+  warnLegacySettingsFile();
 
   // Step 2: Amp API key
   const existingKey = findAmpApiKey(proxyUrl);

package/src/providers/codex-sse.ts

@@ -23,6 +23,7 @@ interface Choice {
 interface Delta {
   role?: string;
   content?: string;
+  reasoning_content?: string;
   tool_calls?: ToolCallDelta[];
 }
 
@@ -38,6 +39,7 @@ interface Usage {
   completion_tokens: number;
   total_tokens: number;
   prompt_tokens_details?: { cached_tokens: number };
+  completion_tokens_details?: { reasoning_tokens: number };
 }
 
 interface TransformState {
@@ -128,10 +130,24 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
         return serializeFinish(state, finishReason, usage);
       }
 
-      // Reasoning/thinking delta — emit as content (Amp shows thinking)
+      // Response incomplete — emit finish_reason "length" + usage
+      case "response.incomplete": {
+        const resp = parsed.response as Record<string, unknown>;
+        const usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+        return serializeFinish(state, "length", usage);
+      }
+
+      // Response failed — emit finish_reason "stop" (error)
+      case "response.failed": {
+        const resp = parsed.response as Record<string, unknown>;
+        const usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+        return serializeFinish(state, "stop", usage);
+      }
+
+      // Reasoning/thinking delta — emit as reasoning_content (separate from content)
       case "response.reasoning_summary_text.delta": {
         const delta = parsed.delta as string;
-        if (delta) return serialize(state, { content: delta });
+        if (delta) return serialize(state, { reasoning_content: delta });
         return "";
       }
 
@@ -180,11 +196,13 @@ function extractUsage(raw: Record<string, unknown> | undefined): Usage | undefin
   const input = (raw.input_tokens as number) ?? 0;
   const output = (raw.output_tokens as number) ?? 0;
   const cached = (raw.input_tokens_details as Record<string, unknown>)?.cached_tokens as number | undefined;
+  const reasoning = (raw.output_tokens_details as Record<string, unknown>)?.reasoning_tokens as number | undefined;
   return {
     prompt_tokens: input,
     completion_tokens: output,
     total_tokens: input + output,
     ...(cached !== undefined ? { prompt_tokens_details: { cached_tokens: cached } } : {}),
+    ...(reasoning !== undefined ? { completion_tokens_details: { reasoning_tokens: reasoning } } : {}),
   };
 }
 
@@ -206,6 +224,161 @@ export function transformCodexResponse(response: Response, ampModel: string): Re
   });
 }
 
+/** Buffer a Codex SSE response into a single Chat Completions JSON response.
+ *  Used when the client requests stream: false but the backend forces streaming. */
+export async function bufferCodexResponse(response: Response, ampModel: string): Promise<Response> {
+  if (!response.body) return response;
+
+  const state: TransformState = {
+    responseId: "",
+    model: ampModel,
+    created: Math.floor(Date.now() / 1000),
+    toolCallIndex: 0,
+    toolCallIds: new Map(),
+  };
+
+  let content = "";
+  let reasoningContent = "";
+  const toolCalls: Map<number, { id: string; type: string; function: { name: string; arguments: string } }> = new Map();
+  let finishReason = "stop";
+  let usage: Usage | undefined;
+
+  const decoder = new TextDecoder();
+  let sseBuffer = "";
+
+  const reader = response.body.getReader();
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    sseBuffer += decoder.decode(value, { stream: true }).replaceAll("\r\n", "\n");
+    const boundary = sseBuffer.lastIndexOf("\n\n");
+    if (boundary === -1) continue;
+
+    const complete = sseBuffer.slice(0, boundary + 2);
+    sseBuffer = sseBuffer.slice(boundary + 2);
+
+    for (const chunk of sse.parse(complete)) {
+      if (chunk.data === "[DONE]") continue;
+
+      let parsed: Record<string, unknown>;
+      try {
+        parsed = JSON.parse(chunk.data) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+
+      const eventType = parsed.type as string | undefined;
+      if (!eventType) continue;
+
+      if (eventType === "response.created") {
+        const resp = parsed.response as Record<string, unknown>;
+        state.responseId = (resp?.id as string) ?? state.responseId;
+        state.created = (resp?.created_at as number) ?? state.created;
+        continue;
+      }
+
+      switch (eventType) {
+        case "response.output_text.delta": {
+          const delta = parsed.delta as string;
+          if (delta) content += delta;
+          break;
+        }
+
+        case "response.reasoning_summary_text.delta": {
+          const delta = parsed.delta as string;
+          if (delta) reasoningContent += delta;
+          break;
+        }
+
+        case "response.output_item.added": {
+          const item = parsed.item as Record<string, unknown>;
+          if (item?.type === "function_call") {
+            const callId = item.call_id as string;
+            const name = item.name as string;
+            const idx = state.toolCallIndex++;
+            state.toolCallIds.set(callId, idx);
+            toolCalls.set(idx, { id: callId, type: "function", function: { name, arguments: "" } });
+          }
+          break;
+        }
+
+        case "response.function_call_arguments.delta": {
+          const delta = parsed.delta as string;
+          const callId = parsed.call_id as string | undefined;
+          if (delta) {
+            const idx = callId ? (state.toolCallIds.get(callId) ?? 0) : 0;
+            const tc = toolCalls.get(idx);
+            if (tc) tc.function.arguments += delta;
+          }
+          break;
+        }
+
+        case "response.completed": {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          finishReason = state.toolCallIndex > 0 ? "tool_calls" : "stop";
+          break;
+        }
+
+        case "response.incomplete": {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          finishReason = "length";
+          break;
+        }
+
+        case "response.failed": {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          break;
+        }
+      }
+    }
+  }
+
+  // Process remaining buffer
+  if (sseBuffer.trim()) {
+    for (const chunk of sse.parse(sseBuffer)) {
+      if (chunk.data === "[DONE]") continue;
+      try {
+        const parsed = JSON.parse(chunk.data) as Record<string, unknown>;
+        if (parsed.type === "response.completed") {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          finishReason = state.toolCallIndex > 0 ? "tool_calls" : "stop";
+        }
+      } catch {
+        // skip
+      }
+    }
+  }
+
+  const message: Record<string, unknown> = { role: "assistant", content: content || null };
+  if (reasoningContent) {
+    message.reasoning_content = reasoningContent;
+  }
+  if (toolCalls.size > 0) {
+    message.tool_calls = Array.from(toolCalls.entries())
+      .sort(([a], [b]) => a - b)
+      .map(([, tc]) => tc);
+  }
+
+  const result = {
+    id: `chatcmpl-${state.responseId}`,
+    object: "chat.completion",
+    created: state.created,
+    model: state.model,
+    choices: [{ index: 0, message, finish_reason: finishReason }],
+    ...(usage ? { usage } : {}),
+  };
+
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
 /** Custom SSE transform that strips event names (Chat Completions doesn't use them). */
 function transformStream(source: ReadableStream<Uint8Array>, fn: (data: string) => string): ReadableStream<Uint8Array> {
   const decoder = new TextDecoder();

package/src/providers/codex.ts

@@ -10,7 +10,7 @@ import * as store from "../auth/store.ts";
 import { CODEX_BASE_URL, codexHeaders, codexHeaderValues, codexPathMap } from "../constants.ts";
 import { fromBase64url } from "../utils/encoding.ts";
 import type { Provider } from "./base.ts";
-import { transformCodexResponse } from "./codex-sse.ts";
+import { bufferCodexResponse, transformCodexResponse } from "./codex-sse.ts";
 import { denied, forward } from "./forward.ts";
 
 const DEFAULT_INSTRUCTIONS = "You are an expert coding assistant.";
@@ -60,6 +60,9 @@ export const provider: Provider = {
 
     // Transform Responses API SSE → Chat Completions SSE when original was messages[] format
     if (needsResponseTransform && response.ok) {
+      if (!body.stream) {
+        return bufferCodexResponse(response, ampModel);
+      }
       return transformCodexResponse(response, ampModel);
     }
     return response;