@nuvin/agent-core 0.0.0-rc.0

package/dist/models/index.d.ts

@@ -0,0 +1,344 @@
+import { P as ProviderSessionResolver, p as ResolvedProviderSession, q as ProviderRequestMutator, i as ModelRequest, r as PreparedRequest, j as ChatRequest, s as ProviderCredential, t as EngineChatModel, u as ReasoningConfig, v as ChatResponseChunk, l as ChatResponse, w as ModelExecutionOptions, B as BaseChatModelOptions, x as ModelInfo } from '../types-BueDJWnx.js';
+export { y as ProviderCredentialKind, z as ProviderEndpoints } from '../types-BueDJWnx.js';
+import { t as toOpenAiResponsesRequest } from '../provider-adapters-BHDQNPHa.js';
+
+interface PrepareProviderRequestOptions {
+    sessionManager?: ProviderSessionManager;
+    requestMutators?: ProviderRequestMutator[];
+    signal?: AbortSignal;
+}
+declare class ProviderSessionManager {
+    private readonly resolver;
+    private cached?;
+    constructor(resolver: ProviderSessionResolver);
+    resolve(signal?: AbortSignal): Promise<ResolvedProviderSession>;
+    invalidate(): void;
+}
+declare function prepareProviderRequest(request: ModelRequest, options?: PrepareProviderRequestOptions): Promise<PreparedRequest>;
+
+type RoutedModelMode = "complete" | "stream";
+interface ModelSurfaceRouter {
+    selectSurface(request: ChatRequest, options: {
+        mode: RoutedModelMode;
+    }): Promise<string> | string;
+}
+declare class StaticModelSurfaceRouter implements ModelSurfaceRouter {
+    private readonly completeSurface;
+    private readonly streamSurface;
+    constructor(options: {
+        complete: string;
+        stream: string;
+    });
+    selectSurface(_request: ChatRequest, options: {
+        mode: RoutedModelMode;
+    }): string;
+}
+
+interface ModelWebSocket {
+    readonly readyState: number;
+    addEventListener(type: "close" | "error" | "message" | "open", listener: EventListenerOrEventListenerObject): void;
+    close(code?: number, reason?: string): void;
+    removeEventListener(type: "close" | "error" | "message" | "open", listener: EventListenerOrEventListenerObject): void;
+    send(data: string): void;
+}
+type WebSocketFactory = (options: {
+    headers: Record<string, string>;
+    url: string;
+}) => ModelWebSocket;
+declare function createDefaultWebSocketFactory(): WebSocketFactory;
+declare function iterateSseEvents(response: Response, signal?: AbortSignal): AsyncGenerator<string>;
+declare function waitForWebSocketOpen(socket: ModelWebSocket, signal?: AbortSignal): Promise<void>;
+declare function iterateWebSocketMessages(socket: ModelWebSocket, signal?: AbortSignal): AsyncIterable<Record<string, unknown>>;
+declare function toWebSocketUrl(baseUrl: string, path: string): string;
+
+interface ProviderHeaderContext {
+    request?: ChatRequest;
+    body?: unknown;
+    credential: ProviderCredential;
+    session?: ResolvedProviderSession;
+    stream: boolean;
+}
+interface ProviderAdapter {
+    createHeaders(context: ProviderHeaderContext, options: {
+        accept: string;
+        includeContentType?: boolean;
+    }): Headers | Promise<Headers>;
+    createMissingCredentialError(): Error;
+    mapApiError(error: Error): Error;
+    resolveBaseUrl(defaultBaseUrl: string, session: ResolvedProviderSession | undefined): string;
+    resolveCredential(apiKey: string | undefined, session: ResolvedProviderSession | undefined): ProviderCredential | undefined;
+    toApiError(response: Response): Promise<Error>;
+}
+declare function trimTrailingSlashes(value: string): string;
+declare function resolveApiCredential(apiKey: string | undefined, session: ResolvedProviderSession | undefined): ProviderCredential | undefined;
+declare function resolveSessionBaseUrl(defaultBaseUrl: string, session: ResolvedProviderSession | undefined): string;
+
+interface RoutedModelStreamParser {
+    consumeSseEvent?(rawEvent: string): ChatResponseChunk[];
+    consumeWebSocketEvent?(event: Record<string, unknown>): ChatResponseChunk[];
+    finish(): ChatResponse;
+    isDone?(): boolean;
+}
+interface RoutedModelSurfaceRequest {
+    accept?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    initialEvent?: unknown;
+    path?: string;
+    url?: string;
+}
+interface RoutedModelSurface {
+    id: string;
+    transport: "http-json" | "http-sse" | "websocket";
+    createRequest(request: ChatRequest): RoutedModelSurfaceRequest;
+    createStreamParser?(request: ChatRequest): RoutedModelStreamParser;
+    parseResponse?(payload: unknown, request: ChatRequest): ChatResponse;
+}
+interface RoutedModelOptions {
+    apiKey?: string;
+    baseUrl: string;
+    fetch?: typeof globalThis.fetch;
+    model: string;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+    providerAdapter: ProviderAdapter;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    router: ModelSurfaceRouter;
+    sessionManager?: ProviderSessionManager;
+    surfaces: RoutedModelSurface[];
+    webSocketFactory?: WebSocketFactory;
+}
+declare class RoutedModel implements EngineChatModel {
+    readonly model: string;
+    readonly maxTokens: number;
+    protected readonly reasoning?: ReasoningConfig;
+    protected readonly apiKey?: string;
+    protected readonly baseUrl: string;
+    protected readonly fetchImpl: typeof globalThis.fetch;
+    protected readonly providerAdapter: ProviderAdapter;
+    protected readonly requestMutators: ProviderRequestMutator[];
+    protected readonly router: ModelSurfaceRouter;
+    protected readonly sessionManager?: ProviderSessionManager;
+    protected readonly webSocketFactory: WebSocketFactory;
+    private readonly surfaces;
+    constructor(options: RoutedModelOptions);
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected completeViaRouter(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected streamViaRouter(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected completeViaSurface(request: ChatRequest, surfaceId: string, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected streamViaSurface(request: ChatRequest, surfaceId: string, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected sendRawRequest(options: {
+        accept?: string;
+        body?: unknown;
+        method: "GET" | "POST";
+        path: string;
+        signal?: AbortSignal;
+    }): Promise<Response>;
+    protected createMissingCredentialError(): Error;
+    protected createHeaders(context: ProviderHeaderContext, options: {
+        accept: string;
+        includeContentType?: boolean;
+    }): Promise<Headers>;
+    protected mapApiError(error: Error): Error;
+    protected toApiError(response: Response): Promise<Error>;
+    private getSurface;
+    private prepareChatRequest;
+    protected applyModelDefaults(request: ChatRequest): ChatRequest;
+    private sendHttpSurfaceRequest;
+    private streamHttpSurface;
+    private streamWebSocketSurface;
+}
+
+interface AnthropicModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    baseUrl?: string;
+    protocolVersion?: string;
+    authScheme?: "bearer" | "x-api-key";
+    fetch?: typeof globalThis.fetch;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    headerResolver?: AnthropicHeaderResolver;
+}
+interface AnthropicRequestHeadersContext {
+    request?: ChatRequest;
+    body: unknown;
+    credential: ProviderCredential;
+    session?: ResolvedProviderSession;
+    stream: boolean;
+}
+type AnthropicHeaderResolver = (context: AnthropicRequestHeadersContext) => Promise<Record<string, string>> | Record<string, string>;
+declare class AnthropicModel extends RoutedModel {
+    constructor(options?: AnthropicModelOptions);
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+}
+
+declare const ANTHROPIC_MESSAGES_SURFACE = "anthropic-messages";
+declare const ANTHROPIC_MESSAGES_STREAM_SURFACE = "anthropic-messages-stream";
+declare function createAnthropicSurfaces(): RoutedModelSurface[];
+
+declare const OPENAI_CHAT_COMPLETIONS_SURFACE = "openai-chat-completions";
+declare const OPENAI_CHAT_COMPLETIONS_STREAM_SURFACE = "openai-chat-completions-stream";
+declare const OPENAI_RESPONSES_SURFACE = "openai-responses";
+declare const OPENAI_RESPONSES_STREAM_SURFACE = "openai-responses-stream";
+declare const OPENAI_RESPONSES_WEBSOCKET_SURFACE = "openai-responses-ws";
+declare class OpenAiApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string, message: string);
+}
+declare class OpenAiResponsesStreamError extends Error {
+    readonly code?: string;
+    readonly status?: number;
+    constructor(message: string, options?: {
+        code?: string;
+        status?: number;
+    });
+}
+declare function createOpenAiResponsesWebSocketEvent(request: ChatRequest, options?: {
+    input?: ReturnType<typeof toOpenAiResponsesRequest>["input"];
+    previousResponseId?: string;
+}): Record<string, unknown>;
+declare function createOpenAiApiError(response: Response): Promise<OpenAiApiError>;
+declare function createOpenAiResponsesStreamParser(request: ChatRequest): RoutedModelStreamParser;
+declare function createOpenAiSurfaces(options?: {
+    chatCompletionsPath?: string;
+    responsesPath?: string;
+}): RoutedModelSurface[];
+
+interface OpenAiRequestHeadersContext {
+    request?: ChatRequest;
+    body: unknown;
+    credential: ProviderCredential;
+    session?: ResolvedProviderSession;
+    stream: boolean;
+}
+type OpenAiHeaderResolver = (context: OpenAiRequestHeadersContext) => Promise<Record<string, string>> | Record<string, string>;
+interface OpenAiModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    baseUrl?: string;
+    chatCompletionsPath?: string;
+    responsesPath?: string;
+    fetch?: typeof globalThis.fetch;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    headerResolver?: OpenAiHeaderResolver;
+    sessionManager?: ProviderSessionManager;
+    webSocketFactory?: WebSocketFactory;
+}
+declare class OpenAiModel extends RoutedModel {
+    private static readonly sharedResponsesSocketSessions;
+    protected readonly chatCompletionsPath: string;
+    protected readonly responsesPath: string;
+    constructor(options?: OpenAiModelOptions);
+    protected completeViaChatCompletionsSurface(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected completeViaResponsesSurface(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected completeViaResponsesWebSocketSurface(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    protected streamViaChatCompletionsSurface(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected streamViaResponsesSurface(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    protected streamViaResponsesWebSocketSurface(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    chatComplete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    response(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    responseSocket(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    chatStream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    responseStream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    responseSocketStream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    private getResponsesSocketSessionState;
+    private getResponsesSocketSessionKey;
+    private acquireResponsesSocketLock;
+    private prepareResponsesSocketRequest;
+    private buildResponsesSocketEvent;
+    private findResponsesSocketCheckpoint;
+    private shouldRetryResponsesSocketRequest;
+    private invalidateResponsesSocketSession;
+    private getOrCreateResponsesSocket;
+    private streamViaPersistentResponsesSocket;
+    private streamViaResponsesSocketAttempt;
+}
+
+declare const AVAILABLE_CHAT_MODEL_SURFACES: readonly ["anthropic-messages", "openai-chat-completions", "openai-responses", "openai-responses-ws"];
+type ChatModelSurface = (typeof AVAILABLE_CHAT_MODEL_SURFACES)[number];
+type ChatModelAuthScheme = NonNullable<AnthropicModelOptions["authScheme"]>;
+interface ChatModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    baseUrl?: string;
+    surface?: ChatModelSurface;
+    authScheme?: ChatModelAuthScheme;
+    fetch?: typeof globalThis.fetch;
+    providerSessionResolver?: ProviderSessionResolver;
+    requestMutators?: ProviderRequestMutator[];
+    headerResolver?: OpenAiHeaderResolver;
+    webSocketFactory?: WebSocketFactory;
+}
+declare class ChatModel implements EngineChatModel {
+    readonly model: string;
+    readonly maxTokens: number;
+    readonly surface: ChatModelSurface;
+    private readonly anthropicDelegate?;
+    private readonly openAiDelegate?;
+    constructor(options?: ChatModelOptions);
+    private getAnthropicDelegate;
+    private getOpenAiDelegate;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+}
+
+type GitHubModelSurface = "auto" | "anthropic-messages" | "openai-chat-completions" | "openai-responses" | "openai-responses-ws";
+interface GitHubModelOptions extends Partial<BaseChatModelOptions> {
+    apiKey?: string;
+    accessToken?: string;
+    baseUrl?: string;
+    surface?: GitHubModelSurface;
+    githubApiUrl?: string;
+    fetch?: typeof globalThis.fetch;
+    editorVersion?: string;
+    editorPluginVersion?: string;
+    tokenExchangeApiVersion?: string;
+    providerSessionResolver?: ProviderSessionResolver;
+}
+declare class GitHubModel extends OpenAiModel {
+    private readonly anthropicDelegate;
+    private readonly modelEndpointCache;
+    private readonly surface;
+    constructor(options?: GitHubModelOptions);
+    protected createMissingCredentialError(): Error;
+    private usesResponsesApi;
+    private shouldPreferResponsesApi;
+    private markModelAsResponsesOnly;
+    protected mapApiError(error: Error): Error;
+    private completeViaConfiguredSurface;
+    private streamViaConfiguredSurface;
+    complete(request: ChatRequest, options?: ModelExecutionOptions): Promise<ChatResponse>;
+    stream(request: ChatRequest, options?: ModelExecutionOptions): AsyncIterable<ChatResponseChunk>;
+    getModels(signal?: AbortSignal): Promise<ModelInfo[]>;
+}
+
+interface FetchJsonOptions {
+    url: string;
+    body: unknown;
+    headers: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+    signal?: AbortSignal;
+}
+declare function fetchRawResponse(options: FetchJsonOptions): Promise<Response>;
+declare function fetchJsonResponse<T>(options: FetchJsonOptions): Promise<T>;
+
+interface MockModelOptions {
+    model?: string;
+    maxTokens?: number;
+    reasoning?: ReasoningConfig;
+}
+declare class MockModel implements EngineChatModel {
+    readonly model: string;
+    readonly maxTokens: number;
+    readonly requests: ChatRequest[];
+    private readonly reasoning?;
+    constructor(options?: MockModelOptions);
+    complete(request: ChatRequest, _options?: ModelExecutionOptions): Promise<ChatResponse>;
+}
+
+export { ANTHROPIC_MESSAGES_STREAM_SURFACE, ANTHROPIC_MESSAGES_SURFACE, AVAILABLE_CHAT_MODEL_SURFACES, type AnthropicHeaderResolver, AnthropicModel, type AnthropicModelOptions, type AnthropicRequestHeadersContext, ChatModel, type ChatModelAuthScheme, type ChatModelOptions, type ChatModelSurface, type FetchJsonOptions, GitHubModel, type GitHubModelOptions, type GitHubModelSurface, MockModel, type MockModelOptions, type ModelSurfaceRouter, type ModelWebSocket, OPENAI_CHAT_COMPLETIONS_STREAM_SURFACE, OPENAI_CHAT_COMPLETIONS_SURFACE, OPENAI_RESPONSES_STREAM_SURFACE, OPENAI_RESPONSES_SURFACE, OPENAI_RESPONSES_WEBSOCKET_SURFACE, OpenAiApiError, type OpenAiHeaderResolver, OpenAiModel, type OpenAiModelOptions, type OpenAiRequestHeadersContext, OpenAiResponsesStreamError, type PrepareProviderRequestOptions, type ProviderAdapter, ProviderCredential, type ProviderHeaderContext, ProviderRequestMutator, ProviderSessionManager, ProviderSessionResolver, ResolvedProviderSession, RoutedModel, type RoutedModelMode, type RoutedModelOptions, type RoutedModelStreamParser, type RoutedModelSurface, type RoutedModelSurfaceRequest, StaticModelSurfaceRouter, type WebSocketFactory, createAnthropicSurfaces, createDefaultWebSocketFactory, createOpenAiApiError, createOpenAiResponsesStreamParser, createOpenAiResponsesWebSocketEvent, createOpenAiSurfaces, fetchJsonResponse, fetchRawResponse, iterateSseEvents, iterateWebSocketMessages, prepareProviderRequest, resolveApiCredential, resolveSessionBaseUrl, toWebSocketUrl, trimTrailingSlashes, waitForWebSocketOpen };