@anyr/ai-sdk-provider 0.1.0

package/dist/index.js

@@ -0,0 +1,739 @@
+'use strict';
+
+var providerUtils = require('@ai-sdk/provider-utils');
+var zod = require('zod');
+var provider = require('@ai-sdk/provider');
+var sdk = require('@anyr/sdk');
+
+// src/anyrouter-chat-language-model.ts
+function convertToAnyRouterChatMessages(prompt) {
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system":
+        messages.push({ role: "system", content: message.content });
+        break;
+      case "user":
+        messages.push(convertUserMessage(message));
+        break;
+      case "assistant":
+        messages.push(convertAssistantMessage(message));
+        break;
+      case "tool":
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            messages.push(convertToolResultMessage(part));
+          }
+        }
+        break;
+      default: {
+        const _exhaustive = message;
+        throw new Error(`Unsupported message role: ${_exhaustive.role}`);
+      }
+    }
+  }
+  return messages;
+}
+function convertUserMessage(message) {
+  if (message.content.length === 1 && message.content[0].type === "text") {
+    return { role: "user", content: message.content[0].text };
+  }
+  const parts = [];
+  for (const part of message.content) {
+    if (part.type === "text") {
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "file") {
+      const filePart = part;
+      const mediaType = filePart.mediaType;
+      const url = toDataUrlOrString(filePart.data, mediaType);
+      if (mediaType.startsWith("image/")) {
+        parts.push({ type: "image_url", image_url: { url } });
+      } else {
+        parts.push({ type: "file", file: { url, media_type: mediaType } });
+      }
+    } else {
+      const unknown = part;
+      throw new provider.UnsupportedFunctionalityError({
+        functionality: `User message part type: ${unknown.type ?? "unknown"}`
+      });
+    }
+  }
+  return { role: "user", content: parts };
+}
+function convertAssistantMessage(message) {
+  let text = "";
+  const toolCalls = [];
+  for (const part of message.content) {
+    switch (part.type) {
+      case "text":
+        text += part.text;
+        break;
+      case "tool-call": {
+        const tc = part;
+        toolCalls.push({
+          id: tc.toolCallId,
+          type: "function",
+          function: {
+            name: tc.toolName,
+            arguments: typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
+          }
+        });
+        break;
+      }
+    }
+  }
+  const result = {
+    role: "assistant",
+    content: text || null
+  };
+  if (toolCalls.length > 0) {
+    result.tool_calls = toolCalls;
+  }
+  return result;
+}
+function convertToolResultMessage(part) {
+  return {
+    role: "tool",
+    tool_call_id: part.toolCallId,
+    content: toolResultOutputToString(part.output)
+  };
+}
+function toolResultOutputToString(output) {
+  switch (output.type) {
+    case "text":
+      return output.value;
+    case "json":
+      return JSON.stringify(output.value);
+    case "error-text":
+      return output.value;
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "execution-denied":
+      return output.reason ?? "Tool execution denied.";
+    case "content": {
+      const segments = [];
+      for (const c of output.value) {
+        if (c.type === "text") {
+          segments.push(c.text);
+        } else {
+          segments.push(`[${c.type}]`);
+        }
+      }
+      return segments.join("\n");
+    }
+    default:
+      return JSON.stringify(output);
+  }
+}
+function toDataUrlOrString(data, mediaType) {
+  if (data instanceof URL) return data.toString();
+  if (typeof data === "string") {
+    if (data.startsWith("http") || data.startsWith("data:")) return data;
+    return `data:${mediaType};base64,${data}`;
+  }
+  return `data:${mediaType};base64,${uint8ArrayToBase64(data)}`;
+}
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+// src/anyrouter-chat-language-model.ts
+var anyRouterProviderOptionsSchema = zod.z.object({
+  /** Routing preference forwarded as `provider` in the request body. */
+  provider: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  /** Session ID forwarded as `session_id` in the request body. */
+  sessionId: zod.z.string().optional(),
+  /** Extra body fields merged in last (highest precedence). */
+  extraBody: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var anyRouterErrorSchema = zod.z.object({
+  error: zod.z.object({
+    code: zod.z.string().optional(),
+    message: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+  }).optional()
+});
+var completionUsageSchema = zod.z.object({
+  prompt_tokens: zod.z.number().optional(),
+  completion_tokens: zod.z.number().optional(),
+  total_tokens: zod.z.number().optional()
+});
+var toolCallSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  type: zod.z.literal("function").optional(),
+  function: zod.z.object({
+    name: zod.z.string().optional(),
+    arguments: zod.z.string().optional()
+  }).optional()
+});
+var toolCallDeltaSchema = zod.z.object({
+  index: zod.z.number(),
+  id: zod.z.string().optional(),
+  type: zod.z.literal("function").optional(),
+  function: zod.z.object({
+    name: zod.z.string().optional(),
+    arguments: zod.z.string().optional()
+  }).optional()
+});
+var messageSchema = zod.z.object({
+  content: zod.z.string().nullish(),
+  reasoning_content: zod.z.string().nullish(),
+  tool_calls: zod.z.array(toolCallSchema).optional()
+});
+var choiceSchema = zod.z.object({
+  message: messageSchema.optional(),
+  finish_reason: zod.z.string().nullish()
+});
+var generateResponseSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  model: zod.z.string().optional(),
+  choices: zod.z.array(choiceSchema).optional(),
+  usage: completionUsageSchema.optional()
+});
+var deltaSchema = zod.z.object({
+  content: zod.z.string().nullish(),
+  reasoning_content: zod.z.string().nullish(),
+  tool_calls: zod.z.array(toolCallDeltaSchema).optional()
+});
+var streamChoiceSchema = zod.z.object({
+  delta: deltaSchema.optional(),
+  finish_reason: zod.z.string().nullish()
+});
+var streamChunkSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  model: zod.z.string().optional(),
+  choices: zod.z.array(streamChoiceSchema).optional(),
+  usage: completionUsageSchema.optional()
+});
+function mapFinishReason(raw) {
+  switch (raw) {
+    case "stop":
+      return { unified: "stop", raw };
+    case "length":
+    case "max_tokens":
+      return { unified: "length", raw };
+    case "tool_calls":
+    case "function_call":
+      return { unified: "tool-calls", raw };
+    case "content_filter":
+      return { unified: "content-filter", raw };
+    default:
+      return { unified: "other", raw: raw ?? void 0 };
+  }
+}
+function buildUsage(raw) {
+  return {
+    inputTokens: {
+      total: raw?.prompt_tokens ?? void 0,
+      noCache: void 0,
+      cacheRead: void 0,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: raw?.completion_tokens ?? void 0,
+      text: void 0,
+      reasoning: void 0
+    }
+  };
+}
+function emitResponseMetadata(chunk, state, fallbackModelId, controller) {
+  if (state.metadataEmitted || !(chunk.id || chunk.model)) return;
+  state.metadataEmitted = true;
+  controller.enqueue({
+    type: "response-metadata",
+    id: chunk.id,
+    modelId: chunk.model ?? fallbackModelId
+  });
+}
+function emitTextDelta(content, state, controller) {
+  if (state.activeTextId === null) {
+    state.activeTextId = providerUtils.generateId();
+    controller.enqueue({ type: "text-start", id: state.activeTextId });
+  }
+  controller.enqueue({ type: "text-delta", id: state.activeTextId, delta: content });
+}
+function emitToolCallDeltas(toolCalls, acc, controller) {
+  for (const tcDelta of toolCalls) {
+    const idx = tcDelta.index;
+    if (!acc[idx]) acc[idx] = { id: "", name: "", arguments: "", started: false };
+    const entry = acc[idx];
+    if (tcDelta.id) entry.id = tcDelta.id;
+    if (tcDelta.function?.name) entry.name = tcDelta.function.name;
+    if (tcDelta.function?.arguments) entry.arguments += tcDelta.function.arguments;
+    const toolId = entry.id || `tool-${idx}`;
+    if (!entry.started && entry.name) {
+      entry.started = true;
+      controller.enqueue({ type: "tool-input-start", id: toolId, toolName: entry.name });
+    }
+    if (tcDelta.function?.arguments) {
+      controller.enqueue({
+        type: "tool-input-delta",
+        id: toolId,
+        delta: tcDelta.function.arguments
+      });
+    }
+  }
+}
+function emitFinish(choice, chunk, state, acc, controller) {
+  if (state.activeTextId !== null) {
+    controller.enqueue({ type: "text-end", id: state.activeTextId });
+    state.activeTextId = null;
+  }
+  for (const [idxStr, entry] of Object.entries(acc)) {
+    if (!entry.started) continue;
+    const toolId = entry.id || `tool-${idxStr}`;
+    controller.enqueue({ type: "tool-input-end", id: toolId });
+    controller.enqueue({
+      type: "tool-call",
+      toolCallId: toolId,
+      toolName: entry.name,
+      input: entry.arguments
+    });
+  }
+  controller.enqueue({
+    type: "finish",
+    usage: buildUsage(chunk.usage),
+    finishReason: mapFinishReason(choice.finish_reason)
+  });
+}
+function mapToolChoice(toolChoice) {
+  if (!toolChoice) return void 0;
+  switch (toolChoice.type) {
+    case "auto":
+      return "auto";
+    case "none":
+      return "none";
+    case "required":
+      return "required";
+    case "tool":
+      return { type: "function", function: { name: toolChoice.toolName } };
+  }
+}
+function buildResponseFormat(responseFormat) {
+  if (!responseFormat) return void 0;
+  if (responseFormat.type === "text") return { type: "text" };
+  if (responseFormat.type === "json") {
+    if (responseFormat.schema) {
+      return {
+        type: "json_schema",
+        json_schema: {
+          name: responseFormat.name ?? "response",
+          description: responseFormat.description,
+          schema: responseFormat.schema,
+          strict: true
+        }
+      };
+    }
+    return { type: "json_object" };
+  }
+  return void 0;
+}
+function buildTools(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  const fns = tools.filter((t) => t.type === "function").map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema,
+      strict: t.strict
+    }
+  }));
+  return fns.length > 0 ? fns : void 0;
+}
+function buildRequestBody(modelId, options, settings, stream, perCallOptions) {
+  const messages = convertToAnyRouterChatMessages(options.prompt);
+  const responseFormat = buildResponseFormat(options.responseFormat);
+  const tools = buildTools(options.tools);
+  const toolChoice = mapToolChoice(options.toolChoice);
+  const provider = perCallOptions.provider ?? settings.provider;
+  const sessionId = perCallOptions.sessionId ?? settings.sessionId;
+  const extraBody = { ...settings.extraBody, ...perCallOptions.extraBody };
+  const body = {
+    model: modelId,
+    messages,
+    ...stream ? { stream: true, stream_options: { include_usage: true } } : {},
+    max_tokens: options.maxOutputTokens,
+    temperature: options.temperature,
+    top_p: options.topP,
+    top_k: options.topK,
+    stop: options.stopSequences,
+    frequency_penalty: options.frequencyPenalty,
+    presence_penalty: options.presencePenalty,
+    seed: options.seed,
+    response_format: responseFormat,
+    tools,
+    tool_choice: toolChoice,
+    provider: provider ?? void 0,
+    session_id: sessionId ?? void 0,
+    ...extraBody
+  };
+  for (const key of Object.keys(body)) {
+    if (body[key] === void 0) delete body[key];
+  }
+  return body;
+}
+var AnyRouterChatLanguageModel = class {
+  specificationVersion = "v3";
+  provider;
+  modelId;
+  supportedUrls = {};
+  config;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.provider = config.provider;
+    this.config = config;
+  }
+  // ─── doGenerate ─────────────────────────────────────────────────────────
+  async doGenerate(options) {
+    const perCallOptions = await providerUtils.parseProviderOptions({
+      provider: "anyrouter",
+      providerOptions: options.providerOptions,
+      schema: anyRouterProviderOptionsSchema
+    }) ?? {};
+    const body = buildRequestBody(
+      this.modelId,
+      options,
+      this.config.settings,
+      false,
+      perCallOptions
+    );
+    const { value: response, responseHeaders } = await providerUtils.postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
+        errorSchema: anyRouterErrorSchema,
+        errorToMessage: (data) => data.error?.message ?? "AnyRouter API error",
+        isRetryable: (response2) => response2.status >= 500
+      }),
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(generateResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices?.[0];
+    const message = choice?.message;
+    const content = [];
+    if (message?.content) {
+      content.push({ type: "text", text: message.content });
+    }
+    if (message?.tool_calls && message.tool_calls.length > 0) {
+      for (const tc of message.tool_calls) {
+        if (tc.id && tc.function?.name) {
+          content.push({
+            type: "tool-call",
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            input: tc.function.arguments ?? "{}"
+          });
+        }
+      }
+    }
+    return {
+      content,
+      finishReason: mapFinishReason(choice?.finish_reason),
+      usage: buildUsage(response.usage),
+      warnings: [],
+      request: { body },
+      response: {
+        id: response.id,
+        modelId: response.model,
+        headers: responseHeaders
+      }
+    };
+  }
+  // ─── doStream ───────────────────────────────────────────────────────────
+  async doStream(options) {
+    const perCallOptions = await providerUtils.parseProviderOptions({
+      provider: "anyrouter",
+      providerOptions: options.providerOptions,
+      schema: anyRouterProviderOptionsSchema
+    }) ?? {};
+    const body = buildRequestBody(this.modelId, options, this.config.settings, true, perCallOptions);
+    const { value: stream, responseHeaders } = await providerUtils.postJsonToApi({
+      url: `${this.config.baseURL}/chat/completions`,
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
+        errorSchema: anyRouterErrorSchema,
+        errorToMessage: (data) => data.error?.message ?? "AnyRouter API error",
+        isRetryable: (response) => response.status >= 500
+      }),
+      successfulResponseHandler: providerUtils.createEventSourceResponseHandler(streamChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCallAccumulator = {};
+    const state = { activeTextId: null, metadataEmitted: false };
+    const selfModelId = this.modelId;
+    const transformStream = new TransformStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+      },
+      transform(chunkResult, controller) {
+        if (!chunkResult.success) {
+          controller.enqueue({ type: "error", error: chunkResult.error });
+          return;
+        }
+        const chunk = chunkResult.value;
+        const choice = chunk.choices?.[0];
+        emitResponseMetadata(chunk, state, selfModelId, controller);
+        const delta = choice?.delta;
+        if (delta) {
+          if (typeof delta.content === "string" && delta.content.length > 0) {
+            emitTextDelta(delta.content, state, controller);
+          }
+          if (delta.tool_calls) {
+            emitToolCallDeltas(delta.tool_calls, toolCallAccumulator, controller);
+          }
+        }
+        if (choice?.finish_reason) {
+          emitFinish(choice, chunk, state, toolCallAccumulator, controller);
+        }
+      },
+      flush(controller) {
+        if (state.activeTextId !== null) {
+          controller.enqueue({ type: "text-end", id: state.activeTextId });
+        }
+      }
+    });
+    return {
+      stream: stream.pipeThrough(transformStream),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+var anyRouterErrorSchema2 = zod.z.object({
+  error: zod.z.object({
+    code: zod.z.string().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+var embeddingResponseSchema = zod.z.object({
+  data: zod.z.array(
+    zod.z.object({
+      embedding: zod.z.array(zod.z.number())
+    })
+  ),
+  usage: zod.z.object({
+    prompt_tokens: zod.z.number().optional(),
+    total_tokens: zod.z.number().optional()
+  }).optional()
+});
+var AnyRouterEmbeddingModel = class {
+  specificationVersion = "v3";
+  provider;
+  modelId;
+  /** No hard per-call limit imposed by the provider layer. */
+  maxEmbeddingsPerCall = void 0;
+  supportsParallelCalls = true;
+  config;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.provider = config.provider;
+    this.config = config;
+  }
+  async doEmbed(options) {
+    const { value: response } = await providerUtils.postJsonToApi({
+      url: `${this.config.baseURL}/embeddings`,
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body: {
+        model: this.modelId,
+        input: options.values
+      },
+      failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
+        errorSchema: anyRouterErrorSchema2,
+        errorToMessage: (data) => data.error?.message ?? "AnyRouter embeddings API error",
+        isRetryable: (response2) => response2.status >= 500
+      }),
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(embeddingResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const embeddings = response.data.map((d) => d.embedding);
+    const tokens = response.usage?.prompt_tokens ?? response.usage?.total_tokens;
+    return {
+      embeddings,
+      usage: tokens !== void 0 ? { tokens } : void 0,
+      warnings: []
+    };
+  }
+};
+var anyRouterErrorSchema3 = zod.z.object({
+  error: zod.z.object({
+    code: zod.z.string().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+var imageGenerationResponseSchema = zod.z.object({
+  created: zod.z.number().optional(),
+  data: zod.z.array(
+    zod.z.object({
+      url: zod.z.string().optional(),
+      b64_json: zod.z.string().optional(),
+      revised_prompt: zod.z.string().optional()
+    })
+  )
+});
+var AnyRouterImageModel = class {
+  specificationVersion = "v3";
+  provider;
+  modelId;
+  /**
+   * Most image generation APIs support only 1 image per call via the
+   * standard `/images/generations` endpoint.
+   */
+  maxImagesPerCall = 1;
+  config;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.provider = config.provider;
+    this.config = config;
+  }
+  async doGenerate(options) {
+    if (options.mask) {
+      throw new provider.UnsupportedFunctionalityError({
+        functionality: "mask (inpainting) for AnyRouter image generation"
+      });
+    }
+    const warnings = [];
+    if (options.n > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: `n=${options.n} (AnyRouter image endpoint supports n=1 per call)`
+      });
+    }
+    const body = {
+      model: this.modelId,
+      prompt: options.prompt ?? "",
+      n: Math.min(options.n, 1),
+      ...options.size ? { size: options.size } : {},
+      ...options.seed !== void 0 ? { seed: options.seed } : {},
+      response_format: "b64_json"
+    };
+    const { value: response, responseHeaders } = await providerUtils.postJsonToApi({
+      url: `${this.config.baseURL}/images/generations`,
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
+        errorSchema: anyRouterErrorSchema3,
+        errorToMessage: (data) => data.error?.message ?? "AnyRouter images API error",
+        isRetryable: (res) => res.status >= 500
+      }),
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(imageGenerationResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const images = [];
+    for (const item of response.data) {
+      if (item.b64_json) {
+        images.push(item.b64_json);
+      } else if (item.url) {
+        images.push(item.url);
+      }
+    }
+    return {
+      images,
+      warnings,
+      response: {
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId,
+        headers: responseHeaders
+      }
+    };
+  }
+};
+var PROVIDER_ID = "anyrouter";
+function createAnyRouter(options = {}) {
+  const baseURL = providerUtils.withoutTrailingSlash(options.baseURL ?? sdk.DEFAULT_BASE_URL) ?? sdk.DEFAULT_BASE_URL;
+  function getHeaders() {
+    const apiKey = providerUtils.loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: "ANYROUTER_API_KEY",
+      description: "AnyRouter"
+    });
+    return providerUtils.combineHeaders({ Authorization: `Bearer ${apiKey}` }, options.headers);
+  }
+  function chatModel(modelId) {
+    return new AnyRouterChatLanguageModel(modelId, {
+      provider: PROVIDER_ID,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      settings: options
+    });
+  }
+  function embeddingModel(modelId) {
+    return new AnyRouterEmbeddingModel(modelId, {
+      provider: PROVIDER_ID,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    });
+  }
+  function imageModel(modelId) {
+    return new AnyRouterImageModel(modelId, {
+      provider: PROVIDER_ID,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    });
+  }
+  const provider$1 = (modelId) => chatModel(modelId);
+  const providerObj = Object.assign(provider$1, {
+    // ProviderV3 required fields
+    specificationVersion: "v3",
+    // ProviderV3 required methods
+    languageModel(modelId) {
+      return chatModel(modelId);
+    },
+    embeddingModel(modelId) {
+      return embeddingModel(modelId);
+    },
+    imageModel(modelId) {
+      return imageModel(modelId);
+    },
+    // ProviderV3 optional methods (deprecated textEmbeddingModel alias)
+    textEmbeddingModel(modelId) {
+      return embeddingModel(modelId);
+    },
+    // AnyRouter convenience alias
+    chat(modelId) {
+      return chatModel(modelId);
+    },
+    // Unsupported model types — throw NoSuchModelError per ProviderV3 contract
+    transcriptionModel(modelId) {
+      throw new provider.NoSuchModelError({ modelId, modelType: "transcriptionModel" });
+    },
+    speechModel(modelId) {
+      throw new provider.NoSuchModelError({ modelId, modelType: "speechModel" });
+    }
+  });
+  Object.defineProperty(providerObj, "client", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      return new sdk.AnyRouter({
+        apiKey: options.apiKey,
+        baseURL: options.baseURL,
+        headers: options.headers,
+        fetch: options.fetch
+      });
+    }
+  });
+  return providerObj;
+}
+var anyrouter = createAnyRouter();
+
+exports.AnyRouterChatLanguageModel = AnyRouterChatLanguageModel;
+exports.AnyRouterEmbeddingModel = AnyRouterEmbeddingModel;
+exports.AnyRouterImageModel = AnyRouterImageModel;
+exports.anyrouter = anyrouter;
+exports.createAnyRouter = createAnyRouter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map