@luketandjung/dedalus-labs 1.0.0

package/dist/index.js

@@ -0,0 +1,1293 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/dedalus-labs/src/Generated.ts
+var exports_Generated = {};
+__export(exports_Generated, {
+  make: () => make,
+  ValidationError: () => ValidationError,
+  UrlCitation: () => UrlCitation,
+  TopLogprob: () => TopLogprob,
+  ToolChoiceEnum: () => ToolChoiceEnum,
+  ToolChoice: () => ToolChoice,
+  ThinkingConfigEnabled: () => ThinkingConfigEnabled,
+  ThinkingConfigDisabled: () => ThinkingConfigDisabled,
+  ReasoningSummaryEnum: () => ReasoningSummaryEnum,
+  ReasoningGenerateSummaryEnum: () => ReasoningGenerateSummaryEnum,
+  ReasoningEffortEnum: () => ReasoningEffortEnum,
+  Reasoning: () => Reasoning,
+  QueryParams: () => QueryParams,
+  PromptTokensDetails: () => PromptTokensDetails,
+  Models: () => Models,
+  ModelSettingsTruncationEnum: () => ModelSettingsTruncationEnum,
+  ModelSettings: () => ModelSettings,
+  ModelId: () => ModelId,
+  MCPToolChoice: () => MCPToolChoice,
+  HeaderParams: () => HeaderParams,
+  HTTPValidationError: () => HTTPValidationError,
+  FunctionCall: () => FunctionCall,
+  Function: () => Function,
+  Embedding: () => Embedding,
+  DedalusModelChoice: () => DedalusModelChoice,
+  DedalusModel: () => DedalusModel,
+  Custom: () => Custom,
+  CreateEmbeddingResponse: () => CreateEmbeddingResponse,
+  CreateEmbeddingRequestModelEnum: () => CreateEmbeddingRequestModelEnum,
+  CreateEmbeddingRequestEncodingFormat: () => CreateEmbeddingRequestEncodingFormat,
+  CreateEmbeddingRequest: () => CreateEmbeddingRequest,
+  CompletionUsage: () => CompletionUsage,
+  CompletionTokensDetails: () => CompletionTokensDetails,
+  ChoiceLogprobs: () => ChoiceLogprobs,
+  ChoiceFinishReasonEnum: () => ChoiceFinishReasonEnum,
+  Choice: () => Choice,
+  ChatCompletionTokenLogprob: () => ChatCompletionTokenLogprob,
+  ChatCompletionServiceTierEnum: () => ChatCompletionServiceTierEnum,
+  ChatCompletionResponseMessage: () => ChatCompletionResponseMessage,
+  ChatCompletionRequestVerbosityEnum: () => ChatCompletionRequestVerbosityEnum,
+  ChatCompletionRequestServiceTierEnum: () => ChatCompletionRequestServiceTierEnum,
+  ChatCompletionRequestReasoningEffortEnum: () => ChatCompletionRequestReasoningEffortEnum,
+  ChatCompletionRequest: () => ChatCompletionRequest,
+  ChatCompletionMessageToolCall: () => ChatCompletionMessageToolCall,
+  ChatCompletionMessageCustomToolCall: () => ChatCompletionMessageCustomToolCall,
+  ChatCompletion: () => ChatCompletion,
+  Audio: () => Audio,
+  AnnotationsItem: () => AnnotationsItem
+});
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import { AiError } from "@luketandjung/ariadne";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+
+class ModelId extends S.String {
+}
+
+class ToolChoiceEnum extends S.Literal("auto", "required", "none") {
+}
+
+class MCPToolChoice extends S.Class("MCPToolChoice")({
+  server_label: S.String,
+  name: S.String
+}) {
+}
+
+class ToolChoice extends S.Union(ToolChoiceEnum, S.String, S.Record({ key: S.String, value: S.Unknown }), MCPToolChoice, S.Null) {
+}
+
+class ModelSettingsTruncationEnum extends S.Literal("auto", "disabled") {
+}
+
+class ReasoningEffortEnum extends S.Literal("minimal", "low", "medium", "high") {
+}
+
+class ReasoningGenerateSummaryEnum extends S.Literal("auto", "concise", "detailed") {
+}
+
+class ReasoningSummaryEnum extends S.Literal("auto", "concise", "detailed") {
+}
+
+class Reasoning extends S.Class("Reasoning")({
+  effort: S.optionalWith(ReasoningEffortEnum, { nullable: true }),
+  generate_summary: S.optionalWith(ReasoningGenerateSummaryEnum, {
+    nullable: true
+  }),
+  summary: S.optionalWith(ReasoningSummaryEnum, { nullable: true })
+}) {
+}
+
+class QueryParams extends S.Record({
+  key: S.String,
+  value: S.Unknown
+}) {
+}
+
+class HeaderParams extends S.Record({
+  key: S.String,
+  value: S.Unknown
+}) {
+}
+
+class ModelSettings extends S.Class("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
+  }),
+  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
+  }),
+  search_parameters: S.optionalWith(S.Record({ key: S.String, value: S.Unknown }), { nullable: true }),
+  deferred: S.optionalWith(S.Boolean, { nullable: true })
+}) {
+}
+
+class DedalusModel extends S.Class("DedalusModel")({
+  model: S.String,
+  settings: S.optionalWith(ModelSettings, { nullable: true })
+}) {
+}
+
+class DedalusModelChoice extends S.Union(ModelId, DedalusModel) {
+}
+
+class Models extends S.Array(DedalusModelChoice) {
+}
+
+class ThinkingConfigDisabled extends S.Class("ThinkingConfigDisabled")({
+  type: S.Literal("disabled")
+}) {
+}
+
+class ThinkingConfigEnabled extends S.Class("ThinkingConfigEnabled")({
+  budget_tokens: S.Int.pipe(S.greaterThanOrEqualTo(1024)),
+  type: S.Literal("enabled")
+}) {
+}
+
+class ChatCompletionRequestReasoningEffortEnum extends S.Literal("low", "medium", "high") {
+}
+
+class ChatCompletionRequestServiceTierEnum extends S.Literal("auto", "default") {
+}
+
+class ChatCompletionRequestVerbosityEnum extends S.Literal("low", "medium", "high") {
+}
+
+class ChatCompletionRequest extends S.Class("ChatCompletionRequest")({
+  model: S.Union(DedalusModelChoice, Models),
+  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
+  }),
+  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
+  })
+}) {
+}
+
+class ChoiceFinishReasonEnum extends S.Literal("stop", "length", "tool_calls", "content_filter", "function_call") {
+}
+
+class Function extends S.Class("Function")({
+  name: S.String,
+  arguments: S.String
+}) {
+}
+
+class ChatCompletionMessageToolCall extends S.Class("ChatCompletionMessageToolCall")({
+  id: S.String,
+  type: S.Literal("function"),
+  function: Function
+}) {
+}
+
+class Custom extends S.Class("Custom")({
+  name: S.String,
+  input: S.String
+}) {
+}
+
+class ChatCompletionMessageCustomToolCall extends S.Class("ChatCompletionMessageCustomToolCall")({
+  id: S.String,
+  type: S.Literal("custom"),
+  custom: Custom
+}) {
+}
+
+class UrlCitation extends S.Class("UrlCitation")({
+  end_index: S.Int,
+  start_index: S.Int,
+  url: S.String,
+  title: S.String
+}) {
+}
+
+class AnnotationsItem extends S.Class("AnnotationsItem")({
+  type: S.Literal("url_citation"),
+  url_citation: UrlCitation
+}) {
+}
+
+class FunctionCall extends S.Class("FunctionCall")({
+  arguments: S.String,
+  name: S.String
+}) {
+}
+
+class Audio extends S.Class("Audio")({
+  id: S.String,
+  expires_at: S.Int,
+  data: S.String,
+  transcript: S.String
+}) {
+}
+
+class ChatCompletionResponseMessage extends S.Class("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 })
+}) {
+}
+
+class TopLogprob extends S.Class("TopLogprob")({
+  token: S.String,
+  logprob: S.Number,
+  bytes: S.NullOr(S.Array(S.Int))
+}) {
+}
+
+class ChatCompletionTokenLogprob extends S.Class("ChatCompletionTokenLogprob")({
+  token: S.String,
+  logprob: S.Number,
+  bytes: S.NullOr(S.Array(S.Int)),
+  top_logprobs: S.Array(TopLogprob)
+}) {
+}
+
+class ChoiceLogprobs extends S.Class("ChoiceLogprobs")({
+  content: S.optionalWith(S.Array(ChatCompletionTokenLogprob), {
+    nullable: true
+  }),
+  refusal: S.optionalWith(S.Array(ChatCompletionTokenLogprob), {
+    nullable: true
+  })
+}) {
+}
+
+class Choice extends S.Class("Choice")({
+  finish_reason: S.optionalWith(ChoiceFinishReasonEnum, { nullable: true }),
+  index: S.Int,
+  message: ChatCompletionResponseMessage,
+  logprobs: S.optionalWith(ChoiceLogprobs, { nullable: true })
+}) {
+}
+
+class ChatCompletionServiceTierEnum extends S.Literal("auto", "default", "flex", "scale", "priority") {
+}
+
+class CompletionTokensDetails extends S.Class("CompletionTokensDetails")({
+  accepted_prediction_tokens: S.optionalWith(S.Int, {
+    nullable: true,
+    default: () => 0
+  }),
+  audio_tokens: S.optionalWith(S.Int, {
+    nullable: true,
+    default: () => 0
+  }),
+  reasoning_tokens: S.optionalWith(S.Int, {
+    nullable: true,
+    default: () => 0
+  }),
+  rejected_prediction_tokens: S.optionalWith(S.Int, {
+    nullable: true,
+    default: () => 0
+  })
+}) {
+}
+
+class PromptTokensDetails extends S.Class("PromptTokensDetails")({
+  audio_tokens: S.optionalWith(S.Int, {
+    nullable: true,
+    default: () => 0
+  }),
+  cached_tokens: S.optionalWith(S.Int, {
+    nullable: true,
+    default: () => 0
+  })
+}) {
+}
+
+class CompletionUsage extends S.Class("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
+  })
+}) {
+}
+
+class ChatCompletion extends S.Class("ChatCompletion")({
+  id: S.String,
+  choices: S.Array(Choice),
+  created: S.Int,
+  model: S.String,
+  service_tier: S.optionalWith(ChatCompletionServiceTierEnum, {
+    nullable: true
+  }),
+  system_fingerprint: S.optionalWith(S.String, { nullable: true }),
+  object: S.Literal("chat.completion"),
+  usage: S.optionalWith(CompletionUsage, { 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 })
+}) {
+}
+
+class ValidationError extends S.Class("ValidationError")({
+  loc: S.Array(S.Union(S.String, S.Int)),
+  msg: S.String,
+  type: S.String
+}) {
+}
+
+class HTTPValidationError extends S.Class("HTTPValidationError")({
+  detail: S.optionalWith(S.Array(ValidationError), { nullable: true })
+}) {
+}
+var make = (httpClient, options = {}) => {
+  const unexpectedStatus = (response) => Effect.flatMap(Effect.orElseSucceed(response.json, () => "Unexpected status code"), (description) => Effect.fail(new HttpClientError.ResponseError({
+    request: response.request,
+    response,
+    reason: "StatusCode",
+    description: typeof description === "string" ? description : JSON.stringify(description)
+  })));
+  const withResponse = options.transformClient ? (f) => (request) => Effect.flatMap(Effect.flatMap(options.transformClient(httpClient), (client) => client.execute(request)), f) : (f) => (request) => Effect.flatMap(httpClient.execute(request), f);
+  const decodeSuccess = (schema) => (response) => HttpClientResponse.schemaBodyJson(schema)(response);
+  const decodeValidationError = (response) => Effect.flatMap(HttpClientResponse.schemaBodyJson(HTTPValidationError)(response), (cause) => Effect.fail(new AiError.MalformedInput({
+    module: "DedalusClient",
+    method: response.request.url,
+    description: cause.detail?.map((v) => `${v.loc.join(".")}: ${v.msg}`).join("; ")
+  })));
+  return {
+    httpClient,
+    createChatCompletionV1ChatCompletionsPost: (options2) => HttpClientRequest.post(`/v1/chat/completions`).pipe(HttpClientRequest.bodyUnsafeJson(options2), withResponse(HttpClientResponse.matchStatus({
+      "2xx": decodeSuccess(ChatCompletion),
+      "422": decodeValidationError,
+      orElse: unexpectedStatus
+    }))),
+    createEmbeddingsV1EmbeddingsPost: (options2) => HttpClientRequest.post(`/v1/embeddings`).pipe(HttpClientRequest.bodyUnsafeJson(options2), withResponse(HttpClientResponse.matchStatus({
+      "2xx": decodeSuccess(CreateEmbeddingResponse),
+      "422": decodeValidationError,
+      orElse: unexpectedStatus
+    })))
+  };
+};
+
+class CreateEmbeddingRequestModelEnum extends S.Literal("openai/text-embedding-ada-002", "openai/text-embedding-3-small", "openai/text-embedding-3-large", "google/text-embedding-004") {
+}
+
+class CreateEmbeddingRequestEncodingFormat extends S.Literal("float", "base64") {
+}
+
+class CreateEmbeddingRequest extends S.Class("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, CreateEmbeddingRequestModelEnum),
+  encoding_format: S.optionalWith(CreateEmbeddingRequestEncodingFormat, {
+    nullable: true,
+    default: () => "float"
+  }),
+  dimensions: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), {
+    nullable: true
+  }),
+  user: S.optionalWith(S.String, { nullable: true })
+}) {
+}
+
+class Embedding extends S.Class("Embedding")({
+  object: S.optionalWith(S.Literal("embedding"), {
+    nullable: true,
+    default: () => "embedding"
+  }),
+  embedding: S.Union(S.Array(S.Number), S.String),
+  index: S.Int
+}) {
+}
+
+class CreateEmbeddingResponse extends S.Class("CreateEmbeddingResponse")({
+  object: S.optionalWith(S.Literal("list"), {
+    nullable: true,
+    default: () => "list"
+  }),
+  data: S.Array(Embedding),
+  model: S.String,
+  usage: S.Record({ key: S.String, value: S.Unknown })
+}) {
+}
+// packages/dedalus-labs/src/DedalusClient.ts
+var exports_DedalusClient = {};
+__export(exports_DedalusClient, {
+  make: () => make2,
+  layerConfig: () => layerConfig,
+  layer: () => layer,
+  DedalusClient: () => DedalusClient,
+  ChatCompletionChunkDelta: () => ChatCompletionChunkDelta,
+  ChatCompletionChunkChoice: () => ChatCompletionChunkChoice,
+  ChatCompletionChunk: () => ChatCompletionChunk
+});
+import * as Sse from "@effect/experimental/Sse";
+import * as HttpBody from "@effect/platform/HttpBody";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest2 from "@effect/platform/HttpClientRequest";
+import { AiError as AiError2 } from "@luketandjung/ariadne";
+import * as Config from "effect/Config";
+import * as Context2 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import { identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+// packages/dedalus-labs/src/DedalusConfig.ts
+var exports_DedalusConfig = {};
+__export(exports_DedalusConfig, {
+  withClientTransform: () => withClientTransform,
+  DedalusConfig: () => DedalusConfig
+});
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import { dual } from "effect/Function";
+
+class DedalusConfig extends Context.Tag("@dedalus-labs/DedalusConfig")() {
+  static getOrUndefined = Effect2.map(Effect2.context(), (context2) => context2.unsafeMap.get(DedalusConfig.key));
+}
+var withClientTransform = dual(2, (self, transformClient) => Effect2.flatMap(DedalusConfig.getOrUndefined, (config) => Effect2.provideService(self, DedalusConfig, {
+  ...config,
+  transformClient
+})));
+
+// packages/dedalus-labs/src/internal/utilities.ts
+var uuid4 = function() {
+  const { crypto } = globalThis;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
+};
+
+// packages/dedalus-labs/src/DedalusClient.ts
+class DedalusClient extends Context2.Tag("@dedalus-labs/DedalusClient")() {
+}
+var make2 = (options) => Effect3.gen(function* () {
+  const baseUrl = options.apiUrl ?? ((options.environment ?? "production") === "production" ? "https://api.dedaluslabs.ai" : "http://localhost:8080");
+  const httpClient = (yield* HttpClient.HttpClient).pipe(HttpClient.mapRequest((request) => {
+    const headers = {
+      "User-Agent": "Dedalus/JS 1.0.0",
+      "X-SDK-Version": "1.0.0"
+    };
+    if (options.provider) {
+      headers["X-Provider"] = options.provider;
+    }
+    if (options.providerKey) {
+      headers["X-Provider-Key"] = Redacted.value(options.providerKey);
+    }
+    if (request.method !== "GET") {
+      headers["Idempotency-Key"] = `stainless-node-retry-${uuid4()}`;
+    }
+    return request.pipe(HttpClientRequest2.prependUrl(baseUrl), options.apiKey ? HttpClientRequest2.bearerToken(options.apiKey) : options.xApiKey ? HttpClientRequest2.setHeader("x-api-key", Redacted.value(options.xApiKey)) : identity, HttpClientRequest2.setHeaders(headers), HttpClientRequest2.acceptJson);
+  }), options.transformClient ?? identity);
+  const httpClientOk = HttpClient.filterStatusOk(httpClient);
+  const client = make(httpClient, {
+    transformClient: (client2) => DedalusConfig.getOrUndefined.pipe(Effect3.map((config) => config?.transformClient ? config.transformClient(client2) : client2))
+  });
+  const createChatCompletion = (options2) => client.createChatCompletionV1ChatCompletionsPost(options2).pipe(Effect3.catchTags({
+    RequestError: (error) => AiError2.HttpRequestError.fromRequestError({
+      module: "DedalusClient",
+      method: "createChatCompletion",
+      error
+    }),
+    ResponseError: (error) => AiError2.HttpResponseError.fromResponseError({
+      module: "DedalusClient",
+      method: "createChatCompletion",
+      error
+    }),
+    ParseError: (error) => AiError2.MalformedOutput.fromParseError({
+      module: "DedalusClient",
+      method: "createChatCompletion",
+      error
+    })
+  }));
+  const createChatCompletionStream = (options2) => {
+    const request = HttpClientRequest2.post("/v1/chat/completions", {
+      body: HttpBody.unsafeJson({ ...options2, stream: true })
+    });
+    const decodeChunk = Schema.decode(Schema.parseJson(ChatCompletionChunk));
+    return httpClientOk.execute(request).pipe(Effect3.map((r) => r.stream), Stream.unwrapScoped, Stream.decodeText(), Stream.pipeThroughChannel(Sse.makeChannel()), Stream.mapEffect((event) => decodeChunk(event.data)), Stream.takeUntil((chunk) => chunk.choices.some((choice) => choice.finish_reason !== null)), Stream.catchTags({
+      RequestError: (error) => AiError2.HttpRequestError.fromRequestError({
+        module: "DedalusClient",
+        method: "createChatCompletionStream",
+        error
+      }),
+      ResponseError: (error) => AiError2.HttpResponseError.fromResponseError({
+        module: "DedalusClient",
+        method: "createChatCompletionStream",
+        error
+      }),
+      ParseError: (error) => AiError2.MalformedOutput.fromParseError({
+        module: "DedalusClient",
+        method: "createChatCompletionStream",
+        error
+      })
+    }));
+  };
+  const createEmbedding = (options2) => client.createEmbeddingsV1EmbeddingsPost(options2).pipe(Effect3.catchTags({
+    RequestError: (error) => AiError2.HttpRequestError.fromRequestError({
+      module: "DedalusClient",
+      method: "createEmbedding",
+      error
+    }),
+    ResponseError: (error) => AiError2.HttpResponseError.fromResponseError({
+      module: "DedalusClient",
+      method: "createEmbedding",
+      error
+    }),
+    ParseError: (error) => AiError2.MalformedOutput.fromParseError({
+      module: "DedalusClient",
+      method: "createEmbedding",
+      error
+    })
+  }));
+  return DedalusClient.of({
+    client,
+    createChatCompletion,
+    createChatCompletionStream,
+    createEmbedding
+  });
+});
+var layer = (options) => Layer.scoped(DedalusClient, make2(options));
+var layerConfig = (options) => {
+  const { transformClient, ...configs } = options;
+  return Config.all(configs).pipe(Effect3.flatMap((configs2) => make2({ ...configs2, transformClient })), Layer.scoped(DedalusClient));
+};
+
+class ChatCompletionChunkDelta extends Schema.Class("@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)
+    }))
+  })))
+}) {
+}
+
+class ChatCompletionChunkChoice extends Schema.Class("@dedalus-labs/ChatCompletionChunkChoice")({
+  index: Schema.Int,
+  delta: ChatCompletionChunkDelta,
+  logprobs: Schema.optional(Schema.NullOr(ChoiceLogprobs)),
+  finish_reason: Schema.NullOr(ChoiceFinishReasonEnum)
+}) {
+}
+
+class ChatCompletionChunk extends Schema.Class("@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(CompletionUsage)),
+  service_tier: Schema.optional(Schema.NullOr(ChatCompletionServiceTierEnum))
+}) {
+}
+// packages/dedalus-labs/src/DedalusEmbeddingModel.ts
+var exports_DedalusEmbeddingModel = {};
+__export(exports_DedalusEmbeddingModel, {
+  withConfigOverride: () => withConfigOverride,
+  model: () => model,
+  makeDataLoader: () => makeDataLoader,
+  layerDataLoader: () => layerDataLoader,
+  layerBatched: () => layerBatched,
+  Config: () => Config2
+});
+import { Model as AiModel, EmbeddingModel } from "@luketandjung/ariadne";
+import * as Context3 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import { dual as dual2 } from "effect/Function";
+import * as Layer2 from "effect/Layer";
+class Config2 extends Context3.Tag("@dedalus-labs/DedalusEmbeddingModel/Config")() {
+  static getOrUndefined = Effect4.map(Effect4.context(), (context3) => context3.unsafeMap.get(Config2.key));
+}
+var model = (model2, {
+  mode,
+  ...config
+}) => {
+  return AiModel.make("dedalus-labs", mode === "batched" ? layerBatched({ model: model2, config }) : layerDataLoader({ model: model2, config }));
+};
+var makeBatched = Effect4.fnUntraced(function* (options) {
+  const client = yield* DedalusClient;
+  const { config = {}, model: model2 } = options;
+  const { cache, maxBatchSize = 2048, ...globalConfig } = config;
+  const makeRequest = Effect4.fnUntraced(function* (input) {
+    const context3 = yield* Effect4.context();
+    const requestConfig = context3.unsafeMap.get(Config2.key);
+    const request = {
+      model: model2,
+      ...globalConfig,
+      ...requestConfig,
+      input
+    };
+    return request;
+  });
+  return yield* EmbeddingModel.make({
+    cache,
+    maxBatchSize,
+    embedMany: Effect4.fnUntraced(function* (input) {
+      const request = yield* makeRequest(input);
+      const response = yield* client.createEmbedding(request);
+      return makeResults(response);
+    })
+  });
+});
+var makeDataLoader = Effect4.fnUntraced(function* (options) {
+  const client = yield* DedalusClient;
+  const { config, model: model2 } = options;
+  const { maxBatchSize = 2048, window, ...globalConfig } = config;
+  const makeRequest = Effect4.fnUntraced(function* (input) {
+    const context3 = yield* Effect4.context();
+    const requestConfig = context3.unsafeMap.get(Config2.key);
+    const request = {
+      model: model2,
+      ...globalConfig,
+      ...requestConfig,
+      input
+    };
+    return request;
+  });
+  return yield* EmbeddingModel.makeDataLoader({
+    window,
+    maxBatchSize,
+    embedMany: Effect4.fnUntraced(function* (input) {
+      const request = yield* makeRequest(input);
+      const response = yield* client.createEmbedding(request);
+      return makeResults(response);
+    })
+  });
+});
+var layerBatched = (options) => Layer2.effect(EmbeddingModel.EmbeddingModel, makeBatched(options));
+var layerDataLoader = (options) => Layer2.scoped(EmbeddingModel.EmbeddingModel, makeDataLoader(options));
+var withConfigOverride = dual2(2, (self, overrides) => Effect4.flatMap(Config2.getOrUndefined, (config) => Effect4.provideService(self, Config2, { ...config, ...overrides })));
+var makeResults = (response) => response.data.map(({ embedding, index }) => ({
+  embeddings: embedding,
+  index
+}));
+// packages/dedalus-labs/src/DedalusLanguageModel.ts
+var exports_DedalusLanguageModel = {};
+__export(exports_DedalusLanguageModel, {
+  withConfigOverride: () => withConfigOverride2,
+  model: () => model2,
+  make: () => make3,
+  layer: () => layer2,
+  Config: () => Config3
+});
+import {
+  AiError as AiError3,
+  Model as AiModel2,
+  IdGenerator,
+  LanguageModel,
+  McpRegistry,
+  Tool
+} from "@luketandjung/ariadne";
+import * as Context4 from "effect/Context";
+import * as DateTime from "effect/DateTime";
+import * as Effect5 from "effect/Effect";
+import { dual as dual3 } from "effect/Function";
+import * as Layer3 from "effect/Layer";
+import * as Stream2 from "effect/Stream";
+class Config3 extends Context4.Tag("@dedalus-labs/DedalusLanguageModel/Config")() {
+  static getOrUndefined = Effect5.map(Effect5.context(), (context4) => context4.unsafeMap.get(Config3.key));
+}
+var model2 = (model3, config) => AiModel2.make("dedalus-labs", layer2({ model: model3, config }));
+var make3 = Effect5.fnUntraced(function* (options) {
+  const client = yield* DedalusClient;
+  const makeRequest = Effect5.fnUntraced(function* (providerOptions) {
+    const context4 = yield* Effect5.context();
+    const config = {
+      model: options.model,
+      ...options.config,
+      ...context4.unsafeMap.get(Config3.key)
+    };
+    const messages = yield* prepareMessages(providerOptions);
+    const { toolChoice, tools } = yield* prepareTools(providerOptions);
+    const responseFormat = prepareResponseFormat(providerOptions);
+    const request = {
+      ...config,
+      messages,
+      tools,
+      tool_choice: toolChoice,
+      response_format: responseFormat,
+      mcp_servers: providerOptions.mcpServers.length > 0 ? McpRegistry.toApiFormat(providerOptions.mcpServers) : undefined
+    };
+    return request;
+  });
+  return yield* LanguageModel.make({
+    generateText: Effect5.fnUntraced(function* (options2) {
+      const request = yield* makeRequest(options2);
+      const rawResponse = yield* client.createChatCompletion(request);
+      return yield* makeResponse(rawResponse, options2);
+    }),
+    streamText: Effect5.fnUntraced(function* (options2) {
+      const request = yield* makeRequest(options2);
+      return client.createChatCompletionStream(request);
+    }, (effect3, options2) => effect3.pipe(Effect5.flatMap((stream) => makeStreamResponse(stream, options2)), Stream2.unwrap))
+  });
+});
+var layer2 = (options) => Layer3.effect(LanguageModel.LanguageModel, make3({ model: options.model, config: options.config }));
+var withConfigOverride2 = dual3(2, (self, overrides) => Effect5.flatMap(Config3.getOrUndefined, (config) => Effect5.provideService(self, Config3, { ...config, ...overrides })));
+var prepareMessages = (options) => Effect5.gen(function* () {
+  const messages = [];
+  for (const message of options.prompt.content) {
+    switch (message.role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: message.content
+        });
+        break;
+      }
+      case "user": {
+        const textParts = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text": {
+              textParts.push(part.text);
+              break;
+            }
+            case "file": {
+              return yield* new AiError3.MalformedInput({
+                module: "DedalusLanguageModel",
+                method: "prepareMessages",
+                description: `File attachments are not yet supported. Received file with media type: '${part.mediaType}'`
+              });
+            }
+          }
+        }
+        messages.push({
+          role: "user",
+          content: textParts.join(`
+`)
+        });
+        break;
+      }
+      case "assistant": {
+        const textParts = [];
+        const toolCalls = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text": {
+              textParts.push(part.text);
+              break;
+            }
+            case "tool-call": {
+              if (!part.providerExecuted) {
+                toolCalls.push({
+                  id: part.id,
+                  type: "function",
+                  function: {
+                    name: part.name,
+                    arguments: JSON.stringify(part.params)
+                  }
+                });
+              }
+              break;
+            }
+            case "reasoning": {
+              break;
+            }
+          }
+        }
+        const content = textParts.length > 0 ? textParts.join(`
+`) : null;
+        if (toolCalls.length > 0) {
+          messages.push({
+            role: "assistant",
+            content,
+            tool_calls: toolCalls
+          });
+        } else if (content !== null) {
+          messages.push({
+            role: "assistant",
+            content
+          });
+        }
+        break;
+      }
+      case "tool": {
+        for (const part of message.content) {
+          messages.push({
+            role: "tool",
+            tool_call_id: part.id,
+            content: JSON.stringify(part.result)
+          });
+        }
+        break;
+      }
+    }
+  }
+  return messages;
+});
+var makeResponse = Effect5.fnUntraced(function* (response, _options) {
+  const idGenerator = yield* IdGenerator.IdGenerator;
+  const parts = [];
+  const createdAt = new Date(response.created * 1000);
+  parts.push({
+    type: "response-metadata",
+    id: response.id,
+    modelId: response.model,
+    timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
+  });
+  const choice = response.choices[0];
+  if (choice) {
+    const message = choice.message;
+    if (message.content !== null && message.content !== undefined) {
+      parts.push({
+        type: "text",
+        text: message.content
+      });
+    }
+    if (message.refusal !== null && message.refusal !== undefined) {
+      parts.push({
+        type: "text",
+        text: "",
+        metadata: { dedalus: { refusal: message.refusal } }
+      });
+    }
+    if (message.annotations) {
+      for (const annotation of message.annotations) {
+        if (annotation.type === "url_citation") {
+          parts.push({
+            type: "source",
+            sourceType: "url",
+            id: yield* idGenerator.generateId(),
+            url: annotation.url_citation.url,
+            title: annotation.url_citation.title,
+            metadata: {
+              dedalus: {
+                startIndex: annotation.url_citation.start_index,
+                endIndex: annotation.url_citation.end_index
+              }
+            }
+          });
+        }
+      }
+    }
+    if (message.tool_calls) {
+      for (const toolCall of message.tool_calls) {
+        if (toolCall.type === "function") {
+          const toolName = toolCall.function.name;
+          const toolParams = toolCall.function.arguments;
+          const params = yield* Effect5.try({
+            try: () => Tool.unsafeSecureJsonParse(toolParams),
+            catch: (cause) => new AiError3.MalformedOutput({
+              module: "DedalusLanguageModel",
+              method: "makeResponse",
+              description: "Failed to securely parse tool call parameters " + `for tool '${toolName}':
+Parameters: ${toolParams}`,
+              cause
+            })
+          });
+          parts.push({
+            type: "tool-call",
+            id: toolCall.id,
+            name: toolName,
+            params
+          });
+        } else if (toolCall.type === "custom") {
+          const toolName = toolCall.custom.name;
+          const toolInput = toolCall.custom.input;
+          const params = yield* Effect5.try({
+            try: () => Tool.unsafeSecureJsonParse(toolInput),
+            catch: (cause) => new AiError3.MalformedOutput({
+              module: "DedalusLanguageModel",
+              method: "makeResponse",
+              description: "Failed to securely parse custom tool call input " + `for tool '${toolName}':
+Input: ${toolInput}`,
+              cause
+            })
+          });
+          parts.push({
+            type: "tool-call",
+            id: toolCall.id,
+            name: toolName,
+            params
+          });
+        }
+      }
+    }
+    const hasToolCalls = (message.tool_calls?.length ?? 0) > 0;
+    const finishReason = resolveFinishReason(choice.finish_reason, hasToolCalls);
+    parts.push({
+      type: "finish",
+      reason: finishReason,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens,
+        outputTokens: response.usage?.completion_tokens,
+        totalTokens: response.usage?.total_tokens,
+        reasoningTokens: response.usage?.completion_tokens_details?.reasoning_tokens,
+        cachedInputTokens: response.usage?.prompt_tokens_details?.cached_tokens
+      },
+      metadata: {
+        dedalus: {
+          serviceTier: response.service_tier,
+          toolsExecuted: response.tools_executed,
+          mcpServerErrors: response.mcp_server_errors
+        }
+      }
+    });
+  }
+  if (response.tools_executed && response.tools_executed.length > 0) {
+    for (const toolName of response.tools_executed) {
+      parts.push({
+        type: "tool-call",
+        id: yield* idGenerator.generateId(),
+        name: toolName,
+        params: {},
+        providerExecuted: true
+      });
+    }
+  }
+  return parts;
+});
+var makeStreamResponse = (stream, _options) => Effect5.gen(function* () {
+  const activeToolCalls = new Map;
+  let hasEmittedMetadata = false;
+  let hasToolCalls = false;
+  return stream.pipe(Stream2.mapEffect(Effect5.fnUntraced(function* (chunk) {
+    const parts = [];
+    if (!hasEmittedMetadata) {
+      const createdAt = new Date(chunk.created * 1000);
+      parts.push({
+        type: "response-metadata",
+        id: chunk.id,
+        modelId: chunk.model,
+        timestamp: DateTime.formatIso(DateTime.unsafeFromDate(createdAt))
+      });
+      hasEmittedMetadata = true;
+    }
+    const choice = chunk.choices[0];
+    if (choice) {
+      const delta = choice.delta;
+      if (delta.content !== null && delta.content !== undefined) {
+        parts.push({
+          type: "text-delta",
+          id: chunk.id,
+          delta: delta.content
+        });
+      }
+      if (delta.tool_calls) {
+        for (const toolCallDelta of delta.tool_calls) {
+          const index = toolCallDelta.index;
+          if (toolCallDelta.id) {
+            activeToolCalls.set(index, {
+              id: toolCallDelta.id,
+              name: toolCallDelta.function?.name ?? "",
+              arguments: ""
+            });
+            parts.push({
+              type: "tool-params-start",
+              id: toolCallDelta.id,
+              name: toolCallDelta.function?.name ?? ""
+            });
+          }
+          const toolCall = activeToolCalls.get(index);
+          if (toolCall) {
+            if (toolCallDelta.function?.name) {
+              toolCall.name = toolCallDelta.function.name;
+            }
+            if (toolCallDelta.function?.arguments) {
+              toolCall.arguments += toolCallDelta.function.arguments;
+              parts.push({
+                type: "tool-params-delta",
+                id: toolCall.id,
+                delta: toolCallDelta.function.arguments
+              });
+            }
+          }
+        }
+      }
+      if (choice.finish_reason !== null) {
+        for (const [_index, toolCall] of activeToolCalls) {
+          hasToolCalls = true;
+          const params = yield* Effect5.try({
+            try: () => Tool.unsafeSecureJsonParse(toolCall.arguments),
+            catch: (cause) => new AiError3.MalformedOutput({
+              module: "DedalusLanguageModel",
+              method: "makeStreamResponse",
+              description: "Failed to securely parse tool call parameters " + `for tool '${toolCall.name}':
+Parameters: ${toolCall.arguments}`,
+              cause
+            })
+          });
+          parts.push({
+            type: "tool-params-end",
+            id: toolCall.id
+          });
+          parts.push({
+            type: "tool-call",
+            id: toolCall.id,
+            name: toolCall.name,
+            params
+          });
+        }
+        activeToolCalls.clear();
+        const finishReason = resolveFinishReason(choice.finish_reason, hasToolCalls);
+        parts.push({
+          type: "finish",
+          reason: finishReason,
+          usage: {
+            inputTokens: chunk.usage?.prompt_tokens,
+            outputTokens: chunk.usage?.completion_tokens,
+            totalTokens: chunk.usage?.total_tokens,
+            reasoningTokens: chunk.usage?.completion_tokens_details?.reasoning_tokens,
+            cachedInputTokens: chunk.usage?.prompt_tokens_details?.cached_tokens
+          },
+          metadata: {
+            dedalus: { serviceTier: chunk.service_tier }
+          }
+        });
+      }
+    }
+    return parts;
+  })), Stream2.flattenIterables);
+});
+var resolveFinishReason = (finishReason, hasToolCalls) => {
+  if (hasToolCalls)
+    return "tool-calls";
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    default:
+      return finishReason ? "unknown" : "stop";
+  }
+};
+var prepareTools = Effect5.fnUntraced(function* (options) {
+  if (options.tools.length === 0) {
+    return { tools: undefined, toolChoice: undefined };
+  }
+  const tools = [];
+  let toolChoice = undefined;
+  let allowedTools = options.tools;
+  if (typeof options.toolChoice === "object" && "oneOf" in options.toolChoice) {
+    const allowedToolNames = new Set(options.toolChoice.oneOf);
+    allowedTools = options.tools.filter((tool) => allowedToolNames.has(tool.name));
+    toolChoice = options.toolChoice.mode === "required" ? "required" : "auto";
+  }
+  for (const tool of allowedTools) {
+    if (Tool.isUserDefined(tool)) {
+      tools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description ?? Tool.getDescriptionFromSchemaAst(tool.parametersSchema.ast),
+          parameters: Tool.getJsonSchemaFromSchemaAst(tool.parametersSchema.ast),
+          strict: true
+        }
+      });
+    }
+    if (Tool.isProviderDefined(tool)) {
+      return yield* new AiError3.MalformedInput({
+        module: "DedalusLanguageModel",
+        method: "prepareTools",
+        description: `Provider-defined tools are not supported. Received: '${tool.name}'`
+      });
+    }
+  }
+  if (options.toolChoice === "none" || options.toolChoice === "required") {
+    toolChoice = options.toolChoice;
+  }
+  if (typeof options.toolChoice === "object" && "tool" in options.toolChoice) {
+    toolChoice = {
+      type: "function",
+      function: { name: options.toolChoice.tool }
+    };
+  }
+  return { tools, toolChoice };
+});
+var prepareResponseFormat = (options) => {
+  if (options.responseFormat.type === "json") {
+    const name = options.responseFormat.objectName;
+    const schema = options.responseFormat.schema;
+    return {
+      type: "json_schema",
+      json_schema: {
+        name,
+        description: Tool.getDescriptionFromSchemaAst(schema.ast) ?? "Response with a JSON object",
+        schema: Tool.getJsonSchemaFromSchemaAst(schema.ast),
+        strict: true
+      }
+    };
+  }
+  return;
+};
+export {
+  exports_Generated as Generated,
+  exports_DedalusLanguageModel as DedalusLanguageModel,
+  exports_DedalusEmbeddingModel as DedalusEmbeddingModel,
+  exports_DedalusConfig as DedalusConfig,
+  exports_DedalusClient as DedalusClient
+};