pi-ai: một API cho mọi mô hình

// Generic StreamFunction with typed options.//// Contract:// - Receives a normalized transcript: the system prompt and tools live in the//   leading system message, never on the context itself.// - Must return an AssistantMessageEventStream.// - Direct streamSimple() calls may throw synchronously when request auth is//   missing. Once a stream is returned, request/model/runtime failures should//   be encoded in that stream.// - Error termination must produce an AssistantMessage with stopReason//   "error" or "aborted" and errorMessage, emitted via the stream protocol.export type StreamFunction<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> = (	model: Model<TApi>,	context: TranscriptContext,	options?: TOptions,) => AssistantMessageEventStream;

export type KnownApi =	| "openai-completions"	| "mistral-conversations"	| "openai-responses"	| "azure-openai-responses"	| "openai-codex-responses"	| "anthropic-messages"	| "bedrock-converse-stream"	| "google-generative-ai"	| "google-vertex"	| "pi-messages";export type Api = KnownApi | (string & {});

/** Fields shared by every catalog entry, regardless of what you can do with it. */export interface BaseModel<TApi extends string> {	id: string;	name: string;	api: TApi;	provider: ProviderId;	baseUrl: string;	input: ModelInputModality[];	/** Provider input limits and cache-safe preprocessing metadata. */	inputLimits?: ModelInputLimits;	cost: ModelCost;	headers?: Record<string, string>;}/** Chat model: usable with `stream()` and friends. */export interface Model<TApi extends Api> extends BaseModel<TApi> {	/**	 * Optional: chat is the default model type, so models without `type` are chat	 * models. Narrow mixed model lists with `isModelType()` instead of comparing	 * `type` directly.	 */	type?: "chat";	reasoning: boolean;	/**	 * Maps pi thinking levels to provider/model-specific values.	 * Missing keys use provider defaults. null marks a level as unsupported.	 */	thinkingLevelMap?: ThinkingLevelMap;	/** Prompt cache lifetimes per retention tier. Unset when the provider's cache behavior is unknown. */	promptCache?: ModelPromptCache;	contextWindow: number;	maxTokens: number;	/** Default sampling parameters for this model. See {@link StreamOptions.samplingParams}; per-request keys override these. */	samplingParams?: SamplingParams;	/** Sampling parameter overrides selected by the effective pi thinking level. */	samplingParamsByThinkingLevel?: SamplingParamsByThinkingLevel;

	/** Compatibility overrides for OpenAI-compatible APIs. If not set, auto-detected from baseUrl. */	compat?: TApi extends "openai-completions"		? OpenAICompletionsCompat		: TApi extends "openai-responses" | "azure-openai-responses" | "openai-codex-responses"			? OpenAIResponsesCompat			: TApi extends "anthropic-messages"				? AnthropicMessagesCompat				: TApi extends "bedrock-converse-stream"					? BedrockCompat					: TApi extends "mistral-conversations"						? MistralConversationsCompat						: never;}

export const THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;export const MODEL_THINKING_LEVELS = ["off", ...THINKING_LEVELS] as const;export const MODEL_INPUT_MODALITIES = ["text", "image"] as const;export const CACHE_RETENTIONS = ["none", "short", "long"] as const;export const MODEL_PROMPT_CACHE_RETENTIONS = ["short", "long"] as const;⋯ lược bớt dòng 8–13const ThinkingLevelMapValueSchema = Type.Union([Type.String(), Type.Null()]);export const ThinkingLevelMapSchema = Type.Partial(Type.Record(ModelThinkingLevelSchema, ThinkingLevelMapValueSchema), {	description:		"Provider value sent for each thinking level. null marks a level unsupported. Levels the model does not map use the provider's default value through high; xhigh and max are unsupported.",});⋯ lược bớt dòng 19–27const ModelCostRatesProperties = {	input: Type.Number({ description: "Input cost in USD per million tokens." }),	output: Type.Number({ description: "Output cost in USD per million tokens." }),	cacheRead: Type.Number({ description: "Cache-read cost in USD per million tokens." }),	cacheWrite: Type.Number({ description: "Cache-write cost in USD per million tokens." }),};export const ModelCostRatesSchema = Type.Object(ModelCostRatesProperties);export const ModelCostTierSchema = Type.Object({	inputTokensAbove: Type.Number({		description: "Use this tier when total request input exceeds this token count.",	}),	...ModelCostRatesProperties,});export const ModelCostSchema = Type.Object({	...ModelCostRatesProperties,	tiers: Type.Optional(		Type.Array(ModelCostTierSchema, {			description: "Request-wide pricing tiers. The highest matching input threshold applies to the full request.",		}),	),});

const ollamaModel: Model<'openai-completions'> = {  id: 'llama-3.1-8b',  name: 'Llama 3.1 8B (Ollama)',  api: 'openai-completions',  provider: 'ollama',  baseUrl: 'http://localhost:11434/v1',  reasoning: false,  input: ['text'],  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },  contextWindow: 128000,  maxTokens: 32000};

/** * Request input accepted by the public stream entry points (`Models.stream()`, * `streamSimple()`, ...). `systemPrompt` and `tools` are shorthand for a leading * system message; `normalizeContext()` folds them into one before the request * reaches a provider. */export interface Context {	systemPrompt?: string;	messages: Message[];	tools?: Tool[];}declare const transcriptContextBrand: unique symbol;/** * Normalized request context passed to providers and API implementations. The * prompt and tool declarations are carried by the transcript's system messages. * Only `normalizeContext()` produces this type, so a raw `Context` cannot reach * provider code by accident. */export type TranscriptContext = {	messages: Message[];	readonly [transcriptContextBrand]: true;};

export function createInitialSystemMessage(	systemPrompt: string | undefined,	tools: Tool[] | undefined,): SystemMessage | undefined {	const hasSystemPrompt = systemPrompt !== undefined && systemPrompt.length > 0;	const hasTools = tools !== undefined && tools.length > 0;	if (!hasSystemPrompt && !hasTools) return undefined;	return {		role: "system",		content: systemPrompt ?? "",		...(hasTools ? { toolsAdded: tools } : {}),		timestamp: 0,	};}/** * Fold `Context.systemPrompt` and `Context.tools` into a leading system message. * This is the only entry point that produces a {@link TranscriptContext}; every * provider-facing function expects the result. */export function normalizeContext(context: Context): TranscriptContext {	const initialMessage = createInitialSystemMessage(context.systemPrompt, context.tools);	const messages = initialMessage ? [initialMessage, ...context.messages] : context.messages;	return { messages } as TranscriptContext;}

/** * System instructions and tool declarations at one point in the transcript. * * The leading system message is the system prompt. Later system messages change it: * `content` adds instructions from that point on, `sections` replace or remove named * prompt sections, and `toolsAdded`/`toolsRemoved` change the tool set. Replaying * every system message in order yields the current prompt and tools. Providers that * accept system messages mid-conversation send each one in place; other providers * rebuild the leading system message from the replayed state. */export interface SystemMessage {	role: "system";	/** Instruction text. On the leading message this is the base prompt; later, additional instructions. */	content: string | TextContent[];	/**	 * Named, ordered prompt sections rendered verbatim after `content`. The leading message	 * declares them; later messages replace sections by name, and `null` removes one. Keep	 * each section self-delimiting (a tag, a heading) so the model can relate an update to	 * the original. Avoid integer-like names; JSON objects reorder those.	 */	sections?: Record<string, string | null>;	/** Complete definitions of tools that become available at this point. */	toolsAdded?: Tool[];	/** Tools that stop being available at this point. */	toolsRemoved?: ToolReference[];	timestamp: number; // Unix timestamp in milliseconds}export interface UserMessage {	role: "user";	content: string | (TextContent | ImageContent)[];	timestamp: number; // Unix timestamp in milliseconds}

export interface AssistantMessage {	role: "assistant";	content: (TextContent | ThinkingContent | ToolCall)[];	api: Api;	provider: ProviderId;	model: string;	responseModel?: string; // Concrete model reported by the provider when different from the requested `model`	responseId?: string; // Provider-specific response/message identifier when the upstream API exposes one	/** Exact provider-native effort level used for this response. Absent for legacy or unmanaged responses. */	providerThinkingLevel?: string;	/** Pi thinking level the agent loop requested for this response. Absent outside the agent loop and for legacy responses. */	thinkingLevel?: ModelThinkingLevel;	diagnostics?: AssistantMessageDiagnostic[]; // Redacted provider/runtime diagnostics for failures and recoveries.	usage: Usage;	stopReason: StopReason;	deferred?: DeferredHandle;	errorMessage?: string;	rawStopReason?: string;	/**	 * Provider indication of whether the model explicitly ended its turn.	 * Preserved for debugging and does not currently affect agent control flow.	 */	endTurn?: boolean;	/** Unix timestamp in milliseconds when the request started. */	timestamp: number;	/**	 * Milliseconds from `timestamp` until the response ended, measured with a monotonic clock. Set by	 * `AssistantMessageEventStream` on the final message of a response it saw start; absent for legacy messages and	 * for deferred results fetched later.	 */	durationMs?: number;}

export type ToolResultMessage<TDetails = JsonValue> = IsJsonCompatible<TDetails> extends true	? {			role: "toolResult";			toolCallId: string;			toolName: string;			content: (TextContent | ImageContent)[]; // Supports text and images			details?: JsonRepresentation<TDetails>;			/** Usage from the tool execution itself, if available. Not part of main LLM context accounting. */			usage?: Usage;			/** Calls this tool made to other tools. Kept for the session record; not sent to the model. */			nestedCalls?: NestedToolCalls;			isError: boolean;			/** Unix timestamp in milliseconds when the result was created. */			timestamp: number;			/** Milliseconds the tool's execution took, measured with a monotonic clock. Absent for legacy results. */			durationMs?: number;		}	: never;export type Message = SystemMessage | UserMessage | AssistantMessage | ToolResultMessage;

export interface TextContent {	type: "text";	text: string;	textSignature?: string; // e.g., for OpenAI responses, message metadata (legacy id string or TextSignatureV1 JSON)}export interface ThinkingContent {	type: "thinking";	thinking: string;	thinkingSignature?: string; // Provider-specific opaque or serialized reasoning replay data	/** When true, the thinking content was redacted by safety filters. The opaque	 *  encrypted payload is stored in `thinkingSignature` so it can be passed back	 *  to the API for multi-turn continuity. */	redacted?: boolean;}export interface ImageContent {	type: "image";	data: string; // base64 encoded image data	mimeType: string; // e.g., "image/jpeg", "image/png"}export interface ToolCall {	type: "toolCall";	id: string;	name: string;	arguments: JsonObject;	thoughtSignature?: string; // Google-specific: opaque signature for reusing thought context	/** OpenAI Responses namespace for calls to dynamically loaded or namespaced tools. */	namespace?: string;	/**	 * Set when the model's complete arguments text was not a valid JSON object. `arguments` is then `{}`.	 * Describes the problem and includes the text the model sent; tool argument validation fails with it.	 */	argumentsError?: string;}

export interface Usage {	input: number;	output: number;	cacheRead: number;	cacheWrite: number;	/** Subset of `cacheWrite` written with 1h retention. Only Anthropic reports this split. */	cacheWrite1h?: number;	/**	 * Reasoning/thinking tokens, when the provider reports them. This is a subset of	 * `output`: `output` already includes these tokens. Set to a number (possibly 0) by	 * providers that expose a reasoning breakdown; left undefined by providers that don't.	 */	reasoning?: number;	totalTokens: number;	cost: {		input: number;		output: number;		cacheRead: number;		cacheWrite: number;		total: number;	};}export type StopReason = "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";

export function calculateCost(model: AnyModel, usage: Usage): Usage["cost"] {	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;	let rates: ModelCostRates = model.cost;	let matchedThreshold = -1;	for (const tier of model.cost.tiers ?? []) {		if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {			rates = tier;			matchedThreshold = tier.inputTokensAbove;		}	}	// Anthropic charges 2x base input for 1h cache writes.	const longWrite = usage.cacheWrite1h ?? 0;	const shortWrite = usage.cacheWrite - longWrite;	usage.cost.input = (rates.input / 1000000) * usage.input;	usage.cost.output = (rates.output / 1000000) * usage.output;	usage.cost.cacheRead = (rates.cacheRead / 1000000) * usage.cacheRead;	usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1000000;	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;	return usage.cost;}

/** OpenAI grammar variants for constrained sampling. */export type GrammarFormat = "openai_lark" | "openai_regex";export type GrammarVariants = Partial<Record<GrammarFormat, string>>;/** * Optional provider-side constrained sampling configs for a tool. * * The `json_schema` value roughly maps to the concept of `strict` in APIs which is * implemented as json-schema constrained sampling by APIs. Grammar variants let * callers provide provider-specific encodings of the same intended language. */export type ConstrainedSamplingConfig =	| {			type: "json_schema";			strict: "prefer" | "require";	  }	| {			type: "grammar";			variants: GrammarVariants;	  };export interface Tool<TParameters extends TSchema = TSchema> {	name: string;	description: string;	parameters: TParameters;	constrainedSampling?: false | ConstrainedSamplingConfig;}export interface ToolReference {	name: string;}

export function validateToolArguments(tool: Tool, toolCall: ToolCall): any {	if (toolCall.argumentsError) {		throw new Error(`Invalid arguments for tool "${toolCall.name}": ${toolCall.argumentsError}`);	}	const args = structuredClone(toolCall.arguments);	normalizeOptionalNulls(args, tool.parameters as JsonSchemaObject);	Value.Convert(tool.parameters, args);	const validator = getValidator(tool.parameters);	if (!Object.getOwnPropertySymbols(tool.parameters).includes(TYPEBOX_KIND)) {		const coerced = coerceWithJsonSchema(args, tool.parameters as JsonSchemaObject);		if (coerced !== args) {			if (typeof args === "object" && args !== null && typeof coerced === "object" && coerced !== null) {				for (const key of Object.keys(args)) {					delete args[key];				}				Object.assign(args, coerced);			} else {				return validator.Check(coerced) ? coerced : args;			}		}	}	if (validator.Check(args)) {		return args;	}	const errors =		validator			.Errors(args)			.map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)			.join("\n") || "Unknown validation error";	const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`;	throw new Error(errorMessage);}

/** * Event protocol for AssistantMessageEventStream. * * Successful streams emit `start` before partial updates and terminate with * `done`. A stream may terminate directly with `error` when request setup fails * before generation starts; after `start`, failures also terminate with `error`. * Direct `streamSimple()` calls throw synchronously when request auth is missing. * Updates and `done` must never appear before `start`. * * `partial` is the shared live response-so-far helper, not an event-time * snapshot. Text and thinking blocks are empty when their `*_start` event is * emitted and grow only through their corresponding `*_delta` events until the * authoritative `*_end`. Redacted thinking may be complete at start and emit no * deltas. Tool-call arguments at `toolcall_start` are provider-specific; * `toolcall_delta` carries subsequent JSON updates. */export type AssistantMessageEvent =	| { type: "start"; partial: AssistantMessage }	| { type: "text_start"; contentIndex: number; partial: AssistantMessage }	| { type: "text_delta"; contentIndex: number; delta: string; partial: AssistantMessage }	| { type: "text_end"; contentIndex: number; content: string; partial: AssistantMessage }	| { type: "thinking_start"; contentIndex: number; partial: AssistantMessage }	| { type: "thinking_delta"; contentIndex: number; delta: string; partial: AssistantMessage }	| { type: "thinking_end"; contentIndex: number; content: string; partial: AssistantMessage }	| { type: "toolcall_start"; contentIndex: number; partial: AssistantMessage }	| { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage }	| { type: "toolcall_end"; contentIndex: number; toolCall: ToolCall; partial: AssistantMessage }	| {			type: "done";			reason: Extract<StopReason, "stop" | "length" | "toolUse" | "deferred">;			message: AssistantMessage;	  }	| { type: "error"; reason: Extract<StopReason, "aborted" | "error">; error: AssistantMessage };

push(event: T): void {	if (this.done) return;	if (this.isComplete(event)) {		this.done = true;		this.resolveFinalResult(this.extractResult(event));	}	// Deliver to waiting consumer or queue it	const waiter = this.waiting.dequeue();	if (waiter) {		waiter({ value: event, done: false });	} else {		this.queue.enqueue(event);	}}⋯ lược bớt dòng 59–71async *[Symbol.asyncIterator](): AsyncIterator<T> {	while (true) {		if (this.queue.length > 0) {			yield this.queue.dequeue()!;		} else if (this.done) {			return;		} else {			const result = await new Promise<IteratorResult<T>>((resolve) => this.waiting.enqueue(resolve));			if (result.done) return;			yield result.value;		}	}}result(): Promise<R> {	return this.finalResultPromise;}

export function lazyStream(	model: Model<Api>,	setup: () => Promise<AsyncIterable<AssistantMessageEvent>>,	observer?: LazyStreamObserver,): AssistantMessageEventStream {	const startedAt = Date.now();	const outer = new AssistantMessageEventStream();	let observedResult = false;	const observeResult = (result: AssistantMessage | undefined): void => {		if (observedResult) return;		observedResult = true;		observer?.onResult?.(result);	};	setup()		.then((inner) => forwardStream(outer, inner, observer, observeResult))		.catch((error) => {			const message = createSetupErrorMessage(model, error, startedAt);			const event: AssistantMessageEvent = { type: "error", reason: "error", error: message };			outer.push(event);			observer?.onEvent?.(event);			outer.end(message);			observeResult(message);		});	return outer;}

stream<TApi extends Api>(	model: Model<TApi>,	context: Context,	options?: ModelsApiStreamOptions<TApi>,): AssistantMessageEventStream {	const transcript = normalizeContext(context);	return lazyStream(		model,		async () => {			const provider = this.requireChatProvider(model);			const { requestModel, requestOptions } = await this.applyAuth(				model,				options as ModelsApiStreamOptions<Api> | undefined,			);			return provider.stream(requestModel, transcript, requestOptions as ApiStreamOptions<TApi>);		},		observeModelRequest(model, options, false),	);}async complete<TApi extends Api>(	model: Model<TApi>,	context: Context,	options?: ModelsApiStreamOptions<TApi>,): Promise<AssistantMessage> {	return this.stream(model, context, options).result();}

// Unified options with reasoning passed to streamSimple() and completeSimple()export interface SimpleStreamOptions extends StreamOptions {	/** Provider-neutral tool selection for simple requests. When omitted, adapters use provider-specific behavior. */	toolChoice?: ToolChoice;	reasoning?: ThinkingLevel;	/** Ask a capable provider to return a durable handle and continue the request asynchronously. */	deferred?: boolean | { window?: "15m" | "1h" | "24h" };	/** Custom token budgets for thinking levels (token-based providers only) */	thinkingBudgets?: ThinkingBudgets;}

const EXTENDED_THINKING_LEVELS: ModelThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];export function getSupportedThinkingLevels<TApi extends Api>(model: Model<TApi>): ModelThinkingLevel[] {	if (!model.reasoning) return ["off"];	return EXTENDED_THINKING_LEVELS.filter((level) => {		const mapped = model.thinkingLevelMap?.[level];		if (mapped === null) return false;		if (level === "xhigh" || level === "max") return mapped !== undefined;		return true;	});}export function clampThinkingLevel<TApi extends Api>(	model: Model<TApi>,	level: ModelThinkingLevel,): ModelThinkingLevel {	const availableLevels = getSupportedThinkingLevels(model);	if (availableLevels.includes(level)) return level;	const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);	if (requestedIndex === -1) return availableLevels[0] ?? "off";	for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {		const candidate = EXTENDED_THINKING_LEVELS[i];		if (availableLevels.includes(candidate)) return candidate;	}	for (let i = requestedIndex - 1; i >= 0; i--) {		const candidate = EXTENDED_THINKING_LEVELS[i];		if (availableLevels.includes(candidate)) return candidate;	}	return availableLevels[0] ?? "off";}

import { createModels } from '@earendil-works/pi-ai/models';import { openaiProvider } from '@earendil-works/pi-ai/providers/openai';const models = createModels();models.setProvider(openaiProvider());

	this.requireProvider(model);	const resolution = await this.getAuth(model, {		apiKey: options?.apiKey,		env: options?.env,		signal: options?.signal,	});	if (!resolution) {		throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);	}	const auth = resolution.auth;	// Explicit request options win per-field; the Models-only transform runs last.	const apiKey = options?.apiKey ?? auth.apiKey;	const requestModel: TModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;	const sessionId =		options && "sessionId" in options && typeof options.sessionId === "string" ? options.sessionId : undefined;	let headers = mergeHeaders(		mergeHeaders(getOpenCodeSessionHeaders(requestModel, sessionId), auth.headers),		options?.headers,	);	if (options?.transformHeaders) headers = await options.transformHeaders(headers ?? {});	const env = resolution.env || options?.env ? { ...(resolution.env ?? {}), ...(options?.env ?? {}) } : undefined;	const identity = mergeClientIdentity(this.identity, options?.identity);	const { transformHeaders: _transformHeaders, ...providerOptions } = options ?? {};	const requestOptions = {		...providerOptions,		apiKey,		headers,		env,		...(identity === undefined ? {} : { identity }),	} as Omit<TOptions, "transformHeaders"> & ProviderRequestOptions<TModel>;	return { requestModel, requestOptions };}

if (overrides?.apiKey !== undefined && provider.auth.apiKey) {	return resolveApiKey(		requestAuthContext,		provider.auth.apiKey,		provider.id,		{			type: "api_key",			key: overrides.apiKey,			env: overrides.env,		},		signal,	);}const stored = await readCredential(credentials, provider.id, signal);if (stored) {	if (stored.type === "oauth" && provider.auth.oauth) {		return resolveStoredOAuth(			credentials,			provider.id,			provider.auth.oauth,			stored,			signal,			overrides?.minOAuthValidityMs,		);	}	if (stored.type === "api_key" && provider.auth.apiKey) {		const credential = overrides?.env ? { ...stored, env: { ...stored.env, ...overrides.env } } : stored;		return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, credential, signal);	}	return undefined;}// Ambient (env vars, AWS profiles, ADC files).return provider.auth.apiKey	? resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, undefined, signal)	: undefined;

export function createProvider<TApi extends Api = Api>(input: CreateProviderOptions<TApi>): Provider<TApi> {	const single =		input.api && typeof (input.api as ProviderStreams).stream === "function"			? (input.api as ProviderStreams)			: undefined;	const byApi = single || !input.api ? undefined : (input.api as Partial<Record<string, ProviderStreams>>);	const images = input.images as Partial<Record<string, ProviderImages>> | undefined;	const classifiers = input.classifiers as Partial<Record<string, ProviderClassifier>> | undefined;	const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== undefined);	const imageImplementations = Object.values(images ?? {}).filter((entry) => entry !== undefined);	const classifierImplementations = Object.values(classifiers ?? {}).filter((entry) => entry !== undefined);	if (streams.length === 0 && imageImplementations.length === 0 && classifierImplementations.length === 0) {		throw new Error(`Provider ${input.id}: at least one of "api", "images", or "classifiers" is required.`);⋯ lược bớt dòng 1090–1094	const currentModels = (): readonly ProviderModel<TApi>[] => {		const merged = [...baselineModels];		for (const model of dynamicModels) {			const index = merged.findIndex(				(entry) => getModelType(entry) === getModelType(model) && entry.id === model.id,			);			if (index >= 0) merged[index] = model;			else merged.push(model);		}		return merged;	};	const apiFor = (model: Model<Api>): ProviderStreams | undefined => single ?? byApi?.[model.api];	const dispatch = (		model: Model<Api>,		run: (streams: ProviderStreams) => AssistantMessageEventStream,	): AssistantMessageEventStream => {		const streams = apiFor(model);		if (!streams) {			return lazyStream(model, async () => {				throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);			});		}		return run(streams);	};

export function anthropicProvider(): Provider<"anthropic-messages"> {	return createProvider({		id: "anthropic",		name: "Anthropic",		baseUrl: "https://api.anthropic.com",		auth: {			apiKey: anthropicApiKeyAuth(),			oauth: lazyOAuth({				name: "Anthropic (Claude Pro/Max)",				isSubscription: true,				load: loadAnthropicOAuth,			}),		},		models: Object.values(ANTHROPIC_MODELS),		api: anthropicMessagesApi(),	});}

"exports": {	".": {		"types": "./dist/index.d.ts",		"import": "./dist/index.js"	},	"./models": {		"types": "./dist/models.d.ts",		"import": "./dist/models.js"	},	"./compat": {		"types": "./dist/compat.d.ts",		"import": "./dist/compat.js"	},	"./providers/*": {		"types": "./dist/providers/*.d.ts",		"import": "./dist/providers/*.js"	},	"./api/*": {		"types": "./dist/api/*.d.ts",		"import": "./dist/api/*.js"	},	"./utils/*": {		"types": "./dist/utils/*.d.ts",		"import": "./dist/utils/*.js"	},	"./oauth": {		"types": "./dist/oauth.d.ts",		"import": "./dist/oauth.js"	},	"./bedrock-provider": {		"types": "./dist/bedrock-provider.d.ts",		"import": "./dist/bedrock-provider.js"	},	"./bun-oauth": {		"types": "./dist/bun-oauth.d.ts",		"import": "./dist/bun-oauth.js"	}},

export interface ClassifierChoiceQuestion {	type: "choice";	instructions: string;	criteria: Record<string, string>;}export interface ClassifierScoreQuestion {	type: "score";	instructions: string;	criteria: string[];}export interface ClassifierBoolQuestion {	type: "bool";	instructions: string;	criteria: { true: string; false: string };}export type ClassifierQuestion = ClassifierChoiceQuestion | ClassifierScoreQuestion | ClassifierBoolQuestion;export interface ClassifierContext {	state: JsonObject;	/**	 * Images judged together with `state`. Only models whose `input` includes `"image"` accept them;	 * other models return an error result.	 */	images?: ImageContent[];	questions: Record<string, ClassifierQuestion>;}

export const stream: StreamFunction<"anthropic-messages", AnthropicOptions> = (	model: Model<"anthropic-messages">,	context: TranscriptContext,	options?: AnthropicOptions,): AssistantMessageEventStream => {	const stream = new AssistantMessageEventStream();	const normalizedContext = resolveTranscript(context, getAnthropicCompat(model).supportsMidConvoSystemMessages);	const currentTools = getCurrentTools(normalizedContext.messages);	(async () => {		const output: AssistantMessage = {			role: "assistant",			content: [],			api: model.api as Api,			provider: model.provider,			model: model.id,			usage: {				input: 0,				output: 0,				cacheRead: 0,				cacheWrite: 0,				totalTokens: 0,				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },			},			stopReason: "pending",			timestamp: Date.now(),		};

// OAuth: Bearer auth, Claude Code identity headers instead of the client identity.if (apiKey && isOAuthToken(apiKey)) {	const client = new PiAnthropic({		apiKey: null,		authToken: apiKey,		baseURL: model.baseUrl,		dangerouslyAllowBrowser: true,		fetch,		defaultHeaders: mergeHeaders(			{				accept: "application/json",				"anthropic-dangerous-direct-browser-access": "true",				"user-agent": `claude-cli/${claudeCodeVersion}`,				"x-app": "cli",			},			model.headers,			optionsHeaders,		),	});	return { client, isOAuthToken: true };}

const requestOptions = {	...(options?.signal ? { signal: options.signal } : {}),	...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),	maxRetries: 0,};let disablePreferredStrictTools = false;let response: Response;for (;;) {	options?.signal?.throwIfAborted();	const built = buildParams(model, normalizedContext, isOAuth, options, disablePreferredStrictTools);	if (built.providerThinkingLevel) output.providerThinkingLevel = built.providerThinkingLevel;	let params = built.params;	const nextParams = await options?.onPayload?.(params, model);	if (nextParams !== undefined) {		params = { ...(nextParams as MessageCreateParamsStreaming), stream: true };	}	try {		response = await retryProviderRequest(			() => client.beta.messages.create(params, requestOptions).asResponse(),			{				maxRetries: options?.maxRetries,				maxRetryDelayMs: options?.maxRetryDelayMs,				signal: options?.signal,			},		);		break;

const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);const compat = getAnthropicCompat(model);const initialSystemMessage = getInitialSystemMessage(context.messages);const initialSystemText = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);const conversationMessages = initialSystemMessage ? transformedMessages.slice(1) : transformedMessages;⋯ lược bớt dòng 1178–1218const params: MessageCreateParamsStreaming = {	model: model.id,	messages: effortMessages ? insertThinkingLevelMessages(converted, activeEffort) : converted.messages,	max_tokens: options?.maxTokens ?? model.maxTokens,	stream: true,	...(betaFeatures.length > 0 ? { betas: betaFeatures } : {}),};// For OAuth tokens, we MUST include Claude Code identityif (isOAuthToken) {	params.system = [		{			type: "text",			text: "You are Claude Code, Anthropic's official CLI for Claude.",			...(cacheControl ? { cache_control: cacheControl } : {}),		},	];	if (initialSystemText) {		params.system.push({			type: "text",			text: sanitizeSurrogates(initialSystemText),			...(cacheControl ? { cache_control: cacheControl } : {}),		});	}} else if (initialSystemText) {	// Add cache control to system prompt for non-OAuth tokens	params.system = [		{			type: "text",			text: sanitizeSurrogates(initialSystemText),			...(cacheControl ? { cache_control: cacheControl } : {}),		},	];}

if (thinkingDisabled) {	// No effort is sent, so the model default applies. Anthropic rejects `block_binding`	// with disabled thinking.	params.thinking = { type: "disabled" };} else if (effortMessages) {	// Managed effort models use adaptive thinking so prefix mismatches can	// be dropped instead of surfacing as persistent 400 responses.	params.thinking = {		type: "adaptive",		display: options?.thinkingDisplay ?? "summarized",		block_binding: { prefix_mismatch_behavior: "drop_block" },	};	params.output_config = { effort: "high" };} else if (model.reasoning && options?.thinkingEnabled) {	// Default to "summarized" so Opus 4.7 and Mythos Preview behave like	// older Claude 4 models (whose API default is also "summarized").	const display: AnthropicThinkingDisplay = options.thinkingDisplay ?? "summarized";	if (model.compat?.forceAdaptiveThinking === true) {		// Adaptive thinking: Claude decides when and how much to think.		params.thinking = { type: "adaptive", display };		if (options.effort) {			params.output_config = { effort: options.effort };		}	} else {		// Budget-based thinking for older models		params.thinking = {			type: "enabled",			budget_tokens: options.thinkingBudgetTokens || 1024,			display,		};	}}

} else if (block.type === "thinking") {	// Redacted thinking: pass the opaque payload back as redacted_thinking	if (block.redacted) {		blocks.push({			type: "redacted_thinking",			data: block.thinkingSignature!,		});		continue;	}	const thinkingSignature = block.thinkingSignature;	const hasThinkingSignature = !!thinkingSignature && thinkingSignature.trim().length > 0;	if (block.thinking.trim().length === 0 && !hasThinkingSignature) continue;	// If thinking signature is missing/empty (e.g., from aborted stream),	// convert to plain text for Anthropic. Some compatible providers emit	// and accept empty signatures, so let marked models preserve the block.	if (!hasThinkingSignature) {		blocks.push(			allowEmptySignature				? {						type: "thinking",						thinking: sanitizeSurrogates(block.thinking),						signature: "",					}				: {						type: "text",						text: sanitizeSurrogates(block.thinking),					},		);	} else {		blocks.push({			type: "thinking",			thinking: sanitizeSurrogates(block.thinking),			signature: thinkingSignature,		});	}

} else if (msg.role === "toolResult") {	// Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.	const toolResults: ContentBlockParam[] = [];	// Anthropic rejects error tool results that contain anything but text, so their images follow	// all tool results of the turn, which must come first in the user message (#10794).	const errorImages: ContentBlockParam[] = [];	let j = i;	while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {		const toolMsg = transformedMessages[j] as ToolResultMessage;		const split = splitErrorToolResultImages(toolMsg);		toolResults.push(convertToolResult(toolMsg, split?.content));		if (split) {			errorImages.push({ type: "text", text: split.caption }, ...split.images.map(convertImageBlock));		}		j++;	}	// Skip the messages we've already processed.	i = j - 1;	params.push({		role: "user",		content: [...toolResults, ...errorImages],	});}

// Add cache_control to the last user or system message to cache conversation historyif (cacheControl && params.length > 0) {	const lastMessage = params[params.length - 1];	if (lastMessage.role === "user" || lastMessage.role === "system") {		if (Array.isArray(lastMessage.content)) {			const lastBlock = lastMessage.content[lastMessage.content.length - 1];			if (				lastBlock &&				(lastBlock.type === "text" ||					lastBlock.type === "image" ||					lastBlock.type === "tool_result" ||					lastBlock.type === "tool_addition" ||					lastBlock.type === "tool_removal")			) {				(lastBlock as any).cache_control = cacheControl;			}		} else if (typeof lastMessage.content === "string") {			lastMessage.content = [				{					type: "text",					text: lastMessage.content,					cache_control: cacheControl,				},			] as any;		}	}}

async function* iterateAnthropicEvents(	response: Response,	signal?: AbortSignal,): AsyncGenerator<RawMessageStreamEvent> {	if (!response.body) {		throw new Error("Attempted to iterate over an Anthropic response with no body");	}	let sawMessageStart = false;	let sawMessageEnd = false;	for await (const sse of iterateSseMessages(response.body, signal)) {		if (sse.event === "error") {			throw new Error(sse.data);		}		if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) {			continue;		}		try {			const event = parseJsonWithRepair<RawMessageStreamEvent>(sse.data);			if (event.type === "message_start") {				sawMessageStart = true;			} else if (event.type === "message_stop") {				sawMessageEnd = true;			}			yield event;		} catch (error) {			const message = error instanceof Error ? error.message : String(error);			throw new Error(				`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`,			);		}	}	if (sawMessageStart && !sawMessageEnd) {		throw new Error("Anthropic stream ended before message_stop");	}}

for await (const event of iterateAnthropicEvents(response, options?.signal)) {	await options?.onProviderStreamEvent?.(event, model);	if (event.type === "message_start") {		output.responseId = event.message.id;		const transformations = event.message.input_transformations;		if (Array.isArray(transformations)) inputTransformations = transformations;		const responseModel = event.message.model;		if (responseModel !== model.id) output.responseModel = responseModel;		const fallbackCost =			responseModel === model.id				? undefined				: model.compat?.allowedFallbackModels?.find(						(fallback) => fallback.provider === model.provider && fallback.model === responseModel,					)?.cost;		usageModel = fallbackCost ? { ...model, id: responseModel, cost: fallbackCost } : model;		// Capture initial token usage from message_start event		// This ensures we have input token counts even if the stream is aborted early		output.usage.input = event.message.usage.input_tokens || 0;		output.usage.output = event.message.usage.output_tokens || 0;		output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;		output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;		output.usage.cacheWrite1h = event.message.usage.cache_creation?.ephemeral_1h_input_tokens || 0;		// Anthropic doesn't provide total_tokens, compute from components		output.usage.totalTokens =			output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;		calculateCost(usageModel, output.usage);

} else if (event.type === "content_block_start") {	if (event.content_block.type === "fallback") {		if (output.content.length > 0) {			throw new Error("Anthropic performed an unsupported mid-output model fallback");		}		continue;	}	if (event.content_block.type === "text") {		const block: Block = {			type: "text",			text: event.content_block.text ?? "",			index: event.index,		};		output.content.push(block);		stream.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output });	} else if (event.content_block.type === "thinking") {		const block: Block = {			type: "thinking",			thinking: event.content_block.thinking ?? "",			thinkingSignature: event.content_block.signature ?? "",			index: event.index,		};		output.content.push(block);		stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });⋯ lược bớt dòng 746–755	} else if (event.content_block.type === "tool_use") {		const block: Block = {			type: "toolCall",			id: event.content_block.id,			name: isOAuth				? fromClaudeCodeName(event.content_block.name, currentTools)				: event.content_block.name,			arguments: (event.content_block.input as Record<string, any>) ?? {},			partialJson: "",			index: event.index,		};		output.content.push(block);		stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });	}

} else if (event.delta.type === "input_json_delta") {	const index = blocks.findIndex((b) => b.index === event.index);	const block = blocks[index];	if (block && block.type === "toolCall") {		block.partialJson += event.delta.partial_json;		block.arguments = parseStreamingJson(block.partialJson);		stream.push({			type: "toolcall_delta",			contentIndex: index,			delta: event.delta.partial_json,			partial: output,		});	}} else if (event.delta.type === "signature_delta") {	const index = blocks.findIndex((b) => b.index === event.index);	const block = blocks[index];	if (block && block.type === "thinking") {		block.thinkingSignature = block.thinkingSignature || "";		block.thinkingSignature += event.delta.signature;	}}

} else if (event.type === "content_block_stop") {	const index = blocks.findIndex((b) => b.index === event.index);	const block = blocks[index];	if (block) {		delete (block as any).index;		if (block.type === "text") {			stream.push({				type: "text_end",				contentIndex: index,				content: block.text,				partial: output,			});		} else if (block.type === "thinking") {			stream.push({				type: "thinking_end",				contentIndex: index,				content: block.thinking,				partial: output,			});		} else if (block.type === "toolCall") {			Object.assign(block, parseToolCallArguments(block.partialJson));			// Finalize in-place and strip the scratch buffer so replay only			// carries parsed arguments.			delete (block as { partialJson?: string }).partialJson;			stream.push({				type: "toolcall_end",				contentIndex: index,				toolCall: block,				partial: output,			});		}	}

} else if (event.type === "message_delta") {	const transformations = event.input_transformations;	if (Array.isArray(transformations)) inputTransformations = transformations;	if (event.delta.stop_reason) {		output.rawStopReason = event.delta.stop_reason;		const stopReasonResult = mapStopReason(event.delta.stop_reason, event.delta.stop_details);		output.stopReason = stopReasonResult.stopReason;		if (stopReasonResult.errorMessage) {			output.errorMessage = stopReasonResult.errorMessage;		}	}⋯ lược bớt dòng 859–880		// Anthropic reports reasoning tokens as a subset of output tokens.		const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;		if (thinkingTokens != null) {			output.usage.reasoning = thinkingTokens;		}	}	// Anthropic doesn't provide total_tokens, compute from components	output.usage.totalTokens =		output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;	calculateCost(usageModel, output.usage);}

	if (options?.signal?.aborted) {		throw new Error("Request was aborted");	}	if (output.stopReason === "pending") {		throw new Error("Anthropic stream ended without a stop reason");	}	if (output.stopReason === "aborted" || output.stopReason === "error") {		throw new Error(output.errorMessage || "An unknown error occurred");	}	if (inputTransformations && inputTransformations.length > 0) {		appendAssistantMessageDiagnostic(output, {			type: "anthropic_input_transformations",			timestamp: Date.now(),			details: {				transformations: inputTransformations.map((transformation) => ({					type: transformation.type ?? undefined,					path: transformation.path ?? undefined,					reason: transformation.reason ?? undefined,				})),			},		});	}	stream.push({ type: "done", reason: output.stopReason, message: output });	stream.end();} catch (error) {	for (const block of output.content) {		delete (block as { index?: number }).index;		// partialJson is only a streaming scratch buffer; never persist it.		delete (block as { partialJson?: string }).partialJson;	}	output.stopReason = options?.signal?.aborted ? "aborted" : "error";	output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);	stream.push({ type: "error", reason: output.stopReason, error: output });	stream.end();}

if (!options?.reasoning) {	return stream(model, context, {		...base,		thinkingEnabled: false,	} satisfies AnthropicOptions);}// For models with adaptive thinking: use an effort level.// For older models: use budget-based thinking.if (model.compat?.forceAdaptiveThinking === true) {	const effort = mapThinkingLevelToEffort(model, options.reasoning);	return stream(model, context, {		...base,		thinkingEnabled: true,		effort,	} satisfies AnthropicOptions);}// Undefined means the caller did not request an output cap; let the helper use the model cap.// Do not coerce to 0 here, or the thinking budget would become the entire max_tokens value.const adjusted = adjustMaxTokensForThinking(	base.maxTokens,	model.maxTokens,	options.reasoning,	options.thinkingBudgets,);const maxTokens = clampMaxTokensToContext(model, context, adjusted.maxTokens);return stream(model, context, {	...base,	maxTokens,	thinkingEnabled: true,	thinkingBudgetTokens: Math.min(adjusted.thinkingBudget, Math.max(0, maxTokens - 1024)),} satisfies AnthropicOptions);

const params: ResponseCreateParamsStreaming = {	model: model.id,	input: messages,	stream: true,	prompt_cache_key: cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey(options?.sessionId),	prompt_cache_retention: omitUnsupportedFields ? undefined : getPromptCacheRetention(compat, cacheRetention),	prompt_cache_options: omitUnsupportedFields ? undefined : getPromptCacheOptions(compat, cacheRetention),	store: false,};⋯ lược bớt dòng 378–401const reasoningEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : undefined);if (model.reasoning) {	if (reasoningEffort) {		const requestedEffort = options?.reasoningEffort			? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)			: reasoningEffort;		const effort = configurationUpdateEffort === undefined ? requestedEffort : CONFIGURATION_UPDATE_REQUEST_EFFORT;		params.reasoning = {			effort: effort as NonNullable<typeof params.reasoning>["effort"],			summary: options?.reasoningSummary || "auto",		};		params.include = ["reasoning.encrypted_content"];	} else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) {		params.reasoning = {			effort: (model.thinkingLevelMap?.off ?? "none") as NonNullable<typeof params.reasoning>["effort"],		};	}	if (model.provider === "xai") params.include = ["reasoning.encrypted_content"];}

if (item.type === "function_call") {	const block: StreamingToolCall = {		type: "toolCall",		id: `${item.call_id}|${item.id}`,		name: item.name,		arguments: {},		...(item.namespace !== undefined ? { namespace: item.namespace } : {}),		partialJson: item.arguments || "",	};	output.content.push(block);	const slot = {		type: "toolCall",		block,		contentIndex: output.content.length - 1,	} satisfies ResponsesOutputSlot;	outputSlots.set(outputIndex, slot);	stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });	return slot;}⋯ lược bớt dòng 583–765	if (item.type === "reasoning" && slot?.type === "thinking") {		const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";		const contentText = item.content?.map((c) => c.text).join("\n\n") || "";		slot.block.thinking = summaryText || contentText || slot.block.thinking;		slot.block.thinkingSignature = JSON.stringify(item);		reasoningBlocksById.set(item.id, slot.block);		stream.push({			type: "thinking_end",			contentIndex: slot.contentIndex,			content: slot.block.thinking,			partial: output,		});		outputSlots.delete(event.output_index);