@supertools-ai/core 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,937 +0,0 @@
-// src/tool.ts
-import { z } from "zod";
-var TOOL_BRAND = /* @__PURE__ */ Symbol.for("supertools.tool");
-function defineTool(definition) {
-  if (!definition.name || typeof definition.name !== "string") {
-    throw new Error("Tool name is required");
-  }
-  if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(definition.name)) {
-    throw new Error(`Invalid tool name "${definition.name}": must start with a letter and contain only alphanumeric characters and underscores`);
-  }
-  if (!definition.description || typeof definition.description !== "string") {
-    throw new Error("Tool description is required");
-  }
-  if (definition.description.length < 5) {
-    throw new Error("Tool description must be at least 5 characters");
-  }
-  if (!isZodSchema(definition.parameters)) {
-    throw new Error("Tool parameters must be a Zod schema");
-  }
-  if (getZodType(definition.parameters) !== "object") {
-    throw new Error(`Tool parameters must be z.object(), got z.${getZodType(definition.parameters)}()`);
-  }
-  if (typeof definition.execute !== "function") {
-    throw new Error("Tool execute must be a function");
-  }
-  return Object.freeze({
-    name: definition.name,
-    description: definition.description,
-    parameters: definition.parameters,
-    execute: definition.execute,
-    [TOOL_BRAND]: true
-  });
-}
-function isTool(value) {
-  return typeof value === "object" && value !== null && TOOL_BRAND in value && value[TOOL_BRAND] === true;
-}
-function normalizeTools(tools) {
-  return tools.map((tool) => {
-    if (!isTool(tool)) {
-      throw new TypeError(`Expected Tool from defineTool(), got ${typeof tool}`);
-    }
-    return Object.freeze({
-      name: toSnakeCase(tool.name),
-      description: tool.description,
-      parameters: Object.freeze(extractParameters(tool.parameters)),
-      execute: tool.execute
-    });
-  });
-}
-function isZodSchema(value) {
-  return typeof value === "object" && value !== null && "_zod" in value;
-}
-function getZodDef(schema) {
-  const s = schema;
-  if (!s._zod?.def) {
-    throw new Error("Invalid Zod schema: missing _zod.def");
-  }
-  return s._zod.def;
-}
-function getZodType(schema) {
-  const def = getZodDef(schema);
-  if (typeof def.type !== "string") {
-    throw new Error("Invalid Zod schema: missing type");
-  }
-  return def.type;
-}
-function extractParameters(schema) {
-  if (getZodType(schema) !== "object") {
-    return [parseField("input", schema)];
-  }
-  const def = getZodDef(schema);
-  const shape = def.shape;
-  const fields = typeof shape === "function" ? shape() : shape;
-  if (!fields || typeof fields !== "object") {
-    throw new Error("Invalid Zod object schema: missing shape");
-  }
-  return Object.entries(fields).map(([name, fieldSchema]) => parseField(name, fieldSchema));
-}
-function parseField(name, schema) {
-  let current = schema;
-  let isOptional2 = false;
-  let defaultValue;
-  let description = "";
-  for (let depth = 0; depth < 10; depth++) {
-    if (current.description) {
-      description = current.description;
-    }
-    const type = getZodType(current);
-    const def = getZodDef(current);
-    const inner = def.innerType;
-    if (type === "optional" && inner) {
-      isOptional2 = true;
-      current = inner;
-    } else if (type === "default" && inner) {
-      isOptional2 = true;
-      const defaultFn = def.defaultValue;
-      defaultValue = typeof defaultFn === "function" ? defaultFn() : defaultFn;
-      current = inner;
-    } else if (type === "nullable" && inner) {
-      isOptional2 = true;
-      current = inner;
-    } else {
-      break;
-    }
-  }
-  return Object.freeze({
-    name,
-    type: inferBaseType(current),
-    description,
-    required: !isOptional2,
-    default: defaultValue
-  });
-}
-function inferBaseType(schema) {
-  const type = getZodType(schema);
-  const def = getZodDef(schema);
-  switch (type) {
-    case "string":
-    case "enum":
-      return "string";
-    case "number": {
-      const checks = def.checks;
-      return checks?.some((c) => c.isInt) ? "integer" : "number";
-    }
-    case "bigint":
-      return "integer";
-    case "boolean":
-      return "boolean";
-    case "array":
-    case "tuple":
-    case "set":
-      return "array";
-    case "object":
-    case "record":
-    case "map":
-      return "object";
-    case "literal": {
-      const val = def.value;
-      if (typeof val === "string") return "string";
-      if (typeof val === "number") return "number";
-      if (typeof val === "boolean") return "boolean";
-      return "any";
-    }
-    default:
-      return "any";
-  }
-}
-function toSnakeCase(str) {
-  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
-}
-
-// src/executor.ts
-import { randomUUID } from "crypto";
-import { Sandbox } from "@e2b/code-interpreter";
-
-// src/relay/client.ts
-import WebSocket from "ws";
-
-// src/relay/protocol.ts
-import { z as z2 } from "zod";
-
-// src/errors.ts
-var OPTError = class extends Error {
-  code;
-  cause;
-  constructor(message, code, cause) {
-    super(message);
-    this.name = "OPTError";
-    this.code = code;
-    this.cause = cause;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      cause: this.cause?.message
-    };
-  }
-};
-var CodeGenerationError = class extends OPTError {
-  constructor(message, cause) {
-    super(message, "CODE_GENERATION_ERROR", cause);
-    this.name = "CodeGenerationError";
-  }
-};
-var ExecutionError = class extends OPTError {
-  output;
-  constructor(message, output, cause) {
-    super(message, "EXECUTION_ERROR", cause);
-    this.name = "ExecutionError";
-    this.output = output;
-  }
-  toJSON() {
-    return { ...super.toJSON(), output: this.output };
-  }
-};
-var ToolError = class extends OPTError {
-  toolName;
-  constructor(message, toolName2, cause) {
-    super(message, "TOOL_ERROR", cause);
-    this.name = "ToolError";
-    this.toolName = toolName2;
-  }
-  toJSON() {
-    return { ...super.toJSON(), toolName: this.toolName };
-  }
-};
-var RelayConnectionError = class extends OPTError {
-  constructor(message, cause) {
-    super(message, "RELAY_CONNECTION_ERROR", cause);
-    this.name = "RelayConnectionError";
-  }
-};
-var RelayTimeoutError = class extends OPTError {
-  constructor(message) {
-    super(message, "RELAY_TIMEOUT_ERROR");
-    this.name = "RelayTimeoutError";
-  }
-};
-var SandboxError = class extends OPTError {
-  constructor(message, cause) {
-    super(message, "SANDBOX_ERROR", cause);
-    this.name = "SandboxError";
-  }
-};
-var AuthenticationError = class extends OPTError {
-  constructor(message) {
-    super(message, "AUTHENTICATION_ERROR");
-    this.name = "AuthenticationError";
-  }
-};
-var ConfigurationError = class extends OPTError {
-  constructor(message) {
-    super(message, "CONFIGURATION_ERROR");
-    this.name = "ConfigurationError";
-  }
-};
-
-// src/relay/protocol.ts
-var ProtocolError = class extends OPTError {
-  protocolCode;
-  zodError;
-  constructor(message, code, zodError) {
-    super(message, "PROTOCOL_ERROR");
-    this.name = "ProtocolError";
-    this.protocolCode = code;
-    this.zodError = zodError;
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      protocolCode: this.protocolCode,
-      issues: this.zodError?.issues
-    };
-  }
-};
-var messageId = z2.string().min(1).max(64);
-var toolName = z2.string().min(1).max(128).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, "Invalid tool name format");
-var toolCallSchema = z2.object({
-  type: z2.literal("tool_call"),
-  id: messageId,
-  tool: toolName,
-  arguments: z2.record(z2.string(), z2.unknown())
-}).strict();
-var toolResultSchema = z2.object({
-  type: z2.literal("tool_result"),
-  id: messageId,
-  success: z2.boolean(),
-  result: z2.unknown().optional(),
-  error: z2.string().max(4096).optional()
-}).strict();
-var errorSchema = z2.object({
-  type: z2.literal("error"),
-  id: messageId,
-  error: z2.string().min(1).max(4096),
-  code: z2.string().max(64).optional()
-}).strict();
-var pingSchema = z2.object({ type: z2.literal("ping"), id: messageId }).strict();
-var pongSchema = z2.object({ type: z2.literal("pong"), id: messageId }).strict();
-var messageSchema = z2.discriminatedUnion("type", [
-  toolCallSchema,
-  toolResultSchema,
-  errorSchema,
-  pingSchema,
-  pongSchema
-]);
-function parseMessage(input) {
-  const data = typeof input === "string" ? parseJson(input) : input;
-  const result = messageSchema.safeParse(data);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    throw new ProtocolError(
-      `Invalid message: ${issue?.message ?? "validation failed"}`,
-      "INVALID_MESSAGE",
-      result.error
-    );
-  }
-  return result.data;
-}
-function validateOutgoing(message) {
-  parseMessage(message);
-}
-function parseJson(str) {
-  try {
-    return JSON.parse(str);
-  } catch {
-    throw new ProtocolError("Invalid JSON", "INVALID_JSON");
-  }
-}
-
-// src/relay/client.ts
-var DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_MAX_RETRIES = 5;
-var MAX_BACKOFF = 3e4;
-var RelayClient = class {
-  ws = null;
-  retryCount = 0;
-  closing = false;
-  config;
-  log;
-  constructor(config) {
-    this.config = {
-      url: config.url,
-      token: config.token,
-      tools: config.tools,
-      debug: config.debug ?? false,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT,
-      reconnect: config.reconnect ?? true,
-      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES
-    };
-    this.log = this.config.debug ? (...args) => console.log("[RelayClient]", ...args) : () => {
-    };
-  }
-  get connected() {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-  async connect() {
-    if (this.ws?.readyState === WebSocket.OPEN) return;
-    this.closing = false;
-    await this.createConnection();
-  }
-  async disconnect() {
-    this.closing = true;
-    if (!this.ws) return;
-    return new Promise((resolve) => {
-      const ws = this.ws;
-      const cleanup = () => {
-        this.ws = null;
-        resolve();
-      };
-      ws.once("close", cleanup);
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.close(1e3, "Client disconnect");
-      } else {
-        cleanup();
-      }
-      setTimeout(() => {
-        ws.terminate();
-        cleanup();
-      }, 5e3);
-    });
-  }
-  createConnection() {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.ws?.terminate();
-        reject(new Error(`Connection timeout (${this.config.timeout}ms)`));
-      }, this.config.timeout);
-      this.log(`Connecting to ${this.config.url}`);
-      this.ws = new WebSocket(this.config.url, {
-        headers: { Authorization: `Bearer ${this.config.token}` }
-      });
-      this.ws.on("open", () => {
-        clearTimeout(timeout);
-        this.retryCount = 0;
-        this.log("Connected");
-        resolve();
-      });
-      this.ws.on("message", (data) => this.onMessage(data));
-      this.ws.on("close", (code, reason) => {
-        clearTimeout(timeout);
-        this.log(`Closed: ${code} ${reason.toString()}`);
-        this.ws = null;
-        if (!this.closing && this.config.reconnect) {
-          this.reconnect();
-        }
-      });
-      this.ws.on("error", (error) => {
-        clearTimeout(timeout);
-        this.log(`Error: ${error.message}`);
-        reject(error);
-      });
-    });
-  }
-  async reconnect() {
-    if (this.retryCount >= this.config.maxRetries) {
-      this.log(`Max retries (${this.config.maxRetries}) exceeded`);
-      return;
-    }
-    this.retryCount++;
-    const delay = Math.min(1e3 * Math.pow(2, this.retryCount - 1), MAX_BACKOFF);
-    this.log(`Reconnecting in ${delay}ms (attempt ${this.retryCount})`);
-    await new Promise((r) => setTimeout(r, delay));
-    if (this.closing) return;
-    try {
-      await this.createConnection();
-      this.log("Reconnected");
-    } catch (error) {
-      this.log(`Reconnect failed: ${error}`);
-      if (!this.closing && this.config.reconnect) {
-        this.reconnect();
-      }
-    }
-  }
-  onMessage(data) {
-    try {
-      const message = parseMessage(data.toString());
-      switch (message.type) {
-        case "tool_call":
-          this.handleToolCall(message);
-          break;
-        case "ping":
-          this.send({ type: "pong", id: message.id });
-          break;
-        case "pong":
-          break;
-        default:
-          this.log(`Unexpected message type: ${message.type}`);
-      }
-    } catch (error) {
-      if (error instanceof ProtocolError) {
-        this.log(`Protocol error: ${error.message}`);
-      } else {
-        this.log(`Message error: ${error}`);
-      }
-    }
-  }
-  async handleToolCall(message) {
-    const { id, tool: name, arguments: args } = message;
-    this.log(`Tool call: ${name}`, args);
-    const tool = this.config.tools.get(name);
-    if (!tool) {
-      this.send({ type: "error", id, error: `Unknown tool: ${name}`, code: "UNKNOWN_TOOL" });
-      return;
-    }
-    try {
-      const result = await tool.execute(args);
-      this.send({ type: "tool_result", id, success: true, result });
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : "Execution failed";
-      this.send({ type: "tool_result", id, success: false, error: msg.slice(0, 4096) });
-    }
-  }
-  send(message) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.log("Cannot send: not connected");
-      return;
-    }
-    try {
-      validateOutgoing(message);
-      this.ws.send(JSON.stringify(message));
-    } catch (error) {
-      this.log(`Invalid outgoing message:`, message, error);
-    }
-  }
-};
-
-// src/relay/server.ts
-function generateRelayServerCode(config) {
-  return RELAY_SERVER_TEMPLATE.replace(/__PORT__/g, String(config.port)).replace(/__TOKEN__/g, config.token).replace(/__TIMEOUT__/g, String(config.timeout)).replace(/__DEBUG__/g, String(config.debug));
-}
-function generateToolFunctions(tools) {
-  return tools.map((tool) => {
-    const snakeName = toSnakeCase2(tool.name);
-    return `async function ${snakeName}(args: Record<string, unknown> = {}) { return callTool('${tool.name}', args); }`;
-  }).join("\n");
-}
-function toSnakeCase2(str) {
-  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
-}
-var RELAY_SERVER_TEMPLATE = `
-const config = { port: __PORT__, token: '__TOKEN__', timeout: __TIMEOUT__, debug: __DEBUG__ };
-const log = (...a: unknown[]) => config.debug && console.error('[Relay]', ...a);
-
-let ws: any = null;
-const pending = new Map<string, { resolve: (r: any) => void; timer: any }>();
-
-Bun.serve({
-  port: config.port,
-  hostname: '127.0.0.1',
-  async fetch(req: Request, server: any) {
-    const url = new URL(req.url);
-    if (url.pathname === '/ws') {
-      if (req.headers.get('authorization') !== 'Bearer ' + config.token) return new Response('', { status: 401 });
-      return server.upgrade(req) ? undefined : new Response('', { status: 500 });
-    }
-    if (req.method === 'POST' && url.pathname === '/tool') {
-      const { tool, arguments: args } = await req.json();
-      if (!ws) return Response.json({ success: false, error: 'Host not connected' });
-      const id = crypto.randomUUID();
-      return Response.json(await new Promise(resolve => {
-        const timer = setTimeout(() => { pending.delete(id); resolve({ success: false, error: 'Timeout' }); }, config.timeout * 1000);
-        pending.set(id, { resolve, timer });
-        ws.send(JSON.stringify({ type: 'tool_call', id, tool, arguments: args ?? {} }));
-        log('Tool:', tool);
-      }));
-    }
-    if (url.pathname === '/health') return Response.json({ ok: true, connected: !!ws });
-    return new Response('', { status: 404 });
-  },
-  websocket: {
-    open(s: any) { log('Host connected'); ws = s; },
-    message(_: any, data: any) {
-      const msg = JSON.parse(String(data));
-      if (msg.type === 'tool_result' || msg.type === 'error') {
-        const p = pending.get(msg.id);
-        if (p) { clearTimeout(p.timer); pending.delete(msg.id); p.resolve(msg); }
-      } else if (msg.type === 'ping') ws?.send(JSON.stringify({ type: 'pong', id: msg.id }));
-    },
-    close() { log('Host disconnected'); ws = null; },
-  },
-});
-log('Ready');
-
-class ToolError extends Error { constructor(m: string) { super(m); this.name = 'ToolError'; } }
-async function callTool(name: string, args: Record<string, unknown> = {}): Promise<unknown> {
-  const r = await (await fetch('http://127.0.0.1:' + config.port + '/tool', {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ tool: name, arguments: args })
-  })).json() as any;
-  if (!r.success) throw new ToolError(name + ': ' + (r.error ?? 'failed'));
-  return r.result;
-}
-`.trim();
-
-// src/relay/types.ts
-var DEFAULT_RELAY_CONFIG = {
-  port: 8080,
-  token: "",
-  timeout: 300,
-  debug: false
-};
-
-// src/prompts.ts
-var EXAMPLE_CODE = `\`\`\`javascript
-// Example: Analyze sales data across regions
-
-// 1. Fetch data using tools (can loop for multiple calls)
-const regions = ["West", "East", "Central"];
-const results = {};
-for (const region of regions) {
-  const data = await query_database({ sql: \`SELECT SUM(revenue) FROM sales WHERE region = '\${region}'\` });
-  results[region] = data;
-}
-
-// 2. Process and analyze the data
-const total = Object.values(results).reduce((a, b) => a + b, 0);
-const topRegion = Object.entries(results).sort((a, b) => b[1] - a[1])[0];
-
-// 3. Print final results
-console.log(\`Total revenue: $\${total.toLocaleString()}\`);
-console.log(\`Top region: \${topRegion[0]} with $\${topRegion[1].toLocaleString()}\`);
-\`\`\``;
-function buildSystemPrompt(toolDefinitions, additionalInstructions) {
-  const sections = [
-    "You are an expert JavaScript programmer. Write JavaScript code that uses the available tools to accomplish the user's request.",
-    "",
-    "## How This Works",
-    "",
-    "1. You have access to tools as async functions",
-    "2. Write code that calls these tools, processes results, and logs output",
-    "3. Your code runs in a secure Node.js sandbox",
-    "4. Tool calls happen inside your code - loop, aggregate, and process results programmatically",
-    "5. Only the console output is returned to the user",
-    "",
-    "## Available Tools",
-    "",
-    toolDefinitions,
-    "",
-    "## Guidelines",
-    "",
-    "1. Write complete, executable JavaScript code",
-    "2. Tools are async - always use await: `const result = await tool_name({ arg1, arg2 })`",
-    "3. Use `console.log()` to output results - this is what the user sees",
-    "4. Process data in code before logging (don't dump raw data)",
-    "5. Use loops for batch operations",
-    "6. Wrap risky operations in try/catch",
-    "",
-    "## Example",
-    "",
-    EXAMPLE_CODE,
-    "",
-    "## Notes",
-    "",
-    "- All tools are async - use await",
-    "- Use modern JavaScript (ES2022+)",
-    "- Top-level await is supported"
-  ];
-  if (additionalInstructions) {
-    sections.push("", "## Additional Instructions", "", additionalInstructions);
-  }
-  sections.push(
-    "",
-    "Write JavaScript code to solve the user's request. Return ONLY the code in a ```javascript code block."
-  );
-  return sections.join("\n");
-}
-function extractCode(response) {
-  const jsMatch = response.match(/```(?:javascript|js)\s*\n([\s\S]*?)```/);
-  if (jsMatch) return jsMatch[1].trim();
-  const genericMatch = response.match(/```\s*\n([\s\S]*?)```/);
-  if (genericMatch) return genericMatch[1].trim();
-  return response.trim();
-}
-
-// src/type-hints.ts
-var MAX_DEPTH = 10;
-function generateTypeHints(tools) {
-  if (tools.length === 0) return "// No tools available";
-  const signatures = tools.map(generateToolSignature);
-  return ["// Available Tools", "// Call these as: const result = await tool_name({ args })", "", ...signatures].join("\n");
-}
-function generateToolSignature(tool) {
-  const snakeName = toSnakeCase3(tool.name);
-  const params = generateParams(tool.parameters);
-  const lines = [
-    `/**`,
-    ` * ${tool.description}`
-  ];
-  const shape = getObjectShape(tool.parameters);
-  if (shape && Object.keys(shape).length > 0) {
-    lines.push(` *`);
-    for (const [name, schema] of Object.entries(shape)) {
-      const desc = getDescription(schema);
-      const opt = isOptional(schema) ? " (optional)" : "";
-      lines.push(` * @param ${name} - ${desc || "No description"}${opt}`);
-    }
-  }
-  lines.push(` */`);
-  lines.push(`async function ${snakeName}(${params}): Promise<any>`);
-  lines.push("");
-  return lines.join("\n");
-}
-function generateParams(schema) {
-  const shape = getObjectShape(schema);
-  if (!shape || Object.keys(shape).length === 0) return "";
-  const entries = Object.entries(shape);
-  const required = [];
-  const optional = [];
-  for (const [name, fieldSchema] of entries) {
-    const jsType = zodToJS(fieldSchema, 0);
-    if (isOptional(fieldSchema)) {
-      optional.push(`${name}?: ${jsType}`);
-    } else {
-      required.push(`${name}: ${jsType}`);
-    }
-  }
-  const allParams = [...required, ...optional];
-  if (allParams.length === 0) return "";
-  return `{ ${allParams.join(", ")} }`;
-}
-function zodToJS(schema, depth) {
-  if (depth > MAX_DEPTH) return "any";
-  const def = getDef(schema);
-  const typeName = def.type;
-  switch (typeName) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "bigint":
-      return "bigint";
-    case "literal": {
-      const val = def.value;
-      if (typeof val === "string") return `'${val}'`;
-      return String(val);
-    }
-    case "enum": {
-      const entries = def.entries;
-      if (!entries || typeof entries !== "object") return "string";
-      const values = Object.values(entries);
-      if (values.length === 0) return "string";
-      return values.map((v) => `'${v}'`).join(" | ");
-    }
-    case "array": {
-      const element = def.element;
-      if (element) return `${zodToJS(element, depth + 1)}[]`;
-      return "any[]";
-    }
-    case "tuple": {
-      const items = def.items ?? [];
-      if (items.length === 0) return "[]";
-      return `[${items.map((i) => zodToJS(i, depth + 1)).join(", ")}]`;
-    }
-    case "set": {
-      const element = def.element;
-      if (element) return `Set<${zodToJS(element, depth + 1)}>`;
-      return "Set<any>";
-    }
-    case "object": {
-      const shape = getObjectShape(schema);
-      if (!shape || Object.keys(shape).length === 0) return "object";
-      return "Record<string, any>";
-    }
-    case "record": {
-      const valType = def.valueType ? zodToJS(def.valueType, depth + 1) : "any";
-      return `Record<string, ${valType}>`;
-    }
-    case "map": {
-      const keyType = def.keyType ? zodToJS(def.keyType, depth + 1) : "any";
-      const valType = def.valueType ? zodToJS(def.valueType, depth + 1) : "any";
-      return `Map<${keyType}, ${valType}>`;
-    }
-    case "union": {
-      const options = def.options ?? [];
-      if (options.length === 0) return "any";
-      const types = options.map((o) => zodToJS(o, depth + 1));
-      const unique = [...new Set(types)];
-      return unique.join(" | ");
-    }
-    case "optional":
-    case "nullable": {
-      const inner = def.innerType;
-      if (inner) return `${zodToJS(inner, depth + 1)} | null`;
-      return "any | null";
-    }
-    case "default": {
-      const inner = def.innerType;
-      if (inner) return zodToJS(inner, depth + 1);
-      return "any";
-    }
-    case "null":
-    case "undefined":
-    case "void":
-      return "null";
-    case "any":
-    case "unknown":
-      return "any";
-    case "never":
-      return "never";
-    case "date":
-      return "Date";
-    default:
-      return "any";
-  }
-}
-function getDef(schema) {
-  const s = schema;
-  return s._zod?.def ?? { type: "unknown" };
-}
-function getObjectShape(schema) {
-  const def = getDef(schema);
-  if (def.type !== "object") return null;
-  const shape = def.shape;
-  if (!shape) return null;
-  return typeof shape === "function" ? shape() : shape;
-}
-function getDescription(schema) {
-  const s = schema;
-  if (s.description) return s.description;
-  const def = getDef(schema);
-  if (def.innerType) return getDescription(def.innerType);
-  return "";
-}
-function isOptional(schema) {
-  const def = getDef(schema);
-  return def.type === "optional" || def.type === "default" || def.type === "nullable";
-}
-function toSnakeCase3(str) {
-  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
-}
-
-// src/executor.ts
-function createExecutor(options) {
-  return new ProgrammaticExecutor(options);
-}
-var ProgrammaticExecutor = class {
-  originalTools;
-  normalizedTools;
-  toolsMap;
-  llm;
-  timeout;
-  e2bApiKey;
-  instructions;
-  debug;
-  constructor(options) {
-    this.originalTools = options.tools;
-    this.normalizedTools = normalizeTools(options.tools);
-    this.toolsMap = new Map(this.normalizedTools.map((t) => [t.name, t]));
-    this.llm = options.llm;
-    this.timeout = options.timeout ?? 3e5;
-    this.e2bApiKey = options.e2bApiKey;
-    this.instructions = options.instructions;
-    this.debug = options.debug ?? false;
-  }
-  async run(userRequest) {
-    const startTime = Date.now();
-    const toolDocs = generateTypeHints(this.originalTools);
-    const systemPrompt = buildSystemPrompt(toolDocs, this.instructions);
-    this.log("Generating code for:", userRequest.slice(0, 100));
-    const generated = await this.generateCode(userRequest, systemPrompt);
-    const code = extractCode(generated.code);
-    this.log("Generated code:", code.slice(0, 500));
-    const result = await this.executeCode(code);
-    return {
-      code,
-      explanation: generated.explanation,
-      result: { ...result, executionTimeMs: Date.now() - startTime }
-    };
-  }
-  async executeCode(code) {
-    const startTime = Date.now();
-    const token = randomUUID();
-    const relayConfig = { ...DEFAULT_RELAY_CONFIG, token, debug: this.debug };
-    const setupCode = [
-      generateRelayServerCode(relayConfig),
-      generateToolFunctions(this.normalizedTools)
-    ].join("\n\n");
-    this.log("Creating E2B sandbox...");
-    const sandbox = await this.createSandbox();
-    let relayClient = null;
-    try {
-      const relayUrl = sandbox.getHost(relayConfig.port);
-      const wsUrl = `wss://${relayUrl}/ws`;
-      this.log("Relay URL:", wsUrl);
-      await sandbox.files.write("/tmp/relay.ts", setupCode);
-      const relayProc = await sandbox.commands.run("bun run /tmp/relay.ts", { background: true });
-      this.log("Relay server started, pid:", relayProc.pid);
-      await sleep(500);
-      this.log("Connecting to relay...");
-      relayClient = await this.connectRelay(wsUrl, token);
-      await sandbox.files.write("/tmp/main.ts", code);
-      this.log("Executing user code...");
-      const result = await sandbox.commands.run("bun run /tmp/main.ts");
-      return {
-        success: result.exitCode === 0,
-        output: result.stdout,
-        error: result.exitCode !== 0 ? result.stderr : void 0,
-        executionTimeMs: Date.now() - startTime
-      };
-    } finally {
-      await this.cleanup(relayClient, sandbox);
-    }
-  }
-  getTools() {
-    return this.normalizedTools;
-  }
-  getToolDocumentation() {
-    return generateTypeHints(this.originalTools);
-  }
-  async generateCode(request, systemPrompt) {
-    try {
-      return await this.llm.generateCode(request, systemPrompt);
-    } catch (error) {
-      throw new CodeGenerationError(
-        `Failed to generate code: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  async createSandbox() {
-    try {
-      return await Sandbox.create({
-        apiKey: this.e2bApiKey,
-        timeoutMs: this.timeout
-        // template: 'bun', // Uncomment when using custom Bun template
-      });
-    } catch (error) {
-      throw new SandboxError(
-        `Failed to create sandbox: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  async connectRelay(url, token) {
-    const client = new RelayClient({
-      url,
-      token,
-      tools: this.toolsMap,
-      debug: this.debug,
-      timeout: 3e4,
-      reconnect: false
-    });
-    try {
-      await client.connect();
-      return client;
-    } catch (error) {
-      throw new RelayConnectionError(
-        `Failed to connect to relay: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  async cleanup(client, sandbox) {
-    if (client) {
-      try {
-        await client.disconnect();
-        this.log("Relay client disconnected");
-      } catch {
-        this.log("Error disconnecting relay");
-      }
-    }
-    try {
-      await sandbox.kill();
-      this.log("Sandbox killed");
-    } catch {
-      this.log("Error killing sandbox");
-    }
-  }
-  log(...args) {
-    if (this.debug) console.log("[Executor]", ...args);
-  }
-};
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-export {
-  AuthenticationError,
-  CodeGenerationError,
-  ConfigurationError,
-  ExecutionError,
-  OPTError,
-  ProgrammaticExecutor,
-  RelayConnectionError,
-  RelayTimeoutError,
-  SandboxError,
-  ToolError,
-  buildSystemPrompt,
-  createExecutor,
-  defineTool,
-  extractCode,
-  generateTypeHints,
-  isTool,
-  normalizeTools,
-  z
-};