@codeworksh/aikit 0.4.1-dev.20260530193930 → 0.4.1-dev.20260531044400

package/index.d.mts

@@ -1,6 +1,14 @@
 import Type$1, { Static, Static as Static$1, TSchema, TSchema as TSchema$1, Type, Type as Type$2 } from "typebox";
 import { statSync } from "fs";
 import { Readable } from "stream";
+import { AnthropicLanguageModelOptions, AnthropicProviderSettings } from "@ai-sdk/anthropic";
+import { GoogleGenerativeAIProviderSettings, GoogleLanguageModelOptions } from "@ai-sdk/google";
+import { GoogleVertexProviderSettings } from "@ai-sdk/google-vertex";
+import { GoogleVertexAnthropicProviderSettings } from "@ai-sdk/google-vertex/anthropic";
+import { OpenAILanguageModelChatOptions, OpenAILanguageModelCompletionOptions, OpenAILanguageModelResponsesOptions, OpenAIProviderSettings } from "@ai-sdk/openai";
+import { OpenAICompatibleLanguageModelChatOptions, OpenAICompatibleLanguageModelCompletionOptions, OpenAICompatibleProviderSettings } from "@ai-sdk/openai-compatible";
+import { XaiLanguageModelChatOptions, XaiLanguageModelResponsesOptions, XaiProviderSettings } from "@ai-sdk/xai";
+import { OpenRouterProviderOptions, OpenRouterProviderSettings } from "@openrouter/ai-sdk-provider";
 
 //#region src/event/event.d.ts
 declare namespace Event {
@@ -5453,13 +5461,13 @@ declare namespace Model {
         openaiCompatible?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-compatible" | "openrouter" | "xai" | undefined;
       } | undefined;
       protocol: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-compatible" | "openrouter" | "xai";
-      name: string;
       id: string;
+      name: string;
       provider: {
         key?: string | undefined;
         options?: Record<string, any> | undefined;
-        name: string;
         id: string;
+        name: string;
         source: "env" | "config" | "custom" | "api" | "unknown";
         env: string[];
       };
@@ -5478,7 +5486,8 @@ declare namespace Model {
     reset(): void;
   };
   function supportsProtocol(model: Info, protocol: KnownProviderEnum): boolean;
-  function getModel<TProtocol extends KnownProviderEnum = KnownProviderEnum>(provider: string, model: string, overrides?: Partial<Info> & {
+  type ProviderToProtocol<TProvider extends string> = TProvider extends KnownProviderEnum ? TProvider : KnownProviderEnum;
+  function getModel<TProvider extends string, TProtocol extends KnownProviderEnum = ProviderToProtocol<TProvider>>(provider: TProvider, model: string, overrides?: Partial<Info> & {
     protocol?: TProtocol;
   }): Promise<TModel<TProtocol> | undefined>;
   function getProviders(): Promise<string[]>;
@@ -5494,7 +5503,9 @@ declare namespace Model {
 //#endregion
 //#region src/llm.d.ts
 type LLM = {
-  <TProvider extends string, TModel extends Model.Info["id"]>(provider: TProvider, model: TModel, overrides?: Partial<Model.Info>): Promise<Model.Info | undefined>;
+  <TProvider extends string, TProtocol extends Model.KnownProviderEnum = Model.ProviderToProtocol<TProvider>>(provider: TProvider, model: string, overrides?: Partial<Model.Info> & {
+    protocol?: TProtocol;
+  }): Promise<Model.TModel<TProtocol> | undefined>;
   model: typeof Model.getModel;
   models: typeof Model.getModels;
   providers: typeof Model.getProviders;
@@ -6582,6 +6593,41 @@ declare class AssistantMessageEventStream extends EventStream<Event.LLMMessageEv
 /** Factory function for AssistantMessageEventStream (for use in extensions) */
 declare function createAssistantMessageEventStream(): AssistantMessageEventStream;
 //#endregion
+//#region src/llm/options.d.ts
+type ProviderOptionBag = Record<string, Record<string, unknown> | undefined>;
+type AISDKOptions<TFactoryOptions, TProviderOptions extends ProviderOptionBag = ProviderOptionBag> = Protocol.CommonOptions & {
+  baseURL?: string;
+  method?: Model.APIMethodEnum;
+  modelId?: string;
+  toolChoice?: unknown;
+  activeTools?: string[];
+  factoryOptions?: Partial<TFactoryOptions> & Record<string, unknown>;
+  providerOptions?: TProviderOptions & ProviderOptionBag;
+};
+type OpenAILanguageOptions = OpenAILanguageModelResponsesOptions | OpenAILanguageModelChatOptions | OpenAILanguageModelCompletionOptions;
+type OpenAICompatibleLanguageOptions = OpenAICompatibleLanguageModelChatOptions | OpenAICompatibleLanguageModelCompletionOptions;
+type XaiLanguageOptions = XaiLanguageModelResponsesOptions | XaiLanguageModelChatOptions;
+type OpenAIOptions = AISDKOptions<OpenAIProviderSettings, {
+  openai?: OpenAILanguageOptions;
+}>;
+type AnthropicOptions = AISDKOptions<AnthropicProviderSettings, {
+  anthropic?: AnthropicLanguageModelOptions;
+}>;
+type GoogleOptions = AISDKOptions<GoogleGenerativeAIProviderSettings, {
+  google?: GoogleLanguageModelOptions;
+}>;
+type GoogleVertexOptions = AISDKOptions<GoogleVertexProviderSettings>;
+type GoogleVertexAnthropicOptions = AISDKOptions<GoogleVertexAnthropicProviderSettings>;
+type OpenAICompatibleOptions = AISDKOptions<OpenAICompatibleProviderSettings, {
+  "openai-compatible"?: OpenAICompatibleLanguageOptions;
+}>;
+type OpenRouterOptions = AISDKOptions<OpenRouterProviderSettings, {
+  openrouter?: OpenRouterProviderOptions;
+}>;
+type XaiOptions = AISDKOptions<XaiProviderSettings, {
+  xai?: XaiLanguageOptions;
+}>;
+//#endregion
 //#region src/llm/shared.d.ts
 declare const ThinkingBudgets: Type$2.TObject<{
   minimal: Type$2.TOptional<Type$2.TNumber>;
@@ -7063,7 +7109,16 @@ declare namespace Protocol {
     reasoning?: Model.ActiveThinkingLevel;
     thinkingBudgets?: ThinkingBudgets;
   };
-  export interface OptionsByProtocol {}
+  export interface OptionsByProtocol {
+    [Model.KnownProviderEnum.openai]: OpenAIOptions;
+    [Model.KnownProviderEnum.anthropic]: AnthropicOptions;
+    [Model.KnownProviderEnum.google]: GoogleOptions;
+    [Model.KnownProviderEnum.googleVertex]: GoogleVertexOptions;
+    [Model.KnownProviderEnum.googleVertexAnthropic]: GoogleVertexAnthropicOptions;
+    [Model.KnownProviderEnum.openaiCompatible]: OpenAICompatibleOptions;
+    [Model.KnownProviderEnum.openrouter]: OpenRouterOptions;
+    [Model.KnownProviderEnum.xai]: XaiOptions;
+  }
   export type ProtocolWithOptions = keyof OptionsByProtocol & Model.KnownProviderEnum;
   export type OptionsFor<TProtocol extends ProtocolWithOptions> = OptionsByProtocol[TProtocol];
   export type StreamFunction<TProtocol extends Model.KnownProviderEnum = Model.KnownProviderEnum, S extends TSchema$1 = TSchema$1> = (model: Model.TModel<TProtocol>, context: Message.Context, options?: Static$1<S>) => AssistantMessageEventStream;
@@ -7144,5 +7199,5 @@ declare function validateToolCall<T extends Message.Tool>(tools: T[], toolExecut
  */
 declare function validateToolArguments<T extends Message.Tool>(tool: T, toolExecution: Message.ToolCallInFlight): Message.ToolArguments<T>;
 //#endregion
-export { type AssistantMessageEventStream, Event, EventStream, Message, Model, Protocol, type Static, type TSchema, ThinkingBudgets, Type, createAssistantMessageEventStream, llm, stream, validateSchema, validateToolArguments, validateToolCall };
+export { type AnthropicOptions, type AssistantMessageEventStream, Event, EventStream, type GoogleOptions, type GoogleVertexAnthropicOptions, type GoogleVertexOptions, Message, Model, type OpenAICompatibleOptions, type OpenAIOptions, type OpenRouterOptions, Protocol, type Static, type TSchema, ThinkingBudgets, Type, type XaiOptions, createAssistantMessageEventStream, llm, stream, validateSchema, validateToolArguments, validateToolCall };
 //# sourceMappingURL=index.d.mts.map