@byfriends/kosong 0.1.0

package/LICENSE

@@ -0,0 +1,28 @@
+BYF PROPRIETARY LICENSE
+
+Copyright (c) 2026-2027 ByronFinn
+
+Permission is hereby granted to copy and redistribute this software in its
+unmodified form, without charge. This permission does not extend to modified
+versions of the software.
+
+Local modification of this software for personal use is permitted, provided
+that such modifications are not distributed to third parties.
+
+Restrictions:
+1. You may NOT redistribute modified versions of this software.
+2. You may NOT use this software for commercial purposes.
+3. You may NOT sublicense, sell, or offer this software as a service.
+
+This software is source-available but NOT open source. The source code is
+made publicly visible for review purposes only.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For questions about licensing, contact: https://github.com/ByronFinn/byf/issues

package/README.md

@@ -0,0 +1,11 @@
+# @byfriends/kosong
+
+LLM abstraction layer used by BYF.
+
+Part of the [BYF](https://github.com/ByronFinn/byf) monorepo.
+
+See the main repository for documentation, issues, and contribution guidelines.
+
+## License
+
+Proprietary — see the root LICENSE file.

package/dist/anthropic-Dm_GqFgS.d.mts

@@ -0,0 +1,69 @@
+import { a as StreamedMessage, b as Message, i as ProviderRequestAuth, m as ModelCapability, o as ThinkingEffort, p as Tool, r as GenerateOptions, t as ChatProvider } from "./provider-DiJKWMsQ.mjs";
+import { o as ChatProviderError } from "./errors-DweKbIOf.mjs";
+import Anthropic from "@anthropic-ai/sdk";
+import { MessageCreateParams } from "@anthropic-ai/sdk/resources/messages/messages.js";
+
+//#region src/providers/anthropic.d.ts
+interface AnthropicOptions {
+  apiKey?: string | undefined;
+  baseUrl?: string | undefined;
+  model: string;
+  defaultMaxTokens?: number | undefined;
+  betaFeatures?: string[] | undefined;
+  defaultHeaders?: Record<string, string>;
+  metadata?: Record<string, string> | undefined;
+  /** Use streaming API. Defaults to true. Set to false for non-streaming (test/fallback). */
+  stream?: boolean | undefined;
+  clientFactory?: (auth: ProviderRequestAuth) => Anthropic;
+}
+interface AnthropicGenerationKwargs {
+  max_tokens?: number | undefined;
+  temperature?: number | undefined;
+  top_k?: number | undefined;
+  top_p?: number | undefined;
+  thinking?: MessageCreateParams['thinking'] | undefined;
+  output_config?: MessageCreateParams['output_config'] | undefined;
+  betaFeatures?: string[] | undefined;
+}
+/**
+ * Resolve the default `max_tokens` for an Anthropic request.
+ *
+ * Precedence:
+ *   1. Caller-provided `override` (e.g. `models.<alias>.maxOutputSize`
+ *      from the harness config) — honored when present so users can
+ *      intentionally lower the budget (handy for forcing truncation
+ *      in tests) or raise it on a model we don't yet know about.
+ *   2. When the model id parses to a known Claude family + version,
+ *      the override is clamped to the documented Messages-API ceiling
+ *      so we never send a value the server would reject.
+ *   3. With no override and no recognized version, fall back to
+ *      {@link FALLBACK_MAX_TOKENS}.
+ */
+declare function resolveDefaultMaxTokens(model: string, override?: number): number;
+declare function convertAnthropicError(error: unknown): ChatProviderError;
+declare class AnthropicChatProvider implements ChatProvider {
+  readonly name: string;
+  private _model;
+  private _stream;
+  private _client;
+  private _generationKwargs;
+  private _metadata;
+  private _apiKey;
+  private _baseUrl;
+  private _defaultHeaders;
+  private _clientFactory;
+  constructor(options: AnthropicOptions);
+  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>;
+  private _createClient;
+  private _buildClient;
+  withThinking(effort: ThinkingEffort): AnthropicChatProvider;
+  withGenerationKwargs(kwargs: Partial<AnthropicGenerationKwargs>): AnthropicChatProvider;
+  private _withGenerationKwargs;
+  private _clone;
+}
+//#endregion
+export { resolveDefaultMaxTokens as i, AnthropicOptions as n, convertAnthropicError as r, AnthropicChatProvider as t };

package/dist/capability-registry-CMBuEYcf.mjs

@@ -0,0 +1,161 @@
+import { i as UNKNOWN_CAPABILITY } from "./request-auth-DCWSyCKI.mjs";
+//#region src/providers/capability-registry.ts
+const OPENAI_RESPONSES_DEVELOPER_ROLE_MODELS = new Set([
+	"gpt-4.1",
+	"gpt-4.1-mini",
+	"gpt-4.1-nano",
+	"gpt-5-codex",
+	"o1",
+	"o1-mini",
+	"o1-pro",
+	"o3",
+	"o3-mini",
+	"o3-pro",
+	"o4-mini"
+]);
+const OPENAI_VISION_TOOL_PREFIXES = [
+	"gpt-4o",
+	"gpt-4-turbo",
+	"gpt-4.1",
+	"gpt-4.5"
+];
+const CLAUDE_3_PREFIXES = [
+	"claude-3-",
+	"claude-3.5-",
+	"claude-3.7-"
+];
+const CLAUDE_4_PREFIXES = [
+	"claude-opus-4",
+	"claude-sonnet-4",
+	"claude-haiku-4"
+];
+const GEMINI_CATALOGUED_PREFIXES = [
+	"gemini-1.5-pro",
+	"gemini-1.5-flash",
+	"gemini-2.0-flash",
+	"gemini-2.0-pro",
+	"gemini-2.5-pro",
+	"gemini-2.5-flash"
+];
+const OPENAI_REASONING_CAPABILITY = Object.freeze({
+	image_in: false,
+	video_in: false,
+	audio_in: false,
+	thinking: true,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const OPENAI_VISION_TOOL_CAPABILITY = Object.freeze({
+	image_in: true,
+	video_in: false,
+	audio_in: false,
+	thinking: false,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const OPENAI_TEXT_TOOL_CAPABILITY = Object.freeze({
+	image_in: false,
+	video_in: false,
+	audio_in: false,
+	thinking: false,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const ANTHROPIC_VISION_TOOL_CAPABILITY = Object.freeze({
+	image_in: true,
+	video_in: false,
+	audio_in: false,
+	thinking: false,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const ANTHROPIC_THINKING_VISION_TOOL_CAPABILITY = Object.freeze({
+	image_in: true,
+	video_in: false,
+	audio_in: false,
+	thinking: true,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const GEMINI_MULTIMODAL_TOOL_CAPABILITY = Object.freeze({
+	image_in: true,
+	video_in: true,
+	audio_in: true,
+	thinking: false,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const GEMINI_THINKING_MULTIMODAL_TOOL_CAPABILITY = Object.freeze({
+	image_in: true,
+	video_in: true,
+	audio_in: true,
+	thinking: true,
+	tool_use: true,
+	max_context_tokens: 0
+});
+const OPENAI_LEGACY_CAPABILITY_CATALOG = [
+	{
+		matches: isOpenAIReasoningModel,
+		capability: OPENAI_REASONING_CAPABILITY
+	},
+	{
+		matches: (name) => hasPrefix(name, OPENAI_VISION_TOOL_PREFIXES),
+		capability: OPENAI_VISION_TOOL_CAPABILITY
+	},
+	{
+		matches: (name) => name.startsWith("gpt-3.5-turbo"),
+		capability: OPENAI_TEXT_TOOL_CAPABILITY
+	}
+];
+const OPENAI_RESPONSES_CAPABILITY_CATALOG = [{
+	matches: isOpenAIReasoningModel,
+	capability: OPENAI_REASONING_CAPABILITY
+}, {
+	matches: (name) => hasPrefix(name, OPENAI_VISION_TOOL_PREFIXES),
+	capability: OPENAI_VISION_TOOL_CAPABILITY
+}];
+const ANTHROPIC_CAPABILITY_CATALOG = [{
+	matches: (name) => hasPrefix(name, CLAUDE_3_PREFIXES),
+	capability: ANTHROPIC_VISION_TOOL_CAPABILITY
+}, {
+	matches: (name) => hasPrefix(name, CLAUDE_4_PREFIXES),
+	capability: ANTHROPIC_THINKING_VISION_TOOL_CAPABILITY
+}];
+function normalizeModelName(modelName) {
+	return modelName.toLowerCase();
+}
+function hasPrefix(modelName, prefixes) {
+	return prefixes.some((prefix) => modelName.startsWith(prefix));
+}
+function isOpenAIReasoningModel(modelName) {
+	return /^o\d/.test(modelName);
+}
+function capabilityFromCatalog(modelName, catalog) {
+	const normalized = normalizeModelName(modelName);
+	for (const entry of catalog) if (entry.matches(normalized)) return entry.capability;
+	return UNKNOWN_CAPABILITY;
+}
+function getOpenAILegacyModelCapability(modelName) {
+	return capabilityFromCatalog(modelName, OPENAI_LEGACY_CAPABILITY_CATALOG);
+}
+function getOpenAIResponsesModelCapability(modelName) {
+	return capabilityFromCatalog(modelName, OPENAI_RESPONSES_CAPABILITY_CATALOG);
+}
+function getAnthropicModelCapability(modelName) {
+	return capabilityFromCatalog(modelName, ANTHROPIC_CAPABILITY_CATALOG);
+}
+function getGoogleGenAIModelCapability(modelName) {
+	const normalized = normalizeModelName(modelName);
+	if (!normalized.startsWith("gemini-")) return UNKNOWN_CAPABILITY;
+	if (!hasPrefix(normalized, GEMINI_CATALOGUED_PREFIXES)) return UNKNOWN_CAPABILITY;
+	if (normalized.startsWith("gemini-2.5-") || normalized.includes("thinking")) return GEMINI_THINKING_MULTIMODAL_TOOL_CAPABILITY;
+	return GEMINI_MULTIMODAL_TOOL_CAPABILITY;
+}
+function usesOpenAIResponsesDeveloperRole(modelName) {
+	const normalized = normalizeModelName(modelName);
+	if (OPENAI_RESPONSES_DEVELOPER_ROLE_MODELS.has(normalized)) return true;
+	for (const cataloguedModel of OPENAI_RESPONSES_DEVELOPER_ROLE_MODELS) if (normalized.startsWith(cataloguedModel + "-")) return true;
+	return false;
+}
+//#endregion
+export { usesOpenAIResponsesDeveloperRole as a, getOpenAIResponsesModelCapability as i, getGoogleGenAIModelCapability as n, getOpenAILegacyModelCapability as r, getAnthropicModelCapability as t };

package/dist/chat-completions-stream-BuMu_xr9.mjs

@@ -0,0 +1,62 @@
+//#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
+export { convertChatCompletionStreamToolCall as t };

package/dist/errors-DweKbIOf.d.mts

@@ -0,0 +1,42 @@
+//#region src/errors.d.ts
+/**
+ * Base error for all chat provider errors.
+ */
+declare class ChatProviderError extends Error {
+  constructor(message: string);
+}
+/**
+ * Network-level connection failure.
+ */
+declare class APIConnectionError extends ChatProviderError {
+  constructor(message: string);
+}
+/**
+ * Request timed out.
+ */
+declare class APITimeoutError extends ChatProviderError {
+  constructor(message: string);
+}
+/**
+ * HTTP status error from the API.
+ */
+declare class APIStatusError extends ChatProviderError {
+  readonly statusCode: number;
+  readonly requestId: string | null;
+  constructor(statusCode: number, message: string, requestId?: string | null);
+}
+/**
+ * HTTP status error that specifically means the request exceeded the model
+ * context window.
+ */
+declare class APIContextOverflowError extends APIStatusError {
+  constructor(statusCode: number, message: string, requestId?: string | null);
+}
+/**
+ * The API returned an empty response (no content, no tool calls).
+ */
+declare class APIEmptyResponseError extends ChatProviderError {
+  constructor(message: string);
+}
+//#endregion
+export { APITimeoutError as a, APIStatusError as i, APIContextOverflowError as n, ChatProviderError as o, APIEmptyResponseError as r, APIConnectionError as t };

package/dist/errors-WFxxzL1B.mjs

@@ -0,0 +1,80 @@
+//#region src/errors.ts
+/**
+* Base error for all chat provider errors.
+*/
+var ChatProviderError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ChatProviderError";
+	}
+};
+/**
+* Network-level connection failure.
+*/
+var APIConnectionError = class extends ChatProviderError {
+	constructor(message) {
+		super(message);
+		this.name = "APIConnectionError";
+	}
+};
+/**
+* Request timed out.
+*/
+var APITimeoutError = class extends ChatProviderError {
+	constructor(message) {
+		super(message);
+		this.name = "APITimeoutError";
+	}
+};
+/**
+* HTTP status error from the API.
+*/
+var APIStatusError = class extends ChatProviderError {
+	statusCode;
+	requestId;
+	constructor(statusCode, message, requestId) {
+		super(message);
+		this.name = "APIStatusError";
+		this.statusCode = statusCode;
+		this.requestId = requestId ?? null;
+	}
+};
+/**
+* HTTP status error that specifically means the request exceeded the model
+* context window.
+*/
+var APIContextOverflowError = class extends APIStatusError {
+	constructor(statusCode, message, requestId) {
+		super(statusCode, message, requestId);
+		this.name = "APIContextOverflowError";
+	}
+};
+/**
+* The API returned an empty response (no content, no tool calls).
+*/
+var APIEmptyResponseError = class extends ChatProviderError {
+	constructor(message) {
+		super(message);
+		this.name = "APIEmptyResponseError";
+	}
+};
+const CONTEXT_OVERFLOW_MESSAGE_PATTERNS = [
+	/context[ _-]?length/,
+	/(?:context[ _-]?window.*exceed|exceed.*context[ _-]?window)/,
+	/maximum context/,
+	/exceed(?:ed|s|ing)?\s+(?:the\s+)?max(?:imum)?\s+tokens?/,
+	/(?:too many tokens.*(?:prompt|input|context)|(?:prompt|input|context).*too many tokens)/,
+	/prompt is too long.*maximum/,
+	/input token count.*exceeds?.*maximum number of tokens/
+];
+function normalizeAPIStatusError(statusCode, message, requestId) {
+	if (isContextOverflowStatusError(statusCode, message)) return new APIContextOverflowError(statusCode, message, requestId);
+	return new APIStatusError(statusCode, message, requestId);
+}
+function isContextOverflowStatusError(statusCode, message) {
+	if (statusCode !== 400 && statusCode !== 413 && statusCode !== 422) return false;
+	const lowerMessage = message.toLowerCase();
+	return CONTEXT_OVERFLOW_MESSAGE_PATTERNS.some((pattern) => pattern.test(lowerMessage));
+}
+//#endregion
+export { APITimeoutError as a, APIStatusError as i, APIContextOverflowError as n, ChatProviderError as o, APIEmptyResponseError as r, normalizeAPIStatusError as s, APIConnectionError as t };

package/dist/google-genai-hX0X6CF3.d.mts

@@ -0,0 +1,98 @@
+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 { o as ChatProviderError } from "./errors-DweKbIOf.mjs";
+import { GoogleGenAI } from "@google/genai";
+
+//#region src/providers/google-genai.d.ts
+interface GoogleGenAIOptions {
+  apiKey?: string | undefined;
+  model: string;
+  vertexai?: boolean | undefined;
+  project?: string | undefined;
+  location?: string | undefined;
+  stream?: boolean | undefined;
+  clientFactory?: (auth: ProviderRequestAuth) => GoogleGenAI;
+}
+interface GoogleGenAIGenerationKwargs {
+  max_output_tokens?: number | undefined;
+  temperature?: number | undefined;
+  top_k?: number | undefined;
+  top_p?: number | undefined;
+  thinking_config?: ThinkingConfig | undefined;
+  [key: string]: unknown;
+}
+interface ThinkingConfig {
+  include_thoughts?: boolean;
+  thinking_budget?: number;
+  thinking_level?: string;
+}
+interface GoogleContent {
+  role: string;
+  parts: GooglePart[];
+}
+interface GooglePart {
+  text?: string;
+  function_call?: {
+    name: string;
+    args: Record<string, unknown>;
+  };
+  function_response?: {
+    name: string;
+    response: Record<string, string>;
+    parts: unknown[];
+  };
+  thought_signature?: string;
+  [key: string]: unknown;
+}
+declare function messagesToGoogleGenAIContents(messages: Message[]): GoogleContent[];
+declare class GoogleGenAIStreamedMessage implements StreamedMessage {
+  private _id;
+  private _usage;
+  private _finishReason;
+  private _rawFinishReason;
+  private readonly _iter;
+  constructor(response: AsyncIterable<Record<string, unknown>> | Record<string, unknown>, isStream: boolean, signal?: AbortSignal);
+  get id(): string | null;
+  get usage(): TokenUsage | null;
+  get finishReason(): FinishReason | null;
+  get rawFinishReason(): string | null;
+  [Symbol.asyncIterator](): AsyncIterator<StreamedMessagePart>;
+  private _captureFinishReason;
+  /** Yield parts from a single (non-streamed) GenerateContentResponse. */
+  private _extractChunkParts;
+  /** Extract usage metadata from a response chunk. */
+  private _extractUsage;
+  /** Extract response ID from a response chunk. */
+  private _extractId;
+  private _throwIfAborted;
+  private _convertNonStreamResponse;
+  private _convertStreamResponse;
+}
+/**
+ * Convert a Google GenAI SDK error (or raw Error) to a kosong `ChatProviderError`.
+ */
+declare function convertGoogleGenAIError(error: unknown): ChatProviderError;
+declare class GoogleGenAIChatProvider implements ChatProvider {
+  readonly name: string;
+  private _model;
+  private _client;
+  private _generationKwargs;
+  private _vertexai;
+  private _stream;
+  private _apiKey;
+  private _project;
+  private _location;
+  private _clientFactory;
+  constructor(options: GoogleGenAIOptions);
+  private _buildClient;
+  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>;
+  private _createClient;
+  withThinking(effort: ThinkingEffort): GoogleGenAIChatProvider;
+  withGenerationKwargs(kwargs: GoogleGenAIGenerationKwargs): GoogleGenAIChatProvider;
+  private _clone;
+}
+//#endregion
+export { convertGoogleGenAIError as a, GoogleGenAIStreamedMessage as i, GoogleGenAIGenerationKwargs as n, messagesToGoogleGenAIContents as o, GoogleGenAIOptions as r, GoogleGenAIChatProvider as t };