@oh-my-pi/pi-ai 17.2.0 → 17.2.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [17.2.1] - 2026-07-30
+
+### Added
+
+- Added exact OAuth credential-row resolution by durable credential id. The targeted path refreshes only that row and never ranks, rotates, or falls back to sibling accounts.
+
+### Changed
+
+- Anthropic OAuth requests now reproduce Cowork's current `claude-desktop` request profile, including client/runtime metadata, beta selection, system and billing attestation, the 64K output cap, and stable HTTP/1.1 header ordering.
+
 ## [17.2.0] - 2026-07-30
 
 ### Added

package/dist/types/auth-storage.d.ts

@@ -1083,6 +1083,18 @@ export declare class AuthStorage {
      * overrides have replaced OAuth with an explicit API key.
      */
     getOAuthAccessAt(provider: string, position: number, options?: AuthApiKeyOptions): Promise<OAuthAccessResolution | undefined>;
+    /**
+     * Resolve one stored OAuth credential by its durable storage row id.
+     *
+     * Unlike the normal session resolver, this method never ranks, rotates, or
+     * falls back to sibling credentials. A forced refresh re-mints only the
+     * requested row, preserving exact-account affinity for operations whose
+     * provenance and policy boundary are tied to one workspace.
+     *
+     * Returns `undefined` when the row does not exist for `provider` or an
+     * explicit runtime/config API-key override suppresses OAuth.
+     */
+    getOAuthAccessByCredentialId(provider: string, credentialId: number, options?: AuthApiKeyOptions): Promise<OAuthAccessResolution | undefined>;
     /**
      * List saved rate-limit resets for every stored OAuth account of `provider`
      * (Codex), fetched LIVE from the dedicated `rate-limit-reset-credits` route.

package/dist/types/providers/anthropic.d.ts

@@ -10,7 +10,7 @@ export type AnthropicHeaderOptions = {
     modelHeaders?: Record<string, string>;
     isCloudflareAiGateway?: boolean;
     claudeCodeSessionId?: string;
-    claudeCodeBetas?: readonly string[];
+    coworkBetas?: readonly string[];
     /** Allow explicit fingerprint headers to replace OAuth defaults on non-official endpoints. */
     allowAnthropicHeaderOverrides?: boolean;
 };
@@ -33,19 +33,17 @@ export declare function clearAnthropicFastModeFallback(providerSessionState: Map
  */
 export declare function isAnthropicFastModeFallbackDisabled(providerSessionState: Map<string, ProviderSessionState> | undefined, model: Model<Api>): boolean;
 export * from "./claude-code-fingerprint.js";
-export declare function mapStainlessOs(platform: string): "MacOS" | "Windows" | "Linux" | "FreeBSD" | `Other::${string}`;
 export declare function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other::${string}`;
-export declare const claudeCodeHeaders: {
-    "X-Stainless-Retry-Count": string;
-    "X-Stainless-Runtime-Version": string;
+/** Static headers emitted by Cowork's Linux Claude runtime. */
+export declare const coworkHeaders: {
+    "X-Stainless-Arch": "arm64" | "x64" | "x86" | `other::${string}`;
+    "X-Stainless-Lang": string;
+    "X-Stainless-OS": string;
     "X-Stainless-Package-Version": string;
+    "X-Stainless-Retry-Count": string;
     "X-Stainless-Runtime": string;
-    "X-Stainless-Lang": string;
-    "X-Stainless-Arch": "arm64" | "x64" | "x86" | `other::${string}`;
-    "X-Stainless-OS": "FreeBSD" | "Linux" | "MacOS" | "Windows" | `Other::${string}`;
+    "X-Stainless-Runtime-Version": string;
     "X-Stainless-Timeout": string;
-    "anthropic-client-platform": string;
-    "anthropic-client-version": string;
 };
 /**
  * Wraps a fetch implementation to patch the Claude Code billing-header `cch`

package/dist/types/providers/claude-code-fingerprint.d.ts

@@ -1,15 +1,19 @@
 /**
- * Claude Code stealth-fingerprint constants, kept in a leaf module so
- * fingerprint consumers outside the provider (`registry/oauth/anthropic`,
- * `usage/claude`) don't import the heavy `providers/anthropic` module.
+ * Cowork inference-fingerprint constants, kept in a leaf module so consumers
+ * outside the provider (`registry/oauth/anthropic`, `usage/claude`) don't
+ * import the heavy `providers/anthropic` module.
+ *
  * That import edge was a live init cycle: `providers/anthropic` → `stream` →
  * `registry` → `registry/oauth/anthropic` → back into the still-initializing
- * provider module, which threw a TDZ ReferenceError whenever
- * `providers/anthropic` was the first module loaded.
+ * provider module.
  */
-export declare const claudeCodeVersion = "2.1.165";
-export declare const claudeAgentSdkVersion = "0.3.165";
-export declare const claudeClientVersion = "1.11187.4";
+/** Claude runtime version bundled by the current Cowork desktop release. */
+export declare const claudeCodeVersion = "2.1.220";
+/** User-Agent emitted by Cowork's `claude-desktop` inference entrypoint. */
+export declare const coworkUserAgent = "claude-cli/2.1.220 (external, claude-desktop)";
+/** Prefix used to isolate custom Anthropic OAuth tools from built-in tools. */
 export declare const claudeToolPrefix: string;
+/** Identity block prepended by Cowork's Claude runtime. */
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+/** Cowork's per-request output-token ceiling. */
 export declare const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64000;

package/dist/types/providers/cowork-fetch.d.ts

@@ -0,0 +1,3 @@
+import type { FetchImpl } from "../types.js";
+/** Sends Cowork-profiled HTTPS requests with stable header order, HTTP/1.1, and streaming decompression. */
+export declare const coworkFetch: FetchImpl;

package/dist/types/utils/proxy.d.ts

@@ -29,6 +29,8 @@ export interface ConnectProxiedSocketOptions {
     signal?: AbortSignal;
     /** Maximum wall-clock time to establish the final TLS tunnel. Disabled when absent or non-positive. */
     timeoutMs?: number;
+    /** Target TLS profile. Cursor defaults to HTTP/2 when this is absent. */
+    tls?: tls.ConnectionOptions;
 }
 /**
  * Tunnel a socket connection through an HTTP CONNECT proxy.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.2.0",
+	"version": "17.2.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/pi-catalog": "17.2.0",
-		"@oh-my-pi/pi-utils": "17.2.0",
-		"@oh-my-pi/pi-wire": "17.2.0",
+		"@oh-my-pi/pi-catalog": "17.2.1",
+		"@oh-my-pi/pi-utils": "17.2.1",
+		"@oh-my-pi/pi-wire": "17.2.1",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},

package/src/auth-storage.ts

@@ -5476,6 +5476,33 @@ export class AuthStorage {
 		return this.#resolveStoredOAuthAccess(provider, selection, providerKey, options);
 	}
 
+	/**
+	 * Resolve one stored OAuth credential by its durable storage row id.
+	 *
+	 * Unlike the normal session resolver, this method never ranks, rotates, or
+	 * falls back to sibling credentials. A forced refresh re-mints only the
+	 * requested row, preserving exact-account affinity for operations whose
+	 * provenance and policy boundary are tied to one workspace.
+	 *
+	 * Returns `undefined` when the row does not exist for `provider` or an
+	 * explicit runtime/config API-key override suppresses OAuth.
+	 */
+	async getOAuthAccessByCredentialId(
+		provider: string,
+		credentialId: number,
+		options?: AuthApiKeyOptions,
+	): Promise<OAuthAccessResolution | undefined> {
+		if (this.#runtimeOverrides.has(provider) || this.#configOverrides.has(provider)) {
+			return undefined;
+		}
+		const selection = this.#getStoredOAuthSelections(provider).find(
+			candidate => candidate.credentialId === credentialId,
+		);
+		if (!selection) return undefined;
+		const providerKey = this.#getProviderTypeKey(provider, "oauth");
+		return this.#resolveStoredOAuthAccess(provider, selection, providerKey, options);
+	}
+
 	/**
 	 * List saved rate-limit resets for every stored OAuth account of `provider`
 	 * (Codex), fetched LIVE from the dedicated `rate-limit-reset-credits` route.

package/src/providers/anthropic.ts

@@ -87,11 +87,10 @@ import {
 } from "./anthropic-wire";
 import {
 	CLAUDE_CODE_MAX_OUTPUT_TOKENS,
-	claudeAgentSdkVersion,
-	claudeClientVersion,
 	claudeCodeSystemInstruction,
 	claudeCodeVersion,
 	claudeToolPrefix,
+	coworkUserAgent,
 } from "./claude-code-fingerprint";
 import {
 	buildCopilotDynamicHeaders,
@@ -111,7 +110,7 @@ export type AnthropicHeaderOptions = {
 	modelHeaders?: Record<string, string>;
 	isCloudflareAiGateway?: boolean;
 	claudeCodeSessionId?: string;
-	claudeCodeBetas?: readonly string[];
+	coworkBetas?: readonly string[];
 	/** Allow explicit fingerprint headers to replace OAuth defaults on non-official endpoints. */
 	allowAnthropicHeaderOverrides?: boolean;
 };
@@ -158,52 +157,49 @@ function mergeAnthropicBetaHeader(callerHeaders: Record<string, string>, beta: s
 const midConversationSystemBeta = "mid-conversation-system-2026-04-07";
 const contextManagementBeta = "context-management-2025-06-27";
 const structuredOutputsBeta = "structured-outputs-2025-12-15";
-const claudeCodeUtilityBetaDefaults = [
-	"oauth-2025-04-20",
+const context1mBeta = "context-1m-2025-08-07";
+const thinkingTokenCountBeta = "thinking-token-count-2026-05-13";
+const fallbackCreditBeta = "fallback-credit-2026-06-01";
+const coworkUtilityBetaDefaults = [
 	"interleaved-thinking-2025-05-14",
+	thinkingTokenCountBeta,
 	contextManagementBeta,
 	"prompt-caching-scope-2026-01-05",
 	structuredOutputsBeta,
 ] as const;
-const claudeCodeAgentBetaDefaults = [
+const coworkAgentBetaDefaults = [
 	"claude-code-20250219",
-	"oauth-2025-04-20",
 	"interleaved-thinking-2025-05-14",
+	thinkingTokenCountBeta,
 	contextManagementBeta,
 	"prompt-caching-scope-2026-01-05",
 	midConversationSystemBeta,
 	"advanced-tool-use-2025-11-20",
 ] as const;
 const extendedCacheTtlBeta = "extended-cache-ttl-2025-04-11";
-const claudeCodeAgentPostEffortBetas = [extendedCacheTtlBeta] as const;
 const fineGrainedToolStreamingBeta = "fine-grained-tool-streaming-2025-05-14";
 const interleavedThinkingBeta = "interleaved-thinking-2025-05-14";
-// Asks the API to redact thinking blocks from responses. Only sent when the
-// caller explicitly hides thinking (`thinkingDisplay: "omitted"`); sending it
-// by default suppresses the thinking traces callers expect to stream.
-const redactThinkingBeta = "redact-thinking-2026-02-12";
 const fastModeBeta = "fast-mode-2026-02-01";
 const taskBudgetBeta = "task-budgets-2026-03-13";
 const effortBeta = "effort-2025-11-24";
 const serverSideFallbackBeta = "server-side-fallback-2026-06-01";
 
-function buildClaudeCodeBetas(
+function buildCoworkBetas(
 	agentRequest: boolean,
 	thinkingRequest: boolean,
-	redactThinking: boolean,
+	longContext: boolean,
 	disableStrictTools = false,
 ): readonly string[] {
-	if (!agentRequest && !redactThinking && !disableStrictTools) return claudeCodeUtilityBetaDefaults;
+	if (!agentRequest && !disableStrictTools) return coworkUtilityBetaDefaults;
 	const betas: string[] = [];
-	for (const beta of agentRequest ? claudeCodeAgentBetaDefaults : claudeCodeUtilityBetaDefaults) {
+	for (const beta of agentRequest ? coworkAgentBetaDefaults : coworkUtilityBetaDefaults) {
 		if (disableStrictTools && beta === structuredOutputsBeta) continue;
 		betas.push(beta);
-		// Match CC's header order: redact-thinking immediately follows interleaved-thinking.
-		if (redactThinking && beta === interleavedThinkingBeta) betas.push(redactThinkingBeta);
+		if (agentRequest && longContext && beta === "claude-code-20250219") betas.push(context1mBeta);
 	}
 	if (!agentRequest) return betas;
 	if (thinkingRequest) betas.push(effortBeta);
-	betas.push(...claudeCodeAgentPostEffortBetas);
+	betas.push(fallbackCreditBeta);
 	return betas;
 }
 
@@ -246,11 +242,10 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 	const incomingUserAgent = getHeaderCaseInsensitive(options.modelHeaders, "User-Agent");
 	const incomingAuthorization = getHeaderCaseInsensitive(options.modelHeaders, "Authorization");
 	const incomingApiKey = getHeaderCaseInsensitive(options.modelHeaders, "X-Api-Key");
-	// Claude Code betas (oauth-2025-04-20, claude-code-20250219, …) are part of
-	// the OAuth fingerprint; API-key requests default to extras only, matching
-	// the streaming path (buildAnthropicClientOptions passes [] for non-OAuth).
+	// Cowork's beta profile is part of the OAuth fingerprint; API-key requests
+	// default to extras only, matching the streaming path.
 	const betaHeader = buildBetaHeader(
-		options.claudeCodeBetas ?? (oauthToken ? buildClaudeCodeBetas(true, true, false) : []),
+		options.coworkBetas ?? (oauthToken ? buildCoworkBetas(true, true, false) : []),
 		extraBetas,
 	);
 	const acceptHeader = oauthToken ? "application/json" : stream ? "text/event-stream" : "application/json";
@@ -308,19 +303,22 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 	}
 
 	if (oauthToken) {
-		const userAgent = isClaudeCodeClientUserAgent(incomingUserAgent)
-			? incomingUserAgent
-			: `claude-cli/${claudeCodeVersion} (external, local-agent, agent-sdk/${claudeAgentSdkVersion})`;
+		const userAgent = isClaudeCodeClientUserAgent(incomingUserAgent) ? incomingUserAgent : coworkUserAgent;
 		const headers = {
 			...modelHeaders,
-			...claudeCodeHeaders,
 			Accept: acceptHeader,
-			Authorization: `Bearer ${options.apiKey}`,
-			...sharedHeaders,
-			...(betaHeader ? { "anthropic-beta": betaHeader } : {}),
+			"Content-Type": "application/json",
+			"User-Agent": userAgent,
 			...(options.claudeCodeSessionId ? { "X-Claude-Code-Session-Id": options.claudeCodeSessionId } : {}),
+			...coworkHeaders,
+			...(betaHeader ? { "anthropic-beta": betaHeader } : {}),
+			"anthropic-dangerous-direct-browser-access": "true",
+			"anthropic-version": "2023-06-01",
+			Authorization: `Bearer ${options.apiKey}`,
+			"x-app": "cli",
 			"x-client-request-id": nodeCrypto.randomUUID(),
-			"User-Agent": userAgent,
+			Connection: "keep-alive",
+			"Accept-Encoding": "gzip, deflate, br, zstd",
 			...(incomingApiKey ? { "X-Api-Key": incomingApiKey } : {}),
 		};
 		return allowAnthropicHeaderOverrides ? mergeHeaders(headers, anthropicHeaderOverrides) : headers;
@@ -503,26 +501,10 @@ function getCacheControl(
 	};
 }
 
-// Stealth mode: mimic Claude Code's request fingerprint. Constants live in the
-// leaf module so registry/usage consumers avoid an init cycle through this file.
+// Cowork mode: mimic the desktop agent's direct inference transport. Constants
+// live in the leaf module so registry/usage consumers avoid an init cycle.
 export * from "./claude-code-fingerprint";
 
-export function mapStainlessOs(platform: string): "MacOS" | "Windows" | "Linux" | "FreeBSD" | `Other::${string}` {
-	switch (platform.toLowerCase()) {
-		case "darwin":
-			return "MacOS";
-		case "windows":
-		case "win32":
-			return "Windows";
-		case "linux":
-			return "Linux";
-		case "freebsd":
-			return "FreeBSD";
-		default:
-			return `Other::${platform.toLowerCase()}`;
-	}
-}
-
 export function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other::${string}` {
 	switch (arch.toLowerCase()) {
 		case "amd64":
@@ -540,22 +522,21 @@ export function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other
 	}
 }
 
-export const claudeCodeHeaders = {
-	"X-Stainless-Retry-Count": "0",
-	"X-Stainless-Runtime-Version": "v24.3.0",
+/** Static headers emitted by Cowork's Linux Claude runtime. */
+export const coworkHeaders = {
+	"X-Stainless-Arch": mapStainlessArch(process.arch),
+	"X-Stainless-Lang": "js",
+	"X-Stainless-OS": "Linux",
 	"X-Stainless-Package-Version": "0.94.0",
+	"X-Stainless-Retry-Count": "0",
 	"X-Stainless-Runtime": "node",
-	"X-Stainless-Lang": "js",
-	"X-Stainless-Arch": mapStainlessArch(process.arch),
-	"X-Stainless-OS": mapStainlessOs(process.platform),
-	"X-Stainless-Timeout": "900",
-	"anthropic-client-platform": "desktop_app",
-	"anthropic-client-version": claudeClientVersion,
+	"X-Stainless-Runtime-Version": "v26.3.0",
+	"X-Stainless-Timeout": "600",
 };
 
 const enforcedHeaderKeys = new Set(
 	[
-		...Object.keys(claudeCodeHeaders),
+		...Object.keys(coworkHeaders),
 		"Accept",
 		"Accept-Encoding",
 		"Connection",
@@ -574,7 +555,7 @@ const enforcedHeaderKeys = new Set(
 );
 
 const overridableAnthropicHeaderKeys = new Set(
-	[...Object.keys(claudeCodeHeaders), "anthropic-beta", "User-Agent", "x-app"].map(key => key.toLowerCase()),
+	[...Object.keys(coworkHeaders), "anthropic-beta", "User-Agent", "x-app"].map(key => key.toLowerCase()),
 );
 
 const CLAUDE_BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
@@ -591,7 +572,7 @@ function createClaudeBillingHeader(firstUserMessageText: string): string {
 		.slice(0, 3);
 	// cch=00000: placeholder replaced with the real attestation hash by wrapFetchForCch
 	// before the request hits the wire (see below).
-	return `${CLAUDE_BILLING_HEADER_PREFIX} cc_version=${claudeCodeVersion}.${versionSuffix}; cc_entrypoint=local-agent; ${CCH_PLACEHOLDER_STR};`;
+	return `${CLAUDE_BILLING_HEADER_PREFIX} cc_version=${claudeCodeVersion}.${versionSuffix}; cc_entrypoint=claude-desktop; ${CCH_PLACEHOLDER_STR};`;
 }
 
 // cch attestation: XXHash64(body_with_placeholder, seed) low-20-bits, 5 hex chars.
@@ -1184,7 +1165,7 @@ export type AnthropicClientOptionsResult = {
 	fetchOptions?: AnthropicFetchOptions;
 };
 
-const CLAUDE_CODE_TLS_CIPHERS = tls.DEFAULT_CIPHERS;
+const COWORK_TLS_CIPHERS = tls.DEFAULT_CIPHERS;
 
 type FoundryTlsOptions = {
 	ca?: string | string[];
@@ -1347,7 +1328,7 @@ function resolveFoundryTlsOptions(model: Model<"anthropic-messages">): FoundryTl
 	return resolved;
 }
 
-function buildClaudeCodeTlsFetchOptions(
+function buildCoworkTlsFetchOptions(
 	model: Model<"anthropic-messages">,
 	baseUrl: string | undefined,
 ): AnthropicFetchOptions | undefined {
@@ -1369,7 +1350,7 @@ function buildClaudeCodeTlsFetchOptions(
 		tls: {
 			rejectUnauthorized: true,
 			serverName,
-			...(CLAUDE_CODE_TLS_CIPHERS ? { ciphers: CLAUDE_CODE_TLS_CIPHERS } : {}),
+			...(COWORK_TLS_CIPHERS ? { ciphers: COWORK_TLS_CIPHERS } : {}),
 			...(foundryTlsOptions ?? {}),
 		},
 	};
@@ -2865,7 +2846,6 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		dynamicHeaders,
 		hasTools = false,
 		thinkingEnabled = false,
-		thinkingDisplay,
 		isOAuth,
 		maxRetryDelayMs,
 		claudeCodeSessionId,
@@ -2903,7 +2883,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	const needsFineGrainedToolStreamingBeta =
 		hasTools && isOfficialAnthropicApiUrl(baseUrl) && !supportsEagerToolInputStreaming;
 	const foundryCustomHeaders = resolveAnthropicCustomHeaders(model);
-	const tlsFetchOptions = buildClaudeCodeTlsFetchOptions(model, baseUrl);
+	const tlsFetchOptions = buildCoworkTlsFetchOptions(model, baseUrl);
 	// Disable Bun's native ~300s pre-response fetch timeout (issue #2422).
 	// `AnthropicMessagesClient` already arms its own DEFAULT_TIMEOUT_MS timer
 	// per request, so the native ceiling can only short-circuit slow-prefill
@@ -2969,11 +2949,11 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
 		allowAnthropicHeaderOverrides: model.compat.allowAnthropicHeaderOverrides,
 		claudeCodeSessionId,
-		claudeCodeBetas: oauthToken
-			? buildClaudeCodeBetas(
+		coworkBetas: oauthToken
+			? buildCoworkBetas(
 					hasTools || thinkingEnabled,
 					thinkingEnabled,
-					thinkingDisplay === "omitted",
+					(model.contextWindow ?? 0) >= 1_000_000,
 					disableStrictTools,
 				)
 			: [],

package/src/providers/claude-code-fingerprint.ts

@@ -1,19 +1,20 @@
 /**
- * Claude Code stealth-fingerprint constants, kept in a leaf module so
- * fingerprint consumers outside the provider (`registry/oauth/anthropic`,
- * `usage/claude`) don't import the heavy `providers/anthropic` module.
+ * Cowork inference-fingerprint constants, kept in a leaf module so consumers
+ * outside the provider (`registry/oauth/anthropic`, `usage/claude`) don't
+ * import the heavy `providers/anthropic` module.
+ *
  * That import edge was a live init cycle: `providers/anthropic` → `stream` →
  * `registry` → `registry/oauth/anthropic` → back into the still-initializing
- * provider module, which threw a TDZ ReferenceError whenever
- * `providers/anthropic` was the first module loaded.
+ * provider module.
  */
 
-export const claudeCodeVersion = "2.1.165";
-export const claudeAgentSdkVersion = "0.3.165";
-export const claudeClientVersion = "1.11187.4";
+/** Claude runtime version bundled by the current Cowork desktop release. */
+export const claudeCodeVersion = "2.1.220";
+/** User-Agent emitted by Cowork's `claude-desktop` inference entrypoint. */
+export const coworkUserAgent = `claude-cli/${claudeCodeVersion} (external, claude-desktop)`;
+/** Prefix used to isolate custom Anthropic OAuth tools from built-in tools. */
 export const claudeToolPrefix: string = "_";
+/** Identity block prepended by Cowork's Claude runtime. */
 export const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-// Claude Code caps requested output at 64k tokens even when the model ceiling is
-// higher (e.g. Opus 4.8 supports 128k); OAuth requests clamp to match the wire
-// fingerprint. API-key requests keep the full model ceiling.
+/** Cowork's per-request output-token ceiling. */
 export const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64000;

package/src/providers/cowork-fetch.ts

@@ -0,0 +1,201 @@
+import type { ClientRequest, IncomingMessage } from "node:http";
+import * as https from "node:https";
+import * as stream from "node:stream";
+import * as tls from "node:tls";
+import * as zlib from "node:zlib";
+import type { FetchImpl } from "../types";
+import { connectProxiedSocket } from "../utils/proxy";
+
+type CoworkTlsOptions = {
+	ca?: string | string[];
+	cert?: string;
+	key?: string;
+	rejectUnauthorized?: boolean;
+	serverName?: string;
+	ciphers?: string;
+};
+
+type CoworkRequestInit = RequestInit & {
+	proxy?: string;
+	tls?: CoworkTlsOptions;
+};
+
+type RequestBody = string | Uint8Array;
+
+type AgentLease = {
+	agent: https.Agent;
+	release?: () => void;
+};
+
+const directAgent = new https.Agent({ keepAlive: true });
+const fallbackFetch: FetchImpl = globalThis.fetch;
+
+function isHeaderRecord(headers: RequestInit["headers"]): headers is Record<string, string> {
+	return headers !== undefined && !(headers instanceof Headers) && !Array.isArray(headers);
+}
+
+function resolveBody(body: RequestInit["body"]): RequestBody | undefined {
+	if (typeof body === "string" || body instanceof Uint8Array) return body;
+	return undefined;
+}
+
+function buildOrderedHeaders(
+	url: URL,
+	source: Record<string, string>,
+	body: RequestBody | undefined,
+): Record<string, string> {
+	const headers: Record<string, string> = {};
+	let hasHost = false;
+	let hasContentLength = false;
+	for (const name in source) {
+		const lowerName = name.toLowerCase();
+		if (lowerName === "host") hasHost = true;
+		if (lowerName === "content-length") hasContentLength = true;
+		if (lowerName === "accept-encoding" && !hasHost) {
+			headers.Host = url.host;
+			hasHost = true;
+		}
+		headers[name] = source[name];
+	}
+	if (!hasHost) headers.Host = url.host;
+	const length = typeof body === "string" ? Buffer.byteLength(body) : body?.byteLength;
+	if (!hasContentLength && length !== undefined) headers["Content-Length"] = String(length);
+	return headers;
+}
+
+function resolveTlsOptions(url: URL, options: CoworkTlsOptions | undefined): tls.ConnectionOptions {
+	const resolved: tls.ConnectionOptions = {
+		ALPNProtocols: ["http/1.1"],
+		ciphers: options?.ciphers ?? tls.DEFAULT_CIPHERS,
+		rejectUnauthorized: options?.rejectUnauthorized ?? true,
+		servername: options?.serverName ?? url.hostname,
+	};
+	if (options?.ca !== undefined) resolved.ca = options.ca;
+	if (options?.cert !== undefined) resolved.cert = options.cert;
+	if (options?.key !== undefined) resolved.key = options.key;
+	return resolved;
+}
+
+async function acquireAgent(
+	url: URL,
+	proxy: string | undefined,
+	tlsOptions: tls.ConnectionOptions,
+	signal: AbortSignal | undefined,
+): Promise<AgentLease> {
+	if (!proxy) return { agent: directAgent };
+	const socket = await connectProxiedSocket(proxy, url.origin, { signal, tls: tlsOptions });
+	const agent = new https.Agent({ keepAlive: false });
+	agent.createConnection = () => socket;
+	return { agent, release: () => agent.destroy() };
+}
+
+function responseHeaders(message: IncomingMessage): Headers {
+	const headers = new Headers();
+	for (let index = 0; index < message.rawHeaders.length; index += 2) {
+		headers.append(message.rawHeaders[index], message.rawHeaders[index + 1]);
+	}
+	return headers;
+}
+
+function decodedResponseStream(message: IncomingMessage): stream.Readable {
+	const rawEncoding = message.headers["content-encoding"];
+	const encoding = (Array.isArray(rawEncoding) ? rawEncoding[0] : rawEncoding)?.trim().toLowerCase();
+	switch (encoding) {
+		case "gzip":
+			return message.pipe(zlib.createGunzip());
+		case "deflate":
+			return message.pipe(zlib.createInflate());
+		case "br":
+			return message.pipe(zlib.createBrotliDecompress());
+		case "zstd":
+			return message.pipe(zlib.createZstdDecompress());
+		default:
+			return message;
+	}
+}
+
+function createResponse(message: IncomingMessage, method: string): Response {
+	const status = message.statusCode;
+	if (status === undefined) throw new Error("Cowork transport received a response without an HTTP status.");
+	const hasBody = method !== "HEAD" && status !== 204 && status !== 304;
+	const body = hasBody ? stream.Readable.toWeb(decodedResponseStream(message)) : null;
+	return new Response(body, {
+		status,
+		statusText: message.statusMessage,
+		headers: responseHeaders(message),
+	});
+}
+
+async function sendCoworkRequest(
+	url: URL,
+	init: CoworkRequestInit,
+	sourceHeaders: Record<string, string>,
+	body: RequestBody | undefined,
+): Promise<Response> {
+	const method = init.method ?? "GET";
+	const signal = init.signal ?? undefined;
+	const tlsOptions = resolveTlsOptions(url, init.tls);
+	const lease = await acquireAgent(url, init.proxy, tlsOptions, signal);
+	const headers = buildOrderedHeaders(url, sourceHeaders, body);
+	const result = Promise.withResolvers<Response>();
+	let request: ClientRequest | undefined;
+	const release = (): void => {
+		signal?.removeEventListener("abort", abort);
+		lease.release?.();
+	};
+	const abort = (): void => {
+		const reason = signal?.reason;
+		request?.destroy(reason instanceof Error ? reason : new DOMException("The operation was aborted.", "AbortError"));
+	};
+	if (signal?.aborted) {
+		release();
+		signal.throwIfAborted();
+	}
+	signal?.addEventListener("abort", abort, { once: true });
+	request = https.request(
+		{
+			protocol: url.protocol,
+			hostname: url.hostname,
+			port: url.port || 443,
+			path: `${url.pathname}${url.search}`,
+			method,
+			headers,
+			agent: lease.agent,
+			...tlsOptions,
+		},
+		message => {
+			message.once("close", release);
+			try {
+				result.resolve(createResponse(message, method));
+			} catch (error) {
+				message.destroy();
+				release();
+				result.reject(error);
+			}
+		},
+	);
+	request.once("error", error => {
+		release();
+		result.reject(error);
+	});
+	request.end(body);
+	return result.promise;
+}
+
+/** Sends Cowork-profiled HTTPS requests with stable header order, HTTP/1.1, and streaming decompression. */
+export const coworkFetch: FetchImpl = async (input, init) => {
+	if (input instanceof Request || init === undefined || !isHeaderRecord(init.headers)) {
+		return fallbackFetch(input, init);
+	}
+	let url: URL;
+	try {
+		url = new URL(input);
+	} catch {
+		return fallbackFetch(input, init);
+	}
+	if (url.protocol !== "https:") return fallbackFetch(input, init);
+	const body = resolveBody(init.body);
+	if (init.body != null && body === undefined) return fallbackFetch(input, init);
+	const coworkInit: CoworkRequestInit = init;
+	return sendCoworkRequest(url, coworkInit, init.headers, body);
+};

package/src/stream.ts

@@ -24,6 +24,7 @@ import { isInvalidatedOAuthTokenError } from "./error/auth-classify";
 import { isUsageLimitOutcome } from "./error/rate-limit";
 import type { BedrockOptions } from "./providers/amazon-bedrock";
 import type { AnthropicOptions } from "./providers/anthropic";
+import { coworkFetch } from "./providers/cowork-fetch";
 import type { CursorOptions } from "./providers/cursor";
 import type { DevinOptions } from "./providers/devin";
 import { isGitLabDuoModel, streamGitLabDuo } from "./providers/gitlab-duo";
@@ -81,6 +82,11 @@ import { wrapFetchForProxy } from "./utils/proxy";
 import { withRequestDebugFetch } from "./utils/request-debug";
 import { withGeminiThinkingLoopGuard } from "./utils/thinking-loop";
 
+function defaultFetchForModel(model: Model<Api>): FetchImpl {
+	if (model.provider === "anthropic" && model.api === "anthropic-messages") return coworkFetch;
+	return globalThis.fetch;
+}
+
 function isGoogleVertexAuthenticatedModel(model: Model<Api>): boolean {
 	return (
 		model.provider === "google-vertex" &&
@@ -769,11 +775,12 @@ function streamDispatch<TApi extends Api>(
 	context: Context,
 	options?: OptionsForApi<TApi>,
 ): AssistantMessageEventStream {
-	const baseOptions = (options || {}) as StreamOptions;
+	const inputOptions = (options || {}) as StreamOptions;
+	const baseOptions = { ...inputOptions, fetch: inputOptions.fetch ?? defaultFetchForModel(model) };
 	const debugOptions = withExtraCaFetch(withRequestDebugFetch(baseOptions));
 	const requestOptions = {
 		...debugOptions,
-		fetch: wrapFetchForProxy(debugOptions.fetch ?? (globalThis.fetch as FetchImpl), model.provider),
+		fetch: wrapFetchForProxy(debugOptions.fetch, model.provider),
 	} as OptionsForApi<TApi>;
 	assertExplicitOpenAIResponsesPromptCacheSupport(model, requestOptions);
 
@@ -1009,11 +1016,12 @@ export function streamSimple<TApi extends Api>(
 	context: Context,
 	options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
-	const baseOptions = (options || {}) as SimpleStreamOptions;
+	const inputOptions = (options || {}) as SimpleStreamOptions;
+	const baseOptions = { ...inputOptions, fetch: inputOptions.fetch ?? defaultFetchForModel(model) };
 	const debugOptions = withExtraCaFetch(withRequestDebugFetch(baseOptions));
 	const requestOptions = {
 		...debugOptions,
-		fetch: wrapFetchForProxy(debugOptions.fetch ?? (globalThis.fetch as FetchImpl), model.provider),
+		fetch: wrapFetchForProxy(debugOptions.fetch, model.provider),
 	} as SimpleStreamOptions;
 
 	const apiKeyResolver = isApiKeyResolver(requestOptions?.apiKey) ? requestOptions.apiKey : undefined;

package/src/utils/proxy.ts

@@ -177,6 +177,8 @@ export interface ConnectProxiedSocketOptions {
 	signal?: AbortSignal;
 	/** Maximum wall-clock time to establish the final TLS tunnel. Disabled when absent or non-positive. */
 	timeoutMs?: number;
+	/** Target TLS profile. Cursor defaults to HTTP/2 when this is absent. */
+	tls?: tls.ConnectionOptions;
 }
 
 /**
@@ -261,10 +263,12 @@ export async function connectProxiedSocket(
 			return;
 		}
 
+		const tlsOptions = options?.tls;
 		tunnelSocket = tls.connect({
+			...tlsOptions,
 			socket: rawSocket,
-			servername: targetHost,
-			ALPNProtocols: ["h2"],
+			servername: tlsOptions?.servername ?? targetHost,
+			ALPNProtocols: tlsOptions?.ALPNProtocols ?? ["h2"],
 		});
 		tunnelSocket.once("secureConnect", onTunnelReady);
 		tunnelSocket.once("error", onTunnelError);