@apifuse/provider-sdk 2.2.0-beta.2 → 2.2.0-beta.4

package/src/runtime/cache.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 
-import { providerCacheRedisUrlFromEnv } from "../config/loader";
+import { providerCacheRedisUrlFromEnv } from "../config/loader.js";
 import type {
 	ProviderCache,
 	ProviderCacheGetOrSetOptions,
@@ -8,13 +8,13 @@ import type {
 	ProviderCacheLookupMeta,
 	ProviderCacheResponseMeta,
 	ProviderCacheResult,
-} from "../types";
+} from "../types.js";
 import {
 	createProviderRedisClient,
 	ensureRedisReady,
 	type ProviderRedisClient,
 	withRedisTimeout,
-} from "./redis";
+} from "./redis.js";
 
 type CacheSource = ProviderCacheLookupMeta["source"];
 
@@ -123,10 +123,7 @@ function normalizeKeyPart(value: unknown, extra: Set<string>): unknown {
 }
 
 function stableHash(value: unknown): string {
-	return createHash("sha256")
-		.update(JSON.stringify(value))
-		.digest("hex")
-		.slice(0, 32);
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 32);
 }
 
 function jitteredTtlMs(ttlMs: number, jitterPct: number | undefined): number {
@@ -161,10 +158,7 @@ function safeParseEnvelope(raw: string | null): CacheEnvelope | null {
 	}
 }
 
-function resultWithValue<T>(
-	value: unknown,
-	meta: ProviderCacheLookupMeta,
-): ProviderCacheResult<T> {
+function resultWithValue<T>(value: unknown, meta: ProviderCacheLookupMeta): ProviderCacheResult<T> {
 	return {
 		value: <T>value,
 		meta,
@@ -187,18 +181,14 @@ function resultFromEnvelope<T>(
 	});
 }
 
-function sourceSummary(
-	events: ProviderCacheLookupMeta[],
-): ProviderCacheResponseMeta["source"] {
+function sourceSummary(events: ProviderCacheLookupMeta[]): ProviderCacheResponseMeta["source"] {
 	const sources = new Set(events.map((event) => event.source));
 	if (sources.size === 0) return undefined;
 	if (sources.size === 1) return events[0]?.source;
 	return "mixed";
 }
 
-async function withRedisFallback<T>(
-	operation: () => Promise<T>,
-): Promise<T | undefined> {
+async function withRedisFallback<T>(operation: () => Promise<T>): Promise<T | undefined> {
 	return await withRedisTimeout(operation, {
 		timeoutMs: DEFAULT_REDIS_TIMEOUT_MS,
 		onTimeout: () => undefined,
@@ -206,15 +196,10 @@ async function withRedisFallback<T>(
 	});
 }
 
-export function createProviderCache(
-	options: ProviderCacheOptions,
-): ProviderCache {
+export function createProviderCache(options: ProviderCacheOptions): ProviderCache {
 	const redisUrl = options.redisUrl ?? providerCacheRedisUrlFromEnv();
 	const backend = getSharedBackend(redisUrl);
-	const memoryMaxEntries = Math.max(
-		1,
-		options.memoryMaxEntries ?? DEFAULT_MEMORY_MAX_ENTRIES,
-	);
+	const memoryMaxEntries = Math.max(1, options.memoryMaxEntries ?? DEFAULT_MEMORY_MAX_ENTRIES);
 	const now = options.now ?? Date.now;
 	const events: ProviderCacheLookupMeta[] = [];
 
@@ -238,11 +223,7 @@ export function createProviderCache(
 		}
 	}
 
-	function rememberEnvelope(
-		key: string,
-		envelope: CacheEnvelope,
-		currentTime: number,
-	): void {
+	function rememberEnvelope(key: string, envelope: CacheEnvelope, currentTime: number): void {
 		sweepMemory(currentTime);
 		backend.memory.delete(key);
 		backend.memory.set(key, {
@@ -253,11 +234,7 @@ export function createProviderCache(
 		enforceMemoryLimit();
 	}
 
-	function touchMemory(
-		key: string,
-		entry: MemoryEntry,
-		currentTime: number,
-	): void {
+	function touchMemory(key: string, entry: MemoryEntry, currentTime: number): void {
 		backend.memory.delete(key);
 		backend.memory.set(key, { ...entry, lastAccessedAt: currentTime });
 	}
@@ -298,12 +275,7 @@ export function createProviderCache(
 			if (memoryEntry.expiresAt <= currentTime) {
 				backend.memory.delete(key);
 			} else {
-				const memoryResult = resultFromEnvelope<T>(
-					key,
-					memoryEntry,
-					currentTime,
-					"memory",
-				);
+				const memoryResult = resultFromEnvelope<T>(key, memoryEntry, currentTime, "memory");
 				if (memoryResult && !memoryResult.meta.stale) {
 					touchMemory(key, memoryEntry, currentTime);
 					return memoryResult;
@@ -334,10 +306,7 @@ export function createProviderCache(
 		cacheOptions: ProviderCacheGetOrSetOptions,
 	): Promise<void> {
 		const currentTime = now();
-		const freshTtlMs = jitteredTtlMs(
-			cacheOptions.ttlMs,
-			cacheOptions.jitterPct,
-		);
+		const freshTtlMs = jitteredTtlMs(cacheOptions.ttlMs, cacheOptions.jitterPct);
 		const staleIfErrorMs = cacheOptions.staleIfErrorMs ?? 0;
 		const staleTtlMs = freshTtlMs + staleIfErrorMs;
 		const envelope: CacheEnvelope = {
@@ -352,9 +321,7 @@ export function createProviderCache(
 		if (!redis || !(await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))) {
 			return;
 		}
-		await withRedisFallback(() =>
-			redis.set(key, JSON.stringify(envelope), "PX", staleTtlMs),
-		);
+		await withRedisFallback(() => redis.set(key, JSON.stringify(envelope), "PX", staleTtlMs));
 	}
 
 	async function loadAndStore<T>(
@@ -385,16 +352,12 @@ export function createProviderCache(
 
 	return {
 		key(namespace, parts, keyOptions?: ProviderCacheKeyOptions) {
-			const extra = new Set(
-				(keyOptions?.redactFields ?? []).map((field) => field.toLowerCase()),
-			);
+			const extra = new Set((keyOptions?.redactFields ?? []).map((field) => field.toLowerCase()));
 			const normalized = normalizeKeyPart(parts, extra);
 			return `${DEFAULT_PREFIX}:${options.providerId}:${namespace}:${stableHash(normalized)}`;
 		},
 
-		async get<T = unknown>(
-			key: string,
-		): Promise<ProviderCacheResult<T> | null> {
+		async get<T = unknown>(key: string): Promise<ProviderCacheResult<T> | null> {
 			const result = await read<T>(key);
 			if (result) record(result.meta);
 			return result;
@@ -405,10 +368,7 @@ export function createProviderCache(
 		async delete(key: string): Promise<void> {
 			backend.memory.delete(key);
 			const redis = backend.redis;
-			if (
-				!redis ||
-				!(await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))
-			) {
+			if (!redis || !(await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))) {
 				return;
 			}
 			await withRedisFallback(() => redis.del(key));
@@ -428,10 +388,7 @@ export function createProviderCache(
 			const existingInflight = backend.inflight.get(key);
 			if (existingInflight) {
 				const inflightResult = await existingInflight;
-				const result = resultWithValue<T>(
-					inflightResult.value,
-					inflightResult.meta,
-				);
+				const result = resultWithValue<T>(inflightResult.value, inflightResult.meta);
 				record(result.meta);
 				return result;
 			}
@@ -470,16 +427,12 @@ export function createBypassProviderCache(
 
 	return {
 		key(namespace, parts, keyOptions?: ProviderCacheKeyOptions) {
-			const extra = new Set(
-				(keyOptions?.redactFields ?? []).map((field) => field.toLowerCase()),
-			);
+			const extra = new Set((keyOptions?.redactFields ?? []).map((field) => field.toLowerCase()));
 			const normalized = normalizeKeyPart(parts, extra);
 			return `${DEFAULT_PREFIX}:${options.providerId}:${namespace}:${stableHash(normalized)}`;
 		},
 
-		async get<T = unknown>(
-			_key: string,
-		): Promise<ProviderCacheResult<T> | null> {
+		async get<T = unknown>(_key: string): Promise<ProviderCacheResult<T> | null> {
 			return null;
 		},
 

package/src/runtime/choice.ts

@@ -10,8 +10,8 @@ import {
 	assertFreshProviderChoiceIssuedAt,
 	ProviderChoiceTokenError,
 	type ProviderChoiceTokenPayload,
-} from "../choice-token";
-import { ProviderError } from "../errors";
+} from "../choice-token.js";
+import { ProviderError } from "../errors.js";
 import type {
 	CredentialContext,
 	EnvContext,
@@ -23,7 +23,7 @@ import type {
 	ProviderRequestContext,
 	ProviderRuntimeState,
 	ProviderStateDurationString,
-} from "../types";
+} from "../types.js";
 
 export const PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV =
 	"APIFUSE__PROVIDER_RUNTIME__CHOICE_TOKEN_MASTER_SECRET";
@@ -74,18 +74,12 @@ export function createProviderChoiceContext(
 	): string;
 	function issue<TPayload extends ProviderChoiceTokenPayload>(
 		issueOptions: ProviderChoiceIssueOptions<TPayload> & {
-			readonly storage: Extract<
-				ProviderChoiceStorageOptions,
-				{ readonly mode: "server" }
-			>;
+			readonly storage: Extract<ProviderChoiceStorageOptions, { readonly mode: "server" }>;
 		},
 	): Promise<string>;
 	function issue<TPayload extends ProviderChoiceTokenPayload>(
 		issueOptions: ProviderChoiceIssueOptions<TPayload> & {
-			readonly storage: Extract<
-				ProviderChoiceStorageOptions,
-				{ readonly mode: "auto" }
-			>;
+			readonly storage: Extract<ProviderChoiceStorageOptions, { readonly mode: "auto" }>;
 		},
 	): string | Promise<string>;
 	function issue<TPayload extends ProviderChoiceTokenPayload>(
@@ -112,10 +106,7 @@ export function createProviderChoiceContext(
 				required: true,
 			}),
 		};
-		const resolvedStorage = resolveIssueStorage(
-			issueOptions.storage,
-			issueOptions.payload,
-		);
+		const resolvedStorage = resolveIssueStorage(issueOptions.storage, issueOptions.payload);
 		if (resolvedStorage.mode === "server") {
 			return issueServerStoredChoice({
 				baseEnvelope,
@@ -146,31 +137,19 @@ export function createProviderChoiceContext(
 	): ProviderChoiceTokenPayload;
 	function parse(
 		parseOptions: ProviderChoiceParseOptions & {
-			readonly storage: Extract<
-				ProviderChoiceStorageOptions,
-				{ readonly mode: "server" }
-			>;
+			readonly storage: Extract<ProviderChoiceStorageOptions, { readonly mode: "server" }>;
 		},
 	): Promise<ProviderChoiceTokenPayload>;
 	function parse(
 		parseOptions: ProviderChoiceParseOptions & {
-			readonly storage: Extract<
-				ProviderChoiceStorageOptions,
-				{ readonly mode: "auto" }
-			>;
+			readonly storage: Extract<ProviderChoiceStorageOptions, { readonly mode: "auto" }>;
 		},
 	): ProviderChoiceTokenPayload | Promise<ProviderChoiceTokenPayload>;
 	function parse(
 		parseOptions: ProviderChoiceParseOptions,
 	): ProviderChoiceTokenPayload | Promise<ProviderChoiceTokenPayload> {
-		const [
-			actualPrefix,
-			tokenKid,
-			encodedIv,
-			encryptedPayload,
-			authTag,
-			signature,
-		] = parseManagedChoiceTokenParts(parseOptions.token);
+		const [actualPrefix, tokenKid, encodedIv, encryptedPayload, authTag, signature] =
+			parseManagedChoiceTokenParts(parseOptions.token);
 		if (
 			actualPrefix !== parseOptions.prefix ||
 			tokenKid !== kid ||
@@ -191,13 +170,9 @@ export function createProviderChoiceContext(
 			purpose: parseOptions.purpose,
 			kid: tokenKid,
 		});
-		const signedBody = [
-			parseOptions.prefix,
-			tokenKid,
-			encodedIv,
-			encryptedPayload,
-			authTag,
-		].join(".");
+		const signedBody = [parseOptions.prefix, tokenKid, encodedIv, encryptedPayload, authTag].join(
+			".",
+		);
 		assertManagedChoiceSignature({
 			signedBody,
 			signature,
@@ -247,30 +222,23 @@ export function createTestProviderChoiceContext(
 	return createProviderChoiceContext({
 		...options,
 		masterSecret:
-			options.masterSecret ??
-			"apifuse-test-provider-runtime-choice-token-master-secret",
+			options.masterSecret ?? "apifuse-test-provider-runtime-choice-token-master-secret",
 	});
 }
 
-function resolveChoiceMasterSecret(
-	options: CreateProviderChoiceContextOptions,
-): string {
+function resolveChoiceMasterSecret(options: CreateProviderChoiceContextOptions): string {
 	const configured =
-		options.masterSecret ??
-		options.env?.get(PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV);
+		options.masterSecret ?? options.env?.get(PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV);
 	const trimmed = configured?.trim();
 	if (trimmed) return trimmed;
-	throw new ProviderError(
-		"Provider runtime choice-token master secret is not configured.",
-		{
-			code: "CHOICE_TOKEN_MASTER_SECRET_NOT_CONFIGURED",
-			category: "internal_error",
-			retryable: false,
-			details: {
-				secret: PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
-			},
+	throw new ProviderError("Provider runtime choice-token master secret is not configured.", {
+		code: "CHOICE_TOKEN_MASTER_SECRET_NOT_CONFIGURED",
+		category: "internal_error",
+		retryable: false,
+		details: {
+			secret: PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
 		},
-	);
+	});
 }
 
 type ManagedChoiceKeyInput = {
@@ -286,9 +254,7 @@ type ManagedChoiceKeys = {
 	readonly binding: Buffer;
 };
 
-function deriveManagedChoiceKeys(
-	input: ManagedChoiceKeyInput,
-): ManagedChoiceKeys {
+function deriveManagedChoiceKeys(input: ManagedChoiceKeyInput): ManagedChoiceKeys {
 	return {
 		encryption: deriveManagedChoiceKey(input, "encryption"),
 		signing: deriveManagedChoiceKey(input, "signing"),
@@ -327,22 +293,14 @@ function encryptManagedChoiceToken(options: {
 	]).toString("base64url");
 	const authTag = cipher.getAuthTag().toString("base64url");
 	const encodedIv = iv.toString("base64url");
-	const signedBody = [
-		options.prefix,
-		options.kid,
-		encodedIv,
-		encryptedPayload,
-		authTag,
-	].join(".");
+	const signedBody = [options.prefix, options.kid, encodedIv, encryptedPayload, authTag].join(".");
 	const signature = createHmac("sha256", options.keys.signing)
 		.update(signedBody)
 		.digest("base64url");
 	return `${signedBody}.${signature}`;
 }
 
-async function issueServerStoredChoice<
-	TPayload extends ProviderChoiceTokenPayload,
->(options: {
+async function issueServerStoredChoice<TPayload extends ProviderChoiceTokenPayload>(options: {
 	readonly baseEnvelope: Omit<ManagedChoiceEnvelope, "payload">;
 	readonly issueOptions: ProviderChoiceIssueOptions<TPayload>;
 	readonly storage: ServerProviderChoiceStorageOptions;
@@ -351,23 +309,18 @@ async function issueServerStoredChoice<
 	readonly keys: ManagedChoiceKeys;
 	readonly issuedAtMs: number;
 }): Promise<string> {
-	const serializedPayload = serializeChoicePayload(
-		options.issueOptions.payload,
-	);
+	const serializedPayload = serializeChoicePayload(options.issueOptions.payload);
 	const payloadBytes = Buffer.byteLength(serializedPayload, "utf8");
 	if (payloadBytes > options.storage.maxValueBytes) {
-		throw new ProviderError(
-			"Provider choice payload exceeds state storage policy.",
-			{
-				code: "CHOICE_STATE_PAYLOAD_TOO_LARGE",
-				category: "input_validation",
-				retryable: false,
-				details: {
-					maxValueBytes: options.storage.maxValueBytes,
-					payloadBytes,
-				},
+		throw new ProviderError("Provider choice payload exceeds state storage policy.", {
+			code: "CHOICE_STATE_PAYLOAD_TOO_LARGE",
+			category: "input_validation",
+			retryable: false,
+			details: {
+				maxValueBytes: options.storage.maxValueBytes,
+				payloadBytes,
 			},
-		);
+		});
 	}
 	const stateId = `choice_${randomBytes(16).toString("base64url")}`;
 	const digest = digestChoicePayload(serializedPayload);
@@ -439,10 +392,7 @@ function resolveIssueStorage<TPayload extends ProviderChoiceTokenPayload>(
 	  } {
 	if (!storage || storage.mode === "inline") return { mode: "inline" };
 	if (storage.mode === "server") return { mode: "server", storage };
-	const payloadBytes = Buffer.byteLength(
-		serializeChoicePayload(payload),
-		"utf8",
-	);
+	const payloadBytes = Buffer.byteLength(serializeChoicePayload(payload), "utf8");
 	if (payloadBytes <= storage.maxInlineBytes) return { mode: "inline" };
 	return { mode: "server", storage };
 }
@@ -536,10 +486,7 @@ function parseManagedChoiceTokenParts(
 ] {
 	const parts = token.split(".");
 	if (parts.length !== 6) {
-		throw new ProviderChoiceTokenError(
-			"invalid_shape",
-			"Provider choice token shape is invalid.",
-		);
+		throw new ProviderChoiceTokenError("invalid_shape", "Provider choice token shape is invalid.");
 	}
 	return [parts[0], parts[1], parts[2], parts[3], parts[4], parts[5]];
 }
@@ -601,9 +548,7 @@ function decryptManagedChoiceToken(options: {
 	}
 }
 
-function isManagedChoiceEnvelope(
-	value: unknown,
-): value is ManagedChoiceEnvelope {
+function isManagedChoiceEnvelope(value: unknown): value is ManagedChoiceEnvelope {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	if (!("payload" in value) || !isChoicePayload(value.payload)) return false;
 	return (
@@ -617,9 +562,7 @@ function isManagedChoiceEnvelope(
 		typeof value.issued_at_ms === "number" &&
 		"ttl_ms" in value &&
 		typeof value.ttl_ms === "number" &&
-		(!("binding" in value) ||
-			value.binding === undefined ||
-			isChoiceBinding(value.binding))
+		(!("binding" in value) || value.binding === undefined || isChoiceBinding(value.binding))
 	);
 }
 
@@ -627,13 +570,10 @@ function isChoicePayload(value: unknown): value is ProviderChoiceTokenPayload {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-function isChoiceBinding(
-	value: unknown,
-): value is ManagedChoiceEnvelope["binding"] {
+function isChoiceBinding(value: unknown): value is ManagedChoiceEnvelope["binding"] {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	return (
-		(!("connection_hash" in value) ||
-			typeof value.connection_hash === "string") &&
+		(!("connection_hash" in value) || typeof value.connection_hash === "string") &&
 		(!("credential_hash" in value) || typeof value.credential_hash === "string")
 	);
 }
@@ -648,10 +588,7 @@ function assertManagedChoiceEnvelope(
 		readonly futureToleranceMs?: number;
 	},
 ): void {
-	if (
-		envelope.provider_id !== options.providerId ||
-		envelope.purpose !== options.purpose
-	) {
+	if (envelope.provider_id !== options.providerId || envelope.purpose !== options.purpose) {
 		throw new ProviderChoiceTokenError(
 			"invalid_payload",
 			"Provider choice token payload is invalid.",
@@ -660,10 +597,7 @@ function assertManagedChoiceEnvelope(
 	assertFreshProviderChoiceIssuedAt(envelope.issued_at_ms, {
 		// Clamp to the issuer's embedded TTL so a caller-supplied value cannot
 		// silently extend token validity past the deadline the issuer intended.
-		ttlMs:
-			options.ttlMs != null
-				? Math.min(options.ttlMs, envelope.ttl_ms)
-				: envelope.ttl_ms,
+		ttlMs: options.ttlMs != null ? Math.min(options.ttlMs, envelope.ttl_ms) : envelope.ttl_ms,
 		nowMs: options.nowMs,
 		futureToleranceMs: options.futureToleranceMs,
 	});
@@ -676,9 +610,7 @@ function createChoiceBinding(options: {
 	readonly credential?: CredentialContext;
 	readonly required: boolean;
 }): ManagedChoiceEnvelope["binding"] {
-	const connectionHash = options.options?.connection
-		? hashRequiredConnection(options)
-		: undefined;
+	const connectionHash = options.options?.connection ? hashRequiredConnection(options) : undefined;
 	const credentialHash = options.options?.credentialKeys?.length
 		? hashCredentialKeys(options)
 		: undefined;
@@ -697,14 +629,11 @@ function hashRequiredConnection(options: {
 	const connectionId = options.request?.connectionId;
 	if (!connectionId) {
 		if (!options.required) return undefined;
-		throw new ProviderError(
-			"Provider choice tokens require connection context.",
-			{
-				code: "CHOICE_CONTEXT_REQUIRED",
-				category: "input_validation",
-				retryable: false,
-			},
-		);
+		throw new ProviderError("Provider choice tokens require connection context.", {
+			code: "CHOICE_CONTEXT_REQUIRED",
+			category: "input_validation",
+			retryable: false,
+		});
 	}
 	return createHmac("sha256", options.keys.binding)
 		.update("connection")
@@ -722,15 +651,12 @@ function hashCredentialKeys(options: {
 	const material = credentialKeys.map((key) => {
 		const value = options.credential?.get(key);
 		if (typeof value !== "string" || value.length === 0) {
-			throw new ProviderError(
-				"Provider choice tokens require configured credential binding.",
-				{
-					code: "CHOICE_CONTEXT_REQUIRED",
-					category: "input_validation",
-					retryable: false,
-					details: { credentialKey: key },
-				},
-			);
+			throw new ProviderError("Provider choice tokens require configured credential binding.", {
+				code: "CHOICE_CONTEXT_REQUIRED",
+				category: "input_validation",
+				retryable: false,
+				details: { credentialKey: key },
+			});
 		}
 		return [key, value];
 	});

package/src/runtime/credential.ts

@@ -1,5 +1,5 @@
-import { CredentialModeError } from "../errors";
-import type { AuthMode, CredentialContext } from "../types";
+import { CredentialModeError } from "../errors.js";
+import type { AuthMode, CredentialContext } from "../types.js";
 
 export interface CreateCredentialContextOptions {
 	allowedKeys?: string[];

package/src/runtime/env.ts

@@ -1,4 +1,4 @@
-import type { EnvContext } from "../types";
+import type { EnvContext } from "../types.js";
 
 export function createEnvContext(allowedKeys?: string[]): EnvContext {
 	return {

package/src/runtime/executor.ts

@@ -1,11 +1,8 @@
-import { ProviderError, SessionExpiredError } from "../errors";
-import { parseSchema } from "../schema";
-import type { ProviderContext, ProviderDefinition } from "../types";
+import { isSessionExpiredError, ProviderError, SessionExpiredError } from "../errors.js";
+import { parseSchema } from "../schema.js";
+import type { ProviderContext, ProviderDefinition } from "../types.js";
 
-export function isStreamingOperation(
-	provider: ProviderDefinition,
-	operationId: string,
-): boolean {
+export function isStreamingOperation(provider: ProviderDefinition, operationId: string): boolean {
 	const kind = provider.operations[operationId]?.transport?.kind ?? "json";
 	return kind !== "json";
 }
@@ -31,13 +28,10 @@ export async function executeOperation(
 	const operation = provider.operations[operationId];
 
 	if (!operation) {
-		throw new ProviderError(
-			`Unknown operation: ${provider.id}/${operationId}`,
-			{
-				code: "NOT_FOUND",
-				fix: `Valid operations: ${Object.keys(provider.operations).join(", ")}`,
-			},
-		);
+		throw new ProviderError(`Unknown operation: ${provider.id}/${operationId}`, {
+			code: "NOT_FOUND",
+			fix: `Valid operations: ${Object.keys(provider.operations).join(", ")}`,
+		});
 	}
 
 	const validatedInput = await parseSchema(
@@ -64,7 +58,12 @@ export async function executeOperation(
 		// operation is safe to re-drive after refresh, which we signal by marking
 		// the surfaced error retryable; non-idempotent operations (the default)
 		// stay non-retryable so they are not auto-re-driven. See design.md §4.3 D3.
-		if (error instanceof SessionExpiredError && operation.retryOnAuthRefresh) {
+		// Use the branded guard, not `instanceof`: a handler loaded through a
+		// duplicate/published SDK module can throw a correctly branded
+		// SessionExpiredError whose constructor identity differs from this
+		// executor's, which `instanceof` would miss — dropping the retryable
+		// upgrade and stranding an operation that opted into auth refresh.
+		if (isSessionExpiredError(error) && operation.retryOnAuthRefresh) {
 			throw new SessionExpiredError(error.message, { retryable: true });
 		}
 		throw error;
@@ -74,9 +73,5 @@ export async function executeOperation(
 		return result;
 	}
 
-	return parseSchema(
-		operation.output,
-		result,
-		`operations.${operationId}.output`,
-	);
+	return parseSchema(operation.output, result, `operations.${operationId}.output`);
 }

package/src/runtime/http.ts

@@ -1,7 +1,7 @@
-import type { ProxyResolutionOptions } from "../config/loader";
-import { resolveProxyConfigAsync } from "../config/loader";
-import { ProviderError, TransportError } from "../errors";
-import { parseSseStream, readableBytes, readableLines, readableTextChunks } from "../stream";
+import type { ProxyResolutionOptions } from "../config/loader.js";
+import { resolveProxyConfigAsync } from "../config/loader.js";
+import { ProviderError, TransportError } from "../errors.js";
+import { parseSseStream, readableBytes, readableLines, readableTextChunks } from "../stream.js";
 import type {
 	HttpClient,
 	HttpMethod,
@@ -11,7 +11,7 @@ import type {
 	RequestOptions,
 	RequestWithMethodOptions,
 	SseMessage,
-} from "../types";
+} from "../types.js";
 import {
 	computeProxyAttemptIndex,
 	computeProxyTransportRetryDelayMs,
@@ -22,8 +22,8 @@ import {
 	proxyTransportRetryErrorStatus,
 	shouldRetryProxyTransportAttempt,
 	validateUnsafeProxyTransportRetryMethods,
-} from "./proxy-retry-policy";
-import { appendQueryParams, normalizeHttpRequestBody } from "./request-options";
+} from "./proxy-retry-policy.js";
+import { appendQueryParams, normalizeHttpRequestBody } from "./request-options.js";
 
 const DEFAULT_HTTP_BASE_URL = "http://localhost";