@luketandjung/ariadne 0.1.0

package/dist/index.js

@@ -0,0 +1,3638 @@
+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/ariadne/src/AiError.ts
+var exports_AiError = {};
+__export(exports_AiError, {
+  isAiError: () => isAiError,
+  UnknownError: () => UnknownError,
+  TypeId: () => TypeId,
+  MalformedOutput: () => MalformedOutput,
+  MalformedInput: () => MalformedInput,
+  HttpResponseError: () => HttpResponseError,
+  HttpResponseDetails: () => HttpResponseDetails,
+  HttpRequestError: () => HttpRequestError,
+  HttpRequestDetails: () => HttpRequestDetails,
+  AiError: () => AiError
+});
+import * as Effect from "effect/Effect";
+import * as Inspectable from "effect/Inspectable";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+var TypeId = "~@effect/ai/AiError";
+var isAiError = (u) => Predicate.hasProperty(u, TypeId);
+var HttpRequestDetails = Schema.Struct({
+  method: Schema.Literal("GET", "POST", "PATCH", "PUT", "DELETE", "HEAD", "OPTIONS"),
+  url: Schema.String,
+  urlParams: Schema.Array(Schema.Tuple(Schema.String, Schema.String)),
+  hash: Schema.Option(Schema.String),
+  headers: Schema.Record({ key: Schema.String, value: Schema.String })
+}).annotations({ identifier: "HttpRequestDetails" });
+
+class HttpRequestError extends Schema.TaggedError("@effect/ai/AiError/HttpRequestError")("HttpRequestError", {
+  module: Schema.String,
+  method: Schema.String,
+  reason: Schema.Literal("Transport", "Encode", "InvalidUrl"),
+  request: HttpRequestDetails,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect)
+}) {
+  [TypeId] = TypeId;
+  static fromRequestError({
+    error,
+    ...params
+  }) {
+    return new HttpRequestError({
+      ...params,
+      cause: error,
+      description: error.description,
+      reason: error.reason,
+      request: {
+        hash: error.request.hash,
+        headers: Inspectable.redact(error.request.headers),
+        method: error.request.method,
+        url: error.request.url,
+        urlParams: error.request.urlParams
+      }
+    });
+  }
+  get message() {
+    const methodAndUrl = `${this.request.method} ${this.request.url}`;
+    let baseMessage = this.description ? `${this.reason}: ${this.description}` : `${this.reason}: An HTTP request error occurred.`;
+    baseMessage += ` (${methodAndUrl})`;
+    let suggestion = "";
+    switch (this.reason) {
+      case "Encode": {
+        suggestion += "Check that the request body data is properly formatted and matches the expected content type.";
+        break;
+      }
+      case "InvalidUrl": {
+        suggestion += "Verify that the URL format is correct and that all required parameters have been provided.";
+        suggestion += " Check for any special characters that may need encoding.";
+        break;
+      }
+      case "Transport": {
+        suggestion += "Check your network connection and verify that the requested URL is accessible.";
+        break;
+      }
+    }
+    baseMessage += `
+
+Suggestion: ${suggestion}`;
+    return baseMessage;
+  }
+}
+var HttpResponseDetails = Schema.Struct({
+  status: Schema.Number,
+  headers: Schema.Record({ key: Schema.String, value: Schema.String })
+}).annotations({ identifier: "HttpResponseDetails" });
+
+class HttpResponseError extends Schema.TaggedError("@effect/ai/AiError/HttpResponseError")("HttpResponseError", {
+  module: Schema.String,
+  method: Schema.String,
+  request: HttpRequestDetails,
+  response: HttpResponseDetails,
+  body: Schema.optional(Schema.String),
+  reason: Schema.Literal("StatusCode", "Decode", "EmptyBody"),
+  description: Schema.optional(Schema.String)
+}) {
+  [TypeId] = TypeId;
+  static fromResponseError({
+    error,
+    ...params
+  }) {
+    let body = Effect.void;
+    const contentType = error.response.headers["content-type"] ?? "";
+    if (contentType.includes("application/json")) {
+      body = error.response.json;
+    } else if (contentType.includes("text/") || contentType.includes("urlencoded")) {
+      body = error.response.text;
+    }
+    return Effect.flatMap(Effect.merge(body), (body2) => new HttpResponseError({
+      ...params,
+      description: error.description,
+      reason: error.reason,
+      request: {
+        hash: error.request.hash,
+        headers: Inspectable.redact(error.request.headers),
+        method: error.request.method,
+        url: error.request.url,
+        urlParams: error.request.urlParams
+      },
+      response: {
+        headers: Inspectable.redact(error.response.headers),
+        status: error.response.status
+      },
+      body: Inspectable.format(body2)
+    }));
+  }
+  get message() {
+    const methodUrlStatus = `${this.response.status} ${this.request.method} ${this.request.url}`;
+    let baseMessage = this.description ? `${this.reason}: ${this.description}` : `${this.reason}: An HTTP response error occurred.`;
+    baseMessage += ` (${methodUrlStatus})`;
+    let suggestion = "";
+    switch (this.reason) {
+      case "Decode": {
+        suggestion += "The response format does not match what is expected. " + "Verify API version compatibility, check response content-type, " + "and/or examine if the endpoint schema has changed.";
+        break;
+      }
+      case "EmptyBody": {
+        suggestion += "The response body was empty. This may indicate a server " + "issue, API version mismatch, or the endpoint may have changed its response format.";
+        break;
+      }
+      case "StatusCode": {
+        suggestion += getStatusCodeSuggestion(this.response.status);
+        break;
+      }
+    }
+    baseMessage += `
+
+${suggestion}`;
+    if (Predicate.isNotUndefined(this.body)) {
+      baseMessage += `
+
+Response Body: ${this.body}`;
+    }
+    return baseMessage;
+  }
+}
+
+class MalformedInput extends Schema.TaggedError("@effect/ai/AiError/MalformedInput")("MalformedInput", {
+  module: Schema.String,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect)
+}) {
+  [TypeId] = TypeId;
+}
+
+class MalformedOutput extends Schema.TaggedError("@effect/ai/AiError/MalformedOutput")("MalformedOutput", {
+  module: Schema.String,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect)
+}) {
+  [TypeId] = TypeId;
+  static fromParseError({
+    error,
+    ...params
+  }) {
+    return new MalformedOutput({
+      ...params,
+      cause: error
+    });
+  }
+}
+
+class UnknownError extends Schema.TaggedError("@effect/ai/UnknownError")("UnknownError", {
+  module: Schema.String,
+  method: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect)
+}) {
+  [TypeId] = TypeId;
+  get message() {
+    const moduleMethod = `${this.module}.${this.method}`;
+    return Predicate.isUndefined(this.description) ? `${moduleMethod}: An error occurred` : `${moduleMethod}: ${this.description}`;
+  }
+}
+var AiError = Schema.Union(HttpRequestError, HttpResponseError, MalformedInput, MalformedOutput, UnknownError);
+var getStatusCodeSuggestion = (statusCode) => {
+  if (statusCode >= 400 && statusCode < 500) {
+    switch (statusCode) {
+      case 400:
+        return "Bad Request - Check request parameters, headers, and body format against API documentation.";
+      case 401:
+        return "Unauthorized - Verify API key, authentication credentials, or token expiration.";
+      case 403:
+        return "Forbidden - Check API permissions, usage limits, or resource access rights.";
+      case 404:
+        return "Not Found - Verify the endpoint URL, API version, and resource identifiers.";
+      case 408:
+        return "Request Timeout - Consider increasing timeout duration or implementing retry logic.";
+      case 422:
+        return "Unprocessable Entity - Check request data validation, required fields, and data formats.";
+      case 429:
+        return "Rate Limited - Implement exponential backoff or reduce request frequency.";
+      default:
+        return "Client error - Review request format, parameters, and API documentation.";
+    }
+  } else if (statusCode >= 500) {
+    return "Server error - This is likely temporary. Implement retry logic with exponential backoff.";
+  } else {
+    return "Check API documentation for this status code.";
+  }
+};
+// packages/ariadne/src/AgentRunner.ts
+var exports_AgentRunner = {};
+__export(exports_AgentRunner, {
+  defaultConfig: () => defaultConfig,
+  ReAct: () => ReAct,
+  Config: () => Config
+});
+import * as Context6 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import * as Ref from "effect/Ref";
+import * as Stream2 from "effect/Stream";
+
+// packages/ariadne/src/LanguageModel.ts
+var exports_LanguageModel = {};
+__export(exports_LanguageModel, {
+  streamText: () => streamText,
+  streamObject: () => streamObject,
+  make: () => make6,
+  generateText: () => generateText,
+  generateObject: () => generateObject,
+  LanguageModel: () => LanguageModel,
+  GenerateTextResponse: () => GenerateTextResponse,
+  GenerateObjectResponse: () => GenerateObjectResponse
+});
+import * as Chunk from "effect/Chunk";
+import * as Context5 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Mailbox from "effect/Mailbox";
+import * as Option3 from "effect/Option";
+import * as ParseResult4 from "effect/ParseResult";
+import * as Predicate8 from "effect/Predicate";
+import * as Schema6 from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+// packages/ariadne/src/IdGenerator.ts
+var exports_IdGenerator = {};
+__export(exports_IdGenerator, {
+  make: () => make,
+  layer: () => layer,
+  defaultIdGenerator: () => defaultIdGenerator,
+  IdGenerator: () => IdGenerator
+});
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate2 from "effect/Predicate";
+import * as Random from "effect/Random";
+
+class IdGenerator extends Context.Tag("@effect/ai/IdGenerator")() {
+}
+var DEFAULT_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var DEFAULT_SEPARATOR = "_";
+var DEFAULT_SIZE = 16;
+var makeGenerator = ({
+  alphabet = DEFAULT_ALPHABET,
+  prefix,
+  separator = DEFAULT_SEPARATOR,
+  size = DEFAULT_SIZE
+}) => {
+  const alphabetLength = alphabet.length;
+  return Effect2.fnUntraced(function* () {
+    const chars = new Array(size);
+    for (let i = 0;i < size; i++) {
+      chars[i] = alphabet[(yield* Random.next) * alphabetLength | 0];
+    }
+    const identifier = chars.join("");
+    if (Predicate2.isUndefined(prefix)) {
+      return identifier;
+    }
+    return `${prefix}${separator}${identifier}`;
+  });
+};
+var defaultIdGenerator = {
+  generateId: makeGenerator({ prefix: "id" })
+};
+var make = Effect2.fnUntraced(function* ({
+  alphabet = DEFAULT_ALPHABET,
+  prefix,
+  separator = DEFAULT_SEPARATOR,
+  size = DEFAULT_SIZE
+}) {
+  if (alphabet.includes(separator)) {
+    const message = `The separator "${separator}" must not be part of the alphabet "${alphabet}".`;
+    return yield* new Cause.IllegalArgumentException(message);
+  }
+  const generateId = makeGenerator({ alphabet, prefix, separator, size });
+  return {
+    generateId
+  };
+});
+var layer = (options) => Layer.effect(IdGenerator, make(options));
+
+// packages/ariadne/src/Prompt.ts
+var exports_Prompt = {};
+__export(exports_Prompt, {
+  userMessage: () => userMessage,
+  toolResultPart: () => toolResultPart,
+  toolMessage: () => toolMessage,
+  toolCallPart: () => toolCallPart,
+  textPart: () => textPart,
+  systemMessage: () => systemMessage,
+  setSystem: () => setSystem,
+  reasoningPart: () => reasoningPart,
+  prependSystem: () => prependSystem,
+  merge: () => merge2,
+  makePart: () => makePart,
+  makeMessage: () => makeMessage,
+  make: () => make2,
+  isPrompt: () => isPrompt,
+  isPart: () => isPart,
+  isMessage: () => isMessage,
+  fromResponseParts: () => fromResponseParts,
+  fromMessages: () => fromMessages,
+  filePart: () => filePart,
+  empty: () => empty,
+  assistantMessage: () => assistantMessage,
+  appendSystem: () => appendSystem,
+  UserMessage: () => UserMessage,
+  TypeId: () => TypeId2,
+  ToolResultPart: () => ToolResultPart,
+  ToolMessage: () => ToolMessage,
+  ToolCallPart: () => ToolCallPart,
+  TextPart: () => TextPart,
+  SystemMessage: () => SystemMessage,
+  ReasoningPart: () => ReasoningPart,
+  ProviderOptions: () => ProviderOptions,
+  PromptFromSelf: () => PromptFromSelf,
+  Prompt: () => Prompt,
+  PartTypeId: () => PartTypeId,
+  MessageTypeId: () => MessageTypeId,
+  MessageContentFromString: () => MessageContentFromString,
+  Message: () => Message,
+  FromJson: () => FromJson,
+  FilePart: () => FilePart,
+  AssistantMessage: () => AssistantMessage
+});
+import * as Arbitrary from "effect/Arbitrary";
+import * as Arr from "effect/Array";
+import { constFalse, dual } from "effect/Function";
+import * as ParseResult from "effect/ParseResult";
+import { pipeArguments } from "effect/Pipeable";
+import * as Predicate3 from "effect/Predicate";
+import * as Schema2 from "effect/Schema";
+var constEmptyObject = () => ({});
+var ProviderOptions = Schema2.Record({
+  key: Schema2.String,
+  value: Schema2.UndefinedOr(Schema2.Record({
+    key: Schema2.String,
+    value: Schema2.Unknown
+  }))
+});
+var PartTypeId = "~effect/ai/Prompt/Part";
+var isPart = (u) => Predicate3.hasProperty(u, PartTypeId);
+var makePart = (type, params) => ({
+  ...params,
+  [PartTypeId]: PartTypeId,
+  type,
+  options: params.options ?? {}
+});
+var TextPart = Schema2.Struct({
+  type: Schema2.Literal("text"),
+  text: Schema2.String,
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(PartTypeId, PartTypeId), Schema2.annotations({ identifier: "TextPart" }));
+var textPart = (params) => makePart("text", params);
+var ReasoningPart = Schema2.Struct({
+  type: Schema2.Literal("reasoning"),
+  text: Schema2.String,
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(PartTypeId, PartTypeId), Schema2.annotations({ identifier: "ReasoningPart" }));
+var reasoningPart = (params) => makePart("reasoning", params);
+var FilePart = Schema2.Struct({
+  type: Schema2.Literal("file"),
+  mediaType: Schema2.String,
+  fileName: Schema2.optional(Schema2.String),
+  data: Schema2.Union(Schema2.String, Schema2.Uint8ArrayFromSelf, Schema2.URLFromSelf),
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(PartTypeId, PartTypeId), Schema2.annotations({ identifier: "FilePart" }));
+var filePart = (params) => makePart("file", params);
+var ToolCallPart = Schema2.Struct({
+  type: Schema2.Literal("tool-call"),
+  id: Schema2.String,
+  name: Schema2.String,
+  params: Schema2.Unknown,
+  providerExecuted: Schema2.optionalWith(Schema2.Boolean, {
+    default: constFalse
+  }),
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(PartTypeId, PartTypeId), Schema2.annotations({ identifier: "ToolCallPart" }));
+var toolCallPart = (params) => makePart("tool-call", params);
+var ToolResultPart = Schema2.Struct({
+  type: Schema2.Literal("tool-result"),
+  id: Schema2.String,
+  name: Schema2.String,
+  isFailure: Schema2.Boolean,
+  result: Schema2.Unknown,
+  providerExecuted: Schema2.Boolean,
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(PartTypeId, PartTypeId), Schema2.annotations({ identifier: "ToolResultPart" }));
+var toolResultPart = (params) => makePart("tool-result", params);
+var MessageTypeId = "~effect/ai/Prompt/Message";
+var isMessage = (u) => Predicate3.hasProperty(u, MessageTypeId);
+var makeMessage = (role, params) => ({
+  ...params,
+  [MessageTypeId]: MessageTypeId,
+  role,
+  options: params.options ?? {}
+});
+var MessageContentFromString = Schema2.transform(Schema2.String, Schema2.NonEmptyArray(Schema2.typeSchema(TextPart)), {
+  strict: true,
+  decode: (text) => Arr.of(makePart("text", { text })),
+  encode: (content) => content[0].text
+});
+var SystemMessage = Schema2.Struct({
+  role: Schema2.Literal("system"),
+  content: Schema2.String,
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(MessageTypeId, MessageTypeId), Schema2.annotations({ identifier: "SystemMessage" }));
+var systemMessage = (params) => makeMessage("system", params);
+var UserMessage = Schema2.Struct({
+  role: Schema2.Literal("user"),
+  content: Schema2.Union(MessageContentFromString, Schema2.Array(Schema2.Union(TextPart, FilePart))),
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(MessageTypeId, MessageTypeId), Schema2.annotations({ identifier: "UserMessage" }));
+var userMessage = (params) => makeMessage("user", params);
+var AssistantMessage = Schema2.Struct({
+  role: Schema2.Literal("assistant"),
+  content: Schema2.Union(MessageContentFromString, Schema2.Array(Schema2.Union(TextPart, FilePart, ReasoningPart, ToolCallPart, ToolResultPart))),
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(MessageTypeId, MessageTypeId), Schema2.annotations({ identifier: "AssistantMessage" }));
+var assistantMessage = (params) => makeMessage("assistant", params);
+var ToolMessage = Schema2.Struct({
+  role: Schema2.Literal("tool"),
+  content: Schema2.Array(ToolResultPart),
+  options: Schema2.optionalWith(ProviderOptions, {
+    default: constEmptyObject
+  })
+}).pipe(Schema2.attachPropertySignature(MessageTypeId, MessageTypeId), Schema2.annotations({ identifier: "ToolMessage" }));
+var toolMessage = (params) => makeMessage("tool", params);
+var Message = Schema2.Union(SystemMessage, UserMessage, AssistantMessage, ToolMessage);
+var TypeId2 = "~@effect/ai/Prompt";
+var isPrompt = (u) => Predicate3.hasProperty(u, TypeId2);
+
+class PromptFromSelf extends Schema2.declare((u) => isPrompt(u), {
+  typeConstructor: { _tag: "effect/ai/Prompt" },
+  identifier: "PromptFromSelf",
+  description: "a Prompt instance",
+  arbitrary: () => (fc) => fc.array(Arbitrary.makeLazy(Message)(fc)).map(makePrompt)
+}) {
+}
+var Prompt = Schema2.transformOrFail(Schema2.Struct({ content: Schema2.Array(Schema2.encodedSchema(Message)) }), PromptFromSelf, {
+  strict: true,
+  decode: (i, _, ast) => decodePrompt(i, ast),
+  encode: (a, _, ast) => encodePrompt(a, ast)
+}).annotations({ identifier: "Prompt" });
+var decodeMessages = ParseResult.decodeEither(Schema2.Array(Message));
+var encodeMessages = ParseResult.encodeEither(Schema2.Array(Message));
+var decodePrompt = (input, ast) => ParseResult.mapBoth(decodeMessages(input.content), {
+  onFailure: () => new ParseResult.Type(ast, input, `Unable to decode ${JSON.stringify(input)} into a Prompt`),
+  onSuccess: makePrompt
+});
+var encodePrompt = (input, ast) => ParseResult.mapBoth(encodeMessages(input.content), {
+  onFailure: () => new ParseResult.Type(ast, input, `Failed to encode Prompt`),
+  onSuccess: (messages) => ({ content: messages })
+});
+var FromJson = Schema2.parseJson(Prompt);
+var Proto = {
+  [TypeId2]: TypeId2,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var makePrompt = (content) => Object.assign(Object.create(Proto), {
+  content
+});
+var decodeMessagesSync = Schema2.decodeSync(Schema2.Array(Message));
+var empty = makePrompt([]);
+var make2 = (input) => {
+  if (Predicate3.isString(input)) {
+    const part = makePart("text", { text: input });
+    const message = makeMessage("user", { content: [part] });
+    return makePrompt([message]);
+  }
+  if (Predicate3.isIterable(input)) {
+    return makePrompt(decodeMessagesSync(Arr.fromIterable(input), {
+      errors: "all"
+    }));
+  }
+  return input;
+};
+var fromMessages = (messages) => makePrompt(messages);
+var fromResponseParts = (parts) => {
+  if (parts.length === 0) {
+    return empty;
+  }
+  const assistantParts = [];
+  const toolParts = [];
+  const activeTextDeltas = new Map;
+  const activeReasoningDeltas = new Map;
+  for (const part of parts) {
+    switch (part.type) {
+      case "text": {
+        assistantParts.push(makePart("text", { text: part.text }));
+        break;
+      }
+      case "text-start": {
+        activeTextDeltas.set(part.id, { text: "" });
+        break;
+      }
+      case "text-delta": {
+        if (activeTextDeltas.has(part.id)) {
+          activeTextDeltas.get(part.id).text += part.delta;
+        }
+        break;
+      }
+      case "text-end": {
+        if (activeTextDeltas.has(part.id)) {
+          assistantParts.push(makePart("text", activeTextDeltas.get(part.id)));
+        }
+        break;
+      }
+      case "reasoning": {
+        assistantParts.push(makePart("reasoning", { text: part.text }));
+        break;
+      }
+      case "reasoning-start": {
+        activeReasoningDeltas.set(part.id, { text: "" });
+        break;
+      }
+      case "reasoning-delta": {
+        if (activeReasoningDeltas.has(part.id)) {
+          activeReasoningDeltas.get(part.id).text += part.delta;
+        }
+        break;
+      }
+      case "reasoning-end": {
+        if (activeReasoningDeltas.has(part.id)) {
+          assistantParts.push(makePart("reasoning", activeReasoningDeltas.get(part.id)));
+        }
+        break;
+      }
+      case "tool-call": {
+        assistantParts.push(makePart("tool-call", {
+          id: part.id,
+          name: part.providerName ?? part.name,
+          params: part.params,
+          providerExecuted: part.providerExecuted ?? false
+        }));
+        break;
+      }
+      case "tool-result": {
+        const toolPart = makePart("tool-result", {
+          id: part.id,
+          name: part.providerName ?? part.name,
+          isFailure: part.isFailure,
+          result: part.encodedResult,
+          providerExecuted: part.providerExecuted ?? false
+        });
+        if (part.providerExecuted) {
+          assistantParts.push(toolPart);
+        } else {
+          toolParts.push(toolPart);
+        }
+      }
+    }
+  }
+  if (assistantParts.length === 0 && toolParts.length === 0) {
+    return empty;
+  }
+  const messages = [];
+  if (assistantParts.length > 0) {
+    messages.push(makeMessage("assistant", { content: assistantParts }));
+  }
+  if (toolParts.length > 0) {
+    messages.push(makeMessage("tool", { content: toolParts }));
+  }
+  return makePrompt(messages);
+};
+var merge2 = dual(2, (self, input) => {
+  const other = make2(input);
+  if (self.content.length === 0) {
+    return other;
+  }
+  if (other.content.length === 0) {
+    return self;
+  }
+  return fromMessages([...self.content, ...other.content]);
+});
+var setSystem = dual(2, (self, content) => {
+  const messages = [makeMessage("system", { content })];
+  for (const message of self.content) {
+    if (message.role !== "system") {
+      messages.push(message);
+    }
+  }
+  return makePrompt(messages);
+});
+var prependSystem = dual(2, (self, content) => {
+  let system = undefined;
+  for (const message of self.content) {
+    if (message.role === "system") {
+      system = makeMessage("system", {
+        content: content + message.content
+      });
+      break;
+    }
+  }
+  if (Predicate3.isUndefined(system)) {
+    system = makeMessage("system", { content });
+  }
+  return makePrompt([system, ...self.content]);
+});
+var appendSystem = dual(2, (self, content) => {
+  let system = undefined;
+  for (const message of self.content) {
+    if (message.role === "system") {
+      system = makeMessage("system", {
+        content: message.content + content
+      });
+      break;
+    }
+  }
+  if (Predicate3.isUndefined(system)) {
+    system = makeMessage("system", { content });
+  }
+  return makePrompt([system, ...self.content]);
+});
+
+// packages/ariadne/src/Response.ts
+var exports_Response = {};
+__export(exports_Response, {
+  urlSourcePart: () => urlSourcePart,
+  toolResultPart: () => toolResultPart2,
+  toolParamsStartPart: () => toolParamsStartPart,
+  toolParamsEndPart: () => toolParamsEndPart,
+  toolParamsDeltaPart: () => toolParamsDeltaPart,
+  toolCallPart: () => toolCallPart2,
+  textStartPart: () => textStartPart,
+  textPart: () => textPart2,
+  textEndPart: () => textEndPart,
+  textDeltaPart: () => textDeltaPart,
+  responseMetadataPart: () => responseMetadataPart,
+  reasoningStartPart: () => reasoningStartPart,
+  reasoningPart: () => reasoningPart2,
+  reasoningEndPart: () => reasoningEndPart,
+  reasoningDeltaPart: () => reasoningDeltaPart,
+  objectDonePart: () => objectDonePart,
+  objectDeltaPart: () => objectDeltaPart,
+  makePart: () => makePart2,
+  isPart: () => isPart2,
+  finishPart: () => finishPart,
+  filePart: () => filePart2,
+  errorPart: () => errorPart,
+  documentSourcePart: () => documentSourcePart,
+  Usage: () => Usage,
+  UrlSourcePart: () => UrlSourcePart,
+  ToolResultPart: () => ToolResultPart2,
+  ToolParamsStartPart: () => ToolParamsStartPart,
+  ToolParamsEndPart: () => ToolParamsEndPart,
+  ToolParamsDeltaPart: () => ToolParamsDeltaPart,
+  ToolCallPart: () => ToolCallPart2,
+  TextStartPart: () => TextStartPart,
+  TextPart: () => TextPart2,
+  TextEndPart: () => TextEndPart,
+  TextDeltaPart: () => TextDeltaPart,
+  StreamPart: () => StreamPart,
+  ResponseMetadataPart: () => ResponseMetadataPart,
+  ReasoningStartPart: () => ReasoningStartPart,
+  ReasoningPart: () => ReasoningPart2,
+  ReasoningEndPart: () => ReasoningEndPart,
+  ReasoningDeltaPart: () => ReasoningDeltaPart,
+  ProviderMetadata: () => ProviderMetadata,
+  PartTypeId: () => PartTypeId2,
+  Part: () => Part,
+  ObjectDonePart: () => ObjectDonePart,
+  ObjectDeltaPart: () => ObjectDeltaPart,
+  FinishReason: () => FinishReason,
+  FinishPart: () => FinishPart,
+  FilePart: () => FilePart2,
+  ErrorPart: () => ErrorPart,
+  DocumentSourcePart: () => DocumentSourcePart,
+  AllParts: () => AllParts
+});
+import * as Effect3 from "effect/Effect";
+import { constFalse as constFalse2 } from "effect/Function";
+import * as ParseResult2 from "effect/ParseResult";
+import * as Predicate4 from "effect/Predicate";
+import * as Schema3 from "effect/Schema";
+var constEmptyObject2 = () => ({});
+var PartTypeId2 = "~effect/ai/Content/Part";
+var isPart2 = (u) => Predicate4.hasProperty(u, PartTypeId2);
+var AllParts = (toolkit) => {
+  const toolCalls = [];
+  const toolCallResults = [];
+  for (const tool of Object.values(toolkit.tools)) {
+    toolCalls.push(ToolCallPart2(tool.name, tool.parametersSchema));
+    toolCallResults.push(ToolResultPart2(tool.name, tool.successSchema, tool.failureSchema));
+  }
+  return Schema3.Union(TextPart2, TextStartPart, TextDeltaPart, TextEndPart, ReasoningPart2, ReasoningStartPart, ReasoningDeltaPart, ReasoningEndPart, ToolParamsStartPart, ToolParamsDeltaPart, ToolParamsEndPart, FilePart2, DocumentSourcePart, UrlSourcePart, ResponseMetadataPart, FinishPart, ErrorPart, ...toolCalls, ...toolCallResults);
+};
+var Part = (toolkit) => {
+  const toolCalls = [];
+  const toolCallResults = [];
+  for (const tool of Object.values(toolkit.tools)) {
+    toolCalls.push(ToolCallPart2(tool.name, tool.parametersSchema));
+    toolCallResults.push(ToolResultPart2(tool.name, tool.successSchema, tool.failureSchema));
+  }
+  return Schema3.Union(TextPart2, ReasoningPart2, FilePart2, DocumentSourcePart, UrlSourcePart, ResponseMetadataPart, FinishPart, ...toolCalls, ...toolCallResults);
+};
+var StreamPart = (toolkit) => {
+  const toolCalls = [];
+  const toolCallResults = [];
+  for (const tool of Object.values(toolkit.tools)) {
+    toolCalls.push(ToolCallPart2(tool.name, tool.parametersSchema));
+    toolCallResults.push(ToolResultPart2(tool.name, tool.successSchema, tool.failureSchema));
+  }
+  return Schema3.Union(TextStartPart, TextDeltaPart, TextEndPart, ReasoningStartPart, ReasoningDeltaPart, ReasoningEndPart, ToolParamsStartPart, ToolParamsDeltaPart, ToolParamsEndPart, FilePart2, DocumentSourcePart, UrlSourcePart, ResponseMetadataPart, FinishPart, ErrorPart, ...toolCalls, ...toolCallResults);
+};
+var ProviderMetadata = Schema3.Record({
+  key: Schema3.String,
+  value: Schema3.UndefinedOr(Schema3.Record({
+    key: Schema3.String,
+    value: Schema3.Unknown
+  }))
+});
+var makePart2 = (type, params) => ({
+  ...params,
+  [PartTypeId2]: PartTypeId2,
+  type,
+  metadata: params.metadata ?? {}
+});
+var TextPart2 = Schema3.Struct({
+  type: Schema3.Literal("text"),
+  text: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "TextPart" }));
+var textPart2 = (params) => makePart2("text", params);
+var TextStartPart = Schema3.Struct({
+  type: Schema3.Literal("text-start"),
+  id: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "TextStartPart" }));
+var textStartPart = (params) => makePart2("text-start", params);
+var TextDeltaPart = Schema3.Struct({
+  type: Schema3.Literal("text-delta"),
+  id: Schema3.String,
+  delta: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "TextDeltaPart" }));
+var textDeltaPart = (params) => makePart2("text-delta", params);
+var TextEndPart = Schema3.Struct({
+  type: Schema3.Literal("text-end"),
+  id: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "TextEndPart" }));
+var textEndPart = (params) => makePart2("text-end", params);
+var ReasoningPart2 = Schema3.Struct({
+  type: Schema3.Literal("reasoning"),
+  text: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ReasoningPart" }));
+var reasoningPart2 = (params) => makePart2("reasoning", params);
+var ReasoningStartPart = Schema3.Struct({
+  type: Schema3.Literal("reasoning-start"),
+  id: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ReasoningStartPart" }));
+var reasoningStartPart = (params) => makePart2("reasoning-start", params);
+var ReasoningDeltaPart = Schema3.Struct({
+  type: Schema3.Literal("reasoning-delta"),
+  id: Schema3.String,
+  delta: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ReasoningDeltaPart" }));
+var reasoningDeltaPart = (params) => makePart2("reasoning-delta", params);
+var ReasoningEndPart = Schema3.Struct({
+  type: Schema3.Literal("reasoning-end"),
+  id: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ReasoningEndPart" }));
+var reasoningEndPart = (params) => makePart2("reasoning-end", params);
+var ToolParamsStartPart = Schema3.Struct({
+  type: Schema3.Literal("tool-params-start"),
+  id: Schema3.String,
+  name: Schema3.String,
+  providerName: Schema3.optional(Schema3.String),
+  providerExecuted: Schema3.optionalWith(Schema3.Boolean, {
+    default: constFalse2
+  }),
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ToolParamsStartPart" }));
+var toolParamsStartPart = (params) => makePart2("tool-params-start", params);
+var ToolParamsDeltaPart = Schema3.Struct({
+  type: Schema3.Literal("tool-params-delta"),
+  id: Schema3.String,
+  delta: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ToolParamsDeltaPart" }));
+var toolParamsDeltaPart = (params) => makePart2("tool-params-delta", params);
+var ToolParamsEndPart = Schema3.Struct({
+  type: Schema3.Literal("tool-params-end"),
+  id: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ToolParamsEndPart" }));
+var toolParamsEndPart = (params) => makePart2("tool-params-end", params);
+var ToolCallPart2 = (name, params) => Schema3.Struct({
+  type: Schema3.Literal("tool-call"),
+  id: Schema3.String,
+  name: Schema3.Literal(name),
+  params,
+  providerName: Schema3.optional(Schema3.String),
+  providerExecuted: Schema3.optionalWith(Schema3.Boolean, {
+    default: constFalse2
+  }),
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ToolCallPart" }));
+var toolCallPart2 = (params) => makePart2("tool-call", params);
+var ToolResultPart2 = (name, success, failure) => {
+  const Base = Schema3.Struct({
+    id: Schema3.String,
+    type: Schema3.Literal("tool-result"),
+    providerName: Schema3.optional(Schema3.String),
+    isFailure: Schema3.Boolean
+  });
+  const ResultSchema = Schema3.Union(success, failure);
+  const Encoded = Schema3.Struct({
+    ...Base.fields,
+    name: Schema3.String,
+    result: Schema3.encodedSchema(ResultSchema),
+    providerExecuted: Schema3.optional(Schema3.Boolean),
+    metadata: Schema3.optional(ProviderMetadata)
+  });
+  const Decoded = Schema3.Struct({
+    ...Base.fields,
+    [PartTypeId2]: Schema3.Literal(PartTypeId2),
+    name: Schema3.Literal(name),
+    result: Schema3.typeSchema(ResultSchema),
+    encodedResult: Schema3.encodedSchema(ResultSchema),
+    providerExecuted: Schema3.Boolean,
+    metadata: ProviderMetadata
+  });
+  const decodeResult = ParseResult2.decode(ResultSchema);
+  const encodeResult = ParseResult2.encode(ResultSchema);
+  return Schema3.transformOrFail(Encoded, Decoded, {
+    strict: true,
+    decode: Effect3.fnUntraced(function* (encoded) {
+      const decoded = yield* decodeResult(encoded.result);
+      const providerExecuted = encoded.providerExecuted ?? false;
+      return {
+        ...encoded,
+        [PartTypeId2]: PartTypeId2,
+        name: encoded.name,
+        result: decoded,
+        encodedResult: encoded.result,
+        metadata: encoded.metadata ?? {},
+        providerExecuted
+      };
+    }),
+    encode: Effect3.fnUntraced(function* (decoded) {
+      const encoded = yield* encodeResult(decoded.result);
+      return {
+        ...decoded,
+        result: encoded,
+        ...decoded.metadata ?? {},
+        ...decoded.providerName ? { providerName: decoded.providerName } : {},
+        ...decoded.providerExecuted ? { providerExecuted: true } : {}
+      };
+    })
+  }).annotations({ identifier: `ToolResultPart(${name})` });
+};
+var toolResultPart2 = (params) => makePart2("tool-result", params);
+var FilePart2 = Schema3.Struct({
+  type: Schema3.Literal("file"),
+  mediaType: Schema3.String,
+  data: Schema3.Uint8ArrayFromBase64,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "FilePart" }));
+var filePart2 = (params) => makePart2("file", params);
+var DocumentSourcePart = Schema3.Struct({
+  type: Schema3.Literal("source"),
+  sourceType: Schema3.Literal("document"),
+  id: Schema3.String,
+  mediaType: Schema3.String,
+  title: Schema3.String,
+  fileName: Schema3.optional(Schema3.String),
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "DocumentSourcePart" }));
+var documentSourcePart = (params) => makePart2("source", { ...params, sourceType: "document" });
+var UrlSourcePart = Schema3.Struct({
+  type: Schema3.Literal("source"),
+  sourceType: Schema3.Literal("url"),
+  id: Schema3.String,
+  url: Schema3.URL,
+  title: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "UrlSourcePart" }));
+var urlSourcePart = (params) => makePart2("source", { ...params, sourceType: "url" });
+var ResponseMetadataPart = Schema3.Struct({
+  type: Schema3.Literal("response-metadata"),
+  id: Schema3.optionalWith(Schema3.String, { as: "Option" }),
+  modelId: Schema3.optionalWith(Schema3.String, { as: "Option" }),
+  timestamp: Schema3.optionalWith(Schema3.DateTimeUtc, { as: "Option" }),
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ResponseMetadataPart" }));
+var responseMetadataPart = (params) => makePart2("response-metadata", params);
+var FinishReason = Schema3.Literal("stop", "length", "content-filter", "tool-calls", "error", "pause", "other", "unknown");
+
+class Usage extends Schema3.Class("@effect/ai/AiResponse/Usage")({
+  inputTokens: Schema3.UndefinedOr(Schema3.Number),
+  outputTokens: Schema3.UndefinedOr(Schema3.Number),
+  totalTokens: Schema3.UndefinedOr(Schema3.Number),
+  reasoningTokens: Schema3.optional(Schema3.Number),
+  cachedInputTokens: Schema3.optional(Schema3.Number)
+}) {
+}
+var FinishPart = Schema3.Struct({
+  type: Schema3.Literal("finish"),
+  reason: FinishReason,
+  usage: Usage,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "FinishPart" }));
+var finishPart = (params) => makePart2("finish", params);
+var ErrorPart = Schema3.Struct({
+  type: Schema3.Literal("error"),
+  error: Schema3.Unknown,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ErrorPart" }));
+var errorPart = (params) => makePart2("error", params);
+var ObjectDeltaPart = Schema3.Struct({
+  type: Schema3.Literal("object-delta"),
+  id: Schema3.String,
+  delta: Schema3.String,
+  accumulated: Schema3.String,
+  partial: Schema3.Unknown,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ObjectDeltaPart" }));
+var objectDeltaPart = (params) => makePart2("object-delta", params);
+var ObjectDonePart = Schema3.Struct({
+  type: Schema3.Literal("object-done"),
+  id: Schema3.String,
+  value: Schema3.Unknown,
+  raw: Schema3.String,
+  metadata: Schema3.optionalWith(ProviderMetadata, {
+    default: constEmptyObject2
+  })
+}).pipe(Schema3.attachPropertySignature(PartTypeId2, PartTypeId2), Schema3.annotations({ identifier: "ObjectDonePart" }));
+var objectDonePart = (params) => makePart2("object-done", params);
+
+// packages/ariadne/src/Telemetry.ts
+var exports_Telemetry = {};
+__export(exports_Telemetry, {
+  addSpanAttributes: () => addSpanAttributes,
+  addGenAIAnnotations: () => addGenAIAnnotations,
+  CurrentSpanTransformer: () => CurrentSpanTransformer
+});
+import * as Context2 from "effect/Context";
+import { dual as dual2 } from "effect/Function";
+import * as Predicate5 from "effect/Predicate";
+import * as String5 from "effect/String";
+var addSpanAttributes = (keyPrefix, transformKey) => (span, attributes) => {
+  for (const [key, value] of Object.entries(attributes)) {
+    if (Predicate5.isNotNullable(value)) {
+      span.attribute(`${keyPrefix}.${transformKey(key)}`, value);
+    }
+  }
+};
+var addSpanBaseAttributes = addSpanAttributes("gen_ai", String5.camelToSnake);
+var addSpanOperationAttributes = addSpanAttributes("gen_ai.operation", String5.camelToSnake);
+var addSpanRequestAttributes = addSpanAttributes("gen_ai.request", String5.camelToSnake);
+var addSpanResponseAttributes = addSpanAttributes("gen_ai.response", String5.camelToSnake);
+var addSpanTokenAttributes = addSpanAttributes("gen_ai.token", String5.camelToSnake);
+var addSpanUsageAttributes = addSpanAttributes("gen_ai.usage", String5.camelToSnake);
+var addGenAIAnnotations = dual2(2, (span, options) => {
+  addSpanBaseAttributes(span, { system: options.system });
+  if (Predicate5.isNotNullable(options.operation))
+    addSpanOperationAttributes(span, options.operation);
+  if (Predicate5.isNotNullable(options.request))
+    addSpanRequestAttributes(span, options.request);
+  if (Predicate5.isNotNullable(options.response))
+    addSpanResponseAttributes(span, options.response);
+  if (Predicate5.isNotNullable(options.token))
+    addSpanTokenAttributes(span, options.token);
+  if (Predicate5.isNotNullable(options.usage))
+    addSpanUsageAttributes(span, options.usage);
+});
+
+class CurrentSpanTransformer extends Context2.Tag("@effect/ai/Telemetry/CurrentSpanTransformer")() {
+}
+
+// packages/ariadne/src/Toolkit.ts
+var exports_Toolkit = {};
+__export(exports_Toolkit, {
+  merge: () => merge5,
+  make: () => make4,
+  empty: () => empty3,
+  TypeId: () => TypeId4
+});
+import * as Context4 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import { CommitPrototype } from "effect/Effectable";
+import { identity as identity2 } from "effect/Function";
+import { BaseProto as InspectableProto } from "effect/Inspectable";
+import * as Layer2 from "effect/Layer";
+import * as ParseResult3 from "effect/ParseResult";
+import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
+import * as Predicate7 from "effect/Predicate";
+import * as Schema5 from "effect/Schema";
+
+// packages/ariadne/src/Tool.ts
+var exports_Tool = {};
+__export(exports_Tool, {
+  unsafeSecureJsonParse: () => unsafeSecureJsonParse,
+  providerDefined: () => providerDefined,
+  make: () => make3,
+  isUserDefined: () => isUserDefined,
+  isProviderDefined: () => isProviderDefined,
+  getJsonSchemaFromSchemaAst: () => getJsonSchemaFromSchemaAst,
+  getJsonSchema: () => getJsonSchema,
+  getDescriptionFromSchemaAst: () => getDescriptionFromSchemaAst,
+  getDescription: () => getDescription,
+  fromTaggedRequest: () => fromTaggedRequest,
+  TypeId: () => TypeId3,
+  Title: () => Title,
+  Readonly: () => Readonly,
+  ProviderDefinedTypeId: () => ProviderDefinedTypeId,
+  OpenWorld: () => OpenWorld,
+  Idempotent: () => Idempotent,
+  Destructive: () => Destructive
+});
+import * as Context3 from "effect/Context";
+import { constFalse as constFalse3, constTrue, identity } from "effect/Function";
+import * as JsonSchema from "effect/JSONSchema";
+import * as Option2 from "effect/Option";
+import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
+import * as Predicate6 from "effect/Predicate";
+import * as Schema4 from "effect/Schema";
+import * as AST from "effect/SchemaAST";
+var TypeId3 = "~@effect/ai/Tool";
+var ProviderDefinedTypeId = "~@effect/ai/Tool/ProviderDefined";
+var isUserDefined = (u) => Predicate6.hasProperty(u, TypeId3) && !isProviderDefined(u);
+var isProviderDefined = (u) => Predicate6.hasProperty(u, ProviderDefinedTypeId);
+var Proto2 = {
+  [TypeId3]: { _Requirements: identity },
+  pipe() {
+    return pipeArguments2(this, arguments);
+  },
+  addDependency() {
+    return userDefinedProto({ ...this });
+  },
+  setParameters(parametersSchema) {
+    return userDefinedProto({
+      ...this,
+      parametersSchema: Schema4.isSchema(parametersSchema) ? parametersSchema : Schema4.Struct(parametersSchema)
+    });
+  },
+  setSuccess(successSchema) {
+    return userDefinedProto({
+      ...this,
+      successSchema
+    });
+  },
+  setFailure(failureSchema) {
+    return userDefinedProto({
+      ...this,
+      failureSchema
+    });
+  },
+  annotate(tag, value) {
+    return userDefinedProto({
+      ...this,
+      annotations: Context3.add(this.annotations, tag, value)
+    });
+  },
+  annotateContext(context) {
+    return userDefinedProto({
+      ...this,
+      annotations: Context3.merge(this.annotations, context)
+    });
+  }
+};
+var ProviderDefinedProto = {
+  ...Proto2,
+  [ProviderDefinedTypeId]: ProviderDefinedTypeId
+};
+var userDefinedProto = (options) => {
+  const self = Object.assign(Object.create(Proto2), options);
+  self.id = `@effect/ai/Tool/${options.name}`;
+  return self;
+};
+var providerDefinedProto = (options) => Object.assign(Object.create(ProviderDefinedProto), options);
+var constEmptyStruct = Schema4.Struct({});
+var make3 = (name, options) => {
+  const successSchema = options?.success ?? Schema4.Void;
+  const failureSchema = options?.failure ?? Schema4.Never;
+  return userDefinedProto({
+    name,
+    description: options?.description,
+    parametersSchema: options?.parameters ? Schema4.Struct(options?.parameters) : constEmptyStruct,
+    successSchema,
+    failureSchema,
+    failureMode: options?.failureMode ?? "error",
+    annotations: Context3.empty()
+  });
+};
+var providerDefined = (options) => (args) => {
+  const failureMode = "failureMode" in args ? args.failureMode : undefined;
+  const successSchema = options?.success ?? Schema4.Void;
+  const failureSchema = options?.failure ?? Schema4.Never;
+  return providerDefinedProto({
+    id: options.id,
+    name: options.toolkitName,
+    providerName: options.providerName,
+    args,
+    argsSchema: Schema4.Struct(options.args),
+    requiresHandler: options.requiresHandler ?? false,
+    parametersSchema: options?.parameters ? Schema4.Struct(options?.parameters) : constEmptyStruct,
+    successSchema,
+    failureSchema,
+    failureMode: failureMode ?? "error"
+  });
+};
+var fromTaggedRequest = (schema) => userDefinedProto({
+  name: schema._tag,
+  description: Option2.getOrUndefined(AST.getDescriptionAnnotation(schema.ast.to)),
+  parametersSchema: schema,
+  successSchema: schema.success,
+  failureSchema: schema.failure,
+  failureMode: "error",
+  annotations: Context3.empty()
+});
+var getDescription = (tool) => {
+  if (Predicate6.isNotUndefined(tool.description)) {
+    return tool.description;
+  }
+  return getDescriptionFromSchemaAst(tool.parametersSchema.ast);
+};
+var getDescriptionFromSchemaAst = (ast) => {
+  const annotations3 = ast._tag === "Transformation" ? {
+    ...ast.to.annotations,
+    ...ast.annotations
+  } : ast.annotations;
+  return AST.DescriptionAnnotationId in annotations3 ? annotations3[AST.DescriptionAnnotationId] : undefined;
+};
+var getJsonSchema = (tool) => getJsonSchemaFromSchemaAst(tool.parametersSchema.ast);
+var getJsonSchemaFromSchemaAst = (ast) => {
+  const props = AST.getPropertySignatures(ast);
+  if (props.length === 0) {
+    return {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  const $defs = {};
+  const schema = JsonSchema.fromAST(ast, {
+    definitions: $defs,
+    topLevelReferenceStrategy: "skip"
+  });
+  if (Object.keys($defs).length === 0)
+    return schema;
+  schema.$defs = $defs;
+  return schema;
+};
+
+class Title extends Context3.Tag("@effect/ai/Tool/Title")() {
+}
+
+class Readonly extends Context3.Reference()("@effect/ai/Tool/Readonly", {
+  defaultValue: constFalse3
+}) {
+}
+
+class Destructive extends Context3.Reference()("@effect/ai/Tool/Destructive", {
+  defaultValue: constTrue
+}) {
+}
+
+class Idempotent extends Context3.Reference()("@effect/ai/Tool/Idempotent", {
+  defaultValue: constFalse3
+}) {
+}
+
+class OpenWorld extends Context3.Reference()("@effect/ai/Tool/OpenWorld", {
+  defaultValue: constTrue
+}) {
+}
+var suspectProtoRx = /"__proto__"\s*:/;
+var suspectConstructorRx = /"constructor"\s*:/;
+function _parse(text) {
+  const obj = JSON.parse(text);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+    return obj;
+  }
+  return filter(obj);
+}
+function filter(obj) {
+  let next2 = [obj];
+  while (next2.length) {
+    const nodes = next2;
+    next2 = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next2.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+var unsafeSecureJsonParse = (text) => {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  try {
+    return _parse(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+};
+
+// packages/ariadne/src/Toolkit.ts
+var TypeId4 = "~@effect/ai/Toolkit";
+var Proto3 = {
+  ...CommitPrototype,
+  ...InspectableProto,
+  of: identity2,
+  toContext(build) {
+    return Effect4.gen(this, function* () {
+      const context2 = yield* Effect4.context();
+      const handlers = Effect4.isEffect(build) ? yield* build : build;
+      const contextMap = new Map;
+      for (const [name, handler] of Object.entries(handlers)) {
+        const tool = this.tools[name];
+        contextMap.set(tool.id, { handler, context: context2 });
+      }
+      return Context4.unsafeMake(contextMap);
+    });
+  },
+  toLayer(build) {
+    return Layer2.scopedContext(this.toContext(build));
+  },
+  commit() {
+    return Effect4.gen(this, function* () {
+      const tools = this.tools;
+      const context2 = yield* Effect4.context();
+      const schemasCache = new WeakMap;
+      const getSchemas = (tool) => {
+        let schemas = schemasCache.get(tool);
+        if (Predicate7.isUndefined(schemas)) {
+          const handler = context2.unsafeMap.get(tool.id);
+          const decodeParameters = Schema5.decodeUnknown(tool.parametersSchema);
+          const resultSchema = Schema5.Union(tool.successSchema, tool.failureSchema);
+          const validateResult = Schema5.validate(resultSchema);
+          const encodeResult = Schema5.encodeUnknown(resultSchema);
+          schemas = {
+            context: handler.context,
+            handler: handler.handler,
+            decodeParameters,
+            validateResult,
+            encodeResult
+          };
+          schemasCache.set(tool, schemas);
+        }
+        return schemas;
+      };
+      const handle = Effect4.fn("Toolkit.handle", {
+        captureStackTrace: false
+      })(function* (name, params) {
+        yield* Effect4.annotateCurrentSpan({
+          tool: name,
+          parameters: params
+        });
+        const tool = tools[name];
+        if (Predicate7.isUndefined(tool)) {
+          const toolNames = Object.keys(tools).join(",");
+          return yield* new MalformedOutput({
+            module: "Toolkit",
+            method: `${name}.handle`,
+            description: `Failed to find tool with name '${name}' in toolkit - available tools: ${toolNames}`
+          });
+        }
+        const schemas = getSchemas(tool);
+        const decodedParams = yield* Effect4.mapError(schemas.decodeParameters(params), (cause) => new MalformedOutput({
+          module: "Toolkit",
+          method: `${name}.handle`,
+          description: `Failed to decode tool call parameters for tool '${name}' from:
+'${JSON.stringify(params, undefined, 2)}'`,
+          cause
+        }));
+        const { isFailure, result } = yield* schemas.handler(decodedParams).pipe(Effect4.map((result2) => ({ result: result2, isFailure: false })), Effect4.catchAll((error) => tool.failureMode === "error" ? Effect4.fail(error) : Effect4.succeed({
+          result: error,
+          isFailure: true
+        })), Effect4.tap(({ result: result2 }) => schemas.validateResult(result2)), Effect4.mapInputContext((input) => Context4.merge(schemas.context, input)), Effect4.mapError((cause) => ParseResult3.isParseError(cause) ? new MalformedInput({
+          module: "Toolkit",
+          method: `${name}.handle`,
+          description: `Failed to validate tool call result for tool '${name}'`,
+          cause
+        }) : cause));
+        const encodedResult = yield* Effect4.mapError(schemas.encodeResult(result), (cause) => new MalformedInput({
+          module: "Toolkit",
+          method: `${name}.handle`,
+          description: `Failed to encode tool call result for tool '${name}'`,
+          cause
+        }));
+        return {
+          isFailure,
+          result,
+          encodedResult
+        };
+      });
+      return {
+        tools,
+        handle
+      };
+    });
+  },
+  toJSON() {
+    return {
+      _id: "@effect/ai/Toolkit",
+      tools: Array.from(Object.values(this.tools)).map((tool) => tool.name)
+    };
+  },
+  pipe() {
+    return pipeArguments3(this, arguments);
+  }
+};
+var makeProto = (tools) => Object.assign(() => {}, Proto3, { tools });
+var resolveInput = (...tools) => {
+  const output = {};
+  for (const tool of tools) {
+    const value = Schema5.isSchema(tool) ? fromTaggedRequest(tool) : tool;
+    output[tool.name] = value;
+  }
+  return output;
+};
+var empty3 = makeProto({});
+var make4 = (...tools) => makeProto(resolveInput(...tools));
+var merge5 = (...toolkits) => {
+  const tools = {};
+  for (const toolkit of toolkits) {
+    for (const [name, tool] of Object.entries(toolkit.tools)) {
+      tools[name] = tool;
+    }
+  }
+  return makeProto(tools);
+};
+
+// packages/ariadne/src/LanguageModel.ts
+class LanguageModel extends Context5.Tag("@effect/ai/LanguageModel")() {
+}
+
+class GenerateTextResponse {
+  content;
+  constructor(content) {
+    this.content = content;
+  }
+  get text() {
+    const text = [];
+    for (const part of this.content) {
+      if (part.type === "text") {
+        text.push(part.text);
+      }
+    }
+    return text.join("");
+  }
+  get reasoning() {
+    return this.content.filter((part) => part.type === "reasoning");
+  }
+  get reasoningText() {
+    const text = [];
+    for (const part of this.content) {
+      if (part.type === "reasoning") {
+        text.push(part.text);
+      }
+    }
+    return text.length === 0 ? undefined : text.join("");
+  }
+  get toolCalls() {
+    return this.content.filter((part) => part.type === "tool-call");
+  }
+  get toolResults() {
+    return this.content.filter((part) => part.type === "tool-result");
+  }
+  get finishReason() {
+    const finishPart2 = this.content.find((part) => part.type === "finish");
+    return Predicate8.isUndefined(finishPart2) ? "unknown" : finishPart2.reason;
+  }
+  get usage() {
+    const finishPart2 = this.content.find((part) => part.type === "finish");
+    if (Predicate8.isUndefined(finishPart2)) {
+      return new Usage({
+        inputTokens: undefined,
+        outputTokens: undefined,
+        totalTokens: undefined,
+        reasoningTokens: undefined,
+        cachedInputTokens: undefined
+      });
+    }
+    return finishPart2.usage;
+  }
+}
+
+class GenerateObjectResponse extends GenerateTextResponse {
+  value;
+  constructor(value, content) {
+    super(content);
+    this.value = value;
+  }
+}
+var make6 = Effect5.fnUntraced(function* (params) {
+  const parentSpanTransformer = yield* Effect5.serviceOption(CurrentSpanTransformer);
+  const getSpanTransformer = Effect5.serviceOption(CurrentSpanTransformer).pipe(Effect5.map(Option3.orElse(() => parentSpanTransformer)));
+  const idGenerator = yield* Effect5.serviceOption(IdGenerator).pipe(Effect5.map(Option3.getOrElse(() => defaultIdGenerator)));
+  const generateText = (options) => Effect5.useSpan("LanguageModel.generateText", {
+    captureStackTrace: false,
+    attributes: {
+      concurrency: options.concurrency,
+      toolChoice: options.toolChoice
+    }
+  }, Effect5.fnUntraced(function* (span) {
+    const spanTransformer = yield* getSpanTransformer;
+    const providerOptions = {
+      prompt: make2(options.prompt),
+      tools: [],
+      toolChoice: "none",
+      responseFormat: { type: "text" },
+      mcpServers: options.mcpServers ?? [],
+      span
+    };
+    const content = yield* generateContent(options, providerOptions);
+    applySpanTransformer(spanTransformer, content, providerOptions);
+    return new GenerateTextResponse(content);
+  }, Effect5.catchTag("ParseError", (error) => MalformedOutput.fromParseError({
+    module: "LanguageModel",
+    method: "generateText",
+    error
+  })), (effect2, span) => Effect5.withParentSpan(effect2, span), Effect5.provideService(IdGenerator, idGenerator)));
+  const generateObject = (options) => {
+    const schema = options.schema;
+    const objectName = getObjectName(options.objectName, schema);
+    return Effect5.useSpan("LanguageModel.generateObject", {
+      captureStackTrace: false,
+      attributes: {
+        objectName,
+        concurrency: options.concurrency,
+        toolChoice: options.toolChoice
+      }
+    }, Effect5.fnUntraced(function* (span) {
+      const spanTransformer = yield* getSpanTransformer;
+      const providerOptions = {
+        prompt: make2(options.prompt),
+        tools: [],
+        toolChoice: "none",
+        responseFormat: {
+          type: "json",
+          objectName,
+          schema
+        },
+        mcpServers: options.mcpServers ?? [],
+        span
+      };
+      const content = yield* generateContent(options, providerOptions);
+      applySpanTransformer(spanTransformer, content, providerOptions);
+      const finishPart2 = content.find((part) => part.type === "finish");
+      const finishReason = finishPart2?.reason ?? "unknown";
+      if (finishReason === "tool-calls") {
+        return new GenerateObjectResponse(undefined, content);
+      }
+      const value = yield* resolveStructuredOutput(content, schema);
+      return new GenerateObjectResponse(value, content);
+    }, Effect5.catchTag("ParseError", (error) => MalformedOutput.fromParseError({
+      module: "LanguageModel",
+      method: "generateText",
+      error
+    })), (effect2, span) => Effect5.withParentSpan(effect2, span), Effect5.provideService(IdGenerator, idGenerator)));
+  };
+  const streamText = Effect5.fnUntraced(function* (options) {
+    const span = yield* Effect5.makeSpanScoped("LanguageModel.streamText", {
+      captureStackTrace: false,
+      attributes: {
+        concurrency: options.concurrency,
+        toolChoice: options.toolChoice
+      }
+    });
+    const providerOptions = {
+      prompt: make2(options.prompt),
+      tools: [],
+      toolChoice: "none",
+      responseFormat: { type: "text" },
+      mcpServers: options.mcpServers ?? [],
+      span
+    };
+    const stream = yield* streamContent(options, providerOptions);
+    const spanTransformer = yield* getSpanTransformer;
+    if (Option3.isNone(spanTransformer)) {
+      return stream;
+    }
+    let content = [];
+    return stream.pipe(Stream.mapChunks((chunk) => {
+      content = [...content, ...chunk];
+      return chunk;
+    }), Stream.ensuring(Effect5.sync(() => {
+      spanTransformer.value({
+        ...providerOptions,
+        response: content
+      });
+    })));
+  }, Stream.unwrapScoped, Stream.mapError((error) => ParseResult4.isParseError(error) ? MalformedOutput.fromParseError({
+    module: "LanguageModel",
+    method: "streamText",
+    error
+  }) : error), Stream.provideService(IdGenerator, idGenerator));
+  const generateContent = Effect5.fnUntraced(function* (options, providerOptions) {
+    const toolChoice = options.toolChoice ?? "auto";
+    if (Predicate8.isUndefined(options.toolkit)) {
+      const ResponseSchema2 = Schema6.mutable(Schema6.Array(Part(empty3)));
+      const rawContent2 = yield* params.generateText(providerOptions);
+      const content2 = yield* Schema6.decodeUnknown(ResponseSchema2)(rawContent2);
+      return content2;
+    }
+    const toolkit = yield* resolveToolkit(options.toolkit);
+    if (Object.values(toolkit.tools).length === 0) {
+      const ResponseSchema2 = Schema6.mutable(Schema6.Array(Part(empty3)));
+      const rawContent2 = yield* params.generateText(providerOptions);
+      const content2 = yield* Schema6.decodeUnknown(ResponseSchema2)(rawContent2);
+      return content2;
+    }
+    const tools = typeof toolChoice === "object" && "oneOf" in toolChoice ? Object.values(toolkit.tools).filter((tool) => toolChoice.oneOf.includes(tool.name)) : Object.values(toolkit.tools);
+    providerOptions.tools = tools;
+    providerOptions.toolChoice = toolChoice;
+    const ResponseSchema = Schema6.mutable(Schema6.Array(Part(toolkit)));
+    if (options.disableToolCallResolution === true) {
+      const rawContent2 = yield* params.generateText(providerOptions);
+      const content2 = yield* Schema6.decodeUnknown(ResponseSchema)(rawContent2);
+      return content2;
+    }
+    const rawContent = yield* params.generateText(providerOptions);
+    const toolResults = yield* resolveToolCalls(rawContent, toolkit, options.concurrency);
+    const content = yield* Schema6.decodeUnknown(ResponseSchema)(rawContent);
+    return [...content, ...toolResults];
+  });
+  const streamContent = Effect5.fnUntraced(function* (options, providerOptions) {
+    const toolChoice = options.toolChoice ?? "auto";
+    if (Predicate8.isUndefined(options.toolkit)) {
+      const schema = Schema6.ChunkFromSelf(StreamPart(empty3));
+      const decode4 = Schema6.decode(schema);
+      return params.streamText(providerOptions).pipe(Stream.mapChunksEffect(decode4));
+    }
+    const toolkit = Effect5.isEffect(options.toolkit) ? yield* options.toolkit : options.toolkit;
+    if (Object.values(toolkit.tools).length === 0) {
+      const schema = Schema6.ChunkFromSelf(StreamPart(empty3));
+      const decode4 = Schema6.decode(schema);
+      return params.streamText(providerOptions).pipe(Stream.mapChunksEffect(decode4));
+    }
+    const tools = typeof toolChoice === "object" && "oneOf" in toolChoice ? Object.values(toolkit.tools).filter((tool) => toolChoice.oneOf.includes(tool.name)) : Object.values(toolkit.tools);
+    providerOptions.tools = tools;
+    providerOptions.toolChoice = toolChoice;
+    if (options.disableToolCallResolution === true) {
+      const schema = Schema6.ChunkFromSelf(StreamPart(toolkit));
+      const decode4 = Schema6.decode(schema);
+      return params.streamText(providerOptions).pipe(Stream.mapChunksEffect(decode4));
+    }
+    const mailbox = yield* Mailbox.make();
+    const ResponseSchema = Schema6.Array(StreamPart(toolkit));
+    const decode3 = Schema6.decode(ResponseSchema);
+    yield* params.streamText(providerOptions).pipe(Stream.runForEachChunk(Effect5.fnUntraced(function* (chunk) {
+      const rawContent = Chunk.toArray(chunk);
+      const content = yield* decode3(rawContent);
+      yield* mailbox.offerAll(content);
+      const toolResults = yield* resolveToolCalls(rawContent, toolkit, options.concurrency);
+      yield* mailbox.offerAll(toolResults);
+    })), Mailbox.into(mailbox), Effect5.forkScoped);
+    return Mailbox.toStream(mailbox);
+  });
+  const streamObject = (options) => {
+    const schema = options.schema;
+    const objectName = getObjectName(options.objectName, schema);
+    const tryParsePartial = (json) => {
+      try {
+        return JSON.parse(json);
+      } catch {
+        try {
+          const trimmed = json.trim();
+          let closed = trimmed;
+          const openBraces = (trimmed.match(/\{/g) || []).length - (trimmed.match(/\}/g) || []).length;
+          const openBrackets = (trimmed.match(/\[/g) || []).length - (trimmed.match(/\]/g) || []).length;
+          for (let i = 0;i < openBrackets; i++)
+            closed += "]";
+          for (let i = 0;i < openBraces; i++)
+            closed += "}";
+          return JSON.parse(closed);
+        } catch {
+          return;
+        }
+      }
+    };
+    return Effect5.fnUntraced(function* () {
+      const span = yield* Effect5.makeSpanScoped("LanguageModel.streamObject", {
+        captureStackTrace: false,
+        attributes: { objectName }
+      });
+      const providerOptions = {
+        prompt: make2(options.prompt),
+        tools: [],
+        toolChoice: "none",
+        responseFormat: { type: "json", objectName, schema },
+        mcpServers: options.mcpServers ?? [],
+        span
+      };
+      const decodeSchema = Schema6.ChunkFromSelf(StreamPart(empty3));
+      const decode3 = Schema6.decode(decodeSchema);
+      const decodedStream = params.streamText(providerOptions).pipe(Stream.mapChunksEffect(decode3));
+      const objectId = yield* idGenerator.generateId();
+      let accumulated = "";
+      return decodedStream.pipe(Stream.mapEffect(Effect5.fnUntraced(function* (part) {
+        if (part.type === "text-delta") {
+          accumulated += part.delta;
+          const partial = tryParsePartial(accumulated);
+          return objectDeltaPart({
+            id: objectId,
+            delta: part.delta,
+            accumulated,
+            partial
+          });
+        }
+        if (part.type === "finish") {
+          const decodeJson = Schema6.decode(Schema6.parseJson(schema));
+          const value = yield* Effect5.mapError(decodeJson(accumulated), (cause) => new MalformedOutput({
+            module: "LanguageModel",
+            method: "streamObject",
+            description: "Generated object failed to conform to provided schema",
+            cause
+          }));
+          return objectDonePart({
+            id: objectId,
+            value,
+            raw: accumulated
+          });
+        }
+        if (part.type === "response-metadata") {
+          return responseMetadataPart({
+            id: part.id,
+            modelId: part.modelId,
+            timestamp: part.timestamp
+          });
+        }
+        if (part.type === "error") {
+          return errorPart({
+            error: part.error
+          });
+        }
+        return;
+      })), Stream.filter((part) => part !== undefined));
+    }, Stream.unwrapScoped, Stream.mapError((error) => ParseResult4.isParseError(error) ? MalformedOutput.fromParseError({
+      module: "LanguageModel",
+      method: "streamObject",
+      error
+    }) : error), Stream.provideService(IdGenerator, idGenerator))();
+  };
+  return {
+    generateText,
+    generateObject,
+    streamText,
+    streamObject
+  };
+});
+var generateText = Effect5.serviceFunctionEffect(LanguageModel, (model) => model.generateText);
+var generateObject = Effect5.serviceFunctionEffect(LanguageModel, (model) => model.generateObject);
+var streamText = (options) => Stream.unwrap(LanguageModel.pipe(Effect5.map((model) => model.streamText(options))));
+var streamObject = (options) => Stream.unwrap(LanguageModel.pipe(Effect5.map((model) => model.streamObject(options))));
+var resolveToolCalls = (content, toolkit, concurrency) => {
+  const toolNames = [];
+  const toolCalls = [];
+  for (const part of content) {
+    if (part.type === "tool-call") {
+      toolNames.push(part.name);
+      if (part.providerExecuted === true) {
+        continue;
+      }
+      toolCalls.push(part);
+    }
+  }
+  return Effect5.forEach(toolCalls, (toolCall) => {
+    return toolkit.handle(toolCall.name, toolCall.params).pipe(Effect5.map(({ encodedResult, isFailure, result }) => makePart2("tool-result", {
+      id: toolCall.id,
+      name: toolCall.name,
+      result,
+      encodedResult,
+      isFailure,
+      providerExecuted: false,
+      ...toolCall.providerName !== undefined ? { providerName: toolCall.providerName } : {}
+    })));
+  }, { concurrency });
+};
+var resolveToolkit = (toolkit) => Effect5.isEffect(toolkit) ? toolkit : Effect5.succeed(toolkit);
+var getObjectName = (objectName, schema) => Predicate8.isNotUndefined(objectName) ? objectName : ("_tag" in schema) ? schema._tag : ("identifier" in schema) ? schema.identifier : "generateObject";
+var resolveStructuredOutput = Effect5.fnUntraced(function* (response, ResultSchema) {
+  const text = [];
+  for (const part of response) {
+    if (part.type === "text") {
+      text.push(part.text);
+    }
+  }
+  if (text.length === 0) {
+    return yield* new MalformedOutput({
+      module: "LanguageModel",
+      method: "generateObject",
+      description: "No object was generated by the large language model"
+    });
+  }
+  const decode3 = Schema6.decode(Schema6.parseJson(ResultSchema));
+  return yield* Effect5.mapError(decode3(text.join("")), (cause) => new MalformedOutput({
+    module: "LanguageModel",
+    method: "generateObject",
+    description: "Generated object failed to conform to provided schema",
+    cause
+  }));
+});
+var applySpanTransformer = (transformer, response, options) => {
+  if (Option3.isSome(transformer)) {
+    transformer.value({ ...options, response });
+  }
+};
+
+// packages/ariadne/src/AgentRunner.ts
+class Config extends Context6.Tag("ariadne/AgentRunner/Config")() {
+  static getOrUndefined = Effect6.map(Effect6.context(), (context3) => context3.unsafeMap.get(Config.key));
+}
+var defaultConfig = Layer3.succeed(Config, {
+  maxTurns: 10
+});
+var ReAct = Layer3.effect(LanguageModel, Effect6.gen(function* () {
+  const underlying = yield* LanguageModel;
+  const config = yield* Config.getOrUndefined;
+  const maxTurns = config?.maxTurns ?? 10;
+  const shouldTerminate = (finishReason) => finishReason === "stop" || finishReason === "length" || finishReason === "content-filter" || finishReason === "error" || finishReason === "unknown";
+  const excludeFinishParts = (content) => content.filter((p) => p.type !== "finish");
+  const generateText2 = (options) => Effect6.gen(function* () {
+    const history = yield* Ref.make(make2(options.prompt));
+    let turns = 0;
+    let allContent = [];
+    while (turns < maxTurns) {
+      turns++;
+      const currentPrompt = yield* Ref.get(history);
+      const response = yield* underlying.generateText({
+        ...options,
+        prompt: currentPrompt
+      });
+      if (shouldTerminate(response.finishReason)) {
+        allContent = [...allContent, ...response.content];
+        return new GenerateTextResponse(allContent);
+      }
+      allContent = [
+        ...allContent,
+        ...excludeFinishParts(response.content)
+      ];
+      const newPrompt = merge2(currentPrompt, fromResponseParts(response.content));
+      yield* Ref.set(history, newPrompt);
+    }
+    return new GenerateTextResponse(allContent);
+  });
+  const generateObject2 = (options) => Effect6.gen(function* () {
+    const history = yield* Ref.make(make2(options.prompt));
+    let turns = 0;
+    let allContent = [];
+    let finalValue;
+    while (turns < maxTurns) {
+      turns++;
+      const currentPrompt = yield* Ref.get(history);
+      const response = yield* underlying.generateObject({
+        ...options,
+        prompt: currentPrompt
+      });
+      finalValue = response.value;
+      if (shouldTerminate(response.finishReason)) {
+        allContent = [...allContent, ...response.content];
+        return new GenerateObjectResponse(finalValue, allContent);
+      }
+      allContent = [
+        ...allContent,
+        ...excludeFinishParts(response.content)
+      ];
+      const newPrompt = merge2(currentPrompt, fromResponseParts(response.content));
+      yield* Ref.set(history, newPrompt);
+    }
+    return new GenerateObjectResponse(finalValue, allContent);
+  });
+  const streamText2 = (options) => {
+    const history = Ref.unsafeMake(make2(options.prompt));
+    let turns = 0;
+    const runTurn = () => Stream2.unwrap(Effect6.gen(function* () {
+      if (turns >= maxTurns) {
+        return Stream2.empty;
+      }
+      turns++;
+      const currentPrompt = yield* Ref.get(history);
+      let accumulatedParts = [];
+      let finishReason = "unknown";
+      const innerStream = underlying.streamText({
+        ...options,
+        prompt: currentPrompt
+      }).pipe(Stream2.tap((part) => Effect6.sync(() => {
+        accumulatedParts.push(part);
+        if (part.type === "finish") {
+          finishReason = part.reason;
+        }
+      })));
+      const continueOrEnd = Effect6.gen(function* () {
+        if (!shouldTerminate(finishReason)) {
+          const currentPrompt2 = yield* Ref.get(history);
+          const newPrompt = merge2(currentPrompt2, fromResponseParts(accumulatedParts));
+          yield* Ref.set(history, newPrompt);
+          return runTurn();
+        }
+        return Stream2.empty;
+      });
+      return Stream2.concat(innerStream, Stream2.unwrap(continueOrEnd));
+    }));
+    return runTurn();
+  };
+  const streamObject2 = (options) => underlying.streamObject(options);
+  return {
+    generateText: generateText2,
+    generateObject: generateObject2,
+    streamText: streamText2,
+    streamObject: streamObject2
+  };
+}));
+// packages/ariadne/src/Chat.ts
+var exports_Chat = {};
+__export(exports_Chat, {
+  makePersisted: () => makePersisted,
+  layerPersisted: () => layerPersisted,
+  fromPrompt: () => fromPrompt,
+  fromJson: () => fromJson,
+  fromExport: () => fromExport,
+  empty: () => empty6,
+  Persistence: () => Persistence,
+  ChatNotFoundError: () => ChatNotFoundError,
+  Chat: () => Chat
+});
+import { BackingPersistence } from "@effect/experimental/Persistence";
+import * as Channel from "effect/Channel";
+import * as Chunk2 from "effect/Chunk";
+import * as Context7 from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect7 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Option4 from "effect/Option";
+import * as Predicate9 from "effect/Predicate";
+import * as Ref2 from "effect/Ref";
+import * as Schema7 from "effect/Schema";
+import * as Stream3 from "effect/Stream";
+class Chat extends Context7.Tag("@effect/ai/Chat")() {
+}
+var empty6 = Effect7.gen(function* () {
+  const history = yield* Ref2.make(empty);
+  const context4 = yield* Effect7.context();
+  const semaphore = yield* Effect7.makeSemaphore(1);
+  const provideContext = (effect3) => Effect7.mapInputContext(effect3, (input) => Context7.merge(context4, input));
+  const provideContextStream = (stream) => Stream3.mapInputContext(stream, (input) => Context7.merge(context4, input));
+  const encodeHistory = Schema7.encode(Prompt);
+  const encodeHistoryJson = Schema7.encode(FromJson);
+  return Chat.of({
+    history,
+    export: Ref2.get(history).pipe(Effect7.flatMap(encodeHistory), Effect7.catchTag("ParseError", (error) => MalformedOutput.fromParseError({
+      module: "Chat",
+      method: "exportJson",
+      description: "Failed to encode chat history",
+      error
+    })), Effect7.withSpan("Chat.export")),
+    exportJson: Ref2.get(history).pipe(Effect7.flatMap(encodeHistoryJson), Effect7.catchTag("ParseError", (error) => MalformedOutput.fromParseError({
+      module: "Chat",
+      method: "exportJson",
+      description: "Failed to encode chat history into JSON",
+      error
+    })), Effect7.withSpan("Chat.exportJson")),
+    generateText: Effect7.fnUntraced(function* (options) {
+      const newPrompt = make2(options.prompt);
+      const oldPrompt = yield* Ref2.get(history);
+      const prompt = merge2(oldPrompt, newPrompt);
+      const response = yield* generateText({
+        ...options,
+        prompt
+      });
+      const newHistory = merge2(prompt, fromResponseParts(response.content));
+      yield* Ref2.set(history, newHistory);
+      return response;
+    }, provideContext, semaphore.withPermits(1), Effect7.withSpan("Chat.generateText", { captureStackTrace: false })),
+    streamText: Effect7.fnUntraced(function* (options) {
+      let parts = Chunk2.empty();
+      return Stream3.fromChannel(Channel.acquireUseRelease(semaphore.take(1).pipe(Effect7.zipRight(Ref2.get(history)), Effect7.map((history2) => merge2(history2, make2(options.prompt)))), (prompt) => streamText({ ...options, prompt }).pipe(Stream3.mapChunks((chunk) => {
+        parts = Chunk2.appendAll(parts, chunk);
+        return chunk;
+      }), Stream3.toChannel), (prompt) => Effect7.zipRight(Ref2.set(history, merge2(prompt, fromResponseParts(Array.from(parts)))), semaphore.release(1)))).pipe(provideContextStream, Stream3.withSpan("Chat.streamText", {
+        captureStackTrace: false
+      }));
+    }, Stream3.unwrap),
+    generateObject: Effect7.fnUntraced(function* (options) {
+      const newPrompt = make2(options.prompt);
+      const oldPrompt = yield* Ref2.get(history);
+      const prompt = merge2(oldPrompt, newPrompt);
+      const response = yield* generateObject({
+        ...options,
+        prompt
+      });
+      const newHistory = merge2(prompt, fromResponseParts(response.content));
+      yield* Ref2.set(history, newHistory);
+      return response;
+    }, provideContext, semaphore.withPermits(1), (effect3, options) => Effect7.withSpan(effect3, "Chat.generateObject", {
+      attributes: {
+        objectName: "objectName" in options ? options.objectName : ("_tag" in options.schema) ? options.schema._tag : options.schema.identifier ?? "generateObject"
+      },
+      captureStackTrace: false
+    }))
+  });
+});
+var fromPrompt = Effect7.fnUntraced(function* (prompt) {
+  const chat = yield* empty6;
+  yield* Ref2.set(chat.history, make2(prompt));
+  return chat;
+});
+var decodeUnknown4 = Schema7.decodeUnknown(Prompt);
+var fromExport = (data) => Effect7.flatMap(decodeUnknown4(data), fromPrompt);
+var decodeHistoryJson = Schema7.decodeUnknown(FromJson);
+var fromJson = (data) => Effect7.flatMap(decodeHistoryJson(data), fromPrompt);
+
+class ChatNotFoundError extends Schema7.TaggedError("@effect/ai/Chat/ChatNotFoundError")("ChatNotFoundError", { chatId: Schema7.String }) {
+}
+
+class Persistence extends Context7.Tag("@effect/ai/Chat/Persisted")() {
+}
+var makePersisted = Effect7.fnUntraced(function* (options) {
+  const persistence = yield* BackingPersistence;
+  const store = yield* persistence.make(options.storeId);
+  const toPersisted = Effect7.fnUntraced(function* (chatId, chat, ttl) {
+    const idGenerator = yield* Effect7.serviceOption(IdGenerator).pipe(Effect7.map(Option4.getOrElse(() => defaultIdGenerator)));
+    const saveChat = Effect7.fnUntraced(function* (prevHistory) {
+      const history = yield* Ref2.get(chat.history);
+      const lastMessage = prevHistory.content[prevHistory.content.length - 1];
+      let messageId = undefined;
+      if (Predicate9.isNotUndefined(lastMessage) && lastMessage.role === "assistant") {
+        messageId = lastMessage.options[Persistence.key]?.messageId;
+      }
+      if (Predicate9.isUndefined(messageId)) {
+        messageId = yield* idGenerator.generateId();
+      }
+      for (let i = prevHistory.content.length;i < history.content.length; i++) {
+        const message = history.content[i];
+        message.options[Persistence.key] = { messageId };
+      }
+      yield* Ref2.set(chat.history, history);
+      const json = yield* chat.exportJson;
+      yield* store.set(chatId, json, ttl);
+    }, Effect7.catchTag("PersistenceError", (error) => {
+      if (error.reason === "ParseError")
+        return Effect7.die(error);
+      return Effect7.fail(error);
+    }));
+    const persisted = {
+      ...chat,
+      id: chatId,
+      save: Effect7.flatMap(Ref2.get(chat.history), saveChat),
+      generateText: Effect7.fnUntraced(function* (options2) {
+        const history = yield* Ref2.get(chat.history);
+        return yield* chat.generateText(options2).pipe(Effect7.ensuring(Effect7.orDie(saveChat(history))));
+      }),
+      generateObject: Effect7.fnUntraced(function* (options2) {
+        const history = yield* Ref2.get(chat.history);
+        return yield* chat.generateObject(options2).pipe(Effect7.ensuring(Effect7.orDie(saveChat(history))));
+      }),
+      streamText: Effect7.fnUntraced(function* (options2) {
+        const history = yield* Ref2.get(chat.history);
+        const stream = chat.streamText(options2).pipe(Stream3.ensuring(Effect7.orDie(saveChat(history))));
+        return stream;
+      }, Stream3.unwrap)
+    };
+    return persisted;
+  });
+  const createChat = Effect7.fnUntraced(function* (chatId, ttl) {
+    const chat = yield* empty6;
+    const history = yield* chat.exportJson;
+    yield* store.set(chatId, history, ttl);
+    return yield* toPersisted(chatId, chat, ttl);
+  }, Effect7.catchTag("PersistenceError", (error) => {
+    if (error.reason === "ParseError")
+      return Effect7.die(error);
+    return Effect7.fail(error);
+  }));
+  const getChat = Effect7.fnUntraced(function* (chatId, ttl) {
+    const chat = yield* empty6;
+    yield* store.get(chatId).pipe(Effect7.flatMap(Effect7.transposeMapOption(decodeHistoryJson)), Effect7.flatten, Effect7.catchTag("NoSuchElementException", () => new ChatNotFoundError({ chatId })), Effect7.flatMap((history) => Ref2.set(chat.history, history)));
+    return yield* toPersisted(chatId, chat, ttl);
+  }, Effect7.catchTags({
+    ParseError: (error) => Effect7.die(error),
+    PersistenceError: (error) => {
+      if (error.reason === "ParseError")
+        return Effect7.die(error);
+      return Effect7.fail(error);
+    }
+  }));
+  const makeTTL = (timeToLive) => Option4.fromNullable(timeToLive).pipe(Option4.map(Duration.decode));
+  const get3 = Effect7.fn("PersistedChat.get")(function* (chatId, options2) {
+    const ttl = makeTTL(options2?.timeToLive);
+    return yield* getChat(chatId, ttl);
+  });
+  const getOrCreate = Effect7.fn("PersistedChat.getOrCreate")(function* (chatId, options2) {
+    const ttl = makeTTL(options2?.timeToLive);
+    return yield* getChat(chatId, ttl).pipe(Effect7.catchTag("ChatNotFoundError", () => createChat(chatId, ttl)));
+  });
+  return Persistence.of({
+    get: get3,
+    getOrCreate
+  });
+});
+var layerPersisted = (options) => Layer4.scoped(Persistence, makePersisted(options));
+// packages/ariadne/src/EmbeddingModel.ts
+var exports_EmbeddingModel = {};
+__export(exports_EmbeddingModel, {
+  makeDataLoader: () => makeDataLoader,
+  make: () => make9,
+  EmbeddingModel: () => EmbeddingModel
+});
+import { dataLoader } from "@effect/experimental/RequestResolver";
+import * as Context8 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+import { identity as identity3 } from "effect/Function";
+import * as Option5 from "effect/Option";
+import * as Request from "effect/Request";
+import * as RequestResolver from "effect/RequestResolver";
+import * as Schema8 from "effect/Schema";
+class EmbeddingModel extends Context8.Tag("@effect/ai/EmbeddingModel")() {
+}
+
+class EmbeddingRequest extends Schema8.TaggedRequest("@effect/ai/EmbeddingModel/Request")("EmbeddingRequest", {
+  failure: AiError,
+  success: Schema8.mutable(Schema8.Array(Schema8.Number)),
+  payload: { input: Schema8.String }
+}) {
+}
+var makeBatchedResolver = (embedMany) => RequestResolver.makeBatched((requests) => embedMany(requests.map((request2) => request2.input)).pipe(Effect8.flatMap(Effect8.forEach(({ embeddings, index }) => Request.succeed(requests[index], embeddings), { discard: true })), Effect8.catchAll((error) => Effect8.forEach(requests, (request2) => Request.fail(request2, error), { discard: true }))));
+var make9 = (options) => Effect8.gen(function* () {
+  const cache = yield* Option5.fromNullable(options.cache).pipe(Effect8.flatMap((config) => Request.makeCache(config)), Effect8.optionFromOptional);
+  const resolver = makeBatchedResolver(options.embedMany).pipe(options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity3);
+  const embed = (input) => {
+    const request2 = Effect8.request(new EmbeddingRequest({ input }), resolver);
+    return Option5.match(cache, {
+      onNone: () => request2,
+      onSome: (cache2) => request2.pipe(Effect8.withRequestCaching(true), Effect8.withRequestCache(cache2))
+    });
+  };
+  const embedMany = (inputs, options2) => Effect8.forEach(inputs, embed, {
+    batching: true,
+    concurrency: options2?.concurrency
+  });
+  return EmbeddingModel.of({
+    embed: (input) => embed(input).pipe(Effect8.withSpan("EmbeddingModel.embed", {
+      captureStackTrace: false
+    })),
+    embedMany: (inputs) => embedMany(inputs).pipe(Effect8.withSpan("EmbeddingModel.embedMany", {
+      captureStackTrace: false
+    }))
+  });
+});
+var makeDataLoader = (options) => Effect8.gen(function* () {
+  const resolver = makeBatchedResolver(options.embedMany);
+  const resolverDelayed = yield* dataLoader(resolver, {
+    window: options.window,
+    maxBatchSize: options.maxBatchSize
+  });
+  function embed(input) {
+    return Effect8.request(new EmbeddingRequest({ input }), resolverDelayed).pipe(Effect8.withSpan("EmbeddingModel.embed", {
+      captureStackTrace: false
+    }));
+  }
+  function embedMany(inputs, options2) {
+    return Effect8.forEach(inputs, embed, {
+      batching: true,
+      concurrency: options2?.concurrency
+    }).pipe(Effect8.withSpan("EmbeddingModel.embedMany", {
+      captureStackTrace: false
+    }));
+  }
+  return EmbeddingModel.of({
+    embed,
+    embedMany
+  });
+});
+// packages/ariadne/src/McpRegistry.ts
+var exports_McpRegistry = {};
+__export(exports_McpRegistry, {
+  url: () => url,
+  toApiFormat: () => toApiFormat,
+  marketplace: () => marketplace,
+  make: () => make10,
+  isUrl: () => isUrl,
+  isMarketplace: () => isMarketplace
+});
+var url = (url2) => ({ _tag: "url", url: url2 });
+var marketplace = (id) => ({
+  _tag: "marketplace",
+  id
+});
+var make10 = (servers) => Array.from(servers);
+var toApiFormat = (servers) => servers.map((server) => server._tag === "url" ? server.url : server.id);
+var isUrl = (server) => server._tag === "url";
+var isMarketplace = (server) => server._tag === "marketplace";
+// packages/ariadne/src/McpSchema.ts
+var exports_McpSchema = {};
+__export(exports_McpSchema, {
+  param: () => param,
+  Unsubscribe: () => Unsubscribe,
+  ToolListChangedNotification: () => ToolListChangedNotification,
+  ToolAnnotations: () => ToolAnnotations,
+  Tool: () => Tool,
+  TextResourceContents: () => TextResourceContents,
+  TextContent: () => TextContent,
+  Subscribe: () => Subscribe,
+  SetLevel: () => SetLevel,
+  ServerRequestRpcs: () => ServerRequestRpcs,
+  ServerNotificationRpcs: () => ServerNotificationRpcs,
+  ServerCapabilities: () => ServerCapabilities,
+  SamplingMessage: () => SamplingMessage,
+  RootsListChangedNotification: () => RootsListChangedNotification,
+  Root: () => Root,
+  Role: () => Role,
+  ResultMeta: () => ResultMeta,
+  ResourceUpdatedNotification: () => ResourceUpdatedNotification,
+  ResourceTemplate: () => ResourceTemplate,
+  ResourceReference: () => ResourceReference,
+  ResourceListChangedNotification: () => ResourceListChangedNotification,
+  ResourceLink: () => ResourceLink,
+  ResourceContents: () => ResourceContents,
+  Resource: () => Resource,
+  RequestMeta: () => RequestMeta,
+  RequestId: () => RequestId,
+  ReadResourceResult: () => ReadResourceResult,
+  ReadResource: () => ReadResource,
+  PromptReference: () => PromptReference,
+  PromptMessage: () => PromptMessage,
+  PromptListChangedNotification: () => PromptListChangedNotification,
+  PromptArgument: () => PromptArgument,
+  Prompt: () => Prompt2,
+  ProgressToken: () => ProgressToken,
+  ProgressNotification: () => ProgressNotification,
+  Ping: () => Ping,
+  ParseError: () => ParseError,
+  ParamAnnotation: () => ParamAnnotation,
+  PaginatedResultMeta: () => PaginatedResultMeta,
+  PaginatedRequestMeta: () => PaginatedRequestMeta,
+  PARSE_ERROR_CODE: () => PARSE_ERROR_CODE,
+  NotificationMeta: () => NotificationMeta,
+  ModelPreferences: () => ModelPreferences,
+  ModelHint: () => ModelHint,
+  MethodNotFound: () => MethodNotFound,
+  McpServerClientMiddleware: () => McpServerClientMiddleware,
+  McpServerClient: () => McpServerClient,
+  McpError: () => McpError,
+  METHOD_NOT_FOUND_ERROR_CODE: () => METHOD_NOT_FOUND_ERROR_CODE,
+  LoggingMessageNotification: () => LoggingMessageNotification,
+  LoggingLevel: () => LoggingLevel,
+  ListToolsResult: () => ListToolsResult,
+  ListTools: () => ListTools,
+  ListRootsResult: () => ListRootsResult,
+  ListRoots: () => ListRoots,
+  ListResourcesResult: () => ListResourcesResult,
+  ListResources: () => ListResources,
+  ListResourceTemplatesResult: () => ListResourceTemplatesResult,
+  ListResourceTemplates: () => ListResourceTemplates,
+  ListPromptsResult: () => ListPromptsResult,
+  ListPrompts: () => ListPrompts,
+  InvalidRequest: () => InvalidRequest,
+  InvalidParams: () => InvalidParams,
+  InternalError: () => InternalError,
+  InitializedNotification: () => InitializedNotification,
+  InitializeResult: () => InitializeResult,
+  Initialize: () => Initialize,
+  Implementation: () => Implementation,
+  ImageContent: () => ImageContent,
+  INVALID_REQUEST_ERROR_CODE: () => INVALID_REQUEST_ERROR_CODE,
+  INVALID_PARAMS_ERROR_CODE: () => INVALID_PARAMS_ERROR_CODE,
+  INTERNAL_ERROR_CODE: () => INTERNAL_ERROR_CODE,
+  GetPromptResult: () => GetPromptResult,
+  GetPrompt: () => GetPrompt,
+  EmbeddedResource: () => EmbeddedResource,
+  ElicitationDeclined: () => ElicitationDeclined,
+  ElicitResult: () => ElicitResult,
+  ElicitDeclineResult: () => ElicitDeclineResult,
+  ElicitAcceptResult: () => ElicitAcceptResult,
+  Elicit: () => Elicit,
+  Cursor: () => Cursor,
+  CreateMessageResult: () => CreateMessageResult,
+  CreateMessage: () => CreateMessage,
+  ContentBlock: () => ContentBlock,
+  CompleteResult: () => CompleteResult,
+  Complete: () => Complete,
+  ClientRpcs: () => ClientRpcs,
+  ClientRequestRpcs: () => ClientRequestRpcs,
+  ClientNotificationRpcs: () => ClientNotificationRpcs,
+  ClientCapabilities: () => ClientCapabilities,
+  CancelledNotification: () => CancelledNotification,
+  CallToolResult: () => CallToolResult,
+  CallTool: () => CallTool,
+  BlobResourceContents: () => BlobResourceContents,
+  AudioContent: () => AudioContent,
+  Annotations: () => Annotations
+});
+import * as Rpc from "@effect/rpc/Rpc";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import * as RpcMiddleware from "@effect/rpc/RpcMiddleware";
+import * as Context9 from "effect/Context";
+import * as Schema9 from "effect/Schema";
+var RequestId = Schema9.Union(Schema9.String, Schema9.Number);
+var ProgressToken = Schema9.Union(Schema9.String, Schema9.Number);
+
+class RequestMeta extends Schema9.Struct({
+  _meta: Schema9.optional(Schema9.Struct({
+    progressToken: Schema9.optional(ProgressToken)
+  }))
+}) {
+}
+
+class ResultMeta extends Schema9.Struct({
+  _meta: Schema9.optional(Schema9.Record({ key: Schema9.String, value: Schema9.Unknown }))
+}) {
+}
+
+class NotificationMeta extends Schema9.Struct({
+  _meta: Schema9.optional(Schema9.Record({ key: Schema9.String, value: Schema9.Unknown }))
+}) {
+}
+var Cursor = Schema9.String;
+
+class PaginatedRequestMeta extends Schema9.Struct({
+  ...RequestMeta.fields,
+  cursor: Schema9.optional(Cursor)
+}) {
+}
+
+class PaginatedResultMeta extends Schema9.Struct({
+  ...ResultMeta.fields,
+  nextCursor: Schema9.optional(Cursor)
+}) {
+}
+var Role = Schema9.Literal("user", "assistant");
+
+class Annotations extends Schema9.Struct({
+  audience: Schema9.optional(Schema9.Array(Role)),
+  priority: Schema9.optional(Schema9.Number.pipe(Schema9.between(0, 1)))
+}) {
+}
+
+class Implementation extends Schema9.Struct({
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String),
+  version: Schema9.String
+}) {
+}
+
+class ClientCapabilities extends Schema9.Class("@effect/ai/McpSchema/ClientCapabilities")({
+  experimental: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.Struct({})
+  })),
+  roots: Schema9.optional(Schema9.Struct({
+    listChanged: Schema9.optional(Schema9.Boolean)
+  })),
+  sampling: Schema9.optional(Schema9.Struct({})),
+  elicitation: Schema9.optional(Schema9.Struct({}))
+}) {
+}
+
+class ServerCapabilities extends Schema9.Struct({
+  experimental: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.Struct({})
+  })),
+  logging: Schema9.optional(Schema9.Struct({})),
+  completions: Schema9.optional(Schema9.Struct({})),
+  prompts: Schema9.optional(Schema9.Struct({
+    listChanged: Schema9.optional(Schema9.Boolean)
+  })),
+  resources: Schema9.optional(Schema9.Struct({
+    subscribe: Schema9.optional(Schema9.Boolean),
+    listChanged: Schema9.optional(Schema9.Boolean)
+  })),
+  tools: Schema9.optional(Schema9.Struct({
+    listChanged: Schema9.optional(Schema9.Boolean)
+  }))
+}) {
+}
+
+class McpError extends Schema9.Class("@effect/ai/McpSchema/McpError")({
+  code: Schema9.Number,
+  message: Schema9.String,
+  data: Schema9.optional(Schema9.Unknown)
+}) {
+}
+var INVALID_REQUEST_ERROR_CODE = -32600;
+var METHOD_NOT_FOUND_ERROR_CODE = -32601;
+var INVALID_PARAMS_ERROR_CODE = -32602;
+var INTERNAL_ERROR_CODE = -32603;
+var PARSE_ERROR_CODE = -32700;
+
+class ParseError extends Schema9.TaggedError()("ParseError", {
+  ...McpError.fields,
+  code: Schema9.tag(PARSE_ERROR_CODE)
+}) {
+}
+
+class InvalidRequest extends Schema9.TaggedError()("InvalidRequest", {
+  ...McpError.fields,
+  code: Schema9.tag(INVALID_REQUEST_ERROR_CODE)
+}) {
+}
+
+class MethodNotFound extends Schema9.TaggedError()("MethodNotFound", {
+  ...McpError.fields,
+  code: Schema9.tag(METHOD_NOT_FOUND_ERROR_CODE)
+}) {
+}
+
+class InvalidParams extends Schema9.TaggedError()("InvalidParams", {
+  ...McpError.fields,
+  code: Schema9.tag(INVALID_PARAMS_ERROR_CODE)
+}) {
+}
+
+class InternalError extends Schema9.TaggedError()("InternalError", {
+  ...McpError.fields,
+  code: Schema9.tag(INTERNAL_ERROR_CODE)
+}) {
+  static notImplemented = new InternalError({
+    message: "Not implemented"
+  });
+}
+
+class Ping extends Rpc.make("ping", {
+  success: Schema9.Struct({}),
+  error: McpError,
+  payload: Schema9.UndefinedOr(RequestMeta)
+}) {
+}
+
+class InitializeResult extends Schema9.Class("@effect/ai/McpSchema/InitializeResult")({
+  ...ResultMeta.fields,
+  protocolVersion: Schema9.String,
+  capabilities: ServerCapabilities,
+  serverInfo: Implementation,
+  instructions: Schema9.optional(Schema9.String)
+}) {
+}
+
+class Initialize extends Rpc.make("initialize", {
+  success: InitializeResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    protocolVersion: Schema9.String,
+    capabilities: ClientCapabilities,
+    clientInfo: Implementation
+  }
+}) {
+}
+
+class InitializedNotification extends Rpc.make("notifications/initialized", {
+  payload: Schema9.UndefinedOr(NotificationMeta)
+}) {
+}
+
+class CancelledNotification extends Rpc.make("notifications/cancelled", {
+  payload: {
+    ...NotificationMeta.fields,
+    requestId: RequestId,
+    reason: Schema9.optional(Schema9.String)
+  }
+}) {
+}
+
+class ProgressNotification extends Rpc.make("notifications/progress", {
+  payload: {
+    ...NotificationMeta.fields,
+    progressToken: ProgressToken,
+    progress: Schema9.optional(Schema9.Number),
+    total: Schema9.optional(Schema9.Number),
+    message: Schema9.optional(Schema9.String)
+  }
+}) {
+}
+
+class Resource extends Schema9.Class("@effect/ai/McpSchema/Resource")({
+  uri: Schema9.String,
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String),
+  mimeType: Schema9.optional(Schema9.String),
+  annotations: Schema9.optional(Annotations),
+  size: Schema9.optional(Schema9.Number)
+}) {
+}
+
+class ResourceTemplate extends Schema9.Class("@effect/ai/McpSchema/ResourceTemplate")({
+  uriTemplate: Schema9.String,
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String),
+  mimeType: Schema9.optional(Schema9.String),
+  annotations: Schema9.optional(Annotations)
+}) {
+}
+
+class ResourceContents extends Schema9.Struct({
+  uri: Schema9.String,
+  mimeType: Schema9.optional(Schema9.String)
+}) {
+}
+
+class TextResourceContents extends Schema9.Struct({
+  ...ResourceContents.fields,
+  text: Schema9.String
+}) {
+}
+
+class BlobResourceContents extends Schema9.Struct({
+  ...ResourceContents.fields,
+  blob: Schema9.Uint8ArrayFromBase64
+}) {
+}
+
+class ListResourcesResult extends Schema9.Class("@effect/ai/McpSchema/ListResourcesResult")({
+  ...PaginatedResultMeta.fields,
+  resources: Schema9.Array(Resource)
+}) {
+}
+
+class ListResources extends Rpc.make("resources/list", {
+  success: ListResourcesResult,
+  error: McpError,
+  payload: Schema9.UndefinedOr(PaginatedRequestMeta)
+}) {
+}
+
+class ListResourceTemplatesResult extends Schema9.Class("@effect/ai/McpSchema/ListResourceTemplatesResult")({
+  ...PaginatedResultMeta.fields,
+  resourceTemplates: Schema9.Array(ResourceTemplate)
+}) {
+}
+
+class ListResourceTemplates extends Rpc.make("resources/templates/list", {
+  success: ListResourceTemplatesResult,
+  error: McpError,
+  payload: Schema9.UndefinedOr(PaginatedRequestMeta)
+}) {
+}
+
+class ReadResourceResult extends Schema9.Struct({
+  ...ResultMeta.fields,
+  contents: Schema9.Array(Schema9.Union(TextResourceContents, BlobResourceContents))
+}) {
+}
+
+class ReadResource extends Rpc.make("resources/read", {
+  success: ReadResourceResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    uri: Schema9.String
+  }
+}) {
+}
+
+class ResourceListChangedNotification extends Rpc.make("notifications/resources/list_changed", {
+  payload: Schema9.UndefinedOr(NotificationMeta)
+}) {
+}
+
+class Subscribe extends Rpc.make("resources/subscribe", {
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    uri: Schema9.String
+  }
+}) {
+}
+
+class Unsubscribe extends Rpc.make("resources/unsubscribe", {
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    uri: Schema9.String
+  }
+}) {
+}
+
+class ResourceUpdatedNotification extends Rpc.make("notifications/resources/updated", {
+  payload: {
+    ...NotificationMeta.fields,
+    uri: Schema9.String
+  }
+}) {
+}
+
+class PromptArgument extends Schema9.Struct({
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String),
+  required: Schema9.optional(Schema9.Boolean)
+}) {
+}
+
+class Prompt2 extends Schema9.Class("@effect/ai/McpSchema/Prompt")({
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String),
+  arguments: Schema9.optional(Schema9.Array(PromptArgument))
+}) {
+}
+
+class TextContent extends Schema9.Struct({
+  type: Schema9.tag("text"),
+  text: Schema9.String,
+  annotations: Schema9.optional(Annotations)
+}) {
+}
+
+class ImageContent extends Schema9.Struct({
+  type: Schema9.tag("image"),
+  data: Schema9.Uint8ArrayFromBase64,
+  mimeType: Schema9.String,
+  annotations: Schema9.optional(Annotations)
+}) {
+}
+
+class AudioContent extends Schema9.Struct({
+  type: Schema9.tag("audio"),
+  data: Schema9.Uint8ArrayFromBase64,
+  mimeType: Schema9.String,
+  annotations: Schema9.optional(Annotations)
+}) {
+}
+
+class EmbeddedResource extends Schema9.Struct({
+  type: Schema9.tag("resource"),
+  resource: Schema9.Union(TextResourceContents, BlobResourceContents),
+  annotations: Schema9.optional(Annotations)
+}) {
+}
+
+class ResourceLink extends Schema9.Struct({
+  ...Resource.fields,
+  type: Schema9.tag("resource_link")
+}) {
+}
+
+class ContentBlock extends Schema9.Union(TextContent, ImageContent, AudioContent, EmbeddedResource, ResourceLink) {
+}
+
+class PromptMessage extends Schema9.Struct({
+  role: Role,
+  content: ContentBlock
+}) {
+}
+
+class ListPromptsResult extends Schema9.Class("@effect/ai/McpSchema/ListPromptsResult")({
+  ...PaginatedResultMeta.fields,
+  prompts: Schema9.Array(Prompt2)
+}) {
+}
+
+class ListPrompts extends Rpc.make("prompts/list", {
+  success: ListPromptsResult,
+  error: McpError,
+  payload: Schema9.UndefinedOr(PaginatedRequestMeta)
+}) {
+}
+
+class GetPromptResult extends Schema9.Class("@effect/ai/McpSchema/GetPromptResult")({
+  ...ResultMeta.fields,
+  messages: Schema9.Array(PromptMessage),
+  description: Schema9.optional(Schema9.String)
+}) {
+}
+
+class GetPrompt extends Rpc.make("prompts/get", {
+  success: GetPromptResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    name: Schema9.String,
+    title: Schema9.optional(Schema9.String),
+    arguments: Schema9.optional(Schema9.Record({
+      key: Schema9.String,
+      value: Schema9.String
+    }))
+  }
+}) {
+}
+
+class PromptListChangedNotification extends Rpc.make("notifications/prompts/list_changed", {
+  payload: Schema9.UndefinedOr(NotificationMeta)
+}) {
+}
+
+class ToolAnnotations extends Schema9.Class("@effect/ai/McpSchema/ToolAnnotations")({
+  title: Schema9.optional(Schema9.String),
+  readOnlyHint: Schema9.optionalWith(Schema9.Boolean, { default: () => false }),
+  destructiveHint: Schema9.optionalWith(Schema9.Boolean, {
+    default: () => true
+  }),
+  idempotentHint: Schema9.optionalWith(Schema9.Boolean, {
+    default: () => false
+  }),
+  openWorldHint: Schema9.optionalWith(Schema9.Boolean, { default: () => true })
+}) {
+}
+
+class Tool extends Schema9.Class("@effect/ai/McpSchema/Tool")({
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String),
+  inputSchema: Schema9.Unknown,
+  annotations: Schema9.optional(ToolAnnotations)
+}) {
+}
+
+class ListToolsResult extends Schema9.Class("@effect/ai/McpSchema/ListToolsResult")({
+  ...PaginatedResultMeta.fields,
+  tools: Schema9.Array(Tool)
+}) {
+}
+
+class ListTools extends Rpc.make("tools/list", {
+  success: ListToolsResult,
+  error: McpError,
+  payload: Schema9.UndefinedOr(PaginatedRequestMeta)
+}) {
+}
+
+class CallToolResult extends Schema9.Class("@effect/ai/McpSchema/CallToolResult")({
+  ...ResultMeta.fields,
+  content: Schema9.Array(ContentBlock),
+  structuredContent: Schema9.optional(Schema9.Unknown),
+  isError: Schema9.optional(Schema9.Boolean)
+}) {
+}
+
+class CallTool extends Rpc.make("tools/call", {
+  success: CallToolResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    name: Schema9.String,
+    arguments: Schema9.Record({
+      key: Schema9.String,
+      value: Schema9.Unknown
+    })
+  }
+}) {
+}
+
+class ToolListChangedNotification extends Rpc.make("notifications/tools/list_changed", {
+  payload: Schema9.UndefinedOr(NotificationMeta)
+}) {
+}
+var LoggingLevel = Schema9.Literal("debug", "info", "notice", "warning", "error", "critical", "alert", "emergency");
+
+class SetLevel extends Rpc.make("logging/setLevel", {
+  payload: {
+    ...RequestMeta.fields,
+    level: LoggingLevel
+  },
+  error: McpError
+}) {
+}
+
+class LoggingMessageNotification extends Rpc.make("notifications/message", {
+  payload: Schema9.Struct({
+    ...NotificationMeta.fields,
+    level: LoggingLevel,
+    logger: Schema9.optional(Schema9.String),
+    data: Schema9.Unknown
+  })
+}) {
+}
+
+class SamplingMessage extends Schema9.Struct({
+  role: Role,
+  content: Schema9.Union(TextContent, ImageContent, AudioContent)
+}) {
+}
+
+class ModelHint extends Schema9.Struct({
+  name: Schema9.optional(Schema9.String)
+}) {
+}
+
+class ModelPreferences extends Schema9.Class("@effect/ai/McpSchema/ModelPreferences")({
+  hints: Schema9.optional(Schema9.Array(ModelHint)),
+  costPriority: Schema9.optional(Schema9.Number.pipe(Schema9.between(0, 1))),
+  speedPriority: Schema9.optional(Schema9.Number.pipe(Schema9.between(0, 1))),
+  intelligencePriority: Schema9.optional(Schema9.Number.pipe(Schema9.between(0, 1)))
+}) {
+}
+
+class CreateMessageResult extends Schema9.Class("@effect/ai/McpSchema/CreateMessageResult")({
+  model: Schema9.String,
+  stopReason: Schema9.optional(Schema9.String)
+}) {
+}
+
+class CreateMessage extends Rpc.make("sampling/createMessage", {
+  success: CreateMessageResult,
+  error: McpError,
+  payload: {
+    messages: Schema9.Array(SamplingMessage),
+    modelPreferences: Schema9.optional(ModelPreferences),
+    systemPrompt: Schema9.optional(Schema9.String),
+    includeContext: Schema9.optional(Schema9.Literal("none", "thisServer", "allServers")),
+    temperature: Schema9.optional(Schema9.Number),
+    maxTokens: Schema9.Number,
+    stopSequences: Schema9.optional(Schema9.Array(Schema9.String)),
+    metadata: Schema9.Unknown
+  }
+}) {
+}
+
+class ResourceReference extends Schema9.Struct({
+  type: Schema9.tag("ref/resource"),
+  uri: Schema9.String
+}) {
+}
+
+class PromptReference extends Schema9.Struct({
+  type: Schema9.tag("ref/prompt"),
+  name: Schema9.String,
+  title: Schema9.optional(Schema9.String)
+}) {
+}
+
+class CompleteResult extends Schema9.Class("@effect/ai/McpSchema/CompleteResult")({
+  completion: Schema9.Struct({
+    values: Schema9.Array(Schema9.String),
+    total: Schema9.optional(Schema9.Number),
+    hasMore: Schema9.optional(Schema9.Boolean)
+  })
+}) {
+  static empty = CompleteResult.make({
+    completion: {
+      values: [],
+      total: 0,
+      hasMore: false
+    }
+  });
+}
+
+class Complete extends Rpc.make("completion/complete", {
+  success: CompleteResult,
+  error: McpError,
+  payload: Schema9.Struct({
+    ref: Schema9.Union(PromptReference, ResourceReference),
+    argument: Schema9.Struct({
+      name: Schema9.String,
+      value: Schema9.String
+    }),
+    context: Schema9.optionalWith(Schema9.Struct({
+      arguments: Schema9.optionalWith(Schema9.Record({
+        key: Schema9.String,
+        value: Schema9.String
+      }), { default: () => ({}) })
+    }), { default: () => ({ arguments: {} }) })
+  })
+}) {
+}
+
+class Root extends Schema9.Class("@effect/ai/McpSchema/Root")({
+  uri: Schema9.String,
+  name: Schema9.optional(Schema9.String)
+}) {
+}
+
+class ListRootsResult extends Schema9.Class("@effect/ai/McpSchema/ListRootsResult")({
+  roots: Schema9.Array(Root)
+}) {
+}
+
+class ListRoots extends Rpc.make("roots/list", {
+  success: ListRootsResult,
+  error: McpError,
+  payload: Schema9.UndefinedOr(RequestMeta)
+}) {
+}
+
+class RootsListChangedNotification extends Rpc.make("notifications/roots/list_changed", {
+  payload: Schema9.UndefinedOr(NotificationMeta)
+}) {
+}
+
+class ElicitAcceptResult extends Schema9.Class("@effect/ai/McpSchema/ElicitAcceptResult")({
+  ...ResultMeta.fields,
+  action: Schema9.Literal("accept"),
+  content: Schema9.Unknown
+}) {
+}
+
+class ElicitDeclineResult extends Schema9.Class("@effect/ai/McpSchema/ElicitDeclineResult")({
+  ...ResultMeta.fields,
+  action: Schema9.Literal("cancel", "decline")
+}) {
+}
+var ElicitResult = Schema9.Union(ElicitAcceptResult, ElicitDeclineResult);
+
+class Elicit extends Rpc.make("elicitation/create", {
+  success: ElicitResult,
+  error: McpError,
+  payload: {
+    message: Schema9.String,
+    requestedSchema: Schema9.Unknown
+  }
+}) {
+}
+
+class ElicitationDeclined extends Schema9.TaggedError("@effect/ai/McpSchema/ElicitationDeclined")("ElicitationDeclined", {
+  request: Elicit.payloadSchema,
+  cause: Schema9.optional(Schema9.Defect)
+}) {
+}
+
+class McpServerClient extends Context9.Tag("@effect/ai/McpSchema/McpServerClient")() {
+}
+
+class McpServerClientMiddleware extends RpcMiddleware.Tag()("@effect/ai/McpSchema/McpServerClientMiddleware", {
+  provides: McpServerClient
+}) {
+}
+
+class ClientRequestRpcs extends RpcGroup.make(Ping, Initialize, Complete, SetLevel, GetPrompt, ListPrompts, ListResources, ListResourceTemplates, ReadResource, Subscribe, Unsubscribe, CallTool, ListTools).middleware(McpServerClientMiddleware) {
+}
+
+class ClientNotificationRpcs extends RpcGroup.make(CancelledNotification, ProgressNotification, InitializedNotification, RootsListChangedNotification) {
+}
+
+class ClientRpcs extends ClientRequestRpcs.merge(ClientNotificationRpcs) {
+}
+
+class ServerRequestRpcs extends RpcGroup.make(Ping, CreateMessage, ListRoots, Elicit) {
+}
+
+class ServerNotificationRpcs extends RpcGroup.make(CancelledNotification, ProgressNotification, LoggingMessageNotification, ResourceUpdatedNotification, ResourceListChangedNotification, ToolListChangedNotification, PromptListChangedNotification) {
+}
+var ParamAnnotation = Symbol.for("@effect/ai/McpSchema/ParamNameId");
+var param = (id, schema) => schema.annotations({
+  [ParamAnnotation]: id
+});
+// packages/ariadne/src/McpServer.ts
+var exports_McpServer = {};
+__export(exports_McpServer, {
+  toolkit: () => toolkit,
+  run: () => run,
+  resource: () => resource,
+  registerToolkit: () => registerToolkit,
+  registerResource: () => registerResource,
+  registerPrompt: () => registerPrompt,
+  prompt: () => prompt,
+  layerStdio: () => layerStdio,
+  layerHttpRouter: () => layerHttpRouter,
+  layerHttp: () => layerHttp,
+  layer: () => layer2,
+  elicit: () => elicit,
+  McpServer: () => McpServer
+});
+import * as Headers from "@effect/platform/Headers";
+import * as RpcClient from "@effect/rpc/RpcClient";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as RpcServer from "@effect/rpc/RpcServer";
+import * as Arr2 from "effect/Array";
+import * as Cause2 from "effect/Cause";
+import * as Context10 from "effect/Context";
+import * as Effect9 from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as JsonSchema2 from "effect/JSONSchema";
+import * as Layer5 from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Mailbox2 from "effect/Mailbox";
+import * as Option6 from "effect/Option";
+import * as RcMap from "effect/RcMap";
+import * as Schema10 from "effect/Schema";
+import * as AST2 from "effect/SchemaAST";
+import * as FindMyWay from "find-my-way-ts";
+class McpServer extends Context10.Tag("@effect/ai/McpServer")() {
+  static make = Effect9.gen(function* () {
+    const matcher = makeUriMatcher();
+    const tools = Arr2.empty();
+    const toolMap = new Map;
+    const resources = [];
+    const resourceTemplates = [];
+    const prompts = [];
+    const promptMap = new Map;
+    const completionsMap = new Map;
+    const notificationsMailbox = yield* Mailbox2.make();
+    const listChangedHandles = new Map;
+    const notifications = yield* RpcClient.makeNoSerialization(ServerNotificationRpcs, {
+      spanPrefix: "McpServer/Notifications",
+      onFromClient(options) {
+        const message = options.message;
+        if (message._tag !== "Request") {
+          return Effect9.void;
+        }
+        if (message.tag.includes("list_changed")) {
+          if (!listChangedHandles.has(message.tag)) {
+            listChangedHandles.set(message.tag, setTimeout(() => {
+              notificationsMailbox.unsafeOffer(message);
+              listChangedHandles.delete(message.tag);
+            }, 0));
+          }
+        } else {
+          notificationsMailbox.unsafeOffer(message);
+        }
+        return notifications.write({
+          clientId: 0,
+          requestId: message.id,
+          _tag: "Exit",
+          exit: Exit.void
+        });
+      }
+    });
+    return McpServer.of({
+      notifications: notifications.client,
+      notificationsMailbox,
+      initializedClients: new Set,
+      get tools() {
+        return tools;
+      },
+      addTool: (options) => Effect9.suspend(() => {
+        tools.push(options.tool);
+        toolMap.set(options.tool.name, options.handle);
+        return notifications.client["notifications/tools/list_changed"]({});
+      }),
+      callTool: (request2) => Effect9.suspend(() => {
+        const handle = toolMap.get(request2.name);
+        if (!handle) {
+          return Effect9.fail(new InvalidParams({
+            message: `Tool '${request2.name}' not found`
+          }));
+        }
+        return handle(request2.arguments);
+      }),
+      get resources() {
+        return resources;
+      },
+      get resourceTemplates() {
+        return resourceTemplates;
+      },
+      addResource: (resource, effect3) => Effect9.suspend(() => {
+        resources.push(resource);
+        matcher.add(resource.uri, { _tag: "Resource", effect: effect3 });
+        return notifications.client["notifications/resources/list_changed"]({});
+      }),
+      addResourceTemplate: ({
+        completions,
+        handle,
+        routerPath,
+        template
+      }) => Effect9.suspend(() => {
+        resourceTemplates.push(template);
+        matcher.add(routerPath, {
+          _tag: "ResourceTemplate",
+          handle
+        });
+        for (const [param2, handle2] of Object.entries(completions)) {
+          completionsMap.set(`ref/resource/${template.uriTemplate}/${param2}`, handle2);
+        }
+        return notifications.client["notifications/resources/list_changed"]({});
+      }),
+      findResource: (uri) => Effect9.suspend(() => {
+        const match3 = matcher.find(uri);
+        if (!match3) {
+          return Effect9.succeed({ contents: [] });
+        } else if (match3.handler._tag === "Resource") {
+          return match3.handler.effect;
+        }
+        const params = [];
+        for (const key of Object.keys(match3.params)) {
+          params[Number(key)] = match3.params[key];
+        }
+        return match3.handler.handle(uri, params);
+      }),
+      get prompts() {
+        return prompts;
+      },
+      addPrompt: (options) => Effect9.suspend(() => {
+        prompts.push(options.prompt);
+        promptMap.set(options.prompt.name, options.handle);
+        for (const [param2, handle] of Object.entries(options.completions)) {
+          completionsMap.set(`ref/prompt/${options.prompt.name}/${param2}`, handle);
+        }
+        return notifications.client["notifications/prompts/list_changed"]({});
+      }),
+      getPromptResult: Effect9.fnUntraced(function* ({
+        arguments: params,
+        name
+      }) {
+        const handler = promptMap.get(name);
+        if (!handler) {
+          return yield* new InvalidParams({
+            message: `Prompt '${name}' not found`
+          });
+        }
+        return yield* handler(params ?? {});
+      }),
+      completion: Effect9.fnUntraced(function* (complete) {
+        const ref = complete.ref;
+        const key = ref.type === "ref/resource" ? `ref/resource/${ref.uri}/${complete.argument.name}` : `ref/prompt/${ref.name}/${complete.argument.name}`;
+        const handler = completionsMap.get(key);
+        return handler ? yield* handler(complete.argument.value) : CompleteResult.empty;
+      })
+    });
+  });
+  static layer = Layer5.scoped(McpServer, McpServer.make);
+}
+var LATEST_PROTOCOL_VERSION = "2025-06-18";
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  LATEST_PROTOCOL_VERSION,
+  "2025-03-26",
+  "2024-11-05",
+  "2024-10-07"
+];
+var run = Effect9.fnUntraced(function* (options) {
+  const protocol = yield* RpcServer.Protocol;
+  const handlers = yield* Layer5.build(layerHandlers(options));
+  const server = yield* McpServer;
+  const clients = yield* RcMap.make({
+    lookup: Effect9.fnUntraced(function* (clientId) {
+      let write;
+      const client = yield* RpcClient.make(ServerRequestRpcs, {
+        spanPrefix: "McpServer/Client"
+      }).pipe(Effect9.provideServiceEffect(RpcClient.Protocol, RpcClient.Protocol.make(Effect9.fnUntraced(function* (writeResponse) {
+        write = writeResponse;
+        return {
+          send(request2, _transferables) {
+            return protocol.send(clientId, {
+              ...request2,
+              headers: undefined,
+              traceId: undefined,
+              spanId: undefined,
+              sampled: undefined
+            });
+          },
+          supportsAck: true,
+          supportsTransferables: false
+        };
+      }))));
+      return { client, write };
+    }),
+    idleTimeToLive: 1e4
+  });
+  const clientMiddleware = McpServerClientMiddleware.of(({ clientId }) => Effect9.sync(() => McpServerClient.of({
+    clientId,
+    getClient: RcMap.get(clients, clientId).pipe(Effect9.map(({ client }) => client))
+  })));
+  const patchedProtocol = RpcServer.Protocol.of({
+    ...protocol,
+    run: (f) => protocol.run((clientId, request_) => {
+      const request2 = request_;
+      switch (request2._tag) {
+        case "Request": {
+          if (ClientNotificationRpcs.requests.has(request2.tag)) {
+            if (request2.tag === "notifications/cancelled") {
+              return f(clientId, {
+                _tag: "Interrupt",
+                requestId: String(request2.payload.requestId)
+              });
+            }
+            const handler = handlers.unsafeMap.get(request2.tag);
+            return handler ? handler.handler(request2.payload, {
+              clientId,
+              headers: Headers.fromInput(request2.headers)
+            }) : Effect9.void;
+          }
+          return f(clientId, request2);
+        }
+        case "Ping":
+        case "Ack":
+        case "Interrupt":
+        case "Eof":
+          return f(clientId, request2);
+        case "Pong":
+        case "Exit":
+        case "Chunk":
+        case "ClientProtocolError":
+        case "Defect":
+          return RcMap.get(clients, clientId).pipe(Effect9.flatMap(({ write }) => write(request2)), Effect9.scoped);
+      }
+    })
+  });
+  const encodeNotification = Schema10.encode(Schema10.Union(...Array.from(ServerNotificationRpcs.requests.values(), (rpc) => rpc.payloadSchema)));
+  yield* server.notificationsMailbox.take.pipe(Effect9.flatMap(Effect9.fnUntraced(function* (request2) {
+    const encoded = yield* encodeNotification(request2.payload);
+    const message = {
+      _tag: "Request",
+      tag: request2.tag,
+      payload: encoded
+    };
+    const clientIds = yield* patchedProtocol.clientIds;
+    for (const clientId of server.initializedClients) {
+      if (!clientIds.has(clientId)) {
+        server.initializedClients.delete(clientId);
+        continue;
+      }
+      yield* patchedProtocol.send(clientId, message);
+    }
+  })), Effect9.catchAllCause(() => Effect9.void), Effect9.forever, Effect9.forkScoped);
+  return yield* RpcServer.make(ClientRpcs, {
+    spanPrefix: "McpServer",
+    disableFatalDefects: true
+  }).pipe(Effect9.provideService(RpcServer.Protocol, patchedProtocol), Effect9.provideService(McpServerClientMiddleware, clientMiddleware), Effect9.provide(handlers));
+}, Effect9.scoped);
+var layer2 = (options) => Layer5.scopedDiscard(Effect9.forkScoped(run(options))).pipe(Layer5.provideMerge(McpServer.layer));
+var layerStdio = (options) => layer2(options).pipe(Layer5.provide(RpcServer.layerProtocolStdio({
+  stdin: options.stdin,
+  stdout: options.stdout
+})), Layer5.provide(RpcSerialization.layerNdJsonRpc()), Layer5.provideMerge(Logger.remove(Logger.defaultLogger)), Layer5.provideMerge(Logger.remove(Logger.prettyLoggerDefault)));
+var layerHttp = (options) => layer2(options).pipe(Layer5.provide(RpcServer.layerProtocolHttp(options)), Layer5.provide(RpcSerialization.layerJsonRpc()));
+var layerHttpRouter = (options) => layer2(options).pipe(Layer5.provide(RpcServer.layerProtocolHttpRouter(options)), Layer5.provide(RpcSerialization.layerJsonRpc()));
+var registerToolkit = Effect9.fnUntraced(function* (toolkit) {
+  const registry = yield* McpServer;
+  const built = yield* toolkit;
+  const context5 = yield* Effect9.context();
+  for (const tool of Object.values(built.tools)) {
+    const mcpTool = new Tool({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: makeJsonSchema(tool.parametersSchema.ast),
+      annotations: new ToolAnnotations({
+        ...Context10.getOption(tool.annotations, Title).pipe(Option6.map((title) => ({ title })), Option6.getOrUndefined),
+        readOnlyHint: Context10.get(tool.annotations, Readonly),
+        destructiveHint: Context10.get(tool.annotations, Destructive),
+        idempotentHint: Context10.get(tool.annotations, Idempotent),
+        openWorldHint: Context10.get(tool.annotations, OpenWorld)
+      })
+    });
+    yield* registry.addTool({
+      tool: mcpTool,
+      handle(payload) {
+        return built.handle(tool.name, payload).pipe(Effect9.provide(context5), Effect9.match({
+          onFailure: (error) => new CallToolResult({
+            isError: true,
+            structuredContent: typeof error === "object" ? error : undefined,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(error)
+              }
+            ]
+          }),
+          onSuccess: (result) => new CallToolResult({
+            isError: false,
+            structuredContent: typeof result.encodedResult === "object" ? result.encodedResult : undefined,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result.encodedResult)
+              }
+            ]
+          })
+        }));
+      }
+    });
+  }
+});
+var toolkit = (toolkit2) => Layer5.effectDiscard(registerToolkit(toolkit2)).pipe(Layer5.provide(McpServer.layer));
+var registerResource = function() {
+  if (arguments.length === 1) {
+    const options = arguments[0];
+    return Effect9.gen(function* () {
+      const context5 = yield* Effect9.context();
+      const registry = yield* McpServer;
+      yield* registry.addResource(new Resource({
+        ...options,
+        annotations: options
+      }), options.content.pipe(Effect9.provide(context5), Effect9.map((content) => resolveResourceContent(options.uri, content)), Effect9.catchAllCause((cause) => {
+        const prettyError = Cause2.prettyErrors(cause)[0];
+        return new InternalError({
+          message: prettyError.message
+        });
+      })));
+    });
+  }
+  const { params, routerPath, schema, uriPath } = compileUriTemplate(...arguments);
+  return Effect9.fnUntraced(function* (options) {
+    const context5 = yield* Effect9.context();
+    const registry = yield* McpServer;
+    const decode4 = Schema10.decodeUnknown(schema);
+    const template = new ResourceTemplate({
+      ...options,
+      uriTemplate: uriPath,
+      annotations: options
+    });
+    const completions = {};
+    for (const [param2, handle] of Object.entries(options.completion ?? {})) {
+      const encodeArray = Schema10.encodeUnknown(Schema10.Array(params[param2]));
+      const handler = (input) => handle(input).pipe(Effect9.flatMap(encodeArray), Effect9.map((values) => new CompleteResult({
+        completion: {
+          values,
+          total: values.length,
+          hasMore: false
+        }
+      })), Effect9.catchAllCause((cause) => {
+        const prettyError = Cause2.prettyErrors(cause)[0];
+        return new InternalError({
+          message: prettyError.message
+        });
+      }), Effect9.provide(context5));
+      completions[param2] = handler;
+    }
+    yield* registry.addResourceTemplate({
+      template,
+      routerPath,
+      completions,
+      handle: (uri, params2) => decode4(params2).pipe(Effect9.mapError((error) => new InvalidParams({ message: error.message })), Effect9.flatMap((params3) => options.content(uri, ...params3).pipe(Effect9.map((content) => resolveResourceContent(uri, content)), Effect9.catchAllCause((cause) => {
+        const prettyError = Cause2.prettyErrors(cause)[0];
+        return new InternalError({
+          message: prettyError.message
+        });
+      }))), Effect9.provide(context5))
+    });
+  });
+};
+var resource = function() {
+  if (arguments.length === 1) {
+    return Layer5.effectDiscard(registerResource(arguments[0])).pipe(Layer5.provide(McpServer.layer));
+  }
+  const register = registerResource(...arguments);
+  return (options) => Layer5.effectDiscard(register(options)).pipe(Layer5.provide(McpServer.layer));
+};
+var registerPrompt = (options) => {
+  const args = Arr2.empty();
+  const props = {};
+  const propSignatures = options.parameters ? AST2.getPropertySignatures(options.parameters.ast) : [];
+  for (const prop of propSignatures) {
+    args.push({
+      name: prop.name,
+      description: Option6.getOrUndefined(AST2.getDescriptionAnnotation(prop)),
+      required: !prop.isOptional
+    });
+    props[prop.name] = Schema10.make(prop.type);
+  }
+  const prompt = new Prompt2({
+    name: options.name,
+    description: options.description,
+    arguments: args
+  });
+  const decode4 = options.parameters ? Schema10.decodeUnknown(options.parameters) : () => Effect9.succeed({});
+  const completion = options.completion ?? {};
+  return Effect9.gen(function* () {
+    const registry = yield* McpServer;
+    const context5 = yield* Effect9.context();
+    const completions = {};
+    for (const [param2, handle] of Object.entries(completion)) {
+      const encodeArray = Schema10.encodeUnknown(Schema10.Array(props[param2]));
+      const handler = (input) => handle(input).pipe(Effect9.flatMap(encodeArray), Effect9.map((values) => ({
+        completion: {
+          values,
+          total: values.length,
+          hasMore: false
+        }
+      })), Effect9.catchAllCause((cause) => {
+        const prettyError = Cause2.prettyErrors(cause)[0];
+        return new InternalError({
+          message: prettyError.message
+        });
+      }), Effect9.provide(context5));
+      completions[param2] = handler;
+    }
+    yield* registry.addPrompt({
+      prompt,
+      completions,
+      handle: (params) => decode4(params).pipe(Effect9.mapError((error) => new InvalidParams({ message: error.message })), Effect9.flatMap((params2) => options.content(params2)), Effect9.map((messages) => {
+        messages = typeof messages === "string" ? [
+          {
+            role: "user",
+            content: TextContent.make({
+              text: messages
+            })
+          }
+        ] : messages;
+        return new GetPromptResult({
+          messages,
+          description: prompt.description
+        });
+      }), Effect9.catchAllCause((cause) => {
+        const prettyError = Cause2.prettyErrors(cause)[0];
+        return new InternalError({
+          message: prettyError.message
+        });
+      }), Effect9.provide(context5))
+    });
+  });
+};
+var prompt = (options) => Layer5.effectDiscard(registerPrompt(options)).pipe(Layer5.provide(McpServer.layer));
+var elicit = Effect9.fnUntraced(function* (options) {
+  const { getClient } = yield* McpServerClient;
+  const client = yield* getClient;
+  const request2 = Elicit.payloadSchema.make({
+    message: options.message,
+    requestedSchema: makeJsonSchema(options.schema.ast)
+  });
+  const res = yield* client["elicitation/create"](request2).pipe(Effect9.catchAllCause((cause) => Effect9.fail(new ElicitationDeclined({
+    cause: Cause2.squash(cause),
+    request: request2
+  }))));
+  switch (res.action) {
+    case "accept":
+      return yield* Effect9.orDie(Schema10.decodeUnknown(options.schema)(res.content));
+    case "cancel":
+      return yield* Effect9.interrupt;
+    case "decline":
+      return yield* Effect9.fail(new ElicitationDeclined({ request: request2 }));
+  }
+}, Effect9.scoped);
+var makeUriMatcher = () => {
+  const router = FindMyWay.make({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true,
+    caseSensitive: true
+  });
+  const add2 = (uri, value) => {
+    router.on("GET", uri, value);
+  };
+  const find = (uri) => router.find("GET", uri);
+  return { add: add2, find };
+};
+var compileUriTemplate = (segments, ...schemas) => {
+  let routerPath = segments[0].replace(":", "::");
+  let uriPath = segments[0];
+  const params = {};
+  let pathSchema = Schema10.Tuple();
+  if (schemas.length > 0) {
+    const arr = [];
+    for (let i = 0;i < schemas.length; i++) {
+      const schema = schemas[i];
+      const segment = segments[i + 1];
+      const key = String(i);
+      arr.push(schema);
+      routerPath += `:${key}${segment.replace(":", "::")}`;
+      const paramName = AST2.getAnnotation(ParamAnnotation)(schema.ast).pipe(Option6.getOrElse(() => `param${key}`));
+      params[paramName] = schema;
+      uriPath += `{${paramName}}${segment}`;
+    }
+    pathSchema = Schema10.Tuple(...arr);
+  }
+  return {
+    routerPath,
+    uriPath,
+    schema: pathSchema,
+    params
+  };
+};
+var layerHandlers = (serverInfo) => ClientRpcs.toLayer(Effect9.gen(function* () {
+  const server = yield* McpServer;
+  return {
+    ping: () => Effect9.succeed({}),
+    initialize(params, { clientId }) {
+      const requestedVersion = params.protocolVersion;
+      const capabilities = {
+        completions: {}
+      };
+      if (server.tools.length > 0) {
+        capabilities.tools = { listChanged: true };
+      }
+      if (server.resources.length > 0 || server.resourceTemplates.length > 0) {
+        capabilities.resources = {
+          listChanged: true,
+          subscribe: false
+        };
+      }
+      if (server.prompts.length > 0) {
+        capabilities.prompts = { listChanged: true };
+      }
+      server.initializedClients.add(clientId);
+      return Effect9.succeed({
+        capabilities,
+        serverInfo,
+        protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION
+      });
+    },
+    "completion/complete": server.completion,
+    "logging/setLevel": () => InternalError.notImplemented,
+    "prompts/get": server.getPromptResult,
+    "prompts/list": () => Effect9.sync(() => new ListPromptsResult({ prompts: server.prompts })),
+    "resources/list": () => Effect9.sync(() => new ListResourcesResult({
+      resources: server.resources
+    })),
+    "resources/read": ({ uri }) => server.findResource(uri),
+    "resources/subscribe": () => InternalError.notImplemented,
+    "resources/unsubscribe": () => InternalError.notImplemented,
+    "resources/templates/list": () => Effect9.sync(() => new ListResourceTemplatesResult({
+      resourceTemplates: server.resourceTemplates
+    })),
+    "tools/call": server.callTool,
+    "tools/list": () => Effect9.sync(() => new ListToolsResult({ tools: server.tools })),
+    "notifications/cancelled": (_) => Effect9.void,
+    "notifications/initialized": (_) => Effect9.void,
+    "notifications/progress": (_) => Effect9.void,
+    "notifications/roots/list_changed": (_) => Effect9.void
+  };
+}));
+var makeJsonSchema = (ast) => {
+  const props = AST2.getPropertySignatures(ast);
+  if (props.length === 0) {
+    return {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  const $defs = {};
+  const schema = JsonSchema2.fromAST(ast, {
+    definitions: $defs,
+    topLevelReferenceStrategy: "skip"
+  });
+  if (Object.keys($defs).length === 0)
+    return schema;
+  schema.$defs = $defs;
+  return schema;
+};
+var resolveResourceContent = (uri, content) => {
+  if (typeof content === "string") {
+    return {
+      contents: [
+        {
+          uri,
+          text: content
+        }
+      ]
+    };
+  } else if (content instanceof Uint8Array) {
+    return {
+      contents: [
+        {
+          uri,
+          blob: content
+        }
+      ]
+    };
+  }
+  return content;
+};
+// packages/ariadne/src/Model.ts
+var exports_Model = {};
+__export(exports_Model, {
+  make: () => make19,
+  TypeId: () => TypeId5,
+  ProviderName: () => ProviderName
+});
+import * as Context11 from "effect/Context";
+import * as Effect10 from "effect/Effect";
+import { CommitPrototype as CommitPrototype2 } from "effect/Effectable";
+import { identity as identity4 } from "effect/Function";
+import * as Layer6 from "effect/Layer";
+var TypeId5 = "~@effect/ai/Model";
+
+class ProviderName extends Context11.Tag("@effect/ai/Model/ProviderName")() {
+}
+var ModelProto = {
+  ...CommitPrototype2,
+  [TypeId5]: TypeId5,
+  [Layer6.LayerTypeId]: {
+    _ROut: identity4,
+    _E: identity4,
+    _RIn: identity4
+  },
+  commit() {
+    return Effect10.contextWith((context5) => {
+      return Layer6.provide(this, Layer6.succeedContext(context5));
+    });
+  }
+};
+var make19 = (provider, layer3) => Object.assign(Object.create(ModelProto), { provider }, Layer6.merge(Layer6.succeed(ProviderName, provider), layer3));
+// packages/ariadne/src/Tokenizer.ts
+var exports_Tokenizer = {};
+__export(exports_Tokenizer, {
+  make: () => make20,
+  Tokenizer: () => Tokenizer
+});
+import * as Context12 from "effect/Context";
+import * as Effect11 from "effect/Effect";
+import * as Predicate10 from "effect/Predicate";
+class Tokenizer extends Context12.Tag("@effect/ai/Tokenizer")() {
+}
+var make20 = (options) => Tokenizer.of({
+  tokenize(input) {
+    return options.tokenize(make2(input));
+  },
+  truncate(input, tokens) {
+    return truncate(make2(input), options.tokenize, tokens);
+  }
+});
+var truncate = (self, tokenize, maxTokens) => Effect11.suspend(() => {
+  let count = 0;
+  let inputMessages = self.content;
+  let outputMessages = [];
+  const loop = Effect11.suspend(() => {
+    const message = inputMessages[inputMessages.length - 1];
+    if (Predicate10.isUndefined(message)) {
+      return Effect11.succeed(fromMessages(outputMessages));
+    }
+    inputMessages = inputMessages.slice(0, inputMessages.length - 1);
+    return Effect11.flatMap(tokenize(fromMessages([message])), (tokens) => {
+      count += tokens.length;
+      if (count > maxTokens) {
+        return Effect11.succeed(fromMessages(outputMessages));
+      }
+      outputMessages = [message, ...outputMessages];
+      return loop;
+    });
+  });
+  return loop;
+});
+export {
+  exports_Toolkit as Toolkit,
+  exports_Tool as Tool,
+  exports_Tokenizer as Tokenizer,
+  exports_Telemetry as Telemetry,
+  exports_Response as Response,
+  exports_Prompt as Prompt,
+  exports_Model as Model,
+  exports_McpServer as McpServer,
+  exports_McpSchema as McpSchema,
+  exports_McpRegistry as McpRegistry,
+  exports_LanguageModel as LanguageModel,
+  exports_IdGenerator as IdGenerator,
+  exports_EmbeddingModel as EmbeddingModel,
+  exports_Chat as Chat,
+  exports_AiError as AiError,
+  exports_AgentRunner as AgentRunner
+};