@praxis-ai/praxis 0.1.0 → 0.1.2

package/dist/modelAdapter/protocols/openaiChat.js

@@ -0,0 +1,324 @@
+import { Effect } from "effect";
+import { raxModelError, textFromContent, toProviderToolName, } from "../schema/index.js";
+export const openAIChatProtocol = {
+    id: "openai.chat",
+    prepare(request, context) {
+        return Effect.try({
+            try: () => prepareOpenAIChatBody(request, context),
+            catch: (error) => raxModelError("request_invalid", "Failed to prepare OpenAI chat request", {}, error),
+        });
+    },
+    initialState() {
+        return { toolCalls: {} };
+    },
+    decodeFrame(frame, state, prepared) {
+        return Effect.try({
+            try: () => decodeOpenAIChatFrame(frame, state, prepared),
+            catch: (error) => raxModelError("decode_error", "Failed to decode OpenAI chat frame", { frame }, error),
+        });
+    },
+    finalize(state, prepared) {
+        return Effect.sync(() => {
+            const chatState = state;
+            const events = flushToolCalls(chatState, prepared.id);
+            events.push({ type: "response.finish", id: prepared.id, finishReason: chatState.finishReason, usage: chatState.usage });
+            return events;
+        });
+    },
+};
+export const openAICompatibleChatProtocol = {
+    ...openAIChatProtocol,
+    id: "openai.compatible_chat",
+};
+function prepareOpenAIChatBody(request, context) {
+    const body = {
+        model: context.modelId,
+        messages: lowerOpenAIMessages(request.system, request.messages),
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    if (request.generation?.temperature !== undefined)
+        body.temperature = request.generation.temperature;
+    if (request.generation?.topP !== undefined)
+        body.top_p = request.generation.topP;
+    if (request.generation?.maxOutputTokens !== undefined)
+        body.max_tokens = request.generation.maxOutputTokens;
+    if (request.generation?.stop?.length)
+        body.stop = request.generation.stop;
+    if (request.generation?.reasoningEffort)
+        body.reasoning_effort = request.generation.reasoningEffort;
+    const responseFormat = lowerOpenAIResponseFormat(request.generation?.responseFormat);
+    if (responseFormat !== undefined)
+        body.response_format = responseFormat;
+    const toolNameMap = new Map();
+    const tools = lowerOpenAITools(request.tools ?? [], toolNameMap);
+    if (tools.length) {
+        body.tools = tools;
+        body.tool_choice = lowerOpenAIToolChoice(request.toolChoice, toolNameMap);
+    }
+    return {
+        body,
+        metadata: {
+            toolNameMap: Object.fromEntries(toolNameMap.entries()),
+        },
+    };
+}
+function lowerOpenAIResponseFormat(format) {
+    if (format === undefined || format === "text")
+        return undefined;
+    if (format === "json")
+        return { type: "json_object" };
+    if (typeof format === "object" && "schema" in format && format.schema !== undefined) {
+        return {
+            type: "json_schema",
+            json_schema: {
+                name: typeof format.type === "string" && format.type.length > 0 ? format.type : "response",
+                schema: format.schema,
+                strict: true,
+            },
+        };
+    }
+    return undefined;
+}
+function lowerOpenAIMessages(system, messages) {
+    const lowered = [];
+    const systemText = (system ?? []).map((part) => part.text).join("\n\n");
+    if (systemText)
+        lowered.push({ role: "system", content: systemText });
+    for (const message of messages) {
+        if (message.role === "tool") {
+            const toolResults = Array.isArray(message.content)
+                ? message.content.filter((part) => part.type === "tool_result")
+                : [];
+            if (!toolResults.length) {
+                lowered.push({ role: "tool", tool_call_id: message.name ?? "tool_call", content: textFromContent(message.content) });
+            }
+            for (const result of toolResults) {
+                lowered.push({
+                    role: "tool",
+                    tool_call_id: result.toolCallId,
+                    content: typeof result.content === "string" ? result.content : textFromContent(result.content),
+                });
+            }
+            continue;
+        }
+        if (message.role === "assistant" && Array.isArray(message.content)) {
+            const toolCalls = message.content.filter((part) => part.type === "tool_call");
+            lowered.push({
+                role: "assistant",
+                content: textFromContent(message.content) || null,
+                ...(toolCalls.length
+                    ? {
+                        tool_calls: toolCalls.map((part) => ({
+                            id: part.call.id,
+                            type: "function",
+                            function: { name: part.call.providerName ?? toProviderToolName(part.call.name), arguments: JSON.stringify(part.call.input ?? {}) },
+                        })),
+                    }
+                    : {}),
+            });
+            continue;
+        }
+        lowered.push({ role: message.role, content: lowerOpenAIContent(message.content) });
+    }
+    return lowered;
+}
+function lowerOpenAIContent(content) {
+    if (typeof content === "string")
+        return content;
+    const lowered = content.flatMap((part) => {
+        if (part.type === "text")
+            return [{ type: "text", text: part.text }];
+        if (part.type === "image") {
+            const url = imageUrl(part);
+            return url ? [{ type: "image_url", image_url: { url } }] : [];
+        }
+        if (part.type === "reasoning")
+            return [{ type: "text", text: part.text }];
+        return [];
+    });
+    return lowered.length ? lowered : textFromContent(content);
+}
+function imageUrl(part) {
+    if (part.url)
+        return part.url;
+    if (part.data)
+        return `data:${part.mimeType ?? "application/octet-stream"};base64,${part.data}`;
+    return undefined;
+}
+function lowerOpenAITools(tools, toolNameMap) {
+    const lowered = [];
+    for (const tool of tools) {
+        if (tool.kind === "native") {
+            if (tool.provider === "openai")
+                lowered.push(tool.payload);
+            continue;
+        }
+        const providerName = toProviderToolName(tool.name);
+        toolNameMap.set(providerName, tool.name);
+        lowered.push({
+            type: "function",
+            function: {
+                name: providerName,
+                description: tool.description ?? "",
+                parameters: tool.inputSchema,
+                ...(tool.strict ? { strict: true } : {}),
+            },
+        });
+    }
+    return lowered;
+}
+function lowerOpenAIToolChoice(choice, toolNameMap) {
+    if (!choice)
+        return "auto";
+    if (choice === "auto" || choice === "none" || choice === "required")
+        return choice;
+    const providerName = [...toolNameMap.entries()].find(([, original]) => original === choice.name)?.[0] ?? toProviderToolName(choice.name);
+    return { type: "function", function: { name: providerName } };
+}
+function decodeOpenAIChatFrame(frame, state, prepared) {
+    const events = [];
+    if (!frame || typeof frame !== "object")
+        return { state, events };
+    const chunk = frame;
+    const usage = lowerUsage(chunk.usage);
+    if (usage) {
+        state.usage = usage;
+        events.push({ type: "usage", id: prepared.id, usage });
+    }
+    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+    for (const choice of choices) {
+        if (!choice || typeof choice !== "object")
+            continue;
+        const choiceObj = choice;
+        if (typeof choiceObj.finish_reason === "string")
+            state.finishReason = choiceObj.finish_reason;
+        const message = choiceObj.message;
+        if (message && typeof message === "object") {
+            events.push(...decodeOpenAIChatMessage(message, prepared, events.length));
+        }
+        const delta = choiceObj.delta;
+        if (!delta || typeof delta !== "object")
+            continue;
+        const deltaObj = delta;
+        if (typeof deltaObj.content === "string" && deltaObj.content) {
+            events.push({ type: "text.delta", id: prepared.id, text: deltaObj.content });
+        }
+        const reasoning = deltaObj.reasoning_content ?? deltaObj.reasoning;
+        if (typeof reasoning === "string" && reasoning) {
+            events.push({ type: "reasoning.delta", id: prepared.id, text: reasoning });
+        }
+        const toolCalls = Array.isArray(deltaObj.tool_calls) ? deltaObj.tool_calls : [];
+        for (const toolCall of toolCalls) {
+            const toolEvents = decodeToolDelta(toolCall, state, prepared);
+            events.push(...toolEvents);
+        }
+    }
+    return { state, events };
+}
+function decodeOpenAIChatMessage(message, prepared, baseIndex) {
+    const events = [];
+    if (typeof message.content === "string" && message.content) {
+        events.push({ type: "text.delta", id: prepared.id, text: message.content });
+    }
+    const reasoning = message.reasoning_content ?? message.reasoning;
+    if (typeof reasoning === "string" && reasoning) {
+        events.push({ type: "reasoning.delta", id: prepared.id, text: reasoning });
+    }
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (const [offset, toolCall] of toolCalls.entries()) {
+        const call = lowerOpenAIToolCall(toolCall, offset);
+        if (!call)
+            continue;
+        const index = baseIndex + offset;
+        const inputText = typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {});
+        events.push({ type: "tool.input.start", id: prepared.id, toolCallId: call.id, name: call.providerName, index });
+        if (inputText)
+            events.push({ type: "tool.input.delta", id: prepared.id, toolCallId: call.id, delta: inputText, index });
+        events.push({ type: "tool.input.end", id: prepared.id, toolCallId: call.id, input: inputText, index });
+        events.push({ type: "tool.call", id: prepared.id, call, index });
+    }
+    return events;
+}
+function lowerOpenAIToolCall(toolCall, index) {
+    if (!toolCall || typeof toolCall !== "object")
+        return undefined;
+    const value = toolCall;
+    const fn = value.function && typeof value.function === "object" ? value.function : {};
+    const name = typeof fn.name === "string" ? fn.name : "unknown_tool";
+    const rawInput = typeof fn.arguments === "string" ? fn.arguments : "";
+    return {
+        id: typeof value.id === "string" ? value.id : `tool_${index}`,
+        name,
+        providerName: name,
+        input: parseToolInput(rawInput),
+    };
+}
+function decodeToolDelta(toolCall, state, prepared) {
+    if (!toolCall || typeof toolCall !== "object")
+        return [];
+    const value = toolCall;
+    const index = typeof value.index === "number" ? value.index : 0;
+    const key = String(index);
+    const existing = state.toolCalls[key] ?? { id: typeof value.id === "string" ? value.id : `tool_${key}`, argumentsText: "", started: false };
+    if (typeof value.id === "string")
+        existing.id = value.id;
+    const fn = value.function && typeof value.function === "object" ? value.function : {};
+    if (typeof fn.name === "string")
+        existing.name = fn.name;
+    const delta = typeof fn.arguments === "string" ? fn.arguments : "";
+    existing.argumentsText += delta;
+    state.toolCalls[key] = existing;
+    const events = [];
+    if (!existing.started) {
+        existing.started = true;
+        events.push({ type: "tool.input.start", id: prepared.id, toolCallId: existing.id, name: existing.name, index });
+    }
+    if (delta) {
+        events.push({ type: "tool.input.delta", id: prepared.id, toolCallId: existing.id, delta, index });
+    }
+    return events;
+}
+function flushToolCalls(state, responseId) {
+    const events = [];
+    for (const [indexText, toolState] of Object.entries(state.toolCalls)) {
+        const index = Number(indexText);
+        events.push({ type: "tool.input.end", id: responseId, toolCallId: toolState.id, input: toolState.argumentsText, index });
+        const input = parseToolInput(toolState.argumentsText);
+        const call = {
+            id: toolState.id,
+            name: toolState.name ?? "unknown_tool",
+            input,
+            providerName: toolState.name,
+        };
+        events.push({ type: "tool.call", id: responseId, call, index });
+    }
+    state.toolCalls = {};
+    return events;
+}
+function parseToolInput(value) {
+    if (!value.trim())
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function lowerUsage(usage) {
+    if (!usage || typeof usage !== "object")
+        return undefined;
+    const value = usage;
+    return {
+        inputTokens: numberValue(value.prompt_tokens),
+        outputTokens: numberValue(value.completion_tokens),
+        totalTokens: numberValue(value.total_tokens),
+        reasoningTokens: numberValue(value.completion_tokens_details?.reasoning_tokens),
+        cacheReadInputTokens: numberValue(value.prompt_tokens_details?.cached_tokens),
+        raw: usage,
+    };
+}
+function numberValue(value) {
+    return typeof value === "number" ? value : undefined;
+}

package/dist/modelAdapter/providers/anthropic.d.ts

@@ -0,0 +1,2 @@
+import type { RaxProviderDefinition } from "../registry/index.js";
+export declare const anthropicProvider: RaxProviderDefinition;

package/dist/modelAdapter/providers/anthropic.js

@@ -0,0 +1,34 @@
+import { anthropicMessagesProtocol } from "../protocols/index.js";
+export const anthropicProvider = {
+    id: "anthropic",
+    displayName: "Anthropic",
+    routes: [
+        {
+            id: "anthropic",
+            providerId: "anthropic",
+            protocol: anthropicMessagesProtocol,
+            endpoint: {
+                baseUrl: "https://api.anthropic.com",
+                path: "/v1/messages",
+                defaultHeaders: { "anthropic-version": "2023-06-01" },
+                allowedNativeOptions: ["anthropic-beta", "service_tier"],
+            },
+        },
+    ],
+    compat: {
+        providerId: "anthropic",
+        protocolId: "anthropic.messages",
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsUsageInStreaming: true,
+        supportsStrictToolSchema: false,
+        maxTokensField: "max_tokens",
+        allowedNativeOptions: ["anthropic-beta", "service_tier"],
+    },
+    authEnv: ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
+    auth: { type: "api_key", env: ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"], header: "x-api-key" },
+    models: [
+        { providerId: "anthropic", modelId: "claude-sonnet-4-5", protocolId: "anthropic.messages", supportsTools: true, status: "unknown" },
+        { providerId: "anthropic", modelId: "claude-opus-4-1", protocolId: "anthropic.messages", supportsTools: true, status: "unknown" },
+    ],
+};

package/dist/modelAdapter/providers/deepseek.d.ts

@@ -0,0 +1 @@
+export declare const deepSeekProvider: import("../index.js").RaxProviderDefinition;

package/dist/modelAdapter/providers/deepseek.js

@@ -0,0 +1,8 @@
+import { createOpenAICompatibleProvider } from "./openaiCompatible.js";
+export const deepSeekProvider = createOpenAICompatibleProvider({
+    id: "deepseek",
+    displayName: "DeepSeek",
+    baseUrl: "https://api.deepseek.com",
+    apiKeyEnv: "DEEPSEEK_API_KEY",
+    models: ["deepseek-chat", "deepseek-reasoner"],
+});

package/dist/modelAdapter/providers/google.d.ts

@@ -0,0 +1,2 @@
+import type { RaxProviderDefinition } from "../registry/index.js";
+export declare const googleProvider: RaxProviderDefinition;

package/dist/modelAdapter/providers/google.js

@@ -0,0 +1,33 @@
+import { googleGenerateContentProtocol } from "../protocols/index.js";
+export const googleProvider = {
+    id: "google",
+    displayName: "Google Gemini",
+    routes: [
+        {
+            id: "google",
+            providerId: "google",
+            protocol: googleGenerateContentProtocol,
+            endpoint: {
+                baseUrl: "https://generativelanguage.googleapis.com",
+                path: "/v1beta/models/{model}:streamGenerateContent",
+                allowedNativeOptions: ["safetySettings", "toolConfig", "cachedContent"],
+            },
+        },
+    ],
+    compat: {
+        providerId: "google",
+        protocolId: "google.generate_content",
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsUsageInStreaming: true,
+        supportsStrictToolSchema: false,
+        maxTokensField: "max_output_tokens",
+        allowedNativeOptions: ["safetySettings", "toolConfig", "cachedContent"],
+    },
+    authEnv: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+    auth: { type: "api_key", env: ["GOOGLE_API_KEY", "GEMINI_API_KEY"], header: "x-goog-api-key" },
+    models: [
+        { providerId: "google", modelId: "gemini-2.5-pro", protocolId: "google.generate_content", supportsTools: true, status: "unknown" },
+        { providerId: "google", modelId: "gemini-2.5-flash", protocolId: "google.generate_content", supportsTools: true, status: "unknown" },
+    ],
+};

package/dist/modelAdapter/providers/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./openaiCompatible.js";
+export * from "./openai.js";
+export * from "./deepseek.js";
+export * from "./anthropic.js";
+export * from "./google.js";
+import { type RaxProviderClientOptions, type RaxProviderRegistry } from "../registry/index.js";
+export declare const defaultRaxProviders: readonly [import("../registry/providerRegistry.js").RaxProviderDefinition, import("../registry/providerRegistry.js").RaxProviderDefinition, import("../registry/providerRegistry.js").RaxProviderDefinition, import("../registry/providerRegistry.js").RaxProviderDefinition];
+export declare function registerDefaultRaxProviders(registry?: RaxProviderRegistry): RaxProviderRegistry;
+export declare function createDefaultRaxProviderRegistry(): RaxProviderRegistry;
+export declare function createDefaultRaxModelClient(options?: RaxProviderClientOptions): import("../index.js").RaxModelClient;

package/dist/modelAdapter/providers/index.js

@@ -0,0 +1,28 @@
+export * from "./openaiCompatible.js";
+export * from "./openai.js";
+export * from "./deepseek.js";
+export * from "./anthropic.js";
+export * from "./google.js";
+import { defaultRaxProviderRegistry } from "../registry/index.js";
+import { createRaxModelClientFromProviders, createRaxProviderRegistry, } from "../registry/index.js";
+import { anthropicProvider } from "./anthropic.js";
+import { deepSeekProvider } from "./deepseek.js";
+import { googleProvider } from "./google.js";
+import { openAIProvider } from "./openai.js";
+export const defaultRaxProviders = [
+    openAIProvider,
+    deepSeekProvider,
+    anthropicProvider,
+    googleProvider,
+];
+export function registerDefaultRaxProviders(registry = defaultRaxProviderRegistry) {
+    for (const provider of defaultRaxProviders)
+        registry.register(provider);
+    return registry;
+}
+export function createDefaultRaxProviderRegistry() {
+    return createRaxProviderRegistry(defaultRaxProviders);
+}
+export function createDefaultRaxModelClient(options = {}) {
+    return createRaxModelClientFromProviders(defaultRaxProviders, options);
+}

package/dist/modelAdapter/providers/openai.d.ts

@@ -0,0 +1,2 @@
+import type { RaxProviderDefinition } from "../registry/index.js";
+export declare const openAIProvider: RaxProviderDefinition;

package/dist/modelAdapter/providers/openai.js

@@ -0,0 +1,34 @@
+import { openAIChatProtocol } from "../protocols/index.js";
+export const openAIProvider = {
+    id: "openai",
+    displayName: "OpenAI",
+    routes: [
+        {
+            id: "openai",
+            providerId: "openai",
+            protocol: openAIChatProtocol,
+            endpoint: {
+                baseUrl: "https://api.openai.com",
+                path: "/v1/chat/completions",
+                allowedNativeOptions: ["parallel_tool_calls", "service_tier", "store", "metadata"],
+            },
+        },
+    ],
+    compat: {
+        providerId: "openai",
+        protocolId: "openai.chat",
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsUsageInStreaming: true,
+        supportsDeveloperRole: false,
+        supportsStrictToolSchema: true,
+        maxTokensField: "max_tokens",
+        allowedNativeOptions: ["parallel_tool_calls", "service_tier", "store", "metadata"],
+    },
+    authEnv: ["OPENAI_API_KEY"],
+    auth: { type: "api_key", env: ["OPENAI_API_KEY"], header: "Authorization" },
+    models: [
+        { providerId: "openai", modelId: "gpt-5.4", protocolId: "openai.chat", supportsTools: true, supportsReasoning: true, status: "unknown" },
+        { providerId: "openai", modelId: "gpt-5.4-mini", protocolId: "openai.chat", supportsTools: true, supportsReasoning: true, status: "unknown" },
+    ],
+};

package/dist/modelAdapter/providers/openaiCompatible.d.ts

@@ -0,0 +1,10 @@
+import type { RaxProviderDefinition } from "../registry/index.js";
+export type RaxOpenAICompatibleProviderOptions = {
+    id: string;
+    displayName?: string;
+    baseUrl: string;
+    models?: string[];
+    apiKeyEnv?: string;
+    allowedNativeOptions?: string[];
+};
+export declare function createOpenAICompatibleProvider(options: RaxOpenAICompatibleProviderOptions): RaxProviderDefinition;

package/dist/modelAdapter/providers/openaiCompatible.js

@@ -0,0 +1,43 @@
+import { openAICompatibleChatProtocol } from "../protocols/index.js";
+export function createOpenAICompatibleProvider(options) {
+    const route = {
+        id: options.id,
+        providerId: options.id,
+        protocol: openAICompatibleChatProtocol,
+        endpoint: {
+            baseUrl: options.baseUrl,
+            path: "/v1/chat/completions",
+            allowedNativeOptions: options.allowedNativeOptions ?? [
+                "frequency_penalty",
+                "presence_penalty",
+                "logit_bias",
+                "parallel_tool_calls",
+                "service_tier",
+            ],
+        },
+    };
+    return {
+        id: options.id,
+        displayName: options.displayName ?? options.id,
+        routes: [route],
+        compat: {
+            providerId: options.id,
+            protocolId: "openai.compatible_chat",
+            supportsTools: true,
+            supportsStreaming: true,
+            supportsUsageInStreaming: true,
+            supportsStrictToolSchema: false,
+            maxTokensField: "max_tokens",
+            allowedNativeOptions: route.endpoint.allowedNativeOptions,
+        },
+        authEnv: options.apiKeyEnv ? [options.apiKeyEnv] : undefined,
+        auth: options.apiKeyEnv ? { type: "api_key", env: [options.apiKeyEnv], header: "Authorization" } : undefined,
+        models: (options.models ?? []).map((modelId) => ({
+            providerId: options.id,
+            modelId,
+            protocolId: "openai.compatible_chat",
+            supportsTools: true,
+            status: "unknown",
+        })),
+    };
+}

package/dist/modelAdapter/registry/compatRegistry.d.ts

@@ -0,0 +1,21 @@
+import type { RaxProtocolId } from "../schema/index.js";
+export type RaxProviderCompat = {
+    providerId: string;
+    protocolId: RaxProtocolId;
+    supportsTools: boolean;
+    supportsStreaming: boolean;
+    supportsUsageInStreaming?: boolean;
+    supportsDeveloperRole?: boolean;
+    supportsStrictToolSchema?: boolean;
+    supportsNativeTools?: string[];
+    maxTokensField?: "max_tokens" | "max_completion_tokens" | "max_output_tokens";
+    unsupportedToolSchemaKeywords?: string[];
+    allowedNativeOptions?: string[];
+};
+export declare class RaxCompatRegistry {
+    readonly entries: Map<string, RaxProviderCompat>;
+    register(entry: RaxProviderCompat): void;
+    get(providerId: string): RaxProviderCompat | undefined;
+    list(): RaxProviderCompat[];
+}
+export declare const defaultRaxCompatRegistry: RaxCompatRegistry;

package/dist/modelAdapter/registry/compatRegistry.js

@@ -0,0 +1,13 @@
+export class RaxCompatRegistry {
+    entries = new Map();
+    register(entry) {
+        this.entries.set(entry.providerId, entry);
+    }
+    get(providerId) {
+        return this.entries.get(providerId);
+    }
+    list() {
+        return [...this.entries.values()];
+    }
+}
+export const defaultRaxCompatRegistry = new RaxCompatRegistry();

package/dist/modelAdapter/registry/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./compatRegistry.js";
+export * from "./modelCatalog.js";
+export * from "./providerRegistry.js";

package/dist/modelAdapter/registry/index.js

@@ -0,0 +1,3 @@
+export * from "./compatRegistry.js";
+export * from "./modelCatalog.js";
+export * from "./providerRegistry.js";

package/dist/modelAdapter/registry/modelCatalog.d.ts

@@ -0,0 +1,20 @@
+import type { RaxModelId, RaxProviderId, RaxProtocolId } from "../schema/index.js";
+export type RaxModelCatalogEntry = {
+    providerId: RaxProviderId | string;
+    modelId: RaxModelId | string;
+    protocolId: RaxProtocolId;
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    supportsTools?: boolean;
+    supportsReasoning?: boolean;
+    supportsVision?: boolean;
+    status?: "stable" | "preview" | "deprecated" | "unknown";
+    metadata?: Record<string, unknown>;
+};
+export declare class RaxModelCatalog {
+    readonly entries: Map<string, RaxModelCatalogEntry>;
+    register(entry: RaxModelCatalogEntry): void;
+    get(providerId: string, modelId: string): RaxModelCatalogEntry | undefined;
+    list(providerId?: string): RaxModelCatalogEntry[];
+}
+export declare const defaultRaxModelCatalog: RaxModelCatalog;

package/dist/modelAdapter/registry/modelCatalog.js

@@ -0,0 +1,14 @@
+export class RaxModelCatalog {
+    entries = new Map();
+    register(entry) {
+        this.entries.set(`${entry.providerId}:${entry.modelId}`, entry);
+    }
+    get(providerId, modelId) {
+        return this.entries.get(`${providerId}:${modelId}`);
+    }
+    list(providerId) {
+        const entries = [...this.entries.values()];
+        return providerId ? entries.filter((entry) => entry.providerId === providerId) : entries;
+    }
+}
+export const defaultRaxModelCatalog = new RaxModelCatalog();