@clinebot/llms 0.0.20 → 0.0.22

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

@@ -1,390 +0,0 @@
-import { convertToolsToAnthropic } from "../transform/anthropic-format";
-import {
-	type ApiStream,
-	type HandlerModelInfo,
-	type ProviderConfig,
-	supportsModelThinking,
-} from "../types";
-import type { Message, ToolDefinition } from "../types/messages";
-import { retryStream } from "../utils/retry";
-import { BaseHandler } from "./base";
-import { createBedrockClient } from "./bedrock-client";
-
-const CLAUDE_SONNET_1M_SUFFIX = ":1m";
-
-type AiModule = {
-	streamText: (input: Record<string, unknown>) => {
-		fullStream?: AsyncIterable<{ type?: string; [key: string]: unknown }>;
-		textStream?: AsyncIterable<string>;
-		usage?: Promise<{
-			inputTokens?: number;
-			outputTokens?: number;
-			reasoningTokens?: number;
-			cachedInputTokens?: number;
-			[key: string]: unknown;
-		}>;
-	};
-};
-
-let cachedAiModule: AiModule | undefined;
-const DEFAULT_THINKING_BUDGET_TOKENS = 1024;
-const DEFAULT_REASONING_EFFORT = "medium" as const;
-
-async function loadAiModule(): Promise<AiModule> {
-	if (cachedAiModule) {
-		return cachedAiModule;
-	}
-
-	const moduleName = "ai";
-	cachedAiModule = (await import(moduleName)) as AiModule;
-	return cachedAiModule;
-}
-
-type ModelMessagePart = Record<string, unknown>;
-type ModelMessage = {
-	role: "system" | "user" | "assistant" | "tool";
-	content: string | ModelMessagePart[];
-};
-
-/**
- * Handler for AWS Bedrock using AI SDK's Amazon Bedrock provider.
- *
- * This handler is async-lazy loaded via createHandlerAsync.
- */
-export class BedrockHandler extends BaseHandler {
-	private clientFactory: ((modelId: string) => unknown) | undefined;
-
-	private async ensureClientFactory(): Promise<(modelId: string) => unknown> {
-		if (!this.clientFactory) {
-			this.clientFactory = await createBedrockClient(
-				this.config,
-				this.getRequestHeaders(),
-			);
-		}
-		return this.clientFactory;
-	}
-
-	getModel(): HandlerModelInfo {
-		const modelId = this.config.modelId;
-		if (!modelId) {
-			throw new Error("Model ID is required. Set modelId in config.");
-		}
-
-		const modelInfo =
-			this.config.modelInfo ?? this.config.knownModels?.[modelId] ?? {};
-		return { id: modelId, info: { ...modelInfo, id: modelId } };
-	}
-
-	getMessages(systemPrompt: string, messages: Message[]): ModelMessage[] {
-		return toModelMessages(systemPrompt, messages);
-	}
-
-	async *createMessage(
-		systemPrompt: string,
-		messages: Message[],
-		tools?: ToolDefinition[],
-	): ApiStream {
-		yield* retryStream(
-			() => this.createMessageInternal(systemPrompt, messages, tools),
-			{ maxRetries: 4 },
-		);
-	}
-
-	private async *createMessageInternal(
-		systemPrompt: string,
-		messages: Message[],
-		tools?: ToolDefinition[],
-	): ApiStream {
-		const ai = await loadAiModule();
-		const factory = await this.ensureClientFactory();
-		const responseId = this.createResponseId();
-		const abortSignal = this.getAbortSignal();
-		const model = this.getModel();
-
-		let modelId = model.id;
-		const providerOptions: Record<string, unknown> = {};
-		const bedrockOptions: Record<string, unknown> = {};
-
-		if (modelId.endsWith(CLAUDE_SONNET_1M_SUFFIX)) {
-			modelId = modelId.slice(0, -CLAUDE_SONNET_1M_SUFFIX.length);
-			bedrockOptions.anthropicBeta = ["context-1m-2025-08-07"];
-		}
-
-		const thinkingSupported = supportsModelThinking(model.info);
-		const budgetTokens =
-			this.config.thinkingBudgetTokens ??
-			(this.config.thinking ? DEFAULT_THINKING_BUDGET_TOKENS : 0);
-		let reasoningEnabled = false;
-		if (
-			thinkingSupported &&
-			budgetTokens > 0 &&
-			modelId.includes("anthropic")
-		) {
-			bedrockOptions.reasoningConfig = { type: "enabled", budgetTokens };
-			reasoningEnabled = true;
-		} else if (thinkingSupported && modelId.includes("amazon.nova")) {
-			const reasoningEffort =
-				this.config.reasoningEffort ??
-				(this.config.thinking ? DEFAULT_REASONING_EFFORT : undefined);
-			if (reasoningEffort) {
-				bedrockOptions.reasoningConfig = {
-					type: "enabled",
-					maxReasoningEffort: reasoningEffort,
-				};
-				reasoningEnabled = true;
-			}
-		}
-
-		if (Object.keys(bedrockOptions).length > 0) {
-			providerOptions.bedrock = bedrockOptions;
-		}
-
-		const stream = ai.streamText({
-			model: factory(modelId),
-			messages: this.getMessages(systemPrompt, messages),
-			tools: toAiSdkTools(tools),
-			maxTokens: model.info.maxTokens ?? this.config.maxOutputTokens ?? 128_000,
-			temperature: reasoningEnabled ? undefined : (model.info.temperature ?? 0),
-			providerOptions:
-				Object.keys(providerOptions).length > 0 ? providerOptions : undefined,
-			abortSignal,
-		});
-
-		let usageEmitted = false;
-
-		if (stream.fullStream) {
-			for await (const part of stream.fullStream) {
-				const partType = part.type;
-
-				if (partType === "text-delta") {
-					const text =
-						(part.textDelta as string | undefined) ??
-						(part.delta as string | undefined);
-					if (text) {
-						yield { type: "text", text, id: responseId };
-					}
-					continue;
-				}
-
-				if (partType === "reasoning-delta" || partType === "reasoning") {
-					const reasoning =
-						(part.textDelta as string | undefined) ??
-						(part.reasoning as string | undefined);
-					if (reasoning) {
-						yield { type: "reasoning", reasoning, id: responseId };
-					}
-					continue;
-				}
-
-				if (partType === "tool-call") {
-					const toolCallId =
-						(part.toolCallId as string | undefined) ??
-						(part.id as string | undefined);
-					const toolName =
-						(part.toolName as string | undefined) ??
-						(part.name as string | undefined);
-					const args = (part.args as Record<string, unknown> | undefined) ?? {};
-
-					yield {
-						type: "tool_calls",
-						id: responseId,
-						tool_call: {
-							call_id: toolCallId,
-							function: {
-								name: toolName,
-								arguments: args,
-							},
-						},
-					};
-					continue;
-				}
-
-				if (partType === "error") {
-					const message =
-						(part.error as Error | undefined)?.message ??
-						"Bedrock stream failed";
-					throw new Error(message);
-				}
-
-				if (partType === "finish") {
-					const usage =
-						(part.usage as Record<string, unknown> | undefined) ?? {};
-					const inputTokens = numberOrZero(usage.inputTokens);
-					const outputTokens = numberOrZero(usage.outputTokens);
-					const thoughtsTokenCount = numberOrZero(usage.reasoningTokens);
-					const cacheReadTokens = numberOrZero(usage.cachedInputTokens);
-
-					yield {
-						type: "usage",
-						inputTokens: Math.max(0, inputTokens - cacheReadTokens),
-						outputTokens,
-						thoughtsTokenCount,
-						cacheReadTokens,
-						totalCost: this.calculateCostFromInclusiveInput(
-							inputTokens,
-							outputTokens,
-							cacheReadTokens,
-						),
-						id: responseId,
-					};
-					usageEmitted = true;
-				}
-			}
-		} else if (stream.textStream) {
-			for await (const text of stream.textStream) {
-				yield { type: "text", text, id: responseId };
-			}
-		}
-
-		if (!usageEmitted && stream.usage) {
-			const usage = await stream.usage;
-			const inputTokens = numberOrZero(usage.inputTokens);
-			const outputTokens = numberOrZero(usage.outputTokens);
-			const thoughtsTokenCount = numberOrZero(usage.reasoningTokens);
-			const cacheReadTokens = numberOrZero(usage.cachedInputTokens);
-
-			yield {
-				type: "usage",
-				inputTokens: Math.max(0, inputTokens - cacheReadTokens),
-				outputTokens,
-				thoughtsTokenCount,
-				cacheReadTokens,
-				totalCost: this.calculateCostFromInclusiveInput(
-					inputTokens,
-					outputTokens,
-					cacheReadTokens,
-				),
-				id: responseId,
-			};
-		}
-
-		yield { type: "done", success: true, id: responseId };
-	}
-}
-
-export function createBedrockHandler(config: ProviderConfig): BedrockHandler {
-	return new BedrockHandler(config);
-}
-
-function numberOrZero(value: unknown): number {
-	return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-function toAiSdkTools(
-	tools: ToolDefinition[] | undefined,
-): Record<string, unknown> | undefined {
-	if (!tools || tools.length === 0) {
-		return undefined;
-	}
-
-	// We keep the same schema shape used by Anthropic conversion.
-	const anthropicTools = convertToolsToAnthropic(tools);
-	return Object.fromEntries(
-		anthropicTools.map((tool) => [
-			tool.name,
-			{
-				description: tool.description,
-				inputSchema: tool.input_schema,
-			},
-		]),
-	);
-}
-
-function toModelMessages(
-	systemPrompt: string,
-	messages: Message[],
-): ModelMessage[] {
-	const result: ModelMessage[] = [{ role: "system", content: systemPrompt }];
-	const toolNamesById = new Map<string, string>();
-
-	for (const message of messages) {
-		if (typeof message.content === "string") {
-			result.push({ role: message.role, content: message.content });
-			continue;
-		}
-
-		if (message.role === "assistant") {
-			const parts: ModelMessagePart[] = [];
-			for (const block of message.content) {
-				if (block.type === "text") {
-					parts.push({ type: "text", text: block.text });
-					continue;
-				}
-
-				if (block.type === "tool_use") {
-					toolNamesById.set(block.id, block.name);
-					parts.push({
-						type: "tool-call",
-						toolCallId: block.id,
-						toolName: block.name,
-						args: block.input,
-					});
-				}
-			}
-
-			if (parts.length > 0) {
-				result.push({ role: "assistant", content: parts });
-			}
-			continue;
-		}
-
-		// User message (can include text/image/tool_result blocks)
-		const userParts: ModelMessagePart[] = [];
-
-		for (const block of message.content) {
-			if (block.type === "text") {
-				userParts.push({ type: "text", text: block.text });
-				continue;
-			}
-
-			if (block.type === "image") {
-				userParts.push({
-					type: "image",
-					image: Buffer.from(block.data, "base64"),
-					mediaType: block.mediaType,
-				});
-				continue;
-			}
-
-			if (block.type === "tool_result") {
-				if (userParts.length > 0) {
-					result.push({
-						role: "user",
-						content: userParts.splice(0, userParts.length),
-					});
-				}
-
-				result.push({
-					role: "tool",
-					content: [
-						{
-							type: "tool-result",
-							toolCallId: block.tool_use_id,
-							toolName: toolNamesById.get(block.tool_use_id) ?? "tool",
-							output: serializeToolResult(block.content),
-							isError: block.is_error ?? false,
-						},
-					],
-				});
-			}
-		}
-
-		if (userParts.length > 0) {
-			result.push({ role: "user", content: userParts });
-		}
-	}
-
-	return result;
-}
-
-function serializeToolResult(content: Message["content"] | string): string {
-	if (typeof content === "string") {
-		return content;
-	}
-
-	try {
-		return JSON.stringify(content);
-	} catch {
-		return String(content);
-	}
-}

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

@@ -1,100 +0,0 @@
-import type { ProviderConfig } from "../types";
-
-type BedrockFactory = (modelId: string) => unknown;
-
-let cachedCreateAmazonBedrock:
-	| ((options: {
-			region?: string;
-			accessKeyId?: string;
-			secretAccessKey?: string;
-			sessionToken?: string;
-			apiKey?: string;
-			baseURL?: string;
-			headers?: Record<string, string>;
-			credentialProvider?: () => PromiseLike<{
-				accessKeyId: string;
-				secretAccessKey: string;
-				sessionToken?: string;
-			}>;
-	  }) => BedrockFactory)
-	| undefined;
-
-let cachedFromNodeProviderChain:
-	| ((options?: { profile?: string }) => () => PromiseLike<{
-			accessKeyId: string;
-			secretAccessKey: string;
-			sessionToken?: string;
-	  }>)
-	| undefined;
-
-async function loadCreateAmazonBedrock() {
-	if (cachedCreateAmazonBedrock) {
-		return cachedCreateAmazonBedrock;
-	}
-
-	const moduleName = "@ai-sdk/amazon-bedrock";
-	const mod = (await import(moduleName)) as {
-		createAmazonBedrock?: typeof cachedCreateAmazonBedrock;
-	};
-	if (!mod.createAmazonBedrock) {
-		throw new Error(`Failed to load createAmazonBedrock from ${moduleName}`);
-	}
-
-	cachedCreateAmazonBedrock = mod.createAmazonBedrock;
-	return cachedCreateAmazonBedrock;
-}
-
-async function loadFromNodeProviderChain() {
-	if (cachedFromNodeProviderChain) {
-		return cachedFromNodeProviderChain;
-	}
-
-	const moduleName = "@aws-sdk/credential-providers";
-	const mod = (await import(moduleName)) as {
-		fromNodeProviderChain?: typeof cachedFromNodeProviderChain;
-	};
-	if (!mod.fromNodeProviderChain) {
-		throw new Error(`Failed to load fromNodeProviderChain from ${moduleName}`);
-	}
-
-	cachedFromNodeProviderChain = mod.fromNodeProviderChain;
-	return cachedFromNodeProviderChain;
-}
-
-export async function createBedrockClient(
-	config: ProviderConfig,
-	defaultHeaders: Record<string, string>,
-): Promise<BedrockFactory> {
-	const createAmazonBedrock = await loadCreateAmazonBedrock();
-
-	const region = config.region ?? "us-east-1";
-	const authentication = config.aws?.authentication;
-	const hasExplicitKeys = Boolean(
-		config.aws?.accessKey && config.aws?.secretKey,
-	);
-	const shouldUseCredentialChain =
-		authentication === "profile" ||
-		authentication === "iam" ||
-		(!authentication && !hasExplicitKeys && !config.apiKey);
-
-	let credentialProvider:
-		| ReturnType<Exclude<typeof cachedFromNodeProviderChain, undefined>>
-		| undefined;
-	if (shouldUseCredentialChain) {
-		const fromNodeProviderChain = await loadFromNodeProviderChain();
-		credentialProvider = fromNodeProviderChain({
-			profile: config.aws?.profile,
-		});
-	}
-
-	return createAmazonBedrock({
-		region,
-		accessKeyId: config.aws?.accessKey ?? undefined,
-		secretAccessKey: config.aws?.secretKey ?? undefined,
-		sessionToken: config.aws?.sessionToken ?? undefined,
-		apiKey: config.apiKey ?? undefined,
-		baseURL: config.aws?.endpoint ?? config.baseUrl ?? undefined,
-		headers: defaultHeaders,
-		credentialProvider,
-	});
-}

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

@@ -1,160 +0,0 @@
-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();
-const codexCliSpy = vi.fn((modelId: string) => ({ modelId }));
-let lastCreateCodexCliOptions: Record<string, unknown> | undefined;
-
-vi.mock("ai", () => ({
-	streamText: (input: unknown) => streamTextSpy(input),
-}));
-
-vi.mock("ai-sdk-provider-codex-cli", () => ({
-	codexCli: (modelId: string) => codexCliSpy(modelId),
-	createCodexCli: (options?: Record<string, unknown>) => {
-		lastCreateCodexCliOptions = options;
-		return (modelId: string) => codexCliSpy(modelId);
-	},
-}));
-
-async function* makeStreamParts(parts: unknown[]) {
-	for (const part of parts) {
-		yield part;
-	}
-}
-
-describe("CodexHandler", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-		lastCreateCodexCliOptions = undefined;
-	});
-
-	it("streams text and usage through AI SDK fullStream", async () => {
-		streamTextSpy.mockReturnValue({
-			fullStream: makeStreamParts([
-				{ type: "text-delta", textDelta: "Hello" },
-				{
-					type: "finish",
-					usage: { inputTokens: 12, outputTokens: 4 },
-				},
-			]),
-		});
-
-		const handler = new CodexHandler({
-			providerId: "openai-codex",
-			modelId: "gpt-5.2-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(codexCliSpy).toHaveBeenCalledWith("gpt-5.2-codex");
-		expect(chunks.map((chunk) => chunk.type)).toEqual([
-			"text",
-			"usage",
-			"done",
-		]);
-		expect(chunks[0]?.text).toBe("Hello");
-		expect(chunks[1]?.inputTokens).toBe(12);
-		expect(chunks[1]?.outputTokens).toBe(4);
-	});
-
-	it("uses a fallback model id when model is missing", () => {
-		const handler = new CodexHandler({
-			providerId: "openai-codex",
-			modelId: "",
-		});
-
-		expect(handler.getModel().id).toBe("gpt-5.3-codex");
-	});
-
-	it("does not map OAuth access tokens to OPENAI_API_KEY env", async () => {
-		streamTextSpy.mockReturnValue({
-			fullStream: makeStreamParts([{ type: "finish" }]),
-		});
-
-		const handler = new CodexHandler({
-			providerId: "openai-codex",
-			modelId: "gpt-5.3-codex",
-			apiKey: "oauth-token-shorthand",
-			accessToken: "oauth-access-token",
-		});
-
-		for await (const _chunk of handler.createMessage("System", [
-			{ role: "user", content: "Hi" },
-		])) {
-			// consume stream
-		}
-
-		const createOptions = lastCreateCodexCliOptions as
-			| { defaultSettings?: { env?: Record<string, string> } }
-			| undefined;
-		expect(createOptions?.defaultSettings?.env?.OPENAI_API_KEY).toBeUndefined();
-	});
-
-	it("maps explicit OpenAI API keys to OPENAI_API_KEY env", async () => {
-		streamTextSpy.mockReturnValue({
-			fullStream: makeStreamParts([{ type: "finish" }]),
-		});
-
-		const handler = new CodexHandler({
-			providerId: "openai-codex",
-			modelId: "gpt-5.3-codex",
-			apiKey: "sk-test-key",
-		});
-
-		for await (const _chunk of handler.createMessage("System", [
-			{ role: "user", content: "Hi" },
-		])) {
-			// consume stream
-		}
-
-		const createOptions = lastCreateCodexCliOptions as
-			| { defaultSettings?: { env?: Record<string, string> } }
-			| undefined;
-		expect(createOptions?.defaultSettings?.env?.OPENAI_API_KEY).toBe(
-			"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");
-	});
-});