@byfriends/kosong 0.1.0

package/dist/openai-common-08qin3UI.mjs

@@ -0,0 +1,278 @@
+import { a as APITimeoutError, o as ChatProviderError, s as normalizeAPIStatusError, t as APIConnectionError$1 } from "./errors-WFxxzL1B.mjs";
+import { APIConnectionError, APIConnectionTimeoutError, APIError, OpenAIError } from "openai";
+//#region src/message.ts
+/** Check if a streamed part is a ContentPart (text, think, image_url, audio_url, video_url). */
+function isContentPart(part) {
+	const t = part.type;
+	return t === "text" || t === "think" || t === "image_url" || t === "audio_url" || t === "video_url";
+}
+/** Check if a streamed part is a ToolCall. */
+function isToolCall(part) {
+	return part.type === "function";
+}
+/** Check if a streamed part is a ToolCallPart (streaming argument delta). */
+function isToolCallPart(part) {
+	return part.type === "tool_call_part";
+}
+/**
+* Merge `source` into `target` in-place for streaming accumulation.
+*
+* Supported combinations:
+* - TextPart + TextPart -> concatenate text
+* - ThinkPart + ThinkPart -> concatenate think (refuse if target.encrypted already set)
+* - ToolCall + ToolCallPart -> append arguments
+*
+* **Routing for parallel tool calls**: When OpenAI (or compatible) APIs stream
+* multiple tool calls in parallel, argument deltas may interleave across calls.
+* To handle this, {@link generate} routes ToolCallParts by their optional
+* {@link ToolCallPart.index} field (mirroring the provider's streaming index)
+* to the correct pending ToolCall, rather than relying on sequential ordering.
+* This function still performs sequential merging as a fallback when the
+* pending part matches the incoming one.
+*
+* Returns `true` if the merge was performed, `false` otherwise.
+*/
+function mergeInPlace(target, source) {
+	if (target.type === "text" && source.type === "text") {
+		target.text += source.text;
+		return true;
+	}
+	if (target.type === "think" && source.type === "think") {
+		if (target.encrypted !== void 0) return false;
+		target.think += source.think;
+		if (source.encrypted !== void 0) target.encrypted = source.encrypted;
+		return true;
+	}
+	if (target.type === "function" && source.type === "tool_call_part") {
+		if (source.argumentsPart !== null) target.arguments = target.arguments === null ? source.argumentsPart : target.arguments + source.argumentsPart;
+		return true;
+	}
+	return false;
+}
+/**
+* Extract the concatenated text from a message's content parts.
+*
+* @param message The message to extract text from.
+* @param sep Separator between text parts. Defaults to empty string.
+*/
+function extractText(message, sep = "") {
+	return message.content.filter((part) => part.type === "text").map((part) => part.text).join(sep);
+}
+/** Create a simple user message with a single text part. */
+function createUserMessage(content) {
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text: content
+		}],
+		toolCalls: []
+	};
+}
+/** Create an assistant message from content parts and optional tool calls. */
+function createAssistantMessage(content, toolCalls) {
+	return {
+		role: "assistant",
+		content,
+		toolCalls: toolCalls ?? []
+	};
+}
+/** Create a tool result message. */
+function createToolMessage(toolCallId, output) {
+	return {
+		role: "tool",
+		content: typeof output === "string" ? [{
+			type: "text",
+			text: output
+		}] : output,
+		toolCalls: [],
+		toolCallId
+	};
+}
+//#endregion
+//#region src/providers/openai-common.ts
+/**
+* Convert a kosong `ContentPart` to OpenAI-compatible content part.
+* Returns `null` for think parts (handled separately as reasoning_content).
+*/
+function convertContentPart(part) {
+	switch (part.type) {
+		case "text": return {
+			type: "text",
+			text: part.text
+		};
+		case "think": return null;
+		case "image_url": return {
+			type: "image_url",
+			image_url: part.imageUrl.id === void 0 ? { url: part.imageUrl.url } : {
+				url: part.imageUrl.url,
+				id: part.imageUrl.id
+			}
+		};
+		case "audio_url": return {
+			type: "audio_url",
+			audio_url: part.audioUrl.id === void 0 ? { url: part.audioUrl.url } : {
+				url: part.audioUrl.url,
+				id: part.audioUrl.id
+			}
+		};
+		case "video_url": return {
+			type: "video_url",
+			video_url: part.videoUrl.id === void 0 ? { url: part.videoUrl.url } : {
+				url: part.videoUrl.url,
+				id: part.videoUrl.id
+			}
+		};
+		default: throw new Error(`Unknown content part type: ${part.type}`);
+	}
+}
+/**
+* Convert a kosong `Tool` to OpenAI tool format.
+*/
+function toolToOpenAI(tool) {
+	return {
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	};
+}
+const NETWORK_RE = /network|connection|connect|disconnect/i;
+const TIMEOUT_RE = /timed?\s*out|timeout|deadline/i;
+function classifyBaseApiError(message) {
+	if (TIMEOUT_RE.test(message)) return new APITimeoutError(message);
+	if (NETWORK_RE.test(message)) return new APIConnectionError$1(message);
+	return new ChatProviderError(`Error: ${message}`);
+}
+/**
+* Convert an OpenAI SDK error (or raw Error) to a kosong `ChatProviderError`.
+*/
+function convertOpenAIError(error) {
+	if (error instanceof ChatProviderError) return error;
+	if (error instanceof APIConnectionTimeoutError) return new APITimeoutError(error.message);
+	if (error instanceof APIConnectionError) return new APIConnectionError$1(error.message);
+	if (error instanceof APIError && typeof error.status === "number") {
+		const reqId = error.requestID ?? null;
+		return normalizeAPIStatusError(error.status, error.message, reqId);
+	}
+	if (error instanceof APIError && error.constructor === APIError && error.error === void 0) return classifyBaseApiError(error.message);
+	if (error instanceof OpenAIError) return new ChatProviderError(`Error: ${error.message}`);
+	if (error instanceof Error) return new ChatProviderError(`Error: ${error.message}`);
+	return new ChatProviderError(`Error: ${String(error)}`);
+}
+/**
+* Type guard: narrow a tool call union to the function-type variant.
+* Works with OpenAI SDK's `ChatCompletionMessageToolCall` as well as
+* any object carrying `{ type: string }`.
+*/
+function isFunctionToolCall(tc) {
+	return tc.type === "function";
+}
+/**
+* Map kosong `ThinkingEffort` to OpenAI `reasoning_effort` string.
+*/
+function thinkingEffortToReasoningEffort(effort) {
+	switch (effort) {
+		case "off": return;
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh":
+		case "max": return "xhigh";
+		default: throw new Error(`Unknown thinking effort: ${String(effort)}`);
+	}
+}
+/**
+* Map OpenAI `reasoning_effort` string back to kosong `ThinkingEffort`.
+*/
+function reasoningEffortToThinkingEffort(reasoning) {
+	if (reasoning === void 0 || reasoning === null) return null;
+	switch (reasoning) {
+		case "low":
+		case "minimal": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh":
+		case "max": return "xhigh";
+		case "none": return "off";
+		default: return "off";
+	}
+}
+/**
+* Extract `TokenUsage` from an OpenAI-compatible usage object.
+*/
+function extractUsage(usage) {
+	if (usage === null || usage === void 0 || typeof usage !== "object") return null;
+	const u = usage;
+	const promptTokens = typeof u["prompt_tokens"] === "number" ? u["prompt_tokens"] : 0;
+	const completionTokens = typeof u["completion_tokens"] === "number" ? u["completion_tokens"] : 0;
+	let cached = 0;
+	if (typeof u["cached_tokens"] === "number") cached = u["cached_tokens"];
+	else if (typeof u["prompt_tokens_details"] === "object" && u["prompt_tokens_details"] !== null) {
+		const details = u["prompt_tokens_details"];
+		if (typeof details["cached_tokens"] === "number") cached = details["cached_tokens"];
+	}
+	return {
+		inputOther: promptTokens - cached,
+		output: completionTokens,
+		inputCacheRead: cached,
+		inputCacheCreation: 0
+	};
+}
+/**
+* Normalize an OpenAI Chat Completions–style `finish_reason` string to the
+* unified {@link FinishReason} enum.
+*
+* Used by both the Byf and OpenAI Legacy adapters because they share the
+* Chat Completions wire format. Returns `{ finishReason: null,
+* rawFinishReason: null }` when the upstream value is missing or `null` so
+* callers can treat "no signal" uniformly.
+*
+* Mapping:
+* - `'stop'` → `'completed'`
+* - `'tool_calls'` → `'tool_calls'`
+* - `'function_call'` → `'tool_calls'` (legacy alias)
+* - `'length'` → `'truncated'`
+* - `'content_filter'` → `'filtered'`
+* - any other non-null string → `'other'`
+*/
+function normalizeOpenAIFinishReason(raw) {
+	if (raw === null || raw === void 0) return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+	switch (raw) {
+		case "stop": return {
+			finishReason: "completed",
+			rawFinishReason: raw
+		};
+		case "tool_calls":
+		case "function_call": return {
+			finishReason: "tool_calls",
+			rawFinishReason: raw
+		};
+		case "length": return {
+			finishReason: "truncated",
+			rawFinishReason: raw
+		};
+		case "content_filter": return {
+			finishReason: "filtered",
+			rawFinishReason: raw
+		};
+		default: return {
+			finishReason: "other",
+			rawFinishReason: raw
+		};
+	}
+}
+/**
+* Convert tool-role message content according to the chosen strategy.
+*/
+function convertToolMessageContent(message, conversion) {
+	if (conversion === "extract_text") return extractText(message);
+	return message.content.map((p) => convertContentPart(p)).filter((p) => p !== null);
+}
+//#endregion
+export { mergeInPlace as _, isFunctionToolCall as a, thinkingEffortToReasoningEffort as c, createToolMessage as d, createUserMessage as f, isToolCallPart as g, isToolCall as h, extractUsage as i, toolToOpenAI as l, isContentPart as m, convertOpenAIError as n, normalizeOpenAIFinishReason as o, extractText as p, convertToolMessageContent as r, reasoningEffortToThinkingEffort as s, convertContentPart as t, createAssistantMessage as u };

package/dist/openai-common-B6cK2ig3.d.mts

@@ -0,0 +1,105 @@
+import { b as Message, c as TokenUsage, n as FinishReason, o as ThinkingEffort, p as Tool, v as ContentPart } from "./provider-DiJKWMsQ.mjs";
+import { o as ChatProviderError } from "./errors-DweKbIOf.mjs";
+
+//#region src/providers/openai-common.d.ts
+interface OpenAIContentPart {
+  type: string;
+  text?: string | undefined;
+  image_url?: {
+    url: string;
+    id?: string | null;
+  } | undefined;
+  audio_url?: {
+    url: string;
+    id?: string | null;
+  } | undefined;
+  video_url?: {
+    url: string;
+    id?: string | null;
+  } | undefined;
+}
+/**
+ * Convert a kosong `ContentPart` to OpenAI-compatible content part.
+ * Returns `null` for think parts (handled separately as reasoning_content).
+ */
+declare function convertContentPart(part: ContentPart): OpenAIContentPart | null;
+interface OpenAIToolParam {
+  type: string;
+  function: {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+}
+/**
+ * Convert a kosong `Tool` to OpenAI tool format.
+ */
+declare function toolToOpenAI(tool: Tool): OpenAIToolParam;
+/**
+ * Convert an OpenAI SDK error (or raw Error) to a kosong `ChatProviderError`.
+ */
+declare function convertOpenAIError(error: unknown): ChatProviderError;
+/** Shape of a function-type tool call (subset used by the guard). */
+interface FunctionToolCallShape {
+  type: 'function';
+  id: string;
+  function: {
+    name: string;
+    arguments: string | null;
+  };
+}
+/**
+ * Type guard: narrow a tool call union to the function-type variant.
+ * Works with OpenAI SDK's `ChatCompletionMessageToolCall` as well as
+ * any object carrying `{ type: string }`.
+ */
+declare function isFunctionToolCall<T extends {
+  type: string;
+}>(tc: T): tc is T & FunctionToolCallShape;
+/**
+ * Map kosong `ThinkingEffort` to OpenAI `reasoning_effort` string.
+ */
+declare function thinkingEffortToReasoningEffort(effort: ThinkingEffort): string | undefined;
+/**
+ * Map OpenAI `reasoning_effort` string back to kosong `ThinkingEffort`.
+ */
+declare function reasoningEffortToThinkingEffort(reasoning: string | undefined): ThinkingEffort | null;
+/**
+ * Extract `TokenUsage` from an OpenAI-compatible usage object.
+ */
+declare function extractUsage(usage: unknown): TokenUsage | null;
+/**
+ * Normalize an OpenAI Chat Completions–style `finish_reason` string to the
+ * unified {@link FinishReason} enum.
+ *
+ * Used by both the Byf and OpenAI Legacy adapters because they share the
+ * Chat Completions wire format. Returns `{ finishReason: null,
+ * rawFinishReason: null }` when the upstream value is missing or `null` so
+ * callers can treat "no signal" uniformly.
+ *
+ * Mapping:
+ * - `'stop'` → `'completed'`
+ * - `'tool_calls'` → `'tool_calls'`
+ * - `'function_call'` → `'tool_calls'` (legacy alias)
+ * - `'length'` → `'truncated'`
+ * - `'content_filter'` → `'filtered'`
+ * - any other non-null string → `'other'`
+ */
+declare function normalizeOpenAIFinishReason(raw: string | null | undefined): {
+  finishReason: FinishReason | null;
+  rawFinishReason: string | null;
+};
+/**
+ * Strategy for converting tool-role message content.
+ *
+ * - `'extract_text'`: flatten all content parts into a single text string
+ *   (some providers require tool results as plain text).
+ * - `null`: convert content parts to the standard OpenAI content-part array.
+ */
+type ToolMessageConversion = 'extract_text' | null;
+/**
+ * Convert tool-role message content according to the chosen strategy.
+ */
+declare function convertToolMessageContent(message: Message, conversion: ToolMessageConversion): string | OpenAIContentPart[];
+//#endregion
+export { convertContentPart as a, extractUsage as c, reasoningEffortToThinkingEffort as d, thinkingEffortToReasoningEffort as f, ToolMessageConversion as i, isFunctionToolCall as l, OpenAIContentPart as n, convertOpenAIError as o, toolToOpenAI as p, OpenAIToolParam as r, convertToolMessageContent as s, FunctionToolCallShape as t, normalizeOpenAIFinishReason as u };

package/dist/openai-compat-CMrIk-ib.d.mts

@@ -0,0 +1,132 @@
+import { D as VideoURLPart, a as StreamedMessage, b as Message, i as ProviderRequestAuth, m as ModelCapability, o as ThinkingEffort, p as Tool, r as GenerateOptions, s as VideoUploadInput, t as ChatProvider } from "./provider-DiJKWMsQ.mjs";
+import OpenAI from "openai";
+
+//#region src/providers/openai-compat-files.d.ts
+interface OpenAICompatUploadOptions {
+  auth?: ProviderRequestAuth;
+  signal?: AbortSignal;
+}
+interface OpenAICompatFilesOptions {
+  apiKey?: string;
+  baseUrl: string;
+  defaultHeaders?: Record<string, string>;
+  clientFactory?: (auth: ProviderRequestAuth) => OpenAI;
+}
+/**
+ * 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}.
+ */
+declare class OpenAICompatFiles {
+  private readonly _apiKey;
+  private readonly _baseUrl;
+  private readonly _defaultHeaders;
+  private readonly _client;
+  private readonly _clientFactory;
+  constructor(options: OpenAICompatFilesOptions);
+  /**
+   * 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.
+   */
+  uploadVideo(input: string | VideoUploadInput, options?: OpenAICompatUploadOptions): Promise<VideoURLPart>;
+  private _createClient;
+}
+//#endregion
+//#region src/providers/openai-compat.d.ts
+interface OpenAICompatOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  model: string;
+  stream?: boolean;
+  defaultHeaders?: Record<string, string>;
+  thinkingEffortKey?: string;
+  generationKwargs?: GenerationKwargs;
+  clientFactory?: (auth: ProviderRequestAuth) => OpenAI;
+}
+interface GenerationKwargs {
+  /**
+   * Legacy completion-budget alias. Some OpenAI-compatible APIs still accept
+   * `max_tokens`, but for reasoning models it shares the budget with
+   * `reasoning_content` and a small value can cause a 200 response with no
+   * `content`. Prefer `max_completion_tokens`. When both are set
+   * `max_completion_tokens` wins; this provider normalizes by sending only
+   * `max_completion_tokens` on the wire.
+   */
+  max_tokens?: number | undefined;
+  max_completion_tokens?: number | undefined;
+  temperature?: number | undefined;
+  top_p?: number | undefined;
+  n?: number | undefined;
+  presence_penalty?: number | undefined;
+  frequency_penalty?: number | undefined;
+  stop?: string | string[] | undefined;
+  reasoning_effort?: string | undefined;
+  prompt_cache_key?: string | undefined;
+  extra_body?: ExtraBody;
+  [key: string]: unknown;
+}
+interface ThinkingConfig {
+  type?: 'enabled' | 'disabled';
+  keep?: unknown;
+  [key: string]: unknown;
+}
+interface ExtraBody {
+  thinking?: ThinkingConfig;
+  [key: string]: unknown;
+}
+/**
+ * Extract usage from a streaming chunk. Some OpenAI-compatible providers may place usage in
+ * `choices[0].usage` in addition to the top-level `usage` field.
+ */
+declare function extractUsageFromChunk(chunk: Record<string, unknown>): Record<string, unknown> | null;
+declare class OpenAICompatChatProvider implements ChatProvider {
+  readonly name: string;
+  private _model;
+  private _stream;
+  private _apiKey;
+  private _baseUrl;
+  private _defaultHeaders;
+  private _generationKwargs;
+  private _thinkingEffortKey;
+  private _client;
+  private _clientFactory;
+  private _files;
+  constructor(options: OpenAICompatOptions);
+  get modelName(): string;
+  /**
+   * File upload client for an OpenAI-compatible service.
+   *
+   * Use this to upload videos (and other media in the future) to the file
+   * service and receive a content part that can be embedded in chat
+   * messages.
+   */
+  get files(): OpenAICompatFiles;
+  uploadVideo(input: string | VideoUploadInput, options?: GenerateOptions): Promise<VideoURLPart>;
+  get thinkingEffort(): ThinkingEffort | null;
+  get modelParameters(): Record<string, unknown>;
+  generate(systemPrompt: string, tools: Tool[], history: Message[], options?: GenerateOptions): Promise<StreamedMessage>;
+  getCapability(_model?: string): ModelCapability;
+  withThinking(effort: ThinkingEffort): OpenAICompatChatProvider;
+  withGenerationKwargs(kwargs: GenerationKwargs): OpenAICompatChatProvider;
+  withMaxCompletionTokens(maxCompletionTokens: number): OpenAICompatChatProvider;
+  withExtraBody(extraBody: ExtraBody): OpenAICompatChatProvider;
+  private _createClient;
+  private _withGenerationKwargs;
+  private _clone;
+}
+//#endregion
+export { ThinkingConfig as a, OpenAICompatOptions as i, GenerationKwargs as n, extractUsageFromChunk as o, OpenAICompatChatProvider as r, ExtraBody as t };