@luketandjung/dedalus-labs 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,992 @@
+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 class ToolChoiceEnum extends S.Literal("auto", "required", "none") {}
+declare class MCPToolChoice extends S.Class<MCPToolChoice>("MCPToolChoice")({
+	server_label: S.String,
+	name: S.String
+}) {}
+declare class ToolChoice extends S.Union(ToolChoiceEnum, S.String, S.Record({
+	key: S.String,
+	value: S.Unknown
+}), MCPToolChoice, S.Null) {}
+declare class ModelSettingsTruncationEnum extends S.Literal("auto", "disabled") {}
+declare class ReasoningEffortEnum extends S.Literal("minimal", "low", "medium", "high") {}
+declare class ReasoningGenerateSummaryEnum extends S.Literal("auto", "concise", "detailed") {}
+declare class ReasoningSummaryEnum extends S.Literal("auto", "concise", "detailed") {}
+declare class Reasoning extends S.Class<Reasoning>("Reasoning")({
+	effort: S.optionalWith(ReasoningEffortEnum, { nullable: true }),
+	generate_summary: S.optionalWith(ReasoningGenerateSummaryEnum, { nullable: true }),
+	summary: S.optionalWith(ReasoningSummaryEnum, { nullable: true })
+}) {}
+declare class QueryParams extends S.Record({
+	key: S.String,
+	value: S.Unknown
+}) {}
+declare class HeaderParams extends S.Record({
+	key: S.String,
+	value: S.Unknown
+}) {}
+declare class ModelSettings extends S.Class<ModelSettings>("ModelSettings")({
+	temperature: S.optionalWith(S.Number, { nullable: true }),
+	top_p: S.optionalWith(S.Number, { nullable: true }),
+	frequency_penalty: S.optionalWith(S.Number, { nullable: true }),
+	presence_penalty: S.optionalWith(S.Number, { nullable: true }),
+	stop: S.optionalWith(S.Union(S.String, S.Array(S.String)), { nullable: true }),
+	seed: S.optionalWith(S.Int, { nullable: true }),
+	logit_bias: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	logprobs: S.optionalWith(S.Boolean, { nullable: true }),
+	top_logprobs: S.optionalWith(S.Int, { nullable: true }),
+	n: S.optionalWith(S.Int, { nullable: true }),
+	user: S.optionalWith(S.String, { nullable: true }),
+	response_format: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	stream: S.optionalWith(S.Boolean, { nullable: true }),
+	stream_options: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	audio: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	service_tier: S.optionalWith(S.String, { nullable: true }),
+	prediction: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	tool_choice: S.optionalWith(ToolChoice, { nullable: true }),
+	parallel_tool_calls: S.optionalWith(S.Boolean, { nullable: true }),
+	truncation: S.optionalWith(ModelSettingsTruncationEnum, { nullable: true }),
+	max_tokens: S.optionalWith(S.Int, { nullable: true }),
+	max_completion_tokens: S.optionalWith(S.Int, { nullable: true }),
+	reasoning: S.optionalWith(Reasoning, { nullable: true }),
+	reasoning_effort: S.optionalWith(S.String, { nullable: true }),
+	metadata: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	store: S.optionalWith(S.Boolean, { nullable: true }),
+	include_usage: S.optionalWith(S.Boolean, { nullable: true }),
+	timeout: S.optionalWith(S.Number, { nullable: true }),
+	prompt_cache_key: S.optionalWith(S.String, { nullable: true }),
+	safety_identifier: S.optionalWith(S.String, { nullable: true }),
+	verbosity: S.optionalWith(S.String, { nullable: true }),
+	web_search_options: S.optionalWith(S.Record({
+		key: S.String,
+		value: 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(S.Boolean, {
+		nullable: true,
+		default: () => false as const
+	}),
+	extra_query: S.optionalWith(QueryParams, { nullable: true }),
+	extra_headers: S.optionalWith(HeaderParams, { nullable: true }),
+	extra_args: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	attributes: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	voice: S.optionalWith(S.String, { nullable: true }),
+	modalities: S.optionalWith(S.Array(S.String), { nullable: true }),
+	input_audio_format: S.optionalWith(S.String, { nullable: true }),
+	output_audio_format: S.optionalWith(S.String, { nullable: true }),
+	input_audio_transcription: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	turn_detection: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	thinking: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	top_k: S.optionalWith(S.Int, { nullable: true }),
+	generation_config: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	system_instruction: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	safety_settings: S.optionalWith(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	tool_config: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	disable_automatic_function_calling: S.optionalWith(S.Boolean, {
+		nullable: true,
+		default: () => true as const
+	}),
+	search_parameters: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	deferred: S.optionalWith(S.Boolean, { nullable: true })
+}) {}
+/**
+* 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 S.Class<DedalusModel>("DedalusModel")({
+	model: S.String,
+	settings: S.optionalWith(ModelSettings, { nullable: true })
+}) {}
+/**
+* Dedalus model choice - either a string ID or DedalusModel configuration object.
+*/
+declare class DedalusModelChoice2 extends S.Union(ModelId, DedalusModel) {}
+/**
+* List of models for multi-model routing.
+*/
+declare class Models2 extends S.Array(DedalusModelChoice2) {}
+/**
+* Fields:
+* - type (required): Literal['disabled']
+*/
+declare class ThinkingConfigDisabled extends S.Class<ThinkingConfigDisabled>("ThinkingConfigDisabled")({ type: S.Literal("disabled") }) {}
+/**
+* Fields:
+* - budget_tokens (required): int
+* - type (required): Literal['enabled']
+*/
+declare class ThinkingConfigEnabled extends S.Class<ThinkingConfigEnabled>("ThinkingConfigEnabled")({
+	budget_tokens: S.Int.pipe(S.greaterThanOrEqualTo(1024)),
+	type: S.Literal("enabled")
+}) {}
+declare class ChatCompletionRequestReasoningEffortEnum extends S.Literal("low", "medium", "high") {}
+declare class ChatCompletionRequestServiceTierEnum extends S.Literal("auto", "default") {}
+declare class ChatCompletionRequestVerbosityEnum extends S.Literal("low", "medium", "high") {}
+/**
+* Chat completion request (OpenAI-compatible).
+*
+* Stateless chat completion endpoint. For stateful conversations with threads,
+* use the Responses API instead.
+*/
+declare class ChatCompletionRequest2 extends S.Class<ChatCompletionRequest2>("ChatCompletionRequest")({
+	model: S.Union(DedalusModelChoice2, Models2),
+	messages: S.Union(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), S.String),
+	input: S.optionalWith(S.Union(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), S.String), { nullable: true }),
+	temperature: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(2)), { nullable: true }),
+	top_p: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), { nullable: true }),
+	max_tokens: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
+	presence_penalty: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(-2), S.lessThanOrEqualTo(2)), { nullable: true }),
+	frequency_penalty: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(-2), S.lessThanOrEqualTo(2)), { nullable: true }),
+	logit_bias: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	stop: S.optionalWith(S.Array(S.String), { nullable: true }),
+	thinking: S.optionalWith(S.Union(ThinkingConfigDisabled, ThinkingConfigEnabled), { nullable: true }),
+	top_k: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(0)), { nullable: true }),
+	system: S.optionalWith(S.Union(S.String, S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}))), { nullable: true }),
+	instructions: S.optionalWith(S.Union(S.String, S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}))), { nullable: true }),
+	generation_config: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	safety_settings: S.optionalWith(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	tool_config: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	disable_automatic_function_calling: S.optionalWith(S.Boolean, { nullable: true }),
+	seed: S.optionalWith(S.Int, { nullable: true }),
+	user: S.optionalWith(S.String, { nullable: true }),
+	n: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(128)), { nullable: true }),
+	stream: S.optionalWith(S.Boolean, {
+		nullable: true,
+		default: () => false as const
+	}),
+	stream_options: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	response_format: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	tools: S.optionalWith(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	tool_choice: S.optionalWith(S.Union(S.String, S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	parallel_tool_calls: S.optionalWith(S.Boolean, { nullable: true }),
+	functions: S.optionalWith(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	function_call: S.optionalWith(S.Union(S.String, S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	logprobs: S.optionalWith(S.Boolean, { nullable: true }),
+	top_logprobs: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(20)), { nullable: true }),
+	max_completion_tokens: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
+	reasoning_effort: S.optionalWith(ChatCompletionRequestReasoningEffortEnum, { nullable: true }),
+	audio: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	modalities: S.optionalWith(S.Array(S.String), { nullable: true }),
+	prediction: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	metadata: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	store: S.optionalWith(S.Boolean, { nullable: true }),
+	service_tier: S.optionalWith(ChatCompletionRequestServiceTierEnum, { nullable: true }),
+	prompt_cache_key: S.optionalWith(S.String, { nullable: true }),
+	safety_identifier: S.optionalWith(S.String, { nullable: true }),
+	verbosity: S.optionalWith(ChatCompletionRequestVerbosityEnum, { nullable: true }),
+	web_search_options: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	search_parameters: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	deferred: S.optionalWith(S.Boolean, { nullable: true }),
+	mcp_servers: S.optionalWith(S.Union(S.String, S.Array(S.String)), { nullable: true }),
+	guardrails: S.optionalWith(S.Array(S.Record({
+		key: S.String,
+		value: S.Unknown
+	})), { nullable: true }),
+	handoff_config: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	model_attributes: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	agent_attributes: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true }),
+	max_turns: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(100)), { nullable: true }),
+	auto_execute_tools: S.optionalWith(S.Boolean, {
+		nullable: true,
+		default: () => true as const
+	})
+}) {}
+declare class ChoiceFinishReasonEnum2 extends S.Literal("stop", "length", "tool_calls", "content_filter", "function_call") {}
+/**
+* The function that the model called.
+*
+* Fields:
+*   - name (required): str
+*   - arguments (required): str
+*/
+declare class Function extends S.Class<Function>("Function")({
+	name: S.String,
+	arguments: S.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 S.Class<ChatCompletionMessageToolCall>("ChatCompletionMessageToolCall")({
+	id: S.String,
+	type: S.Literal("function"),
+	function: Function
+}) {}
+/**
+* The custom tool that the model called.
+*
+* Fields:
+*   - name (required): str
+*   - input (required): str
+*/
+declare class Custom extends S.Class<Custom>("Custom")({
+	name: S.String,
+	input: S.String
+}) {}
+/**
+* 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 S.Class<ChatCompletionMessageCustomToolCall>("ChatCompletionMessageCustomToolCall")({
+	id: S.String,
+	type: S.Literal("custom"),
+	custom: Custom
+}) {}
+/**
+* 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 S.Class<UrlCitation>("UrlCitation")({
+	end_index: S.Int,
+	start_index: S.Int,
+	url: S.String,
+	title: S.String
+}) {}
+/**
+* A URL citation when using web search.
+*
+* Fields:
+*   - type (required): Literal['url_citation']
+*   - url_citation (required): UrlCitation
+*/
+declare class AnnotationsItem extends S.Class<AnnotationsItem>("AnnotationsItem")({
+	type: S.Literal("url_citation"),
+	url_citation: UrlCitation
+}) {}
+/**
+* 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 S.Class<FunctionCall>("FunctionCall")({
+	arguments: S.String,
+	name: S.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 S.Class<Audio>("Audio")({
+	id: S.String,
+	expires_at: S.Int,
+	data: S.String,
+	transcript: S.String
+}) {}
+/**
+* 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 S.Class<ChatCompletionResponseMessage>("ChatCompletionResponseMessage")({
+	content: S.NullOr(S.String),
+	refusal: S.optionalWith(S.NullOr(S.String), { nullable: true }),
+	tool_calls: S.optionalWith(S.Array(S.Union(ChatCompletionMessageToolCall, ChatCompletionMessageCustomToolCall)), { nullable: true }),
+	annotations: S.optionalWith(S.Array(AnnotationsItem), { nullable: true }),
+	role: S.Literal("assistant"),
+	function_call: S.optionalWith(FunctionCall, { nullable: true }),
+	audio: S.optionalWith(Audio, { nullable: true })
+}) {}
+/**
+* Token and its log probability.
+*/
+declare class TopLogprob extends S.Class<TopLogprob>("TopLogprob")({
+	token: S.String,
+	logprob: S.Number,
+	bytes: S.NullOr(S.Array(S.Int))
+}) {}
+/**
+* Token log probability information.
+*/
+declare class ChatCompletionTokenLogprob extends S.Class<ChatCompletionTokenLogprob>("ChatCompletionTokenLogprob")({
+	token: S.String,
+	logprob: S.Number,
+	bytes: S.NullOr(S.Array(S.Int)),
+	top_logprobs: S.Array(TopLogprob)
+}) {}
+/**
+* Log probability information for the choice.
+*/
+declare class ChoiceLogprobs2 extends S.Class<ChoiceLogprobs2>("ChoiceLogprobs")({
+	content: S.optionalWith(S.Array(ChatCompletionTokenLogprob), { nullable: true }),
+	refusal: S.optionalWith(S.Array(ChatCompletionTokenLogprob), { nullable: true })
+}) {}
+/**
+* A chat completion choice.
+*
+* OpenAI-compatible choice object for non-streaming responses.
+* Part of the ChatCompletion response.
+*/
+declare class Choice extends S.Class<Choice>("Choice")({
+	finish_reason: S.optionalWith(ChoiceFinishReasonEnum2, { nullable: true }),
+	index: S.Int,
+	message: ChatCompletionResponseMessage,
+	logprobs: S.optionalWith(ChoiceLogprobs2, { nullable: true })
+}) {}
+declare class ChatCompletionServiceTierEnum2 extends S.Literal("auto", "default", "flex", "scale", "priority") {}
+/**
+* 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 S.Class<CompletionTokensDetails>("CompletionTokensDetails")({
+	accepted_prediction_tokens: S.optionalWith(S.Int, {
+		nullable: true,
+		default: () => 0 as const
+	}),
+	audio_tokens: S.optionalWith(S.Int, {
+		nullable: true,
+		default: () => 0 as const
+	}),
+	reasoning_tokens: S.optionalWith(S.Int, {
+		nullable: true,
+		default: () => 0 as const
+	}),
+	rejected_prediction_tokens: S.optionalWith(S.Int, {
+		nullable: true,
+		default: () => 0 as const
+	})
+}) {}
+/**
+* Breakdown of tokens used in the prompt.
+*
+* Fields:
+*   - audio_tokens (optional): int
+*   - cached_tokens (optional): int
+*/
+declare class PromptTokensDetails extends S.Class<PromptTokensDetails>("PromptTokensDetails")({
+	audio_tokens: S.optionalWith(S.Int, {
+		nullable: true,
+		default: () => 0 as const
+	}),
+	cached_tokens: S.optionalWith(S.Int, {
+		nullable: true,
+		default: () => 0 as const
+	})
+}) {}
+/**
+* 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 S.Class<CompletionUsage2>("CompletionUsage")({
+	completion_tokens: S.Int,
+	prompt_tokens: S.Int,
+	total_tokens: S.Int,
+	completion_tokens_details: S.optionalWith(CompletionTokensDetails, { nullable: true }),
+	prompt_tokens_details: S.optionalWith(PromptTokensDetails, { nullable: true })
+}) {}
+/**
+* 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 S.Class<ChatCompletion2>("ChatCompletion")({
+	id: S.String,
+	choices: S.Array(Choice),
+	created: S.Int,
+	model: S.String,
+	service_tier: S.optionalWith(ChatCompletionServiceTierEnum2, { nullable: true }),
+	system_fingerprint: S.optionalWith(S.String, { nullable: true }),
+	object: S.Literal("chat.completion"),
+	usage: S.optionalWith(CompletionUsage2, { nullable: true }),
+	tools_executed: S.optionalWith(S.Array(S.String), { nullable: true }),
+	mcp_server_errors: S.optionalWith(S.Record({
+		key: S.String,
+		value: S.Unknown
+	}), { nullable: true })
+}) {}
+declare class ValidationError extends S.Class<ValidationError>("ValidationError")({
+	loc: S.Array(S.Union(S.String, S.Int)),
+	msg: S.String,
+	type: S.String
+}) {}
+declare class HTTPValidationError extends S.Class<HTTPValidationError>("HTTPValidationError")({ detail: S.optionalWith(S.Array(ValidationError), { nullable: true }) }) {}
+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 class CreateEmbeddingRequestModelEnum2 extends S.Literal("openai/text-embedding-ada-002", "openai/text-embedding-3-small", "openai/text-embedding-3-large", "google/text-embedding-004") {}
+/**
+* The format to return the embeddings in. Can be either `float` or [`base64`](https://pypi.org/project/pybase64/).
+*/
+declare class CreateEmbeddingRequestEncodingFormat extends S.Literal("float", "base64") {}
+/**
+* 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 S.Class<CreateEmbeddingRequest2>("CreateEmbeddingRequest")({
+	input: S.Union(S.String, S.NonEmptyArray(S.String).pipe(S.minItems(1), S.maxItems(2048)), S.NonEmptyArray(S.Int).pipe(S.minItems(1), S.maxItems(2048)), S.NonEmptyArray(S.NonEmptyArray(S.Int).pipe(S.minItems(1))).pipe(S.minItems(1), S.maxItems(2048))),
+	model: S.Union(S.String, CreateEmbeddingRequestModelEnum2),
+	encoding_format: S.optionalWith(CreateEmbeddingRequestEncodingFormat, {
+		nullable: true,
+		default: () => "float" as const
+	}),
+	dimensions: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
+	user: S.optionalWith(S.String, { nullable: true })
+}) {}
+/**
+* Single embedding object.
+*/
+declare class Embedding extends S.Class<Embedding>("Embedding")({
+	object: S.optionalWith(S.Literal("embedding"), {
+		nullable: true,
+		default: () => "embedding" as const
+	}),
+	embedding: S.Union(S.Array(S.Number), S.String),
+	index: S.Int
+}) {}
+/**
+* Response from embeddings endpoint.
+*/
+declare class CreateEmbeddingResponse2 extends S.Class<CreateEmbeddingResponse2>("CreateEmbeddingResponse")({
+	object: S.optionalWith(S.Literal("list"), {
+		nullable: true,
+		default: () => "list" as const
+	}),
+	data: S.Array(Embedding),
+	model: S.String,
+	usage: S.Record({
+		key: S.String,
+		value: S.Unknown
+	})
+}) {}
+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";
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class DedalusClient extends Context.Tag("@dedalus-labs/DedalusClient")<DedalusClient, Service2>() {}
+/**
+* @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>;
+/**
+* A delta message in a streaming chat completion chunk.
+*
+* @since 1.0.0
+* @category Schemas
+*/
+declare class ChatCompletionChunkDelta extends Schema.Class<ChatCompletionChunkDelta>("@dedalus-labs/ChatCompletionChunkDelta")({
+	role: Schema.optional(Schema.Literal("developer", "system", "user", "assistant", "tool")),
+	content: Schema.optional(Schema.NullOr(Schema.String)),
+	refusal: Schema.optional(Schema.NullOr(Schema.String)),
+	tool_calls: Schema.optional(Schema.Array(Schema.Struct({
+		index: Schema.Int,
+		id: Schema.optional(Schema.String),
+		type: Schema.optional(Schema.Literal("function")),
+		function: Schema.optional(Schema.Struct({
+			name: Schema.optional(Schema.String),
+			arguments: Schema.optional(Schema.String)
+		}))
+	})))
+}) {}
+/**
+* A choice in a streaming chat completion chunk.
+*
+* @since 1.0.0
+* @category Schemas
+*/
+declare class ChatCompletionChunkChoice extends Schema.Class<ChatCompletionChunkChoice>("@dedalus-labs/ChatCompletionChunkChoice")({
+	index: Schema.Int,
+	delta: ChatCompletionChunkDelta,
+	logprobs: Schema.optional(Schema.NullOr(exports_Generated.ChoiceLogprobs)),
+	finish_reason: Schema.NullOr(exports_Generated.ChoiceFinishReasonEnum)
+}) {}
+/**
+* A streaming chat completion chunk (OpenAI-compatible).
+*
+* @since 1.0.0
+* @category Schemas
+*/
+declare class ChatCompletionChunk extends Schema.Class<ChatCompletionChunk>("@dedalus-labs/ChatCompletionChunk")({
+	id: Schema.String,
+	object: Schema.Literal("chat.completion.chunk"),
+	created: Schema.Int,
+	model: Schema.String,
+	system_fingerprint: Schema.optional(Schema.NullOr(Schema.String)),
+	choices: Schema.Array(ChatCompletionChunkChoice),
+	usage: Schema.optional(Schema.NullOr(exports_Generated.CompletionUsage)),
+	service_tier: Schema.optional(Schema.NullOr(exports_Generated.ChatCompletionServiceTierEnum))
+}) {}
+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";
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class DedalusConfig extends Context2.Tag("@dedalus-labs/DedalusConfig")<DedalusConfig, DedalusConfig.Service>() {
+	/**
+	* @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 Duration from "effect/Duration";
+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;
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class Config2 extends Context3.Tag("@dedalus-labs/DedalusEmbeddingModel/Config")<Config2, Config2.Service>() {
+	/**
+	* @since 1.0.0
+	*/
+	static readonly getOrUndefined: Effect4.Effect4<Config2.Service | undefined>;
+}
+/**
+* @since 1.0.0
+*/
+declare namespace Config2 {
+	/**
+	* @since 1.0.
+	* @category Configuration
+	*/
+	interface Service extends Simplify<Partial<Omit<typeof exports_Generated.CreateEmbeddingRequest.Encoded, "input">>> {}
+	/**
+	* @since 1.0.
+	* @category Configuration
+	*/
+	interface Batched extends Omit<Config2.Service, "model"> {
+		readonly maxBatchSize?: number;
+		readonly cache?: {
+			readonly capacity: number
+			readonly timeToLive: Duration.DurationInput
+		};
+	}
+	/**
+	* @since 1.0.
+	* @category Configuration
+	*/
+	interface DataLoader extends Omit<Config2.Service, "model"> {
+		readonly window: Duration.DurationInput;
+		readonly maxBatchSize?: number;
+	}
+}
+/**
+* @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: 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";
+import { Simplify as Simplify2 } from "effect/Types";
+/**
+* @since 1.0.0
+* @category Models
+*/
+type Model2 = typeof exports_Generated.DedalusModelChoice.Encoded | typeof exports_Generated.Models.Encoded;
+/**
+* @since 1.0.0
+* @category Context
+*/
+declare class Config3 extends Context4.Tag("@dedalus-labs/DedalusLanguageModel/Config")<Config3, Config3.Service>() {
+	/**
+	* @since 1.0.0
+	*/
+	static readonly getOrUndefined: Effect5.Effect5<Config3.Service | undefined>;
+}
+/**
+* @since 1.0.0
+*/
+declare namespace Config3 {
+	/**
+	* @since 1.0.0
+	* @category Models
+	*/
+	interface Service extends Simplify2<Partial<Omit<typeof exports_Generated.ChatCompletionRequest.Encoded, "messages" | "input" | "instructions" | "system" | "tools" | "tool_choice" | "response_format" | "stream">>> {}
+}
+/**
+* @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: 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 };