@clinebot/llms 0.0.0 → 0.0.2

package/src/providers/transform/gemini-format.ts

@@ -4,7 +4,7 @@
  * Converts our unified Message format to Google Gemini's Content format.
  */
 
-import { formatFileContentBlock } from "@clinebot/shared";
+import { formatFileContentBlock, parseJsonStream } from "@clinebot/shared";
 import type { Content, FunctionDeclaration, Part } from "@google/genai";
 import type {
 	ContentBlock,
@@ -25,10 +25,16 @@ import {
  * Convert messages to Gemini format
  */
 export function convertToGeminiMessages(messages: Message[]): Content[] {
-	return messages.map(convertMessage).filter((m): m is Content => m !== null);
+	const toolNameByCallId = new Map<string, string>();
+	return messages
+		.map((message) => convertMessage(message, toolNameByCallId))
+		.filter((m): m is Content => m !== null);
 }
 
-function convertMessage(message: Message): Content | null {
+function convertMessage(
+	message: Message,
+	toolNameByCallId: Map<string, string>,
+): Content | null {
 	const { role, content } = message;
 
 	// Map roles: Gemini uses "user" and "model"
@@ -43,7 +49,7 @@ function convertMessage(message: Message): Content | null {
 	}
 
 	// Array content
-	const parts = convertContentBlocks(content);
+	const parts = convertContentBlocks(content, toolNameByCallId);
 	if (parts.length === 0) {
 		return null;
 	}
@@ -54,11 +60,17 @@ function convertMessage(message: Message): Content | null {
 	};
 }
 
-function convertContentBlocks(content: ContentBlock[]): Part[] {
+function convertContentBlocks(
+	content: ContentBlock[],
+	toolNameByCallId: Map<string, string>,
+): Part[] {
 	const parts: Part[] = [];
 
 	for (const block of content) {
-		const converted = convertContentBlock(block);
+		if (block.type === "tool_use") {
+			toolNameByCallId.set(block.id, block.name);
+		}
+		const converted = convertContentBlock(block, toolNameByCallId);
 		if (converted) {
 			parts.push(converted);
 		}
@@ -67,7 +79,10 @@ function convertContentBlocks(content: ContentBlock[]): Part[] {
 	return parts;
 }
 
-function convertContentBlock(block: ContentBlock): Part | null {
+function convertContentBlock(
+	block: ContentBlock,
+	toolNameByCallId: Map<string, string>,
+): Part | null {
 	switch (block.type) {
 		case "text": {
 			const textBlock = block as TextContent;
@@ -101,6 +116,7 @@ function convertContentBlock(block: ContentBlock): Part | null {
 			const toolBlock = block as ToolUseContent;
 			const part: Part = {
 				functionCall: {
+					id: toolBlock.id,
 					name: toolBlock.name,
 					args: normalizeToolUseInput(toolBlock.input),
 				},
@@ -116,7 +132,7 @@ function convertContentBlock(block: ContentBlock): Part | null {
 			let responseContent: Record<string, unknown>;
 
 			if (typeof resultBlock.content === "string") {
-				responseContent = { result: resultBlock.content };
+				responseContent = { result: parseJsonStream(resultBlock.content) };
 			} else {
 				responseContent = {
 					result: serializeToolResultContent(resultBlock.content),
@@ -129,7 +145,10 @@ function convertContentBlock(block: ContentBlock): Part | null {
 
 			return {
 				functionResponse: {
-					name: resultBlock.tool_use_id, // Gemini uses the function name here
+					id: resultBlock.tool_use_id,
+					name:
+						toolNameByCallId.get(resultBlock.tool_use_id) ??
+						resultBlock.tool_use_id,
 					response: responseContent,
 				},
 			};

package/src/providers/types/config.ts

@@ -118,7 +118,7 @@ export interface TokenConfig {
  */
 export interface ReasoningConfig {
 	/** Reasoning effort level */
-	reasoningEffort?: "low" | "medium" | "high";
+	reasoningEffort?: "low" | "medium" | "high" | "xhigh";
 	/** Extended thinking budget in tokens */
 	thinkingBudgetTokens?: number;
 	/** Enable thinking with provider/model defaults when supported */

package/src/providers/types/messages.ts

@@ -50,6 +50,8 @@ export interface ToolUseContent {
 	type: "tool_use";
 	/** Unique ID for this tool call */
 	id: string;
+	/** Provider-native call ID for this tool call (if available) */
+	call_id?: string;
 	/** Name of the tool being called */
 	name: string;
 	/** Arguments for the tool call */

package/src/providers/types/settings.ts

@@ -57,7 +57,7 @@ export type AuthSettings = z.infer<typeof AuthSettingsSchema>;
 /**
  * Reasoning/thinking configuration
  */
-const ReasoningLevelSchema = z.enum(["none", "low", "medium", "high"]);
+const ReasoningLevelSchema = z.enum(["none", "low", "medium", "high", "xhigh"]);
 
 export const ReasoningSettingsSchema = z.object({
 	/** Enable thinking with provider/model defaults when supported */

package/src/providers/utils/tool-processor.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import { getOpenAIToolParams } from "../transform/openai-format";
 import { ToolCallProcessor } from "./tool-processor";
 
 describe("ToolCallProcessor", () => {
@@ -31,4 +32,144 @@ describe("ToolCallProcessor", () => {
 		expect(first[0].tool_call.function.arguments).toBe('{"commands":["ls');
 		expect(second[0].tool_call.function.arguments).toBe(' -la"]}');
 	});
+
+	it("preserves tool call id/name for interleaved parallel deltas", () => {
+		const processor = new ToolCallProcessor();
+
+		const firstChunk = [
+			{
+				index: 0,
+				id: "call_a",
+				function: { name: "read_file" },
+			},
+			{
+				index: 1,
+				id: "call_b",
+				function: { name: "search_files" },
+			},
+		];
+
+		const secondChunk = [
+			{
+				index: 1,
+				function: { arguments: '{"path":"src"}' },
+			},
+			{
+				index: 0,
+				function: { arguments: '{"path":"README.md"}' },
+			},
+		];
+
+		const firstResult = processor.processToolCallDeltas(firstChunk, "resp_1");
+		const secondResult = processor.processToolCallDeltas(secondChunk, "resp_1");
+
+		// Current implementation emits tool call chunks once id+name are known,
+		// even before argument deltas arrive.
+		expect(firstResult).toHaveLength(2);
+		expect(secondResult).toHaveLength(2);
+
+		// Intentionally reversed from the setup chunk: output follows incoming
+		// argument-delta order while reconstruction remains index-safe.
+		const firstToolCall = secondResult[0].tool_call;
+		const secondToolCall = secondResult[1].tool_call;
+
+		expect(firstToolCall.function.id).toBe("call_b");
+		expect(firstToolCall.function.name).toBe("search_files");
+		expect(firstToolCall.function.arguments).toBe('{"path":"src"}');
+
+		expect(secondToolCall.function.id).toBe("call_a");
+		expect(secondToolCall.function.name).toBe("read_file");
+		expect(secondToolCall.function.arguments).toBe('{"path":"README.md"}');
+	});
+
+	it("clears accumulated state on reset", () => {
+		const processor = new ToolCallProcessor();
+
+		const setupChunk = [
+			{
+				index: 0,
+				id: "call_reset",
+				function: { name: "read_file" },
+			},
+		];
+
+		const argsChunk = [
+			{
+				index: 0,
+				function: { arguments: '{"path":"after-reset"}' },
+			},
+		];
+
+		expect(processor.processToolCallDeltas(setupChunk, "resp_1")).toHaveLength(
+			1,
+		);
+		processor.reset();
+		expect(processor.processToolCallDeltas(argsChunk, "resp_1")).toHaveLength(
+			0,
+		);
+
+		const newSetupChunk = [
+			{
+				index: 0,
+				id: "call_new",
+				function: { name: "write_file" },
+			},
+		];
+
+		const newArgsChunk = [
+			{
+				index: 0,
+				function: { arguments: '{"path":"file.txt"}' },
+			},
+		];
+
+		expect(
+			processor.processToolCallDeltas(newSetupChunk, "resp_1"),
+		).toHaveLength(1);
+		expect(
+			processor.processToolCallDeltas(newArgsChunk, "resp_1"),
+		).toHaveLength(1);
+	});
+});
+
+describe("getOpenAIToolParams", () => {
+	it("returns tools and tool_choice when tools are present", () => {
+		const tools = [
+			{
+				name: "read_file",
+				description: "",
+				inputSchema: { type: "object" },
+			},
+		];
+
+		const params = getOpenAIToolParams(tools);
+
+		expect(params.tools).toHaveLength(1);
+		expect(params.tool_choice).toBe("auto");
+		expect(params).not.toHaveProperty("parallel_tool_calls");
+	});
+
+	it("returns empty object when tools are absent", () => {
+		const params = getOpenAIToolParams(undefined);
+
+		expect(params).toEqual({});
+		expect(params).not.toHaveProperty("parallel_tool_calls");
+	});
+
+	it("supports strict option passthrough", () => {
+		const tools = [
+			{
+				name: "read_file",
+				description: "",
+				inputSchema: { type: "object" },
+			},
+		];
+
+		const params = getOpenAIToolParams(tools, { strict: false });
+
+		expect(params.tools?.[0]).toMatchObject({
+			type: "function",
+			function: { strict: false },
+		});
+	});
 });