@byfriends/kosong 0.1.0

package/dist/providers/openai-legacy.mjs

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

@@ -0,0 +1,2 @@
+import { i as OpenAIResponsesStreamedMessage, n as OpenAIResponsesGenerationKwargs, r as OpenAIResponsesOptions, t as OpenAIResponsesChatProvider } from "../openai-responses-BxOwxtd3.mjs";
+export { OpenAIResponsesChatProvider, OpenAIResponsesGenerationKwargs, OpenAIResponsesOptions, OpenAIResponsesStreamedMessage };