@clinebot/llms 0.0.6 → 0.0.10

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

@@ -13,41 +13,16 @@ export declare const DEFAULT_REQUEST_HEADERS: Record<string, string>;
 export declare abstract class BaseHandler implements ApiHandler {
     protected config: ProviderConfig;
     protected abortController: AbortController | undefined;
+    private abortSignalSequence;
     constructor(config: ProviderConfig);
-    /**
-     * Convert Cline messages to provider-specific format
-     * Must be implemented by subclasses
-     */
     abstract getMessages(systemPrompt: string, messages: Message[]): unknown;
-    /**
-     * Create a streaming message completion
-     * Must be implemented by subclasses
-     */
     abstract createMessage(systemPrompt: string, messages: Message[], tools?: ToolDefinition[]): ApiStream;
-    /**
-     * Get the current model configuration
-     * Can be overridden by subclasses for provider-specific logic
-     */
     getModel(): HandlerModelInfo;
-    /**
-     * Get usage information (optional)
-     * Override in subclasses that support this
-     */
     getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined>;
-    /**
-     * Get the abort signal for the current request
-     * Creates a new AbortController if one doesn't exist or was already aborted
-     * Combines with config.abortSignal if provided
-     */
     protected getAbortSignal(): AbortSignal;
-    /**
-     * Abort the current request
-     */
     abort(): void;
     setAbortSignal(signal: AbortSignal | undefined): void;
-    /**
-     * Helper to calculate cost from usage
-     */
+    private logAbort;
     protected calculateCost(inputTokens: number, outputTokens: number, cacheReadTokens?: number): number | undefined;
     protected createResponseId(): string;
     protected withResponseId<T extends ApiStreamChunk>(chunk: T, responseId: string): T;

package/dist/providers/transform/openai-format.d.ts

@@ -9,7 +9,7 @@ type OpenAIMessage = OpenAI.Chat.ChatCompletionMessageParam;
 /**
  * Convert messages to OpenAI format
  */
-export declare function convertToOpenAIMessages(messages: Message[]): OpenAIMessage[];
+export declare function convertToOpenAIMessages(messages: Message[], enableCaching?: boolean): OpenAIMessage[];
 /**
  * Convert tool definitions to OpenAI format
  */

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

@@ -187,6 +187,10 @@ export interface ProviderOptions {
     /** Runtime model catalog refresh configuration */
     modelCatalog?: ModelCatalogConfig;
 }
+/**
+ * Provider-specific options that don't fit other categories
+ */
+import type { BasicLogger } from "@clinebot/shared";
 /**
  * Runtime model catalog refresh options
  */
@@ -219,6 +223,8 @@ export interface ProviderConfig extends AuthConfig, EndpointConfig, ModelConfig,
     onRetryAttempt?: (attempt: number, maxRetries: number, delay: number, error: unknown) => void;
     /** AbortSignal for cancelling requests */
     abortSignal?: AbortSignal;
+    /** Optional runtime logger for provider-level diagnostics */
+    logger?: BasicLogger;
     /** Codex CLI-specific options */
     codex?: CodexConfig;
     /** Claude Code-specific options */

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,10 +1,11 @@
 {
 	"name": "@clinebot/llms",
-	"version": "0.0.6",
+	"version": "0.0.10",
 	"description": "Config-driven SDK for selecting, extending, and instantiating LLM providers and models",
 	"main": "./dist/index.js",
 	"module": "./dist/index.js",
 	"dependencies": {
+		"@clinebot/shared": "0.0.10",
 		"@ai-sdk/amazon-bedrock": "^4.0.67",
 		"@ai-sdk/google-vertex": "^4.0.74",
 		"@ai-sdk/mistral": "^3.0.24",

package/src/index.browser.ts

@@ -1,6 +1,6 @@
 export { defineLlmsConfig, loadLlmsConfigFromFile } from "./config-browser";
-export * as models from "./models/index";
-export * as providers from "./providers/public.browser";
+export * as LlmsModels from "./models/index";
+export * as LlmsProviders from "./providers/public.browser";
 export type {
 	CustomProviderConfig,
 	LlmsConfig,

package/src/index.ts

@@ -1,6 +1,6 @@
 export { defineLlmsConfig } from "./config";
-export * as models from "./models/index";
-export * as providers from "./providers/public";
+export * as LlmsModels from "./models/index";
+export * as LlmsProviders from "./providers/public";
 export { createLlmsSdk } from "./sdk";
 export type {
 	CustomProviderConfig,

package/src/models/generated.ts

@@ -14,7 +14,7 @@ export const GENERATED_PROVIDER_MODELS: {
 	version: number;
 	providers: Record<string, Record<string, ModelInfo>>;
 } = {
-	version: 1773975012193,
+	version: 1774031158558,
 	providers: {
 		aihubmix: {
 			"claude-sonnet-4-6": {
@@ -9235,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/models/providers/vercel-ai-gateway.ts

@@ -14,7 +14,7 @@ export const VERCEL_AI_GATEWAY_PROVIDER: ModelCollection = {
 		name: "Vercel AI Gateway",
 		description: "Vercel's AI gateway service",
 		protocol: "openai-chat",
-		baseUrl: "https://ai-gateway.vercel.app/v1",
+		baseUrl: "https://ai-gateway.vercel.sh/v1",
 		defaultModelId: Object.keys(VERCEL_AI_GATEWAY_MODELS)[0],
 		capabilities: ["reasoning"],
 		env: ["AI_GATEWAY_API_KEY"],

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

@@ -145,7 +145,8 @@ export class AnthropicHandler extends BaseHandler {
 				thinking: reasoningOn
 					? { type: "enabled", budget_tokens: budgetTokens }
 					: undefined,
-				max_tokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 8192,
+				max_tokens:
+					model.info.maxTokens ?? this.config.maxOutputTokens ?? 128_000,
 				temperature: reasoningOn ? undefined : 0,
 				system: supportsPromptCache
 					? [
@@ -173,6 +174,7 @@ export class AnthropicHandler extends BaseHandler {
 			cacheReadTokens: 0,
 			cacheWriteTokens: 0,
 		};
+		let stopReason: string | null = null;
 
 		for await (const chunk of stream) {
 			if (debugThinking) {
@@ -185,6 +187,11 @@ export class AnthropicHandler extends BaseHandler {
 					countChunk(`content_block_delta:${chunk.delta?.type ?? "unknown"}`);
 				}
 			}
+			if (chunk.type === "message_delta") {
+				stopReason =
+					(chunk as { delta?: { stop_reason?: string } }).delta?.stop_reason ??
+					stopReason;
+			}
 			yield* this.withResponseIdForAll(
 				this.processChunk(chunk, currentToolCall, usageSnapshot, responseId),
 				responseId,
@@ -199,11 +206,15 @@ export class AnthropicHandler extends BaseHandler {
 			console.error(`[thinking-debug][anthropic][stream] ${summary}`);
 		}
 
-		// Yield done chunk to indicate streaming completed successfully
-		yield { type: "done", success: true, id: responseId };
+		yield {
+			type: "done",
+			success: true,
+			id: responseId,
+			incompleteReason: stopReason === "max_tokens" ? "max_tokens" : undefined,
+		};
 	}
 
-	private *processChunk(
+	protected *processChunk(
 		chunk: RawMessageStreamEvent,
 		currentToolCall: { id: string; name: string; arguments: string },
 		usageSnapshot: {
@@ -332,11 +343,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.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { ApiStream, ProviderConfig } from "../types/index";
 import { BaseHandler } from "./base";
 
@@ -18,6 +18,10 @@ class TestHandler extends BaseHandler {
 	): number | undefined {
 		return this.calculateCost(inputTokens, outputTokens, cacheReadTokens);
 	}
+
+	public exposeAbortSignal(): AbortSignal {
+		return this.getAbortSignal();
+	}
 }
 
 describe("BaseHandler.calculateCost", () => {
@@ -44,3 +48,58 @@ describe("BaseHandler.calculateCost", () => {
 		expect(cost).toBeCloseTo(17.73, 6);
 	});
 });
+
+describe("BaseHandler abort signal wiring", () => {
+	it("does not let a stale request signal abort a newer request", () => {
+		const logger = {
+			debug: vi.fn(),
+			warn: vi.fn(),
+		};
+		const request1 = new AbortController();
+		const handler = new TestHandler({
+			providerId: "openrouter",
+			modelId: "mock-model",
+			apiKey: "test-key",
+			baseUrl: "https://example.com/v1",
+			abortSignal: request1.signal,
+			logger,
+		});
+
+		const signal1 = handler.exposeAbortSignal();
+		expect(signal1.aborted).toBe(false);
+
+		const request2 = new AbortController();
+		handler.setAbortSignal(request2.signal);
+		const signal2 = handler.exposeAbortSignal();
+		expect(signal2).not.toBe(signal1);
+		expect(signal2.aborted).toBe(false);
+
+		request1.abort(new Error("stale timeout"));
+
+		expect(signal1.aborted).toBe(true);
+		expect(signal2.aborted).toBe(false);
+		expect(logger.warn).toHaveBeenCalledWith(
+			"Provider request abort signal fired",
+			expect.objectContaining({
+				reason: expect.objectContaining({ message: "stale timeout" }),
+			}),
+		);
+	});
+
+	it("creates a fresh controller for each request", () => {
+		const handler = new TestHandler({
+			providerId: "openrouter",
+			modelId: "mock-model",
+			apiKey: "test-key",
+			baseUrl: "https://example.com/v1",
+			abortSignal: new AbortController().signal,
+		});
+
+		const signal1 = handler.exposeAbortSignal();
+		const signal2 = handler.exposeAbortSignal();
+
+		expect(signal2).not.toBe(signal1);
+		expect(signal1.aborted).toBe(false);
+		expect(signal2.aborted).toBe(false);
+	});
+});

package/src/providers/handlers/base.ts

@@ -22,37 +22,44 @@ export const DEFAULT_REQUEST_HEADERS: Record<string, string> = {
 	"X-CLIENT-TYPE": "cline-sdk",
 };
 
+const controllerIds = new WeakMap<AbortController, string>();
+let controllerIdCounter = 0;
+
+function getControllerId(controller: AbortController): string {
+	let id = controllerIds.get(controller);
+	if (!id) {
+		id = `abort_${++controllerIdCounter}`;
+		controllerIds.set(controller, id);
+	}
+	return id;
+}
+
+function serializeAbortReason(reason: unknown): unknown {
+	return reason instanceof Error
+		? { name: reason.name, message: reason.message }
+		: reason;
+}
+
 /**
  * Base handler class with common functionality
  */
 export abstract class BaseHandler implements ApiHandler {
 	protected config: ProviderConfig;
 	protected abortController: AbortController | undefined;
+	private abortSignalSequence = 0;
 
 	constructor(config: ProviderConfig) {
 		this.config = config;
 	}
 
-	/**
-	 * Convert Cline messages to provider-specific format
-	 * Must be implemented by subclasses
-	 */
 	abstract getMessages(systemPrompt: string, messages: Message[]): unknown;
 
-	/**
-	 * Create a streaming message completion
-	 * Must be implemented by subclasses
-	 */
 	abstract createMessage(
 		systemPrompt: string,
 		messages: Message[],
 		tools?: ToolDefinition[],
 	): ApiStream;
 
-	/**
-	 * Get the current model configuration
-	 * Can be overridden by subclasses for provider-specific logic
-	 */
 	getModel(): HandlerModelInfo {
 		const modelId = this.config.modelId;
 		return {
@@ -61,43 +68,55 @@ export abstract class BaseHandler implements ApiHandler {
 		};
 	}
 
-	/**
-	 * Get usage information (optional)
-	 * Override in subclasses that support this
-	 */
 	async getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined> {
 		return undefined;
 	}
 
-	/**
-	 * Get the abort signal for the current request
-	 * Creates a new AbortController if one doesn't exist or was already aborted
-	 * Combines with config.abortSignal if provided
-	 */
 	protected getAbortSignal(): AbortSignal {
-		// Create a new controller if needed
-		if (!this.abortController || this.abortController.signal.aborted) {
-			this.abortController = new AbortController();
-		}
-
-		// If a signal was provided in config, chain it
-		if (this.config.abortSignal) {
-			const configSignal = this.config.abortSignal;
+		const controller = new AbortController();
+		this.abortController = controller;
+		controller.signal.addEventListener(
+			"abort",
+			() => {
+				if (this.abortController === controller) {
+					this.abortController = undefined;
+				}
+			},
+			{ once: true },
+		);
+
+		const configSignal = this.config.abortSignal;
+		if (configSignal) {
 			if (configSignal.aborted) {
-				this.abortController.abort(configSignal.reason);
+				this.logAbort("debug", "Provider request inherited aborted signal", {
+					controllerId: getControllerId(controller),
+					reason: serializeAbortReason(configSignal.reason),
+				});
+				controller.abort(configSignal.reason);
 			} else {
-				configSignal.addEventListener("abort", () => {
-					this.abortController?.abort(configSignal.reason);
+				const signalId = ++this.abortSignalSequence;
+				configSignal.addEventListener(
+					"abort",
+					() => {
+						this.logAbort("warn", "Provider request abort signal fired", {
+							controllerId: getControllerId(controller),
+							signalId,
+							reason: serializeAbortReason(configSignal.reason),
+						});
+						controller.abort(configSignal.reason);
+					},
+					{ once: true },
+				);
+				this.logAbort("debug", "Provider request attached abort signal", {
+					controllerId: getControllerId(controller),
+					signalId,
 				});
 			}
 		}
 
-		return this.abortController.signal;
+		return controller.signal;
 	}
 
-	/**
-	 * Abort the current request
-	 */
 	abort(): void {
 		this.abortController?.abort();
 	}
@@ -105,37 +124,47 @@ export abstract class BaseHandler implements ApiHandler {
 	setAbortSignal(signal: AbortSignal | undefined): void {
 		this.config.abortSignal = signal;
 		if (signal?.aborted) {
+			this.logAbort("debug", "Provider handler received pre-aborted signal", {
+				controllerId: this.abortController
+					? getControllerId(this.abortController)
+					: undefined,
+				reason: serializeAbortReason(signal.reason),
+			});
 			this.abortController?.abort(signal.reason);
 		}
 	}
 
-	/**
-	 * Helper to calculate cost from usage
-	 */
+	private logAbort(
+		level: "debug" | "warn",
+		message: string,
+		metadata?: Record<string, unknown>,
+	): void {
+		this.config.logger?.[level]?.(message, {
+			providerId: this.config.providerId,
+			modelId: this.config.modelId,
+			...metadata,
+		});
+	}
+
 	protected calculateCost(
 		inputTokens: number,
 		outputTokens: number,
 		cacheReadTokens = 0,
 	): number | undefined {
-		const modelPricingSource =
-			this.config.modelInfo ??
-			(this.config.modelId
-				? this.config.knownModels?.[this.config.modelId]
-				: undefined);
-		const pricing = modelPricingSource?.pricing;
+		const pricing = (
+			this.config.modelInfo ?? this.config.knownModels?.[this.config.modelId]
+		)?.pricing;
 		if (!pricing?.input || !pricing?.output) {
 			return undefined;
 		}
 
-		const uncachedInputTokens = inputTokens - cacheReadTokens;
-		const inputCost = (uncachedInputTokens / 1_000_000) * pricing.input;
-		const outputCost = (outputTokens / 1_000_000) * pricing.output;
-		const cacheReadCost =
-			cacheReadTokens > 0
+		return (
+			((inputTokens - cacheReadTokens) / 1_000_000) * pricing.input +
+			(outputTokens / 1_000_000) * pricing.output +
+			(cacheReadTokens > 0
 				? (cacheReadTokens / 1_000_000) * (pricing.cacheRead ?? 0)
-				: 0;
-
-		return inputCost + outputCost + cacheReadCost;
+				: 0)
+		);
 	}
 
 	protected createResponseId(): string {
@@ -154,7 +183,7 @@ export abstract class BaseHandler implements ApiHandler {
 		responseId: string,
 	): Generator<ApiStreamChunk> {
 		for (const chunk of chunks) {
-			yield this.withResponseId(chunk, responseId);
+			yield { ...chunk, id: responseId };
 		}
 	}
 

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

@@ -143,7 +143,7 @@ export class BedrockHandler extends BaseHandler {
 			model: factory(modelId),
 			messages: this.getMessages(systemPrompt, messages),
 			tools: toAiSdkTools(tools),
-			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 8192,
+			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 128_000,
 			temperature: reasoningEnabled ? undefined : (model.info.temperature ?? 0),
 			providerOptions:
 				Object.keys(providerOptions).length > 0 ? providerOptions : undefined,

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"],
 		};
 	}