@drumcode/runner 0.1.0

package/dist/chunk-VYYR5EI4.mjs

@@ -0,0 +1,1061 @@
+// src/runner.ts
+import { CORE_TOOLSET, redactSecrets } from "@drumcode/core";
+var DrumcodeRunner = class {
+  options;
+  toolCache = /* @__PURE__ */ new Map();
+  skillCache = /* @__PURE__ */ new Map();
+  manifestCache = null;
+  authContext = {
+    isAuthenticated: false,
+    projectId: null,
+    tokenId: null,
+    tokenName: null,
+    profileId: null
+  };
+  authInitialized = false;
+  constructor(options) {
+    this.options = options;
+    this.log("info", "Drumcode Runner initialized", {
+      registryUrl: options.registryUrl,
+      cacheEnabled: options.cacheEnabled
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Authentication
+  // ---------------------------------------------------------------------------
+  /**
+   * Initialize authentication by validating the token with the registry
+   * This should be called before processing any requests
+   */
+  async initializeAuth() {
+    if (this.authInitialized) {
+      return this.authContext;
+    }
+    if (!this.options.token) {
+      this.log("info", "No token provided, running in demo mode");
+      this.authInitialized = true;
+      return this.authContext;
+    }
+    try {
+      this.log("debug", "Validating token with registry");
+      const response = await fetch(`${this.options.registryUrl}/v1/auth/token`, {
+        method: "POST",
+        headers: this.getAuthHeaders()
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        this.log("warn", "Token validation failed", {
+          status: response.status,
+          error: errorData.error?.message
+        });
+        this.authInitialized = true;
+        return this.authContext;
+      }
+      const data = await response.json();
+      if (data.valid && data.project && data.token) {
+        this.authContext = {
+          isAuthenticated: true,
+          projectId: data.project.id,
+          tokenId: data.token.id,
+          tokenName: data.token.name,
+          profileId: data.token.profileId
+        };
+        this.log("info", "Token validated successfully", {
+          projectId: this.authContext.projectId,
+          tokenName: this.authContext.tokenName,
+          hasProfile: !!this.authContext.profileId
+        });
+      }
+    } catch (error) {
+      this.log("error", "Token validation error", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+    this.authInitialized = true;
+    return this.authContext;
+  }
+  /**
+   * Get the current authentication context
+   */
+  getAuthContext() {
+    return this.authContext;
+  }
+  /**
+   * Check if the runner is authenticated
+   */
+  isAuthenticated() {
+    return this.authContext.isAuthenticated;
+  }
+  // ---------------------------------------------------------------------------
+  // Tool Discovery
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the list of tools to expose to the client
+   * Uses Polyfill strategy for non-Anthropic clients
+   */
+  async getToolList(capabilities) {
+    if (capabilities.supportsAdvancedToolUse && capabilities.supportsDeferredLoading) {
+      this.log("debug", "Using Strategy A: Full manifest with deferred loading");
+      return this.getFullManifest();
+    }
+    this.log("debug", "Using Strategy B: Polyfill mode with core toolset");
+    return CORE_TOOLSET;
+  }
+  /**
+   * Fetch the full tool manifest from the Registry
+   */
+  async getFullManifest() {
+    if (this.manifestCache && this.options.cacheEnabled) {
+      return this.manifestCache;
+    }
+    try {
+      const response = await fetch(`${this.options.registryUrl}/v1/manifest`, {
+        headers: this.getAuthHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`Registry returned ${response.status}`);
+      }
+      const data = await response.json();
+      this.manifestCache = data.tools;
+      return this.manifestCache;
+    } catch (error) {
+      this.log("warn", "Failed to fetch manifest, using cached or fallback", { error });
+      return this.manifestCache || CORE_TOOLSET;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Tool Execution
+  // ---------------------------------------------------------------------------
+  /**
+   * Execute a tool call
+   */
+  async executeTool(request) {
+    const startTime = Date.now();
+    try {
+      if (request.name === "drumcode_search_tools") {
+        return this.handleSearchTools(request.arguments);
+      }
+      if (request.name === "drumcode_get_tool_schema") {
+        return this.handleGetToolSchema(request.arguments);
+      }
+      return this.executeRegularTool(request);
+    } catch (error) {
+      const latency = Date.now() - startTime;
+      this.log("error", "Tool execution failed", {
+        tool: request.name,
+        error,
+        latencyMs: latency
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Error executing tool: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Handle drumcode_search_tools meta-tool
+   */
+  async handleSearchTools(args) {
+    this.log("debug", "Searching tools", { query: args.query });
+    try {
+      const response = await fetch(`${this.options.registryUrl}/v1/tools/search`, {
+        method: "POST",
+        headers: {
+          ...this.getAuthHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query: args.query,
+          project_token: this.options.token,
+          limit: 5
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed with status ${response.status}`);
+      }
+      const data = await response.json();
+      const resultText = data.matches.length > 0 ? data.matches.map(
+        (m, i) => `${i + 1}. **${m.name}** (relevance: ${(m.relevance * 100).toFixed(0)}%)
+   ${m.description}`
+      ).join("\n\n") : "No matching tools found. Try a different search query.";
+      return {
+        content: [{
+          type: "text",
+          text: `Found ${data.matches.length} matching tools:
+
+${resultText}
+
+Use \`drumcode_get_tool_schema\` to get detailed arguments for any of these tools.`
+        }]
+      };
+    } catch (error) {
+      this.log("error", "Search failed", { error });
+      return {
+        content: [{
+          type: "text",
+          text: `Search failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Handle drumcode_get_tool_schema meta-tool
+   */
+  async handleGetToolSchema(args) {
+    this.log("debug", "Fetching tool schema", { toolName: args.tool_name });
+    if (this.toolCache.has(args.tool_name)) {
+      const cached = this.toolCache.get(args.tool_name);
+      return {
+        content: [{
+          type: "text",
+          text: this.formatToolSchema(cached)
+        }]
+      };
+    }
+    try {
+      const response = await fetch(
+        `${this.options.registryUrl}/v1/tools/${encodeURIComponent(args.tool_name)}`,
+        { headers: this.getAuthHeaders() }
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          return {
+            content: [{
+              type: "text",
+              text: `Tool "${args.tool_name}" not found. Use drumcode_search_tools to find available tools.`
+            }],
+            isError: true
+          };
+        }
+        throw new Error(`Failed to fetch schema: ${response.status}`);
+      }
+      const schema = await response.json();
+      const tool = {
+        name: schema.name,
+        description: schema.description,
+        input_schema: schema.input_schema
+      };
+      this.toolCache.set(args.tool_name, tool);
+      return {
+        content: [{
+          type: "text",
+          text: this.formatToolSchema(tool)
+        }]
+      };
+    } catch (error) {
+      this.log("error", "Schema fetch failed", { error });
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to fetch schema: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  async fetchRegistryToolSchema(name) {
+    try {
+      const response = await fetch(
+        `${this.options.registryUrl}/v1/tools/${encodeURIComponent(name)}`,
+        { headers: this.getAuthHeaders() }
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        this.log("warn", "Registry tool fetch failed", { name, status: response.status });
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      this.log("error", "Registry tool fetch error", { name, error });
+      return null;
+    }
+  }
+  /**
+   * Execute a regular (non-meta) tool
+   */
+  async executeRegularTool(request) {
+    if (request.name === "drumcode_echo") {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(request.arguments, null, 2)
+        }]
+      };
+    }
+    if (request.name === "drumcode_http_get") {
+      const url = request.arguments.url;
+      try {
+        const response = await fetch(url);
+        const text = await response.text();
+        return {
+          content: [{
+            type: "text",
+            text: `Status: ${response.status}
+
+${text.slice(0, 5e3)}${text.length > 5e3 ? "...(truncated)" : ""}`
+          }]
+        };
+      } catch (error) {
+        return {
+          content: [{
+            type: "text",
+            text: `HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`
+          }],
+          isError: true
+        };
+      }
+    }
+    if (request.name.startsWith("arxiv_")) {
+      return this.executeArxivTool(request);
+    }
+    const skill = await this.fetchSkill(request.name);
+    if (skill) {
+      return this.executeSkill(skill, request.arguments);
+    }
+    const registryResult = await this.executeRegistryTool(request);
+    if (registryResult) {
+      return registryResult;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `Tool "${request.name}" is not yet implemented. This tool needs to be fetched and executed via the Registry.`
+      }],
+      isError: true
+    };
+  }
+  async executeRegistryTool(request) {
+    const schema = await this.fetchRegistryToolSchema(request.name);
+    if (!schema) {
+      return null;
+    }
+    if (!schema.http_method || !schema.http_path) {
+      return {
+        content: [{
+          type: "text",
+          text: `Tool "${request.name}" is missing http_method/http_path in the registry.`
+        }],
+        isError: true
+      };
+    }
+    const integrationName = schema.integration?.name;
+    const baseUrl = this.getIntegrationBaseUrl(integrationName);
+    if (!baseUrl) {
+      return {
+        content: [{
+          type: "text",
+          text: `Missing base URL for integration "${integrationName || "unknown"}". Set DRUMCODE_INTEGRATION_BASE_URLS for this integration.`
+        }],
+        isError: true
+      };
+    }
+    const method = schema.http_method.toUpperCase();
+    let requestUrl;
+    let body;
+    try {
+      ({ url: requestUrl, body } = this.buildToolRequest(
+        baseUrl,
+        schema.http_path,
+        request.arguments,
+        method
+      ));
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to build request for "${request.name}": ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+    const headers = {
+      ...this.getIntegrationHeaders(integrationName)
+    };
+    if (body && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    try {
+      const response = await fetch(requestUrl, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      });
+      const text = await response.text();
+      const truncated = text.length > 5e3 ? "...(truncated)" : "";
+      return {
+        content: [{
+          type: "text",
+          text: `Status: ${response.status}
+
+${text.slice(0, 5e3)}${truncated}`
+        }],
+        isError: !response.ok
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Skill Execution
+  // ---------------------------------------------------------------------------
+  /**
+   * Fetch skill definition from registry
+   */
+  async fetchSkill(name) {
+    if (this.skillCache.has(name)) {
+      return this.skillCache.get(name);
+    }
+    try {
+      const response = await fetch(
+        `${this.options.registryUrl}/v1/skills/${encodeURIComponent(name)}`,
+        { headers: this.getAuthHeaders() }
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        this.log("warn", "Skill fetch failed", { name, status: response.status });
+        return null;
+      }
+      const skill = await response.json();
+      this.skillCache.set(name, skill);
+      this.log("debug", "Fetched skill", { name, type: skill.skill_type });
+      return skill;
+    } catch (error) {
+      this.log("error", "Skill fetch error", { name, error });
+      return null;
+    }
+  }
+  /**
+   * Execute a skill (validator or workflow)
+   */
+  async executeSkill(skill, input) {
+    this.log("info", "Executing skill", { name: skill.name, type: skill.skill_type });
+    const steps = skill.logic_layer.steps;
+    const stepResults = {};
+    const context = { input, steps: stepResults };
+    try {
+      for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (step.action === "check_policy") {
+          const policyStep = step;
+          const passed = this.evaluateRule(policyStep.rule, context);
+          if (!passed) {
+            this.log("warn", "Policy check failed", {
+              skill: skill.name,
+              step: i,
+              rule: policyStep.rule
+            });
+            return {
+              content: [{
+                type: "text",
+                text: `Validation failed: ${policyStep.error_msg}`
+              }],
+              isError: true
+            };
+          }
+          this.log("debug", "Policy check passed", { step: i });
+        } else if (step.action === "execute_atomic") {
+          const execStep = step;
+          const toolArgs = {};
+          if (execStep.args_map) {
+            for (const [argName, mapping] of Object.entries(execStep.args_map)) {
+              toolArgs[argName] = this.evaluateMapping(mapping, context);
+            }
+          } else {
+            Object.assign(toolArgs, input);
+          }
+          this.log("debug", "Executing atomic tool", {
+            tool: execStep.tool,
+            args: Object.keys(toolArgs)
+          });
+          const result = await this.executeTool({
+            name: execStep.tool,
+            arguments: toolArgs
+          });
+          if (execStep.output_key) {
+            stepResults[execStep.output_key] = this.parseToolResult(result);
+          }
+          if (i === steps.length - 1 && !skill.logic_layer.output) {
+            return result;
+          }
+        }
+      }
+      if (skill.logic_layer.output) {
+        const output = {};
+        for (const [key, mapping] of Object.entries(skill.logic_layer.output)) {
+          output[key] = this.evaluateMapping(mapping, context);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Skill "${skill.name}" completed successfully.`
+        }]
+      };
+    } catch (error) {
+      this.log("error", "Skill execution failed", { skill: skill.name, error });
+      return {
+        content: [{
+          type: "text",
+          text: `Skill execution failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Evaluate a policy rule against context
+   * Simple expression evaluator for rules like "input.query && input.query.length >= 2"
+   */
+  evaluateRule(rule, context) {
+    try {
+      const { input, steps } = context;
+      const evalFn = new Function("input", "steps", `
+        try {
+          return Boolean(${rule});
+        } catch (e) {
+          return false;
+        }
+      `);
+      return evalFn(input, steps);
+    } catch (error) {
+      this.log("error", "Rule evaluation failed", { rule, error });
+      return false;
+    }
+  }
+  /**
+   * Evaluate an argument mapping expression
+   * Supports expressions like "input.query", "input.max_results || 5", "steps.search_results.papers[0].id"
+   */
+  evaluateMapping(mapping, context) {
+    try {
+      const { input, steps } = context;
+      const evalFn = new Function("input", "steps", `
+        try {
+          return ${mapping};
+        } catch (e) {
+          return undefined;
+        }
+      `);
+      return evalFn(input, steps);
+    } catch (error) {
+      this.log("error", "Mapping evaluation failed", { mapping, error });
+      return void 0;
+    }
+  }
+  /**
+   * Parse tool result content to extract structured data
+   */
+  parseToolResult(result) {
+    if (result.isError) {
+      return { error: true, message: result.content[0]?.text };
+    }
+    const text = result.content[0]?.text || "";
+    try {
+      return JSON.parse(text);
+    } catch {
+      if (text.includes("Found") && text.includes("papers")) {
+        const papers = [];
+        const paperMatches = text.matchAll(/ID: ([^\n]+)[\s\S]*?\*\*([^*]+)\*\*/g);
+        for (const match of paperMatches) {
+          papers.push({ id: match[1].trim(), title: match[2].trim() });
+        }
+        const altMatches = text.matchAll(/\*\*([^*]+)\*\*[^(]*\(([^)]+)\)/g);
+        for (const match of altMatches) {
+          if (!papers.find((p) => p.id === match[2].trim())) {
+            papers.push({ id: match[2].trim(), title: match[1].trim() });
+          }
+        }
+        return { papers, raw: text };
+      }
+      return { raw: text };
+    }
+  }
+  /**
+   * Execute arXiv tools via the arXiv API
+   */
+  async executeArxivTool(request) {
+    const baseUrl = "http://export.arxiv.org/api/query";
+    try {
+      switch (request.name) {
+        case "arxiv_search_papers": {
+          const { query, max_results = 10, categories } = request.arguments;
+          let searchQuery = query;
+          if (categories && categories.length > 0) {
+            const catFilter = categories.map((c) => `cat:${c}`).join(" OR ");
+            searchQuery = `(${query}) AND (${catFilter})`;
+          }
+          const params = new URLSearchParams({
+            search_query: `all:${searchQuery}`,
+            start: "0",
+            max_results: String(Math.min(max_results, 20)),
+            sortBy: "submittedDate",
+            sortOrder: "descending"
+          });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          return {
+            content: [{
+              type: "text",
+              text: `Found ${papers.length} papers:
+
+${papers.map(
+                (p, i) => `${i + 1}. **${p.title}**
+   ID: ${p.id}
+   Authors: ${p.authors}
+   Published: ${p.published}
+   ${p.summary.slice(0, 200)}...`
+              ).join("\n\n")}`
+            }]
+          };
+        }
+        case "arxiv_get_paper":
+        case "arxiv_get_abstract": {
+          const { paper_id } = request.arguments;
+          const params = new URLSearchParams({ id_list: paper_id });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          if (papers.length === 0) {
+            return {
+              content: [{ type: "text", text: `Paper ${paper_id} not found.` }],
+              isError: true
+            };
+          }
+          const p = papers[0];
+          return {
+            content: [{
+              type: "text",
+              text: `**${p.title}**
+
+ID: ${p.id}
+Authors: ${p.authors}
+Published: ${p.published}
+Categories: ${p.categories}
+PDF: ${p.pdf_url}
+
+**Abstract:**
+${p.summary}`
+            }]
+          };
+        }
+        case "arxiv_search_by_author": {
+          const { author, max_results = 10 } = request.arguments;
+          const params = new URLSearchParams({
+            search_query: `au:${author}`,
+            start: "0",
+            max_results: String(Math.min(max_results, 20)),
+            sortBy: "submittedDate",
+            sortOrder: "descending"
+          });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          return {
+            content: [{
+              type: "text",
+              text: `Found ${papers.length} papers by "${author}":
+
+${papers.map(
+                (p, i) => `${i + 1}. **${p.title}** (${p.id})
+   ${p.published}`
+              ).join("\n\n")}`
+            }]
+          };
+        }
+        case "arxiv_search_by_category": {
+          const { category, max_results = 10 } = request.arguments;
+          const params = new URLSearchParams({
+            search_query: `cat:${category}`,
+            start: "0",
+            max_results: String(Math.min(max_results, 20)),
+            sortBy: "submittedDate",
+            sortOrder: "descending"
+          });
+          const response = await fetch(`${baseUrl}?${params}`);
+          const xml = await response.text();
+          const papers = this.parseArxivResponse(xml);
+          return {
+            content: [{
+              type: "text",
+              text: `Found ${papers.length} recent papers in ${category}:
+
+${papers.map(
+                (p, i) => `${i + 1}. **${p.title}** (${p.id})
+   Authors: ${p.authors}
+   ${p.published}`
+              ).join("\n\n")}`
+            }]
+          };
+        }
+        default:
+          return {
+            content: [{
+              type: "text",
+              text: `arXiv tool "${request.name}" is not yet implemented.`
+            }],
+            isError: true
+          };
+      }
+    } catch (error) {
+      this.log("error", "arXiv API call failed", { error });
+      return {
+        content: [{
+          type: "text",
+          text: `arXiv API error: ${error instanceof Error ? error.message : "Unknown error"}`
+        }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Parse arXiv Atom XML response
+   */
+  parseArxivResponse(xml) {
+    const papers = [];
+    const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
+    let match;
+    while ((match = entryRegex.exec(xml)) !== null) {
+      const entry = match[1];
+      const getId = (s) => {
+        const m = s.match(/<id>(.*?)<\/id>/);
+        return m ? m[1].replace("http://arxiv.org/abs/", "") : "";
+      };
+      const getTitle = (s) => {
+        const m = s.match(/<title>([\s\S]*?)<\/title>/);
+        return m ? m[1].replace(/\s+/g, " ").trim() : "";
+      };
+      const getSummary = (s) => {
+        const m = s.match(/<summary>([\s\S]*?)<\/summary>/);
+        return m ? m[1].replace(/\s+/g, " ").trim() : "";
+      };
+      const getAuthors = (s) => {
+        const authors = [];
+        const authorRegex = /<author>\s*<name>(.*?)<\/name>/g;
+        let authorMatch;
+        while ((authorMatch = authorRegex.exec(s)) !== null) {
+          authors.push(authorMatch[1]);
+        }
+        return authors.join(", ");
+      };
+      const getPublished = (s) => {
+        const m = s.match(/<published>(.*?)<\/published>/);
+        return m ? m[1].split("T")[0] : "";
+      };
+      const getCategories = (s) => {
+        const cats = [];
+        const catRegex = /<category[^>]*term="([^"]+)"/g;
+        let catMatch;
+        while ((catMatch = catRegex.exec(s)) !== null) {
+          cats.push(catMatch[1]);
+        }
+        return cats.join(", ");
+      };
+      const getPdfUrl = (s) => {
+        const m = s.match(/<link[^>]*title="pdf"[^>]*href="([^"]+)"/);
+        return m ? m[1] : "";
+      };
+      papers.push({
+        id: getId(entry),
+        title: getTitle(entry),
+        summary: getSummary(entry),
+        authors: getAuthors(entry),
+        published: getPublished(entry),
+        categories: getCategories(entry),
+        pdf_url: getPdfUrl(entry)
+      });
+    }
+    return papers;
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  getIntegrationBaseUrl(integrationName) {
+    if (!integrationName) {
+      return this.options.integrationBaseUrls?.default || null;
+    }
+    const direct = this.options.integrationBaseUrls?.[integrationName] || this.options.integrationBaseUrls?.[integrationName.toLowerCase()];
+    return direct || this.options.integrationBaseUrls?.default || null;
+  }
+  getIntegrationHeaders(integrationName) {
+    if (!integrationName) {
+      return this.options.integrationHeaders?.default || {};
+    }
+    return this.options.integrationHeaders?.[integrationName] || this.options.integrationHeaders?.[integrationName.toLowerCase()] || this.options.integrationHeaders?.default || {};
+  }
+  buildToolRequest(baseUrl, path, args, method) {
+    const normalizedBase = baseUrl.replace(/\/+$/, "");
+    let resolvedPath = path;
+    const remainingArgs = { ...args };
+    const pathParams = [...path.matchAll(/{([^}]+)}/g)].map((match) => match[1]);
+    for (const param of pathParams) {
+      const value = remainingArgs[param];
+      if (value === void 0 || value === null) {
+        throw new Error(`Missing required path param "${param}"`);
+      }
+      resolvedPath = resolvedPath.replace(`{${param}}`, encodeURIComponent(String(value)));
+      delete remainingArgs[param];
+    }
+    const normalizedPath = resolvedPath.startsWith("/") ? resolvedPath : `/${resolvedPath}`;
+    let url = `${normalizedBase}${normalizedPath}`;
+    if (method === "GET" || method === "DELETE") {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(remainingArgs)) {
+        if (value === void 0 || value === null) continue;
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            params.append(key, String(item));
+          }
+          continue;
+        }
+        if (typeof value === "object") {
+          params.append(key, JSON.stringify(value));
+          continue;
+        }
+        params.append(key, String(value));
+      }
+      const query = params.toString();
+      if (query) {
+        url = `${url}?${query}`;
+      }
+      return { url, body: null };
+    }
+    return { url, body: remainingArgs };
+  }
+  getAuthHeaders() {
+    const headers = {
+      "User-Agent": "drumcode-runner/0.1.0"
+    };
+    if (this.options.token) {
+      headers["Authorization"] = `Bearer ${this.options.token}`;
+    }
+    return headers;
+  }
+  formatToolSchema(tool) {
+    const props = tool.input_schema.properties;
+    const required = tool.input_schema.required || [];
+    const argsDescription = Object.entries(props).map(([name, prop]) => {
+      const req = required.includes(name) ? " (required)" : " (optional)";
+      return `  - ${name}${req}: ${prop.type}${prop.description ? ` - ${prop.description}` : ""}`;
+    }).join("\n");
+    return `## ${tool.name}
+
+${tool.description}
+
+### Arguments:
+${argsDescription || "  No arguments required."}
+
+### Usage:
+Call this tool with the arguments above to execute it.`;
+  }
+  log(level, message, data) {
+    const levels = ["debug", "info", "warn", "error"];
+    const currentLevel = levels.indexOf(this.options.logLevel);
+    const messageLevel = levels.indexOf(level);
+    if (messageLevel >= currentLevel) {
+      const safeData = data ? JSON.parse(redactSecrets(JSON.stringify(data))) : void 0;
+      console.error(`[drumcode] ${message}`, safeData ? safeData : "");
+    }
+  }
+};
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+async function createServer(options) {
+  const runner = new DrumcodeRunner(options);
+  const authContext = await runner.initializeAuth();
+  if (authContext.isAuthenticated) {
+    console.error(`[drumcode] Authenticated as: ${authContext.tokenName || "unnamed token"}`);
+    console.error(`[drumcode] Project ID: ${authContext.projectId}`);
+    if (authContext.profileId) {
+      console.error(`[drumcode] Permission profile: ${authContext.profileId}`);
+    }
+  } else if (options.token) {
+    console.error("[drumcode] Warning: Token provided but authentication failed");
+  }
+  const server = new Server(
+    {
+      name: "drumcode",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const capabilities = {
+      type: options.clientMode === "full" ? "anthropic" : "unknown",
+      supportsAdvancedToolUse: options.clientMode === "full",
+      supportsDeferredLoading: options.clientMode === "full"
+    };
+    const tools = await runner.getToolList(capabilities);
+    const includeAuxTools = options.clientMode === "full";
+    const demoTools = includeAuxTools ? [
+      {
+        name: "drumcode_echo",
+        description: "Echo back the input arguments. Useful for testing.",
+        input_schema: {
+          type: "object",
+          properties: {
+            message: {
+              type: "string",
+              description: "The message to echo back"
+            }
+          },
+          required: ["message"]
+        }
+      },
+      {
+        name: "drumcode_http_get",
+        description: "Make an HTTP GET request to a URL and return the response.",
+        input_schema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "The URL to fetch"
+            }
+          },
+          required: ["url"]
+        }
+      }
+    ] : [];
+    const arxivTools = includeAuxTools ? [
+      {
+        name: "arxiv_search_papers",
+        description: "Search for academic papers on arXiv. Returns papers matching the query with optional filters.",
+        input_schema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: 'Search query keywords (e.g., "machine learning", "quantum computing")'
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results to return (1-20)"
+            },
+            categories: {
+              type: "string",
+              description: 'Comma-separated arXiv categories to filter by (e.g., "cs.AI,cs.LG")'
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "arxiv_get_paper",
+        description: "Get detailed metadata and abstract for a specific paper by its arXiv ID.",
+        input_schema: {
+          type: "object",
+          properties: {
+            paper_id: {
+              type: "string",
+              description: 'The arXiv paper ID (e.g., "2301.07041" or "1706.03762")'
+            }
+          },
+          required: ["paper_id"]
+        }
+      },
+      {
+        name: "arxiv_search_by_author",
+        description: "Search for papers by a specific author on arXiv.",
+        input_schema: {
+          type: "object",
+          properties: {
+            author: {
+              type: "string",
+              description: "Author name to search for"
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results (1-20)"
+            }
+          },
+          required: ["author"]
+        }
+      },
+      {
+        name: "arxiv_search_by_category",
+        description: "Search for recent papers in a specific arXiv category.",
+        input_schema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              description: 'arXiv category (e.g., "cs.AI", "math.CO", "physics.hep-th")'
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results (1-20)"
+            }
+          },
+          required: ["category"]
+        }
+      }
+    ] : [];
+    const toolMap = /* @__PURE__ */ new Map();
+    for (const t of [...demoTools, ...arxivTools]) {
+      toolMap.set(t.name, t);
+    }
+    for (const t of tools) {
+      toolMap.set(t.name, t);
+    }
+    const allTools = Array.from(toolMap.values()).map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: {
+        type: "object",
+        properties: t.input_schema.properties,
+        required: t.input_schema.required
+      }
+    }));
+    return { tools: allTools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await runner.executeTool({
+      name,
+      arguments: args ?? {}
+    });
+    return {
+      content: result.content,
+      isError: result.isError
+    };
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[drumcode] MCP Server started");
+}
+
+export {
+  DrumcodeRunner,
+  createServer
+};