@vibe-lark/larkpal 0.1.86 → 0.1.87

package/dist/openai-responses-oGxwZyuC.mjs

@@ -1,184 +0,0 @@
-import { t as getEnvApiKey } from "./env-api-keys-BVvSg7T2.mjs";
-import { o as supportsXhigh, t as AssistantMessageEventStream } from "./event-stream-xaQWmyas.mjs";
-import { n as OpenAI } from "./openai-BDtIh3Ja.mjs";
-import { t as headersToRecord } from "./headers-R3HdCbAE.mjs";
-import { i as clampReasoning, r as buildBaseOptions } from "./transform-messages-DbhIzTxq.mjs";
-import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-DjqWtUoP.mjs";
-import { n as convertResponsesTools, r as processResponsesStream, t as convertResponsesMessages } from "./openai-responses-shared-BixMSDZE.mjs";
-//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/openai-responses.js
-const OPENAI_TOOL_CALL_PROVIDERS = new Set([
-	"openai",
-	"openai-codex",
-	"opencode"
-]);
-/**
-* Resolve cache retention preference.
-* Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
-*/
-function resolveCacheRetention(cacheRetention) {
-	if (cacheRetention) return cacheRetention;
-	if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") return "long";
-	return "short";
-}
-/**
-* Get prompt cache retention based on cacheRetention and base URL.
-* Only applies to direct OpenAI API calls (api.openai.com).
-*/
-function getPromptCacheRetention(baseUrl, cacheRetention) {
-	if (cacheRetention !== "long") return;
-	if (baseUrl.includes("api.openai.com")) return "24h";
-}
-/**
-* Generate function for OpenAI Responses API
-*/
-const streamOpenAIResponses = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const output = {
-			role: "assistant",
-			content: [],
-			api: model.api,
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: Date.now()
-		};
-		try {
-			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const cacheSessionId = resolveCacheRetention(options?.cacheRetention) === "none" ? void 0 : options?.sessionId;
-			const client = createClient(model, context, apiKey, options?.headers, cacheSessionId);
-			let params = buildParams(model, context, options);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== void 0) params = nextParams;
-			const { data: openaiStream, response } = await client.responses.create(params, options?.signal ? { signal: options.signal } : void 0).withResponse();
-			await options?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			await processResponsesStream(openaiStream, output, stream, model, {
-				serviceTier: options?.serviceTier,
-				applyServiceTierPricing
-			});
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
-			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			for (const block of output.content) {
-				delete block.index;
-				delete block.partialJson;
-			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		}
-	})();
-	return stream;
-};
-const streamSimpleOpenAIResponses = (model, context, options) => {
-	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const base = buildBaseOptions(model, options, apiKey);
-	const reasoningEffort = supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning);
-	return streamOpenAIResponses(model, context, {
-		...base,
-		reasoningEffort
-	});
-};
-function createClient(model, context, apiKey, optionsHeaders, sessionId) {
-	if (!apiKey) {
-		if (!process.env.OPENAI_API_KEY) throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-		apiKey = process.env.OPENAI_API_KEY;
-	}
-	const headers = { ...model.headers };
-	if (model.provider === "github-copilot") {
-		const hasImages = hasCopilotVisionInput(context.messages);
-		const copilotHeaders = buildCopilotDynamicHeaders({
-			messages: context.messages,
-			hasImages
-		});
-		Object.assign(headers, copilotHeaders);
-	}
-	if (sessionId) {
-		headers.session_id = sessionId;
-		headers["x-client-request-id"] = sessionId;
-	}
-	if (optionsHeaders) Object.assign(headers, optionsHeaders);
-	return new OpenAI({
-		apiKey,
-		baseURL: model.baseUrl,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: headers
-	});
-}
-function buildParams(model, context, options) {
-	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS);
-	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-	const params = {
-		model: model.id,
-		input: messages,
-		stream: true,
-		prompt_cache_key: cacheRetention === "none" ? void 0 : options?.sessionId,
-		prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),
-		store: false
-	};
-	if (options?.maxTokens) params.max_output_tokens = options?.maxTokens;
-	if (options?.temperature !== void 0) params.temperature = options?.temperature;
-	if (options?.serviceTier !== void 0) params.service_tier = options.serviceTier;
-	if (context.tools) params.tools = convertResponsesTools(context.tools);
-	if (model.reasoning) {
-		if (options?.reasoningEffort || options?.reasoningSummary) {
-			params.reasoning = {
-				effort: options?.reasoningEffort || "medium",
-				summary: options?.reasoningSummary || "auto"
-			};
-			params.include = ["reasoning.encrypted_content"];
-		} else if (model.provider !== "github-copilot") params.reasoning = { effort: "none" };
-	}
-	return params;
-}
-function getServiceTierCostMultiplier(serviceTier) {
-	switch (serviceTier) {
-		case "flex": return .5;
-		case "priority": return 2;
-		default: return 1;
-	}
-}
-function applyServiceTierPricing(usage, serviceTier) {
-	const multiplier = getServiceTierCostMultiplier(serviceTier);
-	if (multiplier === 1) return;
-	usage.cost.input *= multiplier;
-	usage.cost.output *= multiplier;
-	usage.cost.cacheRead *= multiplier;
-	usage.cost.cacheWrite *= multiplier;
-	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
-//#endregion
-export { streamOpenAIResponses, streamSimpleOpenAIResponses };

package/dist/openai-responses-shared-BixMSDZE.mjs

@@ -1,398 +0,0 @@
-import { r as calculateCost } from "./event-stream-xaQWmyas.mjs";
-import { n as parseStreamingJson } from "./json-parse-v_HIJjjI.mjs";
-import { a as sanitizeSurrogates, t as transformMessages } from "./transform-messages-DbhIzTxq.mjs";
-import { t as shortHash } from "./hash-DAFtW_W7.mjs";
-//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/openai-responses-shared.js
-function encodeTextSignatureV1(id, phase) {
-	const payload = {
-		v: 1,
-		id
-	};
-	if (phase) payload.phase = phase;
-	return JSON.stringify(payload);
-}
-function parseTextSignature(signature) {
-	if (!signature) return void 0;
-	if (signature.startsWith("{")) try {
-		const parsed = JSON.parse(signature);
-		if (parsed.v === 1 && typeof parsed.id === "string") {
-			if (parsed.phase === "commentary" || parsed.phase === "final_answer") return {
-				id: parsed.id,
-				phase: parsed.phase
-			};
-			return { id: parsed.id };
-		}
-	} catch {}
-	return { id: signature };
-}
-function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
-	const messages = [];
-	const normalizeIdPart = (part) => {
-		const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
-		return (sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized).replace(/_+$/, "");
-	};
-	const buildForeignResponsesItemId = (itemId) => {
-		const normalized = `fc_${shortHash(itemId)}`;
-		return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
-	};
-	const normalizeToolCallId = (id, _targetModel, source) => {
-		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
-		if (!id.includes("|")) return normalizeIdPart(id);
-		const [callId, itemId] = id.split("|");
-		const normalizedCallId = normalizeIdPart(callId);
-		let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
-		if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
-		return `${normalizedCallId}|${normalizedItemId}`;
-	};
-	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) {
-		const role = model.reasoning ? "developer" : "system";
-		messages.push({
-			role,
-			content: sanitizeSurrogates(context.systemPrompt)
-		});
-	}
-	let msgIndex = 0;
-	for (const msg of transformedMessages) {
-		if (msg.role === "user") if (typeof msg.content === "string") messages.push({
-			role: "user",
-			content: [{
-				type: "input_text",
-				text: sanitizeSurrogates(msg.content)
-			}]
-		});
-		else {
-			const content = msg.content.map((item) => {
-				if (item.type === "text") return {
-					type: "input_text",
-					text: sanitizeSurrogates(item.text)
-				};
-				return {
-					type: "input_image",
-					detail: "auto",
-					image_url: `data:${item.mimeType};base64,${item.data}`
-				};
-			});
-			if (content.length === 0) continue;
-			messages.push({
-				role: "user",
-				content
-			});
-		}
-		else if (msg.role === "assistant") {
-			const output = [];
-			const assistantMsg = msg;
-			const isDifferentModel = assistantMsg.model !== model.id && assistantMsg.provider === model.provider && assistantMsg.api === model.api;
-			for (const block of msg.content) if (block.type === "thinking") {
-				if (block.thinkingSignature) {
-					const reasoningItem = JSON.parse(block.thinkingSignature);
-					output.push(reasoningItem);
-				}
-			} else if (block.type === "text") {
-				const textBlock = block;
-				const parsedSignature = parseTextSignature(textBlock.textSignature);
-				let msgId = parsedSignature?.id;
-				if (!msgId) msgId = `msg_${msgIndex}`;
-				else if (msgId.length > 64) msgId = `msg_${shortHash(msgId)}`;
-				output.push({
-					type: "message",
-					role: "assistant",
-					content: [{
-						type: "output_text",
-						text: sanitizeSurrogates(textBlock.text),
-						annotations: []
-					}],
-					status: "completed",
-					id: msgId,
-					phase: parsedSignature?.phase
-				});
-			} else if (block.type === "toolCall") {
-				const toolCall = block;
-				const [callId, itemIdRaw] = toolCall.id.split("|");
-				let itemId = itemIdRaw;
-				if (isDifferentModel && itemId?.startsWith("fc_")) itemId = void 0;
-				output.push({
-					type: "function_call",
-					id: itemId,
-					call_id: callId,
-					name: toolCall.name,
-					arguments: JSON.stringify(toolCall.arguments)
-				});
-			}
-			if (output.length === 0) continue;
-			messages.push(...output);
-		} else if (msg.role === "toolResult") {
-			const textResult = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-			const hasImages = msg.content.some((c) => c.type === "image");
-			const hasText = textResult.length > 0;
-			const [callId] = msg.toolCallId.split("|");
-			let output;
-			if (hasImages && model.input.includes("image")) {
-				const contentParts = [];
-				if (hasText) contentParts.push({
-					type: "input_text",
-					text: sanitizeSurrogates(textResult)
-				});
-				for (const block of msg.content) if (block.type === "image") contentParts.push({
-					type: "input_image",
-					detail: "auto",
-					image_url: `data:${block.mimeType};base64,${block.data}`
-				});
-				output = contentParts;
-			} else output = sanitizeSurrogates(hasText ? textResult : "(see attached image)");
-			messages.push({
-				type: "function_call_output",
-				call_id: callId,
-				output
-			});
-		}
-		msgIndex++;
-	}
-	return messages;
-}
-function convertResponsesTools(tools, options) {
-	const strict = options?.strict === void 0 ? false : options.strict;
-	return tools.map((tool) => ({
-		type: "function",
-		name: tool.name,
-		description: tool.description,
-		parameters: tool.parameters,
-		strict
-	}));
-}
-async function processResponsesStream(openaiStream, output, stream, model, options) {
-	let currentItem = null;
-	let currentBlock = null;
-	const blocks = output.content;
-	const blockIndex = () => blocks.length - 1;
-	for await (const event of openaiStream) if (event.type === "response.created") output.responseId = event.response.id;
-	else if (event.type === "response.output_item.added") {
-		const item = event.item;
-		if (item.type === "reasoning") {
-			currentItem = item;
-			currentBlock = {
-				type: "thinking",
-				thinking: ""
-			};
-			output.content.push(currentBlock);
-			stream.push({
-				type: "thinking_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
-		} else if (item.type === "message") {
-			currentItem = item;
-			currentBlock = {
-				type: "text",
-				text: ""
-			};
-			output.content.push(currentBlock);
-			stream.push({
-				type: "text_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
-		} else if (item.type === "function_call") {
-			currentItem = item;
-			currentBlock = {
-				type: "toolCall",
-				id: `${item.call_id}|${item.id}`,
-				name: item.name,
-				arguments: {},
-				partialJson: item.arguments || ""
-			};
-			output.content.push(currentBlock);
-			stream.push({
-				type: "toolcall_start",
-				contentIndex: blockIndex(),
-				partial: output
-			});
-		}
-	} else if (event.type === "response.reasoning_summary_part.added") {
-		if (currentItem && currentItem.type === "reasoning") {
-			currentItem.summary = currentItem.summary || [];
-			currentItem.summary.push(event.part);
-		}
-	} else if (event.type === "response.reasoning_summary_text.delta") {
-		if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-			currentItem.summary = currentItem.summary || [];
-			const lastPart = currentItem.summary[currentItem.summary.length - 1];
-			if (lastPart) {
-				currentBlock.thinking += event.delta;
-				lastPart.text += event.delta;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: blockIndex(),
-					delta: event.delta,
-					partial: output
-				});
-			}
-		}
-	} else if (event.type === "response.reasoning_summary_part.done") {
-		if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-			currentItem.summary = currentItem.summary || [];
-			const lastPart = currentItem.summary[currentItem.summary.length - 1];
-			if (lastPart) {
-				currentBlock.thinking += "\n\n";
-				lastPart.text += "\n\n";
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: blockIndex(),
-					delta: "\n\n",
-					partial: output
-				});
-			}
-		}
-	} else if (event.type === "response.content_part.added") {
-		if (currentItem?.type === "message") {
-			currentItem.content = currentItem.content || [];
-			if (event.part.type === "output_text" || event.part.type === "refusal") currentItem.content.push(event.part);
-		}
-	} else if (event.type === "response.output_text.delta") {
-		if (currentItem?.type === "message" && currentBlock?.type === "text") {
-			if (!currentItem.content || currentItem.content.length === 0) continue;
-			const lastPart = currentItem.content[currentItem.content.length - 1];
-			if (lastPart?.type === "output_text") {
-				currentBlock.text += event.delta;
-				lastPart.text += event.delta;
-				stream.push({
-					type: "text_delta",
-					contentIndex: blockIndex(),
-					delta: event.delta,
-					partial: output
-				});
-			}
-		}
-	} else if (event.type === "response.refusal.delta") {
-		if (currentItem?.type === "message" && currentBlock?.type === "text") {
-			if (!currentItem.content || currentItem.content.length === 0) continue;
-			const lastPart = currentItem.content[currentItem.content.length - 1];
-			if (lastPart?.type === "refusal") {
-				currentBlock.text += event.delta;
-				lastPart.refusal += event.delta;
-				stream.push({
-					type: "text_delta",
-					contentIndex: blockIndex(),
-					delta: event.delta,
-					partial: output
-				});
-			}
-		}
-	} else if (event.type === "response.function_call_arguments.delta") {
-		if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-			currentBlock.partialJson += event.delta;
-			currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
-			stream.push({
-				type: "toolcall_delta",
-				contentIndex: blockIndex(),
-				delta: event.delta,
-				partial: output
-			});
-		}
-	} else if (event.type === "response.function_call_arguments.done") {
-		if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-			const previousPartialJson = currentBlock.partialJson;
-			currentBlock.partialJson = event.arguments;
-			currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
-			if (event.arguments.startsWith(previousPartialJson)) {
-				const delta = event.arguments.slice(previousPartialJson.length);
-				if (delta.length > 0) stream.push({
-					type: "toolcall_delta",
-					contentIndex: blockIndex(),
-					delta,
-					partial: output
-				});
-			}
-		}
-	} else if (event.type === "response.output_item.done") {
-		const item = event.item;
-		if (item.type === "reasoning" && currentBlock?.type === "thinking") {
-			currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
-			currentBlock.thinkingSignature = JSON.stringify(item);
-			stream.push({
-				type: "thinking_end",
-				contentIndex: blockIndex(),
-				content: currentBlock.thinking,
-				partial: output
-			});
-			currentBlock = null;
-		} else if (item.type === "message" && currentBlock?.type === "text") {
-			currentBlock.text = item.content.map((c) => c.type === "output_text" ? c.text : c.refusal).join("");
-			currentBlock.textSignature = encodeTextSignatureV1(item.id, item.phase ?? void 0);
-			stream.push({
-				type: "text_end",
-				contentIndex: blockIndex(),
-				content: currentBlock.text,
-				partial: output
-			});
-			currentBlock = null;
-		} else if (item.type === "function_call") {
-			const args = currentBlock?.type === "toolCall" && currentBlock.partialJson ? parseStreamingJson(currentBlock.partialJson) : parseStreamingJson(item.arguments || "{}");
-			let toolCall;
-			if (currentBlock?.type === "toolCall") {
-				currentBlock.arguments = args;
-				delete currentBlock.partialJson;
-				toolCall = currentBlock;
-			} else toolCall = {
-				type: "toolCall",
-				id: `${item.call_id}|${item.id}`,
-				name: item.name,
-				arguments: args
-			};
-			currentBlock = null;
-			stream.push({
-				type: "toolcall_end",
-				contentIndex: blockIndex(),
-				toolCall,
-				partial: output
-			});
-		}
-	} else if (event.type === "response.completed") {
-		const response = event.response;
-		if (response?.id) output.responseId = response.id;
-		if (response?.usage) {
-			const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
-			output.usage = {
-				input: (response.usage.input_tokens || 0) - cachedTokens,
-				output: response.usage.output_tokens || 0,
-				cacheRead: cachedTokens,
-				cacheWrite: 0,
-				totalTokens: response.usage.total_tokens || 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			};
-		}
-		calculateCost(model, output.usage);
-		if (options?.applyServiceTierPricing) {
-			const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response?.service_tier, options.serviceTier) : response?.service_tier ?? options.serviceTier;
-			options.applyServiceTierPricing(output.usage, serviceTier);
-		}
-		output.stopReason = mapStopReason(response?.status);
-		if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
-	} else if (event.type === "error") throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
-	else if (event.type === "response.failed") {
-		const error = event.response?.error;
-		const details = event.response?.incomplete_details;
-		const msg = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
-		throw new Error(msg);
-	}
-}
-function mapStopReason(status) {
-	if (!status) return "stop";
-	switch (status) {
-		case "completed": return "stop";
-		case "incomplete": return "length";
-		case "failed":
-		case "cancelled": return "error";
-		case "in_progress":
-		case "queued": return "stop";
-		default: throw new Error(`Unhandled stop reason: ${status}`);
-	}
-}
-//#endregion
-export { convertResponsesTools as n, processResponsesStream as r, convertResponsesMessages as t };