@byfriends/kosong 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -1,17 +1,913 @@
-import { _ as mergeInPlace, d as createToolMessage, f as createUserMessage, g as isToolCallPart, h as isToolCall, m as isContentPart, p as extractText, u as createAssistantMessage } from "./openai-common-08qin3UI.mjs";
+import { _ as mergeInPlace, a as isFunctionToolCall, d as createToolMessage, f as createUserMessage, g as isToolCallPart, h as isToolCall, i as extractUsage, l as toolToOpenAI, m as isContentPart, n as convertOpenAIError, o as normalizeOpenAIFinishReason, p as extractText, r as convertToolMessageContent, s as reasoningEffortToThinkingEffort, t as convertContentPart, u as createAssistantMessage } from "./openai-common-Dl42y_vn.mjs";
 import { a as APITimeoutError, i as APIStatusError, n as APIContextOverflowError, o as ChatProviderError, r as APIEmptyResponseError, t as APIConnectionError } from "./errors-WFxxzL1B.mjs";
-import { a as isUnknownCapability, i as UNKNOWN_CAPABILITY } from "./request-auth-DCWSyCKI.mjs";
+import { c as resolveCapabilityFromRegistry, d as isUnknownCapability, n as requireProviderApiKey, o as getOpenAILegacyModelCapability, r as resolveAuthBackedClient, t as mergeRequestHeaders, u as UNKNOWN_CAPABILITY } from "./request-auth-BMXt8jRu.mjs";
 import { AnthropicChatProvider } from "./providers/anthropic.mjs";
 import { GoogleGenAIChatProvider } from "./providers/google-genai.mjs";
-import { t as OpenAICompatChatProvider } from "./openai-compat-CWbwO4b7.mjs";
-import { OpenAILegacyChatProvider } from "./providers/openai-legacy.mjs";
 import { OpenAIResponsesChatProvider } from "./providers/openai-responses.mjs";
+import OpenAI from "openai";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+//#region src/providers/openai-compat-schema.ts
+/**
+* Dereference all `$ref` references in a JSON Schema by inlining definitions
+* from local JSON pointers such as `$defs` and draft-7 `definitions`. Resolved
+* top-level definition buckets are removed from the result.
+*
+* Circular references are detected and left as `$ref` to avoid infinite
+* recursion; in that case the referenced definition bucket is preserved so the
+* remaining local `$ref` pointers stay resolvable to a JSON Schema validator.
+*/
+function derefJsonSchema(schema) {
+	const result = resolveNode(schema, schema, /* @__PURE__ */ new Set());
+	if (!hasUnresolvedDefinitionRef(result, "$defs")) delete result["$defs"];
+	if (!hasUnresolvedDefinitionRef(result, "definitions")) delete result["definitions"];
+	return result;
+}
+const TYPE_COMPLETION_SKIP_KEYS = new Set([
+	"$ref",
+	"allOf",
+	"anyOf",
+	"else",
+	"if",
+	"not",
+	"oneOf",
+	"then"
+]);
+const CHILD_SCHEMA_SLOTS = [
+	{
+		key: "$defs",
+		kind: "map"
+	},
+	{
+		key: "definitions",
+		kind: "map"
+	},
+	{
+		key: "dependencies",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "dependentSchemas",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "patternProperties",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "properties",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "additionalItems",
+		kind: "single",
+		parentType: "array"
+	},
+	{
+		key: "additionalProperties",
+		kind: "single",
+		parentType: "object"
+	},
+	{
+		key: "contains",
+		kind: "single",
+		parentType: "array"
+	},
+	{
+		key: "contentSchema",
+		kind: "single",
+		parentType: "string"
+	},
+	{
+		key: "else",
+		kind: "single"
+	},
+	{
+		key: "if",
+		kind: "single"
+	},
+	{
+		key: "not",
+		kind: "single"
+	},
+	{
+		key: "propertyNames",
+		kind: "single",
+		parentType: "object"
+	},
+	{
+		key: "then",
+		kind: "single"
+	},
+	{
+		key: "unevaluatedItems",
+		kind: "single",
+		parentType: "array"
+	},
+	{
+		key: "unevaluatedProperties",
+		kind: "single",
+		parentType: "object"
+	},
+	{
+		key: "allOf",
+		kind: "array"
+	},
+	{
+		key: "anyOf",
+		kind: "array"
+	},
+	{
+		key: "oneOf",
+		kind: "array"
+	},
+	{
+		key: "prefixItems",
+		kind: "array",
+		parentType: "array"
+	},
+	{
+		key: "items",
+		kind: "schema-or-array",
+		parentType: "array"
+	}
+];
+const OBJECT_STRUCTURE_KEYS = new Set([
+	...childSchemaKeysForParentType("object"),
+	"dependentRequired",
+	"maxProperties",
+	"minProperties",
+	"required"
+]);
+const ARRAY_STRUCTURE_KEYS = new Set([
+	...childSchemaKeysForParentType("array"),
+	"maxContains",
+	"maxItems",
+	"minContains",
+	"minItems",
+	"uniqueItems"
+]);
+const STRING_STRUCTURE_KEYS = new Set([
+	...childSchemaKeysForParentType("string"),
+	"contentEncoding",
+	"contentMediaType",
+	"format",
+	"maxLength",
+	"minLength",
+	"pattern"
+]);
+const NUMERIC_STRUCTURE_KEYS = new Set([
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"maximum",
+	"minimum",
+	"multipleOf"
+]);
+/**
+* Return a deep-cloned JSON Schema with missing `type` fields filled in for
+* OpenAI-compatible tool compatibility.
+*
+* The tool validator rejects some valid JSON Schema shapes when nested
+* property schemas omit `type` (for example enum-only MCP properties). This is
+* a provider-compatibility normalizer, not a complete JSON Schema compiler:
+* it resolves local refs, preserves combinator nodes, infers obvious
+* scalar/object/array types, and falls back to `string` only for nested
+* typeless property schemas. The root schema object is treated as a container
+* and is not itself normalized.
+*/
+function normalizeOpenAICompatToolSchema(schema) {
+	return ensureOpenAICompatPropertyTypes(derefJsonSchema(schema));
+}
+function ensureOpenAICompatPropertyTypes(schema) {
+	const normalized = cloneJsonValue(schema);
+	if (!isRecord(normalized)) throw new Error("JSON Schema root must normalize to an object.");
+	recurseSchema(normalized);
+	return normalized;
+}
+function hasUnresolvedDefinitionRef(node, bucketKey) {
+	if (Array.isArray(node)) return node.some((child) => hasUnresolvedDefinitionRef(child, bucketKey));
+	if (typeof node === "object" && node !== null) {
+		const obj = node;
+		const ref = obj["$ref"];
+		if (typeof ref === "string" && ref.startsWith(`#/${bucketKey}/`)) return true;
+		for (const [key, value] of Object.entries(obj)) {
+			if (key === bucketKey) continue;
+			if (hasUnresolvedDefinitionRef(value, bucketKey)) return true;
+		}
+		return false;
+	}
+	return false;
+}
+function resolveNode(node, root, visited) {
+	if (Array.isArray(node)) return node.map((item) => resolveNode(item, root, visited));
+	if (typeof node === "object" && node !== null) {
+		const obj = node;
+		if (typeof obj["$ref"] === "string") {
+			const ref = obj["$ref"];
+			if (isLocalJsonPointerRef(ref)) {
+				if (visited.has(ref)) return obj;
+				const resolvedRef = resolveLocalJsonPointer(root, ref);
+				if (resolvedRef.found) {
+					visited.add(ref);
+					const resolved = resolveNode(resolvedRef.value, root, visited);
+					visited.delete(ref);
+					if (typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+						const merged = { ...resolved };
+						for (const [key, value] of Object.entries(obj)) {
+							if (key === "$ref") continue;
+							merged[key] = resolveNode(value, root, visited);
+						}
+						return merged;
+					}
+					return resolved;
+				}
+			}
+			return obj;
+		}
+		const resolved = {};
+		for (const [key, value] of Object.entries(obj)) resolved[key] = resolveNode(value, root, visited);
+		return resolved;
+	}
+	return node;
+}
+function isLocalJsonPointerRef(ref) {
+	return ref === "#" || ref.startsWith("#/");
+}
+function resolveLocalJsonPointer(root, ref) {
+	if (ref === "#") return {
+		found: true,
+		value: root
+	};
+	let current = root;
+	for (const rawPart of ref.slice(2).split("/")) {
+		const part = unescapeJsonPointerPart(rawPart);
+		if (isRecord(current)) {
+			if (!hasOwn(current, part)) return { found: false };
+			current = current[part];
+		} else if (Array.isArray(current)) {
+			const index = parseJsonPointerArrayIndex(part);
+			if (index === null || index >= current.length) return { found: false };
+			current = current[index];
+		} else return { found: false };
+	}
+	return {
+		found: true,
+		value: current
+	};
+}
+function unescapeJsonPointerPart(part) {
+	return part.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function parseJsonPointerArrayIndex(part) {
+	if (!/^(0|[1-9]\d*)$/.test(part)) return null;
+	return Number(part);
+}
+function recurseSchema(node) {
+	if (!isRecord(node)) return;
+	visitChildSchemas(node, normalizeProperty);
+}
+function visitChildSchemas(node, visit) {
+	for (const { key, kind } of CHILD_SCHEMA_SLOTS) {
+		const value = node[key];
+		if (kind === "single") {
+			if (isRecord(value)) visit(value);
+		} else if (kind === "array") {
+			if (Array.isArray(value)) for (const item of value) visit(item);
+		} else if (kind === "map") {
+			if (isRecord(value)) for (const item of Object.values(value)) visit(item);
+		} else if (kind === "schema-or-array") {
+			if (isRecord(value)) visit(value);
+			else if (Array.isArray(value)) for (const item of value) visit(item);
+		}
+	}
+}
+function childSchemaKeysForParentType(parentType) {
+	return CHILD_SCHEMA_SLOTS.flatMap((slot) => {
+		if (!("parentType" in slot) || slot.parentType !== parentType) return [];
+		return [slot.key];
+	});
+}
+function normalizeProperty(node) {
+	if (!isRecord(node)) return;
+	if (!hasOwn(node, "type") && !hasAnyKey(node, TYPE_COMPLETION_SKIP_KEYS)) {
+		const enumValues = node["enum"];
+		if (Array.isArray(enumValues) && enumValues.length > 0) node["type"] = inferTypeFromValues(enumValues);
+		else if (hasOwn(node, "const")) node["type"] = inferTypeFromValues([node["const"]]);
+		else node["type"] = inferTypeFromStructure(node);
+	}
+	recurseSchema(node);
+}
+function inferTypeFromStructure(schema) {
+	if (hasAnyKey(schema, OBJECT_STRUCTURE_KEYS)) return "object";
+	if (hasAnyKey(schema, ARRAY_STRUCTURE_KEYS)) return "array";
+	if (hasAnyKey(schema, STRING_STRUCTURE_KEYS)) return "string";
+	if (hasAnyKey(schema, NUMERIC_STRUCTURE_KEYS)) return "number";
+	return "string";
+}
+function inferTypeFromValues(values) {
+	const inferred = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		const valueType = inferValueType(value);
+		if (valueType === void 0) throw new Error("Cannot infer JSON Schema type from non-JSON enum or const value.");
+		inferred.add(valueType);
+	}
+	const types = normalizeInferredTypes(inferred);
+	if (types.length === 1) {
+		const onlyType = types[0];
+		if (onlyType === void 0) throw new Error("Cannot infer JSON Schema type from an empty enum.");
+		return onlyType;
+	}
+	throw new Error("Mixed JSON Schema enum or const types are not supported by OpenAI-compatible tool schemas.");
+}
+function inferValueType(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	switch (typeof value) {
+		case "string": return "string";
+		case "number": return Number.isInteger(value) ? "integer" : "number";
+		case "boolean": return "boolean";
+		case "object": return "object";
+		case "bigint":
+		case "function":
+		case "symbol":
+		case "undefined": return;
+	}
+}
+function normalizeInferredTypes(types) {
+	const normalized = new Set(types);
+	if (normalized.has("number")) normalized.delete("integer");
+	return [
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"object",
+		"array",
+		"null"
+	].filter((type) => normalized.has(type));
+}
+function hasAnyKey(obj, keys) {
+	for (const key of keys) if (hasOwn(obj, key)) return true;
+	return false;
+}
+function cloneJsonValue(value) {
+	if (Array.isArray(value)) return value.map((item) => cloneJsonValue(item));
+	if (isRecord(value)) {
+		const cloned = {};
+		for (const [key, child] of Object.entries(value)) cloned[key] = cloneJsonValue(child);
+		return cloned;
+	}
+	return value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+//#endregion
+//#region src/providers/openai-compat-files.ts
+/**
+* OpenAI-compatible file upload client.
+*
+* Wraps the underlying OpenAI-compatible `files.create` API to upload videos
+* to the file service and return them as {@link VideoURLPart} values
+* suitable for use in chat messages.
+*
+* An `OpenAICompatFiles` instance is typically obtained from
+* {@link OpenAICompatChatProvider.files}.
+*/
+var OpenAICompatFiles = class {
+	_apiKey;
+	_baseUrl;
+	_defaultHeaders;
+	_client;
+	_clientFactory;
+	constructor(options) {
+		this._apiKey = options.apiKey;
+		this._baseUrl = options.baseUrl;
+		this._defaultHeaders = options.defaultHeaders;
+		this._clientFactory = options.clientFactory;
+		this._client = options.apiKey === void 0 || options.apiKey.length === 0 ? void 0 : new OpenAI({
+			apiKey: options.apiKey,
+			baseURL: options.baseUrl,
+			defaultHeaders: options.defaultHeaders
+		});
+	}
+	/**
+	* Upload a video file for use in chat messages.
+	*
+	* Accepts either a local filesystem path or an in-memory
+	* {@link VideoUploadInput}. Returns a {@link VideoURLPart} referencing the
+	* uploaded file by its file id.
+	*
+	* @param input - Local path string or `{ data, mimeType }` object.
+	* @returns A `VideoURLPart` whose `url` references the uploaded file
+	*          by its file id (e.g. `ms://<file-id>`).
+	* @throws {ChatProviderError} if the input is not a video or the upload
+	*         fails.
+	*/
+	async uploadVideo(input, options) {
+		let file;
+		if (typeof input === "string") {
+			if (!fs.existsSync(input)) throw new ChatProviderError(`Video file not found: ${input}`);
+			const filename = path.basename(input);
+			const mimeType = guessMimeTypeFromExt(filename);
+			if (mimeType === void 0 || !mimeType.startsWith("video/")) throw new ChatProviderError(`OpenAICompatFiles.uploadVideo: file extension does not indicate a video type: ${filename}`);
+			const data = await fs.promises.readFile(input);
+			const blob = new Blob([new Uint8Array(data)], { type: mimeType });
+			file = new File([blob], filename, { type: mimeType });
+		} else {
+			if (!input.mimeType.startsWith("video/")) throw new ChatProviderError(`Expected a video mime type, got ${input.mimeType}`);
+			const filename = input.filename ?? guessFilename(input.mimeType);
+			const bytes = input.data instanceof Uint8Array ? input.data : new Uint8Array(input.data);
+			const blob = new Blob([bytes], { type: input.mimeType });
+			file = new File([blob], filename, { type: input.mimeType });
+		}
+		let uploaded;
+		try {
+			uploaded = await this._createClient(options?.auth).files.create({
+				file,
+				purpose: "video"
+			}, options?.signal ? { signal: options.signal } : void 0);
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+		return {
+			type: "video_url",
+			videoUrl: {
+				url: `ms://${uploaded.id}`,
+				id: uploaded.id
+			}
+		};
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => {
+			const defaultHeaders = mergeRequestHeaders(this._defaultHeaders, a?.headers);
+			return new OpenAI({
+				apiKey: requireProviderApiKey("OpenAICompatFiles.uploadVideo", a, this._apiKey),
+				baseURL: this._baseUrl,
+				defaultHeaders
+			});
+		});
+	}
+};
+/**
+* Guess a filename for an upload from a video MIME type.
+* Falls back to `upload.bin` for unknown types.
+*/
+function guessFilename(mimeType) {
+	return `upload.${MIME_TO_EXT[mimeType.toLowerCase()] ?? "bin"}`;
+}
+const MIME_TO_EXT = {
+	"video/mp4": "mp4",
+	"video/mpeg": "mpeg",
+	"video/quicktime": "mov",
+	"video/webm": "webm",
+	"video/x-matroska": "mkv",
+	"video/x-msvideo": "avi",
+	"video/x-flv": "flv",
+	"video/3gpp": "3gp"
+};
+const EXT_TO_MIME = Object.fromEntries(Object.entries(MIME_TO_EXT).map(([mime, ext]) => [ext, mime]));
+/**
+* Guess a MIME type from a filename extension. Only recognises the video
+* types listed in {@link MIME_TO_EXT}; returns `undefined` otherwise.
+*/
+function guessMimeTypeFromExt(filename) {
+	const dot = filename.lastIndexOf(".");
+	if (dot < 0) return void 0;
+	return EXT_TO_MIME[filename.slice(dot + 1).toLowerCase()];
+}
+//#endregion
+//#region src/providers/chat-completions-stream.ts
+/**
+* Convert an OpenAI Chat Completions-style streamed tool-call delta into the
+* normalized kosong stream part protocol.
+*
+* OpenAI-compatible providers may emit argument chunks before the function name
+* for a stream index. Buffer those early argument chunks until the first named
+* header arrives, then emit subsequent chunks as indexed `tool_call_part`s so
+* the shared generate loop can route interleaved parallel calls.
+*/
+function convertChatCompletionStreamToolCall(toolCall, bufferedByIndex) {
+	if (toolCall.function === void 0 || toolCall.function === null) return [];
+	const streamIndex = toolCall.index;
+	const functionName = toolCall.function.name;
+	const functionArguments = toolCall.function.arguments;
+	const hasConcreteName = typeof functionName === "string" && functionName.length > 0;
+	const hasArguments = typeof functionArguments === "string" && functionArguments.length > 0;
+	if (streamIndex === void 0) {
+		if (hasConcreteName) return [{
+			type: "function",
+			id: toolCall.id ?? crypto.randomUUID(),
+			name: functionName,
+			arguments: functionArguments ?? null
+		}];
+		if (hasArguments) return [{
+			type: "tool_call_part",
+			argumentsPart: functionArguments
+		}];
+		return [];
+	}
+	const buffered = bufferedByIndex.get(streamIndex) ?? {
+		arguments: "",
+		emitted: false
+	};
+	if (toolCall.id !== void 0) buffered.id = toolCall.id;
+	if (!buffered.emitted) {
+		if (!hasConcreteName) {
+			if (hasArguments) buffered.arguments += functionArguments;
+			bufferedByIndex.set(streamIndex, buffered);
+			return [];
+		}
+		buffered.emitted = true;
+		const initialArguments = buffered.arguments.length > 0 ? buffered.arguments + (functionArguments ?? "") : functionArguments ?? null;
+		buffered.arguments = "";
+		bufferedByIndex.set(streamIndex, buffered);
+		return [{
+			type: "function",
+			id: buffered.id ?? toolCall.id ?? crypto.randomUUID(),
+			name: functionName,
+			arguments: initialArguments,
+			_streamIndex: streamIndex
+		}];
+	}
+	if (!hasArguments) return [];
+	return [{
+		type: "tool_call_part",
+		argumentsPart: functionArguments,
+		index: streamIndex
+	}];
+}
+//#endregion
+//#region src/providers/openai-completions.ts
+const KNOWN_REASONING_KEYS = [
+	"reasoning_content",
+	"reasoning_details",
+	"reasoning"
+];
+const DEFAULT_OUTBOUND_REASONING_KEY = KNOWN_REASONING_KEYS[0];
+function extractReasoningContent(source, explicitKey) {
+	if (typeof source !== "object" || source === null) return void 0;
+	const record = source;
+	const keys = explicitKey !== void 0 ? [explicitKey] : KNOWN_REASONING_KEYS;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+function isEffectivelyEmptyContent(parts) {
+	for (const part of parts) {
+		if (part.type !== "text") return false;
+		if (part.text.trim() !== "") return false;
+	}
+	return true;
+}
+/**
+* Derive a stable SHA256 hash from cacheable blocks in a PromptPlan.
+*
+* Only blocks with cacheScope 'global' are included in the hash, as OpenAI
+* only supports caching the prefix (global scope).
+*
+* @param promptPlan - The prompt plan containing cacheable blocks.
+* @returns A hexadecimal SHA256 hash string.
+*/
+function deriveCacheKeyFromPromptPlan(promptPlan) {
+	if (!promptPlan || promptPlan.blocks.length === 0) return createHash("sha256").digest("hex");
+	const cacheableTexts = [];
+	for (const block of promptPlan.blocks) if (block.cacheScope === "global") cacheableTexts.push(block.text);
+	const concatenated = cacheableTexts.join("");
+	return createHash("sha256").update(concatenated).digest("hex");
+}
+function convertMessage(message, reasoningKey, toolMessageConversion) {
+	let reasoningContent = "";
+	const nonThinkParts = [];
+	for (const part of message.content) if (part.type === "think") reasoningContent += part.think;
+	else nonThinkParts.push(part);
+	const result = { role: message.role };
+	const hasToolCalls = message.toolCalls.length > 0;
+	const shouldOmitContent = message.role === "assistant" && hasToolCalls && isEffectivelyEmptyContent(nonThinkParts);
+	if (message.role === "tool") {
+		const effectiveConversion = message.content.some((p) => p.type !== "text" && p.type !== "think") ? "extract_text" : toolMessageConversion;
+		if (effectiveConversion !== null) result.content = convertToolMessageContent(message, effectiveConversion);
+		else if (!shouldOmitContent) {
+			const firstPart = nonThinkParts[0];
+			if (nonThinkParts.length === 1 && firstPart?.type === "text") result.content = firstPart.text;
+			else if (nonThinkParts.length > 0) result.content = nonThinkParts.map((p) => convertContentPart(p)).filter((p) => p !== null);
+		}
+	} else if (!shouldOmitContent) {
+		const firstPart = nonThinkParts[0];
+		if (nonThinkParts.length === 1 && firstPart?.type === "text") result.content = firstPart.text;
+		else if (nonThinkParts.length > 0) result.content = nonThinkParts.map((p) => convertContentPart(p)).filter((p) => p !== null);
+	}
+	if (message.name !== void 0) result.name = message.name;
+	if (hasToolCalls) result.tool_calls = message.toolCalls.map((tc) => {
+		const mapped = {
+			type: tc.type,
+			id: tc.id,
+			function: {
+				name: tc.name,
+				arguments: tc.arguments
+			}
+		};
+		if (tc.extras !== void 0) mapped.extras = tc.extras;
+		return mapped;
+	});
+	if (message.toolCallId !== void 0) result.tool_call_id = message.toolCallId;
+	if (reasoningContent) result[reasoningKey ?? DEFAULT_OUTBOUND_REASONING_KEY] = reasoningContent;
+	return result;
+}
+function convertTool(tool) {
+	if (tool.name.startsWith("$")) return {
+		type: "builtin_function",
+		function: { name: tool.name }
+	};
+	const converted = toolToOpenAI(tool);
+	return {
+		...converted,
+		function: {
+			...converted.function,
+			parameters: normalizeOpenAICompatToolSchema(tool.parameters)
+		}
+	};
+}
+function extractUsageFromChunk(chunk) {
+	if (chunk["usage"] !== null && chunk["usage"] !== void 0 && typeof chunk["usage"] === "object") return chunk["usage"];
+	const choices = chunk["choices"];
+	if (!Array.isArray(choices) || choices.length === 0) return null;
+	const firstChoice = choices[0];
+	if (firstChoice === void 0) return null;
+	const choiceUsage = firstChoice["usage"];
+	if (choiceUsage !== null && choiceUsage !== void 0 && typeof choiceUsage === "object") return choiceUsage;
+	return null;
+}
+var OpenAICompletionsStreamedMessage = class {
+	_id = null;
+	_usage = null;
+	_finishReason = null;
+	_rawFinishReason = null;
+	_iter;
+	constructor(response, isStream, reasoningKey) {
+		if (isStream) this._iter = this._convertStreamResponse(response, reasoningKey);
+		else this._iter = this._convertNonStreamResponse(response, reasoningKey);
+	}
+	get id() {
+		return this._id;
+	}
+	get usage() {
+		return this._usage;
+	}
+	get finishReason() {
+		return this._finishReason;
+	}
+	get rawFinishReason() {
+		return this._rawFinishReason;
+	}
+	async *[Symbol.asyncIterator]() {
+		yield* this._iter;
+	}
+	_captureFinishReason(raw) {
+		const normalized = normalizeOpenAIFinishReason(raw);
+		this._finishReason = normalized.finishReason;
+		this._rawFinishReason = normalized.rawFinishReason;
+	}
+	async *_convertNonStreamResponse(response, reasoningKey) {
+		this._id = response.id;
+		if (response.usage) this._usage = extractUsage(response.usage) ?? null;
+		this._captureFinishReason(response.choices[0]?.finish_reason ?? null);
+		const message = response.choices[0]?.message;
+		if (!message) return;
+		const reasoning = extractReasoningContent(message, reasoningKey);
+		if (reasoning) yield {
+			type: "think",
+			think: reasoning
+		};
+		if (message.content) yield {
+			type: "text",
+			text: message.content
+		};
+		if (message.tool_calls) for (const toolCall of message.tool_calls) {
+			if (!isFunctionToolCall(toolCall)) continue;
+			yield {
+				type: "function",
+				id: toolCall.id || crypto.randomUUID(),
+				name: toolCall.function.name,
+				arguments: toolCall.function.arguments
+			};
+		}
+	}
+	async *_convertStreamResponse(response, reasoningKey) {
+		const bufferedToolCalls = /* @__PURE__ */ new Map();
+		try {
+			for await (const chunk of response) {
+				if (chunk.id) this._id = chunk.id;
+				const rawUsage = extractUsageFromChunk(chunk);
+				if (rawUsage) this._usage = extractUsage(rawUsage) ?? null;
+				if (!chunk.choices || chunk.choices.length === 0) continue;
+				const choice = chunk.choices[0];
+				if (!choice) continue;
+				if (choice.finish_reason !== null && choice.finish_reason !== void 0) this._captureFinishReason(choice.finish_reason);
+				const delta = choice.delta;
+				const reasoning = extractReasoningContent(delta, reasoningKey);
+				if (reasoning) yield {
+					type: "think",
+					think: reasoning
+				};
+				if (delta.content) yield {
+					type: "text",
+					text: delta.content
+				};
+				for (const toolCall of delta.tool_calls ?? []) for (const part of convertChatCompletionStreamToolCall(toolCall, bufferedToolCalls)) yield part;
+			}
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+	}
+};
+var OpenAICompletionsChatProvider = class {
+	name = "openai-completions";
+	_model;
+	_stream;
+	_apiKey;
+	_baseUrl;
+	_defaultHeaders;
+	_generationKwargs;
+	_thinkingEffortKey;
+	_reasoningKey;
+	_toolMessageConversion;
+	_client;
+	_clientFactory;
+	_files;
+	constructor(options) {
+		const apiKey = options.apiKey;
+		this._apiKey = apiKey === void 0 || apiKey.length === 0 ? void 0 : apiKey;
+		this._baseUrl = options.baseUrl ?? "";
+		this._defaultHeaders = options.defaultHeaders;
+		this._clientFactory = options.clientFactory;
+		this._model = options.model;
+		this._stream = options.stream ?? true;
+		const normalizedThinkingEffortKey = options.thinkingEffortKey?.trim();
+		this._thinkingEffortKey = normalizedThinkingEffortKey !== void 0 && normalizedThinkingEffortKey.length > 0 ? normalizedThinkingEffortKey : "reasoning_effort";
+		const normalizedReasoningKey = options.reasoningKey?.trim();
+		this._reasoningKey = normalizedReasoningKey !== void 0 && normalizedReasoningKey.length > 0 ? normalizedReasoningKey : void 0;
+		this._generationKwargs = { ...options.generationKwargs };
+		this._toolMessageConversion = options.toolMessageConversion ?? null;
+		this._client = this._apiKey === void 0 ? void 0 : new OpenAI({
+			apiKey: this._apiKey,
+			baseURL: this._baseUrl,
+			defaultHeaders: this._defaultHeaders
+		});
+	}
+	get modelName() {
+		return this._model;
+	}
+	get thinkingEffort() {
+		const customValue = this._generationKwargs[this._thinkingEffortKey];
+		if (typeof customValue === "string") return reasoningEffortToThinkingEffort(customValue);
+		const defaultValue = this._generationKwargs.reasoning_effort;
+		return reasoningEffortToThinkingEffort(defaultValue);
+	}
+	get files() {
+		this._files ??= new OpenAICompatFiles({
+			apiKey: this._apiKey,
+			baseUrl: this._baseUrl,
+			defaultHeaders: this._defaultHeaders,
+			clientFactory: this._clientFactory
+		});
+		return this._files;
+	}
+	uploadVideo(input, options) {
+		return this.files.uploadVideo(input, options);
+	}
+	get modelParameters() {
+		return {
+			model: this._model,
+			baseUrl: this._baseUrl,
+			...this._generationKwargs
+		};
+	}
+	getCapability(model) {
+		return getOpenAILegacyModelCapability(model ?? this._model);
+	}
+	async generate(systemPrompt, tools, history, options) {
+		const messages = [];
+		if (systemPrompt) messages.push({
+			role: "system",
+			content: systemPrompt
+		});
+		for (const msg of history) messages.push(convertMessage(msg, this._reasoningKey, this._toolMessageConversion));
+		const kwargs = { ...this._generationKwargs };
+		if (kwargs[this._thinkingEffortKey] === void 0 && kwargs["reasoning_effort"] === void 0) {
+			if (history.some((message) => message.content.some((part) => part.type === "think"))) kwargs[this._thinkingEffortKey] = "high";
+		}
+		for (const key of Object.keys(kwargs)) if (kwargs[key] === void 0) delete kwargs[key];
+		if (kwargs["max_completion_tokens"] === void 0 && kwargs["max_tokens"] !== void 0) kwargs["max_completion_tokens"] = kwargs["max_tokens"];
+		delete kwargs["max_tokens"];
+		const { extra_body: extraBody, ...requestKwargs } = kwargs;
+		const createParams = {
+			model: this._model,
+			messages,
+			stream: this._stream,
+			...requestKwargs,
+			...extraBody
+		};
+		if (tools.length > 0) createParams["tools"] = tools.map((t) => convertTool(t));
+		if (this._stream) createParams["stream_options"] = { include_usage: true };
+		if (options?.promptPlan) {
+			const cacheKey = deriveCacheKeyFromPromptPlan(options.promptPlan);
+			if (cacheKey) createParams["prompt_cache_key"] = cacheKey;
+		}
+		try {
+			return new OpenAICompletionsStreamedMessage(await this._createClient(options?.auth).chat.completions.create(createParams, options?.signal ? { signal: options.signal } : void 0), this._stream, this._reasoningKey);
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+	}
+	withThinking(effort) {
+		const thinking = { type: effort === "off" ? "disabled" : "enabled" };
+		let reasoningEffort;
+		switch (effort) {
+			case "off":
+				reasoningEffort = void 0;
+				break;
+			case "low":
+				reasoningEffort = "low";
+				break;
+			case "medium":
+				reasoningEffort = "medium";
+				break;
+			case "high":
+			case "xhigh":
+			case "max":
+				reasoningEffort = "high";
+				break;
+		}
+		const nextEffort = { [this._thinkingEffortKey]: reasoningEffort };
+		return this._withGenerationKwargs(nextEffort).withExtraBody({ thinking });
+	}
+	withGenerationKwargs(kwargs) {
+		return this._withGenerationKwargs(kwargs);
+	}
+	withMaxCompletionTokens(maxCompletionTokens) {
+		return this._withGenerationKwargs({ max_completion_tokens: maxCompletionTokens });
+	}
+	withExtraBody(extraBody) {
+		const oldExtra = this._generationKwargs.extra_body ?? {};
+		const merged = {
+			...oldExtra,
+			...extraBody
+		};
+		const oldThinking = oldExtra.thinking;
+		const newThinking = extraBody.thinking;
+		if (oldThinking !== void 0 && newThinking !== void 0) merged.thinking = {
+			...oldThinking,
+			...newThinking
+		};
+		return this._withGenerationKwargs({ extra_body: merged });
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => {
+			const defaultHeaders = mergeRequestHeaders(this._defaultHeaders, a?.headers);
+			return new OpenAI({
+				apiKey: requireProviderApiKey("OpenAICompletionsChatProvider", a, this._apiKey),
+				baseURL: this._baseUrl,
+				defaultHeaders
+			});
+		});
+	}
+	_withGenerationKwargs(kwargs) {
+		const clone = this._clone();
+		clone._generationKwargs = {
+			...clone._generationKwargs,
+			...kwargs
+		};
+		return clone;
+	}
+	_clone() {
+		const clone = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+		clone._generationKwargs = { ...this._generationKwargs };
+		clone._files = void 0;
+		return clone;
+	}
+};
+//#endregion
 //#region src/providers/index.ts
 function createProvider(config) {
 	switch (config.type) {
 		case "anthropic": return new AnthropicChatProvider(config);
-		case "openai": return new OpenAILegacyChatProvider(config);
-		case "openai-compat": return new OpenAICompatChatProvider(config);
+		case "openai-completions": return new OpenAICompletionsChatProvider(config);
 		case "google-genai": return new GoogleGenAIChatProvider(config);
 		case "openai_responses": return new OpenAIResponsesChatProvider(config);
 		case "vertexai": return new GoogleGenAIChatProvider(config);
@@ -22,8 +918,7 @@ function createProvider(config) {
 //#region src/catalog.ts
 const KNOWN_WIRE_TYPES = [
 	"anthropic",
-	"openai",
-	"openai-compat",
+	"openai-completions",
 	"google-genai",
 	"openai_responses",
 	"vertexai"
@@ -53,7 +948,7 @@ function inferWireType(entry) {
 	if (npm.includes("anthropic") || id.includes("anthropic") || id.includes("claude")) return "anthropic";
 	if (id.includes("vertex")) return "vertexai";
 	if (npm.includes("google") || id.includes("google") || id.includes("gemini")) return "google-genai";
-	if (npm.includes("openai") || id.includes("openai")) return "openai";
+	if (npm.includes("openai") || id.includes("openai")) return "openai-completions";
 }
 /**
 * Resolves the base URL to store for a catalog provider, adapting the catalog's
@@ -80,19 +975,29 @@ function catalogModelToCapability(model) {
 	if (!isUsableChatModel(model)) return void 0;
 	const inputs = model.modalities?.input ?? [];
 	const output = model.limit?.output;
+	const base = {
+		image_in: inputs.includes("image"),
+		video_in: inputs.includes("video"),
+		audio_in: inputs.includes("audio"),
+		thinking: Boolean(model.reasoning),
+		tool_use: model.tool_call ?? true,
+		thinking_effort: false,
+		thinking_xhigh: false,
+		thinking_max: false,
+		max_context_tokens: context
+	};
+	const registry = resolveCapabilityFromRegistry(model.id);
+	const capability = registry !== void 0 ? {
+		...base,
+		...registry,
+		max_context_tokens: context
+	} : base;
 	return {
 		id: model.id,
 		name: typeof model.name === "string" && model.name.length > 0 ? model.name : void 0,
 		maxOutputSize: typeof output === "number" && output > 0 ? output : void 0,
 		reasoningKey: catalogReasoningKey(model.interleaved),
-		capability: {
-			image_in: inputs.includes("image"),
-			video_in: inputs.includes("video"),
-			audio_in: inputs.includes("audio"),
-			thinking: Boolean(model.reasoning),
-			tool_use: model.tool_call ?? true,
-			max_context_tokens: context
-		}
+		capability
 	};
 }
 function catalogReasoningKey(interleaved) {
@@ -141,9 +1046,12 @@ async function generate(provider, systemPrompt, tools, history, callbacks, optio
 	let pendingPart = null;
 	const toolCallIndexMap = /* @__PURE__ */ new Map();
 	if (options?.signal?.aborted) throwAbortError();
+	const generateStart = performance.now();
 	const stream = await provider.generate(systemPrompt, tools, history, options);
 	await throwIfAborted(options?.signal, stream);
+	let firstChunkTime;
 	for await (const part of stream) {
+		firstChunkTime ??= performance.now();
 		await throwIfAborted(options?.signal, stream);
 		if (callbacks?.onMessagePart !== void 0) {
 			await callbacks.onMessagePart(deepCopyPart(part));
@@ -174,12 +1082,17 @@ async function generate(provider, systemPrompt, tools, history, callbacks, optio
 		await throwIfAborted(options?.signal, stream);
 		await callbacks.onToolCall(toolCall);
 	}
+	const streamEnd = performance.now();
+	const llmFirstTokenLatencyMs = firstChunkTime !== void 0 ? Math.round(firstChunkTime - generateStart) : void 0;
+	const llmStreamDurationMs = firstChunkTime !== void 0 ? Math.round(streamEnd - generateStart) : void 0;
 	return {
 		id: stream.id,
 		message,
 		usage: stream.usage,
 		finishReason: stream.finishReason,
-		rawFinishReason: stream.rawFinishReason
+		rawFinishReason: stream.rawFinishReason,
+		...llmFirstTokenLatencyMs !== void 0 ? { llmFirstTokenLatencyMs } : {},
+		...llmStreamDurationMs !== void 0 ? { llmStreamDurationMs } : {}
 	};
 }
 function throwAbortError() {
@@ -275,13 +1188,24 @@ function addUsage(a, b) {
 		inputCacheCreation: a.inputCacheCreation + b.inputCacheCreation
 	};
 }
+/**
+* Compute the cache hit rate as a branded number between 0 and 1.
+*
+* Returns `undefined` when no input tokens were processed (inputTotal === 0),
+* so callers can distinguish "no data" from "zero hits".
+*/
+function cacheHitRate(usage) {
+	const total = inputTotal(usage);
+	if (total === 0) return void 0;
+	return usage.inputCacheRead / total;
+}
 //#endregion
 //#region src/index.ts
 /**
 * Concrete provider adapters stay off the root barrel because their SDK type
 * graphs pollute downstream declaration bundles. Import them from subpaths:
-* `@byfriends/kosong/providers/openai-compat`,
-* `@byfriends/kosong/providers/openai-legacy`, etc.
+* `@byfriends/kosong/providers/openai-responses`,
+* `@byfriends/kosong/providers/anthropic`, etc.
 */
 //#endregion
-export { APIConnectionError, APIContextOverflowError, APIEmptyResponseError, APIStatusError, APITimeoutError, ChatProviderError, UNKNOWN_CAPABILITY, addUsage, catalogBaseUrl, catalogModelToCapability, catalogProviderModels, createAssistantMessage, createProvider, createToolMessage, createUserMessage, emptyUsage, extractText, generate, grandTotal, inferWireType, inputTotal, isContentPart, isToolCall, isToolCallPart, isUnknownCapability, mergeInPlace };
+export { APIConnectionError, APIContextOverflowError, APIEmptyResponseError, APIStatusError, APITimeoutError, ChatProviderError, UNKNOWN_CAPABILITY, addUsage, cacheHitRate, catalogBaseUrl, catalogModelToCapability, catalogProviderModels, createAssistantMessage, createProvider, createToolMessage, createUserMessage, emptyUsage, extractText, generate, grandTotal, inferWireType, inputTotal, isContentPart, isToolCall, isToolCallPart, isUnknownCapability, mergeInPlace, resolveCapabilityFromRegistry };