@robinbraemer/codemode 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,45 +1,158 @@
 import {
   IsolatedVMExecutor
-} from "./chunk-NSUQUO7S.js";
-import {
-  QuickJSExecutor
-} from "./chunk-ZWSO33DZ.js";
+} from "./chunk-M4AL5G4U.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/executor/auto.ts
 async function createExecutor(options = {}) {
   try {
     await import("isolated-vm");
-    const { IsolatedVMExecutor: IsolatedVMExecutor2 } = await import("./isolated-vm-57EIYEJM.js");
+    const { IsolatedVMExecutor: IsolatedVMExecutor2 } = await import("./isolated-vm-7REUQAB5.js");
     return new IsolatedVMExecutor2(options);
   } catch {
   }
-  try {
-    await import("quickjs-emscripten");
-    const { QuickJSExecutor: QuickJSExecutor2 } = await import("./quickjs-BGVQS2YE.js");
-    return new QuickJSExecutor2(options);
-  } catch {
-  }
   throw new Error(
-    "No sandbox runtime found. Install one of:\n  npm install isolated-vm    # V8 isolates, fastest (Node.js only)\n  npm install quickjs-emscripten  # WASM sandbox, portable (Node.js, Bun, browsers)"
+    "No sandbox runtime found. Install isolated-vm:\n  npm install isolated-vm    # V8 isolates (Node.js)"
   );
 }
 
 // src/request-bridge.ts
-function createRequestBridge(handler, baseUrl) {
-  return async (options) => {
-    const { method, path, query, body, headers } = options;
+var ALLOWED_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+var BLOCKED_HEADER_PATTERNS = [
+  /^authorization$/i,
+  /^cookie$/i,
+  /^host$/i,
+  /^origin$/i,
+  /^referer$/i,
+  /^x-forwarded-/i,
+  /^x-real-ip$/i,
+  /^x-client-ip$/i,
+  /^cf-connecting-ip$/i,
+  /^true-client-ip$/i,
+  /^proxy-/i,
+  /^transfer-encoding$/i,
+  /^connection$/i,
+  /^upgrade$/i,
+  /^te$/i
+];
+var DEFAULT_MAX_REQUESTS = 50;
+var DEFAULT_MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+async function readResponseWithLimit(response, maxBytes) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const text = await response.text();
+    if (text.length > maxBytes) {
+      throw new Error(
+        `Response too large: ${text.length} bytes exceeds limit of ${maxBytes} bytes`
+      );
+    }
+    return text;
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        throw new Error(
+          `Response too large: exceeded limit of ${maxBytes} bytes`
+        );
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const decoder = new TextDecoder();
+  if (chunks.length === 1) return decoder.decode(chunks[0]);
+  const combined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return decoder.decode(combined);
+}
+function validatePath(path) {
+  if (path.includes("://")) {
+    throw new Error(`Invalid path: must not contain "://" \u2014 got "${path}"`);
+  }
+  if (!path.startsWith("/")) {
+    throw new Error(`Invalid path: must start with "/" \u2014 got "${path}"`);
+  }
+  if (path.startsWith("//")) {
+    throw new Error(`Invalid path: must not start with "//" \u2014 got "${path}"`);
+  }
+  if (path.includes("\0")) {
+    throw new Error("Invalid path: must not contain null bytes");
+  }
+  if (/[\r\n]/.test(path)) {
+    throw new Error("Invalid path: must not contain CR/LF characters");
+  }
+  if (path.includes("\\")) {
+    throw new Error("Invalid path: must not contain backslashes");
+  }
+}
+function filterHeaders(headers, allowedHeaders) {
+  if (!headers) return {};
+  if (allowedHeaders) {
+    const allowed = new Set(allowedHeaders.map((h) => h.toLowerCase()));
+    const filtered2 = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (allowed.has(key.toLowerCase())) {
+        filtered2[key] = value;
+      }
+    }
+    return filtered2;
+  }
+  const filtered = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const blocked = BLOCKED_HEADER_PATTERNS.some((p) => p.test(key));
+    if (!blocked) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function createRequestBridge(handler, baseUrl, options = {}) {
+  const maxRequests = options.maxRequests ?? DEFAULT_MAX_REQUESTS;
+  const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+  const allowedHeaders = options.allowedHeaders;
+  let requestCount = 0;
+  return async (opts) => {
+    const { method, path, query, body, headers } = opts;
+    if (++requestCount > maxRequests) {
+      throw new Error(
+        `Request limit exceeded: max ${maxRequests} requests per execution`
+      );
+    }
+    const upperMethod = method.toUpperCase();
+    if (!ALLOWED_METHODS.has(upperMethod)) {
+      throw new Error(
+        `Invalid HTTP method: "${method}". Allowed: ${[...ALLOWED_METHODS].join(", ")}`
+      );
+    }
+    validatePath(path);
     const url = new URL(path, baseUrl);
     if (query) {
       for (const [key, value] of Object.entries(query)) {
         url.searchParams.set(key, String(value));
       }
     }
+    const filteredHeaders = filterHeaders(headers, allowedHeaders);
     const init = {
-      method: method.toUpperCase(),
-      headers: {
-        ...headers
-      }
+      method: upperMethod,
+      headers: { ...filteredHeaders }
     };
     if (body !== void 0 && body !== null) {
       init.body = JSON.stringify(body);
@@ -51,15 +164,16 @@ function createRequestBridge(handler, baseUrl) {
       responseHeaders[key] = value;
     });
     const contentType = response.headers.get("content-type") ?? "";
+    const text = await readResponseWithLimit(response, maxResponseBytes);
     let responseBody;
     if (contentType.includes("application/json")) {
       try {
-        responseBody = await response.json();
+        responseBody = JSON.parse(text);
       } catch {
-        responseBody = await response.text();
+        responseBody = text;
       }
     } else {
-      responseBody = await response.text();
+      responseBody = text;
     }
     return {
       status: response.status,
@@ -69,46 +183,205 @@ function createRequestBridge(handler, baseUrl) {
   };
 }
 
+// src/spec.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+var DEFAULT_MAX_REF_DEPTH = 50;
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function resolveRefs(obj, root, seen = /* @__PURE__ */ new Set(), maxDepth = DEFAULT_MAX_REF_DEPTH, _cache = /* @__PURE__ */ new Map()) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj))
+    return obj.map((item) => resolveRefs(item, root, seen, maxDepth, _cache));
+  const record = obj;
+  if ("$ref" in record && typeof record.$ref === "string") {
+    const ref = record.$ref;
+    if (seen.has(ref)) return { $circular: ref };
+    if (seen.size >= maxDepth) {
+      return { $circular: ref, $reason: "max depth exceeded" };
+    }
+    if (_cache.has(ref)) return _cache.get(ref);
+    const parts = ref.replace("#/", "").split("/");
+    let resolved = root;
+    for (const part of parts) {
+      if (DANGEROUS_KEYS.has(part)) return { $ref: ref, $error: "unsafe ref path" };
+      resolved = resolved?.[part];
+    }
+    const branchSeen = new Set(seen);
+    branchSeen.add(ref);
+    const result2 = resolveRefs(resolved, root, branchSeen, maxDepth, _cache);
+    _cache.set(ref, result2);
+    return result2;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (DANGEROUS_KEYS.has(key)) continue;
+    result[key] = resolveRefs(value, root, seen, maxDepth, _cache);
+  }
+  return result;
+}
+function extractServerBasePath(spec) {
+  const servers = spec.servers;
+  if (!servers?.length) return "";
+  const url = servers[0].url;
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname.replace(/\/+$/, "");
+  } catch {
+    return url.replace(/\/+$/, "");
+  }
+}
+function processSpec(spec, maxRefDepth = DEFAULT_MAX_REF_DEPTH) {
+  const rawPaths = spec.paths ?? {};
+  const basePath = extractServerBasePath(spec);
+  const paths = {};
+  for (const [path, pathItem] of Object.entries(rawPaths)) {
+    if (!pathItem) continue;
+    const fullPath = basePath ? basePath + path : path;
+    paths[fullPath] = {};
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (op) {
+        paths[fullPath][method] = {
+          summary: op.summary,
+          description: op.description,
+          tags: op.tags,
+          operationId: op.operationId,
+          parameters: resolveRefs(
+            op.parameters,
+            spec,
+            void 0,
+            maxRefDepth
+          ),
+          requestBody: resolveRefs(
+            op.requestBody,
+            spec,
+            void 0,
+            maxRefDepth
+          ),
+          responses: resolveRefs(
+            op.responses,
+            spec,
+            void 0,
+            maxRefDepth
+          )
+        };
+      }
+    }
+  }
+  const result = { paths };
+  if (spec.info) result.info = spec.info;
+  if (spec.components) {
+    result.components = resolveRefs(
+      spec.components,
+      spec,
+      void 0,
+      maxRefDepth
+    );
+  }
+  return result;
+}
+function extractTags(spec) {
+  const rawPaths = spec.paths;
+  if (!rawPaths) return [];
+  const tags = /* @__PURE__ */ new Map();
+  for (const pathItem of Object.values(rawPaths)) {
+    if (!pathItem) continue;
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (op?.tags) {
+        for (const tag of op.tags) {
+          tags.set(tag, (tags.get(tag) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  return [...tags.entries()].toSorted((a, b) => b[1] - a[1]).map(([t]) => t);
+}
+
 // src/tools.ts
-function createSearchToolDefinition(toolName) {
-  return {
-    name: toolName,
-    description: `Search the API specification to discover available endpoints.
+var SPEC_TYPES = `
+interface OperationInfo {
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  operationId?: string;
+  parameters?: Array<{ name: string; in: string; required?: boolean; schema?: unknown; description?: string }>;
+  requestBody?: { required?: boolean; content?: Record<string, { schema?: unknown }> };
+  responses?: Record<string, { description?: string; content?: Record<string, { schema?: unknown }> }>;
+}
 
-Write an async JavaScript arrow function that filters and explores the \`spec\` object (an OpenAPI 3.x document). The full spec is available as a global variable.
+interface PathItem {
+  get?: OperationInfo;
+  post?: OperationInfo;
+  put?: OperationInfo;
+  patch?: OperationInfo;
+  delete?: OperationInfo;
+}
 
-Common patterns:
-- Find endpoints by path: \`spec.paths\` is an object keyed by path string
-- Each path has HTTP methods (get, post, put, delete, patch) as keys
-- Each operation has: summary, description, parameters, requestBody, responses
-- Use spec.components.schemas for data models
+declare const spec: {
+  paths: Record<string, PathItem>;
+  components?: { schemas?: Record<string, unknown> };
+  info?: { title?: string; version?: string; description?: string };
+};
+`;
+function createSearchToolDefinition(toolName, context) {
+  const parts = [];
+  parts.push(
+    `Search the API specification to discover available endpoints. All $refs are pre-resolved inline.`
+  );
+  if (context?.tags && context.tags.length > 0) {
+    const shown = context.tags.slice(0, 30).join(", ");
+    const suffix = context.tags.length > 30 ? `... (${context.tags.length} total)` : "";
+    parts.push(`Tags: ${shown}${suffix}`);
+  }
+  if (context?.endpointCount) {
+    parts.push(`Endpoints: ${context.endpointCount}`);
+  }
+  parts.push(`Types:
+${SPEC_TYPES}`);
+  const exampleTag = context?.tags?.[0]?.toLowerCase() ?? "items";
+  parts.push(`Your code must be an async arrow function that returns the result.
 
 Examples:
-  // Find all cluster-related endpoints
-  async () => {
-    return Object.entries(spec.paths)
-      .filter(([p]) => p.includes('/clusters'))
-      .flatMap(([path, methods]) =>
-        Object.entries(methods)
-          .filter(([m]) => ['get','post','put','delete','patch'].includes(m))
-          .map(([method, op]) => ({
-            method: method.toUpperCase(), path, summary: op.summary
-          }))
-      );
+
+// List all endpoints
+async () => {
+  const results = [];
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    for (const [method, op] of Object.entries(methods)) {
+      results.push({ method: method.toUpperCase(), path, summary: op.summary });
+    }
   }
+  return results;
+}
 
-  // Get the schema for a specific model
-  async () => {
-    return spec.components?.schemas?.Product;
+// Find endpoints by tag
+async () => {
+  const results = [];
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    for (const [method, op] of Object.entries(methods)) {
+      if (op.tags?.some(t => t.toLowerCase() === '${exampleTag}')) {
+        results.push({ method: method.toUpperCase(), path, summary: op.summary });
+      }
+    }
   }
+  return results;
+}
 
-Return the matching endpoints/schemas as a structured result the agent can use to plan execute() calls.`,
+// Get full details for a specific endpoint (refs are already resolved)
+async () => {
+  const op = spec.paths['/example']?.get;
+  return { summary: op?.summary, parameters: op?.parameters, requestBody: op?.requestBody };
+}`);
+  return {
+    name: toolName,
+    description: parts.join("\n\n"),
     inputSchema: {
       type: "object",
       properties: {
         code: {
           type: "string",
-          description: "An async JavaScript arrow function that searches the `spec` object. Must return a value."
+          description: "JavaScript async arrow function to search the `spec` object"
         }
       },
       required: ["code"]
@@ -116,55 +389,67 @@ Return the matching endpoints/schemas as a structured result the agent can use t
   };
 }
 function createExecuteToolDefinition(toolName, namespace) {
-  return {
-    name: toolName,
-    description: `Execute API calls by writing JavaScript code.
+  const types = `
+interface RequestOptions {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: string;
+  query?: Record<string, string | number | boolean>;
+  body?: unknown;
+  headers?: Record<string, string>;
+}
 
-Write an async JavaScript arrow function that uses \`${namespace}.request()\` to make API calls. The request function handles authentication automatically.
+interface Response<T = unknown> {
+  status: number;
+  headers: Record<string, string>;
+  body: T;
+}
 
-\`${namespace}.request(options)\` takes:
-  - method: HTTP method string ("GET", "POST", "PUT", "DELETE", "PATCH")
-  - path: API path string (e.g. "/v1/clusters")
-  - query: optional object of query parameters
-  - body: optional request body (will be JSON-serialized)
-  - headers: optional object of additional headers
+declare const ${namespace}: {
+  request<T = unknown>(options: RequestOptions): Promise<Response<T>>;
+};
+`;
+  return {
+    name: toolName,
+    description: `Execute API calls by writing JavaScript code. First use the 'search' tool to find the right endpoints.
 
-Returns: { status: number, headers: object, body: unknown }
+Available in your code:
+${types}
+Your code must be an async arrow function that returns the result.
 
 Examples:
-  // List resources
-  async () => {
-    const res = await ${namespace}.request({ method: "GET", path: "/v1/clusters" });
-    return res.body;
-  }
 
-  // Create a resource
-  async () => {
-    return ${namespace}.request({
-      method: "POST",
-      path: "/v1/products",
-      body: { name: "My Product", chart: "nginx" }
-    });
-  }
+// List resources
+async () => {
+  const res = await ${namespace}.request({ method: "GET", path: "/v1/items" });
+  return res.body;
+}
 
-  // Chain multiple calls
-  async () => {
-    const clusters = await ${namespace}.request({ method: "GET", path: "/v1/clusters" });
-    const details = await Promise.all(
-      clusters.body.map(c =>
-        ${namespace}.request({ method: "GET", path: \`/v1/clusters/\${c.id}\` })
-      )
-    );
-    return details.map(d => d.body);
-  }
+// Create a resource
+async () => {
+  const res = await ${namespace}.request({
+    method: "POST",
+    path: "/v1/items",
+    body: { name: "Widget" }
+  });
+  return { status: res.status, body: res.body };
+}
 
-Write clean, focused code. Return the data the user needs.`,
+// Chain multiple calls
+async () => {
+  const list = await ${namespace}.request({ method: "GET", path: "/v1/items" });
+  const details = await Promise.all(
+    list.body.map(item =>
+      ${namespace}.request({ method: "GET", path: \`/v1/items/\${item.id}\` })
+    )
+  );
+  return details.map(d => d.body);
+}`,
     inputSchema: {
       type: "object",
       properties: {
         code: {
           type: "string",
-          description: `An async JavaScript arrow function that uses \`${namespace}.request()\` to make API calls.`
+          description: `JavaScript async arrow function that uses \`${namespace}.request()\` to make API calls`
         }
       },
       required: ["code"]
@@ -172,16 +457,83 @@ Write clean, focused code. Return the data the user needs.`,
   };
 }
 
+// src/truncate.ts
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_MAX_TOKENS = 25e3;
+function truncateResponse(content, maxTokens = DEFAULT_MAX_TOKENS) {
+  const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+  const maxChars = maxTokens * CHARS_PER_TOKEN;
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const truncated = text.slice(0, maxChars);
+  const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
+  return `${truncated}
+
+--- TRUNCATED ---
+Response was ~${estimatedTokens.toLocaleString()} tokens (limit: ${maxTokens.toLocaleString()}). Use more specific queries to reduce response size.`;
+}
+
 // src/codemode.ts
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "Object",
+  "Array",
+  "Promise",
+  "Function",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Error",
+  "JSON",
+  "Math",
+  "Proxy",
+  "Reflect",
+  "globalThis",
+  "undefined",
+  "null",
+  "NaN",
+  "Infinity",
+  "console",
+  "spec",
+  "global"
+]);
+var VALID_JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function validateNamespace(namespace) {
+  if (!VALID_JS_IDENTIFIER.test(namespace)) {
+    throw new Error(
+      `Invalid namespace "${namespace}": must be a valid JavaScript identifier`
+    );
+  }
+  if (RESERVED_NAMES.has(namespace)) {
+    throw new Error(
+      `Invalid namespace "${namespace}": conflicts with reserved name`
+    );
+  }
+}
 var CodeMode = class {
   specProvider;
-  requestBridge;
   namespace;
   executor;
   executorPromise = null;
   options;
   searchToolName;
   executeToolName;
+  maxResponseTokens;
+  // Bridge config — a fresh bridge is created per execute() call
+  // so the request counter resets each time.
+  bridgeHandler;
+  bridgeBaseUrl;
+  bridgeOptions;
+  // Cached processed spec & context for tool descriptions
+  processedSpec = null;
+  specContext = null;
   constructor(options) {
     this.options = options;
     this.specProvider = options.spec;
@@ -189,9 +541,15 @@ var CodeMode = class {
     this.executor = options.executor ?? null;
     this.searchToolName = "search";
     this.executeToolName = "execute";
-    const baseUrl = options.baseUrl ?? "http://localhost";
-    const bridge = createRequestBridge(options.request, baseUrl);
-    this.requestBridge = (...args) => bridge(args[0]);
+    this.maxResponseTokens = options.maxResponseTokens ?? 25e3;
+    validateNamespace(this.namespace);
+    this.bridgeHandler = options.request;
+    this.bridgeBaseUrl = options.baseUrl ?? "http://localhost";
+    this.bridgeOptions = {
+      maxRequests: options.maxRequests,
+      maxResponseBytes: options.maxResponseBytes,
+      allowedHeaders: options.allowedHeaders
+    };
   }
   /**
    * Override the default tool names.
@@ -206,7 +564,7 @@ var CodeMode = class {
    */
   tools() {
     return [
-      createSearchToolDefinition(this.searchToolName),
+      createSearchToolDefinition(this.searchToolName, this.specContext ?? void 0),
       createExecuteToolDefinition(this.executeToolName, this.namespace)
     ];
   }
@@ -228,12 +586,13 @@ var CodeMode = class {
   /**
    * Execute a search against the OpenAPI spec.
    * The code runs in a sandbox with `spec` available as a global.
+   * All $refs are pre-resolved inline.
    */
   async search(code) {
     const executor = await this.getExecutor();
-    const spec = await this.resolveSpec();
+    const spec = await this.getProcessedSpec();
     const result = await executor.execute(code, { spec });
-    return formatResult(result);
+    return this.formatResult(result);
   }
   /**
    * Execute API calls in the sandbox.
@@ -241,13 +600,18 @@ var CodeMode = class {
    */
   async execute(code) {
     const executor = await this.getExecutor();
+    const bridge = createRequestBridge(
+      this.bridgeHandler,
+      this.bridgeBaseUrl,
+      this.bridgeOptions
+    );
     const client = {
-      request: this.requestBridge
+      request: (...args) => bridge(args[0])
     };
     const result = await executor.execute(code, {
       [this.namespace]: client
     });
-    return formatResult(result);
+    return this.formatResult(result);
   }
   /**
    * Clean up sandbox resources.
@@ -261,6 +625,19 @@ var CodeMode = class {
     }
     return this.specProvider;
   }
+  /**
+   * Get the processed spec (refs resolved, fields extracted).
+   * Caches the result after first call.
+   */
+  async getProcessedSpec() {
+    if (this.processedSpec) return this.processedSpec;
+    const raw = await this.resolveSpec();
+    this.processedSpec = processSpec(raw, this.options.maxRefDepth);
+    const tags = extractTags(raw);
+    const endpointCount = Object.keys(raw.paths ?? {}).length;
+    this.specContext = { tags, endpointCount };
+    return this.processedSpec;
+  }
   async getExecutor() {
     if (this.executor) return this.executor;
     if (!this.executorPromise) {
@@ -273,36 +650,28 @@ var CodeMode = class {
     }
     return this.executorPromise;
   }
-};
-function formatResult(result) {
-  if (result.error) {
-    const parts2 = [];
-    if (result.logs.length > 0) {
-      parts2.push(`Console output:
-${result.logs.join("\n")}`);
+  formatResult(result) {
+    if (result.error) {
+      return {
+        content: [{ type: "text", text: `Error: ${result.error}` }],
+        isError: true
+      };
     }
-    parts2.push(`Error: ${result.error}`);
+    const resultText = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
     return {
-      content: [{ type: "text", text: parts2.join("\n\n") }],
-      isError: true
+      content: [{ type: "text", text: truncateResponse(resultText, this.maxResponseTokens) }]
     };
   }
-  const parts = [];
-  if (result.logs.length > 0) {
-    parts.push(`Console output:
-${result.logs.join("\n")}`);
-  }
-  const resultText = typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2);
-  parts.push(resultText);
-  return {
-    content: [{ type: "text", text: parts.join("\n\n") }]
-  };
-}
+};
 export {
   CodeMode,
   IsolatedVMExecutor,
-  QuickJSExecutor,
   createExecutor,
-  createRequestBridge
+  createRequestBridge,
+  extractServerBasePath,
+  extractTags,
+  processSpec,
+  resolveRefs,
+  truncateResponse
 };
 //# sourceMappingURL=index.js.map