@byfriends/kosong 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,161 @@
+import { A as createUserMessage, C as TextPart, D as VideoURLPart, E as ToolCallPart, F as mergeInPlace, M as isContentPart, N as isToolCall, O as createAssistantMessage, P as isToolCallPart, S as StreamedMessagePart, T as ToolCall, _ as AudioURLPart, a as StreamedMessage, b as Message, c as TokenUsage, d as grandTotal, f as inputTotal, g as isUnknownCapability, h as UNKNOWN_CAPABILITY, i as ProviderRequestAuth, j as extractText, k as createToolMessage, l as addUsage, m as ModelCapability, n as FinishReason, o as ThinkingEffort, p as Tool, r as GenerateOptions, s as VideoUploadInput, t as ChatProvider, u as emptyUsage, v as ContentPart, w as ThinkPart, x as Role, y as ImageURLPart } from "./provider-DiJKWMsQ.mjs";
+import { a as APITimeoutError, i as APIStatusError, n as APIContextOverflowError, o as ChatProviderError, r as APIEmptyResponseError, t as APIConnectionError } from "./errors-DweKbIOf.mjs";
+import { n as AnthropicOptions } from "./anthropic-Dm_GqFgS.mjs";
+import { r as GoogleGenAIOptions } from "./google-genai-hX0X6CF3.mjs";
+import { i as OpenAICompatOptions } from "./openai-compat-CMrIk-ib.mjs";
+import { r as OpenAILegacyOptions } from "./openai-legacy-B6CVfLlr.mjs";
+import { r as OpenAIResponsesOptions } from "./openai-responses-BxOwxtd3.mjs";
+
+//#region src/providers/index.d.ts
+type ProviderConfig = ({
+  type: 'anthropic';
+} & AnthropicOptions) | ({
+  type: 'openai';
+} & OpenAILegacyOptions) | ({
+  type: 'openai-compat';
+} & OpenAICompatOptions) | ({
+  type: 'google-genai';
+} & GoogleGenAIOptions) | ({
+  type: 'openai_responses';
+} & OpenAIResponsesOptions) | ({
+  type: 'vertexai';
+} & GoogleGenAIOptions);
+type ProviderType = ProviderConfig['type'];
+declare function createProvider(config: ProviderConfig): ChatProvider;
+//#endregion
+//#region src/catalog.d.ts
+/**
+ * models.dev-style catalog: a public map of provider/model metadata. Callers
+ * consume a snapshot of this shape to populate provider + model configuration
+ * without hand-writing context windows or capabilities.
+ */
+interface CatalogModelEntry {
+  readonly id?: string;
+  readonly name?: string;
+  readonly family?: string;
+  readonly limit?: {
+    readonly context?: number;
+    readonly output?: number;
+  };
+  readonly tool_call?: boolean;
+  readonly reasoning?: boolean;
+  readonly interleaved?: boolean | {
+    readonly field?: string;
+  };
+  readonly modalities?: {
+    readonly input?: readonly string[];
+    readonly output?: readonly string[];
+  };
+}
+interface CatalogProviderEntry {
+  readonly id?: string;
+  readonly name?: string;
+  /** Base URL for the provider; may be empty (some SDKs hardcode it). */
+  readonly api?: string;
+  /** Env var names carrying credentials — surfaced as a hint by callers. */
+  readonly env?: readonly string[];
+  /** models.dev SDK package id; used to infer the wire type when `type` is absent. */
+  readonly npm?: string;
+  /** Explicit wire type extension; inferred from `npm`/`id` when absent. */
+  readonly type?: string;
+  readonly models?: Record<string, CatalogModelEntry>;
+}
+/** Top-level catalog: `{ [providerId]: ProviderEntry }` (e.g. models.dev/api.json). */
+type Catalog = Record<string, CatalogProviderEntry>;
+/** A normalized catalog model: identity plus its {@link ModelCapability}. */
+interface CatalogModel {
+  readonly id: string;
+  readonly name?: string;
+  readonly maxOutputSize?: number;
+  readonly reasoningKey?: string;
+  readonly capability: ModelCapability;
+}
+/**
+ * Resolves a catalog provider entry to a supported wire type. Honors an
+ * explicit `type`, otherwise infers from `npm`/`id`. Unknown providers return
+ * `undefined` so callers can omit them instead of writing an invalid config.
+ */
+declare function inferWireType(entry: CatalogProviderEntry): ProviderType | undefined;
+/**
+ * Resolves the base URL to store for a catalog provider, adapting the catalog's
+ * `api` to the wire's SDK convention.
+ *
+ * models.dev `api` URLs are written for the SDK named in `npm` (e.g.
+ * `@ai-sdk/anthropic`), whose base already includes the `/v1` version segment.
+ * We route the `anthropic` wire through the official `@anthropic-ai/sdk`, which
+ * appends `/v1/messages` itself — so a catalog `api` ending in `/v1` would POST
+ * to `/v1/v1/messages` (404). Strip the trailing `/v1` for anthropic. OpenAI
+ * family SDKs append `/chat/completions` to a `/v1` base, so those pass through.
+ */
+declare function catalogBaseUrl(entry: CatalogProviderEntry, wire: ProviderType): string | undefined;
+/** Normalizes one catalog model entry into a {@link CatalogModel}; skips invalid entries. */
+declare function catalogModelToCapability(model: CatalogModelEntry): CatalogModel | undefined;
+/** Extracts the valid, normalized models from a catalog provider entry. */
+declare function catalogProviderModels(entry: CatalogProviderEntry): CatalogModel[];
+//#endregion
+//#region src/generate.d.ts
+/**
+ * The result of a single {@link generate} call.
+ *
+ * Contains the fully-assembled assistant {@link message}, an optional
+ * provider-assigned {@link id}, and token {@link usage} statistics.
+ */
+interface GenerateResult {
+  /** Provider-assigned response identifier, or `null` if unavailable. */
+  readonly id: string | null;
+  /** The fully-assembled assistant message with merged content parts and tool calls. */
+  readonly message: Message;
+  /** Token usage for this generation, or `null` if not reported. */
+  readonly usage: TokenUsage | null;
+  /**
+   * Normalized finish reason reported by the provider, or `null` if no
+   * finish_reason was emitted (for example, the stream was interrupted
+   * before the final event).
+   */
+  readonly finishReason: FinishReason | null;
+  /**
+   * Raw provider-specific finish_reason string preserved verbatim.
+   * `null` if the provider did not emit one.
+   */
+  readonly rawFinishReason: string | null;
+}
+interface GenerateCallbacks {
+  onMessagePart?: (part: StreamedMessagePart) => void | Promise<void>;
+  /**
+   * Fires once per fully-assembled tool call after the stream drains, in the
+   * order tool calls appear in the final assistant message.
+   *
+   * Tool calls are deliberately deferred until after the stream completes:
+   * parallel-tool-call streams may interleave argument deltas across calls
+   * (e.g. tc0-header → tc1-header → tc0-args → tc1-args), so firing mid-stream
+   * would dispatch a tool with half-parsed arguments and trigger toolParseError.
+   */
+  onToolCall?: (toolCall: ToolCall) => void | Promise<void>;
+}
+/**
+ * Generate one assistant message by streaming from the given provider.
+ *
+ * Parts of the message are streamed and merged: consecutive compatible parts
+ * (e.g. TextPart + TextPart, ToolCall + ToolCallPart) are merged in-place so
+ * the returned message always contains fully-assembled parts.
+ *
+ * **Tool call completion** is inferred from merge boundaries (a non-merging
+ * next part flushes the pending tool call into `message.toolCalls`) and from
+ * stream end. Provider adapters translate native "done" signals into this
+ * unified form; the generate loop never sees a separate done event.
+ *
+ * @param provider - The chat provider to generate from.
+ * @param systemPrompt - System-level instruction prepended to the request.
+ * @param tools - Tool definitions the model may invoke.
+ * @param history - The conversation history sent as context.
+ * @param callbacks - Optional streaming callbacks.
+ * @param options - Optional per-call settings (e.g. an {@link AbortSignal}).
+ *
+ * @throws {DOMException} with name `"AbortError"` when `options.signal` is
+ *   aborted before or during streaming.
+ * @throws {APIEmptyResponseError} when the response contains no content and
+ *   no tool calls, or only thinking content without any text or tool calls.
+ */
+declare function generate(provider: ChatProvider, systemPrompt: string, tools: Tool[], history: Message[], callbacks?: GenerateCallbacks, options?: GenerateOptions): Promise<GenerateResult>;
+//#endregion
+export { APIConnectionError, APIContextOverflowError, APIEmptyResponseError, APIStatusError, APITimeoutError, type AudioURLPart, type Catalog, type CatalogModel, type CatalogModelEntry, type CatalogProviderEntry, ChatProvider, ChatProviderError, type ContentPart, FinishReason, type GenerateCallbacks, GenerateOptions, type GenerateResult, type ImageURLPart, type Message, type ModelCapability, type ProviderConfig, ProviderRequestAuth, type ProviderType, type Role, StreamedMessage, type StreamedMessagePart, type TextPart, type ThinkPart, ThinkingEffort, type TokenUsage, type Tool, type ToolCall, type ToolCallPart, UNKNOWN_CAPABILITY, type VideoURLPart, VideoUploadInput, addUsage, catalogBaseUrl, catalogModelToCapability, catalogProviderModels, createAssistantMessage, createProvider, createToolMessage, createUserMessage, emptyUsage, extractText, generate, grandTotal, inferWireType, inputTotal, isContentPart, isToolCall, isToolCallPart, isUnknownCapability, mergeInPlace };

package/dist/index.mjs

@@ -0,0 +1,287 @@
+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 { 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 { 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";
+//#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 "google-genai": return new GoogleGenAIChatProvider(config);
+		case "openai_responses": return new OpenAIResponsesChatProvider(config);
+		case "vertexai": return new GoogleGenAIChatProvider(config);
+		default: throw new Error(`Unknown provider type: ${String(config)}`);
+	}
+}
+//#endregion
+//#region src/catalog.ts
+const KNOWN_WIRE_TYPES = [
+	"anthropic",
+	"openai",
+	"openai-compat",
+	"google-genai",
+	"openai_responses",
+	"vertexai"
+];
+function isWireType(value) {
+	return typeof value === "string" && KNOWN_WIRE_TYPES.includes(value);
+}
+function hasEmbeddingMarker(value) {
+	if (value === void 0) return false;
+	const lower = value.toLowerCase();
+	return lower.includes("embedding") || /(?:^|[-_/])embed(?:$|[-_/])/.test(lower);
+}
+function isUsableChatModel(model) {
+	const outputModalities = model.modalities?.output;
+	if (outputModalities !== void 0 && !outputModalities.includes("text")) return false;
+	return !hasEmbeddingMarker(model.family) && !hasEmbeddingMarker(model.id) && !hasEmbeddingMarker(model.name);
+}
+/**
+* Resolves a catalog provider entry to a supported wire type. Honors an
+* explicit `type`, otherwise infers from `npm`/`id`. Unknown providers return
+* `undefined` so callers can omit them instead of writing an invalid config.
+*/
+function inferWireType(entry) {
+	if (isWireType(entry.type)) return entry.type;
+	const npm = (entry.npm ?? "").toLowerCase();
+	const id = (entry.id ?? "").toLowerCase();
+	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";
+}
+/**
+* Resolves the base URL to store for a catalog provider, adapting the catalog's
+* `api` to the wire's SDK convention.
+*
+* models.dev `api` URLs are written for the SDK named in `npm` (e.g.
+* `@ai-sdk/anthropic`), whose base already includes the `/v1` version segment.
+* We route the `anthropic` wire through the official `@anthropic-ai/sdk`, which
+* appends `/v1/messages` itself — so a catalog `api` ending in `/v1` would POST
+* to `/v1/v1/messages` (404). Strip the trailing `/v1` for anthropic. OpenAI
+* family SDKs append `/chat/completions` to a `/v1` base, so those pass through.
+*/
+function catalogBaseUrl(entry, wire) {
+	const api = entry.api;
+	if (typeof api !== "string" || api.length === 0) return void 0;
+	if (wire === "anthropic") return api.replace(/\/v1\/?$/, "");
+	return api;
+}
+/** Normalizes one catalog model entry into a {@link CatalogModel}; skips invalid entries. */
+function catalogModelToCapability(model) {
+	if (typeof model.id !== "string" || model.id.length === 0) return void 0;
+	const context = model.limit?.context;
+	if (typeof context !== "number" || !Number.isInteger(context) || context <= 0) return void 0;
+	if (!isUsableChatModel(model)) return void 0;
+	const inputs = model.modalities?.input ?? [];
+	const output = model.limit?.output;
+	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
+		}
+	};
+}
+function catalogReasoningKey(interleaved) {
+	if (interleaved === true) return "reasoning_content";
+	if (typeof interleaved !== "object" || interleaved === null) return void 0;
+	const field = interleaved.field?.trim();
+	return field !== void 0 && field.length > 0 ? field : void 0;
+}
+/** Extracts the valid, normalized models from a catalog provider entry. */
+function catalogProviderModels(entry) {
+	const models = entry.models ?? {};
+	return Object.values(models).map((model) => catalogModelToCapability(model)).filter((model) => model !== void 0);
+}
+//#endregion
+//#region src/generate.ts
+/**
+* Generate one assistant message by streaming from the given provider.
+*
+* Parts of the message are streamed and merged: consecutive compatible parts
+* (e.g. TextPart + TextPart, ToolCall + ToolCallPart) are merged in-place so
+* the returned message always contains fully-assembled parts.
+*
+* **Tool call completion** is inferred from merge boundaries (a non-merging
+* next part flushes the pending tool call into `message.toolCalls`) and from
+* stream end. Provider adapters translate native "done" signals into this
+* unified form; the generate loop never sees a separate done event.
+*
+* @param provider - The chat provider to generate from.
+* @param systemPrompt - System-level instruction prepended to the request.
+* @param tools - Tool definitions the model may invoke.
+* @param history - The conversation history sent as context.
+* @param callbacks - Optional streaming callbacks.
+* @param options - Optional per-call settings (e.g. an {@link AbortSignal}).
+*
+* @throws {DOMException} with name `"AbortError"` when `options.signal` is
+*   aborted before or during streaming.
+* @throws {APIEmptyResponseError} when the response contains no content and
+*   no tool calls, or only thinking content without any text or tool calls.
+*/
+async function generate(provider, systemPrompt, tools, history, callbacks, options) {
+	const message = {
+		role: "assistant",
+		content: [],
+		toolCalls: []
+	};
+	let pendingPart = null;
+	const toolCallIndexMap = /* @__PURE__ */ new Map();
+	if (options?.signal?.aborted) throwAbortError();
+	const stream = await provider.generate(systemPrompt, tools, history, options);
+	await throwIfAborted(options?.signal, stream);
+	for await (const part of stream) {
+		await throwIfAborted(options?.signal, stream);
+		if (callbacks?.onMessagePart !== void 0) {
+			await callbacks.onMessagePart(deepCopyPart(part));
+			await throwIfAborted(options?.signal, stream);
+		}
+		if (isToolCallPart(part) && part.index !== void 0 && !isPendingToolCallAtIndex(pendingPart, part.index)) {
+			const arrayIdx = toolCallIndexMap.get(part.index);
+			if (arrayIdx !== void 0) {
+				const target = message.toolCalls[arrayIdx];
+				if (target !== void 0 && part.argumentsPart !== null) target.arguments = target.arguments === null ? part.argumentsPart : target.arguments + part.argumentsPart;
+				continue;
+			}
+		}
+		if (pendingPart === null) pendingPart = part;
+		else if (!mergeInPlace(pendingPart, part)) {
+			flushPart(message, pendingPart, toolCallIndexMap);
+			pendingPart = part;
+		}
+	}
+	await throwIfAborted(options?.signal, stream);
+	if (pendingPart !== null) flushPart(message, pendingPart, toolCallIndexMap);
+	if (message.content.length === 0 && message.toolCalls.length === 0) throw new APIEmptyResponseError(`The API returned an empty response (no content, no tool calls). Provider: ${provider.name}, model: ${provider.modelName}`);
+	const hasThink = message.content.some((p) => p.type === "think");
+	const hasText = message.content.some((p) => p.type === "text" && p.text.trim().length > 0);
+	const hasToolCalls = message.toolCalls.length > 0;
+	if (hasThink && !hasText && !hasToolCalls) throw new APIEmptyResponseError(`The API returned a response containing only thinking content without any text or tool calls. This usually indicates the stream was interrupted or the output token budget was exhausted during reasoning. Provider: ${provider.name}, model: ${provider.modelName}`);
+	if (callbacks?.onToolCall !== void 0) for (const toolCall of message.toolCalls) {
+		await throwIfAborted(options?.signal, stream);
+		await callbacks.onToolCall(toolCall);
+	}
+	return {
+		id: stream.id,
+		message,
+		usage: stream.usage,
+		finishReason: stream.finishReason,
+		rawFinishReason: stream.rawFinishReason
+	};
+}
+function throwAbortError() {
+	throw new DOMException("The operation was aborted.", "AbortError");
+}
+async function cancelStream(stream) {
+	const cancelable = stream;
+	try {
+		await cancelable.cancel?.();
+	} catch {}
+	try {
+		await cancelable.return?.();
+	} catch {}
+}
+async function throwIfAborted(signal, stream) {
+	if (!signal?.aborted) return;
+	if (stream !== void 0) await cancelStream(stream);
+	throwAbortError();
+}
+/** True when `pending` is a ToolCall whose _streamIndex equals `index`. */
+function isPendingToolCallAtIndex(pending, index) {
+	return pending !== null && isToolCall(pending) && pending._streamIndex === index;
+}
+/**
+* Append a fully-merged part to the message.
+*
+* - ContentPart -> message.content
+* - ToolCall    -> message.toolCalls (the `_streamIndex` routing key is
+*                  registered in the map and stripped before storage).
+* - ToolCallPart -> ignored (orphaned delta without a matching pending call)
+*/
+function flushPart(message, part, toolCallIndexMap) {
+	if (isContentPart(part)) {
+		message.content.push(part);
+		return;
+	}
+	if (isToolCall(part)) {
+		const streamIndex = part._streamIndex;
+		const stored = {
+			type: "function",
+			id: part.id,
+			name: part.name,
+			arguments: part.arguments,
+			extras: part.extras
+		};
+		const ordinal = message.toolCalls.length;
+		message.toolCalls.push(stored);
+		if (streamIndex !== void 0) toolCallIndexMap.set(streamIndex, ordinal);
+	}
+}
+/**
+* Produce a shallow-ish copy of a StreamedMessagePart.
+*
+* This is intentionally minimal: we only need isolation for the mutable
+* string fields that `mergeInPlace` mutates (text, think, arguments).
+*/
+function deepCopyPart(part) {
+	return structuredClone(part);
+}
+//#endregion
+//#region src/usage.ts
+/**
+* Compute total input tokens (other + cache read + cache creation).
+*/
+function inputTotal(usage) {
+	return usage.inputOther + usage.inputCacheRead + usage.inputCacheCreation;
+}
+/**
+* Compute grand total tokens (input total + output).
+*/
+function grandTotal(usage) {
+	return inputTotal(usage) + usage.output;
+}
+/**
+* Create a zero-valued TokenUsage.
+*/
+function emptyUsage() {
+	return {
+		inputOther: 0,
+		output: 0,
+		inputCacheRead: 0,
+		inputCacheCreation: 0
+	};
+}
+/**
+* Sum two TokenUsage values.
+*/
+function addUsage(a, b) {
+	return {
+		inputOther: a.inputOther + b.inputOther,
+		output: a.output + b.output,
+		inputCacheRead: a.inputCacheRead + b.inputCacheRead,
+		inputCacheCreation: a.inputCacheCreation + b.inputCacheCreation
+	};
+}
+//#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.
+*/
+//#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 };