ampcode-connector 0.1.14 → 0.1.16

package/package.json

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

package/src/auth/oauth.ts

@@ -36,18 +36,8 @@ export async function token(config: OAuthConfig, account = 0): Promise<string |
 
   if (store.fresh(creds)) return creds.accessToken;
 
-  try {
-    return (await refresh(config, creds.refreshToken, account)).accessToken;
-  } catch (err) {
-    logger.warn(`Token refresh failed for ${config.providerName}:${account}, retrying...`, { error: String(err) });
-    try {
-      await Bun.sleep(1000);
-      return (await refresh(config, creds.refreshToken, account)).accessToken;
-    } catch (retryErr) {
-      logger.error(`Token refresh retry failed for ${config.providerName}:${account}`, { error: String(retryErr) });
-      return null;
-    }
-  }
+  const refreshed = await refreshWithRetry(config, creds.refreshToken, account);
+  return refreshed?.accessToken ?? null;
 }
 
 export async function tokenFromAny(config: OAuthConfig): Promise<{ accessToken: string; account: number } | null> {
@@ -61,6 +51,7 @@ export async function tokenFromAny(config: OAuthConfig): Promise<{ accessToken:
       const refreshed = await refresh(config, c.refreshToken, account);
       return { accessToken: refreshed.accessToken, account };
     } catch (err) {
+      handleRefreshFailure(config, account, err);
       logger.debug(`${config.providerName}:${account} refresh failed in tokenFromAny`, { error: String(err) });
     }
   }
@@ -160,6 +151,29 @@ async function refresh(config: OAuthConfig, refreshToken: string, account = 0):
   return credentials;
 }
 
+async function refreshWithRetry(
+  config: OAuthConfig,
+  refreshToken: string,
+  account: number,
+): Promise<Credentials | null> {
+  try {
+    return await refresh(config, refreshToken, account);
+  } catch (err) {
+    if (handleRefreshFailure(config, account, err)) return null;
+
+    logger.warn(`Token refresh failed for ${config.providerName}:${account}, retrying...`, { error: String(err) });
+
+    try {
+      await Bun.sleep(1000);
+      return await refresh(config, refreshToken, account);
+    } catch (retryErr) {
+      handleRefreshFailure(config, account, retryErr);
+      logger.error(`Token refresh retry failed for ${config.providerName}:${account}`, { error: String(retryErr) });
+      return null;
+    }
+  }
+}
+
 async function exchange(config: OAuthConfig, params: Record<string, string>): Promise<Record<string, unknown>> {
   const all: Record<string, string> = { client_id: config.clientId, ...params };
   if (config.clientSecret) all.client_secret = config.clientSecret;
@@ -173,12 +187,83 @@ async function exchange(config: OAuthConfig, params: Record<string, string>): Pr
 
   if (!res.ok) {
     const text = await res.text();
-    throw new Error(`${config.providerName} token exchange failed (${res.status}): ${text}`);
+    const oauthError = parseOAuthError(text);
+    throw new TokenExchangeError(config.providerName, res.status, text, oauthError.code, oauthError.description);
   }
 
   return (await res.json()) as Record<string, unknown>;
 }
 
+class TokenExchangeError extends Error {
+  readonly status: number;
+  readonly responseBody: string;
+  readonly errorCode: string | null;
+  readonly errorDescription: string | null;
+
+  constructor(
+    providerName: string,
+    status: number,
+    responseBody: string,
+    errorCode: string | null,
+    errorDescription: string | null,
+  ) {
+    super(`${providerName} token exchange failed (${status}): ${responseBody}`);
+    this.name = "TokenExchangeError";
+    this.status = status;
+    this.responseBody = responseBody;
+    this.errorCode = errorCode;
+    this.errorDescription = errorDescription;
+  }
+}
+
+function parseOAuthError(responseBody: string): { code: string | null; description: string | null } {
+  try {
+    const parsed = JSON.parse(responseBody) as { error?: unknown; error_description?: unknown };
+    const code = typeof parsed.error === "string" ? parsed.error : null;
+    const description = typeof parsed.error_description === "string" ? parsed.error_description : null;
+    return { code, description };
+  } catch {
+    return { code: null, description: null };
+  }
+}
+
+/** Handles terminal refresh failures and returns true when retry should stop. */
+function handleRefreshFailure(config: OAuthConfig, account: number, err: unknown): boolean {
+  if (!isInvalidRefreshTokenError(err)) return false;
+  if (!store.get(config.providerName, account)) return false;
+
+  store.remove(config.providerName, account);
+  logger.warn(`Removed invalid refresh token for ${config.providerName}:${account}; re-login required.`, {
+    error: String(err),
+  });
+  return true;
+}
+
+function isInvalidRefreshTokenError(err: unknown): boolean {
+  if (!(err instanceof TokenExchangeError)) return false;
+  if (err.status !== 400 && err.status !== 401) return false;
+
+  if (err.errorCode === "invalid_grant") return true;
+
+  const description = err.errorDescription?.toLowerCase() ?? "";
+  const hasRefreshTokenContext = description.includes("refresh token");
+  const indicatesInvalidState =
+    description.includes("invalid") ||
+    description.includes("not found") ||
+    description.includes("expired") ||
+    description.includes("revoked");
+
+  if (hasRefreshTokenContext && indicatesInvalidState) return true;
+
+  const body = err.responseBody.toLowerCase();
+  return (
+    body.includes("invalid_grant") ||
+    body.includes("invalid refresh token") ||
+    body.includes("refresh token not found") ||
+    body.includes("refresh token is invalid")
+  );
+}
+
 function parseTokenFields(raw: Record<string, unknown>, config: OAuthConfig): Credentials {
   if (typeof raw.access_token !== "string" || !raw.access_token) {
     throw new Error(`${config.providerName} token response missing access_token`);

package/src/providers/codex-sse.ts

@@ -62,7 +62,7 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
   };
 
   return (data: string): string => {
-    if (data === "[DONE]") return data;
+    if (data === "[DONE]") return "";
 
     let parsed: Record<string, unknown>;
     try {
@@ -130,18 +130,26 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
         return serializeFinish(state, finishReason, usage);
       }
 
-      // Response incomplete — emit finish_reason "length" + usage
+      // Response incomplete — inspect reason to determine finish_reason
       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);
+        const finishReason = incompleteReason(resp);
+        return serializeFinish(state, finishReason, usage);
       }
 
-      // Response failed — emit finish_reason "stop" (error)
+      // Response failed — emit error content so the client sees the failure
       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);
+        const errorMsg = extractErrorMessage(resp);
+        let chunks = "";
+        if (errorMsg) {
+          chunks = serialize(state, { role: "assistant", content: `[Error] ${errorMsg}` });
+          chunks += "\n\n";
+        }
+        chunks += serializeFinish(state, "stop", usage);
+        return chunks;
       }
 
       // Reasoning/thinking delta — emit as reasoning_content (separate from content)
@@ -191,6 +199,28 @@ function serializeFinish(state: TransformState, finishReason: string, usage?: Us
   return JSON.stringify(chunk);
 }
 
+/** Map Responses API incomplete reason → Chat Completions finish_reason. */
+function incompleteReason(resp: Record<string, unknown> | undefined): string {
+  if (!resp) return "length";
+  const reason = resp.incomplete_details as Record<string, unknown> | undefined;
+  const type = reason?.reason as string | undefined;
+  if (type === "max_output_tokens" || type === "max_tokens") return "length";
+  if (type === "content_filter") return "content_filter";
+  return "length";
+}
+
+/** Extract a human-readable error message from a failed response. */
+function extractErrorMessage(resp: Record<string, unknown> | undefined): string | null {
+  if (!resp) return null;
+  const error = resp.error as Record<string, unknown> | undefined;
+  if (!error) return null;
+  const message = error.message as string | undefined;
+  const code = error.code as string | undefined;
+  if (message) return code ? `${code}: ${message}` : message;
+  if (code) return code;
+  return null;
+}
+
 function extractUsage(raw: Record<string, unknown> | undefined): Usage | undefined {
   if (!raw) return undefined;
   const input = (raw.input_tokens as number) ?? 0;
@@ -206,6 +236,15 @@ function extractUsage(raw: Record<string, unknown> | undefined): Usage | undefin
   };
 }
 
+const FORWARDED_HEADERS = [
+  "x-request-id",
+  "request-id",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-tokens",
+] as const;
+
 /** Wrap a Codex SSE response with the Responses → Chat Completions transformer.
  *  Strips Responses API event names so output looks like standard Chat Completions SSE. */
 export function transformCodexResponse(response: Response, ampModel: string): Response {
@@ -214,14 +253,17 @@ export function transformCodexResponse(response: Response, ampModel: string): Re
   const transformer = createResponseTransformer(ampModel);
   const body = transformStream(response.body, transformer);
 
-  return new Response(body, {
-    status: response.status,
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    },
-  });
+  const headers: Record<string, string> = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  };
+  for (const name of FORWARDED_HEADERS) {
+    const value = response.headers.get(name);
+    if (value) headers[name] = value;
+  }
+
+  return new Response(body, { status: response.status, headers });
 }
 
 /** Buffer a Codex SSE response into a single Chat Completions JSON response.
@@ -324,32 +366,87 @@ export async function bufferCodexResponse(response: Response, ampModel: string):
         case "response.incomplete": {
           const resp = parsed.response as Record<string, unknown>;
           usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
-          finishReason = "length";
+          finishReason = incompleteReason(resp);
           break;
         }
 
         case "response.failed": {
           const resp = parsed.response as Record<string, unknown>;
           usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          const errorMsg = extractErrorMessage(resp);
+          if (errorMsg) content += `[Error] ${errorMsg}`;
           break;
         }
       }
     }
   }
 
-  // Process remaining buffer
+  // Process remaining buffer — reuse the same event handling as main loop
   if (sseBuffer.trim()) {
     for (const chunk of sse.parse(sseBuffer)) {
       if (chunk.data === "[DONE]") continue;
+
+      let parsed: Record<string, unknown>;
       try {
-        const parsed = JSON.parse(chunk.data) as Record<string, unknown>;
-        if (parsed.type === "response.completed") {
+        parsed = JSON.parse(chunk.data) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+
+      const eventType = parsed.type as string | undefined;
+      if (!eventType) 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 = incompleteReason(resp);
+          break;
+        }
+        case "response.failed": {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          const errorMsg = extractErrorMessage(resp);
+          if (errorMsg) content += `[Error] ${errorMsg}`;
+          break;
         }
-      } catch {
-        // skip
       }
     }
   }

package/src/providers/codex.ts

@@ -135,16 +135,22 @@ function transformForCodex(
     fixOrphanOutputs(parsed.input as Record<string, unknown>[]);
   }
 
-  // Reasoning config — defaults match reference behavior
+  // Reasoning config — merge with caller-provided values, defaults match reference behavior
   const model = (parsed.model as string) ?? "";
+  const existingReasoning = (parsed.reasoning as Record<string, unknown>) ?? {};
   parsed.reasoning = {
-    effort: clampReasoningEffort(model, "high"),
-    summary: "auto",
+    effort: clampReasoningEffort(model, (existingReasoning.effort as string) ?? "high"),
+    summary: existingReasoning.summary ?? "auto",
   };
 
-  parsed.text = { verbosity: "medium" };
+  const existingText = (parsed.text as Record<string, unknown>) ?? {};
+  parsed.text = { ...existingText, verbosity: existingText.verbosity ?? "medium" };
 
-  parsed.include = ["reasoning.encrypted_content"];
+  const existingInclude = Array.isArray(parsed.include) ? (parsed.include as string[]) : [];
+  if (!existingInclude.includes("reasoning.encrypted_content")) {
+    existingInclude.push("reasoning.encrypted_content");
+  }
+  parsed.include = existingInclude;
 
   if (promptCacheKey) {
     parsed.prompt_cache_key = promptCacheKey;
@@ -165,6 +171,23 @@ function transformForCodex(
   delete parsed.logit_bias;
   delete parsed.response_format;
 
+  // Normalize tools[] for Responses API: flatten function.{name,description,parameters,strict} to top-level
+  if (Array.isArray(parsed.tools)) {
+    parsed.tools = (parsed.tools as Record<string, unknown>[]).map((tool) => {
+      if (tool.type === "function" && tool.function && typeof tool.function === "object") {
+        const fn = tool.function as Record<string, unknown>;
+        return {
+          type: "function",
+          name: fn.name,
+          description: fn.description,
+          parameters: fn.parameters,
+          ...(fn.strict !== undefined ? { strict: fn.strict } : {}),
+        };
+      }
+      return tool;
+    });
+  }
+
   // Normalize tool_choice for Responses API
   if (parsed.tool_choice !== undefined && parsed.tool_choice !== null) {
     if (typeof parsed.tool_choice === "string") {
@@ -236,7 +259,7 @@ function convertMessages(messages: ChatMessage[]): { instructions: string | null
         input.push({
           type: "function_call_output",
           call_id: msg.tool_call_id,
-          output: textOf(msg.content) ?? "",
+          output: stringifyContent(msg.content),
         });
         break;
     }
@@ -265,6 +288,18 @@ function convertUserContent(content: unknown): unknown[] {
   return [{ type: "input_text", text: String(content) }];
 }
 
+/** Convert content to string, with JSON fallback for non-text values. */
+function stringifyContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  const text = textOf(content);
+  if (text !== null) return text;
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content ?? "");
+  }
+}
+
 /** Extract text from content (string or array). */
 function textOf(content: unknown): string | null {
   if (typeof content === "string") return content;