@clinebot/llms 0.0.5 → 0.0.7

package/dist/providers/handlers/anthropic-base.d.ts

@@ -5,6 +5,7 @@
  * Supports prompt caching, extended thinking, and native tool calling.
  */
 import { Anthropic } from "@anthropic-ai/sdk";
+import type { RawMessageStreamEvent } from "@anthropic-ai/sdk/resources";
 import { type ApiStream, type HandlerModelInfo, type ProviderConfig } from "../types";
 import type { Message, ToolDefinition } from "../types/messages";
 import { BaseHandler } from "./base";
@@ -18,7 +19,16 @@ export declare class AnthropicHandler extends BaseHandler {
     getMessages(_systemPrompt: string, messages: Message[]): Anthropic.MessageParam[];
     createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
     private createMessageInternal;
-    private processChunk;
+    protected processChunk(chunk: RawMessageStreamEvent, currentToolCall: {
+        id: string;
+        name: string;
+        arguments: string;
+    }, usageSnapshot: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+    }, responseId: string): Generator<import("../types").ApiStreamChunk>;
 }
 /**
  * Create an Anthropic handler

package/dist/providers/handlers/base.d.ts

@@ -44,6 +44,7 @@ export declare abstract class BaseHandler implements ApiHandler {
      * Abort the current request
      */
     abort(): void;
+    setAbortSignal(signal: AbortSignal | undefined): void;
     /**
      * Helper to calculate cost from usage
      */

package/dist/providers/types/handler.d.ts

@@ -51,6 +51,10 @@ export interface ApiHandler {
      * Abort the current request (optional)
      */
     abort?(): void;
+    /**
+     * Update the abort signal used for subsequent requests (optional).
+     */
+    setAbortSignal?(signal: AbortSignal | undefined): void;
 }
 /**
  * Handler for simple single-turn completions

package/dist/providers/types/messages.d.ts

@@ -103,6 +103,8 @@ export interface Message {
 export interface MessageWithMetadata extends Message {
     /** Unique message ID */
     id?: string;
+    /** Additional message metadata for storage/history consumers */
+    metadata?: Record<string, unknown>;
     /** Provider ID used to generate this message */
     providerId?: string;
     /** Model ID used to generate this message */

package/dist/providers/utils/tool-processor.d.ts

@@ -11,7 +11,7 @@ interface ToolCallDelta {
     id?: string;
     function?: {
         name?: string;
-        arguments?: string;
+        arguments?: unknown;
     };
 }
 /**
@@ -31,4 +31,5 @@ export declare class ToolCallProcessor {
      * Reset the processor state
      */
     reset(): void;
+    private normalizeArgumentsDelta;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@clinebot/llms",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "Config-driven SDK for selecting, extending, and instantiating LLM providers and models",
 	"main": "./dist/index.js",
 	"module": "./dist/index.js",

package/src/models/generated.ts

@@ -14,7 +14,7 @@ export const GENERATED_PROVIDER_MODELS: {
 	version: number;
 	providers: Record<string, Record<string, ModelInfo>>;
 } = {
-	version: 1773940480693,
+	version: 1774031158558,
 	providers: {
 		aihubmix: {
 			"claude-sonnet-4-6": {
@@ -5296,6 +5296,47 @@ export const GENERATED_PROVIDER_MODELS: {
 				},
 				releaseDate: "2026-03-18",
 			},
+			"openai/gpt-5.4-mini": {
+				id: "openai/gpt-5.4-mini",
+				name: "GPT-5.4 Mini",
+				contextWindow: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"reasoning",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 7.5e-7,
+					output: 0.0000045,
+					cacheRead: 7.5e-8,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+			},
+			"openai/gpt-5.4-nano": {
+				id: "openai/gpt-5.4-nano",
+				name: "GPT-5.4 Nano",
+				contextWindow: 400000,
+				maxTokens: 128000,
+				capabilities: [
+					"images",
+					"files",
+					"tools",
+					"structured_output",
+					"temperature",
+				],
+				pricing: {
+					input: 2e-7,
+					output: 0.00000125,
+					cacheRead: 2e-8,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-17",
+			},
 			"x-ai/grok-4.20-beta": {
 				id: "x-ai/grok-4.20-beta",
 				name: "Grok 4.20 Beta",
@@ -9194,6 +9235,20 @@ export const GENERATED_PROVIDER_MODELS: {
 				},
 				releaseDate: "2026-03-18",
 			},
+			"xiaomi/mimo-v2-pro": {
+				id: "xiaomi/mimo-v2-pro",
+				name: "MiMo V2 Pro",
+				contextWindow: 1000000,
+				maxTokens: 128000,
+				capabilities: ["tools", "reasoning", "temperature"],
+				pricing: {
+					input: 1,
+					output: 3,
+					cacheRead: 0.19999999999999998,
+					cacheWrite: 0,
+				},
+				releaseDate: "2026-03-18",
+			},
 			"openai/gpt-5.4-mini": {
 				id: "openai/gpt-5.4-mini",
 				name: "GPT 5.4 Mini",

package/src/models/providers/openai-codex.ts

@@ -7,10 +7,26 @@
 
 import { getGeneratedModelsForProvider } from "../generated-access";
 import type { ModelCollection, ModelInfo } from "../schemas/index";
-import { OPENAI_MODELS } from "./openai";
+
+function removeCustomToolCapability(model: ModelInfo): ModelInfo {
+	if (!model.capabilities?.includes("tools")) {
+		return model;
+	}
+
+	return {
+		...model,
+		capabilities: model.capabilities.filter(
+			(capability) => capability !== "tools",
+		),
+	};
+}
 
 export const OPENAI_CODEX_MODELS: Record<string, ModelInfo> =
-	getGeneratedModelsForProvider("openai");
+	Object.fromEntries(
+		Object.entries(getGeneratedModelsForProvider("openai")).map(
+			([modelId, model]) => [modelId, removeCustomToolCapability(model)],
+		),
+	);
 
 export const OPENAI_CODEX_DEFAULT_MODEL =
 	Object.keys(OPENAI_CODEX_MODELS)[0] ?? "gpt-5.3-codex";
@@ -26,5 +42,5 @@ export const OPENAI_CODEX_PROVIDER: ModelCollection = {
 		defaultModelId: OPENAI_CODEX_DEFAULT_MODEL,
 		capabilities: ["reasoning", "oauth"],
 	},
-	models: OPENAI_MODELS,
+	models: OPENAI_CODEX_MODELS,
 };

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

@@ -203,7 +203,7 @@ export class AnthropicHandler extends BaseHandler {
 		yield { type: "done", success: true, id: responseId };
 	}
 
-	private *processChunk(
+	protected *processChunk(
 		chunk: RawMessageStreamEvent,
 		currentToolCall: { id: string; name: string; arguments: string },
 		usageSnapshot: {
@@ -332,11 +332,13 @@ export class AnthropicHandler extends BaseHandler {
 			case "content_block_stop": {
 				// If we have a tool call, yield it
 				if (currentToolCall.id) {
-					let parsedArgs: Record<string, unknown>;
+					let parsedArgs: string | Record<string, unknown>;
 					try {
 						parsedArgs = JSON.parse(currentToolCall.arguments || "{}");
 					} catch {
-						parsedArgs = {};
+						// Preserve the raw JSON fragment so downstream can classify it
+						// as an invalid tool call instead of silently turning it into {}.
+						parsedArgs = currentToolCall.arguments;
 					}
 
 					yield {

package/src/providers/handlers/base.ts

@@ -102,6 +102,13 @@ export abstract class BaseHandler implements ApiHandler {
 		this.abortController?.abort();
 	}
 
+	setAbortSignal(signal: AbortSignal | undefined): void {
+		this.config.abortSignal = signal;
+		if (signal?.aborted) {
+			this.abortController?.abort(signal.reason);
+		}
+	}
+
 	/**
 	 * Helper to calculate cost from usage
 	 */

package/src/providers/handlers/codex.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { OPENAI_CODEX_PROVIDER } from "../../models/providers/openai-codex";
 import { CodexHandler } from "./community-sdk";
 
 const streamTextSpy = vi.fn();
@@ -120,4 +121,40 @@ describe("CodexHandler", () => {
 			"sk-test-key",
 		);
 	});
+
+	it("does not surface Codex native tool calls as local tool calls", async () => {
+		streamTextSpy.mockReturnValue({
+			fullStream: makeStreamParts([
+				{
+					type: "tool-call",
+					toolCallId: "codex-call-1",
+					toolName: "read_file",
+					args: { path: "README.md" },
+				},
+				{
+					type: "finish",
+					usage: { inputTokens: 8, outputTokens: 3 },
+				},
+			]),
+		});
+
+		const handler = new CodexHandler({
+			providerId: "openai-codex",
+			modelId: "gpt-5.3-codex",
+		});
+
+		const chunks: Array<Record<string, unknown>> = [];
+		for await (const chunk of handler.createMessage("System", [
+			{ role: "user", content: "Hi" },
+		])) {
+			chunks.push(chunk as unknown as Record<string, unknown>);
+		}
+
+		expect(chunks.map((chunk) => chunk.type)).toEqual(["usage", "done"]);
+	});
+
+	it("does not advertise custom tool capability for Codex models", () => {
+		const model = OPENAI_CODEX_PROVIDER.models["gpt-5.3-codex"];
+		expect(model?.capabilities).not.toContain("tools");
+	});
 });

package/src/providers/handlers/community-sdk.ts

@@ -145,7 +145,6 @@ export class CodexHandler extends AiSdkProviderHandler {
 	> {
 		return {
 			reasoningTypes: ["reasoning-delta", "reasoning"],
-			enableToolCalls: true,
 			toolCallArgsOrder: ["args", "input"],
 		};
 	}

package/src/providers/types/handler.ts

@@ -62,6 +62,11 @@ export interface ApiHandler {
 	 * Abort the current request (optional)
 	 */
 	abort?(): void;
+
+	/**
+	 * Update the abort signal used for subsequent requests (optional).
+	 */
+	setAbortSignal?(signal: AbortSignal | undefined): void;
 }
 
 /**

package/src/providers/types/messages.ts

@@ -121,6 +121,8 @@ export interface Message {
 export interface MessageWithMetadata extends Message {
 	/** Unique message ID */
 	id?: string;
+	/** Additional message metadata for storage/history consumers */
+	metadata?: Record<string, unknown>;
 	/** Provider ID used to generate this message */
 	providerId?: string;
 	/** Model ID used to generate this message */

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

@@ -33,6 +33,66 @@ describe("ToolCallProcessor", () => {
 		expect(second[0].tool_call.function.arguments).toBe(' -la"]}');
 	});
 
+	it("normalizes cumulative argument snapshots into deltas", () => {
+		const processor = new ToolCallProcessor();
+
+		const first = processor.processToolCallDeltas(
+			[
+				{
+					index: 0,
+					id: "call_1",
+					function: { name: "editor", arguments: '{"command":"create"' },
+				},
+			],
+			"resp_1",
+		);
+
+		const second = processor.processToolCallDeltas(
+			[
+				{
+					index: 0,
+					function: {
+						arguments: '{"command":"create","path":"/tmp/file.txt"}',
+					},
+				},
+			],
+			"resp_1",
+		);
+
+		expect(first).toHaveLength(1);
+		expect(second).toHaveLength(1);
+		expect(first[0].tool_call.function.arguments).toBe('{"command":"create"');
+		expect(second[0].tool_call.function.arguments).toBe(
+			',"path":"/tmp/file.txt"}',
+		);
+	});
+
+	it("serializes object-shaped arguments instead of concatenating [object Object]", () => {
+		const processor = new ToolCallProcessor();
+
+		const result = processor.processToolCallDeltas(
+			[
+				{
+					index: 0,
+					id: "call_1",
+					function: {
+						name: "editor",
+						arguments: {
+							command: "create",
+							path: "/tmp/file.txt",
+						},
+					},
+				},
+			],
+			"resp_1",
+		);
+
+		expect(result).toHaveLength(1);
+		expect(result[0].tool_call.function.arguments).toBe(
+			'{"command":"create","path":"/tmp/file.txt"}',
+		);
+	});
+
 	it("preserves tool call id/name for interleaved parallel deltas", () => {
 		const processor = new ToolCallProcessor();
 

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

@@ -18,7 +18,7 @@ interface ToolCallDelta {
 	id?: string;
 	function?: {
 		name?: string;
-		arguments?: string;
+		arguments?: unknown;
 	};
 }
 
@@ -61,7 +61,11 @@ export class ToolCallProcessor {
 			if (fn?.name) {
 				toolCall.name = fn.name;
 			}
-			const deltaArguments = fn?.arguments ?? "";
+			const rawArguments = fn?.arguments;
+			const deltaArguments = this.normalizeArgumentsDelta(
+				toolCall.arguments,
+				rawArguments,
+			);
 			if (deltaArguments) {
 				toolCall.arguments += deltaArguments;
 			}
@@ -108,4 +112,35 @@ export class ToolCallProcessor {
 	reset(): void {
 		this.toolCalls.clear();
 	}
+
+	private normalizeArgumentsDelta(
+		accumulatedArguments: string,
+		rawArguments: unknown,
+	): string {
+		if (rawArguments == null) {
+			return "";
+		}
+
+		const nextArguments =
+			typeof rawArguments === "string"
+				? rawArguments
+				: JSON.stringify(rawArguments);
+
+		if (!nextArguments) {
+			return "";
+		}
+
+		// Some OpenAI-compatible providers emit cumulative argument snapshots
+		// instead of true deltas. Convert those snapshots back into a suffix so
+		// downstream accumulation only happens once.
+		if (
+			accumulatedArguments &&
+			nextArguments.length >= accumulatedArguments.length &&
+			nextArguments.startsWith(accumulatedArguments)
+		) {
+			return nextArguments.slice(accumulatedArguments.length);
+		}
+
+		return nextArguments;
+	}
 }