@clinebot/llms 0.0.0 → 0.0.2

package/src/providers/handlers/openai-responses.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, it } from "vitest";
+import type { Message } from "../types/messages";
+import type { ApiStreamChunk } from "../types/stream";
+import { OpenAIResponsesHandler } from "./openai-responses";
+
+class TestOpenAIResponsesHandler extends OpenAIResponsesHandler {
+	private readonly functionCallMetadataByItemId = new Map<
+		string,
+		{ callId?: string; name?: string }
+	>();
+
+	processChunkForTest(chunk: any, responseId = "resp_1"): ApiStreamChunk[] {
+		return [
+			...this.processResponseChunk(
+				chunk,
+				{ id: "gpt-5.4", capabilities: ["tools"] },
+				responseId,
+				this.functionCallMetadataByItemId,
+			),
+		];
+	}
+}
+
+describe("OpenAIResponsesHandler", () => {
+	it("converts tool_use/tool_result message history into Responses input items", () => {
+		const handler = new TestOpenAIResponsesHandler({
+			providerId: "openai-native",
+			modelId: "gpt-5.4",
+			apiKey: "test-key",
+			baseUrl: "https://example.com",
+		});
+
+		const messages: Message[] = [
+			{ role: "user", content: [{ type: "text", text: "Run pwd" }] },
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "Running command..." },
+					{
+						type: "tool_use",
+						id: "fc_1",
+						call_id: "call_1",
+						name: "run_commands",
+						input: { commands: ["pwd"] },
+					},
+					{ type: "text", text: "Waiting for output" },
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: "/tmp/workspace",
+					},
+					{ type: "text", text: "continue" },
+				],
+			},
+		];
+
+		const input = handler.getMessages("system", messages);
+
+		expect(input).toEqual([
+			{
+				type: "message",
+				role: "user",
+				content: [{ type: "input_text", text: "Run pwd" }],
+			},
+			{
+				type: "message",
+				role: "assistant",
+				content: [{ type: "output_text", text: "Running command..." }],
+			},
+			{
+				type: "function_call",
+				call_id: "call_1",
+				name: "run_commands",
+				arguments: '{"commands":["pwd"]}',
+			},
+			{
+				type: "message",
+				role: "assistant",
+				content: [{ type: "output_text", text: "Waiting for output" }],
+			},
+			{
+				type: "function_call_output",
+				call_id: "call_1",
+				output: "/tmp/workspace",
+			},
+			{
+				type: "message",
+				role: "user",
+				content: [{ type: "input_text", text: "continue" }],
+			},
+		]);
+	});
+
+	it("falls back to tool_use id when call_id is unavailable", () => {
+		const handler = new TestOpenAIResponsesHandler({
+			providerId: "openai-native",
+			modelId: "gpt-5.4",
+			apiKey: "test-key",
+			baseUrl: "https://example.com",
+		});
+
+		const messages: Message[] = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "fc_123",
+						name: "search_codebase",
+						input: { pattern: "history" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "fc_123",
+						content: "found",
+					},
+				],
+			},
+		];
+
+		const input = handler.getMessages("system", messages);
+		expect(input).toEqual([
+			{
+				type: "function_call",
+				call_id: "fc_123",
+				name: "search_codebase",
+				arguments: '{"pattern":"history"}',
+			},
+			{
+				type: "function_call_output",
+				call_id: "fc_123",
+				output: "found",
+			},
+		]);
+	});
+
+	it("does not map function-call item ids to tool names", () => {
+		const handler = new TestOpenAIResponsesHandler({
+			providerId: "openai-native",
+			modelId: "gpt-5.4",
+			apiKey: "test-key",
+			baseUrl: "https://example.com",
+		});
+
+		const itemId = "fc_03aad4ff6c019bed0069ba5e9ad030819f8b2b06c5ac013811";
+
+		const addedChunks = handler.processChunkForTest({
+			type: "response.output_item.added",
+			item: {
+				type: "function_call",
+				id: itemId,
+				call_id: "call_1",
+				name: "run_commands",
+				arguments: "{}",
+			},
+		});
+		const deltaChunks = handler.processChunkForTest({
+			type: "response.function_call_arguments.delta",
+			item_id: itemId,
+			delta: '{"commands":["pwd"]',
+		});
+
+		expect(addedChunks).toHaveLength(1);
+		expect(deltaChunks).toHaveLength(1);
+		expect(deltaChunks[0]).toMatchObject({
+			type: "tool_calls",
+			tool_call: {
+				call_id: "call_1",
+				function: {
+					id: itemId,
+					name: "run_commands",
+				},
+			},
+		});
+	});
+
+	it("leaves tool name undefined for argument deltas without metadata", () => {
+		const handler = new TestOpenAIResponsesHandler({
+			providerId: "openai-native",
+			modelId: "gpt-5.4",
+			apiKey: "test-key",
+			baseUrl: "https://example.com",
+		});
+
+		const itemId = "fc_unknown";
+		const deltaChunks = handler.processChunkForTest({
+			type: "response.function_call_arguments.delta",
+			item_id: itemId,
+			delta: '{"x":1}',
+		});
+
+		expect(deltaChunks).toHaveLength(1);
+		expect(deltaChunks[0]).toMatchObject({
+			type: "tool_calls",
+			tool_call: {
+				function: {
+					id: itemId,
+					name: undefined,
+				},
+			},
+		});
+	});
+});

package/src/providers/handlers/openai-responses.ts

@@ -12,90 +12,34 @@
  */
 
 import OpenAI from "openai";
+import {
+	normalizeToolUseInput,
+	serializeToolResultContent,
+} from "../transform/content-format";
 import type {
 	ApiStream,
 	HandlerModelInfo,
 	ModelInfo,
 	ProviderConfig,
 } from "../types";
-import type { Message, ToolDefinition } from "../types/messages";
+import type {
+	ContentBlock,
+	Message,
+	ToolDefinition,
+	ToolUseContent,
+} from "../types/messages";
 import { retryStream } from "../utils/retry";
 import { getMissingApiKeyError, resolveApiKeyForProvider } from "./auth";
 import { BaseHandler } from "./base";
 
 const DEFAULT_REASONING_EFFORT = "medium" as const;
 
-function normalizeStrictToolSchema(
-	schema: unknown,
-	options?: { stripFormat?: boolean },
-): unknown {
-	if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-		return schema;
-	}
-
-	const normalized = { ...(schema as Record<string, unknown>) };
-	if (options?.stripFormat && "format" in normalized) {
-		delete normalized.format;
-	}
-	const type = normalized.type;
-
-	if (type === "object") {
-		if (!Object.hasOwn(normalized, "additionalProperties")) {
-			normalized.additionalProperties = false;
-		}
-		const properties = normalized.properties;
-		if (
-			properties &&
-			typeof properties === "object" &&
-			!Array.isArray(properties)
-		) {
-			const nextProperties: Record<string, unknown> = {};
-			for (const [key, value] of Object.entries(
-				properties as Record<string, unknown>,
-			)) {
-				nextProperties[key] = normalizeStrictToolSchema(value, options);
-			}
-			normalized.properties = nextProperties;
-		}
-	}
-
-	if (Array.isArray(normalized.anyOf)) {
-		normalized.anyOf = normalized.anyOf.map((item) =>
-			normalizeStrictToolSchema(item, options),
-		);
-	}
-	if (Array.isArray(normalized.oneOf)) {
-		normalized.oneOf = normalized.oneOf.map((item) =>
-			normalizeStrictToolSchema(item, options),
-		);
-	}
-	if (Array.isArray(normalized.allOf)) {
-		normalized.allOf = normalized.allOf.map((item) =>
-			normalizeStrictToolSchema(item, options),
-		);
-	}
-	if (normalized.not && typeof normalized.not === "object") {
-		normalized.not = normalizeStrictToolSchema(normalized.not, options);
-	}
-	if (normalized.items) {
-		if (Array.isArray(normalized.items)) {
-			normalized.items = normalized.items.map((item) =>
-				normalizeStrictToolSchema(item, options),
-			);
-		} else {
-			normalized.items = normalizeStrictToolSchema(normalized.items, options);
-		}
-	}
-
-	return normalized;
-}
-
 /**
  * Convert tool definitions to Responses API format
  */
 function convertToolsToResponsesFormat(
 	tools?: ToolDefinition[],
-	options?: { stripFormat?: boolean },
+	_options?: { stripFormat?: boolean },
 ) {
 	if (!tools?.length) return undefined;
 
@@ -103,8 +47,7 @@ function convertToolsToResponsesFormat(
 		type: "function" as const,
 		name: tool.name,
 		description: tool.description,
-		parameters: normalizeStrictToolSchema(tool.inputSchema, options),
-		strict: true, // Responses API defaults to strict mode
+		parameters: tool.inputSchema,
 	}));
 }
 
@@ -112,41 +55,103 @@ function convertToolsToResponsesFormat(
  * Convert messages to Responses API input format
  */
 function convertToResponsesInput(messages: Message[]) {
-	// Responses API uses a flat input array with specific item types
-	const input: Array<{
-		type: "message";
-		role: "user" | "assistant";
-		content:
-			| string
-			| Array<{ type: "input_text" | "output_text"; text: string }>;
-	}> = [];
+	type ResponsesInputItem =
+		| {
+				type: "message";
+				role: "user" | "assistant";
+				content: Array<{ type: "input_text" | "output_text"; text: string }>;
+		  }
+		| {
+				type: "function_call";
+				call_id: string;
+				name: string;
+				arguments: string;
+		  }
+		| {
+				type: "function_call_output";
+				call_id: string;
+				output: string;
+		  };
+
+	const input: ResponsesInputItem[] = [];
+
+	const toText = (
+		role: "user" | "assistant",
+		contentBlocks: Array<{ type: "text"; text: string }>,
+	) => {
+		const textContent = contentBlocks.map((block) => block.text).join("\n");
+		if (!textContent) {
+			return;
+		}
+		input.push({
+			type: "message",
+			role,
+			content: [
+				{
+					type: role === "user" ? "input_text" : "output_text",
+					text: textContent,
+				},
+			],
+		});
+	};
+
+	const isTextBlock = (
+		block: ContentBlock,
+	): block is { type: "text"; text: string } => block.type === "text";
+
+	const assistantToolUseCallId = (block: ToolUseContent): string =>
+		block.call_id?.trim() || block.id;
 
 	for (const msg of messages) {
-		if (msg.role === "user" || msg.role === "assistant") {
-			// Handle content blocks
-			const contentBlocks = Array.isArray(msg.content)
-				? msg.content
-				: [{ type: "text" as const, text: msg.content }];
-
-			const textContent = contentBlocks
-				.filter(
-					(block): block is { type: "text"; text: string } =>
-						block.type === "text",
-				)
-				.map((block) => block.text)
-				.join("\n");
-
-			if (textContent) {
+		if (msg.role !== "user" && msg.role !== "assistant") {
+			continue;
+		}
+
+		if (!Array.isArray(msg.content)) {
+			if (msg.content) {
+				toText(msg.role, [{ type: "text", text: msg.content }]);
+			}
+			continue;
+		}
+
+		let bufferedText: Array<{ type: "text"; text: string }> = [];
+		const flushText = () => {
+			if (bufferedText.length === 0) {
+				return;
+			}
+			toText(msg.role, bufferedText);
+			bufferedText = [];
+		};
+
+		for (const block of msg.content) {
+			if (isTextBlock(block)) {
+				bufferedText.push(block);
+				continue;
+			}
+
+			if (msg.role === "assistant" && block.type === "tool_use") {
+				flushText();
+				const toolUseBlock = block as ToolUseContent;
+				input.push({
+					type: "function_call",
+					call_id: assistantToolUseCallId(toolUseBlock),
+					name: toolUseBlock.name,
+					arguments: JSON.stringify(normalizeToolUseInput(toolUseBlock.input)),
+				});
+				continue;
+			}
+
+			if (msg.role === "user" && block.type === "tool_result") {
+				flushText();
 				input.push({
-					type: "message",
-					role: msg.role,
-					content:
-						msg.role === "user"
-							? [{ type: "input_text", text: textContent }]
-							: [{ type: "output_text", text: textContent }],
+					type: "function_call_output",
+					call_id: block.tool_use_id,
+					output: serializeToolResultContent(block.content),
 				});
 			}
 		}
+
+		flushText();
 	}
 
 	return input;
@@ -253,6 +258,10 @@ export class OpenAIResponsesHandler extends BaseHandler {
 		const abortSignal = this.getAbortSignal();
 		const fallbackResponseId = this.createResponseId();
 		let resolvedResponseId: string | undefined;
+		const functionCallMetadataByItemId = new Map<
+			string,
+			{ callId?: string; name?: string }
+		>();
 
 		// Convert messages to Responses API input format
 		const input = this.getMessages(systemPrompt, messages);
@@ -362,6 +371,7 @@ export class OpenAIResponsesHandler extends BaseHandler {
 				chunk,
 				modelInfo,
 				resolvedResponseId ?? fallbackResponseId,
+				functionCallMetadataByItemId,
 			);
 		}
 	}
@@ -373,12 +383,20 @@ export class OpenAIResponsesHandler extends BaseHandler {
 		chunk: any,
 		_modelInfo: ModelInfo,
 		responseId: string,
+		functionCallMetadataByItemId: Map<
+			string,
+			{ callId?: string; name?: string }
+		>,
 	): Generator<import("../types").ApiStreamChunk> {
 		// Handle different event types from Responses API
 		switch (chunk.type) {
 			case "response.output_item.added": {
 				const item = chunk.item;
 				if (item.type === "function_call" && item.id) {
+					functionCallMetadataByItemId.set(item.id, {
+						callId: item.call_id,
+						name: item.name,
+					});
 					yield {
 						type: "tool_calls",
 						id: item.id || responseId,
@@ -406,6 +424,12 @@ export class OpenAIResponsesHandler extends BaseHandler {
 			case "response.output_item.done": {
 				const item = chunk.item;
 				if (item.type === "function_call") {
+					if (item.id) {
+						functionCallMetadataByItemId.set(item.id, {
+							callId: item.call_id,
+							name: item.name,
+						});
+					}
 					yield {
 						type: "tool_calls",
 						id: item.id || responseId,
@@ -476,28 +500,36 @@ export class OpenAIResponsesHandler extends BaseHandler {
 				break;
 
 			case "response.function_call_arguments.delta":
-				yield {
-					type: "tool_calls",
-					id: chunk.item_id || responseId,
-					tool_call: {
-						function: {
-							id: chunk.item_id,
-							name: chunk.item_id,
-							arguments: chunk.delta,
+				{
+					const meta = chunk.item_id
+						? functionCallMetadataByItemId.get(chunk.item_id)
+						: undefined;
+					yield {
+						type: "tool_calls",
+						id: chunk.item_id || responseId,
+						tool_call: {
+							call_id: meta?.callId,
+							function: {
+								id: chunk.item_id,
+								name: meta?.name,
+								arguments: chunk.delta,
+							},
 						},
-					},
-				};
+					};
+				}
 				break;
 
 			case "response.function_call_arguments.done":
-				if (chunk.item_id && chunk.name && chunk.arguments) {
+				if (chunk.item_id && chunk.arguments) {
+					const meta = functionCallMetadataByItemId.get(chunk.item_id);
 					yield {
 						type: "tool_calls",
 						id: chunk.item_id || responseId,
 						tool_call: {
+							call_id: chunk.call_id ?? meta?.callId,
 							function: {
 								id: chunk.item_id,
-								name: chunk.name,
+								name: chunk.name ?? meta?.name,
 								arguments: chunk.arguments,
 							},
 						},

package/src/providers/handlers/r1-base.ts

@@ -155,8 +155,9 @@ export class R1BaseHandler extends BaseHandler {
 		};
 
 		// Add max tokens if configured
-		if (modelInfo.maxTokens) {
-			requestOptions.max_completion_tokens = modelInfo.maxTokens;
+		const maxTokens = modelInfo.maxTokens ?? this.config.maxOutputTokens;
+		if (maxTokens) {
+			requestOptions.max_completion_tokens = maxTokens;
 		}
 
 		// Only set temperature for non-reasoner models

package/src/providers/handlers/vertex.ts

@@ -241,7 +241,7 @@ export class VertexHandler extends BaseHandler {
 				promptCacheOn,
 			}),
 			tools: toAiSdkTools(tools),
-			maxTokens: model.info.maxTokens ?? 8192,
+			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 8192,
 			temperature: reasoningOn ? undefined : 0,
 			providerOptions:
 				Object.keys(providerOptions).length > 0 ? providerOptions : undefined,

package/src/providers/transform/format-conversion.test.ts

@@ -56,9 +56,12 @@ describe("format conversion", () => {
 
 		const gemini = convertToGeminiMessages(messages) as any[];
 		expect(gemini[0]?.parts?.[0]?.text).toBe(fileText);
+		expect(gemini[1]?.parts?.[0]?.functionCall?.id).toBe("call_1");
 		expect(gemini[2]?.parts?.[0]?.functionResponse?.response?.result).toBe(
 			fileText,
 		);
+		expect(gemini[2]?.parts?.[0]?.functionResponse?.id).toBe("call_1");
+		expect(gemini[2]?.parts?.[0]?.functionResponse?.name).toBe("read_file");
 
 		const anthropic = convertToAnthropicMessages(messages) as any[];
 		expect(anthropic[0]?.content?.[0]).toMatchObject({
@@ -104,6 +107,7 @@ describe("format conversion", () => {
 		const assistant = gemini[1] as any;
 		expect(assistant.role).toBe("model");
 		expect(assistant.parts[0].functionCall.name).toBe("run_commands");
+		expect(assistant.parts[0].functionCall.id).toBe("call_1");
 		expect(assistant.parts[0].thoughtSignature).toBe("sig-a");
 		expect(assistant.parts[1].thought).toBe(true);
 		expect(assistant.parts[1].thoughtSignature).toBe("sig-think");
@@ -111,6 +115,56 @@ describe("format conversion", () => {
 		expect(assistant.parts[2].thoughtSignature).toBe("sig-text");
 	});
 
+	it("maps out-of-order gemini tool results by call id", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "check both" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "read_file",
+						input: { path: "a.ts" },
+					},
+					{
+						type: "tool_use",
+						id: "call_2",
+						name: "search_files",
+						input: { query: "TODO" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_2",
+						content: '{"matches":1}',
+					},
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: '{"text":"ok"}',
+					},
+				],
+			},
+		];
+
+		const gemini = convertToGeminiMessages(messages) as any[];
+		expect(gemini[2]?.parts?.[0]?.functionResponse).toMatchObject({
+			id: "call_2",
+			name: "search_files",
+			response: { result: { matches: 1 } },
+		});
+		expect(gemini[2]?.parts?.[1]?.functionResponse).toMatchObject({
+			id: "call_1",
+			name: "read_file",
+			response: { result: { text: "ok" } },
+		});
+	});
+
 	it("converts multiple tool_result blocks for openai without dropping any", () => {
 		const messages: Message[] = [
 			{ role: "user", content: "check both" },