@ank1015/providers 0.0.1 → 0.0.2

package/src/providers/openai.ts

@@ -1,437 +0,0 @@
-// Return a abstracted event stream
-// Return the final response as it is.
-import OpenAI from "openai";
-import { AssistantMessageEventStream } from "../utils/event-stream";
-import { StreamFunction, Model, Context, Tool, Api, AssistantMessage, AssistantThinkingContent, AssistantTextContent, AssistantToolCall, StopReason } from "../types";
-import { buildOpenAIMessages } from "./convert";
-import { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
-import type {Tool as OpenAITool, ResponseFunctionToolCall, ResponseOutputMessage, ResponseReasoningItem,} from "openai/resources/responses/responses.js";
-import { parseStreamingJson } from "../utils/json-parse";
-import { validateToolArguments } from "../utils/validation";
-import { calculateCost } from "../models";
-import { Response } from "openai/resources/responses/responses.js";
-export interface OpenAIProviderOptions {
-	apiKey?: string;
-	signal?: AbortSignal;
-	maxOutputTokens?: number;
-	parallelToolCalls?: boolean;
-	prompt_cache_key?: string;
-	promptCacheRetention?: 'in-memory' | '24h' | null;
-	reasoning?: {
-		effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | null;
-		summary?: 'auto' | 'concise' | 'detailed' | null;
-	};
-	temperature?: number;
-	truncation?: 'auto' | 'disabled' | null;
-}
-
-// takes in model, built in message
-export const streamOpenAI: StreamFunction<'openai'> = (
-    model: Model<'openai'>,
-    context: Context,
-    options: OpenAIProviderOptions
-) => {
-
-    const stream = new AssistantMessageEventStream();
-
-	// Start async processing
-	(async () => {
-		const output: AssistantMessage = {
-			role: "assistant",
-			content: [],
-			api: "openai" as Api,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-			},
-			stopReason: "stop",
-			timestamp: Date.now(),
-		};
-		let finalResponse: Response = {
-			id: "resp_123",
-			object: "response",
-			created_at: 1740855869,
-			output_text: '',
-			status: "completed",
-			incomplete_details: null,
-			parallel_tool_calls: false,
-			error: null,
-			instructions: null,
-			max_output_tokens: null,
-			model: "gpt-4o-mini-2024-07-18",
-			output: [],
-			previous_response_id: null,
-			temperature: 1,
-			text: {},
-			tool_choice: "auto",
-			tools: [],
-			top_p: 1,
-			truncation: "disabled",
-			usage: {
-			  input_tokens: 0,
-			  output_tokens: 0,
-			  output_tokens_details: {
-				reasoning_tokens: 0
-			  },
-			  input_tokens_details: {
-				cached_tokens: 0
-			  },
-			  total_tokens: 0
-			},
-			user: undefined,
-			metadata: {}
-		  }
-		try {
-			const client = createClient(model, options?.apiKey);
-			const params = buildParams(model, context, options);
-			const openaiStream = await client.responses.create(params, { signal: options?.signal });
-			stream.push({ type: "start", partial: output });
-
-			let currentItem: ResponseReasoningItem | ResponseOutputMessage | ResponseFunctionToolCall | null = null;
-			let currentBlock: AssistantThinkingContent | AssistantTextContent | (AssistantToolCall & { partialJson: string }) | null = null;
-			const blocks = output.content;
-			const blockIndex = () => blocks.length - 1;
-
-			for await (const event of openaiStream) {
-				// Handle output item start
-				if (event.type === "response.output_item.added") {
-					const item = event.item;
-					if (item.type === "reasoning") {
-						currentItem = item;
-						currentBlock = { type: "thinking", thinking: "" };
-						output.content.push(currentBlock);
-						stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-					} else if (item.type === "message") {
-						currentItem = item;
-						currentBlock = { type: "text", text: "" };
-						output.content.push(currentBlock);
-						stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-					} else if (item.type === "function_call") {
-						currentItem = item;
-						currentBlock = {
-							type: "toolCall",
-							id: item.call_id,
-							name: item.name,
-							arguments: {},
-							partialJson: item.arguments || "",
-						};
-						output.content.push(currentBlock);
-						stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-					}
-				}
-				// Handle reasoning summary deltas
-				else if (event.type === "response.reasoning_summary_part.added") {
-					if (currentItem && currentItem.type === "reasoning") {
-						currentItem.summary = currentItem.summary || [];
-						currentItem.summary.push(event.part);
-					}
-				} else if (event.type === "response.reasoning_summary_text.delta") {
-					if (
-						currentItem &&
-						currentItem.type === "reasoning" &&
-						currentBlock &&
-						currentBlock.type === "thinking"
-					) {
-						currentItem.summary = currentItem.summary || [];
-						const lastPart = currentItem.summary[currentItem.summary.length - 1];
-						if (lastPart) {
-							currentBlock.thinking += event.delta;
-							lastPart.text += event.delta;
-							stream.push({
-								type: "thinking_delta",
-								contentIndex: blockIndex(),
-								delta: event.delta,
-								partial: output,
-							});
-						}
-					}
-				}
-				// Add a new line between summary parts (hack...)
-				else if (event.type === "response.reasoning_summary_part.done") {
-					if (
-						currentItem &&
-						currentItem.type === "reasoning" &&
-						currentBlock &&
-						currentBlock.type === "thinking"
-					) {
-						currentItem.summary = currentItem.summary || [];
-						const lastPart = currentItem.summary[currentItem.summary.length - 1];
-						if (lastPart) {
-							currentBlock.thinking += "\n\n";
-							lastPart.text += "\n\n";
-							stream.push({
-								type: "thinking_delta",
-								contentIndex: blockIndex(),
-								delta: "\n\n",
-								partial: output,
-							});
-						}
-					}
-				}
-				// Handle text output deltas
-				else if (event.type === "response.content_part.added") {
-					if (currentItem && currentItem.type === "message") {
-						currentItem.content = currentItem.content || [];
-						currentItem.content.push(event.part as any);
-					}
-				} else if (event.type === "response.output_text.delta") {
-					if (currentItem && currentItem.type === "message" && currentBlock && currentBlock.type === "text") {
-						const lastPart = currentItem.content[currentItem.content.length - 1];
-						if (lastPart && lastPart.type === "output_text") {
-							currentBlock.text += event.delta;
-							lastPart.text += event.delta;
-							stream.push({
-								type: "text_delta",
-								contentIndex: blockIndex(),
-								delta: event.delta,
-								partial: output,
-							});
-						}
-					}
-				} else if (event.type === "response.refusal.delta") {
-					if (currentItem && currentItem.type === "message" && currentBlock && currentBlock.type === "text") {
-						const lastPart = currentItem.content[currentItem.content.length - 1];
-						if (lastPart && lastPart.type === "refusal") {
-							currentBlock.text += event.delta;
-							lastPart.refusal += event.delta;
-							stream.push({
-								type: "text_delta",
-								contentIndex: blockIndex(),
-								delta: event.delta,
-								partial: output,
-							});
-						}
-					}
-				}
-				// Handle function call argument deltas
-				else if (event.type === "response.function_call_arguments.delta") {
-					if (
-						currentItem &&
-						currentItem.type === "function_call" &&
-						currentBlock &&
-						currentBlock.type === "toolCall"
-					) {
-						currentBlock.partialJson += event.delta;
-						currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
-						stream.push({
-							type: "toolcall_delta",
-							contentIndex: blockIndex(),
-							delta: event.delta,
-							partial: output,
-						});
-					}
-				}
-				// Handle output item completion
-				else if (event.type === "response.output_item.done") {
-					const item = event.item;
-
-					if (item.type === "reasoning" && currentBlock && currentBlock.type === "thinking") {
-						currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
-						stream.push({
-							type: "thinking_end",
-							contentIndex: blockIndex(),
-							content: currentBlock.thinking,
-							partial: output,
-						});
-						currentBlock = null;
-					} else if (item.type === "message" && currentBlock && currentBlock.type === "text") {
-						currentBlock.text = item.content.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("");
-						stream.push({
-							type: "text_end",
-							contentIndex: blockIndex(),
-							content: currentBlock.text,
-							partial: output,
-						});
-						currentBlock = null;
-					} else if (item.type === "function_call") {
-						const toolCall: AssistantToolCall = {
-							type: "toolCall",
-							id: item.call_id,
-							name: item.name,
-							arguments: JSON.parse(item.arguments),
-						};
-
-						// Validate tool arguments if tool definition is available
-						if (context.tools) {
-							const tool = context.tools.find((t) => t.name === toolCall.name);
-							if (tool) {
-								toolCall.arguments = validateToolArguments(tool, toolCall) as Record<string, any>;
-							}
-						}
-
-						stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
-					}
-				}
-				// Handle completion
-				else if (event.type === "response.completed") {
-					const response = event.response;
-					// Update the final Response
-					finalResponse = response
-					if (response?.usage) {
-						const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
-						output.usage = {
-							// OpenAI includes cached tokens in input_tokens, so subtract to get non-cached input
-							input: (response.usage.input_tokens || 0) - cachedTokens,
-							output: response.usage.output_tokens || 0,
-							cacheRead: cachedTokens,
-							cacheWrite: 0,
-							totalTokens: response.usage.total_tokens || 0,
-							cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-						};
-					}
-					calculateCost(model, output.usage);
-					// Map status to stop reason
-					output.stopReason = mapStopReason(response?.status);
-					if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
-						output.stopReason = "toolUse";
-					}
-				}
-				// Handle errors
-				else if (event.type === "error") {
-					throw new Error(`OpenAI API Error (${event.code}): ${event.message}` || "Unknown OpenAI error");
-				} else if (event.type === "response.failed") {
-					throw new Error("OpenAI response failed without error details");
-				}
-			}
-			if (options?.signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				throw new Error(
-					`Stream ended with status: ${output.stopReason}${output.errorMessage ? ` - ${output.errorMessage}` : ""}`
-				);
-			}
-
-			stream.push({ type: "done", reason: output.stopReason, message: output });
-			stream.end({
-				_provider: 'openai',
-				role: 'assistant',
-				message: finalResponse
-			});
-		}catch(error){
-			for (const block of output.content) delete (block as any).index;
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-
-			// Update finalResponse to reflect the error state
-			finalResponse.status = options?.signal?.aborted ? "cancelled" : "failed";
-			finalResponse.error = error instanceof Error ? {
-				message: error.message,
-				code: (error as any).code || "unknown_error",
-				type: error.name || "Error"
-			} as any : { message: String(error) } as any;
-
-			stream.end({
-				_provider: 'openai',
-				role: 'assistant',
-				message: finalResponse
-			});
-		}
-    })()
-
-    return stream;
-}
-
-
-function createClient(model: Model<"openai">, apiKey?: string) {
-	if (!apiKey) {
-		if (!process.env.OPENAI_API_KEY) {
-			throw new Error(
-				"OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.",
-			);
-		}
-		apiKey = process.env.OPENAI_API_KEY;
-	}
-	return new OpenAI({
-		apiKey,
-		baseURL: model.baseUrl,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: model.headers,
-	});
-}
-
-function buildParams(model: Model<"openai">, context: Context, options?: OpenAIProviderOptions){
-	const messages = buildOpenAIMessages(model, context);
-
-	const params: ResponseCreateParamsStreaming = {
-		include: ['reasoning.encrypted_content'],
-		input: messages,
-		model: model.id,
-		stream: true
-	}
-
-	if(options?.maxOutputTokens){
-		params.max_output_tokens = options.maxOutputTokens;
-	}
-
-	if(options?.parallelToolCalls){
-		params.parallel_tool_calls = options.parallelToolCalls;
-	}
-
-	if(options?.prompt_cache_key){
-		params.prompt_cache_key = options.prompt_cache_key;
-	}
-
-	if(options?.promptCacheRetention){
-		params.prompt_cache_retention = options.promptCacheRetention;
-	}
-
-	if(options?.reasoning){
-		params.reasoning = {
-			effort: options.reasoning.effort ||  "medium",
-			summary: options.reasoning.summary || "auto"
-		}
-	}
-
-	if(options?.temperature){
-		params.temperature = options.temperature
-	}
-
-	if(context.tools){
-		params.tools = convertTools(context.tools)
-	}
-
-	if(options?.truncation){
-		params.truncation = options.truncation
-	}
-
-	return params;
-}
-
-function convertTools(tools: readonly Tool[]): OpenAITool[] {
-	return tools.map((tool) => ({
-		type: "function",
-		name: tool.name,
-		description: tool.description,
-		parameters: tool.parameters as any, // TypeBox already generates JSON Schema
-		strict: null,
-	}));
-}
-
-function mapStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason {
-	if (!status) return "stop";
-	switch (status) {
-		case "completed":
-			return "stop";
-		case "incomplete":
-			return "length";
-		case "failed":
-		case "cancelled":
-			return "error";
-		// These two are wonky ...
-		case "in_progress":
-		case "queued":
-			return "stop";
-		default: {
-			const _exhaustive: never = status;
-			throw new Error(`Unhandled stop reason: ${_exhaustive}`);
-		}
-	}
-}

package/src/stream.ts

@@ -1,60 +0,0 @@
-import type { Model, Context, Api, OptionsForApi } from "./types";
-import { AssistantMessageEventStream } from "./utils/event-stream";
-import { streamOpenAI, OpenAIProviderOptions } from "./providers/openai";
-import { streamGoogle, GoogleProviderOptions } from "./providers/google";
-
-const envMap: Record<Api, string> = {
-	openai: "OPENAI_API_KEY",
-	// anthropic: "ANTHROPIC_API_KEY",
-	google: "GEMINI_API_KEY",
-	// groq: "GROQ_API_KEY",
-	// cerebras: "CEREBRAS_API_KEY",
-	// xai: "XAI_API_KEY",
-	// openrouter: "OPENROUTER_API_KEY",
-	// zai: "ZAI_API_KEY",
-};
-
-
-function getApiKeyFromEnv(api: Api){
-    const envVar = envMap[api]
-    return process.env[envVar]
-}
-
-export function stream<TApi extends Api>(
-	model: Model<TApi>,
-	context: Context,
-	options?: OptionsForApi<TApi>,
-): AssistantMessageEventStream {
-
-    const apiKey = options?.apiKey !== undefined ? options.apiKey : getApiKeyFromEnv(model.api)
-    if(!apiKey){
-		throw new Error(`No API key for provider: ${model.api}`);
-    }
-
-	const providerOptions = { ...options, apiKey };
-
-	// Switch directly on model.api and use type assertions for each provider
-	switch (model.api) {
-        case 'openai':
-            // TypeScript knows this branch only runs when model.api === 'openai'
-            return streamOpenAI(
-				model as Model<'openai'>,
-				context,
-				providerOptions as OpenAIProviderOptions
-			);
-
-		case 'google':
-            // TypeScript knows this branch only runs when model.api === 'google'
-			return streamGoogle(
-				model as Model<'google'>,
-				context,
-				providerOptions as GoogleProviderOptions
-			);
-
-        default: {
-			const _exhaustive: never = model.api;
-			throw new Error(`Unhandled API: ${_exhaustive}`);
-        }
-    }
-
-}

package/src/types.ts

@@ -1,198 +0,0 @@
-import { Response } from "openai/resources/responses/responses.js";
-import type { TSchema } from "@sinclair/typebox";
-import { OpenAIProviderOptions } from "./providers/openai";
-import { AssistantMessageEventStream } from "./utils/event-stream";
-import { GoogleProviderOptions } from "./providers/google";
-import type { GenerateContentResponse } from "@google/genai";
-
-export type Api = 'openai' | 'google'
-
-export interface Model<TApi extends Api> {
-	id: string;
-	name: string;
-	api: TApi;
-	baseUrl: string;
-	reasoning: boolean;
-	input: ("text" | "image" | "file")[];
-	cost: {
-		input: number; // $/million tokens
-		output: number; // $/million tokens
-		cacheRead: number; // $/million tokens
-		cacheWrite: number; // $/million tokens
-	};
-	contextWindow: number;
-	maxTokens: number;
-	headers?: Record<string, string>;
-}
-
-
-// ################################ Types for Standardized storing of User Message and Tool Result
-
-export interface UserMessage {
-    role: "user"
-    timestamp: number;
-    content: (UserTextContent | UserImageContent | UserFileContent)[] // Supports text, images and files
-}
-
-export interface ToolResultMessage<TDetails = any> {
-	role: "toolResult";
-	toolName: string;
-	toolCallId?: string;
-    content: (UserTextContent | UserImageContent | UserFileContent)[]; // Supports text, images and files
-	details?: TDetails; // Any extra information not sent to model
-	isError: boolean;
-	error?: {
-		message: string;
-		name?: string;
-		stack?: string;
-	}; // Full error details if isError is true
-	timestamp: number; // Unix timestamp in milliseconds
-}
-
-export interface UserImageContent {
-    type: "image"
-	data: string; // base64 encoded image data
-	mimeType: string; // e.g., "image/jpeg", "image/png"
-}
-
-export interface UserFileContent {
-    type: "file"
-	data: string; // base64 buffer encoded data
-	mimeType: string; // e.g., "application/pdf",
-}
-
-export interface UserTextContent {
-    type: 'text'
-    content: string
-}
-
-// ################################ Types for Native Assistant Message
-
-export interface NativeOpenAIMessage {
-	role: "assistant"
-    _provider: 'openai'
-    message: Response
-}
-
-export interface NativeGoogleMessage {
-	role: "assistant"
-    _provider: 'google'
-    message: GenerateContentResponse
-}
-
-export type NativeAssistantMessage = NativeOpenAIMessage | NativeGoogleMessage;
-
-// ################################ Types for Stored Message
-
-export type Message = UserMessage | NativeAssistantMessage | ToolResultMessage
-
-export interface Tool<TParameters extends TSchema = TSchema, TName extends string = string> {
-	name: TName;
-	description: string;
-	parameters: TParameters;
-}
-
-// Helper type to extract tool names from a tool array for better autocomplete
-export type ToolName<TTool extends Tool> = TTool["name"];
-export type ToolNames<TTools extends readonly Tool[]> = TTools[number]["name"];
-
-// Helper function to create a tool with better type inference
-// Use 'as const' on the tool array for best autocomplete:
-// const tools = [defineTool({ name: "calculator", ... }), ...] as const
-export function defineTool<TParameters extends TSchema, TName extends string>(
-	tool: Tool<TParameters, TName>
-): Tool<TParameters, TName> {
-	return tool;
-}
-
-export interface Context<TTools extends readonly Tool[] = readonly Tool[]> {
-	messages: Message[]
-	systemPrompt?: string;
-	tools?: TTools
-}
-
-// ################################ Types for Standardized streaming of Assistant Message
-
-export interface Usage {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	totalTokens: number;
-	cost: {
-		input: number;
-		output: number;
-		cacheRead: number;
-		cacheWrite: number;
-		total: number;
-	};
-}
-
-export type StopReason = "stop" | "length" | "toolUse" | "error" | "aborted";
-
-// return content from assistant -> Thinking, Text, ToolCall, Image (for image models)
-export interface AssistantMessage {
-	role: "assistant";
-	content: (AssistantTextContent | AssistantThinkingContent | AssistantToolCall | AbstractedImageContent)[];
-	api: Api;
-	model: string;
-	usage: Usage;
-	stopReason: StopReason;
-	errorMessage?: string;
-	timestamp: number; // Unix timestamp in milliseconds
-}
-
-export interface AssistantTextContent {
-    type: 'text'
-    text: string
-}
-
-export interface AssistantThinkingContent {
-    type: 'thinking'
-    thinking: string
-}
-
-export interface AssistantToolCall {
-	type: "toolCall";
-    name: string
-	arguments: Record<string, any>;
-	id?: string
-}
-
-export interface AbstractedImageContent {
-	type: "image";
-	data: string; // base64 encoded image data
-	mimeType: string; // e.g., "image/jpeg", "image/png"
-}
-
-export type AssistantMessageEvent =
-	| { type: "start"; partial: AssistantMessage }
-	| { type: "text_start"; contentIndex: number; partial: AssistantMessage }
-	| { type: "text_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-	| { type: "text_end"; contentIndex: number; content: string; partial: AssistantMessage }
-	| { type: "thinking_start"; contentIndex: number; partial: AssistantMessage }
-	| { type: "thinking_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-	| { type: "thinking_end"; contentIndex: number; content: string; partial: AssistantMessage }
-	| { type: "toolcall_start"; contentIndex: number; partial: AssistantMessage }
-	| { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-	| { type: "toolcall_end"; contentIndex: number; toolCall: AssistantToolCall; partial: AssistantMessage }
-	| { type: "done"; reason: Extract<StopReason, "stop" | "length" | "toolUse">; message: AssistantMessage }
-	| { type: "error"; reason: Extract<StopReason, "aborted" | "error">; error: AssistantMessage };
-
-
-
-// ################################ Types for Stream Function
-
-export interface ApiOptionsMap {
-	"openai": OpenAIProviderOptions;
-	"google": GoogleProviderOptions;
-}
-
-export type OptionsForApi<TApi extends Api> = ApiOptionsMap[TApi];
-
-
-export type StreamFunction<TApi extends Api> = (
-	model: Model<TApi>,
-	context: Context,
-	options: OptionsForApi<TApi>,
-) => AssistantMessageEventStream;