@codeworksh/aikit 0.7.1 → 0.7.2-dev.20260825090340

package/model-CKKq3s4y.d.mts

@@ -0,0 +1,1138 @@
+import Type$1, { Static, TSchema } from "typebox";
+//#region src/model/catalog.d.ts
+declare const KnownProviderEnum$1: {
+  readonly anthropic: "anthropic";
+  readonly google: "google";
+  readonly googleVertex: "google-vertex";
+  readonly googleVertexAnthropic: "google-vertex-anthropic";
+  readonly openai: "openai";
+  readonly openaiCompatible: "openai-compatible";
+  readonly openaiCodex: "openai-codex";
+  readonly openrouter: "openrouter";
+  readonly xai: "xai";
+};
+declare const KnownProviderEnumSchema$1: Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>;
+type KnownProviderEnum$1 = Static<typeof KnownProviderEnumSchema$1>;
+declare const ModelCatalogLoadError$1: {
+  new (data: {
+    path: string;
+    reason: "empty" | "invalid" | "missing" | "unreadable";
+    message: string;
+  }, options?: ErrorOptions): {
+    cause?: unknown;
+    readonly name: "ModelCatalogLoadError";
+    readonly data: {
+      path: string;
+      reason: "empty" | "invalid" | "missing" | "unreadable";
+      message: string;
+    };
+    schema(): {
+      readonly $id: "ModelCatalogLoadError";
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: "ModelCatalogLoadError";
+        };
+        readonly data: Type$1.TObject<{
+          path: Type$1.TString;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          message: Type$1.TString;
+        }>;
+      };
+    };
+    toObject(): {
+      name: "ModelCatalogLoadError";
+      data: {
+        path: string;
+        reason: "empty" | "invalid" | "missing" | "unreadable";
+        message: string;
+      };
+    };
+    message: string;
+    stack?: string;
+    readonly "~effect/ErrorReporter/ignore"?: boolean;
+    readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+    readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    readonly "~effect/Runtime/errorExitCode"?: number;
+    readonly "~effect/Runtime/errorReported"?: boolean;
+  };
+  readonly Schema: {
+    readonly $id: "ModelCatalogLoadError";
+    readonly type: "object";
+    readonly required: readonly ["name", "data"];
+    readonly properties: {
+      readonly name: {
+        readonly const: "ModelCatalogLoadError";
+      };
+      readonly data: Type$1.TObject<{
+        path: Type$1.TString;
+        reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+        message: Type$1.TString;
+      }>;
+    };
+  };
+  isInstance(input: unknown): input is {
+    cause?: unknown;
+    readonly name: "ModelCatalogLoadError";
+    readonly data: {
+      path: string;
+      reason: "empty" | "invalid" | "missing" | "unreadable";
+      message: string;
+    };
+    schema(): {
+      readonly $id: "ModelCatalogLoadError";
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: "ModelCatalogLoadError";
+        };
+        readonly data: Type$1.TObject<{
+          path: Type$1.TString;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          message: Type$1.TString;
+        }>;
+      };
+    };
+    toObject(): {
+      name: "ModelCatalogLoadError";
+      data: {
+        path: string;
+        reason: "empty" | "invalid" | "missing" | "unreadable";
+        message: string;
+      };
+    };
+    message: string;
+    stack?: string;
+    readonly "~effect/ErrorReporter/ignore"?: boolean;
+    readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+    readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    readonly "~effect/Runtime/errorExitCode"?: number;
+    readonly "~effect/Runtime/errorReported"?: boolean;
+  };
+  create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): {
+    new (data: import("typebox").StaticType<[], "Encode", {}, {}, Data>, options?: ErrorOptions): {
+      cause?: unknown;
+      readonly name: Name;
+      readonly data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+      schema(): {
+        readonly $id: Name;
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: Name;
+          };
+          readonly data: Data;
+        };
+      };
+      toObject(): {
+        name: Name;
+        data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+      };
+      message: string;
+      stack?: string;
+      readonly "~effect/ErrorReporter/ignore"?: boolean;
+      readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+      readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+      readonly "~effect/Runtime/errorExitCode"?: number;
+      readonly "~effect/Runtime/errorReported"?: boolean;
+    };
+    readonly Schema: {
+      readonly $id: Name;
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: Name;
+        };
+        readonly data: Data;
+      };
+    };
+    isInstance(input: unknown): input is InstanceType< /*elided*/ any>;
+    create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): /*elided*/ any;
+    readonly Unknown: {
+      new (data: {
+        message?: unknown;
+      }, options?: ErrorOptions): {
+        cause?: unknown;
+        readonly name: "UnknownError";
+        readonly data: {
+          message?: unknown;
+        };
+        schema(): {
+          readonly $id: "UnknownError";
+          readonly type: "object";
+          readonly required: readonly ["name", "data"];
+          readonly properties: {
+            readonly name: {
+              readonly const: "UnknownError";
+            };
+            readonly data: {
+              type: string;
+              required: string[];
+              properties: {
+                message: {
+                  type: string;
+                };
+              };
+            };
+          };
+        };
+        toObject(): {
+          name: "UnknownError";
+          data: {
+            message?: unknown;
+          };
+        };
+        message: string;
+        stack?: string;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+      };
+      readonly Schema: {
+        readonly $id: "UnknownError";
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: "UnknownError";
+          };
+          readonly data: {
+            type: string;
+            required: string[];
+            properties: {
+              message: {
+                type: string;
+              };
+            };
+          };
+        };
+      };
+      isInstance(input: unknown): input is {
+        cause?: unknown;
+        readonly name: "UnknownError";
+        readonly data: {
+          message?: unknown;
+        };
+        schema(): {
+          readonly $id: "UnknownError";
+          readonly type: "object";
+          readonly required: readonly ["name", "data"];
+          readonly properties: {
+            readonly name: {
+              readonly const: "UnknownError";
+            };
+            readonly data: {
+              type: string;
+              required: string[];
+              properties: {
+                message: {
+                  type: string;
+                };
+              };
+            };
+          };
+        };
+        toObject(): {
+          name: "UnknownError";
+          data: {
+            message?: unknown;
+          };
+        };
+        message: string;
+        stack?: string;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+      };
+      create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): /*elided*/ any;
+      readonly Unknown: /*elided*/ any;
+      captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+      prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+      stackTraceLimit: number;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+  readonly Unknown: {
+    new (data: {
+      message?: unknown;
+    }, options?: ErrorOptions): {
+      cause?: unknown;
+      readonly name: "UnknownError";
+      readonly data: {
+        message?: unknown;
+      };
+      schema(): {
+        readonly $id: "UnknownError";
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: "UnknownError";
+          };
+          readonly data: {
+            type: string;
+            required: string[];
+            properties: {
+              message: {
+                type: string;
+              };
+            };
+          };
+        };
+      };
+      toObject(): {
+        name: "UnknownError";
+        data: {
+          message?: unknown;
+        };
+      };
+      message: string;
+      stack?: string;
+      readonly "~effect/ErrorReporter/ignore"?: boolean;
+      readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+      readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+      readonly "~effect/Runtime/errorExitCode"?: number;
+      readonly "~effect/Runtime/errorReported"?: boolean;
+    };
+    readonly Schema: {
+      readonly $id: "UnknownError";
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: "UnknownError";
+        };
+        readonly data: {
+          type: string;
+          required: string[];
+          properties: {
+            message: {
+              type: string;
+            };
+          };
+        };
+      };
+    };
+    isInstance(input: unknown): input is {
+      cause?: unknown;
+      readonly name: "UnknownError";
+      readonly data: {
+        message?: unknown;
+      };
+      schema(): {
+        readonly $id: "UnknownError";
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: "UnknownError";
+          };
+          readonly data: {
+            type: string;
+            required: string[];
+            properties: {
+              message: {
+                type: string;
+              };
+            };
+          };
+        };
+      };
+      toObject(): {
+        name: "UnknownError";
+        data: {
+          message?: unknown;
+        };
+      };
+      message: string;
+      stack?: string;
+      readonly "~effect/ErrorReporter/ignore"?: boolean;
+      readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+      readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+      readonly "~effect/Runtime/errorExitCode"?: number;
+      readonly "~effect/Runtime/errorReported"?: boolean;
+    };
+    create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): {
+      new (data: import("typebox").StaticType<[], "Encode", {}, {}, Data>, options?: ErrorOptions): {
+        cause?: unknown;
+        readonly name: Name;
+        readonly data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+        schema(): {
+          readonly $id: Name;
+          readonly type: "object";
+          readonly required: readonly ["name", "data"];
+          readonly properties: {
+            readonly name: {
+              readonly const: Name;
+            };
+            readonly data: Data;
+          };
+        };
+        toObject(): {
+          name: Name;
+          data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+        };
+        message: string;
+        stack?: string;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+      };
+      readonly Schema: {
+        readonly $id: Name;
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: Name;
+          };
+          readonly data: Data;
+        };
+      };
+      isInstance(input: unknown): input is InstanceType< /*elided*/ any>;
+      create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): /*elided*/ any;
+      readonly Unknown: /*elided*/ any;
+      captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+      prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+      stackTraceLimit: number;
+    };
+    readonly Unknown: /*elided*/ any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+  prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+  stackTraceLimit: number;
+};
+type ModelCatalogLoadError$1 = InstanceType<typeof ModelCatalogLoadError$1>;
+declare namespace model_d_exports {
+  export { APIMetadata, APIMetadataSchema, APIMethodEnum, APIMethodEnumSchema, ActiveThinkingLevel, BuiltInModels, Compatibility, CompatibilitySchema, ExtrasSchema, Info, KnownProviderEnum, KnownProviderEnumSchema, ModelCatalogLoadError, ProviderInfo, ProviderToProtocol, Schema, TModel, ThinkingLevel, ThinkingLevelEnum, ThinkingLevelMap, ThinkingLevelMapSchema, calculateCost, clampThinkingLevel, getBuiltInModels, getModel, getModels, getProviders, getSupportedThinkingLevels, modelsAreEqual, normalizeInput, registry, supportsProtocol };
+}
+declare const KnownProviderEnum: {
+  readonly anthropic: "anthropic";
+  readonly google: "google";
+  readonly googleVertex: "google-vertex";
+  readonly googleVertexAnthropic: "google-vertex-anthropic";
+  readonly openai: "openai";
+  readonly openaiCompatible: "openai-compatible";
+  readonly openaiCodex: "openai-codex";
+  readonly openrouter: "openrouter";
+  readonly xai: "xai";
+};
+declare const KnownProviderEnumSchema: Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>;
+type KnownProviderEnum = KnownProviderEnum$1;
+declare const ModelCatalogLoadError: {
+  new (data: {
+    path: string;
+    reason: "empty" | "invalid" | "missing" | "unreadable";
+    message: string;
+  }, options?: ErrorOptions): {
+    cause?: unknown;
+    readonly name: "ModelCatalogLoadError";
+    readonly data: {
+      path: string;
+      reason: "empty" | "invalid" | "missing" | "unreadable";
+      message: string;
+    };
+    schema(): {
+      readonly $id: "ModelCatalogLoadError";
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: "ModelCatalogLoadError";
+        };
+        readonly data: Type$1.TObject<{
+          path: Type$1.TString;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          message: Type$1.TString;
+        }>;
+      };
+    };
+    toObject(): {
+      name: "ModelCatalogLoadError";
+      data: {
+        path: string;
+        reason: "empty" | "invalid" | "missing" | "unreadable";
+        message: string;
+      };
+    };
+    message: string;
+    stack?: string;
+    readonly "~effect/ErrorReporter/ignore"?: boolean;
+    readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+    readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    readonly "~effect/Runtime/errorExitCode"?: number;
+    readonly "~effect/Runtime/errorReported"?: boolean;
+  };
+  readonly Schema: {
+    readonly $id: "ModelCatalogLoadError";
+    readonly type: "object";
+    readonly required: readonly ["name", "data"];
+    readonly properties: {
+      readonly name: {
+        readonly const: "ModelCatalogLoadError";
+      };
+      readonly data: Type$1.TObject<{
+        path: Type$1.TString;
+        reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+        message: Type$1.TString;
+      }>;
+    };
+  };
+  isInstance(input: unknown): input is {
+    cause?: unknown;
+    readonly name: "ModelCatalogLoadError";
+    readonly data: {
+      path: string;
+      reason: "empty" | "invalid" | "missing" | "unreadable";
+      message: string;
+    };
+    schema(): {
+      readonly $id: "ModelCatalogLoadError";
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: "ModelCatalogLoadError";
+        };
+        readonly data: Type$1.TObject<{
+          path: Type$1.TString;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          message: Type$1.TString;
+        }>;
+      };
+    };
+    toObject(): {
+      name: "ModelCatalogLoadError";
+      data: {
+        path: string;
+        reason: "empty" | "invalid" | "missing" | "unreadable";
+        message: string;
+      };
+    };
+    message: string;
+    stack?: string;
+    readonly "~effect/ErrorReporter/ignore"?: boolean;
+    readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+    readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    readonly "~effect/Runtime/errorExitCode"?: number;
+    readonly "~effect/Runtime/errorReported"?: boolean;
+  };
+  create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): {
+    new (data: import("typebox").StaticType<[], "Encode", {}, {}, Data>, options?: ErrorOptions): {
+      cause?: unknown;
+      readonly name: Name;
+      readonly data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+      schema(): {
+        readonly $id: Name;
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: Name;
+          };
+          readonly data: Data;
+        };
+      };
+      toObject(): {
+        name: Name;
+        data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+      };
+      message: string;
+      stack?: string;
+      readonly "~effect/ErrorReporter/ignore"?: boolean;
+      readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+      readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+      readonly "~effect/Runtime/errorExitCode"?: number;
+      readonly "~effect/Runtime/errorReported"?: boolean;
+    };
+    readonly Schema: {
+      readonly $id: Name;
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: Name;
+        };
+        readonly data: Data;
+      };
+    };
+    isInstance(input: unknown): input is InstanceType< /*elided*/ any>;
+    create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): /*elided*/ any;
+    readonly Unknown: {
+      new (data: {
+        message?: unknown;
+      }, options?: ErrorOptions): {
+        cause?: unknown;
+        readonly name: "UnknownError";
+        readonly data: {
+          message?: unknown;
+        };
+        schema(): {
+          readonly $id: "UnknownError";
+          readonly type: "object";
+          readonly required: readonly ["name", "data"];
+          readonly properties: {
+            readonly name: {
+              readonly const: "UnknownError";
+            };
+            readonly data: {
+              type: string;
+              required: string[];
+              properties: {
+                message: {
+                  type: string;
+                };
+              };
+            };
+          };
+        };
+        toObject(): {
+          name: "UnknownError";
+          data: {
+            message?: unknown;
+          };
+        };
+        message: string;
+        stack?: string;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+      };
+      readonly Schema: {
+        readonly $id: "UnknownError";
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: "UnknownError";
+          };
+          readonly data: {
+            type: string;
+            required: string[];
+            properties: {
+              message: {
+                type: string;
+              };
+            };
+          };
+        };
+      };
+      isInstance(input: unknown): input is {
+        cause?: unknown;
+        readonly name: "UnknownError";
+        readonly data: {
+          message?: unknown;
+        };
+        schema(): {
+          readonly $id: "UnknownError";
+          readonly type: "object";
+          readonly required: readonly ["name", "data"];
+          readonly properties: {
+            readonly name: {
+              readonly const: "UnknownError";
+            };
+            readonly data: {
+              type: string;
+              required: string[];
+              properties: {
+                message: {
+                  type: string;
+                };
+              };
+            };
+          };
+        };
+        toObject(): {
+          name: "UnknownError";
+          data: {
+            message?: unknown;
+          };
+        };
+        message: string;
+        stack?: string;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+      };
+      create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): /*elided*/ any;
+      readonly Unknown: /*elided*/ any;
+      captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+      prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+      stackTraceLimit: number;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+  readonly Unknown: {
+    new (data: {
+      message?: unknown;
+    }, options?: ErrorOptions): {
+      cause?: unknown;
+      readonly name: "UnknownError";
+      readonly data: {
+        message?: unknown;
+      };
+      schema(): {
+        readonly $id: "UnknownError";
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: "UnknownError";
+          };
+          readonly data: {
+            type: string;
+            required: string[];
+            properties: {
+              message: {
+                type: string;
+              };
+            };
+          };
+        };
+      };
+      toObject(): {
+        name: "UnknownError";
+        data: {
+          message?: unknown;
+        };
+      };
+      message: string;
+      stack?: string;
+      readonly "~effect/ErrorReporter/ignore"?: boolean;
+      readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+      readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+      readonly "~effect/Runtime/errorExitCode"?: number;
+      readonly "~effect/Runtime/errorReported"?: boolean;
+    };
+    readonly Schema: {
+      readonly $id: "UnknownError";
+      readonly type: "object";
+      readonly required: readonly ["name", "data"];
+      readonly properties: {
+        readonly name: {
+          readonly const: "UnknownError";
+        };
+        readonly data: {
+          type: string;
+          required: string[];
+          properties: {
+            message: {
+              type: string;
+            };
+          };
+        };
+      };
+    };
+    isInstance(input: unknown): input is {
+      cause?: unknown;
+      readonly name: "UnknownError";
+      readonly data: {
+        message?: unknown;
+      };
+      schema(): {
+        readonly $id: "UnknownError";
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: "UnknownError";
+          };
+          readonly data: {
+            type: string;
+            required: string[];
+            properties: {
+              message: {
+                type: string;
+              };
+            };
+          };
+        };
+      };
+      toObject(): {
+        name: "UnknownError";
+        data: {
+          message?: unknown;
+        };
+      };
+      message: string;
+      stack?: string;
+      readonly "~effect/ErrorReporter/ignore"?: boolean;
+      readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+      readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+      readonly "~effect/Runtime/errorExitCode"?: number;
+      readonly "~effect/Runtime/errorReported"?: boolean;
+    };
+    create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): {
+      new (data: import("typebox").StaticType<[], "Encode", {}, {}, Data>, options?: ErrorOptions): {
+        cause?: unknown;
+        readonly name: Name;
+        readonly data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+        schema(): {
+          readonly $id: Name;
+          readonly type: "object";
+          readonly required: readonly ["name", "data"];
+          readonly properties: {
+            readonly name: {
+              readonly const: Name;
+            };
+            readonly data: Data;
+          };
+        };
+        toObject(): {
+          name: Name;
+          data: import("typebox").StaticType<[], "Encode", {}, {}, Data>;
+        };
+        message: string;
+        stack?: string;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+      };
+      readonly Schema: {
+        readonly $id: Name;
+        readonly type: "object";
+        readonly required: readonly ["name", "data"];
+        readonly properties: {
+          readonly name: {
+            readonly const: Name;
+          };
+          readonly data: Data;
+        };
+      };
+      isInstance(input: unknown): input is InstanceType< /*elided*/ any>;
+      create<Name extends string, Data extends import("typebox").TSchema>(name: Name, data: Data): /*elided*/ any;
+      readonly Unknown: /*elided*/ any;
+      captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+      prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+      stackTraceLimit: number;
+    };
+    readonly Unknown: /*elided*/ any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+  prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+  stackTraceLimit: number;
+};
+type ModelCatalogLoadError = ModelCatalogLoadError$1;
+declare const ThinkingLevelEnum: {
+  readonly off: "off";
+  readonly minimal: "minimal";
+  readonly low: "low";
+  readonly medium: "medium";
+  readonly high: "high";
+  readonly xhigh: "xhigh";
+  readonly max: "max";
+};
+declare const ThinkingLevel: Type$1.TUnion<[Type$1.TLiteral<"off">, Type$1.TLiteral<"minimal">, Type$1.TLiteral<"low">, Type$1.TLiteral<"medium">, Type$1.TLiteral<"high">, Type$1.TLiteral<"xhigh">, Type$1.TLiteral<"max">]>;
+type ThinkingLevel = Static<typeof ThinkingLevel>;
+declare const ActiveThinkingLevel: Type$1.TUnion<[Type$1.TLiteral<"minimal">, Type$1.TLiteral<"low">, Type$1.TLiteral<"medium">, Type$1.TLiteral<"high">, Type$1.TLiteral<"xhigh">, Type$1.TLiteral<"max">]>;
+type ActiveThinkingLevel = Static<typeof ActiveThinkingLevel>;
+declare const ProviderInfo: Type$1.TObject<{
+  id: Type$1.TString;
+  name: Type$1.TString;
+  source: Type$1.TEnum<["env", "config", "custom", "api", "unknown"]>;
+  env: Type$1.TArray<Type$1.TString>;
+  key: Type$1.TOptional<Type$1.TString>;
+  options: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TAny>>;
+}>;
+type ProviderInfo = Static<typeof ProviderInfo>;
+declare const APIMethodEnum: {
+  readonly languageModel: "languageModel";
+  readonly chat: "chat";
+  readonly completion: "completion";
+  readonly completionModel: "completionModel";
+  readonly messages: "messages";
+  readonly responses: "responses";
+};
+declare const APIMethodEnumSchema: Type$1.TUnion<[Type$1.TLiteral<"languageModel">, Type$1.TLiteral<"chat">, Type$1.TLiteral<"completion">, Type$1.TLiteral<"completionModel">, Type$1.TLiteral<"messages">, Type$1.TLiteral<"responses">]>;
+type APIMethodEnum = Static<typeof APIMethodEnumSchema>;
+declare const APIMetadataSchema: Type$1.TObject<{
+  id: Type$1.TOptional<Type$1.TString>;
+  url: Type$1.TOptional<Type$1.TString>;
+  method: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"languageModel">, Type$1.TLiteral<"chat">, Type$1.TLiteral<"completion">, Type$1.TLiteral<"completionModel">, Type$1.TLiteral<"messages">, Type$1.TLiteral<"responses">]>>;
+}>;
+type APIMetadata = Static<typeof APIMetadataSchema>;
+declare const ThinkingLevelMapSchema: Type$1.TObject<{
+  high: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  low: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  max: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  medium: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  minimal: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  off: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  xhigh: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+}>;
+type ThinkingLevelMap = Static<typeof ThinkingLevelMapSchema>;
+declare const CompatibilitySchema: Type$1.TObject<{
+  supportsToolSearch: Type$1.TOptional<Type$1.TBoolean>;
+  supportsAdditionalTools: Type$1.TOptional<Type$1.TBoolean>;
+  supportsStrictMode: Type$1.TOptional<Type$1.TBoolean>;
+  supportsOpenAIGrammarTools: Type$1.TOptional<Type$1.TBoolean>;
+}>;
+type Compatibility = Static<typeof CompatibilitySchema>;
+declare const Schema: Type$1.TObject<{
+  id: Type$1.TString;
+  name: Type$1.TString;
+  provider: Type$1.TObject<{
+    id: Type$1.TString;
+    name: Type$1.TString;
+    source: Type$1.TEnum<["env", "config", "custom", "api", "unknown"]>;
+    env: Type$1.TArray<Type$1.TString>;
+    key: Type$1.TOptional<Type$1.TString>;
+    options: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TAny>>;
+  }>;
+  baseUrl: Type$1.TString;
+  reasoning: Type$1.TBoolean;
+  thinkingLevelMap: Type$1.TOptional<Type$1.TObject<{
+    high: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    low: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    max: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    medium: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    minimal: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    off: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    xhigh: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  }>>;
+  input: Type$1.TArray<Type$1.TUnion<[Type$1.TLiteral<"text">, Type$1.TLiteral<"image">]>>;
+  cost: Type$1.TObject<{
+    input: Type$1.TNumber;
+    output: Type$1.TNumber;
+    cacheRead: Type$1.TNumber;
+    cacheWrite: Type$1.TNumber;
+    tiers: Type$1.TOptional<Type$1.TArray<Type$1.TObject<{
+      input: Type$1.TNumber;
+      output: Type$1.TNumber;
+      cacheRead: Type$1.TNumber;
+      cacheWrite: Type$1.TNumber;
+      inputTokensAbove: Type$1.TNumber;
+    }>>>;
+  }>;
+  contextWindow: Type$1.TNumber;
+  maxTokens: Type$1.TNumber;
+  headers: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TString>>;
+  npm: Type$1.TOptional<Type$1.TString>;
+  api: Type$1.TOptional<Type$1.TObject<{
+    id: Type$1.TOptional<Type$1.TString>;
+    url: Type$1.TOptional<Type$1.TString>;
+    method: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"languageModel">, Type$1.TLiteral<"chat">, Type$1.TLiteral<"completion">, Type$1.TLiteral<"completionModel">, Type$1.TLiteral<"messages">, Type$1.TLiteral<"responses">]>>;
+  }>>;
+  providerOptionsKey: Type$1.TOptional<Type$1.TString>;
+  options: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TUnknown>>;
+  providerOptions: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TUnknown>>;
+  compat: Type$1.TOptional<Type$1.TObject<{
+    supportsToolSearch: Type$1.TOptional<Type$1.TBoolean>;
+    supportsAdditionalTools: Type$1.TOptional<Type$1.TBoolean>;
+    supportsStrictMode: Type$1.TOptional<Type$1.TBoolean>;
+    supportsOpenAIGrammarTools: Type$1.TOptional<Type$1.TBoolean>;
+  }>>;
+  protocol: Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>;
+  supportedProtocols: Type$1.TOptional<Type$1.TObject<{
+    anthropic: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    google: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    googleVertex: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    googleVertexAnthropic: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openai: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openaiCompatible: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openaiCodex: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openrouter: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    xai: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+  }>>;
+}>;
+declare const ExtrasSchema: Type$1.TObject<{}>;
+declare const Info: Type$1.TObject<{
+  id: Type$1.TString;
+  name: Type$1.TString;
+  provider: Type$1.TObject<{
+    id: Type$1.TString;
+    name: Type$1.TString;
+    source: Type$1.TEnum<["env", "config", "custom", "api", "unknown"]>;
+    env: Type$1.TArray<Type$1.TString>;
+    key: Type$1.TOptional<Type$1.TString>;
+    options: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TAny>>;
+  }>;
+  baseUrl: Type$1.TString;
+  reasoning: Type$1.TBoolean;
+  thinkingLevelMap: Type$1.TOptional<Type$1.TObject<{
+    high: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    low: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    max: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    medium: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    minimal: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    off: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+    xhigh: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
+  }>>;
+  input: Type$1.TArray<Type$1.TUnion<[Type$1.TLiteral<"text">, Type$1.TLiteral<"image">]>>;
+  cost: Type$1.TObject<{
+    input: Type$1.TNumber;
+    output: Type$1.TNumber;
+    cacheRead: Type$1.TNumber;
+    cacheWrite: Type$1.TNumber;
+    tiers: Type$1.TOptional<Type$1.TArray<Type$1.TObject<{
+      input: Type$1.TNumber;
+      output: Type$1.TNumber;
+      cacheRead: Type$1.TNumber;
+      cacheWrite: Type$1.TNumber;
+      inputTokensAbove: Type$1.TNumber;
+    }>>>;
+  }>;
+  contextWindow: Type$1.TNumber;
+  maxTokens: Type$1.TNumber;
+  headers: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TString>>;
+  npm: Type$1.TOptional<Type$1.TString>;
+  api: Type$1.TOptional<Type$1.TObject<{
+    id: Type$1.TOptional<Type$1.TString>;
+    url: Type$1.TOptional<Type$1.TString>;
+    method: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"languageModel">, Type$1.TLiteral<"chat">, Type$1.TLiteral<"completion">, Type$1.TLiteral<"completionModel">, Type$1.TLiteral<"messages">, Type$1.TLiteral<"responses">]>>;
+  }>>;
+  providerOptionsKey: Type$1.TOptional<Type$1.TString>;
+  options: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TUnknown>>;
+  providerOptions: Type$1.TOptional<Type$1.TRecord<"^.*$", Type$1.TUnknown>>;
+  compat: Type$1.TOptional<Type$1.TObject<{
+    supportsToolSearch: Type$1.TOptional<Type$1.TBoolean>;
+    supportsAdditionalTools: Type$1.TOptional<Type$1.TBoolean>;
+    supportsStrictMode: Type$1.TOptional<Type$1.TBoolean>;
+    supportsOpenAIGrammarTools: Type$1.TOptional<Type$1.TBoolean>;
+  }>>;
+  protocol: Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>;
+  supportedProtocols: Type$1.TOptional<Type$1.TObject<{
+    anthropic: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    google: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    googleVertex: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    googleVertexAnthropic: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openai: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openaiCompatible: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openaiCodex: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    openrouter: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+    xai: Type$1.TOptional<Type$1.TUnion<[Type$1.TLiteral<"anthropic">, Type$1.TLiteral<"google">, Type$1.TLiteral<"google-vertex">, Type$1.TLiteral<"google-vertex-anthropic">, Type$1.TLiteral<"openai">, Type$1.TLiteral<"openai-compatible">, Type$1.TLiteral<"openai-codex">, Type$1.TLiteral<"openrouter">, Type$1.TLiteral<"xai">]>>;
+  }>>;
+}>;
+type Info = Static<typeof Info>;
+type TModel<TProtocol extends KnownProviderEnum> = Omit<Info, "protocol"> & {
+  protocol: TProtocol;
+};
+declare function calculateCost(model: Info, usage: {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+}): void;
+type BuiltInModels = Partial<Record<string, Record<string, Info>>>;
+declare function normalizeInput(input?: string[]): Array<"text" | "image">;
+declare function getBuiltInModels(): Promise<BuiltInModels>;
+declare const registry: {
+  (): Promise<Map<string, Map<string, {
+    id: string;
+    name: string;
+    provider: {
+      id: string;
+      name: string;
+      source: "api" | "config" | "custom" | "env" | "unknown";
+      env: string[];
+      key?: string;
+      options?: Record<string, any>;
+    };
+    baseUrl: string;
+    reasoning: boolean;
+    thinkingLevelMap?: {
+      high?: string | null;
+      low?: string | null;
+      max?: string | null;
+      medium?: string | null;
+      minimal?: string | null;
+      off?: string | null;
+      xhigh?: string | null;
+    };
+    input: ("image" | "text")[];
+    cost: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      tiers?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        inputTokensAbove: number;
+      }[];
+    };
+    contextWindow: number;
+    maxTokens: number;
+    headers?: Record<string, string>;
+    npm?: string;
+    api?: {
+      id?: string;
+      url?: string;
+      method?: "chat" | "completion" | "completionModel" | "languageModel" | "messages" | "responses";
+    };
+    providerOptionsKey?: string;
+    options?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+    compat?: {
+      supportsToolSearch?: boolean;
+      supportsAdditionalTools?: boolean;
+      supportsStrictMode?: boolean;
+      supportsOpenAIGrammarTools?: boolean;
+    };
+    protocol: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    supportedProtocols?: {
+      anthropic?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      google?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      googleVertex?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      googleVertexAnthropic?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      openai?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      openaiCompatible?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      openaiCodex?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      openrouter?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+      xai?: "anthropic" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
+    };
+  }>>>;
+  reset: () => void;
+};
+declare function supportsProtocol(model: Info, protocol: KnownProviderEnum): boolean;
+type ProviderToProtocol<TProvider extends string> = TProvider extends KnownProviderEnum ? TProvider : KnownProviderEnum;
+declare function getModel<TProvider extends string, TProtocol extends KnownProviderEnum = ProviderToProtocol<TProvider>>(provider: TProvider, model: string, overrides?: Partial<Info> & {
+  protocol?: TProtocol;
+}): Promise<TModel<TProtocol> | undefined>;
+declare function getProviders(): Promise<string[]>;
+declare function getModels<TProvider extends string>(provider: TProvider): Promise<Info[]>;
+/**
+ * Check if two models are equal by comparing both their id and provider id.
+ * Returns false if either model is null or undefined.
+ */
+declare function modelsAreEqual(a: Info | null | undefined, b: Info | null | undefined): boolean;
+declare function getSupportedThinkingLevels<TProtocol extends KnownProviderEnum>(model: TModel<TProtocol>): ThinkingLevel[];
+declare function clampThinkingLevel<TProtocol extends KnownProviderEnum>(model: TModel<TProtocol>, level: ThinkingLevel): ThinkingLevel;
+//#endregion
+export { ProviderToProtocol as a, getModels as c, modelsAreEqual as d, registry as f, KnownProviderEnum as i, getProviders as l, ActiveThinkingLevel as n, TModel as o, Info as r, getModel as s, APIMethodEnum as t, model_d_exports as u };
+//# sourceMappingURL=model-CKKq3s4y.d.mts.map