@clinebot/llms 0.0.0

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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,123 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+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",
+		);
+	});
+});

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

@@ -0,0 +1,288 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ApiStreamChunk } from "../types";
+import {
+	ClaudeCodeHandler,
+	DifyHandler,
+	MistralHandler,
+	OpenCodeHandler,
+	SapAiCoreHandler,
+} from "./community-sdk";
+
+const streamTextSpy = vi.fn();
+const claudeCodeSpy = vi.fn((modelId: string) => ({ modelId }));
+const opencodeSpy = vi.fn((modelId: string) => ({ modelId }));
+const mistralSpy = vi.fn((modelId: string) => ({ modelId }));
+const difySpy = vi.fn(
+	(modelId: string, settings?: Record<string, unknown>) => ({
+		modelId,
+		settings,
+	}),
+);
+const sapAiProviderSpy = vi.fn((modelId: string) => ({ modelId }));
+let lastCreateSapAiProviderOptions: Record<string, unknown> | undefined;
+let lastCreateDifyProviderOptions: Record<string, unknown> | undefined;
+
+vi.mock("ai", () => ({
+	streamText: (input: unknown) => streamTextSpy(input),
+}));
+
+vi.mock("ai-sdk-provider-claude-code", () => ({
+	claudeCode: (modelId: string) => claudeCodeSpy(modelId),
+	createClaudeCode: () => (modelId: string) => claudeCodeSpy(modelId),
+}));
+
+vi.mock("ai-sdk-provider-opencode-sdk", () => ({
+	opencode: (modelId: string) => opencodeSpy(modelId),
+	createOpencode: () => (modelId: string) => opencodeSpy(modelId),
+}));
+
+vi.mock("@ai-sdk/mistral", () => ({
+	mistral: (modelId: string) => mistralSpy(modelId),
+	createMistral: () => (modelId: string) => mistralSpy(modelId),
+}));
+
+vi.mock("dify-ai-provider", () => ({
+	difyProvider: (modelId: string, settings?: Record<string, unknown>) =>
+		difySpy(modelId, settings),
+	createDifyProvider: (options?: Record<string, unknown>) => {
+		lastCreateDifyProviderOptions = options;
+		return (modelId: string, settings?: Record<string, unknown>) =>
+			difySpy(modelId, settings);
+	},
+}));
+
+vi.mock("@jerome-benoit/sap-ai-provider", () => ({
+	sapai: (modelId: string) => sapAiProviderSpy(modelId),
+	createSAPAIProvider: (options?: Record<string, unknown>) => {
+		lastCreateSapAiProviderOptions = options;
+		return (modelId: string) => sapAiProviderSpy(modelId);
+	},
+}));
+
+async function* makeStreamParts(parts: unknown[]) {
+	for (const part of parts) {
+		yield part;
+	}
+}
+
+describe("Community SDK handlers", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		lastCreateSapAiProviderOptions = undefined;
+		lastCreateDifyProviderOptions = undefined;
+	});
+
+	describe("ClaudeCodeHandler", () => {
+		it("streams text and usage through AI SDK fullStream", async () => {
+			streamTextSpy.mockReturnValue({
+				fullStream: makeStreamParts([
+					{ type: "text-delta", textDelta: "Hello" },
+					{
+						type: "finish",
+						usage: { inputTokens: 10, outputTokens: 3 },
+					},
+				]),
+			});
+
+			const handler = new ClaudeCodeHandler({
+				providerId: "claude-code",
+				modelId: "sonnet",
+			});
+
+			const chunks: ApiStreamChunk[] = [];
+			for await (const chunk of handler.createMessage("System", [
+				{ role: "user", content: "Hi" },
+			])) {
+				chunks.push(chunk);
+			}
+
+			expect(claudeCodeSpy).toHaveBeenCalledWith("sonnet");
+			expect(chunks.map((chunk) => chunk.type)).toEqual([
+				"text",
+				"usage",
+				"done",
+			]);
+			const textChunk = chunks.find(
+				(chunk): chunk is Extract<ApiStreamChunk, { type: "text" }> =>
+					chunk.type === "text",
+			);
+			const usageChunk = chunks.find(
+				(chunk): chunk is Extract<ApiStreamChunk, { type: "usage" }> =>
+					chunk.type === "usage",
+			);
+			expect(textChunk?.text).toBe("Hello");
+			expect(usageChunk?.inputTokens).toBe(10);
+			expect(usageChunk?.outputTokens).toBe(3);
+		});
+
+		it("uses a fallback model id when model is missing", () => {
+			const handler = new ClaudeCodeHandler({
+				providerId: "claude-code",
+				modelId: "",
+			});
+
+			expect(handler.getModel().id).toBe("sonnet");
+		});
+	});
+
+	describe("MistralHandler", () => {
+		it("uses a fallback model id when model is missing", () => {
+			const handler = new MistralHandler({
+				providerId: "mistral",
+				modelId: "",
+			});
+
+			expect(handler.getModel().id).toBe("mistral-medium-latest");
+		});
+	});
+
+	describe("DifyHandler", () => {
+		it("passes baseURL and apiKey model settings to dify provider", async () => {
+			streamTextSpy.mockReturnValue({
+				fullStream: makeStreamParts([{ type: "finish", usage: {} }]),
+			});
+
+			const handler = new DifyHandler({
+				providerId: "dify",
+				modelId: "workflow-123",
+				apiKey: "dify-key",
+				baseUrl: "https://dify.example.com/v1",
+			});
+
+			for await (const _chunk of handler.createMessage("System", [
+				{ role: "user", content: "Hi" },
+			])) {
+				// noop
+			}
+
+			expect(lastCreateDifyProviderOptions).toEqual({
+				baseURL: "https://dify.example.com/v1",
+			});
+			expect(difySpy).toHaveBeenCalledWith("workflow-123", {
+				responseMode: "blocking",
+				apiKey: "dify-key",
+			});
+		});
+	});
+
+	describe("OpenCodeHandler", () => {
+		it("streams text and usage through AI SDK fullStream", async () => {
+			streamTextSpy.mockReturnValue({
+				fullStream: makeStreamParts([
+					{ type: "text-delta", textDelta: "Hello" },
+					{
+						type: "finish",
+						usage: { inputTokens: 10, outputTokens: 3 },
+					},
+				]),
+			});
+
+			const handler = new OpenCodeHandler({
+				providerId: "opencode",
+				modelId: "gpt-5.1-codex",
+			});
+
+			const chunks: ApiStreamChunk[] = [];
+			for await (const chunk of handler.createMessage("System", [
+				{ role: "user", content: "Hi" },
+			])) {
+				chunks.push(chunk);
+			}
+
+			expect(opencodeSpy).toHaveBeenCalledWith("openai/gpt-5.1-codex");
+			expect(chunks.map((chunk) => chunk.type)).toEqual([
+				"text",
+				"usage",
+				"done",
+			]);
+			const textChunk = chunks.find(
+				(chunk): chunk is Extract<ApiStreamChunk, { type: "text" }> =>
+					chunk.type === "text",
+			);
+			const usageChunk = chunks.find(
+				(chunk): chunk is Extract<ApiStreamChunk, { type: "usage" }> =>
+					chunk.type === "usage",
+			);
+			expect(textChunk?.text).toBe("Hello");
+			expect(usageChunk?.inputTokens).toBe(10);
+			expect(usageChunk?.outputTokens).toBe(3);
+		});
+
+		it("uses full model IDs without changes", async () => {
+			streamTextSpy.mockReturnValue({
+				fullStream: makeStreamParts([{ type: "finish", usage: {} }]),
+			});
+
+			const handler = new OpenCodeHandler({
+				providerId: "opencode",
+				modelId: "openai/gpt-5.1-codex-max",
+			});
+
+			for await (const _chunk of handler.createMessage("System", [
+				{ role: "user", content: "Hi" },
+			])) {
+				// noop
+			}
+
+			expect(opencodeSpy).toHaveBeenCalledWith("openai/gpt-5.1-codex-max");
+		});
+	});
+
+	describe("SapAiCoreHandler", () => {
+		it("uses a fallback model id when model is missing", () => {
+			const handler = new SapAiCoreHandler({
+				providerId: "sapaicore",
+				modelId: "",
+			});
+
+			expect(handler.getModel().id).toBe("anthropic--claude-3.5-sonnet");
+		});
+
+		it("maps sap config to provider create options and streams text", async () => {
+			streamTextSpy.mockReturnValue({
+				fullStream: makeStreamParts([
+					{ type: "text-delta", textDelta: "Hello" },
+					{
+						type: "finish",
+						usage: { inputTokens: 10, outputTokens: 3 },
+					},
+				]),
+			});
+
+			const handler = new SapAiCoreHandler({
+				providerId: "sapaicore",
+				modelId: "gpt-4o",
+				sap: {
+					resourceGroup: "default",
+					deploymentId: "dep-123",
+					useOrchestrationMode: false,
+					defaultSettings: {
+						modelParams: { temperature: 0 },
+					},
+				},
+			});
+
+			const chunks: ApiStreamChunk[] = [];
+			for await (const chunk of handler.createMessage("System", [
+				{ role: "user", content: "Hi" },
+			])) {
+				chunks.push(chunk);
+			}
+
+			expect(sapAiProviderSpy).toHaveBeenCalledWith("gpt-4o");
+			expect(lastCreateSapAiProviderOptions).toEqual({
+				resourceGroup: "default",
+				deploymentId: "dep-123",
+				api: "foundation-models",
+				defaultSettings: {
+					modelParams: { temperature: 0 },
+				},
+			});
+			expect(chunks.map((chunk) => chunk.type)).toEqual([
+				"text",
+				"usage",
+				"done",
+			]);
+		});
+	});
+});