@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/ollama-DoBz5SFm.mjs

@@ -0,0 +1,589 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-B-9cMxz5.mjs";
+import { g as parseStreamingJson, i as readJsonl } from "./src-lDmkSRbm.mjs";
+import { G as fetchWithRetry, b as LLAMA_CPP_TOOL_CALL_PARSE_PATTERN, g as MissingApiKeyError, l as finalize, z as OllamaApiError } from "./error-yCSG0mGC.mjs";
+import { C as kStreamingPartialJson, I as sanitizeSchemaForOllama, a as normalizeSystemPrompts, h as clearStreamingPartialJson, k as toolWireSchema, m as transformMessages } from "./utils-Bw139LTz.mjs";
+import { Ct as withEmptyCompletionRetry, n as getEnvApiKey } from "./stream-BlldLkVq.mjs";
+import { i as partitionVisionContent, r as joinTextWithImagePlaceholder } from "./vision-guard-DzZGaOga.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-loUa0s1T.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, r as getOpenAIStreamIdleTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-Baoyn3Hp.mjs";
+import { n as getStreamMarkupHealingPattern, t as StreamMarkupHealing } from "./stream-markup-healing-DMsxBx1L.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/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))
+		}
+	}));
+}
+/**
+* Ollama Cloud rejects `num_predict` above this value with HTTP 400
+* (`max_tokens (...) exceeds model's maximum output tokens (65536)`).
+* The cap currently applies uniformly to cloud-served models; the cloud-side
+* limit was confirmed empirically against `deepseek-v4-pro`/`-flash` and is
+* the same cap surfaced for every other Ollama Cloud model we've probed.
+*
+* Acts as a wire-level safety net so stale `models.db` rows (or custom
+* `modelOverrides` re-enabling `num_predict`) cannot 400 the request — even
+* when `model.omitMaxOutputTokens` was never applied. See #3392.
+*/
+const OLLAMA_CLOUD_NUM_PREDICT_CAP = 65536;
+function resolveNumPredict(model, requested) {
+	if (model.provider === "ollama-cloud") return Math.min(requested, OLLAMA_CLOUD_NUM_PREDICT_CAP);
+	return requested;
+}
+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 = resolveNumPredict(model, 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.provider, model.id);
+		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.input = chunk.prompt_eval_count ?? 0;
+					output.usage.output = chunk.eval_count ?? 0;
+					output.usage.totalTokens = output.usage.input + output.usage.output;
+				}
+			}
+			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) => withEmptyCompletionRetry(model, context, options, streamOllamaOnce);
+//#endregion
+export { ollama_exports as t };