@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/ollama-6R0oXZks.mjs

@@ -1,574 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { r as __exportAll } from "./fs-promises-shim-B2YFWkcd.mjs";
-import { _ as parseStreamingJson, i as readJsonl } from "./src-AELUUb5U.mjs";
-import { G as fetchWithRetry, c as finalize, h as MissingApiKeyError, y as LLAMA_CPP_TOOL_CALL_PARSE_PATTERN, z as OllamaApiError } from "./error-O63pC8zg.mjs";
-import { A as toolWireSchema, R as sanitizeSchemaForOllama, g as clearStreamingPartialJson, h as transformMessages, o as normalizeSystemPrompts, w as kStreamingPartialJson } from "./utils-cZX3f_Ls.mjs";
-import { At as withReplaySafeStreamRetry, n as getEnvApiKey } from "./stream-AVOoe5Hj.mjs";
-import { i as partitionVisionContent, r as joinTextWithImagePlaceholder } from "./vision-guard-BCpXWUj3.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BKEtb45Y.mjs";
-import { n as getOpenAIStreamFirstEventTimeoutMs, r as getOpenAIStreamIdleTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-D0ZXEcUq.mjs";
-import { n as getStreamMarkupHealingPattern, t as StreamMarkupHealing } from "./stream-markup-healing-CN3RsqG9.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/ollama.ts
-var ollama_exports = /* @__PURE__ */ __exportAll({ streamOllama: () => streamOllama });
-function normalizeBaseUrl(baseUrl) {
-	const value = baseUrl?.trim();
-	if (!value) return "https://ollama.com";
-	const trimmed = value.endsWith("/") ? value.slice(0, -1) : value;
-	return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
-}
-function mapReasoning(model, reasoning, disableReasoning) {
-	const modelReasoning = model.reasoning;
-	if (disableReasoning && modelReasoning) return false;
-	switch (model.provider === "ollama-cloud" && reasoning ? model.thinking?.effortMap?.[reasoning] ?? reasoning : reasoning) {
-		case "minimal":
-		case "low": return "low";
-		case "medium": return "medium";
-		case "high": return "high";
-		case "max": return "max";
-		case "xhigh": return "high";
-		default: return;
-	}
-}
-function mapToolChoice(toolChoice) {
-	if (!toolChoice || toolChoice === "auto") return;
-	if (toolChoice === "none") return "none";
-	if (toolChoice === "required" || toolChoice === "any") return "required";
-	if (typeof toolChoice === "object" && toolChoice.type === "computer") return void 0;
-	if (typeof toolChoice === "object") return "required";
-}
-function getNamedToolChoiceName(toolChoice) {
-	if (!toolChoice || typeof toolChoice === "string") return;
-	if (toolChoice.type === "computer") return void 0;
-	if ("function" in toolChoice) return toolChoice.function.name;
-	return toolChoice.name;
-}
-function selectToolsForToolChoice(tools, toolChoice) {
-	const toolName = getNamedToolChoiceName(toolChoice);
-	if (!toolName || !tools) return tools;
-	for (const tool of tools) if (tool.name === toolName) return [tool];
-	return [];
-}
-function toPlainContent(content, supportsImages) {
-	if (typeof content === "string") return { content };
-	const { textBlocks, imageBlocks, omittedImages } = partitionVisionContent(content, supportsImages);
-	const text = textBlocks.map((block) => block.text).join("\n");
-	return {
-		content: joinTextWithImagePlaceholder(text, omittedImages),
-		...imageBlocks.length > 0 ? { images: imageBlocks.map((block) => block.data) } : {}
-	};
-}
-function convertMessage(message, supportsImages, developerRole = "user") {
-	if (message.role === "user") return {
-		role: "user",
-		...toPlainContent(message.content, supportsImages)
-	};
-	if (message.role === "developer") return {
-		role: developerRole,
-		...toPlainContent(message.content, supportsImages)
-	};
-	if (message.role === "toolResult") {
-		const converted = toPlainContent(message.content, supportsImages);
-		return {
-			role: "tool",
-			tool_name: message.toolName,
-			...converted
-		};
-	}
-	const text = [];
-	const thinking = [];
-	const toolCalls = [];
-	for (const block of message.content) {
-		if (block.type === "text") {
-			text.push(block.text);
-			continue;
-		}
-		if (block.type === "thinking") {
-			thinking.push(block.thinking);
-			continue;
-		}
-		if (block.type === "toolCall") toolCalls.push({
-			type: "function",
-			function: {
-				name: block.name,
-				arguments: block.arguments
-			}
-		});
-	}
-	return {
-		role: "assistant",
-		content: text.join("\n"),
-		...thinking.length > 0 ? { thinking: thinking.join("\n") } : {},
-		...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
-	};
-}
-function convertMessages(model, context) {
-	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
-	const messages = [...systemPrompts.map((systemPrompt) => ({
-		role: "developer",
-		content: systemPrompt,
-		timestamp: Date.now()
-	})), ...context.messages];
-	const isCloud = model.provider === "ollama-cloud";
-	const supportsImages = model.input.includes("image");
-	const converted = transformMessages(messages, model).map((msg, index) => {
-		const developerRole = msg.role === "developer" && (index < systemPrompts.length || msg.attribution !== "user") ? "system" : "user";
-		const converted = convertMessage(msg, supportsImages, developerRole);
-		if (isCloud && converted.role === "assistant" && converted.thinking) {
-			const { thinking: _t, ...rest } = converted;
-			return rest;
-		}
-		return converted;
-	});
-	if (!converted.some((m) => m.role === "user")) {
-		for (let i = converted.length - 1; i >= systemPrompts.length; i--) if (converted[i].role === "system") {
-			converted[i].role = "user";
-			break;
-		}
-	}
-	return converted;
-}
-function convertTools(tools) {
-	if (!tools || tools.length === 0) return;
-	return tools.map((tool) => ({
-		type: "function",
-		function: {
-			name: tool.name,
-			description: tool.description,
-			parameters: sanitizeSchemaForOllama(toolWireSchema(tool))
-		}
-	}));
-}
-function createChatBody(model, context, options) {
-	const think = mapReasoning(model, options?.reasoning, options?.disableReasoning);
-	const toolChoice = mapToolChoice(options?.toolChoice);
-	const tools = convertTools(selectToolsForToolChoice(context.tools, options?.toolChoice));
-	const runtimeOptions = {};
-	let hasRuntimeOptions = false;
-	if (options?.maxTokens !== void 0 && !model.omitMaxOutputTokens) {
-		runtimeOptions.num_predict = model.provider === "ollama-cloud" ? Math.min(options.maxTokens, 65536) : options.maxTokens;
-		hasRuntimeOptions = true;
-	}
-	if (options?.temperature !== void 0) {
-		runtimeOptions.temperature = options.temperature;
-		hasRuntimeOptions = true;
-	}
-	if (options?.topP !== void 0) {
-		runtimeOptions.top_p = options.topP;
-		hasRuntimeOptions = true;
-	}
-	return {
-		model: model.id,
-		messages: convertMessages(model, context),
-		...tools ? { tools } : {},
-		...think !== void 0 ? { think } : {},
-		...toolChoice !== void 0 ? { tool_choice: toolChoice } : {},
-		...hasRuntimeOptions ? { options: runtimeOptions } : {},
-		stream: true
-	};
-}
-function shouldRetryOllamaResponse(response, bodyText) {
-	return response.status < 500 || !LLAMA_CPP_TOOL_CALL_PARSE_PATTERN.test(bodyText);
-}
-async function captureHttpErrorResponse(response) {
-	let bodyText;
-	let bodyJson;
-	try {
-		bodyText = await response.text();
-		if (bodyText.trim()) try {
-			bodyJson = JSON.parse(bodyText);
-		} catch {}
-	} catch {}
-	return {
-		status: response.status,
-		headers: response.headers,
-		bodyText,
-		bodyJson
-	};
-}
-function createEmptyOutput(model) {
-	return {
-		role: "assistant",
-		content: [],
-		api: "ollama-chat",
-		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()
-	};
-}
-function endThinkingBlock(stream, output, index) {
-	const block = output.content[index];
-	if (block?.type === "thinking") stream.push({
-		type: "thinking_end",
-		contentIndex: index,
-		content: block.thinking,
-		partial: output
-	});
-}
-function endTextBlock(stream, output, index) {
-	const block = output.content[index];
-	if (block?.type === "text") stream.push({
-		type: "text_end",
-		contentIndex: index,
-		content: block.text,
-		partial: output
-	});
-}
-function endToolCallBlock(stream, output, index) {
-	const block = output.content[index];
-	if (block?.type !== "toolCall") return;
-	const toolCall = block;
-	if (toolCall[kStreamingPartialJson]) {
-		toolCall.arguments = parseStreamingJson(toolCall[kStreamingPartialJson]);
-		clearStreamingPartialJson(toolCall);
-	}
-	stream.push({
-		type: "toolcall_end",
-		contentIndex: index,
-		toolCall,
-		partial: output
-	});
-}
-function mapDoneReason(doneReason, output) {
-	if (doneReason === "length") return "length";
-	if (doneReason === "tool_calls") return "toolUse";
-	if (doneReason === "load") return "error";
-	if (doneReason === void 0 && output.content.some((block) => block.type === "toolCall")) return "toolUse";
-	return "stop";
-}
-const EMPTY_OLLAMA_LENGTH_COMPLETION_MESSAGE = "Model returned no content: prompt filled the context window; raise Ollama num_ctx or shorten the prompt.";
-const EMPTY_OLLAMA_LOAD_COMPLETION_MESSAGE = "Ollama loaded the model but generated nothing (done_reason: load): the request contained no user-role message.";
-function hasVisibleAssistantContent(output) {
-	return output.content.some((block) => {
-		if (block.type === "text") return block.text.trim().length > 0;
-		if (block.type === "thinking") return block.thinking.trim().length > 0;
-		return block.type === "toolCall";
-	});
-}
-const OLLAMA_RETRY_DELAYS_MS = [
-	2e3,
-	5e3,
-	1e4
-];
-const streamOllamaOnce = (model, context, options = {}) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const startTime = performance.now();
-		let firstTokenTime;
-		const output = createEmptyOutput(model);
-		let rawRequestDump;
-		let capturedErrorResponse;
-		let activeThinkingIndex;
-		let activeTextIndex;
-		const activeToolIndices = /* @__PURE__ */ new Set();
-		const streamMarkupHealingPattern = getStreamMarkupHealingPattern(model);
-		const streamMarkupHealing = streamMarkupHealingPattern ? new StreamMarkupHealing({ pattern: streamMarkupHealingPattern }) : void 0;
-		let healedToolCallEmitted = false;
-		let suppressHealedThinking = false;
-		const endActiveTextBlock = () => {
-			if (activeTextIndex === void 0) return;
-			endTextBlock(stream, output, activeTextIndex);
-			activeTextIndex = void 0;
-		};
-		const endActiveThinkingBlock = () => {
-			if (activeThinkingIndex === void 0) return;
-			endThinkingBlock(stream, output, activeThinkingIndex);
-			activeThinkingIndex = void 0;
-		};
-		const appendVisibleText = (text) => {
-			if (text.length === 0) return;
-			endActiveThinkingBlock();
-			if (activeTextIndex === void 0) {
-				output.content.push({
-					type: "text",
-					text: ""
-				});
-				activeTextIndex = output.content.length - 1;
-				stream.push({
-					type: "text_start",
-					contentIndex: activeTextIndex,
-					partial: output
-				});
-			}
-			const block = output.content[activeTextIndex];
-			if (block?.type === "text") {
-				block.text += text;
-				stream.push({
-					type: "text_delta",
-					contentIndex: activeTextIndex,
-					delta: text,
-					partial: output
-				});
-			}
-			if (!firstTokenTime) firstTokenTime = performance.now();
-		};
-		const appendVisibleThinking = (thinking) => {
-			if (thinking.length === 0) return;
-			endActiveTextBlock();
-			if (activeThinkingIndex === void 0) {
-				output.content.push({
-					type: "thinking",
-					thinking: ""
-				});
-				activeThinkingIndex = output.content.length - 1;
-				stream.push({
-					type: "thinking_start",
-					contentIndex: activeThinkingIndex,
-					partial: output
-				});
-			}
-			const block = output.content[activeThinkingIndex];
-			if (block?.type === "thinking") {
-				block.thinking += thinking;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: activeThinkingIndex,
-					delta: thinking,
-					partial: output
-				});
-			}
-			if (!firstTokenTime) firstTokenTime = performance.now();
-		};
-		const emitHealedToolCall = (call) => {
-			endActiveThinkingBlock();
-			endActiveTextBlock();
-			const toolCall = {
-				type: "toolCall",
-				id: call.id,
-				name: call.name,
-				arguments: parseStreamingJson(call.arguments),
-				[kStreamingPartialJson]: call.arguments
-			};
-			output.content.push(toolCall);
-			const index = output.content.length - 1;
-			stream.push({
-				type: "toolcall_start",
-				contentIndex: index,
-				partial: output
-			});
-			stream.push({
-				type: "toolcall_delta",
-				contentIndex: index,
-				delta: call.arguments,
-				partial: output
-			});
-			endToolCallBlock(stream, output, index);
-			healedToolCallEmitted = true;
-			if (!firstTokenTime) firstTokenTime = performance.now();
-		};
-		const emitHealingEvent = (event) => {
-			if (event.type === "text") appendVisibleText(event.text);
-			else if (event.type === "thinking") {
-				if (!suppressHealedThinking) appendVisibleThinking(event.thinking);
-			} else emitHealedToolCall(event.call);
-		};
-		const drainHealedToolCalls = () => {
-			if (!streamMarkupHealing) return;
-			for (const call of streamMarkupHealing.drainCompleted()) emitHealedToolCall(call);
-		};
-		try {
-			const apiKey = options.apiKey || getEnvApiKey(model.provider);
-			if (!apiKey) throw new MissingApiKeyError(model.provider);
-			const baseUrl = normalizeBaseUrl(model.baseUrl);
-			let body = createChatBody(model, context, options);
-			const replacementPayload = await options.onPayload?.(body, model);
-			if (replacementPayload !== void 0) body = replacementPayload;
-			rawRequestDump = {
-				provider: model.provider,
-				api: model.api,
-				model: model.id,
-				method: "POST",
-				url: `${baseUrl}/api/chat`,
-				body
-			};
-			const idleTimeoutMs = options.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
-			const firstEventTimeoutMs = options.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs);
-			const watchdog = armPreResponseTimeout(options.signal, firstEventTimeoutMs);
-			let response;
-			try {
-				response = await fetchWithRetry(`${baseUrl}/api/chat`, {
-					method: "POST",
-					headers: {
-						...model.headers,
-						...options.headers,
-						Authorization: `Bearer ${apiKey}`,
-						"Content-Type": "application/json"
-					},
-					body: JSON.stringify(body),
-					signal: watchdog.signal,
-					defaultDelayMs: OLLAMA_RETRY_DELAYS_MS,
-					shouldRetryResponse: shouldRetryOllamaResponse,
-					fetch: options.fetch,
-					timeout: false
-				});
-			} finally {
-				watchdog.clear();
-			}
-			if (!response.ok) {
-				capturedErrorResponse = await captureHttpErrorResponse(response);
-				throw new OllamaApiError(`HTTP ${response.status} from ${baseUrl}/api/chat`, response.status, { headers: response.headers });
-			}
-			if (!response.body) throw new OllamaApiError("Ollama returned an empty response body", response.status, { headers: response.headers });
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			for await (const chunk of readJsonl(response.body)) {
-				if (chunk.message?.thinking) {
-					suppressHealedThinking = true;
-					endActiveTextBlock();
-					if (activeThinkingIndex === void 0) {
-						output.content.push({
-							type: "thinking",
-							thinking: ""
-						});
-						activeThinkingIndex = output.content.length - 1;
-						stream.push({
-							type: "thinking_start",
-							contentIndex: activeThinkingIndex,
-							partial: output
-						});
-					}
-					const block = output.content[activeThinkingIndex];
-					if (block?.type === "thinking") {
-						block.thinking += chunk.message.thinking;
-						stream.push({
-							type: "thinking_delta",
-							contentIndex: activeThinkingIndex,
-							delta: chunk.message.thinking,
-							partial: output
-						});
-					}
-					if (!firstTokenTime) firstTokenTime = performance.now();
-				}
-				const chunkContent = chunk.message?.content;
-				const structuredCalls = chunk.message?.tool_calls?.length ? chunk.message.tool_calls : void 0;
-				if (chunkContent) {
-					if (streamMarkupHealing) {
-						const healingEvents = structuredCalls ? streamMarkupHealing.feedEventsWithoutCalls(chunkContent) : streamMarkupHealing.feedEvents(chunkContent);
-						for (const event of healingEvents) emitHealingEvent(event);
-					} else appendVisibleText(chunkContent);
-				}
-				if (structuredCalls) {
-					endActiveThinkingBlock();
-					endActiveTextBlock();
-					for (const call of structuredCalls) {
-						const name = call.function?.name ?? "unknown_tool";
-						const rawArgs = call.function?.arguments;
-						const partialJson = typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs ?? {});
-						const toolCall = {
-							type: "toolCall",
-							id: `ollama:${output.content.length}:${name}`,
-							name,
-							arguments: parseStreamingJson(partialJson),
-							[kStreamingPartialJson]: partialJson
-						};
-						output.content.push(toolCall);
-						const index = output.content.length - 1;
-						activeToolIndices.add(index);
-						stream.push({
-							type: "toolcall_start",
-							contentIndex: index,
-							partial: output
-						});
-						stream.push({
-							type: "toolcall_delta",
-							contentIndex: index,
-							delta: partialJson,
-							partial: output
-						});
-						if (!firstTokenTime) firstTokenTime = performance.now();
-					}
-				}
-				if (chunk.done) {
-					if (streamMarkupHealing) {
-						for (const event of streamMarkupHealing.flushEvents()) emitHealingEvent(event);
-						drainHealedToolCalls();
-					}
-					endActiveThinkingBlock();
-					endActiveTextBlock();
-					for (const index of activeToolIndices) endToolCallBlock(stream, output, index);
-					activeToolIndices.clear();
-					output.stopReason = mapDoneReason(chunk.done_reason, output);
-					if (healedToolCallEmitted && output.stopReason === "stop") output.stopReason = "toolUse";
-					output.usage.cacheRead = chunk.prompt_eval_cached_count ?? 0;
-					output.usage.input = (chunk.prompt_eval_count ?? 0) - output.usage.cacheRead;
-					output.usage.output = chunk.eval_count ?? 0;
-					output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead;
-				}
-			}
-			if (streamMarkupHealing) {
-				for (const event of streamMarkupHealing.flushEvents()) emitHealingEvent(event);
-				drainHealedToolCalls();
-				if (healedToolCallEmitted && output.stopReason === "stop") output.stopReason = "toolUse";
-			}
-			endActiveThinkingBlock();
-			endActiveTextBlock();
-			if (output.stopReason === "length" && !hasVisibleAssistantContent(output)) {
-				output.stopReason = "error";
-				output.errorMessage = EMPTY_OLLAMA_LENGTH_COMPLETION_MESSAGE;
-			}
-			if (output.stopReason === "error" && !output.errorMessage) output.errorMessage = EMPTY_OLLAMA_LOAD_COMPLETION_MESSAGE;
-			if (output.stopReason === "stop" && output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			if (output.stopReason === "error") {
-				stream.push({
-					type: "error",
-					reason: "error",
-					error: output
-				});
-				stream.end();
-				return;
-			}
-			const doneReason = output.stopReason === "length" ? "length" : output.stopReason === "toolUse" ? "toolUse" : "stop";
-			stream.push({
-				type: "done",
-				reason: doneReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			for (const block of output.content) if (block.type === "toolCall") clearStreamingPartialJson(block);
-			const result = await finalize(error, {
-				api: model.api,
-				provider: model.provider,
-				signal: options.signal,
-				rawRequestDump,
-				capturedErrorResponse
-			});
-			output.stopReason = result.stopReason;
-			output.errorStatus = result.status;
-			output.errorId = result.id;
-			output.errorMessage = result.message;
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		}
-	})();
-	return stream;
-};
-/** Retry EOS-only Ollama completions before the agent loop sees an empty stop. */
-const streamOllama = (model, context, options) => withReplaySafeStreamRetry(model, context, options, streamOllamaOnce, { retryEmptyCompletion: true });
-//#endregion
-export { ollama_exports as t };