@luketandjung/dedalus-labs 1.0.0 → 2.0.0

package/dist/index.d.cts

@@ -0,0 +1,3104 @@
+declare namespace exports_Generated {
+	export { make, ValidationError, UrlCitation, TopLogprob, ToolChoiceEnum, ToolChoice, ThinkingConfigEnabled, ThinkingConfigDisabled, ReasoningSummaryEnum, ReasoningGenerateSummaryEnum, ReasoningEffortEnum, Reasoning, QueryParams, PromptTokensDetails, Models2 as Models, ModelSettingsTruncationEnum, ModelSettings, ModelId, MCPToolChoice, HeaderParams, HTTPValidationError, FunctionCall, Function, Embedding, DedalusModelChoice2 as DedalusModelChoice, DedalusModel, Custom, CreateEmbeddingResponse2 as CreateEmbeddingResponse, CreateEmbeddingRequestModelEnum2 as CreateEmbeddingRequestModelEnum, CreateEmbeddingRequestEncodingFormat, CreateEmbeddingRequest2 as CreateEmbeddingRequest, CompletionUsage2 as CompletionUsage, CompletionTokensDetails, Client2 as Client, ChoiceLogprobs2 as ChoiceLogprobs, ChoiceFinishReasonEnum2 as ChoiceFinishReasonEnum, Choice, ChatCompletionTokenLogprob, ChatCompletionServiceTierEnum2 as ChatCompletionServiceTierEnum, ChatCompletionResponseMessage, ChatCompletionRequestVerbosityEnum, ChatCompletionRequestServiceTierEnum, ChatCompletionRequestReasoningEffortEnum, ChatCompletionRequest2 as ChatCompletionRequest, ChatCompletionMessageToolCall, ChatCompletionMessageCustomToolCall, ChatCompletion2 as ChatCompletion, Audio, AnnotationsItem };
+}
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import { AiError } from "@luketandjung/ariadne";
+import * as Effect from "effect/Effect";
+import { ParseError } from "effect/ParseResult";
+import * as S from "effect/Schema";
+/**
+* Model identifier string (e.g., 'openai/gpt-5', 'anthropic/claude-3-5-sonnet').
+*/
+declare class ModelId extends S.String {}
+declare const ToolChoiceEnum_base: S.Literal<["auto", "required", "none"]>;
+declare class ToolChoiceEnum extends ToolChoiceEnum_base {}
+declare const MCPToolChoice_base: S.Class<MCPToolChoice, {
+	server_label: typeof S.String;
+	name: typeof S.String;
+}, S.Struct.Encoded<{
+	server_label: typeof S.String;
+	name: typeof S.String;
+}>, never, {
+	readonly server_label: string;
+} & {
+	readonly name: string;
+}, {}, {}>;
+declare class MCPToolChoice extends MCPToolChoice_base {}
+declare const ToolChoice_base: S.Union<[typeof ToolChoiceEnum, typeof S.String, S.Record$<typeof S.String, typeof S.Unknown>, typeof MCPToolChoice, typeof S.Null]>;
+declare class ToolChoice extends ToolChoice_base {}
+declare const ModelSettingsTruncationEnum_base: S.Literal<["auto", "disabled"]>;
+declare class ModelSettingsTruncationEnum extends ModelSettingsTruncationEnum_base {}
+declare const ReasoningEffortEnum_base: S.Literal<["minimal", "low", "medium", "high"]>;
+declare class ReasoningEffortEnum extends ReasoningEffortEnum_base {}
+declare const ReasoningGenerateSummaryEnum_base: S.Literal<["auto", "concise", "detailed"]>;
+declare class ReasoningGenerateSummaryEnum extends ReasoningGenerateSummaryEnum_base {}
+declare const ReasoningSummaryEnum_base: S.Literal<["auto", "concise", "detailed"]>;
+declare class ReasoningSummaryEnum extends ReasoningSummaryEnum_base {}
+declare const Reasoning_base: S.Class<Reasoning, {
+	effort: S.optionalWith<typeof ReasoningEffortEnum, {
+		nullable: true;
+	}>;
+	generate_summary: S.optionalWith<typeof ReasoningGenerateSummaryEnum, {
+		nullable: true;
+	}>;
+	summary: S.optionalWith<typeof ReasoningSummaryEnum, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	effort: S.optionalWith<typeof ReasoningEffortEnum, {
+		nullable: true;
+	}>;
+	generate_summary: S.optionalWith<typeof ReasoningGenerateSummaryEnum, {
+		nullable: true;
+	}>;
+	summary: S.optionalWith<typeof ReasoningSummaryEnum, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly effort?: "minimal" | "low" | "medium" | "high" | undefined;
+} & {
+	readonly generate_summary?: "auto" | "concise" | "detailed" | undefined;
+} & {
+	readonly summary?: "auto" | "concise" | "detailed" | undefined;
+}, {}, {}>;
+declare class Reasoning extends Reasoning_base {}
+declare const QueryParams_base: S.Record$<typeof S.String, typeof S.Unknown>;
+declare class QueryParams extends QueryParams_base {}
+declare const HeaderParams_base: S.Record$<typeof S.String, typeof S.Unknown>;
+declare class HeaderParams extends HeaderParams_base {}
+declare const ModelSettings_base: S.Class<ModelSettings, {
+	temperature: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	top_p: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	frequency_penalty: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	presence_penalty: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	stop: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof S.String>]>, {
+		nullable: true;
+	}>;
+	seed: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	logprobs: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	top_logprobs: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	n: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	user: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	stream: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	stream_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	audio: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	service_tier: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	prediction: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	tool_choice: S.optionalWith<typeof ToolChoice, {
+		nullable: true;
+	}>;
+	parallel_tool_calls: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	truncation: S.optionalWith<typeof ModelSettingsTruncationEnum, {
+		nullable: true;
+	}>;
+	max_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	max_completion_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	reasoning: S.optionalWith<typeof Reasoning, {
+		nullable: true;
+	}>;
+	reasoning_effort: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	store: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	include_usage: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	timeout: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	prompt_cache_key: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	safety_identifier: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	verbosity: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	web_search_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	response_include: S.optionalWith<S.Array$<S.Literal<["code_interpreter_call.outputs", "computer_call_output.output.image_url", "file_search_call.results", "message.input_image.image_url", "message.output_text.logprobs", "reasoning.encrypted_content"]>>, {
+		nullable: true;
+	}>;
+	use_responses: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => false;
+	}>;
+	extra_query: S.optionalWith<typeof QueryParams, {
+		nullable: true;
+	}>;
+	extra_headers: S.optionalWith<typeof HeaderParams, {
+		nullable: true;
+	}>;
+	extra_args: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	attributes: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	voice: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	modalities: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	input_audio_format: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	output_audio_format: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	input_audio_transcription: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	turn_detection: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	thinking: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	top_k: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	generation_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	system_instruction: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	safety_settings: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	tool_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	disable_automatic_function_calling: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => true;
+	}>;
+	search_parameters: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	deferred: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	temperature: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	top_p: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	frequency_penalty: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	presence_penalty: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	stop: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof S.String>]>, {
+		nullable: true;
+	}>;
+	seed: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	logprobs: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	top_logprobs: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	n: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	user: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	stream: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	stream_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	audio: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	service_tier: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	prediction: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	tool_choice: S.optionalWith<typeof ToolChoice, {
+		nullable: true;
+	}>;
+	parallel_tool_calls: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	truncation: S.optionalWith<typeof ModelSettingsTruncationEnum, {
+		nullable: true;
+	}>;
+	max_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	max_completion_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	reasoning: S.optionalWith<typeof Reasoning, {
+		nullable: true;
+	}>;
+	reasoning_effort: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	store: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	include_usage: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	timeout: S.optionalWith<typeof S.Number, {
+		nullable: true;
+	}>;
+	prompt_cache_key: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	safety_identifier: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	verbosity: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	web_search_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	response_include: S.optionalWith<S.Array$<S.Literal<["code_interpreter_call.outputs", "computer_call_output.output.image_url", "file_search_call.results", "message.input_image.image_url", "message.output_text.logprobs", "reasoning.encrypted_content"]>>, {
+		nullable: true;
+	}>;
+	use_responses: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => false;
+	}>;
+	extra_query: S.optionalWith<typeof QueryParams, {
+		nullable: true;
+	}>;
+	extra_headers: S.optionalWith<typeof HeaderParams, {
+		nullable: true;
+	}>;
+	extra_args: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	attributes: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	voice: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	modalities: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	input_audio_format: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	output_audio_format: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	input_audio_transcription: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	turn_detection: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	thinking: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	top_k: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	generation_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	system_instruction: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	safety_settings: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	tool_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	disable_automatic_function_calling: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => true;
+	}>;
+	search_parameters: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	deferred: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly temperature?: number | undefined;
+} & {
+	readonly top_p?: number | undefined;
+} & {
+	readonly frequency_penalty?: number | undefined;
+} & {
+	readonly presence_penalty?: number | undefined;
+} & {
+	readonly stop?: string | readonly string[] | undefined;
+} & {
+	readonly seed?: number | undefined;
+} & {
+	readonly logit_bias?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly logprobs?: boolean | undefined;
+} & {
+	readonly top_logprobs?: number | undefined;
+} & {
+	readonly n?: number | undefined;
+} & {
+	readonly user?: string | undefined;
+} & {
+	readonly response_format?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly stream?: boolean | undefined;
+} & {
+	readonly stream_options?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly audio?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly service_tier?: string | undefined;
+} & {
+	readonly prediction?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly tool_choice?: string | MCPToolChoice | {
+		readonly [x: string]: unknown;
+	} | null | undefined;
+} & {
+	readonly parallel_tool_calls?: boolean | undefined;
+} & {
+	readonly truncation?: "auto" | "disabled" | undefined;
+} & {
+	readonly max_tokens?: number | undefined;
+} & {
+	readonly max_completion_tokens?: number | undefined;
+} & {
+	readonly reasoning?: Reasoning | undefined;
+} & {
+	readonly reasoning_effort?: string | undefined;
+} & {
+	readonly metadata?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly store?: boolean | undefined;
+} & {
+	readonly include_usage?: boolean | undefined;
+} & {
+	readonly timeout?: number | undefined;
+} & {
+	readonly prompt_cache_key?: string | undefined;
+} & {
+	readonly safety_identifier?: string | undefined;
+} & {
+	readonly verbosity?: string | undefined;
+} & {
+	readonly web_search_options?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly response_include?: readonly ("code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content")[] | undefined;
+} & {
+	readonly use_responses?: boolean | undefined;
+} & {
+	readonly extra_query?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly extra_headers?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly extra_args?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly attributes?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly voice?: string | undefined;
+} & {
+	readonly modalities?: readonly string[] | undefined;
+} & {
+	readonly input_audio_format?: string | undefined;
+} & {
+	readonly output_audio_format?: string | undefined;
+} & {
+	readonly input_audio_transcription?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly turn_detection?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly thinking?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly top_k?: number | undefined;
+} & {
+	readonly generation_config?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly system_instruction?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly safety_settings?: readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly tool_config?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly disable_automatic_function_calling?: boolean | undefined;
+} & {
+	readonly search_parameters?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly deferred?: boolean | undefined;
+}, {}, {}>;
+declare class ModelSettings extends ModelSettings_base {}
+declare const DedalusModel_base: S.Class<DedalusModel, {
+	/**
+	* Model identifier with provider prefix (e.g., 'openai/gpt-5', 'anthropic/claude-3-5-sonnet').
+	*/
+	model: typeof S.String;
+	/**
+	* Optional default generation settings (e.g., temperature, max_tokens) applied when this model is selected.
+	*/
+	settings: S.optionalWith<typeof ModelSettings, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* Model identifier with provider prefix (e.g., 'openai/gpt-5', 'anthropic/claude-3-5-sonnet').
+	*/
+	model: typeof S.String;
+	/**
+	* Optional default generation settings (e.g., temperature, max_tokens) applied when this model is selected.
+	*/
+	settings: S.optionalWith<typeof ModelSettings, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly model: string;
+} & {
+	readonly settings?: ModelSettings | undefined;
+}, {}, {}>;
+/**
+* Structured model selection entry used in request payloads.
+*
+* Supports OpenAI-style semantics (string model id) while enabling
+* optional per-model default settings for Dedalus multi-model routing.
+*/
+declare class DedalusModel extends DedalusModel_base {}
+declare const DedalusModelChoice_base: S.Union<[typeof ModelId, typeof DedalusModel]>;
+/**
+* Dedalus model choice - either a string ID or DedalusModel configuration object.
+*/
+declare class DedalusModelChoice2 extends DedalusModelChoice_base {}
+declare const Models_base: S.Array$<typeof DedalusModelChoice2>;
+/**
+* List of models for multi-model routing.
+*/
+declare class Models2 extends Models_base {}
+declare const ThinkingConfigDisabled_base: S.Class<ThinkingConfigDisabled, {
+	type: S.Literal<["disabled"]>;
+}, S.Struct.Encoded<{
+	type: S.Literal<["disabled"]>;
+}>, never, {
+	readonly type: "disabled";
+}, {}, {}>;
+/**
+* Fields:
+* - type (required): Literal['disabled']
+*/
+declare class ThinkingConfigDisabled extends ThinkingConfigDisabled_base {}
+declare const ThinkingConfigEnabled_base: S.Class<ThinkingConfigEnabled, {
+	/**
+	* Determines how many tokens Claude can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality.
+	*
+	* Must be ≥1024 and less than `max_tokens`.
+	*
+	* See [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) for details.
+	*/
+	budget_tokens: S.filter<typeof S.Int>;
+	type: S.Literal<["enabled"]>;
+}, S.Struct.Encoded<{
+	/**
+	* Determines how many tokens Claude can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality.
+	*
+	* Must be ≥1024 and less than `max_tokens`.
+	*
+	* See [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) for details.
+	*/
+	budget_tokens: S.filter<typeof S.Int>;
+	type: S.Literal<["enabled"]>;
+}>, never, {
+	readonly type: "enabled";
+} & {
+	readonly budget_tokens: number;
+}, {}, {}>;
+/**
+* Fields:
+* - budget_tokens (required): int
+* - type (required): Literal['enabled']
+*/
+declare class ThinkingConfigEnabled extends ThinkingConfigEnabled_base {}
+declare const ChatCompletionRequestReasoningEffortEnum_base: S.Literal<["low", "medium", "high"]>;
+declare class ChatCompletionRequestReasoningEffortEnum extends ChatCompletionRequestReasoningEffortEnum_base {}
+declare const ChatCompletionRequestServiceTierEnum_base: S.Literal<["auto", "default"]>;
+declare class ChatCompletionRequestServiceTierEnum extends ChatCompletionRequestServiceTierEnum_base {}
+declare const ChatCompletionRequestVerbosityEnum_base: S.Literal<["low", "medium", "high"]>;
+declare class ChatCompletionRequestVerbosityEnum extends ChatCompletionRequestVerbosityEnum_base {}
+declare const ChatCompletionRequest_base: S.Class<ChatCompletionRequest2, {
+	/**
+	* Model ID or list of model IDs for multi-model routing.
+	*/
+	model: S.Union<[typeof DedalusModelChoice2, typeof Models2]>;
+	/**
+	* Conversation history. Accepts either a list of message objects or a string, which is treated as a single user message.
+	*/
+	messages: S.Union<[S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, typeof S.String]>;
+	/**
+	* Convenience alias for Responses-style `input`. Used when `messages` is omitted to provide the user prompt directly.
+	*/
+	input: S.optionalWith<S.Union<[S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, typeof S.String]>, {
+		nullable: true;
+	}>;
+	/**
+	* What sampling temperature to use, between 0 and 2. Higher values like 0.8 make the output more random, while lower values like 0.2 make it more focused and deterministic. We generally recommend altering this or 'top_p' but not both.
+	*/
+	temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or 'temperature' but not both.
+	*/
+	top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API. This value is now deprecated in favor of 'max_completion_tokens' and is not compatible with o-series models.
+	*/
+	max_tokens: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
+	*/
+	presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+	*/
+	frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object mapping token IDs (as strings) to bias values from -100 to 100. The bias is added to the logits before sampling; values between -1 and 1 nudge selection probability, while values like -100 or 100 effectively ban or require a token.
+	*/
+	logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Not supported with latest reasoning models 'o3' and 'o4-mini'.
+	*
+	*         Up to 4 sequences where the API will stop generating further tokens; the returned text will not contain the stop sequence.
+	*/
+	stop: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* Extended thinking configuration (Anthropic only). Set type to 'enabled' or 'disabled'. When enabled, shows reasoning process in thinking blocks. Requires min 1,024 token budget.
+	*/
+	thinking: S.optionalWith<S.Union<[typeof ThinkingConfigDisabled, typeof ThinkingConfigEnabled]>, {
+		nullable: true;
+	}>;
+	/**
+	* Top-k sampling. Anthropic: pass-through. Google: injected into generationConfig.topK.
+	*/
+	top_k: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* System prompt/instructions. Anthropic: pass-through. Google: converted to systemInstruction. OpenAI: extracted from messages.
+	*/
+	system: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Convenience alias for Responses-style `instructions`. Takes precedence over `system` and over system-role messages when provided.
+	*/
+	instructions: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Google generationConfig object. Merged with auto-generated config. Use for Google-specific params (candidateCount, responseMimeType, etc.).
+	*/
+	generation_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Google safety settings (harm categories and thresholds).
+	*/
+	safety_settings: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Google tool configuration (function calling mode, etc.).
+	*/
+	tool_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Google-only flag to disable the SDK's automatic function execution. When true, the model returns function calls for the client to execute manually.
+	*/
+	disable_automatic_function_calling: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* If specified, system will make a best effort to sample deterministically. Determinism is not guaranteed for the same seed across different models or API versions.
+	*/
+	seed: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	/**
+	* Stable identifier for your end-users. Helps OpenAI detect and prevent abuse and may boost cache hit rates. This field is being replaced by 'safety_identifier' and 'prompt_cache_key'.
+	*/
+	user: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* How many chat completion choices to generate for each input message. Keep 'n' as 1 to minimize costs.
+	*/
+	n: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+		nullable: true;
+	}>;
+	/**
+	* If true, the model response data is streamed to the client as it is generated using Server-Sent Events.
+	*/
+	stream: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => false;
+	}>;
+	/**
+	* Options for streaming responses. Only set when 'stream' is true (supports 'include_usage' and 'include_obfuscation').
+	*/
+	stream_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* An object specifying the format that the model must output. Use {'type': 'json_schema', 'json_schema': {...}} for structured outputs or {'type': 'json_object'} for the legacy JSON mode. Currently only OpenAI-prefixed models honour this field; Anthropic and Google requests will return an invalid_request_error if it is supplied.
+	*/
+	response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* A list of tools the model may call. Supports OpenAI function tools and custom tools; use 'mcp_servers' for Dedalus-managed server-side tools.
+	*/
+	tools: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Controls which (if any) tool is called by the model. 'none' stops tool calling, 'auto' lets the model decide, and 'required' forces at least one tool invocation. Specific tool payloads force that tool.
+	*/
+	tool_choice: S.optionalWith<S.Union<[typeof S.String, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Whether to enable parallel function calling during tool use.
+	*/
+	parallel_tool_calls: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* Deprecated in favor of 'tools'. Legacy list of function definitions the model may generate JSON inputs for.
+	*/
+	functions: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Deprecated in favor of 'tool_choice'. Controls which function is called by the model (none, auto, or specific name).
+	*/
+	function_call: S.optionalWith<S.Union<[typeof S.String, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Whether to return log probabilities of the output tokens. If true, returns the log probabilities for each token in the response content.
+	*/
+	logprobs: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* An integer between 0 and 20 specifying how many of the most likely tokens to return at each position, with log probabilities. Requires 'logprobs' to be true.
+	*/
+	top_logprobs: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+		nullable: true;
+	}>;
+	/**
+	* An upper bound for the number of tokens that can be generated for a completion, including visible output and reasoning tokens.
+	*/
+	max_completion_tokens: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* Constrains effort on reasoning for supported reasoning models. Higher values use more compute, potentially improving reasoning quality at the cost of latency and tokens.
+	*/
+	reasoning_effort: S.optionalWith<typeof ChatCompletionRequestReasoningEffortEnum, {
+		nullable: true;
+	}>;
+	/**
+	* Parameters for audio output. Required when requesting audio responses (for example, modalities including 'audio').
+	*/
+	audio: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Output types you would like the model to generate. Most models default to ['text']; some support ['text', 'audio'].
+	*/
+	modalities: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* Configuration for predicted outputs. Improves response times when you already know large portions of the response content.
+	*/
+	prediction: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Set of up to 16 key-value string pairs that can be attached to the request for structured metadata.
+	*/
+	metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Whether to store the output of this chat completion request for OpenAI model distillation or eval products. Image inputs over 8MB are dropped if storage is enabled.
+	*/
+	store: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* Specifies the processing tier used for the request. 'auto' uses project defaults, while 'default' forces standard pricing and performance.
+	*/
+	service_tier: S.optionalWith<typeof ChatCompletionRequestServiceTierEnum, {
+		nullable: true;
+	}>;
+	/**
+	* Used by OpenAI to cache responses for similar requests and optimize cache hit rates. Replaces the legacy 'user' field for caching.
+	*/
+	prompt_cache_key: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* Stable identifier used to help detect users who might violate OpenAI usage policies. Consider hashing end-user identifiers before sending.
+	*/
+	safety_identifier: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* Constrains the verbosity of the model's response. Lower values produce concise answers, higher values allow more detail.
+	*/
+	verbosity: S.optionalWith<typeof ChatCompletionRequestVerbosityEnum, {
+		nullable: true;
+	}>;
+	/**
+	* Configuration for OpenAI's web search tool. Learn more at https://platform.openai.com/docs/guides/tools-web-search?api-mode=chat.
+	*/
+	web_search_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* xAI-specific parameter for configuring web search data acquisition. If not set, no data will be acquired by the model.
+	*/
+	search_parameters: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* xAI-specific parameter. If set to true, the request returns a request_id for async completion retrieval via GET /v1/chat/deferred-completion/{request_id}.
+	*/
+	deferred: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* MCP (Model Context Protocol) server addresses to make available for server-side tool execution. Entries can be URLs (e.g., 'https://mcp.example.com'), slugs (e.g., 'dedalus-labs/brave-search'), or structured objects specifying slug/version/url. MCP tools are executed server-side and billed separately.
+	*/
+	mcp_servers: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof S.String>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Guardrails to apply to the agent for input/output validation and safety checks. Reserved for future use - guardrails configuration format not yet finalized.
+	*/
+	guardrails: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Configuration for multi-model handoffs and agent orchestration. Reserved for future use - handoff configuration format not yet finalized.
+	*/
+	handoff_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Attributes for individual models used in routing decisions during multi-model execution. Format: {'model_name': {'attribute': value}}, where values are 0.0-1.0. Common attributes: 'intelligence', 'speed', 'cost', 'creativity', 'accuracy'. Used by agent to select optimal model based on task requirements.
+	*/
+	model_attributes: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Attributes for the agent itself, influencing behavior and model selection. Format: {'attribute': value}, where values are 0.0-1.0. Common attributes: 'complexity', 'accuracy', 'efficiency', 'creativity', 'friendliness'. Higher values indicate stronger preference for that characteristic.
+	*/
+	agent_attributes: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Maximum number of turns for agent execution before terminating (default: 10). Each turn represents one model inference cycle. Higher values allow more complex reasoning but increase cost and latency.
+	*/
+	max_turns: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+		nullable: true;
+	}>;
+	/**
+	* When False, skip server-side tool execution and return raw OpenAI-style tool_calls in the response.
+	*/
+	auto_execute_tools: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* Model ID or list of model IDs for multi-model routing.
+	*/
+	model: S.Union<[typeof DedalusModelChoice2, typeof Models2]>;
+	/**
+	* Conversation history. Accepts either a list of message objects or a string, which is treated as a single user message.
+	*/
+	messages: S.Union<[S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, typeof S.String]>;
+	/**
+	* Convenience alias for Responses-style `input`. Used when `messages` is omitted to provide the user prompt directly.
+	*/
+	input: S.optionalWith<S.Union<[S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, typeof S.String]>, {
+		nullable: true;
+	}>;
+	/**
+	* What sampling temperature to use, between 0 and 2. Higher values like 0.8 make the output more random, while lower values like 0.2 make it more focused and deterministic. We generally recommend altering this or 'top_p' but not both.
+	*/
+	temperature: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or 'temperature' but not both.
+	*/
+	top_p: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API. This value is now deprecated in favor of 'max_completion_tokens' and is not compatible with o-series models.
+	*/
+	max_tokens: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
+	*/
+	presence_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+	*/
+	frequency_penalty: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+		nullable: true;
+	}>;
+	/**
+	* Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object mapping token IDs (as strings) to bias values from -100 to 100. The bias is added to the logits before sampling; values between -1 and 1 nudge selection probability, while values like -100 or 100 effectively ban or require a token.
+	*/
+	logit_bias: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Not supported with latest reasoning models 'o3' and 'o4-mini'.
+	*
+	*         Up to 4 sequences where the API will stop generating further tokens; the returned text will not contain the stop sequence.
+	*/
+	stop: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* Extended thinking configuration (Anthropic only). Set type to 'enabled' or 'disabled'. When enabled, shows reasoning process in thinking blocks. Requires min 1,024 token budget.
+	*/
+	thinking: S.optionalWith<S.Union<[typeof ThinkingConfigDisabled, typeof ThinkingConfigEnabled]>, {
+		nullable: true;
+	}>;
+	/**
+	* Top-k sampling. Anthropic: pass-through. Google: injected into generationConfig.topK.
+	*/
+	top_k: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* System prompt/instructions. Anthropic: pass-through. Google: converted to systemInstruction. OpenAI: extracted from messages.
+	*/
+	system: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Convenience alias for Responses-style `instructions`. Takes precedence over `system` and over system-role messages when provided.
+	*/
+	instructions: S.optionalWith<S.Union<[typeof S.String, S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Google generationConfig object. Merged with auto-generated config. Use for Google-specific params (candidateCount, responseMimeType, etc.).
+	*/
+	generation_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Google safety settings (harm categories and thresholds).
+	*/
+	safety_settings: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Google tool configuration (function calling mode, etc.).
+	*/
+	tool_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Google-only flag to disable the SDK's automatic function execution. When true, the model returns function calls for the client to execute manually.
+	*/
+	disable_automatic_function_calling: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* If specified, system will make a best effort to sample deterministically. Determinism is not guaranteed for the same seed across different models or API versions.
+	*/
+	seed: S.optionalWith<typeof S.Int, {
+		nullable: true;
+	}>;
+	/**
+	* Stable identifier for your end-users. Helps OpenAI detect and prevent abuse and may boost cache hit rates. This field is being replaced by 'safety_identifier' and 'prompt_cache_key'.
+	*/
+	user: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* How many chat completion choices to generate for each input message. Keep 'n' as 1 to minimize costs.
+	*/
+	n: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+		nullable: true;
+	}>;
+	/**
+	* If true, the model response data is streamed to the client as it is generated using Server-Sent Events.
+	*/
+	stream: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => false;
+	}>;
+	/**
+	* Options for streaming responses. Only set when 'stream' is true (supports 'include_usage' and 'include_obfuscation').
+	*/
+	stream_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* An object specifying the format that the model must output. Use {'type': 'json_schema', 'json_schema': {...}} for structured outputs or {'type': 'json_object'} for the legacy JSON mode. Currently only OpenAI-prefixed models honour this field; Anthropic and Google requests will return an invalid_request_error if it is supplied.
+	*/
+	response_format: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* A list of tools the model may call. Supports OpenAI function tools and custom tools; use 'mcp_servers' for Dedalus-managed server-side tools.
+	*/
+	tools: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Controls which (if any) tool is called by the model. 'none' stops tool calling, 'auto' lets the model decide, and 'required' forces at least one tool invocation. Specific tool payloads force that tool.
+	*/
+	tool_choice: S.optionalWith<S.Union<[typeof S.String, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Whether to enable parallel function calling during tool use.
+	*/
+	parallel_tool_calls: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* Deprecated in favor of 'tools'. Legacy list of function definitions the model may generate JSON inputs for.
+	*/
+	functions: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Deprecated in favor of 'tool_choice'. Controls which function is called by the model (none, auto, or specific name).
+	*/
+	function_call: S.optionalWith<S.Union<[typeof S.String, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Whether to return log probabilities of the output tokens. If true, returns the log probabilities for each token in the response content.
+	*/
+	logprobs: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* An integer between 0 and 20 specifying how many of the most likely tokens to return at each position, with log probabilities. Requires 'logprobs' to be true.
+	*/
+	top_logprobs: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+		nullable: true;
+	}>;
+	/**
+	* An upper bound for the number of tokens that can be generated for a completion, including visible output and reasoning tokens.
+	*/
+	max_completion_tokens: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* Constrains effort on reasoning for supported reasoning models. Higher values use more compute, potentially improving reasoning quality at the cost of latency and tokens.
+	*/
+	reasoning_effort: S.optionalWith<typeof ChatCompletionRequestReasoningEffortEnum, {
+		nullable: true;
+	}>;
+	/**
+	* Parameters for audio output. Required when requesting audio responses (for example, modalities including 'audio').
+	*/
+	audio: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Output types you would like the model to generate. Most models default to ['text']; some support ['text', 'audio'].
+	*/
+	modalities: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* Configuration for predicted outputs. Improves response times when you already know large portions of the response content.
+	*/
+	prediction: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Set of up to 16 key-value string pairs that can be attached to the request for structured metadata.
+	*/
+	metadata: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Whether to store the output of this chat completion request for OpenAI model distillation or eval products. Image inputs over 8MB are dropped if storage is enabled.
+	*/
+	store: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* Specifies the processing tier used for the request. 'auto' uses project defaults, while 'default' forces standard pricing and performance.
+	*/
+	service_tier: S.optionalWith<typeof ChatCompletionRequestServiceTierEnum, {
+		nullable: true;
+	}>;
+	/**
+	* Used by OpenAI to cache responses for similar requests and optimize cache hit rates. Replaces the legacy 'user' field for caching.
+	*/
+	prompt_cache_key: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* Stable identifier used to help detect users who might violate OpenAI usage policies. Consider hashing end-user identifiers before sending.
+	*/
+	safety_identifier: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* Constrains the verbosity of the model's response. Lower values produce concise answers, higher values allow more detail.
+	*/
+	verbosity: S.optionalWith<typeof ChatCompletionRequestVerbosityEnum, {
+		nullable: true;
+	}>;
+	/**
+	* Configuration for OpenAI's web search tool. Learn more at https://platform.openai.com/docs/guides/tools-web-search?api-mode=chat.
+	*/
+	web_search_options: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* xAI-specific parameter for configuring web search data acquisition. If not set, no data will be acquired by the model.
+	*/
+	search_parameters: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* xAI-specific parameter. If set to true, the request returns a request_id for async completion retrieval via GET /v1/chat/deferred-completion/{request_id}.
+	*/
+	deferred: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+	}>;
+	/**
+	* MCP (Model Context Protocol) server addresses to make available for server-side tool execution. Entries can be URLs (e.g., 'https://mcp.example.com'), slugs (e.g., 'dedalus-labs/brave-search'), or structured objects specifying slug/version/url. MCP tools are executed server-side and billed separately.
+	*/
+	mcp_servers: S.optionalWith<S.Union<[typeof S.String, S.Array$<typeof S.String>]>, {
+		nullable: true;
+	}>;
+	/**
+	* Guardrails to apply to the agent for input/output validation and safety checks. Reserved for future use - guardrails configuration format not yet finalized.
+	*/
+	guardrails: S.optionalWith<S.Array$<S.Record$<typeof S.String, typeof S.Unknown>>, {
+		nullable: true;
+	}>;
+	/**
+	* Configuration for multi-model handoffs and agent orchestration. Reserved for future use - handoff configuration format not yet finalized.
+	*/
+	handoff_config: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Attributes for individual models used in routing decisions during multi-model execution. Format: {'model_name': {'attribute': value}}, where values are 0.0-1.0. Common attributes: 'intelligence', 'speed', 'cost', 'creativity', 'accuracy'. Used by agent to select optimal model based on task requirements.
+	*/
+	model_attributes: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Attributes for the agent itself, influencing behavior and model selection. Format: {'attribute': value}, where values are 0.0-1.0. Common attributes: 'complexity', 'accuracy', 'efficiency', 'creativity', 'friendliness'. Higher values indicate stronger preference for that characteristic.
+	*/
+	agent_attributes: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+	/**
+	* Maximum number of turns for agent execution before terminating (default: 10). Each turn represents one model inference cycle. Higher values allow more complex reasoning but increase cost and latency.
+	*/
+	max_turns: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+		nullable: true;
+	}>;
+	/**
+	* When False, skip server-side tool execution and return raw OpenAI-style tool_calls in the response.
+	*/
+	auto_execute_tools: S.optionalWith<typeof S.Boolean, {
+		nullable: true;
+		default: () => true;
+	}>;
+}>, never, {
+	readonly temperature?: number | undefined;
+} & {
+	readonly top_p?: number | undefined;
+} & {
+	readonly frequency_penalty?: number | undefined;
+} & {
+	readonly presence_penalty?: number | undefined;
+} & {
+	readonly stop?: readonly string[] | undefined;
+} & {
+	readonly seed?: number | undefined;
+} & {
+	readonly logit_bias?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly logprobs?: boolean | undefined;
+} & {
+	readonly top_logprobs?: number | undefined;
+} & {
+	readonly n?: number | undefined;
+} & {
+	readonly user?: string | undefined;
+} & {
+	readonly response_format?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly stream?: boolean | undefined;
+} & {
+	readonly stream_options?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly audio?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly service_tier?: "default" | "auto" | undefined;
+} & {
+	readonly prediction?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly tool_choice?: string | {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly parallel_tool_calls?: boolean | undefined;
+} & {
+	readonly max_tokens?: number | undefined;
+} & {
+	readonly max_completion_tokens?: number | undefined;
+} & {
+	readonly reasoning_effort?: "low" | "medium" | "high" | undefined;
+} & {
+	readonly metadata?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly store?: boolean | undefined;
+} & {
+	readonly prompt_cache_key?: string | undefined;
+} & {
+	readonly safety_identifier?: string | undefined;
+} & {
+	readonly verbosity?: "low" | "medium" | "high" | undefined;
+} & {
+	readonly web_search_options?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly modalities?: readonly string[] | undefined;
+} & {
+	readonly thinking?: ThinkingConfigDisabled | ThinkingConfigEnabled | undefined;
+} & {
+	readonly top_k?: number | undefined;
+} & {
+	readonly generation_config?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly safety_settings?: readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly tool_config?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly disable_automatic_function_calling?: boolean | undefined;
+} & {
+	readonly search_parameters?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly deferred?: boolean | undefined;
+} & {
+	readonly model: string | DedalusModel | readonly (string | DedalusModel)[];
+} & {
+	readonly messages: string | readonly {
+		readonly [x: string]: unknown;
+	}[];
+} & {
+	readonly input?: string | readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly system?: string | readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly instructions?: string | readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly tools?: readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly functions?: readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly function_call?: string | {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly mcp_servers?: string | readonly string[] | undefined;
+} & {
+	readonly guardrails?: readonly {
+		readonly [x: string]: unknown;
+	}[] | undefined;
+} & {
+	readonly handoff_config?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly model_attributes?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly agent_attributes?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+} & {
+	readonly max_turns?: number | undefined;
+} & {
+	readonly auto_execute_tools?: boolean | undefined;
+}, {}, {}>;
+/**
+* Chat completion request (OpenAI-compatible).
+*
+* Stateless chat completion endpoint. For stateful conversations with threads,
+* use the Responses API instead.
+*/
+declare class ChatCompletionRequest2 extends ChatCompletionRequest_base {}
+declare const ChoiceFinishReasonEnum_base: S.Literal<["stop", "length", "tool_calls", "content_filter", "function_call"]>;
+declare class ChoiceFinishReasonEnum2 extends ChoiceFinishReasonEnum_base {}
+declare const Function_base: S.Class<Function, {
+	/**
+	* The name of the function to call.
+	*/
+	name: typeof S.String;
+	/**
+	* The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
+	*/
+	arguments: typeof S.String;
+}, S.Struct.Encoded<{
+	/**
+	* The name of the function to call.
+	*/
+	name: typeof S.String;
+	/**
+	* The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
+	*/
+	arguments: typeof S.String;
+}>, never, {
+	readonly name: string;
+} & {
+	readonly arguments: string;
+}, {}, {}>;
+/**
+* The function that the model called.
+*
+* Fields:
+*   - name (required): str
+*   - arguments (required): str
+*/
+declare class Function extends Function_base {}
+declare const ChatCompletionMessageToolCall_base: S.Class<ChatCompletionMessageToolCall, {
+	/**
+	* The ID of the tool call.
+	*/
+	id: typeof S.String;
+	/**
+	* The type of the tool. Currently, only `function` is supported.
+	*/
+	type: S.Literal<["function"]>;
+	/**
+	* The function that the model called.
+	*/
+	function: typeof Function;
+}, S.Struct.Encoded<{
+	/**
+	* The ID of the tool call.
+	*/
+	id: typeof S.String;
+	/**
+	* The type of the tool. Currently, only `function` is supported.
+	*/
+	type: S.Literal<["function"]>;
+	/**
+	* The function that the model called.
+	*/
+	function: typeof Function;
+}>, never, {
+	readonly function: Function;
+} & {
+	readonly type: "function";
+} & {
+	readonly id: string;
+}, {}, {}>;
+/**
+* A call to a function tool created by the model.
+*
+* Fields:
+*   - id (required): str
+*   - type (required): Literal['function']
+*   - function (required): Function
+*/
+declare class ChatCompletionMessageToolCall extends ChatCompletionMessageToolCall_base {}
+declare const Custom_base: S.Class<Custom, {
+	/**
+	* The name of the custom tool to call.
+	*/
+	name: typeof S.String;
+	/**
+	* The input for the custom tool call generated by the model.
+	*/
+	input: typeof S.String;
+}, S.Struct.Encoded<{
+	/**
+	* The name of the custom tool to call.
+	*/
+	name: typeof S.String;
+	/**
+	* The input for the custom tool call generated by the model.
+	*/
+	input: typeof S.String;
+}>, never, {
+	readonly name: string;
+} & {
+	readonly input: string;
+}, {}, {}>;
+/**
+* The custom tool that the model called.
+*
+* Fields:
+*   - name (required): str
+*   - input (required): str
+*/
+declare class Custom extends Custom_base {}
+declare const ChatCompletionMessageCustomToolCall_base: S.Class<ChatCompletionMessageCustomToolCall, {
+	/**
+	* The ID of the tool call.
+	*/
+	id: typeof S.String;
+	/**
+	* The type of the tool. Always `custom`.
+	*/
+	type: S.Literal<["custom"]>;
+	/**
+	* The custom tool that the model called.
+	*/
+	custom: typeof Custom;
+}, S.Struct.Encoded<{
+	/**
+	* The ID of the tool call.
+	*/
+	id: typeof S.String;
+	/**
+	* The type of the tool. Always `custom`.
+	*/
+	type: S.Literal<["custom"]>;
+	/**
+	* The custom tool that the model called.
+	*/
+	custom: typeof Custom;
+}>, never, {
+	readonly type: "custom";
+} & {
+	readonly id: string;
+} & {
+	readonly custom: Custom;
+}, {}, {}>;
+/**
+* A call to a custom tool created by the model.
+*
+* Fields:
+*   - id (required): str
+*   - type (required): Literal['custom']
+*   - custom (required): Custom
+*/
+declare class ChatCompletionMessageCustomToolCall extends ChatCompletionMessageCustomToolCall_base {}
+declare const UrlCitation_base: S.Class<UrlCitation, {
+	/**
+	* The index of the last character of the URL citation in the message.
+	*/
+	end_index: typeof S.Int;
+	/**
+	* The index of the first character of the URL citation in the message.
+	*/
+	start_index: typeof S.Int;
+	/**
+	* The URL of the web resource.
+	*/
+	url: typeof S.String;
+	/**
+	* The title of the web resource.
+	*/
+	title: typeof S.String;
+}, S.Struct.Encoded<{
+	/**
+	* The index of the last character of the URL citation in the message.
+	*/
+	end_index: typeof S.Int;
+	/**
+	* The index of the first character of the URL citation in the message.
+	*/
+	start_index: typeof S.Int;
+	/**
+	* The URL of the web resource.
+	*/
+	url: typeof S.String;
+	/**
+	* The title of the web resource.
+	*/
+	title: typeof S.String;
+}>, never, {
+	readonly end_index: number;
+} & {
+	readonly start_index: number;
+} & {
+	readonly url: string;
+} & {
+	readonly title: string;
+}, {}, {}>;
+/**
+* A URL citation when using web search.
+*
+* Fields:
+*   - end_index (required): int
+*   - start_index (required): int
+*   - url (required): str
+*   - title (required): str
+*/
+declare class UrlCitation extends UrlCitation_base {}
+declare const AnnotationsItem_base: S.Class<AnnotationsItem, {
+	/**
+	* The type of the URL citation. Always `url_citation`.
+	*/
+	type: S.Literal<["url_citation"]>;
+	/**
+	* A URL citation when using web search.
+	*/
+	url_citation: typeof UrlCitation;
+}, S.Struct.Encoded<{
+	/**
+	* The type of the URL citation. Always `url_citation`.
+	*/
+	type: S.Literal<["url_citation"]>;
+	/**
+	* A URL citation when using web search.
+	*/
+	url_citation: typeof UrlCitation;
+}>, never, {
+	readonly type: "url_citation";
+} & {
+	readonly url_citation: UrlCitation;
+}, {}, {}>;
+/**
+* A URL citation when using web search.
+*
+* Fields:
+*   - type (required): Literal['url_citation']
+*   - url_citation (required): UrlCitation
+*/
+declare class AnnotationsItem extends AnnotationsItem_base {}
+declare const FunctionCall_base: S.Class<FunctionCall, {
+	/**
+	* The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
+	*/
+	arguments: typeof S.String;
+	/**
+	* The name of the function to call.
+	*/
+	name: typeof S.String;
+}, S.Struct.Encoded<{
+	/**
+	* The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.
+	*/
+	arguments: typeof S.String;
+	/**
+	* The name of the function to call.
+	*/
+	name: typeof S.String;
+}>, never, {
+	readonly name: string;
+} & {
+	readonly arguments: string;
+}, {}, {}>;
+/**
+* Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model.
+*
+* Fields:
+*   - arguments (required): str
+*   - name (required): str
+*/
+declare class FunctionCall extends FunctionCall_base {}
+declare const Audio_base: S.Class<Audio, {
+	/**
+	* Unique identifier for this audio response.
+	*/
+	id: typeof S.String;
+	/**
+	* The Unix timestamp (in seconds) for when this audio response will
+	* no longer be accessible on the server for use in multi-turn
+	* conversations.
+	*/
+	expires_at: typeof S.Int;
+	/**
+	* Base64 encoded audio bytes generated by the model, in the format
+	* specified in the request.
+	*/
+	data: typeof S.String;
+	/**
+	* Transcript of the audio generated by the model.
+	*/
+	transcript: typeof S.String;
+}, S.Struct.Encoded<{
+	/**
+	* Unique identifier for this audio response.
+	*/
+	id: typeof S.String;
+	/**
+	* The Unix timestamp (in seconds) for when this audio response will
+	* no longer be accessible on the server for use in multi-turn
+	* conversations.
+	*/
+	expires_at: typeof S.Int;
+	/**
+	* Base64 encoded audio bytes generated by the model, in the format
+	* specified in the request.
+	*/
+	data: typeof S.String;
+	/**
+	* Transcript of the audio generated by the model.
+	*/
+	transcript: typeof S.String;
+}>, never, {
+	readonly id: string;
+} & {
+	readonly expires_at: number;
+} & {
+	readonly data: string;
+} & {
+	readonly transcript: string;
+}, {}, {}>;
+/**
+* If the audio output modality is requested, this object contains data
+*
+* about the audio response from the model. [Learn more](https://platform.openai.com/docs/guides/audio).
+*
+* Fields:
+*   - id (required): str
+*   - expires_at (required): int
+*   - data (required): str
+*   - transcript (required): str
+*/
+declare class Audio extends Audio_base {}
+declare const ChatCompletionResponseMessage_base: S.Class<ChatCompletionResponseMessage, {
+	/**
+	* The contents of the message.
+	*/
+	content: S.NullOr<typeof S.String>;
+	/**
+	* The refusal message generated by the model.
+	*/
+	refusal: S.optionalWith<S.NullOr<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* The tool calls generated by the model, such as function calls.
+	*/
+	tool_calls: S.optionalWith<S.Array$<S.Union<[typeof ChatCompletionMessageToolCall, typeof ChatCompletionMessageCustomToolCall]>>, {
+		nullable: true;
+	}>;
+	/**
+	* Annotations for the message, when applicable, as when using the
+	* [web search tool](https://platform.openai.com/docs/guides/tools-web-search?api-mode=chat).
+	*/
+	annotations: S.optionalWith<S.Array$<typeof AnnotationsItem>, {
+		nullable: true;
+	}>;
+	/**
+	* The role of the author of this message.
+	*/
+	role: S.Literal<["assistant"]>;
+	/**
+	* Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model.
+	*/
+	function_call: S.optionalWith<typeof FunctionCall, {
+		nullable: true;
+	}>;
+	/**
+	* If the audio output modality is requested, this object contains data
+	* about the audio response from the model. [Learn more](https://platform.openai.com/docs/guides/audio).
+	*/
+	audio: S.optionalWith<typeof Audio, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* The contents of the message.
+	*/
+	content: S.NullOr<typeof S.String>;
+	/**
+	* The refusal message generated by the model.
+	*/
+	refusal: S.optionalWith<S.NullOr<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* The tool calls generated by the model, such as function calls.
+	*/
+	tool_calls: S.optionalWith<S.Array$<S.Union<[typeof ChatCompletionMessageToolCall, typeof ChatCompletionMessageCustomToolCall]>>, {
+		nullable: true;
+	}>;
+	/**
+	* Annotations for the message, when applicable, as when using the
+	* [web search tool](https://platform.openai.com/docs/guides/tools-web-search?api-mode=chat).
+	*/
+	annotations: S.optionalWith<S.Array$<typeof AnnotationsItem>, {
+		nullable: true;
+	}>;
+	/**
+	* The role of the author of this message.
+	*/
+	role: S.Literal<["assistant"]>;
+	/**
+	* Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be called, as generated by the model.
+	*/
+	function_call: S.optionalWith<typeof FunctionCall, {
+		nullable: true;
+	}>;
+	/**
+	* If the audio output modality is requested, this object contains data
+	* about the audio response from the model. [Learn more](https://platform.openai.com/docs/guides/audio).
+	*/
+	audio: S.optionalWith<typeof Audio, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly annotations?: readonly AnnotationsItem[] | undefined;
+} & {
+	readonly audio?: Audio | undefined;
+} & {
+	readonly function_call?: FunctionCall | undefined;
+} & {
+	readonly tool_calls?: readonly (ChatCompletionMessageToolCall | ChatCompletionMessageCustomToolCall)[] | undefined;
+} & {
+	readonly content: string | null;
+} & {
+	readonly refusal?: string | null | undefined;
+} & {
+	readonly role: "assistant";
+}, {}, {}>;
+/**
+* A chat completion message generated by the model.
+*
+* Fields:
+*   - content (required): str | None
+*   - refusal (required): str | None
+*   - tool_calls (optional): ChatCompletionMessageToolCalls
+*   - annotations (optional): list[AnnotationsItem]
+*   - role (required): Literal['assistant']
+*   - function_call (optional): FunctionCall
+*   - audio (optional): Audio | None
+*/
+declare class ChatCompletionResponseMessage extends ChatCompletionResponseMessage_base {}
+declare const TopLogprob_base: S.Class<TopLogprob, {
+	/**
+	* The token.
+	*/
+	token: typeof S.String;
+	/**
+	* The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely.
+	*/
+	logprob: typeof S.Number;
+	/**
+	* A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token.
+	*/
+	bytes: S.NullOr<S.Array$<typeof S.Int>>;
+}, S.Struct.Encoded<{
+	/**
+	* The token.
+	*/
+	token: typeof S.String;
+	/**
+	* The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely.
+	*/
+	logprob: typeof S.Number;
+	/**
+	* A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token.
+	*/
+	bytes: S.NullOr<S.Array$<typeof S.Int>>;
+}>, never, {
+	readonly token: string;
+} & {
+	readonly logprob: number;
+} & {
+	readonly bytes: readonly number[] | null;
+}, {}, {}>;
+/**
+* Token and its log probability.
+*/
+declare class TopLogprob extends TopLogprob_base {}
+declare const ChatCompletionTokenLogprob_base: S.Class<ChatCompletionTokenLogprob, {
+	/**
+	* The token.
+	*/
+	token: typeof S.String;
+	/**
+	* The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely.
+	*/
+	logprob: typeof S.Number;
+	/**
+	* A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token.
+	*/
+	bytes: S.NullOr<S.Array$<typeof S.Int>>;
+	/**
+	* List of the most likely tokens and their log probability, at this token position. In rare cases, there may be fewer than the number of requested `top_logprobs` returned.
+	*/
+	top_logprobs: S.Array$<typeof TopLogprob>;
+}, S.Struct.Encoded<{
+	/**
+	* The token.
+	*/
+	token: typeof S.String;
+	/**
+	* The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely.
+	*/
+	logprob: typeof S.Number;
+	/**
+	* A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token.
+	*/
+	bytes: S.NullOr<S.Array$<typeof S.Int>>;
+	/**
+	* List of the most likely tokens and their log probability, at this token position. In rare cases, there may be fewer than the number of requested `top_logprobs` returned.
+	*/
+	top_logprobs: S.Array$<typeof TopLogprob>;
+}>, never, {
+	readonly top_logprobs: readonly TopLogprob[];
+} & {
+	readonly token: string;
+} & {
+	readonly logprob: number;
+} & {
+	readonly bytes: readonly number[] | null;
+}, {}, {}>;
+/**
+* Token log probability information.
+*/
+declare class ChatCompletionTokenLogprob extends ChatCompletionTokenLogprob_base {}
+declare const ChoiceLogprobs_base: S.Class<ChoiceLogprobs2, {
+	/**
+	* A list of message content tokens with log probability information.
+	*/
+	content: S.optionalWith<S.Array$<typeof ChatCompletionTokenLogprob>, {
+		nullable: true;
+	}>;
+	/**
+	* A list of message refusal tokens with log probability information.
+	*/
+	refusal: S.optionalWith<S.Array$<typeof ChatCompletionTokenLogprob>, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* A list of message content tokens with log probability information.
+	*/
+	content: S.optionalWith<S.Array$<typeof ChatCompletionTokenLogprob>, {
+		nullable: true;
+	}>;
+	/**
+	* A list of message refusal tokens with log probability information.
+	*/
+	refusal: S.optionalWith<S.Array$<typeof ChatCompletionTokenLogprob>, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly content?: readonly ChatCompletionTokenLogprob[] | undefined;
+} & {
+	readonly refusal?: readonly ChatCompletionTokenLogprob[] | undefined;
+}, {}, {}>;
+/**
+* Log probability information for the choice.
+*/
+declare class ChoiceLogprobs2 extends ChoiceLogprobs_base {}
+declare const Choice_base: S.Class<Choice, {
+	/**
+	* The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence,
+	* `length` if the maximum number of tokens specified in the request was reached,
+	* `content_filter` if content was omitted due to a flag from our content filters,
+	* `tool_calls` if the model called a tool, or `function_call` (deprecated) if the model called a function.
+	*/
+	finish_reason: S.optionalWith<typeof ChoiceFinishReasonEnum2, {
+		nullable: true;
+	}>;
+	/**
+	* The index of the choice in the list of choices.
+	*/
+	index: typeof S.Int;
+	/**
+	* A chat completion message generated by the model.
+	*/
+	message: typeof ChatCompletionResponseMessage;
+	/**
+	* Log probability information for the choice.
+	*/
+	logprobs: S.optionalWith<typeof ChoiceLogprobs2, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence,
+	* `length` if the maximum number of tokens specified in the request was reached,
+	* `content_filter` if content was omitted due to a flag from our content filters,
+	* `tool_calls` if the model called a tool, or `function_call` (deprecated) if the model called a function.
+	*/
+	finish_reason: S.optionalWith<typeof ChoiceFinishReasonEnum2, {
+		nullable: true;
+	}>;
+	/**
+	* The index of the choice in the list of choices.
+	*/
+	index: typeof S.Int;
+	/**
+	* A chat completion message generated by the model.
+	*/
+	message: typeof ChatCompletionResponseMessage;
+	/**
+	* Log probability information for the choice.
+	*/
+	logprobs: S.optionalWith<typeof ChoiceLogprobs2, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly logprobs?: ChoiceLogprobs2 | undefined;
+} & {
+	readonly index: number;
+} & {
+	readonly message: ChatCompletionResponseMessage;
+} & {
+	readonly finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | undefined;
+}, {}, {}>;
+/**
+* A chat completion choice.
+*
+* OpenAI-compatible choice object for non-streaming responses.
+* Part of the ChatCompletion response.
+*/
+declare class Choice extends Choice_base {}
+declare const ChatCompletionServiceTierEnum_base: S.Literal<["auto", "default", "flex", "scale", "priority"]>;
+declare class ChatCompletionServiceTierEnum2 extends ChatCompletionServiceTierEnum_base {}
+declare const CompletionTokensDetails_base: S.Class<CompletionTokensDetails, {
+	/**
+	* When using Predicted Outputs, the number of tokens in the
+	* prediction that appeared in the completion.
+	*/
+	accepted_prediction_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* Audio input tokens generated by the model.
+	*/
+	audio_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* Tokens generated by the model for reasoning.
+	*/
+	reasoning_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* When using Predicted Outputs, the number of tokens in the
+	* prediction that did not appear in the completion. However, like
+	* reasoning tokens, these tokens are still counted in the total
+	* completion tokens for purposes of billing, output, and context window
+	* limits.
+	*/
+	rejected_prediction_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* When using Predicted Outputs, the number of tokens in the
+	* prediction that appeared in the completion.
+	*/
+	accepted_prediction_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* Audio input tokens generated by the model.
+	*/
+	audio_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* Tokens generated by the model for reasoning.
+	*/
+	reasoning_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* When using Predicted Outputs, the number of tokens in the
+	* prediction that did not appear in the completion. However, like
+	* reasoning tokens, these tokens are still counted in the total
+	* completion tokens for purposes of billing, output, and context window
+	* limits.
+	*/
+	rejected_prediction_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+}>, never, {
+	readonly accepted_prediction_tokens?: number | undefined;
+} & {
+	readonly audio_tokens?: number | undefined;
+} & {
+	readonly reasoning_tokens?: number | undefined;
+} & {
+	readonly rejected_prediction_tokens?: number | undefined;
+}, {}, {}>;
+/**
+* Breakdown of tokens used in a completion.
+*
+* Fields:
+*   - accepted_prediction_tokens (optional): int
+*   - audio_tokens (optional): int
+*   - reasoning_tokens (optional): int
+*   - rejected_prediction_tokens (optional): int
+*/
+declare class CompletionTokensDetails extends CompletionTokensDetails_base {}
+declare const PromptTokensDetails_base: S.Class<PromptTokensDetails, {
+	/**
+	* Audio input tokens present in the prompt.
+	*/
+	audio_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* Cached tokens present in the prompt.
+	*/
+	cached_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* Audio input tokens present in the prompt.
+	*/
+	audio_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+	/**
+	* Cached tokens present in the prompt.
+	*/
+	cached_tokens: S.optionalWith<typeof S.Int, {
+		nullable: true;
+		default: () => 0;
+	}>;
+}>, never, {
+	readonly audio_tokens?: number | undefined;
+} & {
+	readonly cached_tokens?: number | undefined;
+}, {}, {}>;
+/**
+* Breakdown of tokens used in the prompt.
+*
+* Fields:
+*   - audio_tokens (optional): int
+*   - cached_tokens (optional): int
+*/
+declare class PromptTokensDetails extends PromptTokensDetails_base {}
+declare const CompletionUsage_base: S.Class<CompletionUsage2, {
+	/**
+	* Number of tokens in the generated completion.
+	*/
+	completion_tokens: typeof S.Int;
+	/**
+	* Number of tokens in the prompt.
+	*/
+	prompt_tokens: typeof S.Int;
+	/**
+	* Total number of tokens used in the request (prompt + completion).
+	*/
+	total_tokens: typeof S.Int;
+	/**
+	* Breakdown of tokens used in a completion.
+	*/
+	completion_tokens_details: S.optionalWith<typeof CompletionTokensDetails, {
+		nullable: true;
+	}>;
+	/**
+	* Breakdown of tokens used in the prompt.
+	*/
+	prompt_tokens_details: S.optionalWith<typeof PromptTokensDetails, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* Number of tokens in the generated completion.
+	*/
+	completion_tokens: typeof S.Int;
+	/**
+	* Number of tokens in the prompt.
+	*/
+	prompt_tokens: typeof S.Int;
+	/**
+	* Total number of tokens used in the request (prompt + completion).
+	*/
+	total_tokens: typeof S.Int;
+	/**
+	* Breakdown of tokens used in a completion.
+	*/
+	completion_tokens_details: S.optionalWith<typeof CompletionTokensDetails, {
+		nullable: true;
+	}>;
+	/**
+	* Breakdown of tokens used in the prompt.
+	*/
+	prompt_tokens_details: S.optionalWith<typeof PromptTokensDetails, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly completion_tokens: number;
+} & {
+	readonly prompt_tokens: number;
+} & {
+	readonly total_tokens: number;
+} & {
+	readonly completion_tokens_details?: CompletionTokensDetails | undefined;
+} & {
+	readonly prompt_tokens_details?: PromptTokensDetails | undefined;
+}, {}, {}>;
+/**
+* Usage statistics for the completion request.
+*
+* Fields:
+*   - completion_tokens (required): int
+*   - prompt_tokens (required): int
+*   - total_tokens (required): int
+*   - completion_tokens_details (optional): CompletionTokensDetails
+*   - prompt_tokens_details (optional): PromptTokensDetails
+*/
+declare class CompletionUsage2 extends CompletionUsage_base {}
+declare const ChatCompletion_base: S.Class<ChatCompletion2, {
+	/**
+	* A unique identifier for the chat completion.
+	*/
+	id: typeof S.String;
+	/**
+	* A list of chat completion choices. Can be more than one if `n` is greater than 1.
+	*/
+	choices: S.Array$<typeof Choice>;
+	/**
+	* The Unix timestamp (in seconds) of when the chat completion was created.
+	*/
+	created: typeof S.Int;
+	/**
+	* The model used for the chat completion.
+	*/
+	model: typeof S.String;
+	/**
+	* Specifies the processing type used for serving the request.
+	*   - If set to 'auto', then the request will be processed with the service tier configured in the Project settings. Unless otherwise configured, the Project will use 'default'.
+	*   - If set to 'default', then the request will be processed with the standard pricing and performance for the selected model.
+	*   - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or '[priority](https://openai.com/api-priority-processing/)', then the request will be processed with the corresponding service tier.
+	*   - When not set, the default behavior is 'auto'.
+	*
+	*   When the `service_tier` parameter is set, the response body will include the `service_tier` value based on the processing mode actually used to serve the request. This response value may be different from the value set in the parameter.
+	*/
+	service_tier: S.optionalWith<typeof ChatCompletionServiceTierEnum2, {
+		nullable: true;
+	}>;
+	/**
+	* This fingerprint represents the backend configuration that the model runs with.
+	*
+	* Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
+	*/
+	system_fingerprint: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* The object type, which is always `chat.completion`.
+	*/
+	object: S.Literal<["chat.completion"]>;
+	/**
+	* Usage statistics for the completion request.
+	*/
+	usage: S.optionalWith<typeof CompletionUsage2, {
+		nullable: true;
+	}>;
+	/**
+	* List of tool names that were executed server-side (e.g., MCP tools). Only present when tools were executed on the server rather than returned for client-side execution.
+	*/
+	tools_executed: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* Information about MCP server failures, if any occurred during the request. Contains details about which servers failed and why, along with recommendations for the user. Only present when MCP server failures occurred.
+	*/
+	mcp_server_errors: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* A unique identifier for the chat completion.
+	*/
+	id: typeof S.String;
+	/**
+	* A list of chat completion choices. Can be more than one if `n` is greater than 1.
+	*/
+	choices: S.Array$<typeof Choice>;
+	/**
+	* The Unix timestamp (in seconds) of when the chat completion was created.
+	*/
+	created: typeof S.Int;
+	/**
+	* The model used for the chat completion.
+	*/
+	model: typeof S.String;
+	/**
+	* Specifies the processing type used for serving the request.
+	*   - If set to 'auto', then the request will be processed with the service tier configured in the Project settings. Unless otherwise configured, the Project will use 'default'.
+	*   - If set to 'default', then the request will be processed with the standard pricing and performance for the selected model.
+	*   - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or '[priority](https://openai.com/api-priority-processing/)', then the request will be processed with the corresponding service tier.
+	*   - When not set, the default behavior is 'auto'.
+	*
+	*   When the `service_tier` parameter is set, the response body will include the `service_tier` value based on the processing mode actually used to serve the request. This response value may be different from the value set in the parameter.
+	*/
+	service_tier: S.optionalWith<typeof ChatCompletionServiceTierEnum2, {
+		nullable: true;
+	}>;
+	/**
+	* This fingerprint represents the backend configuration that the model runs with.
+	*
+	* Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
+	*/
+	system_fingerprint: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+	/**
+	* The object type, which is always `chat.completion`.
+	*/
+	object: S.Literal<["chat.completion"]>;
+	/**
+	* Usage statistics for the completion request.
+	*/
+	usage: S.optionalWith<typeof CompletionUsage2, {
+		nullable: true;
+	}>;
+	/**
+	* List of tool names that were executed server-side (e.g., MCP tools). Only present when tools were executed on the server rather than returned for client-side execution.
+	*/
+	tools_executed: S.optionalWith<S.Array$<typeof S.String>, {
+		nullable: true;
+	}>;
+	/**
+	* Information about MCP server failures, if any occurred during the request. Contains details about which servers failed and why, along with recommendations for the user. Only present when MCP server failures occurred.
+	*/
+	mcp_server_errors: S.optionalWith<S.Record$<typeof S.String, typeof S.Unknown>, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly object: "chat.completion";
+} & {
+	readonly service_tier?: "default" | "auto" | "flex" | "scale" | "priority" | undefined;
+} & {
+	readonly model: string;
+} & {
+	readonly id: string;
+} & {
+	readonly created: number;
+} & {
+	readonly choices: readonly Choice[];
+} & {
+	readonly system_fingerprint?: string | undefined;
+} & {
+	readonly usage?: CompletionUsage2 | undefined;
+} & {
+	readonly tools_executed?: readonly string[] | undefined;
+} & {
+	readonly mcp_server_errors?: {
+		readonly [x: string]: unknown;
+	} | undefined;
+}, {}, {}>;
+/**
+* Chat completion response for Dedalus API.
+*
+* OpenAI-compatible chat completion response with Dedalus extensions.
+* Maintains full compatibility with OpenAI API while providing additional
+* features like server-side tool execution tracking and MCP error reporting.
+*/
+declare class ChatCompletion2 extends ChatCompletion_base {}
+declare const ValidationError_base: S.Class<ValidationError, {
+	loc: S.Array$<S.Union<[typeof S.String, typeof S.Int]>>;
+	msg: typeof S.String;
+	type: typeof S.String;
+}, S.Struct.Encoded<{
+	loc: S.Array$<S.Union<[typeof S.String, typeof S.Int]>>;
+	msg: typeof S.String;
+	type: typeof S.String;
+}>, never, {
+	readonly type: string;
+} & {
+	readonly msg: string;
+} & {
+	readonly loc: readonly (string | number)[];
+}, {}, {}>;
+declare class ValidationError extends ValidationError_base {}
+declare const HTTPValidationError_base: S.Class<HTTPValidationError, {
+	detail: S.optionalWith<S.Array$<typeof ValidationError>, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	detail: S.optionalWith<S.Array$<typeof ValidationError>, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly detail?: readonly ValidationError[] | undefined;
+}, {}, {}>;
+declare class HTTPValidationError extends HTTPValidationError_base {}
+declare const make: (httpClient: HttpClient.HttpClient, options?: {
+	readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
+}) => Client2;
+interface Client2 {
+	readonly httpClient: HttpClient.HttpClient;
+	/**
+	* Generate a model response. Supports streaming, tools, and MCP servers.
+	*/
+	readonly createChatCompletionV1ChatCompletionsPost: (options: typeof ChatCompletionRequest2.Encoded) => Effect.Effect<typeof ChatCompletion2.Type, HttpClientError.HttpClientError | ParseError | AiError.MalformedInput>;
+	/**
+	* Create embeddings using the configured provider.
+	*/
+	readonly createEmbeddingsV1EmbeddingsPost: (options: typeof CreateEmbeddingRequest2.Encoded) => Effect.Effect<typeof CreateEmbeddingResponse2.Type, HttpClientError.HttpClientError | ParseError | AiError.MalformedInput>;
+}
+declare const CreateEmbeddingRequestModelEnum_base: S.Literal<["openai/text-embedding-ada-002", "openai/text-embedding-3-small", "openai/text-embedding-3-large", "google/text-embedding-004"]>;
+declare class CreateEmbeddingRequestModelEnum2 extends CreateEmbeddingRequestModelEnum_base {}
+declare const CreateEmbeddingRequestEncodingFormat_base: S.Literal<["float", "base64"]>;
+/**
+* The format to return the embeddings in. Can be either `float` or [`base64`](https://pypi.org/project/pybase64/).
+*/
+declare class CreateEmbeddingRequestEncodingFormat extends CreateEmbeddingRequestEncodingFormat_base {}
+declare const CreateEmbeddingRequest_base: S.Class<CreateEmbeddingRequest2, {
+	/**
+	* Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single request, pass an array of strings or array of token arrays. The input must not exceed the max input tokens for the model (8192 tokens for all embedding models), cannot be an empty string, and any array must be 2048 dimensions or less. [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken) for counting tokens. In addition to the per-input token limit, all embedding  models enforce a maximum of 300,000 tokens summed across all inputs in a  single request.
+	*/
+	input: S.Union<[typeof S.String, S.filter<S.filter<S.NonEmptyArray<typeof S.String>>>, S.filter<S.filter<S.NonEmptyArray<typeof S.Int>>>, S.filter<S.filter<S.NonEmptyArray<S.filter<S.NonEmptyArray<typeof S.Int>>>>>]>;
+	/**
+	* ID of the model to use. See our [Model Providers](/sdk/guides/providers) for available embedding models.
+	*/
+	model: S.Union<[typeof S.String, typeof CreateEmbeddingRequestModelEnum2]>;
+	/**
+	* The format to return the embeddings in. Can be either `float` or [`base64`](https://pypi.org/project/pybase64/).
+	*/
+	encoding_format: S.optionalWith<typeof CreateEmbeddingRequestEncodingFormat, {
+		nullable: true;
+		default: () => "float";
+	}>;
+	/**
+	* The number of dimensions the resulting output embeddings should have. Only supported in `text-embedding-3` and later models.
+	*/
+	dimensions: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+	*/
+	user: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+}, S.Struct.Encoded<{
+	/**
+	* Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single request, pass an array of strings or array of token arrays. The input must not exceed the max input tokens for the model (8192 tokens for all embedding models), cannot be an empty string, and any array must be 2048 dimensions or less. [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken) for counting tokens. In addition to the per-input token limit, all embedding  models enforce a maximum of 300,000 tokens summed across all inputs in a  single request.
+	*/
+	input: S.Union<[typeof S.String, S.filter<S.filter<S.NonEmptyArray<typeof S.String>>>, S.filter<S.filter<S.NonEmptyArray<typeof S.Int>>>, S.filter<S.filter<S.NonEmptyArray<S.filter<S.NonEmptyArray<typeof S.Int>>>>>]>;
+	/**
+	* ID of the model to use. See our [Model Providers](/sdk/guides/providers) for available embedding models.
+	*/
+	model: S.Union<[typeof S.String, typeof CreateEmbeddingRequestModelEnum2]>;
+	/**
+	* The format to return the embeddings in. Can be either `float` or [`base64`](https://pypi.org/project/pybase64/).
+	*/
+	encoding_format: S.optionalWith<typeof CreateEmbeddingRequestEncodingFormat, {
+		nullable: true;
+		default: () => "float";
+	}>;
+	/**
+	* The number of dimensions the resulting output embeddings should have. Only supported in `text-embedding-3` and later models.
+	*/
+	dimensions: S.optionalWith<S.filter<typeof S.Int>, {
+		nullable: true;
+	}>;
+	/**
+	* A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+	*/
+	user: S.optionalWith<typeof S.String, {
+		nullable: true;
+	}>;
+}>, never, {
+	readonly user?: string | undefined;
+} & {
+	readonly model: string;
+} & {
+	readonly input: string | readonly [string, ...string[]] | readonly [number, ...number[]] | readonly [readonly [number, ...number[]], ...(readonly [number, ...number[]])[]];
+} & {
+	readonly encoding_format?: "float" | "base64" | undefined;
+} & {
+	readonly dimensions?: number | undefined;
+}, {}, {}>;
+/**
+* Fields:
+* - input (required): str | Annotated[list[str], MinLen(1), MaxLen(2048)] | Annotated[list[int], MinLen(1), MaxLen(2048)] | Annotated[list[Annotated[list[int], MinLen(1)]], MinLen(1), MaxLen(2048)]
+* - model (required): str | Literal['openai/text-embedding-ada-002', 'openai/text-embedding-3-small', 'openai/text-embedding-3-large', 'google/text-embedding-004']
+* - encoding_format (optional): Literal['float', 'base64']
+* - dimensions (optional): int
+* - user (optional): str
+*/
+declare class CreateEmbeddingRequest2 extends CreateEmbeddingRequest_base {}
+declare const Embedding_base: S.Class<Embedding, {
+	/**
+	* Object type, always 'embedding'
+	*/
+	object: S.optionalWith<S.Literal<["embedding"]>, {
+		nullable: true;
+		default: () => "embedding";
+	}>;
+	/**
+	* The embedding vector (float array or base64 string)
+	*/
+	embedding: S.Union<[S.Array$<typeof S.Number>, typeof S.String]>;
+	/**
+	* Index of the embedding in the list
+	*/
+	index: typeof S.Int;
+}, S.Struct.Encoded<{
+	/**
+	* Object type, always 'embedding'
+	*/
+	object: S.optionalWith<S.Literal<["embedding"]>, {
+		nullable: true;
+		default: () => "embedding";
+	}>;
+	/**
+	* The embedding vector (float array or base64 string)
+	*/
+	embedding: S.Union<[S.Array$<typeof S.Number>, typeof S.String]>;
+	/**
+	* Index of the embedding in the list
+	*/
+	index: typeof S.Int;
+}>, never, {
+	readonly object?: "embedding" | undefined;
+} & {
+	readonly index: number;
+} & {
+	readonly embedding: string | readonly number[];
+}, {}, {}>;
+/**
+* Single embedding object.
+*/
+declare class Embedding extends Embedding_base {}
+declare const CreateEmbeddingResponse_base: S.Class<CreateEmbeddingResponse2, {
+	/**
+	* Object type, always 'list'
+	*/
+	object: S.optionalWith<S.Literal<["list"]>, {
+		nullable: true;
+		default: () => "list";
+	}>;
+	/**
+	* List of embedding objects
+	*/
+	data: S.Array$<typeof Embedding>;
+	/**
+	* The model used for embeddings
+	*/
+	model: typeof S.String;
+	/**
+	* Usage statistics (prompt_tokens, total_tokens)
+	*/
+	usage: S.Record$<typeof S.String, typeof S.Unknown>;
+}, S.Struct.Encoded<{
+	/**
+	* Object type, always 'list'
+	*/
+	object: S.optionalWith<S.Literal<["list"]>, {
+		nullable: true;
+		default: () => "list";
+	}>;
+	/**
+	* List of embedding objects
+	*/
+	data: S.Array$<typeof Embedding>;
+	/**
+	* The model used for embeddings
+	*/
+	model: typeof S.String;
+	/**
+	* Usage statistics (prompt_tokens, total_tokens)
+	*/
+	usage: S.Record$<typeof S.String, typeof S.Unknown>;
+}>, never, {
+	readonly object?: "list" | undefined;
+} & {
+	readonly model: string;
+} & {
+	readonly data: readonly Embedding[];
+} & {
+	readonly usage: {
+		readonly [x: string]: unknown;
+	};
+}, {}, {}>;
+/**
+* Response from embeddings endpoint.
+*/
+declare class CreateEmbeddingResponse2 extends CreateEmbeddingResponse_base {}
+declare namespace exports_DedalusClient {
+	export { make2 as make, layerConfig, layer, StreamChatCompletionRequest, Service2 as Service, DedalusClient, ChatCompletionChunkDelta, ChatCompletionChunkChoice, ChatCompletionChunk };
+}
+import * as HttpClient2 from "@effect/platform/HttpClient";
+import { AiError as AiError2 } from "@luketandjung/ariadne";
+import * as Config from "effect/Config";
+import { ConfigError } from "effect/ConfigError";
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+declare const DedalusClient_base: Context.TagClass<DedalusClient, "@dedalus-labs/DedalusClient", Service2>;
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class DedalusClient extends DedalusClient_base {}
+/**
+* @since 1.0.0
+* @category Models
+*/
+interface Service2 {
+	readonly client: exports_Generated.Client;
+	readonly createChatCompletion: (options: typeof exports_Generated.ChatCompletionRequest.Encoded) => Effect2.Effect2<exports_Generated.ChatCompletion, AiError2.AiError2>;
+	readonly createChatCompletionStream: (options: Omit<typeof exports_Generated.ChatCompletionRequest.Encoded, "stream">) => Stream.Stream<ChatCompletionChunk, AiError2.AiError2>;
+	readonly createEmbedding: (options: typeof exports_Generated.CreateEmbeddingRequest.Encoded) => Effect2.Effect2<exports_Generated.CreateEmbeddingResponse, AiError2.AiError2>;
+}
+/**
+* @since 1.0.0
+* @category Models
+*/
+type StreamChatCompletionRequest = Omit<typeof exports_Generated.ChatCompletionRequest.Encoded, "stream">;
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+declare const make2: (options: {
+	/**
+	* Standard OAuth-style API key to use to communicate with the Dedalus API.
+	*/
+	readonly apiKey?: Redacted.Redacted | undefined;
+	/**
+	* An alternative API gateway/proxy style API key to use to communicate with the Dedalus API.
+	*/
+	readonly xApiKey?: Redacted.Redacted | undefined;
+	/**
+	* The model provider. Only for users with access to and using BYOK API key.
+	*/
+	readonly provider?: string | undefined;
+	/**
+	* The model provider key. Only for users with access to and using BYOK API key.
+	*/
+	readonly providerKey?: Redacted.Redacted | undefined;
+	/**
+	* The environment to use. Determines the base URL if `apiUrl` is not provided.
+	* - `"production"` uses https://api.dedaluslabs.ai/v1
+	* - `"development"` uses http://localhost:8080/v1
+	* Defaults to `"production"`.
+	*/
+	readonly environment?: "production" | "development" | undefined;
+	/**
+	* The URL to use to communicate with the Dedalus API.
+	* Overrides the `environment` setting if provided.
+	*/
+	readonly apiUrl?: string | undefined;
+	/**
+	* A method which can be used to transform the underlying `HttpClient` which
+	* will be used to communicate with the Dedalus API.
+	*/
+	readonly transformClient?: ((client: HttpClient2.HttpClient2) => HttpClient2.HttpClient2) | undefined;
+}) => Effect2.Effect2<Service2, never, HttpClient2.HttpClient2 | Scope.Scope>;
+/**
+* @since 1.0.0
+* @category Layers
+*/
+declare const layer: (options: {
+	readonly apiKey?: Redacted.Redacted | undefined;
+	readonly xApiKey?: Redacted.Redacted | undefined;
+	readonly provider?: string | undefined;
+	readonly providerKey?: Redacted.Redacted | undefined;
+	readonly environment?: "production" | "development" | undefined;
+	readonly apiUrl?: string | undefined;
+	readonly transformClient?: (client: HttpClient2.HttpClient2) => HttpClient2.HttpClient2;
+}) => Layer.Layer<DedalusClient, never, HttpClient2.HttpClient2>;
+/**
+* @since 1.0.0
+* @category Layers
+*/
+declare const layerConfig: (options: {
+	readonly apiKey?: Config.Config<Redacted.Redacted | undefined> | undefined;
+	readonly xApiKey?: Config.Config<Redacted.Redacted | undefined> | undefined;
+	readonly provider?: Config.Config<string | undefined> | undefined;
+	readonly providerKey?: Config.Config<Redacted.Redacted | undefined> | undefined;
+	readonly environment?: Config.Config<"production" | "development" | undefined> | undefined;
+	readonly apiUrl?: Config.Config<string | undefined> | undefined;
+	readonly transformClient?: (client: HttpClient2.HttpClient2) => HttpClient2.HttpClient2;
+}) => Layer.Layer<DedalusClient, ConfigError, HttpClient2.HttpClient2>;
+declare const ChatCompletionChunkDelta_base: Schema.Class<ChatCompletionChunkDelta, {
+	/**
+	* The role of the author of this message delta.
+	*/
+	role: Schema.optional<Schema.Literal<["developer", "system", "user", "assistant", "tool"]>>;
+	/**
+	* The content delta.
+	*/
+	content: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+	/**
+	* The refusal message delta.
+	*/
+	refusal: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+	/**
+	* Tool calls delta.
+	*/
+	tool_calls: Schema.optional<Schema.Array$<Schema.Struct<{
+		index: typeof Schema.Int;
+		id: Schema.optional<typeof Schema.String>;
+		type: Schema.optional<Schema.Literal<["function"]>>;
+		function: Schema.optional<Schema.Struct<{
+			name: Schema.optional<typeof Schema.String>;
+			arguments: Schema.optional<typeof Schema.String>;
+		}>>;
+	}>>>;
+}, Schema.Struct.Encoded<{
+	/**
+	* The role of the author of this message delta.
+	*/
+	role: Schema.optional<Schema.Literal<["developer", "system", "user", "assistant", "tool"]>>;
+	/**
+	* The content delta.
+	*/
+	content: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+	/**
+	* The refusal message delta.
+	*/
+	refusal: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+	/**
+	* Tool calls delta.
+	*/
+	tool_calls: Schema.optional<Schema.Array$<Schema.Struct<{
+		index: typeof Schema.Int;
+		id: Schema.optional<typeof Schema.String>;
+		type: Schema.optional<Schema.Literal<["function"]>>;
+		function: Schema.optional<Schema.Struct<{
+			name: Schema.optional<typeof Schema.String>;
+			arguments: Schema.optional<typeof Schema.String>;
+		}>>;
+	}>>>;
+}>, never, {
+	readonly tool_calls?: readonly {
+		readonly function?: {
+			readonly name?: string | undefined;
+			readonly arguments?: string | undefined;
+		} | undefined;
+		readonly type?: "function" | undefined;
+		readonly id?: string | undefined;
+		readonly index: number;
+	}[] | undefined;
+} & {
+	readonly content?: string | null | undefined;
+} & {
+	readonly refusal?: string | null | undefined;
+} & {
+	readonly role?: "user" | "system" | "assistant" | "developer" | "tool" | undefined;
+}, {}, {}>;
+/**
+* A delta message in a streaming chat completion chunk.
+*
+* @since 1.0.0
+* @category Schemas
+*/
+declare class ChatCompletionChunkDelta extends ChatCompletionChunkDelta_base {}
+declare const ChatCompletionChunkChoice_base: Schema.Class<ChatCompletionChunkChoice, {
+	/**
+	* The index of this choice.
+	*/
+	index: typeof Schema.Int;
+	/**
+	* The delta content.
+	*/
+	delta: typeof ChatCompletionChunkDelta;
+	/**
+	* Log probability information.
+	*/
+	logprobs: Schema.optional<Schema.NullOr<typeof exports_Generated.ChoiceLogprobs>>;
+	/**
+	* The reason the model stopped generating tokens.
+	*/
+	finish_reason: Schema.NullOr<typeof exports_Generated.ChoiceFinishReasonEnum>;
+}, Schema.Struct.Encoded<{
+	/**
+	* The index of this choice.
+	*/
+	index: typeof Schema.Int;
+	/**
+	* The delta content.
+	*/
+	delta: typeof ChatCompletionChunkDelta;
+	/**
+	* Log probability information.
+	*/
+	logprobs: Schema.optional<Schema.NullOr<typeof exports_Generated.ChoiceLogprobs>>;
+	/**
+	* The reason the model stopped generating tokens.
+	*/
+	finish_reason: Schema.NullOr<typeof exports_Generated.ChoiceFinishReasonEnum>;
+}>, never, {
+	readonly logprobs?: exports_Generated.ChoiceLogprobs | null | undefined;
+} & {
+	readonly index: number;
+} & {
+	readonly finish_reason: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null;
+} & {
+	readonly delta: ChatCompletionChunkDelta;
+}, {}, {}>;
+/**
+* A choice in a streaming chat completion chunk.
+*
+* @since 1.0.0
+* @category Schemas
+*/
+declare class ChatCompletionChunkChoice extends ChatCompletionChunkChoice_base {}
+declare const ChatCompletionChunk_base: Schema.Class<ChatCompletionChunk, {
+	/**
+	* A unique identifier for the chat completion chunk.
+	*/
+	id: typeof Schema.String;
+	/**
+	* The object type, which is always `chat.completion.chunk`.
+	*/
+	object: Schema.Literal<["chat.completion.chunk"]>;
+	/**
+	* The Unix timestamp (in seconds) of when the chunk was created.
+	*/
+	created: typeof Schema.Int;
+	/**
+	* The model used for the chat completion.
+	*/
+	model: typeof Schema.String;
+	/**
+	* This fingerprint represents the backend configuration that the model runs with.
+	*/
+	system_fingerprint: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+	/**
+	* A list of chat completion choices.
+	*/
+	choices: Schema.Array$<typeof ChatCompletionChunkChoice>;
+	/**
+	* Usage statistics (only present in final chunk if requested).
+	*/
+	usage: Schema.optional<Schema.NullOr<typeof exports_Generated.CompletionUsage>>;
+	/**
+	* Service tier used for processing the request.
+	*/
+	service_tier: Schema.optional<Schema.NullOr<typeof exports_Generated.ChatCompletionServiceTierEnum>>;
+}, Schema.Struct.Encoded<{
+	/**
+	* A unique identifier for the chat completion chunk.
+	*/
+	id: typeof Schema.String;
+	/**
+	* The object type, which is always `chat.completion.chunk`.
+	*/
+	object: Schema.Literal<["chat.completion.chunk"]>;
+	/**
+	* The Unix timestamp (in seconds) of when the chunk was created.
+	*/
+	created: typeof Schema.Int;
+	/**
+	* The model used for the chat completion.
+	*/
+	model: typeof Schema.String;
+	/**
+	* This fingerprint represents the backend configuration that the model runs with.
+	*/
+	system_fingerprint: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+	/**
+	* A list of chat completion choices.
+	*/
+	choices: Schema.Array$<typeof ChatCompletionChunkChoice>;
+	/**
+	* Usage statistics (only present in final chunk if requested).
+	*/
+	usage: Schema.optional<Schema.NullOr<typeof exports_Generated.CompletionUsage>>;
+	/**
+	* Service tier used for processing the request.
+	*/
+	service_tier: Schema.optional<Schema.NullOr<typeof exports_Generated.ChatCompletionServiceTierEnum>>;
+}>, never, {
+	readonly object: "chat.completion.chunk";
+} & {
+	readonly service_tier?: "default" | "auto" | "flex" | "scale" | "priority" | null | undefined;
+} & {
+	readonly model: string;
+} & {
+	readonly id: string;
+} & {
+	readonly created: number;
+} & {
+	readonly choices: readonly ChatCompletionChunkChoice[];
+} & {
+	readonly system_fingerprint?: string | null | undefined;
+} & {
+	readonly usage?: exports_Generated.CompletionUsage | null | undefined;
+}, {}, {}>;
+/**
+* A streaming chat completion chunk (OpenAI-compatible).
+*
+* @since 1.0.0
+* @category Schemas
+*/
+declare class ChatCompletionChunk extends ChatCompletionChunk_base {}
+declare namespace exports_DedalusConfig {
+	export { withClientTransform, DedalusConfig };
+}
+import { HttpClient as HttpClient3 } from "@effect/platform/HttpClient";
+import * as Context2 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+declare const DedalusConfig_base: Context2.TagClass<DedalusConfig, "@dedalus-labs/DedalusConfig", DedalusConfig.Service>;
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class DedalusConfig extends DedalusConfig_base {
+	/**
+	* @since 1.0.0
+	*/
+	static readonly getOrUndefined: Effect3.Effect3<typeof DedalusConfig.Service | undefined>;
+}
+/**
+* @since 1.0.0
+*/
+declare namespace DedalusConfig {
+	/**
+	* @since 1.0.
+	* @category Models
+	*/
+interface Service {
+		readonly transformClient?: (client: HttpClient3) => HttpClient3;
+	}
+}
+/**
+* @since 1.0.0
+* @category Configuration
+*/
+declare const withClientTransform: {
+	(transform: (client: HttpClient3) => HttpClient3): <
+		A,
+		E,
+		R
+	>(self: Effect3.Effect3<A, E, R>) => Effect3.Effect3<A, E, R>;
+	<
+		A,
+		E,
+		R
+	>(self: Effect3.Effect3<A, E, R>, transform: (client: HttpClient3) => HttpClient3): Effect3.Effect3<A, E, R>;
+};
+declare namespace exports_DedalusEmbeddingModel {
+	export { withConfigOverride, model, makeDataLoader, layerDataLoader, layerBatched, Model, Config2 as Config };
+}
+import { Model as AiModel, EmbeddingModel } from "@luketandjung/ariadne";
+import * as Context3 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { Simplify } from "effect/Types";
+/**
+* @since 1.0.0
+* @category Models
+*/
+type Model = typeof exports_Generated.CreateEmbeddingRequestModelEnum.Encoded;
+declare const Config_base: Context3.TagClass<Config2, "@dedalus-labs/DedalusEmbeddingModel/Config", Config2.Service>;
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class Config2 extends Config_base {
+	/**
+	* @since 1.0.0
+	*/
+	static readonly getOrUndefined: Effect4.Effect4<Config2.Service | undefined>;
+}
+/**
+* @since 1.0.0
+* @category Models
+*/
+declare const model: (model: (string & {}) | Model, { mode,...config }: Simplify<({
+	readonly mode: "batched";
+} & Config2.Batched) | ({
+	readonly mode: "data-loader";
+} & Config2.DataLoader)>) => AiModel.Model<"dedalus-labs", EmbeddingModel.EmbeddingModel, DedalusClient>;
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+declare const makeDataLoader: (options: {
+	readonly model: (string & {}) | Model;
+	readonly config: Config2.DataLoader;
+}) => Effect4.Effect4<any, unknown, unknown>;
+/**
+* @since 1.0.0
+* @category Layers
+*/
+declare const layerBatched: (options: {
+	readonly model: (string & {}) | Model;
+	readonly config?: Config2.Batched;
+}) => Layer2.Layer2<EmbeddingModel.EmbeddingModel, never, DedalusClient>;
+/**
+* @since 1.0.0
+* @category Layers
+*/
+declare const layerDataLoader: (options: {
+	readonly model: (string & {}) | Model;
+	readonly config: Config2.DataLoader;
+}) => Layer2.Layer2<EmbeddingModel.EmbeddingModel, never, DedalusClient>;
+/**
+* @since 1.0.0
+* @category Configuration
+*/
+declare const withConfigOverride: {
+	(config: Config2.Service): <
+		A,
+		E,
+		R
+	>(self: Effect4.Effect4<A, E, R>) => Effect4.Effect4<A, E, R>;
+	<
+		A,
+		E,
+		R
+	>(self: Effect4.Effect4<A, E, R>, config: Config2.Service): Effect4.Effect4<A, E, R>;
+};
+declare namespace exports_DedalusLanguageModel {
+	export { withConfigOverride2 as withConfigOverride, model2 as model, make3 as make, layer2 as layer, Model2 as Model, Config3 as Config };
+}
+import { Model as AiModel2, LanguageModel } from "@luketandjung/ariadne";
+import * as Context4 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+/**
+* @since 1.0.0
+* @category Models
+*/
+type Model2 = typeof exports_Generated.DedalusModelChoice.Encoded | typeof exports_Generated.Models.Encoded;
+declare const Config_base2: Context4.TagClass<Config3, "@dedalus-labs/DedalusLanguageModel/Config", Config3.Service>;
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class Config3 extends Config_base2 {
+	/**
+	* @since 1.0.0
+	*/
+	static readonly getOrUndefined: Effect5.Effect5<Config3.Service | undefined>;
+}
+/**
+* @since 1.0.0
+* @category Ai Models
+*/
+declare const model2: (model2: (string & {}) | Model2, config?: Omit<Config3.Service, "model">) => AiModel2.Model2<"dedalus-labs", LanguageModel.LanguageModel, DedalusClient>;
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+declare const make3: (options: {
+	readonly model2: (string & {}) | Model2;
+	readonly config?: Omit<Config3.Service, "model">;
+}) => Effect5.Effect5<any, unknown, unknown>;
+/**
+* @since 1.0.0
+* @category Layers
+*/
+declare const layer2: (options: {
+	readonly model2: (string & {}) | Model2;
+	readonly config?: Omit<Config3.Service, "model">;
+}) => Layer3.Layer3<LanguageModel.LanguageModel, never, DedalusClient>;
+/**
+* @since 1.0.0
+* @category Configuration
+*/
+declare const withConfigOverride2: {
+	(overrides: Config3.Service): <
+		A,
+		E,
+		R
+	>(self: Effect5.Effect5<A, E, R>) => Effect5.Effect5<A, E, R>;
+	<
+		A,
+		E,
+		R
+	>(self: Effect5.Effect5<A, E, R>, overrides: Config3.Service): Effect5.Effect5<A, E, R>;
+};
+export { exports_Generated as Generated, exports_DedalusLanguageModel as DedalusLanguageModel, exports_DedalusEmbeddingModel as DedalusEmbeddingModel, exports_DedalusConfig as DedalusConfig, exports_DedalusClient as DedalusClient };