@byfriends/kosong 0.1.0 → 0.2.0

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

@@ -1,71 +0,0 @@
-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/providers/openai-compat.d.mts

@@ -1,2 +0,0 @@
-import { a as ThinkingConfig, i as OpenAICompatOptions, n as GenerationKwargs, o as extractUsageFromChunk, r as OpenAICompatChatProvider, t as ExtraBody } from "../openai-compat-CMrIk-ib.mjs";
-export { ExtraBody, GenerationKwargs, OpenAICompatChatProvider, OpenAICompatOptions, ThinkingConfig, extractUsageFromChunk };

package/dist/providers/openai-compat.mjs

@@ -1,2 +0,0 @@
-import { n as extractUsageFromChunk, t as OpenAICompatChatProvider } from "../openai-compat-CWbwO4b7.mjs";
-export { OpenAICompatChatProvider, extractUsageFromChunk };

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

@@ -1,2 +0,0 @@
-import { i as OpenAILegacyStreamedMessage, n as OpenAILegacyGenerationKwargs, r as OpenAILegacyOptions, t as OpenAILegacyChatProvider } from "../openai-legacy-B6CVfLlr.mjs";
-export { OpenAILegacyChatProvider, OpenAILegacyGenerationKwargs, OpenAILegacyOptions, OpenAILegacyStreamedMessage };

package/dist/providers/openai-legacy.mjs

@@ -1,248 +0,0 @@
-import { a as isFunctionToolCall, c as thinkingEffortToReasoningEffort, i as extractUsage, l as toolToOpenAI, n as convertOpenAIError, o as normalizeOpenAIFinishReason, r as convertToolMessageContent, s as reasoningEffortToThinkingEffort, t as convertContentPart } from "../openai-common-08qin3UI.mjs";
-import { n as requireProviderApiKey, r as resolveAuthBackedClient, t as mergeRequestHeaders } from "../request-auth-DCWSyCKI.mjs";
-import { r as getOpenAILegacyModelCapability } from "../capability-registry-CMBuEYcf.mjs";
-import { t as convertChatCompletionStreamToolCall } from "../chat-completions-stream-BuMu_xr9.mjs";
-import OpenAI from "openai";
-//#region src/providers/openai-legacy.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 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 };
-	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 {
-			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 {
-		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 (message.toolCalls.length > 0) result.tool_calls = message.toolCalls.map((tc) => ({
-		type: tc.type,
-		id: tc.id,
-		function: {
-			name: tc.name,
-			arguments: tc.arguments
-		}
-	}));
-	if (message.toolCallId !== void 0) result.tool_call_id = message.toolCallId;
-	if (reasoningContent) result[reasoningKey ?? DEFAULT_OUTBOUND_REASONING_KEY] = reasoningContent;
-	return result;
-}
-var OpenAILegacyStreamedMessage = 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;
-				if (chunk.usage) this._usage = extractUsage(chunk.usage) ?? 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 OpenAILegacyChatProvider = class {
-	name = "openai";
-	_model;
-	_stream;
-	_apiKey;
-	_baseUrl;
-	_defaultHeaders;
-	_reasoningKey;
-	_reasoningEffort;
-	_generationKwargs;
-	_toolMessageConversion;
-	_client;
-	_httpClient;
-	_clientFactory;
-	constructor(options) {
-		const apiKey = options.apiKey ?? process.env["OPENAI_API_KEY"];
-		this._apiKey = apiKey === void 0 || apiKey.length === 0 ? void 0 : apiKey;
-		this._baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
-		this._defaultHeaders = options.defaultHeaders;
-		this._model = options.model;
-		this._stream = options.stream ?? true;
-		const normalizedReasoningKey = options.reasoningKey?.trim();
-		this._reasoningKey = normalizedReasoningKey !== void 0 && normalizedReasoningKey.length > 0 ? normalizedReasoningKey : void 0;
-		this._reasoningEffort = void 0;
-		this._generationKwargs = {};
-		if (options.maxTokens !== void 0) this._generationKwargs.max_tokens = options.maxTokens;
-		this._toolMessageConversion = options.toolMessageConversion ?? null;
-		this._httpClient = options.httpClient;
-		this._clientFactory = options.clientFactory;
-		this._client = this._apiKey === void 0 ? void 0 : this._buildClient(this._apiKey);
-	}
-	get modelName() {
-		return this._model;
-	}
-	get thinkingEffort() {
-		return reasoningEffortToThinkingEffort(this._reasoningEffort);
-	}
-	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 };
-		let reasoningEffort = this._reasoningEffort;
-		if (reasoningEffort === void 0 && kwargs["reasoning_effort"] === void 0) {
-			if (history.some((message) => message.content.some((part) => part.type === "think"))) reasoningEffort = "medium";
-		}
-		for (const key of Object.keys(kwargs)) if (kwargs[key] === void 0) delete kwargs[key];
-		const createParams = {
-			model: this._model,
-			messages,
-			stream: this._stream,
-			...kwargs
-		};
-		if (tools.length > 0) createParams["tools"] = tools.map((t) => toolToOpenAI(t));
-		if (this._stream) createParams["stream_options"] = { include_usage: true };
-		if (reasoningEffort !== void 0) createParams["reasoning_effort"] = reasoningEffort;
-		try {
-			return new OpenAILegacyStreamedMessage(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 reasoningEffort = thinkingEffortToReasoningEffort(effort);
-		const clone = this._clone();
-		clone._reasoningEffort = reasoningEffort;
-		return clone;
-	}
-	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 };
-		return clone;
-	}
-	_createClient(auth) {
-		return resolveAuthBackedClient({
-			cachedClient: this._client,
-			clientFactory: this._clientFactory
-		}, auth, (a) => this._buildClient(requireProviderApiKey("OpenAILegacyChatProvider", a, this._apiKey), a));
-	}
-	_buildClient(apiKey, auth) {
-		const clientOpts = {
-			apiKey,
-			baseURL: this._baseUrl
-		};
-		const defaultHeaders = mergeRequestHeaders(this._defaultHeaders, auth?.headers);
-		if (defaultHeaders !== void 0) clientOpts["defaultHeaders"] = defaultHeaders;
-		if (this._httpClient !== void 0) clientOpts["httpClient"] = this._httpClient;
-		return new OpenAI(clientOpts);
-	}
-};
-//#endregion
-export { OpenAILegacyChatProvider, OpenAILegacyStreamedMessage };

package/dist/request-auth-DCWSyCKI.mjs

@@ -1,63 +0,0 @@
-import { o as ChatProviderError } from "./errors-WFxxzL1B.mjs";
-//#region src/capability.ts
-const UNKNOWN_CAPABILITY_MARKER = Symbol.for("byf.kosong.UNKNOWN_CAPABILITY");
-/**
-* 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.
-*/
-const UNKNOWN_CAPABILITY = Object.freeze(Object.defineProperty({
-	image_in: false,
-	video_in: false,
-	audio_in: false,
-	thinking: false,
-	tool_use: false,
-	max_context_tokens: 0
-}, UNKNOWN_CAPABILITY_MARKER, { value: true }));
-function isUnknownCapability(capability) {
-	if (capability === UNKNOWN_CAPABILITY) return true;
-	if (capability[UNKNOWN_CAPABILITY_MARKER] === true) return true;
-	return !capability.image_in && !capability.video_in && !capability.audio_in && !capability.thinking && !capability.tool_use && capability.max_context_tokens === 0;
-}
-//#endregion
-//#region src/providers/request-auth.ts
-function requireProviderApiKey(providerName, auth, defaultApiKey) {
-	const apiKey = auth?.apiKey ?? defaultApiKey;
-	if (apiKey === void 0 || apiKey.length === 0) throw new ChatProviderError(`${providerName}: apiKey is required. Provide it via the constructor options, the provider's API-key environment variable, options.auth.apiKey on each request, or an OAuth login.`);
-	return apiKey;
-}
-function mergeRequestHeaders(defaultHeaders, requestHeaders) {
-	const merged = {};
-	if (defaultHeaders !== void 0) Object.assign(merged, defaultHeaders);
-	if (requestHeaders !== void 0) Object.assign(merged, requestHeaders);
-	return Object.keys(merged).length > 0 ? merged : void 0;
-}
-/**
-* Resolve the SDK client to use for a single provider request, applying the
-* standard precedence shared by every provider adapter:
-*
-* 1. If a `clientFactory` was supplied, delegate to it (it receives the
-*    per-request {@link ProviderRequestAuth}, defaulting to `{}`).
-* 2. Otherwise, if no per-request auth is needed AND a constructor-time
-*    client was cached, reuse the cached instance.
-* 3. Otherwise, call `build(auth)` to construct a fresh client for this
-*    request — typically using `requireProviderApiKey` plus
-*    `mergeRequestHeaders`.
-*
-* Note: when per-request `auth` is provided (e.g. an OAuth bearer token
-* resolved immediately before each call), step 3 fires and a brand-new SDK
-* client is constructed per request. This is intentional — it keeps short-lived
-* credentials out of any long-lived shared state and avoids racing concurrent
-* requests on a mutable client. The trade-off is that connection-pool / keep-
-* alive state inside the SDK client isn't reused across requests on the OAuth
-* path. For the current agent-CLI workload (one LLM call per turn step) this
-* is fine; if a future host needs high-throughput per-request auth, the
-* obvious optimization is a small LRU keyed on `(apiKey, headers digest)`.
-*/
-function resolveAuthBackedClient(state, auth, build) {
-	if (state.clientFactory !== void 0) return state.clientFactory(auth ?? {});
-	if (auth === void 0 && state.cachedClient !== void 0) return state.cachedClient;
-	return build(auth);
-}
-//#endregion
-export { isUnknownCapability as a, UNKNOWN_CAPABILITY as i, requireProviderApiKey as n, resolveAuthBackedClient as r, mergeRequestHeaders as t };