supercompat 3.18.0 → 4.0.0

package/dist/openai/index.d.ts

@@ -0,0 +1,547 @@
+export { supercompat } from '../supercompat.js';
+import OpenAI, { AzureOpenAI } from 'openai';
+import { AIProjectClient } from '@azure/ai-projects';
+import { Mistral } from '@mistralai/mistralai';
+import Anthropic from '@anthropic-ai/sdk';
+import { GoogleGenAI } from '@google/genai';
+import { OpenRouter } from '@openrouter/sdk';
+import { MessageWithRun, StorageAdapterArgs, RequestHandler, RunAdapterWithAssistant } from '../types/index.js';
+import { PrismaClient } from '@prisma/client';
+
+declare const groqClientAdapter: ({ groq, }: {
+    groq: any;
+}) => {
+    client: any;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/v1/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const openaiClientAdapter: ({ openai, }: {
+    openai: OpenAI;
+}) => {
+    client: OpenAI;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const azureOpenaiClientAdapter: ({ azureOpenai, }: {
+    azureOpenai: AzureOpenAI;
+}) => {
+    type: string;
+    client: AzureOpenAI;
+    requestHandlers: {
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+/**
+ * Client adapter for Azure AI Projects.
+ *
+ * Supports both Azure Agents API and Azure Responses API:
+ *
+ * @example Azure Agents API
+ * ```typescript
+ * const client = supercompat({
+ *   client: azureAiProjectClientAdapter({ azureAiProject }),
+ *   storage: azureAgentsStorageAdapter(),
+ *   runAdapter: azureAgentsRunAdapter({ ... })
+ * })
+ * ```
+ *
+ * @example Azure Responses API
+ * ```typescript
+ * const client = supercompat({
+ *   client: azureAiProjectClientAdapter({ azureAiProject }),
+ *   storage: azureResponsesStorageAdapter(),
+ *   runAdapter: responsesRunAdapter({ ... })
+ * })
+ * ```
+ */
+declare const azureAiProjectClientAdapter: ({ azureAiProject, }: {
+    azureAiProject: AIProjectClient;
+}) => {
+    type: string;
+    client: AIProjectClient;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const mistralClientAdapter: ({ mistral, }: {
+    mistral: Mistral;
+}) => {
+    client: Mistral;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/v1/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const perplexityClientAdapter: ({ perplexity, }: {
+    perplexity: OpenAI;
+}) => {
+    client: OpenAI;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/v1/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const anthropicClientAdapter: ({ anthropic, }: {
+    anthropic: Anthropic;
+}) => {
+    client: Anthropic;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/v1/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const togetherClientAdapter: ({ together, }: {
+    together: OpenAI;
+}) => {
+    client: OpenAI;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const googleClientAdapter: ({ google, }: {
+    google: GoogleGenAI;
+}) => {
+    client: GoogleGenAI;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const humirisClientAdapter: ({ humiris, }: {
+    humiris: OpenAI;
+}) => {
+    client: OpenAI;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const ollamaClientAdapter: ({ ollama, }: {
+    ollama: OpenAI;
+}) => {
+    client: OpenAI;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: any) => Promise<Response>;
+        };
+    };
+};
+
+declare const openRouterClientAdapter: ({ openRouter, provider, }: {
+    openRouter: OpenRouter;
+    provider?: Record<string, unknown>;
+}) => {
+    client: OpenRouter;
+    requestHandlers: {
+        '^/v1/models$': {
+            get: (_url: string, _options: any) => Promise<Response>;
+        };
+        '^/(?:v1|/?openai)/chat/completions$': {
+            post: (_url: string, options: {
+                body: string;
+            }) => Promise<Response>;
+        };
+    };
+};
+
+declare const completionsRunAdapter: () => {
+    handleRun: ({ client, run, onEvent, getMessages, }: {
+        client: OpenAI;
+        run: OpenAI.Beta.Threads.Run;
+        onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>;
+        getMessages: () => Promise<MessageWithRun[]>;
+    }) => Promise<any>;
+};
+
+type Args = {
+    select?: {
+        id?: boolean;
+    };
+};
+declare const responsesRunAdapter: ({ getOpenaiAssistant: getDirectOpenaiAssistant, waitUntil }: {
+    getOpenaiAssistant: (args?: Args) => Promise<OpenAI.Beta.Assistants.Assistant> | OpenAI.Beta.Assistants.Assistant | Pick<OpenAI.Beta.Assistants.Assistant, "id"> | Promise<Pick<OpenAI.Beta.Assistants.Assistant, "id">>;
+    waitUntil?: <T>(p: Promise<T>) => void | Promise<void>;
+}) => {
+    handleRun: ({ client, threadId, response, onEvent, }: {
+        client: OpenAI;
+        threadId: string;
+        response: AsyncIterable<any>;
+        onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>;
+    }) => Promise<void>;
+    getOpenaiAssistant: ({ select: { id } }?: Args) => Promise<OpenAI.Beta.Assistants.Assistant | {
+        id: string;
+    }>;
+};
+
+declare const azureAgentsRunAdapter: ({ azureAiProject, }: {
+    azureAiProject: AIProjectClient;
+}) => {
+    handleRun: ({ threadId, assistantId, instructions, tools, onEvent, }: {
+        threadId: string;
+        assistantId: string;
+        instructions?: string;
+        tools?: any[];
+        onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>;
+    }) => Promise<void>;
+};
+
+declare const perplexityAgentRunAdapter: ({ apiKey, baseURL, preset, }: {
+    apiKey: string;
+    baseURL?: string;
+    preset?: string;
+}) => {
+    handleRun: ({ run, onEvent, getMessages, }: {
+        client: OpenAI;
+        run: OpenAI.Beta.Threads.Run;
+        onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>;
+        getMessages: () => Promise<MessageWithRun[]>;
+    }) => Promise<any>;
+};
+
+/**
+ * OpenAI run adapter for the Responses API surface.
+ *
+ * Calls OpenAI's native Responses API directly and streams events through.
+ * Supports all built-in tools (web_search, file_search, code_interpreter, computer_use).
+ */
+
+type ResponsesRunEvent$4 = {
+    type: string;
+    [key: string]: any;
+};
+type HandleArgs$4 = {
+    requestBody: any;
+    onEvent: (event: ResponsesRunEvent$4) => Promise<void>;
+};
+declare const openaiResponsesRunAdapter: ({ openai, }: {
+    openai: OpenAI;
+}) => {
+    type: "responses-openai";
+    handleRun: ({ requestBody, onEvent, }: HandleArgs$4) => Promise<void>;
+};
+
+type ResponsesRunEvent$3 = {
+    type: string;
+    [key: string]: any;
+};
+type HandleArgs$3 = {
+    requestBody: any;
+    onEvent: (event: ResponsesRunEvent$3) => Promise<void>;
+};
+declare const azureResponsesRunAdapter: ({ azureAiProject, }: {
+    azureAiProject: AIProjectClient;
+}) => {
+    type: "responses-azure";
+    handleRun: ({ requestBody, onEvent, }: HandleArgs$3) => Promise<void>;
+};
+
+/**
+ * Anthropic run adapter for the Responses API surface.
+ *
+ * Calls Anthropic's beta.messages.create() with native beta tools
+ * (web_search, code_execution, computer_use) and translates Anthropic
+ * streaming events → Responses API events.
+ *
+ * Also handles regular function tools via Anthropic's tool_use format.
+ */
+
+type ResponsesRunEvent$2 = {
+    type: string;
+    [key: string]: any;
+};
+type HandleArgs$2 = {
+    requestBody: any;
+    onEvent: (event: ResponsesRunEvent$2) => Promise<void>;
+};
+declare const anthropicRunAdapter: ({ anthropic, }: {
+    anthropic: Anthropic;
+}) => {
+    type: "responses-anthropic";
+    handleRun: ({ requestBody, onEvent, }: HandleArgs$2) => Promise<void>;
+};
+
+/**
+ * Azure Agents run adapter for the Responses API surface.
+ *
+ * Creates an Azure Agent with the requested tools, runs it, and translates
+ * Azure Agent streaming events → Responses API events.
+ *
+ * Supports: file_search, code_interpreter, function tools.
+ */
+
+type ResponsesRunEvent$1 = {
+    type: string;
+    [key: string]: any;
+};
+type HandleArgs$1 = {
+    requestBody: any;
+    onEvent: (event: ResponsesRunEvent$1) => Promise<void>;
+    agentId?: string;
+    threadId?: string;
+};
+declare const azureAgentsResponsesRunAdapter: ({ azureAiProject, }: {
+    azureAiProject: AIProjectClient;
+}) => {
+    type: "responses-azure-agents";
+    handleRun: ({ requestBody, onEvent, agentId: existingAgentId, threadId: existingThreadId, }: HandleArgs$1) => Promise<void>;
+};
+
+/**
+ * Gemini run adapter for the Responses API surface.
+ *
+ * Calls Google's Gemini API with native computer_use support.
+ * Translates Gemini streaming events → Responses API events.
+ *
+ * For non-computer-use tools, delegates to completions path.
+ */
+
+type ResponsesRunEvent = {
+    type: string;
+    [key: string]: any;
+};
+type HandleArgs = {
+    requestBody: any;
+    onEvent: (event: ResponsesRunEvent) => Promise<void>;
+};
+declare const geminiRunAdapter: ({ google, }: {
+    google: GoogleGenAI;
+}) => {
+    type: "responses-gemini";
+    handleRun: ({ requestBody, onEvent, }: HandleArgs) => Promise<void>;
+};
+
+declare const prismaStorageAdapter: ({ prisma, }: {
+    prisma: PrismaClient;
+}) => (args: StorageAdapterArgs) => {
+    requestHandlers: {
+        [x: string]: {
+            get?: RequestHandler;
+            post?: RequestHandler;
+            delete?: RequestHandler;
+        } | {
+            get?: RequestHandler;
+            post?: RequestHandler;
+            delete?: RequestHandler;
+        };
+    };
+};
+
+type MethodHandlers$2 = {
+    get?: RequestHandler;
+    post?: RequestHandler;
+    delete?: RequestHandler;
+};
+declare const memoryStorageAdapter: () => ((args: StorageAdapterArgs) => {
+    requestHandlers: Record<string, MethodHandlers$2>;
+});
+
+type MethodHandlers$1 = {
+    get?: RequestHandler;
+    post?: RequestHandler;
+    delete?: RequestHandler;
+};
+type ResponsesStorageAdapterArgs = StorageAdapterArgs & {
+    runAdapter: RunAdapterWithAssistant;
+};
+declare const responsesStorageAdapter: ({ deferItemCreationUntilRun, }?: {
+    deferItemCreationUntilRun?: boolean;
+}) => ((args: ResponsesStorageAdapterArgs) => {
+    requestHandlers: Record<string, MethodHandlers$1>;
+});
+
+type AzureAgentsStorageAdapterArgs = StorageAdapterArgs & {
+    runAdapter: RunAdapterWithAssistant;
+};
+declare const azureAgentsStorageAdapter: ({ azureAiProject, prisma, }: {
+    azureAiProject: AIProjectClient;
+    prisma: PrismaClient;
+}) => ({ runAdapter }: AzureAgentsStorageAdapterArgs) => {
+    requestHandlers: {
+        '^/(?:v1|/?openai)/assistants$': {
+            post: RequestHandler;
+        };
+        '^/(?:v1|/?openai)/threads$': {
+            post: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/runs$": {
+            post: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)$": {
+            get: RequestHandler;
+            post: RequestHandler;
+            delete: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/messages$": {
+            post: RequestHandler;
+            get: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/messages/([^/]+)$": {
+            get: RequestHandler;
+            post: RequestHandler;
+            delete: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/runs$": {
+            get: RequestHandler;
+            post: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/runs/([^/]+)$": {
+            get: RequestHandler;
+            post: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/runs/([^/]+)/steps/([^/]+)$": {
+            get: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/runs/([^/]+)/steps$": {
+            get: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/runs/([^/]+)/submit_tool_outputs$": {
+            post: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/threads/([^/]+)/runs/([^/]+)/cancel$": {
+            post: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/files/([^/]+)$": {
+            delete: RequestHandler;
+            get: RequestHandler;
+        };
+        "^/(?:v1|/?openai)/files/([^/]+)/content$": {
+            get: RequestHandler;
+        };
+        '^/(?:v1|/?openai)/files$': {
+            post: RequestHandler;
+        };
+        '^/(?:v1|/?openai)/vector_stores$': {
+            post: RequestHandler;
+        };
+        '^/(?:v1|/?openai)/vector_stores/[^/]+$': {
+            get: RequestHandler;
+            delete: RequestHandler;
+        };
+    };
+};
+
+type MethodHandlers = {
+    get?: RequestHandler;
+    post?: RequestHandler;
+    delete?: RequestHandler;
+};
+type AzureResponsesStorageAdapterArgs = StorageAdapterArgs & {
+    runAdapter: RunAdapterWithAssistant;
+    originalClient?: any;
+};
+/**
+ * Storage adapter for Azure's Responses API (conversations + responses endpoints).
+ *
+ * Use this with Azure AI Projects and azureAiProjectClientAdapter:
+ *
+ * @example
+ * ```typescript
+ * const azureAiProject = new AIProjectClient(endpoint, credential)
+ *
+ * const client = supercompat({
+ *   client: azureAiProjectClientAdapter({ azureAiProject }),
+ *   storage: azureResponsesStorageAdapter(),
+ *   runAdapter: responsesRunAdapter({ getOpenaiAssistant: () => assistant }),
+ * })
+ * ```
+ */
+declare const azureResponsesStorageAdapter: () => ((args: AzureResponsesStorageAdapterArgs) => {
+    requestHandlers: Record<string, MethodHandlers>;
+});
+
+type ComputerAction = Record<string, unknown> & {
+    type: string;
+};
+declare const isOpenaiComputerUseModel: ({ model, }: {
+    model: string | null | undefined;
+}) => boolean;
+declare const serializeComputerUseTool: ({ useOpenaiComputerTool, tool, }: {
+    useOpenaiComputerTool: boolean;
+    tool: Record<string, unknown>;
+}) => {
+    type: "computer";
+    computer: Record<string, unknown>;
+    computer_use_preview?: undefined;
+} | {
+    type: "computer_use_preview";
+    computer_use_preview: Record<string, unknown>;
+    computer?: undefined;
+};
+declare const getComputerCallActions: ({ item, }: {
+    item: {
+        action?: unknown;
+        actions?: unknown;
+    };
+}) => ComputerAction[];
+declare const serializeCompatComputerCall: ({ item, }: {
+    item: {
+        call_id: string;
+        pending_safety_checks?: unknown;
+        action?: unknown;
+        actions?: unknown;
+    };
+}) => {
+    id: string;
+    type: "computer_call";
+    computer_call: {
+        pending_safety_checks: any[];
+        actions?: ComputerAction[] | undefined;
+        action?: ComputerAction | undefined;
+    };
+};
+
+export { anthropicClientAdapter, anthropicRunAdapter, azureAgentsResponsesRunAdapter, azureAgentsRunAdapter, azureAgentsStorageAdapter, azureAiProjectClientAdapter, azureOpenaiClientAdapter, azureResponsesRunAdapter, azureResponsesStorageAdapter, completionsRunAdapter, geminiRunAdapter, getComputerCallActions, googleClientAdapter, groqClientAdapter, humirisClientAdapter, isOpenaiComputerUseModel, memoryStorageAdapter, mistralClientAdapter, ollamaClientAdapter, openRouterClientAdapter, openaiClientAdapter, openaiResponsesRunAdapter, perplexityAgentRunAdapter, perplexityClientAdapter, prismaStorageAdapter, responsesRunAdapter, responsesStorageAdapter, serializeCompatComputerCall, serializeComputerUseTool, togetherClientAdapter };