@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/models.ts

@@ -5,12 +5,12 @@
 import type { Provider } from "./types.ts";
 
 export function isHaikuModel(model: string): boolean {
-  return /haiku/i.test(model);
+    return /haiku/i.test(model);
 }
 
 export function supportsThinking(model: string): boolean {
-  if (!model) return true;
-  return /claude|sonnet|opus|haiku/i.test(model);
+    if (!model) return true;
+    return /claude|sonnet|opus|haiku/i.test(model);
 }
 
 /**
@@ -19,11 +19,11 @@ export function supportsThinking(model: string): boolean {
  * manual budgetTokens.
  */
 export function isOpus46Model(model: string): boolean {
-  if (!model) return false;
-  // Match standard IDs (claude-opus-4-6, claude-opus-4.6) and Bedrock ARNs
-  // (arn:aws:bedrock:...anthropic.claude-opus-4-6-...).
-  // Also match bare "opus-4-6" / "opus-4.6" fragments for non-standard strings.
-  return /claude-opus-4[._-]6|opus[._-]4[._-]6/i.test(model);
+    if (!model) return false;
+    // Match standard IDs (claude-opus-4-6, claude-opus-4.6) and Bedrock ARNs
+    // (arn:aws:bedrock:...anthropic.claude-opus-4-6-...).
+    // Also match bare "opus-4-6" / "opus-4.6" fragments for non-standard strings.
+    return /claude-opus-4[._-]6|opus[._-]4[._-]6/i.test(model);
 }
 
 /**
@@ -31,8 +31,8 @@ export function isOpus46Model(model: string): boolean {
  * Like Opus 4.6, these models use adaptive thinking (effort parameter).
  */
 export function isSonnet46Model(model: string): boolean {
-  if (!model) return false;
-  return /claude-sonnet-4[._-]6|sonnet[._-]4[._-]6/i.test(model);
+    if (!model) return false;
+    return /claude-sonnet-4[._-]6|sonnet[._-]4[._-]6/i.test(model);
 }
 
 /**
@@ -40,39 +40,39 @@ export function isSonnet46Model(model: string): boolean {
  * This includes both Opus 4.6 and Sonnet 4.6.
  */
 export function isAdaptiveThinkingModel(model: string): boolean {
-  return isOpus46Model(model) || isSonnet46Model(model);
+    return isOpus46Model(model) || isSonnet46Model(model);
 }
 
 export function hasOneMillionContext(model: string): boolean {
-  // Models with explicit 1m suffix, or Opus 4.6 (1M by default since v2.1.75).
-  return /(^|[-_ ])1m($|[-_ ])|context[-_]?1m/i.test(model) || isOpus46Model(model);
+    // Models with explicit 1m suffix, or Opus 4.6 (1M by default since v2.1.75).
+    return /(^|[-_ ])1m($|[-_ ])|context[-_]?1m/i.test(model) || isOpus46Model(model);
 }
 
 export function supportsStructuredOutputs(model: string): boolean {
-  if (!/claude|sonnet|opus|haiku/i.test(model)) return false;
-  return !isHaikuModel(model);
+    if (!/claude|sonnet|opus|haiku/i.test(model)) return false;
+    return !isHaikuModel(model);
 }
 
 /**
  * Context management is supported on Claude 4+ models (matches upstream CC).
  */
 export function supportsContextManagement(model: string): boolean {
-  if (!model) return false;
-  // Claude 3.x does not support context management
-  if (/claude-3-/i.test(model)) return false;
-  // Any other Claude model (4+) supports it
-  return /claude|sonnet|opus|haiku/i.test(model);
+    if (!model) return false;
+    // Claude 3.x does not support context management
+    if (/claude-3-/i.test(model)) return false;
+    // Any other Claude model (4+) supports it
+    return /claude|sonnet|opus|haiku/i.test(model);
 }
 
 export function supportsWebSearch(model: string): boolean {
-  return /claude|sonnet|opus|haiku|gpt|gemini/i.test(model);
+    return /claude|sonnet|opus|haiku|gpt|gemini/i.test(model);
 }
 
 export function detectProvider(requestUrl: URL | null): Provider {
-  if (!requestUrl) return "anthropic";
-  const host = requestUrl.hostname.toLowerCase();
-  if (host.includes("bedrock") || host.includes("amazonaws.com")) return "bedrock";
-  if (host.includes("aiplatform") || host.includes("vertex")) return "vertex";
-  if (host.includes("foundry") || host.includes("azure")) return "foundry";
-  return "anthropic";
+    if (!requestUrl) return "anthropic";
+    const host = requestUrl.hostname.toLowerCase();
+    if (host.includes("bedrock") || host.includes("amazonaws.com")) return "bedrock";
+    if (host.includes("aiplatform") || host.includes("vertex")) return "vertex";
+    if (host.includes("foundry") || host.includes("azure")) return "foundry";
+    return "anthropic";
 }

package/src/oauth.test.ts

@@ -5,129 +5,129 @@ const mockFetch = vi.fn();
 const originalFetch = globalThis.fetch;
 
 describe("oauth headers", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-    globalThis.fetch = mockFetch as typeof fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it("sends Claude Code user-agent on token exchange", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      text: async () => "",
+    beforeEach(() => {
+        vi.resetAllMocks();
+        globalThis.fetch = mockFetch as typeof fetch;
     });
 
-    await exchange("code#state", "verifier");
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+
+    it("sends Claude Code user-agent on token exchange", async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 400,
+            text: async () => "",
+        });
 
-    const [, init] = mockFetch.mock.calls[0];
-    expect(init.headers["User-Agent"]).toBe("axios/1.13.6");
-  });
+        await exchange("code#state", "verifier");
 
-  it("sends Claude Code user-agent on token refresh", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        access_token: "a",
-        refresh_token: "r",
-        expires_in: 3600,
-      }),
+        const [, init] = mockFetch.mock.calls[0];
+        expect(init.headers["User-Agent"]).toBe("axios/1.13.6");
     });
 
-    await refreshToken("refresh-token");
+    it("sends Claude Code user-agent on token refresh", async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                access_token: "a",
+                refresh_token: "r",
+                expires_in: 3600,
+            }),
+        });
 
-    const [, init] = mockFetch.mock.calls[0];
-    expect(init.headers["User-Agent"]).toBe("axios/1.13.6");
-  });
+        await refreshToken("refresh-token");
 
-  it("sends Claude Code user-agent on token revoke", async () => {
-    mockFetch.mockResolvedValueOnce({ ok: true });
+        const [, init] = mockFetch.mock.calls[0];
+        expect(init.headers["User-Agent"]).toBe("axios/1.13.6");
+    });
 
-    await revoke("refresh-token");
+    it("sends Claude Code user-agent on token revoke", async () => {
+        mockFetch.mockResolvedValueOnce({ ok: true });
 
-    const [, init] = mockFetch.mock.calls[0];
-    expect(init.headers["User-Agent"]).toBe("axios/1.13.6");
-  });
+        await revoke("refresh-token");
+
+        const [, init] = mockFetch.mock.calls[0];
+        expect(init.headers["User-Agent"]).toBe("axios/1.13.6");
+    });
 });
 
 describe("oauth scopes", () => {
-  it("requests all required scopes in authorization URL", async () => {
-    const { url } = await authorize("console");
-    const parsed = new URL(url);
-    const scope = parsed.searchParams.get("scope");
-
-    expect(scope).toContain("org:create_api_key");
-    expect(scope).toContain("user:profile");
-    expect(scope).toContain("user:inference");
-    expect(scope).toContain("user:sessions:claude_code");
-    expect(scope).toContain("user:mcp_servers");
-    expect(scope).toContain("user:file_upload");
-  });
-
-  it("uses console host for console mode", async () => {
-    const { url } = await authorize("console");
-    expect(url).toContain("platform.claude.com/oauth/authorize");
-  });
-
-  it("uses max host for max mode", async () => {
-    const { url } = await authorize("max");
-    expect(url).toContain("claude.ai/oauth/authorize");
-  });
+    it("requests all required scopes in authorization URL", async () => {
+        const { url } = await authorize("console");
+        const parsed = new URL(url);
+        const scope = parsed.searchParams.get("scope");
+
+        expect(scope).toContain("org:create_api_key");
+        expect(scope).toContain("user:profile");
+        expect(scope).toContain("user:inference");
+        expect(scope).toContain("user:sessions:claude_code");
+        expect(scope).toContain("user:mcp_servers");
+        expect(scope).toContain("user:file_upload");
+    });
+
+    it("uses console host for console mode", async () => {
+        const { url } = await authorize("console");
+        expect(url).toContain("platform.claude.com/oauth/authorize");
+    });
+
+    it("uses max host for max mode", async () => {
+        const { url } = await authorize("max");
+        expect(url).toContain("claude.ai/oauth/authorize");
+    });
 });
 
 describe("oauth authorize options", () => {
-  it("includes orgUUID when provided", async () => {
-    const { url } = await authorize("console", { orgUUID: "org-123" });
-    const parsed = new URL(url);
-    expect(parsed.searchParams.get("orgUUID")).toBe("org-123");
-  });
-
-  it("includes login_hint when provided", async () => {
-    const { url } = await authorize("console", {
-      loginHint: "user@example.com",
+    it("includes orgUUID when provided", async () => {
+        const { url } = await authorize("console", { orgUUID: "org-123" });
+        const parsed = new URL(url);
+        expect(parsed.searchParams.get("orgUUID")).toBe("org-123");
+    });
+
+    it("includes login_hint when provided", async () => {
+        const { url } = await authorize("console", {
+            loginHint: "user@example.com",
+        });
+        const parsed = new URL(url);
+        expect(parsed.searchParams.get("login_hint")).toBe("user@example.com");
+    });
+
+    it("includes login_method when provided", async () => {
+        const { url } = await authorize("console", { loginMethod: "google" });
+        const parsed = new URL(url);
+        expect(parsed.searchParams.get("login_method")).toBe("google");
+    });
+
+    it("omits optional params when not provided", async () => {
+        const { url } = await authorize("console");
+        const parsed = new URL(url);
+        expect(parsed.searchParams.has("orgUUID")).toBe(false);
+        expect(parsed.searchParams.has("login_hint")).toBe(false);
+        expect(parsed.searchParams.has("login_method")).toBe(false);
     });
-    const parsed = new URL(url);
-    expect(parsed.searchParams.get("login_hint")).toBe("user@example.com");
-  });
-
-  it("includes login_method when provided", async () => {
-    const { url } = await authorize("console", { loginMethod: "google" });
-    const parsed = new URL(url);
-    expect(parsed.searchParams.get("login_method")).toBe("google");
-  });
-
-  it("omits optional params when not provided", async () => {
-    const { url } = await authorize("console");
-    const parsed = new URL(url);
-    expect(parsed.searchParams.has("orgUUID")).toBe(false);
-    expect(parsed.searchParams.has("login_hint")).toBe(false);
-    expect(parsed.searchParams.has("login_method")).toBe(false);
-  });
 });
 
 describe("oauth exchange timeout", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-    globalThis.fetch = mockFetch as typeof fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it("sets 15s timeout on token exchange", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      text: async () => "",
+    beforeEach(() => {
+        vi.resetAllMocks();
+        globalThis.fetch = mockFetch as typeof fetch;
+    });
+
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
     });
 
-    await exchange("code#state", "verifier");
+    it("sets 15s timeout on token exchange", async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 400,
+            text: async () => "",
+        });
 
-    const [, init] = mockFetch.mock.calls[0];
-    expect(init.signal).toBeDefined();
-  });
+        await exchange("code#state", "verifier");
+
+        const [, init] = mockFetch.mock.calls[0];
+        expect(init.signal).toBeDefined();
+    });
 });