@byfriends/kosong 0.1.0

package/dist/openai-legacy-B6CVfLlr.d.mts

@@ -0,0 +1,71 @@
+import { S as StreamedMessagePart, a as StreamedMessage, b as Message, c as TokenUsage, i as ProviderRequestAuth, m as ModelCapability, n as FinishReason, o as ThinkingEffort, p as Tool, r as GenerateOptions, t as ChatProvider } from "./provider-DiJKWMsQ.mjs";
+import { i as ToolMessageConversion } from "./openai-common-B6cK2ig3.mjs";
+import OpenAI from "openai";
+
+//#region src/providers/openai-legacy.d.ts
+interface OpenAILegacyOptions {
+  apiKey?: string | undefined;
+  baseUrl?: string | undefined;
+  model: string;
+  stream?: boolean | undefined;
+  maxTokens?: number | undefined;
+  reasoningKey?: string | undefined;
+  httpClient?: unknown;
+  defaultHeaders?: Record<string, string>;
+  toolMessageConversion?: ToolMessageConversion | undefined;
+  clientFactory?: (auth: ProviderRequestAuth) => OpenAI;
+}
+interface OpenAILegacyGenerationKwargs {
+  max_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;
+  [key: string]: unknown;
+}
+declare class OpenAILegacyStreamedMessage implements StreamedMessage {
+  private _id;
+  private _usage;
+  private _finishReason;
+  private _rawFinishReason;
+  private readonly _iter;
+  constructor(response: OpenAI.Chat.ChatCompletion | AsyncIterable<OpenAI.Chat.ChatCompletionChunk>, isStream: boolean, reasoningKey: string | undefined);
+  get id(): string | null;
+  get usage(): TokenUsage | null;
+  get finishReason(): FinishReason | null;
+  get rawFinishReason(): string | null;
+  [Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart>;
+  private _captureFinishReason;
+  private _convertNonStreamResponse;
+  private _convertStreamResponse;
+}
+declare class OpenAILegacyChatProvider implements ChatProvider {
+  readonly name: string;
+  private _model;
+  private _stream;
+  private _apiKey;
+  private _baseUrl;
+  private _defaultHeaders;
+  private _reasoningKey;
+  private _reasoningEffort;
+  private _generationKwargs;
+  private _toolMessageConversion;
+  private _client;
+  private _httpClient;
+  private _clientFactory;
+  constructor(options: OpenAILegacyOptions);
+  get modelName(): string;
+  get thinkingEffort(): ThinkingEffort | null;
+  get modelParameters(): Record<string, unknown>;
+  getCapability(model?: string): ModelCapability;
+  generate(systemPrompt: string, tools: Tool[], history: Message[], options?: GenerateOptions): Promise<StreamedMessage>;
+  withThinking(effort: ThinkingEffort): OpenAILegacyChatProvider;
+  withGenerationKwargs(kwargs: OpenAILegacyGenerationKwargs): OpenAILegacyChatProvider;
+  private _clone;
+  private _createClient;
+  private _buildClient;
+}
+//#endregion
+export { OpenAILegacyStreamedMessage as i, OpenAILegacyGenerationKwargs as n, OpenAILegacyOptions as r, OpenAILegacyChatProvider as t };

package/dist/openai-responses-BxOwxtd3.d.mts

@@ -0,0 +1,65 @@
+import { S as StreamedMessagePart, a as StreamedMessage, b as Message, c as TokenUsage, i as ProviderRequestAuth, m as ModelCapability, n as FinishReason, o as ThinkingEffort, p as Tool, r as GenerateOptions, t as ChatProvider } from "./provider-DiJKWMsQ.mjs";
+import { i as ToolMessageConversion } from "./openai-common-B6cK2ig3.mjs";
+import OpenAI from "openai";
+
+//#region src/providers/openai-responses.d.ts
+interface OpenAIResponsesOptions {
+  apiKey?: string | undefined;
+  baseUrl?: string | undefined;
+  model: string;
+  maxOutputTokens?: number | undefined;
+  httpClient?: unknown;
+  defaultHeaders?: Record<string, string>;
+  toolMessageConversion?: ToolMessageConversion | undefined;
+  clientFactory?: (auth: ProviderRequestAuth) => OpenAI;
+}
+interface OpenAIResponsesGenerationKwargs {
+  max_output_tokens?: number | undefined;
+  temperature?: number | undefined;
+  top_p?: number | undefined;
+  reasoning_effort?: string | undefined;
+  [key: string]: unknown;
+}
+declare class OpenAIResponsesStreamedMessage implements StreamedMessage {
+  private _id;
+  private _usage;
+  private _finishReason;
+  private _rawFinishReason;
+  private readonly _iter;
+  constructor(response: unknown, isStream: boolean);
+  get id(): string | null;
+  get usage(): TokenUsage | null;
+  get finishReason(): FinishReason | null;
+  get rawFinishReason(): string | null;
+  [Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart>;
+  private _captureFinishReasonFromResponse;
+  private _extractUsage;
+  private _convertNonStreamResponse;
+  private _convertStreamResponse;
+}
+declare class OpenAIResponsesChatProvider implements ChatProvider {
+  readonly name: string;
+  private _model;
+  private _stream;
+  private _apiKey;
+  private _baseUrl;
+  private _defaultHeaders;
+  private _generationKwargs;
+  private _toolMessageConversion;
+  private _client;
+  private _httpClient;
+  private _clientFactory;
+  constructor(options: OpenAIResponsesOptions);
+  get modelName(): string;
+  get thinkingEffort(): ThinkingEffort | null;
+  get modelParameters(): Record<string, unknown>;
+  getCapability(model?: string): ModelCapability;
+  generate(systemPrompt: string, tools: Tool[], history: Message[], options?: GenerateOptions): Promise<StreamedMessage>;
+  withThinking(effort: ThinkingEffort): OpenAIResponsesChatProvider;
+  withGenerationKwargs(kwargs: OpenAIResponsesGenerationKwargs): OpenAIResponsesChatProvider;
+  private _clone;
+  private _createClient;
+  private _buildClient;
+}
+//#endregion
+export { OpenAIResponsesStreamedMessage as i, OpenAIResponsesGenerationKwargs as n, OpenAIResponsesOptions as r, OpenAIResponsesChatProvider as t };

package/dist/provider-DiJKWMsQ.d.mts

@@ -0,0 +1,371 @@
+//#region src/message.d.ts
+type Role = 'system' | 'user' | 'assistant' | 'tool';
+interface TextPart {
+  type: 'text';
+  text: string;
+}
+interface ThinkPart {
+  type: 'think';
+  think: string;
+  encrypted?: string;
+}
+interface ImageURLPart {
+  type: 'image_url';
+  imageUrl: {
+    url: string;
+    id?: string;
+  };
+}
+interface AudioURLPart {
+  type: 'audio_url';
+  audioUrl: {
+    url: string;
+    id?: string;
+  };
+}
+interface VideoURLPart {
+  type: 'video_url';
+  videoUrl: {
+    url: string;
+    id?: string | undefined;
+  };
+}
+/**
+ * A single piece of content within a {@link Message}.
+ *
+ * The union covers text, model reasoning ("think"), images, audio, and video.
+ * Providers convert these to their native content-block format during
+ * {@link ChatProvider.generate}.
+ */
+type ContentPart = TextPart | ThinkPart | ImageURLPart | AudioURLPart | VideoURLPart;
+interface ToolCall {
+  type: 'function';
+  id: string;
+  name: string;
+  arguments: string | null;
+  extras?: Record<string, unknown>;
+  /**
+   * Provider-specific streaming index used to route argument deltas to the
+   * correct parallel tool call. Set by streaming providers (OpenAI Chat
+   * Completions `index`, Responses API `item_id`). Consumed internally by
+   * {@link generate} and stripped before the ToolCall is stored on a Message.
+   *
+   * @internal
+   */
+  _streamIndex?: number | string;
+}
+/** Streaming delta for tool call arguments. */
+interface ToolCallPart {
+  type: 'tool_call_part';
+  argumentsPart: string | null;
+  /**
+   * Provider-specific index for routing this streaming delta to the correct
+   * parallel tool call. Used by OpenAI Chat Completions (`index`) and
+   * Responses API (`item_id`/`output_index`). When absent, the delta is
+   * appended to the most-recently-seen ToolCall (single-tool-call fallback).
+   */
+  index?: number | string;
+}
+/**
+ * A single chunk yielded by {@link StreamedMessage}'s async iterator.
+ *
+ * During streaming, the generate loop receives a sequence of these parts and
+ * merges compatible consecutive parts (e.g. TextPart + TextPart) in-place so
+ * the final {@link Message} contains fully-assembled content.
+ *
+ * Tool-call completion is inferred from merge boundaries (a non-merging next
+ * part flushes the pending tool call) and from stream end. Provider adapters
+ * are responsible for translating their native "done" signals into this
+ * shape; they do not emit a separate done event.
+ */
+type StreamedMessagePart = ContentPart | ToolCall | ToolCallPart;
+/**
+ * A single message in a conversation.
+ *
+ * Messages carry a {@link role} (system, user, assistant, or tool), an array
+ * of {@link ContentPart} content blocks, and optional {@link ToolCall} entries.
+ * Tool result messages set {@link toolCallId} to correlate with the originating
+ * call.
+ */
+interface Message {
+  /** The role of the message sender. */
+  role: Role;
+  /** Optional display name for the sender (used by some providers). */
+  name?: string;
+  /** Ordered content parts (text, images, thinking, etc.). */
+  content: ContentPart[];
+  /** Tool calls requested by the assistant in this message. */
+  toolCalls: ToolCall[];
+  /** For `tool` role messages, the ID of the tool call this result answers. */
+  toolCallId?: string;
+  /** When `true`, indicates the message was not fully received (e.g. stream interrupted). */
+  partial?: boolean;
+}
+/** Check if a streamed part is a ContentPart (text, think, image_url, audio_url, video_url). */
+declare function isContentPart(part: StreamedMessagePart): part is ContentPart;
+/** Check if a streamed part is a ToolCall. */
+declare function isToolCall(part: StreamedMessagePart): part is ToolCall;
+/** Check if a streamed part is a ToolCallPart (streaming argument delta). */
+declare function isToolCallPart(part: StreamedMessagePart): part is ToolCallPart;
+/**
+ * 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.
+ */
+declare function mergeInPlace(target: StreamedMessagePart, source: StreamedMessagePart): boolean;
+/**
+ * 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.
+ */
+declare function extractText(message: Message, sep?: string): string;
+/** Create a simple user message with a single text part. */
+declare function createUserMessage(content: string): Message;
+/** Create an assistant message from content parts and optional tool calls. */
+declare function createAssistantMessage(content: ContentPart[], toolCalls?: ToolCall[]): Message;
+/** Create a tool result message. */
+declare function createToolMessage(toolCallId: string, output: string | ContentPart[]): Message;
+//#endregion
+//#region src/capability.d.ts
+/**
+ * Declared capabilities for a specific model exposed by a {@link ChatProvider}.
+ *
+ * Providers return one of these from {@link ChatProvider.getCapability} so
+ * callers can gate requests against modalities the model does not accept
+ * without dispatching the request and watching it fail upstream.
+ *
+ * `max_context_tokens: 0` means "unknown"; callers that do not gate on
+ * context length can ignore the field.
+ */
+interface ModelCapability {
+  readonly image_in: boolean;
+  readonly video_in: boolean;
+  readonly audio_in: boolean;
+  readonly thinking: boolean;
+  readonly tool_use: boolean;
+  readonly max_context_tokens: number;
+}
+/**
+ * Shared read-only default returned when a provider has not catalogued a
+ * given model. Frozen so accidental mutation at one call site cannot leak
+ * into another.
+ */
+declare const UNKNOWN_CAPABILITY: ModelCapability;
+declare function isUnknownCapability(capability: ModelCapability): boolean;
+//#endregion
+//#region src/tool.d.ts
+/**
+ * A tool that the model may invoke during generation.
+ *
+ * The definition is provider-agnostic; each provider implementation converts
+ * it to the appropriate wire format (e.g. OpenAI function-calling, Anthropic
+ * tool-use, Google function declarations).
+ */
+interface Tool {
+  /** Unique tool name used to match invocations. */
+  name: string;
+  /** Human-readable description shown to the model. */
+  description: string;
+  /** JSON Schema describing the tool's parameters. */
+  parameters: Record<string, unknown>;
+}
+//#endregion
+//#region src/usage.d.ts
+/**
+ * Token usage breakdown for a single LLM generation.
+ *
+ * Providers map their native usage counters into this common shape so
+ * callers can aggregate costs without caring about the backend.
+ */
+interface TokenUsage {
+  /** Input tokens that were neither cache-read nor cache-created. */
+  inputOther: number;
+  /** Output (completion) tokens generated by the model. */
+  output: number;
+  /** Input tokens served from the provider's prompt cache. */
+  inputCacheRead: number;
+  /** Input tokens written into the provider's prompt cache. */
+  inputCacheCreation: number;
+}
+/**
+ * Compute total input tokens (other + cache read + cache creation).
+ */
+declare function inputTotal(usage: TokenUsage): number;
+/**
+ * Compute grand total tokens (input total + output).
+ */
+declare function grandTotal(usage: TokenUsage): number;
+/**
+ * Create a zero-valued TokenUsage.
+ */
+declare function emptyUsage(): TokenUsage;
+/**
+ * Sum two TokenUsage values.
+ */
+declare function addUsage(a: TokenUsage, b: TokenUsage): TokenUsage;
+//#endregion
+//#region src/provider.d.ts
+/**
+ * Normalized thinking effort level used across providers.
+ *
+ * Values above `high` are provider/model-specific and may be clamped by the
+ * adapter when the native API has no matching level. OpenAI maps `max` to its
+ * `xhigh` ceiling; Byf and Gemini cap `xhigh`/`max` at `high`; Anthropic
+ * supports `xhigh`/`max` only on selected models and otherwise clamps to
+ * `high`.
+ */
+type ThinkingEffort = 'off' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/**
+ * Normalized finish-reason signal indicating why a generation stopped.
+ *
+ * Each provider's native stop value is mapped to one of these, and the
+ * unmapped original string is preserved in `rawFinishReason` as an escape
+ * hatch. `null` means the provider did not emit a finish_reason (e.g. the
+ * stream was cut off before the final event).
+ *
+ * - `'completed'`: normal completion (OpenAI `'stop'`, Anthropic
+ *   `'end_turn'` / `'stop_sequence'`, Gemini `'STOP'`).
+ * - `'tool_calls'`: generation paused so the caller can dispatch tool
+ *   calls and feed their results back. Note that the OpenAI Responses API
+ *   and Google GenAI report `'completed'` here; only the Chat
+ *   Completions–style providers and Anthropic surface a dedicated value.
+ * - `'truncated'`: token budget exhausted (OpenAI `'length'`, Anthropic
+ *   `'max_tokens'`, Gemini `'MAX_TOKENS'`, Responses `'max_output_tokens'`).
+ * - `'filtered'`: content filter or safety policy blocked the response.
+ * - `'paused'`: Anthropic-specific `'pause_turn'`.
+ * - `'other'`: recognized non-null reason that does not fit the categories
+ *   above.
+ */
+type FinishReason = 'completed' | 'tool_calls' | 'truncated' | 'filtered' | 'paused' | 'other';
+/**
+ * An async-iterable stream of message parts produced by a single LLM response.
+ *
+ * Consumers iterate over the stream with `for await..of` to receive
+ * {@link StreamedMessagePart} chunks. After the iteration completes, the
+ * {@link id}, {@link usage}, {@link finishReason}, and
+ * {@link rawFinishReason} properties reflect the final values reported by
+ * the provider.
+ */
+interface StreamedMessage {
+  [Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart>;
+  /** Provider-assigned response identifier, or `null` if not available. */
+  readonly id: string | null;
+  /** Token usage statistics, populated after the stream completes. */
+  readonly usage: TokenUsage | null;
+  /**
+   * Normalized finish reason, populated after the stream completes.
+   *
+   * `null` if the provider did not emit a finish_reason (for example, the
+   * stream was interrupted before the final event arrived).
+   */
+  readonly finishReason: FinishReason | null;
+  /**
+   * Raw provider-specific finish_reason string, preserved verbatim as an
+   * escape hatch for callers that need the original wire value.
+   *
+   * `null` if the provider did not emit a finish_reason.
+   */
+  readonly rawFinishReason: string | null;
+}
+/**
+ * Options that can be forwarded to a single {@link ChatProvider.generate} call.
+ */
+interface ProviderRequestAuth {
+  /** Bearer/API token resolved for this specific provider request. */
+  apiKey?: string;
+  /** Request-scoped headers. These override constructor-level default headers. */
+  headers?: Record<string, string>;
+}
+interface GenerateOptions {
+  /**
+   * An {@link AbortSignal} that, when aborted, requests cancellation of the
+   * in-flight generate call. Providers that accept a signal will forward it
+   * to their underlying HTTP client; the generate loop in
+   * {@link generate | generate()} also checks the signal between streamed
+   * parts.
+   */
+  signal?: AbortSignal;
+  /**
+   * Request-scoped provider auth. Hosts should resolve this immediately before
+   * each request/retry so providers never retain mutable credential state.
+   */
+  auth?: ProviderRequestAuth;
+}
+/**
+ * In-memory video bytes for providers that require an uploaded file
+ * reference instead of an inline data URL.
+ */
+interface VideoUploadInput {
+  readonly data: Uint8Array;
+  readonly mimeType: string;
+  readonly filename?: string | undefined;
+}
+/**
+ * Unified interface for an LLM chat provider.
+ *
+ * Each provider implementation (Byf, OpenAI, Anthropic, Google GenAI, etc.)
+ * converts the common {@link Message} / {@link Tool} types into the
+ * provider-specific wire format, streams back a {@link StreamedMessage}, and
+ * exposes configuration helpers such as {@link withThinking}.
+ */
+interface ChatProvider {
+  /** Short identifier for the provider backend (e.g. `"byf"`, `"anthropic"`). */
+  readonly name: string;
+  /** Model name passed to the upstream API (e.g. `"byf-v1-auto"`). */
+  readonly modelName: string;
+  /** Current thinking-effort level, or `null` if thinking is not configured. */
+  readonly thinkingEffort: ThinkingEffort | null;
+  /**
+   * Send a conversation to the LLM and return a streamed response.
+   *
+   * @param systemPrompt - System-level instruction prepended to the request.
+   * @param tools - Tool definitions the model may invoke.
+   * @param history - The conversation history (user, assistant, tool messages).
+   * @param options - Optional per-call settings such as an {@link AbortSignal}.
+   */
+  generate(systemPrompt: string, tools: Tool[], history: Message[], options?: GenerateOptions): Promise<StreamedMessage>;
+  /** Return a shallow copy of this provider with the given thinking effort. */
+  withThinking(effort: ThinkingEffort): ChatProvider;
+  /**
+   * Return a shallow copy of this provider with the per-request completion
+   * budget clamped to `maxCompletionTokens`. Optional because not every
+   * backend benefits from a client-computed cap.
+   *
+   * Implementations MUST NOT mutate or replace internal HTTP clients on the
+   * returned clone — the clone is expected to share transport state with the
+   * original. See `OpenAICompatChatProvider._clone()` for the rationale.
+   */
+  withMaxCompletionTokens?(maxCompletionTokens: number): ChatProvider;
+  /** Upload a video and return a content part that can be sent to this provider. */
+  uploadVideo?(input: string | VideoUploadInput, options?: GenerateOptions): Promise<VideoURLPart>;
+  /**
+   * Return declared capabilities for `model` (defaults to `modelName`).
+   *
+   * Unknown / uncatalogued models return {@link UNKNOWN_CAPABILITY} rather
+   * than throwing, so capability checks stay non-fatal and operators can
+   * point at private/custom deployments without crashing.
+   *
+   * Optional on the interface so pre-existing test mocks (which predate
+   * the capability matrix) still structurally satisfy `ChatProvider`
+   * without churn. Callers that gate on modalities should fall back to
+   * {@link UNKNOWN_CAPABILITY} when a provider does not expose it.
+   */
+  getCapability?(model?: string): ModelCapability;
+  getContextSizeLimit?(): number | undefined;
+}
+//#endregion
+export { createUserMessage as A, TextPart as C, VideoURLPart as D, ToolCallPart as E, mergeInPlace as F, isContentPart as M, isToolCall as N, createAssistantMessage as O, isToolCallPart as P, StreamedMessagePart as S, ToolCall as T, AudioURLPart as _, StreamedMessage as a, Message as b, TokenUsage as c, grandTotal as d, inputTotal as f, isUnknownCapability as g, UNKNOWN_CAPABILITY as h, ProviderRequestAuth as i, extractText as j, createToolMessage as k, addUsage as l, ModelCapability as m, FinishReason as n, ThinkingEffort as o, Tool as p, GenerateOptions as r, VideoUploadInput as s, ChatProvider as t, emptyUsage as u, ContentPart as v, ThinkPart as w, Role as x, ImageURLPart as y };

package/dist/providers/anthropic.d.mts

@@ -0,0 +1,2 @@
+import { i as resolveDefaultMaxTokens, n as AnthropicOptions, r as convertAnthropicError, t as AnthropicChatProvider } from "../anthropic-Dm_GqFgS.mjs";
+export { AnthropicChatProvider, AnthropicOptions, convertAnthropicError, resolveDefaultMaxTokens };