@orcarouter/mcp 1.1.2

package/dist/index.js

@@ -0,0 +1,736 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+
+// src/errors.ts
+var ApiError = class extends Error {
+  status;
+  body;
+  constructor(message, status, body, options) {
+    super(message, options);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var AuthenticationError = class extends ApiError {
+  constructor(message, body) {
+    super(message, 401, body);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionDeniedError = class extends ApiError {
+  constructor(message, body) {
+    super(message, 403, body);
+    this.name = "PermissionDeniedError";
+  }
+};
+var InsufficientQuotaError = class extends ApiError {
+  constructor(message, status, body) {
+    super(message, status, body);
+    this.name = "InsufficientQuotaError";
+  }
+};
+var RequestCancelledError = class extends Error {
+  constructor(message = "OrcaRouter request cancelled by caller.", options) {
+    super(message, options);
+    this.name = "AbortError";
+  }
+};
+var RateLimitError = class extends ApiError {
+  retryAfter;
+  constructor(message, retryAfter, body) {
+    super(message, 429, body);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var InternalServerError = class extends ApiError {
+  constructor(message, status, body) {
+    super(message, status, body);
+    this.name = "InternalServerError";
+  }
+};
+var MissingApiKeyError = class extends Error {
+  constructor(toolName) {
+    super(
+      `ORCAROUTER_API_KEY is required for tool "${toolName}". Set the ORCAROUTER_API_KEY environment variable when launching the MCP server.`
+    );
+    this.name = "MissingApiKeyError";
+  }
+};
+
+// src/version.ts
+var PACKAGE_VERSION = "1.1.2";
+
+// src/api_client.ts
+var DEFAULT_BASE_URL = "https://api.orcarouter.ai";
+var DEFAULT_TIMEOUT_MS = 3e5;
+var USER_AGENT = `@orcarouter/mcp/${PACKAGE_VERSION} (Node.js)`;
+var ApiClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  fetchImpl;
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.timeoutMs = typeof opts.timeoutMs === "number" && opts.timeoutMs > 0 ? opts.timeoutMs : DEFAULT_TIMEOUT_MS;
+  }
+  get(path, opts = {}) {
+    return this.request("GET", path, void 0, opts);
+  }
+  post(path, body, opts = {}) {
+    return this.request("POST", path, body, opts);
+  }
+  async raw(method, path, body, opts = {}) {
+    const url = this.buildUrl(path, opts.query);
+    const headers = this.buildHeaders(body !== void 0, opts.headers);
+    const externalSignal = opts.signal;
+    const { signal, cancel, didTimeout } = this.makeTimeoutSignal(externalSignal);
+    const init = {
+      method,
+      headers,
+      signal
+    };
+    if (body !== void 0) {
+      init.body = typeof body === "string" ? body : JSON.stringify(body);
+    }
+    try {
+      return await this.fetchImpl(url, init);
+    } catch (e) {
+      if (didTimeout()) {
+        throw new Error(
+          `OrcaRouter request timed out after ${this.timeoutMs}ms (${method} ${path}).`
+        );
+      }
+      if (externalSignal?.aborted || signal.aborted) {
+        throw new RequestCancelledError(
+          `OrcaRouter request cancelled by caller (${method} ${path}).`,
+          { cause: e }
+        );
+      }
+      if (this.isAbortError(e)) {
+        throw new RequestCancelledError(
+          `OrcaRouter request cancelled by caller (${method} ${path}).`,
+          { cause: e }
+        );
+      }
+      throw e;
+    } finally {
+      cancel();
+    }
+  }
+  isAbortError(e) {
+    if (!e || typeof e !== "object") return false;
+    const name = e.name;
+    return name === "AbortError" || name === "TimeoutError";
+  }
+  makeTimeoutSignal(external) {
+    const controller = new AbortController();
+    let didTimeoutFlag = false;
+    const timer = setTimeout(() => {
+      didTimeoutFlag = true;
+      controller.abort(new Error("OrcaRouter request timeout"));
+    }, this.timeoutMs);
+    const onExternalAbort = () => controller.abort(external?.reason);
+    if (external) {
+      if (external.aborted) {
+        controller.abort(external.reason);
+      } else {
+        external.addEventListener("abort", onExternalAbort, { once: true });
+      }
+    }
+    const cancel = () => {
+      clearTimeout(timer);
+      if (external) external.removeEventListener("abort", onExternalAbort);
+    };
+    const didTimeout = () => didTimeoutFlag;
+    return { signal: controller.signal, cancel, didTimeout };
+  }
+  async request(method, path, body, opts) {
+    const response = await this.raw(method, path, body, opts);
+    if (!response.ok) {
+      await this.throwForStatus(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  buildUrl(path, query) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(this.baseUrl + normalizedPath);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0 || value === null) continue;
+        url.searchParams.append(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(hasBody, extra) {
+    const headers = new Headers();
+    if (this.apiKey) {
+      headers.set("Authorization", `Bearer ${this.apiKey}`);
+    }
+    headers.set("Accept", "application/json");
+    headers.set("User-Agent", USER_AGENT);
+    if (hasBody) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (extra) {
+      for (const [k, v] of Object.entries(extra)) {
+        headers.set(k, v);
+      }
+    }
+    return headers;
+  }
+  async throwForStatus(response) {
+    const status = response.status;
+    let bodyText = "";
+    let parsed = void 0;
+    try {
+      bodyText = await response.text();
+      if (bodyText) {
+        try {
+          parsed = JSON.parse(bodyText);
+        } catch {
+          parsed = void 0;
+        }
+      }
+    } catch {
+    }
+    const message = extractErrorMessage(parsed) ?? (bodyText || response.statusText);
+    if ((status === 402 || status === 403) && hasInsufficientQuotaCode(parsed)) {
+      throw new InsufficientQuotaError(message, status, parsed);
+    }
+    if (status === 401) {
+      throw new AuthenticationError(message, parsed);
+    }
+    if (status === 403) {
+      throw new PermissionDeniedError(message, parsed);
+    }
+    if (status === 429) {
+      throw new RateLimitError(
+        message,
+        parseRetryAfter(response.headers.get("retry-after")),
+        parsed
+      );
+    }
+    if (status >= 500) {
+      throw new InternalServerError(message, status, parsed);
+    }
+    throw new ApiError(message, status, parsed);
+  }
+};
+function parseRetryAfter(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber)) {
+    return asNumber;
+  }
+  const asDate = Date.parse(trimmed);
+  if (Number.isFinite(asDate)) {
+    return Math.max(0, Math.round((asDate - Date.now()) / 1e3));
+  }
+  return void 0;
+}
+function hasInsufficientQuotaCode(body) {
+  if (!body || typeof body !== "object") return false;
+  const codes = /* @__PURE__ */ new Set(["insufficient_quota", "insufficient_user_quota"]);
+  const b = body;
+  if (typeof b.code === "string" && codes.has(b.code)) return true;
+  if (b.error && typeof b.error === "object") {
+    const inner = b.error;
+    if (typeof inner.code === "string" && codes.has(inner.code)) return true;
+  }
+  return false;
+}
+function extractErrorMessage(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (typeof b.message === "string") return b.message;
+  if (b.error && typeof b.error === "object") {
+    const inner = b.error;
+    if (typeof inner.message === "string") return inner.message;
+  }
+  if (typeof b.error === "string") return b.error;
+  return void 0;
+}
+
+// src/tools/types.ts
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/chat.ts
+var DEFAULT_MODEL = "orcarouter/auto";
+var DEFAULT_TEMPERATURE = 0.7;
+var DEFAULT_MAX_TOKENS = 2e3;
+function isReasoningModel(modelId) {
+  const bare = modelId.split("/").pop() ?? modelId;
+  return /^(gpt-5|o[1-9])([-.]|$)/i.test(bare);
+}
+function stringifyContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = content.map((p) => {
+      if (typeof p === "string") return p;
+      if (p && typeof p === "object") {
+        const pp = p;
+        if (pp.type === "text" && typeof pp.text === "string") return pp.text;
+      }
+      return "";
+    }).filter(Boolean);
+    if (parts.length > 0) return parts.join("\n");
+  }
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+var chatTool = {
+  name: "orcarouter_chat",
+  description: "Send a single-turn chat request to OrcaRouter. Default model is the workspace's auto-router. Use `orcarouter/<name>` for other routers or `<provider>/<model>` for direct calls. For OpenAI reasoning models (gpt-5/o1/o3/...), max_tokens is automatically routed to max_completion_tokens at the wire level.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      model: {
+        type: "string",
+        default: DEFAULT_MODEL,
+        description: "Model to call. Defaults to `orcarouter/auto` \u2014 your workspace's seeded auto-router. Use `orcarouter/<name>` for other workspace routers, or `<provider>/<model>` for direct upstream selection (e.g. `openai/gpt-4o-mini`, `anthropic/claude-haiku-4.5`)."
+      },
+      prompt: {
+        type: "string",
+        description: "User message to send (single-turn)."
+      },
+      system_prompt: {
+        type: "string",
+        description: "Optional system prompt prepended to the conversation."
+      },
+      max_tokens: {
+        type: "integer",
+        default: DEFAULT_MAX_TOKENS,
+        description: "Maximum tokens to generate (default 2000). Automatically translated to max_completion_tokens for OpenAI reasoning models."
+      },
+      temperature: {
+        type: "number",
+        default: DEFAULT_TEMPERATURE,
+        description: "Sampling temperature (default 0.7)."
+      },
+      models: {
+        type: "array",
+        items: { type: "string" },
+        minItems: 1,
+        maxItems: 5,
+        description: "Optional fallback chain. Models are tried in order if the primary fails. Max 5 entries including the primary."
+      }
+    },
+    required: ["prompt"],
+    additionalProperties: false
+  },
+  async handler(input, { client }) {
+    if (!client.apiKey) {
+      throw new MissingApiKeyError("orcarouter_chat");
+    }
+    const rawModel = typeof input.model === "string" ? input.model.trim() : "";
+    const effectiveModel = rawModel.length > 0 ? rawModel : DEFAULT_MODEL;
+    if (typeof input.prompt !== "string" || input.prompt.length === 0) {
+      throw new ValidationError("prompt must be a non-empty string");
+    }
+    if (input.system_prompt !== void 0 && (typeof input.system_prompt !== "string" || input.system_prompt.length === 0)) {
+      throw new ValidationError(
+        "system_prompt must be a non-empty string when provided"
+      );
+    }
+    const effectiveMessages = typeof input.system_prompt === "string" ? [
+      { role: "system", content: input.system_prompt },
+      { role: "user", content: input.prompt }
+    ] : [{ role: "user", content: input.prompt }];
+    let effectiveModels;
+    if (input.models !== void 0) {
+      if (!Array.isArray(input.models) || input.models.length === 0) {
+        throw new ValidationError(
+          "models must be a non-empty array of model slug strings"
+        );
+      }
+      if (input.models.some((m) => typeof m !== "string" || m.length === 0)) {
+        throw new ValidationError("each entry in models must be a non-empty string");
+      }
+      const chain = [
+        effectiveModel,
+        ...input.models.filter((m) => m !== effectiveModel)
+      ];
+      if (chain.length > 5) {
+        throw new ValidationError(
+          "the effective fallback chain (primary model + models) must not exceed 5 entries; reduce the models array or omit the primary from it"
+        );
+      }
+      if (chain.length >= 2) {
+        effectiveModels = chain;
+      }
+    }
+    if (input.stream === true) {
+      throw new ValidationError(
+        "stream:true is not supported via MCP tools \u2014 MCP returns a single result. Set stream:false or omit."
+      );
+    }
+    const effectiveTemperature = typeof input.temperature === "number" ? input.temperature : DEFAULT_TEMPERATURE;
+    const effectiveMaxTokens = typeof input.max_tokens === "number" ? input.max_tokens : DEFAULT_MAX_TOKENS;
+    const body = {
+      model: effectiveModel,
+      messages: effectiveMessages,
+      stream: false,
+      temperature: effectiveTemperature
+    };
+    if (isReasoningModel(effectiveModel)) {
+      body.max_completion_tokens = effectiveMaxTokens;
+    } else {
+      body.max_tokens = effectiveMaxTokens;
+    }
+    if (effectiveModels && effectiveModels.length > 0) {
+      body.extra_body = { models: effectiveModels, route: "fallback" };
+    }
+    const data = await client.post("/v1/chat/completions", body);
+    const choice = data.choices?.[0];
+    const content = choice?.message?.content;
+    const text = stringifyContent(content ?? "");
+    return textResult(text);
+  }
+};
+
+// src/tools/model_card.ts
+function errorResult(text) {
+  return { isError: true, content: [{ type: "text", text }] };
+}
+var modelCardTool = {
+  name: "orcarouter_model_card",
+  description: "Get detailed information about a single model: pricing, context window, supported endpoints, latency.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      model: {
+        type: "string",
+        description: "Model ref in `provider/slug` form (e.g. `openai/gpt-4o-mini`, `anthropic/claude-haiku-4.5`). Use the exact `id` value returned by orcarouter_models_list."
+      }
+    },
+    required: ["model"],
+    additionalProperties: false
+  },
+  async handler(input, { client }) {
+    if (typeof input.model !== "string" || input.model.trim().length === 0) {
+      throw new ValidationError("model must be a non-empty string");
+    }
+    const ref = input.model.trim();
+    const slashIdx = ref.indexOf("/");
+    let urlPath;
+    if (slashIdx === -1) {
+      urlPath = `/api/public/models/${encodeURIComponent(ref)}`;
+    } else if (slashIdx === 0 || slashIdx === ref.length - 1) {
+      throw new ValidationError(
+        `model must not start or end with '/'; got: ${input.model}`
+      );
+    } else {
+      const provider = encodeURIComponent(ref.slice(0, slashIdx));
+      const slug = encodeURIComponent(ref.slice(slashIdx + 1));
+      urlPath = `/api/public/models/${provider}/${slug}`;
+    }
+    let body;
+    try {
+      body = await client.get(urlPath);
+    } catch (e) {
+      if (e instanceof ApiError) {
+        const msg = e.message || "";
+        if (e.status === 404 || /not found/i.test(msg)) {
+          return errorResult(
+            `Model not found: ${ref}. Check the model id, or use orcarouter_models_list to discover available models.`
+          );
+        }
+        return errorResult(
+          `Failed to fetch model card for ${ref}: ${msg || `HTTP ${e.status}`}`
+        );
+      }
+      throw e instanceof Error ? new Error(`Failed to fetch model card for ${ref}: ${e.message}`, {
+        cause: e
+      }) : e;
+    }
+    if (body == null || body.success === false || body.data == null) {
+      const msg = body && body.message || "";
+      if (/not found/i.test(msg) || msg === "") {
+        return errorResult(
+          `Model not found: ${ref}. Check the model id, or use orcarouter_models_list to discover available models.`
+        );
+      }
+      return errorResult(`Failed to fetch model card for ${ref}: ${msg}`);
+    }
+    const summary = `Model card for ${ref}:`;
+    const json = JSON.stringify(body.data, null, 2);
+    return textResult(`${summary}
+
+${json}`);
+  }
+};
+
+// src/tools/models_list.ts
+var modelsListTool = {
+  name: "orcarouter_models_list",
+  description: "List available LLM models. Filter by provider, capability, or minimum context length \u2014 filters are applied server-side by the OrcaRouter backend.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      provider: {
+        type: "string",
+        description: "Provider id (lowercase, e.g. 'openai', 'anthropic'). Get the full list via orcarouter_providers_list."
+      },
+      capability: {
+        type: "string",
+        enum: ["chat", "embedding", "image", "audio"],
+        description: "Filter to models supporting this capability."
+      },
+      min_context: {
+        type: "integer",
+        minimum: 1,
+        description: "Filter to models with context window at least this large (tokens)."
+      }
+    },
+    additionalProperties: false
+  },
+  async handler(input, { client }) {
+    const query = {};
+    if (typeof input.provider === "string" && input.provider.trim()) {
+      query.provider = input.provider.trim().toLowerCase();
+    }
+    if (typeof input.capability === "string" && input.capability.trim()) {
+      query.capability = input.capability.trim().toLowerCase();
+    }
+    if (typeof input.min_context === "number" && input.min_context > 0) {
+      query.min_context = String(input.min_context);
+    }
+    const data = await client.get("/v1/models", { query });
+    const all = Array.isArray(data.data) ? data.data : [];
+    if (all.length === 0) {
+      const activeFilters = [];
+      if (query.provider) activeFilters.push(`provider=${query.provider}`);
+      if (query.capability) activeFilters.push(`capability=${query.capability}`);
+      if (query.min_context) activeFilters.push(`min_context=${query.min_context}`);
+      const hint = activeFilters.length > 0 ? `No models match: ${activeFilters.join(", ")}` : `No models currently available.`;
+      return textResult(hint);
+    }
+    const summary = `Found ${all.length} model${all.length === 1 ? "" : "s"}:`;
+    const json = JSON.stringify(all, null, 2);
+    return textResult(`${summary}
+
+${json}`);
+  }
+};
+
+// src/tools/providers_list.ts
+function errorResult2(text) {
+  return { isError: true, content: [{ type: "text", text }] };
+}
+var providersListTool = {
+  name: "orcarouter_providers_list",
+  description: "List all model providers on OrcaRouter with their model counts and display metadata. Works without an API key. Useful for discovering provider ids (e.g. 'openai', 'anthropic') to pass to orcarouter_models_list as the `provider` filter.",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  },
+  async handler(_input, { client }) {
+    let body;
+    try {
+      body = await client.get("/api/public/providers");
+    } catch (e) {
+      if (e instanceof ApiError) {
+        if (e.status === 404) {
+          return errorResult2(
+            "This OrcaRouter deployment does not expose provider discovery. Use orcarouter_models_list to discover available models."
+          );
+        }
+        return errorResult2(
+          `Failed to fetch providers: ${e.message || `HTTP ${e.status}`}`
+        );
+      }
+      throw e instanceof Error ? new Error(`Failed to fetch providers: ${e.message}`, { cause: e }) : e;
+    }
+    if (body == null || body.success === false || body.data == null) {
+      const msg = body && body.message || "unknown";
+      return errorResult2(`Failed to fetch providers: ${msg}`);
+    }
+    if (!Array.isArray(body.data.providers)) {
+      return errorResult2(
+        `Invalid response from OrcaRouter: 'providers' field is not an array.`
+      );
+    }
+    const providers = body.data.providers;
+    const summary = `Found ${providers.length} providers:`;
+    const json = JSON.stringify(body.data, null, 2);
+    return textResult(`${summary}
+
+${json}`);
+  }
+};
+
+// src/server.ts
+var TOOLS = [
+  chatTool,
+  modelsListTool,
+  modelCardTool,
+  providersListTool
+];
+function buildValidators() {
+  const AjvCtor = Ajv.default ?? Ajv;
+  const addFmt = addFormats.default ?? addFormats;
+  const ajv = new AjvCtor({ allErrors: true, strict: false });
+  addFmt(ajv);
+  const map = /* @__PURE__ */ new Map();
+  for (const t of TOOLS) {
+    map.set(t.name, ajv.compile(t.inputSchema));
+  }
+  return map;
+}
+function createOrcaRouterMcpServer(opts = {}) {
+  const client = new ApiClient({
+    apiKey: opts.apiKey,
+    baseUrl: opts.baseUrl,
+    timeoutMs: opts.timeoutMs
+  });
+  const ctx = {
+    client
+  };
+  const validators = buildValidators();
+  const server = new Server(
+    {
+      name: opts.serverName ?? "@orcarouter/mcp",
+      version: opts.serverVersion ?? "1.1.2"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: TOOLS.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const name = req.params.name;
+    const args = req.params.arguments ?? {};
+    const tool = TOOLS.find((t) => t.name === name);
+    if (!tool) {
+      return {
+        isError: true,
+        content: [
+          { type: "text", text: `Unknown tool: ${name}` }
+        ]
+      };
+    }
+    const validate = validators.get(name);
+    if (validate && !validate(args)) {
+      return {
+        isError: true,
+        content: [
+          { type: "text", text: `Invalid input: ${formatAjvErrors(validate)}` }
+        ]
+      };
+    }
+    try {
+      const result = await tool.handler(args, ctx);
+      return result;
+    } catch (e) {
+      const msg = formatToolError(e);
+      return {
+        isError: true,
+        content: [{ type: "text", text: msg }]
+      };
+    }
+  });
+  return { server, client };
+}
+function formatAjvErrors(validate) {
+  const errs = validate.errors ?? [];
+  if (errs.length === 0) return "schema validation failed";
+  return errs.map((e) => {
+    const path = e.instancePath || "(root)";
+    const detail = e.keyword === "additionalProperties" && e.params && "additionalProperty" in e.params ? `unexpected property '${e.params.additionalProperty}'` : e.message ?? "invalid";
+    return `${path} ${detail}`;
+  }).join("; ");
+}
+function formatToolError(err) {
+  if (err instanceof MissingApiKeyError) return err.message;
+  if (err instanceof ValidationError) return `Invalid input: ${err.message}`;
+  if (err instanceof RateLimitError) {
+    const seconds = err.retryAfter;
+    if (typeof seconds === "number" && Number.isFinite(seconds)) {
+      return `OrcaRouter rate limited (429). Retry after ${seconds} seconds.`;
+    }
+    return `OrcaRouter rate limited (429). Retry shortly.`;
+  }
+  if (err instanceof InsufficientQuotaError) {
+    return "OrcaRouter quota exhausted. Top up at https://orcarouter.ai/console/billing.";
+  }
+  if (err instanceof PermissionDeniedError) {
+    return `OrcaRouter permission denied (403): ${err.message}`;
+  }
+  if (err instanceof ApiError) {
+    return `OrcaRouter API error (${err.status}): ${err.message}`;
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/index.ts
+async function main() {
+  const apiKey = process.env.ORCAROUTER_API_KEY?.trim() || void 0;
+  const baseUrl = process.env.ORCAROUTER_BASE_URL?.trim() || void 0;
+  const timeoutRaw = process.env.ORCAROUTER_REQUEST_TIMEOUT?.trim();
+  let timeoutMs;
+  if (timeoutRaw) {
+    const parsedSeconds = Number(timeoutRaw);
+    if (Number.isFinite(parsedSeconds) && parsedSeconds > 0) {
+      timeoutMs = parsedSeconds * 1e3;
+    }
+  }
+  const { server } = createOrcaRouterMcpServer({
+    apiKey,
+    baseUrl,
+    timeoutMs
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(
+    `[orcarouter-mcp] fatal: ${err instanceof Error ? err.message : String(err)}
+`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map