@execbox/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mouaad Aallam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# @execbox/core
+
+Executor-agnostic core for guest JavaScript that can call host tools directly or wrap MCP servers and clients into callable namespaces.
+
+[![npm version](https://img.shields.io/npm/v/%40execbox%2Fcore?style=flat-square)](https://www.npmjs.com/package/@execbox/core)
+[![License](https://img.shields.io/github/license/aallam/execbox?style=flat-square)](https://github.com/aallam/execbox/blob/main/LICENSE)
+
+## What You Get
+
+- Resolve host tools into deterministic guest namespaces with name sanitization.
+- Validate tool inputs and outputs with JSON Schema, full Zod schemas, or MCP SDK-style raw Zod shapes.
+- Normalize user code before execution and generate namespace typings from resolved schemas.
+- Wrap MCP servers or clients into execbox providers, or expose code-execution tools from an MCP server.
+
+## Pair It With an Executor
+
+`@execbox/core` does not execute code on its own. Pair it with one of the executor packages:
+
+| Package                                                                      | Best for                                                             |
+| ---------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| [`@execbox/quickjs`](https://www.npmjs.com/package/@execbox/quickjs)         | Easiest setup, no native addon, good default backend                 |
+| [`@execbox/remote`](https://www.npmjs.com/package/@execbox/remote)           | Same executor API, but with a caller-supplied remote boundary        |
+| [`@execbox/process`](https://www.npmjs.com/package/@execbox/process)         | QuickJS execution in a child process with a stronger lifecycle split |
+| [`@execbox/worker`](https://www.npmjs.com/package/@execbox/worker)           | QuickJS execution on a worker thread with a message boundary         |
+| [`@execbox/isolated-vm`](https://www.npmjs.com/package/@execbox/isolated-vm) | Native `isolated-vm` backend when you specifically want that runtime |
+
+## Examples
+
+- [Basic provider execution](https://github.com/aallam/execbox/blob/main/examples/execbox-basic.ts)
+- [Process-backed provider execution](https://github.com/aallam/execbox/blob/main/examples/execbox-process.ts)
+- [Remote provider execution](https://github.com/aallam/execbox/blob/main/examples/execbox-remote.ts)
+- [Worker-backed provider execution](https://github.com/aallam/execbox/blob/main/examples/execbox-worker.ts)
+- [Wrap MCP tools into a provider](https://github.com/aallam/execbox/blob/main/examples/execbox-mcp-provider.ts)
+- [Expose MCP code-execution tools from a server](https://github.com/aallam/execbox/blob/main/examples/execbox-mcp-server.ts)
+- [Run the same flow on `isolated-vm`](https://github.com/aallam/execbox/blob/main/examples/execbox-isolated-vm-basic.ts)
+- [Full examples index](https://github.com/aallam/execbox/tree/main/examples)
+
+## Install
+
+```bash
+npm install @execbox/core @execbox/quickjs
+```
+
+Swap in `@execbox/isolated-vm` when you want the native executor instead.
+Swap in `@execbox/process` when you want the QuickJS runtime to live in a fresh child process.
+Swap in `@execbox/remote` when you want the same API but a caller-managed remote transport boundary.
+
+## Security Posture
+
+- Execbox gives you fresh execution state, JSON-only tool boundaries, schema validation, timeout handling, memory limits, and bounded logs.
+- Execbox does not give you a hard security boundary for hostile code by itself. The actual boundary depends on which executor you pair it with.
+- Providers are explicit capability grants. Every tool you expose is authority you are handing to guest code.
+- In the default deployment model, provider and MCP tool definitions are controlled by the application, not by the end user.
+- Third-party MCP integrations should be reviewed as dependency-trust decisions, not folded into the primary end-user attacker model.
+- If the code source is hostile, prefer stronger isolation such as `@execbox/process`, `@execbox/remote`, a container, or a VM.
+
+## Architecture Docs
+
+- [Execbox architecture overview](https://github.com/aallam/execbox/blob/main/docs/execbox/architecture/README.md)
+- [Execbox core architecture](https://github.com/aallam/execbox/blob/main/docs/execbox/architecture/execbox-core.md)
+- [Execbox executors](https://github.com/aallam/execbox/blob/main/docs/execbox/architecture/execbox-executors.md)
+- [Execbox MCP adapters and protocol](https://github.com/aallam/execbox/blob/main/docs/execbox/architecture/execbox-mcp-and-protocol.md)
+
+## Exports
+
+- `@execbox/core`
+  - `ExecutionOptions`
+  - `resolveProvider`
+  - `normalizeCode`
+  - `sanitizeToolName`
+  - `extractProviderManifests`
+  - `createToolCallDispatcher`
+  - JSON Schema type generation and executor/result types
+- `@execbox/core/mcp`
+  - `createMcpToolProvider`
+  - `openMcpToolProvider`
+  - `getMcpToolSourceServerInfo`
+  - `codeMcpServer`
+
+## Basic Usage
+
+```ts
+import { resolveProvider } from "@execbox/core";
+import { QuickJsExecutor } from "@execbox/quickjs";
+import * as z from "zod";
+
+const provider = resolveProvider({
+  name: "tools",
+  tools: {
+    add: {
+      inputSchema: z.object({
+        x: z.number(),
+        y: z.number(),
+      }),
+      execute: async (input) => {
+        const { x, y } = input as { x: number; y: number };
+        return { sum: x + y };
+      },
+    },
+  },
+});
+
+const executor = new QuickJsExecutor();
+const result = await executor.execute(
+  "await tools.add({ x: 2, y: 5 })",
+  [provider],
+  { timeoutMs: 250 },
+);
+```
+
+## MCP Adapters
+
+Use `@execbox/core/mcp` when you want to wrap an MCP server or client into a tool provider, or expose code-execution tools from an MCP server. Wrapped tools preserve raw MCP `CallToolResult` envelopes so guest code can inspect `structuredContent` first and fall back to `content`.

package/dist/executor-C0lf5vWT.d.ts

@@ -0,0 +1,182 @@
+import { ZodRawShape, ZodTypeAny } from "zod";
+
+//#region src/types.d.ts
+
+/**
+ * JSON Schema-like object used by the public tool and type-generation APIs.
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Supported authoring formats for tool schemas.
+ */
+type ToolSchema = JsonSchema | ZodTypeAny | ZodRawShape;
+/**
+ * Stable error codes returned by executors and wrapped tool calls.
+ */
+type ExecuteErrorCode = "timeout" | "memory_limit" | "validation_error" | "tool_error" | "runtime_error" | "serialization_error" | "internal_error";
+/**
+ * Structured execution failure returned in {@link ExecuteResult}.
+ */
+interface ExecuteError {
+  /** Machine-readable error category. */
+  code: ExecuteErrorCode;
+  /** Human-readable failure message. */
+  message: string;
+}
+/**
+ * Structured result returned by every executor invocation.
+ */
+type ExecuteResult<T = unknown> = {
+  durationMs: number;
+  logs: string[];
+  ok: true;
+  result: T;
+} | {
+  durationMs: number;
+  error: ExecuteError;
+  logs: string[];
+  ok: false;
+};
+/**
+ * Context passed to every tool execution.
+ */
+interface ToolExecutionContext {
+  /** Abort signal cancelled when execution times out or tears down. */
+  signal: AbortSignal;
+  /** Provider namespace visible in guest code. */
+  providerName: string;
+  /** Sanitized tool identifier exposed inside the sandbox. */
+  safeToolName: string;
+  /** Original upstream tool name before sanitization. */
+  originalToolName: string;
+}
+/**
+ * Host-side tool definition before provider resolution.
+ */
+interface ToolDescriptor {
+  /** Optional human-readable description used in generated types and docs. */
+  description?: string;
+  /** Optional input schema validated before the tool is invoked. */
+  inputSchema?: ToolSchema;
+  /** Optional output schema validated after the tool resolves. */
+  outputSchema?: ToolSchema;
+  /** Tool implementation invoked by the host runtime. */
+  execute: (input: unknown, context: ToolExecutionContext) => Promise<unknown> | unknown;
+}
+/**
+ * Collection of tools exposed under a single guest namespace.
+ */
+interface ToolProvider {
+  /** Optional namespace shown in guest code. Defaults to `codemode`. */
+  name?: string;
+  /** Raw tools keyed by their original names. */
+  tools: Record<string, ToolDescriptor>;
+  /** Optional hand-authored type declarations overriding generated types. */
+  types?: string;
+}
+/**
+ * Tool descriptor after validation, sanitization, and execution wrapping.
+ */
+interface ResolvedToolDescriptor {
+  /** Optional human-readable description used in generated types and docs. */
+  description?: string;
+  /** Normalized JSON Schema validated before the tool is invoked. */
+  inputSchema?: JsonSchema;
+  /** Normalized JSON Schema validated after the tool resolves. */
+  outputSchema?: JsonSchema;
+  /** Original upstream tool name. */
+  originalName: string;
+  /** Sanitized tool name visible in guest code. */
+  safeName: string;
+  /** Wrapped tool execution function used by executors. */
+  execute: (input: unknown, context: ToolExecutionContext) => Promise<unknown>;
+}
+/**
+ * Fully resolved provider consumed by executors and MCP adapters.
+ */
+interface ResolvedToolProvider {
+  /** Validated namespace visible in guest code. */
+  name: string;
+  /** Mapping from upstream tool names to sanitized guest names. */
+  originalToSafeName: Record<string, string>;
+  /** Reverse mapping from sanitized guest names to upstream tool names. */
+  safeToOriginalName: Record<string, string>;
+  /** Wrapped tools keyed by their sanitized names. */
+  tools: Record<string, ResolvedToolDescriptor>;
+  /** Generated or user-supplied type declarations for the provider namespace. */
+  types: string;
+}
+/**
+ * Tool shape consumed by JSON Schema type generation.
+ */
+type TypegenToolDescriptor = Pick<ResolvedToolDescriptor, "description" | "inputSchema" | "outputSchema"> & Partial<Pick<ResolvedToolDescriptor, "execute">>;
+//#endregion
+//#region src/runner.d.ts
+/**
+ * Transport-safe metadata for one exposed tool.
+ */
+interface ProviderToolManifest {
+  description?: string;
+  originalName: string;
+  safeName: string;
+}
+/**
+ * Namespace manifest shared with runner implementations.
+ */
+interface ProviderManifest {
+  name: string;
+  tools: Record<string, ProviderToolManifest>;
+  types: string;
+}
+/**
+ * Execution limits forwarded to runner implementations.
+ */
+interface ExecutorRuntimeOptions {
+  maxLogChars?: number;
+  maxLogLines?: number;
+  memoryLimitBytes?: number;
+  timeoutMs?: number;
+}
+/**
+ * Public execution options accepted by executors per call.
+ */
+interface ExecutionOptions extends ExecutorRuntimeOptions {
+  signal?: AbortSignal;
+}
+/**
+ * Tool invocation request emitted from a runner.
+ */
+interface ToolCall {
+  input: unknown;
+  providerName: string;
+  safeToolName: string;
+}
+/**
+ * Trusted host response to a tool invocation request.
+ */
+type ToolCallResult = {
+  ok: true;
+  result: unknown;
+} | {
+  error: ExecuteError;
+  ok: false;
+};
+/**
+ * Converts resolved providers into manifest metadata that reveals only namespace details.
+ */
+declare function extractProviderManifests(providers: ResolvedToolProvider[]): ProviderManifest[];
+/**
+ * Creates a host-side dispatcher for runner-emitted tool calls.
+ */
+declare function createToolCallDispatcher(providers: ResolvedToolProvider[], signal: AbortSignal): (call: ToolCall) => Promise<ToolCallResult>;
+//#endregion
+//#region src/executor/executor.d.ts
+/**
+ * Executes JavaScript against one or more resolved tool providers.
+ */
+interface Executor {
+  execute(code: string, providers: ResolvedToolProvider[], options?: ExecutionOptions): Promise<ExecuteResult>;
+}
+//#endregion
+export { ToolExecutionContext as _, ProviderToolManifest as a, TypegenToolDescriptor as b, createToolCallDispatcher as c, ExecuteErrorCode as d, ExecuteResult as f, ToolDescriptor as g, ResolvedToolProvider as h, ProviderManifest as i, extractProviderManifests as l, ResolvedToolDescriptor as m, ExecutionOptions as n, ToolCall as o, JsonSchema as p, ExecutorRuntimeOptions as r, ToolCallResult as s, Executor as t, ExecuteError as u, ToolProvider as v, ToolSchema as y };
+//# sourceMappingURL=executor-C0lf5vWT.d.ts.map

package/dist/executor-C0lf5vWT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-C0lf5vWT.d.ts","names":[],"sources":["../src/types.ts","../src/runner.ts","../src/executor/executor.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAKY,KALA,UAAA,GAAa,MAKH,CAAA,MAAA,EAAA,OAAA,CAAA;;;;AAAwC,KAAlD,UAAA,GAAa,UAAqC,GAAxB,UAAwB,GAAX,WAAW;AAK9D;AAYA;AAUA;AAiBiB,KAvCL,gBAAA,GAuCyB,SAE3B,GAAA,cAAW,GAAA,kBAAA,GAAA,YAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,gBAAA;AAYrB;;;AAUa,UAnDI,YAAA,CAmDJ;EACN;EAAO,IAAA,EAlDN,gBAkDM;EAMG;EAYA,OAAA,EAAA,MAAA;;;;;AAYoD,KAxEzD,aAwEyD,CAAA,IAAA,OAAA,CAAA,GAAA;EAMpD,UAAA,EAAA,MAAA;EAIK,IAAA,EAAA,MAAA,EAAA;EAEA,EAAA,EAAA,IAAA;EAEE,MAAA,EAjFV,CAiFU;CAAf,GAAA;EAAM,UAAA,EAAA,MAAA;EAQH,KAAA,EArFC,YAqFD;EACV,IAAA,EAAA,MAAA,EAAA;EADkC,EAAA,EAAA,KAAA;CAIrB;;;;UAjFE,oBAAA;;UAEP;ECzCO;EASA,YAAA,EAAA,MAAgB;EAShB;EAUA,YAAA,EAAA,MAAiB;EAOjB;EASL,gBAAA,EAAc,MAAA;AA2B1B;AAsBA;;;AAGU,UD3CO,cAAA,CC2CP;EAAqB;EAAR,WAAA,CAAA,EAAA,MAAA;EAAO;gBDvCd;;iBAEC;EEpEA;EAGF,OAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EFqEF,oBErEE,EAAA,GFsER,OEtEQ,CAAA,OAAA,CAAA,GAAA,OAAA;;;;;UF4EE,YAAA;;;;SAIR,eAAe;;;;;;;UAQP,sBAAA;;;;gBAID;;iBAEC;;;;;;qCAMoB,yBAAyB;;;;;UAM7C,oBAAA;;;;sBAIK;;sBAEA;;SAEb,eAAe;;;;;;;KAQZ,qBAAA,GAAwB,KAClC,0EAGA,QAAQ,KAAK;;;;;AAlIf;AAKY,UCKK,oBAAA,CDLK;EAAG,WAAA,CAAA,EAAA,MAAA;EAAa,YAAA,EAAA,MAAA;EAAa,QAAA,EAAA,MAAA;;AAKnD;AAYA;AAUA;AAiBiB,UC9BA,gBAAA,CD8BoB;EAcpB,IAAA,EAAA,MAAA;EAID,KAAA,EC9CP,MD8CO,CAAA,MAAA,EC9CQ,oBD8CR,CAAA;EAEC,KAAA,EAAA,MAAA;;;;AAWjB;AAYiB,UChEA,sBAAA,CDgEsB;EAIvB,WAAA,CAAA,EAAA,MAAA;EAEC,WAAA,CAAA,EAAA,MAAA;EAMoB,gBAAA,CAAA,EAAA,MAAA;EAAyB,SAAA,CAAA,EAAA,MAAA;;AAM9D;;;AAQwB,UChFP,gBAAA,SAAyB,sBDgFlB,CAAA;EAAf,MAAA,CAAA,EC/EE,WD+EF;;AAQT;;;AAIe,UCrFE,QAAA,CDqFF;EAAL,KAAA,EAAA,OAAA;EAAR,YAAA,EAAA,MAAA;EAAO,YAAA,EAAA,MAAA;;;;ACxHT;AASiB,KAmCL,cAAA,GAnCqB;EAShB,EAAA,EAAA,IAAA;EAUA,MAAA,EAAA,OAAA;AAOjB,CAAA,GAAiB;EASL,KAAA,EAMC,YANa;EA2BV,EAAA,EAAA,KAAA;AAsBhB,CAAA;;;;AAG+B,iBAzBf,wBAAA,CAyBe,SAAA,EAxBlB,oBAwBkB,EAAA,CAAA,EAvB5B,gBAuB4B,EAAA;;;;iBAHf,wBAAA,YACH,gCACH,qBACA,aAAa,QAAQ;;;;AD1G/B;AAKA;AAAyB,UEJR,QAAA,CFIQ;EAAa,OAAA,CAAA,IAAA,EAAA,MAAA,EAAA,SAAA,EEDvB,oBFCuB,EAAA,EAAA,OAAA,CAAA,EEAxB,gBFAwB,CAAA,EECjC,OFDiC,CECzB,aFDyB,CAAA"}

package/dist/executor-DcnjQGwA.d.cts

@@ -0,0 +1,182 @@
+import { ZodRawShape, ZodTypeAny } from "zod";
+
+//#region src/types.d.ts
+
+/**
+ * JSON Schema-like object used by the public tool and type-generation APIs.
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Supported authoring formats for tool schemas.
+ */
+type ToolSchema = JsonSchema | ZodTypeAny | ZodRawShape;
+/**
+ * Stable error codes returned by executors and wrapped tool calls.
+ */
+type ExecuteErrorCode = "timeout" | "memory_limit" | "validation_error" | "tool_error" | "runtime_error" | "serialization_error" | "internal_error";
+/**
+ * Structured execution failure returned in {@link ExecuteResult}.
+ */
+interface ExecuteError {
+  /** Machine-readable error category. */
+  code: ExecuteErrorCode;
+  /** Human-readable failure message. */
+  message: string;
+}
+/**
+ * Structured result returned by every executor invocation.
+ */
+type ExecuteResult<T = unknown> = {
+  durationMs: number;
+  logs: string[];
+  ok: true;
+  result: T;
+} | {
+  durationMs: number;
+  error: ExecuteError;
+  logs: string[];
+  ok: false;
+};
+/**
+ * Context passed to every tool execution.
+ */
+interface ToolExecutionContext {
+  /** Abort signal cancelled when execution times out or tears down. */
+  signal: AbortSignal;
+  /** Provider namespace visible in guest code. */
+  providerName: string;
+  /** Sanitized tool identifier exposed inside the sandbox. */
+  safeToolName: string;
+  /** Original upstream tool name before sanitization. */
+  originalToolName: string;
+}
+/**
+ * Host-side tool definition before provider resolution.
+ */
+interface ToolDescriptor {
+  /** Optional human-readable description used in generated types and docs. */
+  description?: string;
+  /** Optional input schema validated before the tool is invoked. */
+  inputSchema?: ToolSchema;
+  /** Optional output schema validated after the tool resolves. */
+  outputSchema?: ToolSchema;
+  /** Tool implementation invoked by the host runtime. */
+  execute: (input: unknown, context: ToolExecutionContext) => Promise<unknown> | unknown;
+}
+/**
+ * Collection of tools exposed under a single guest namespace.
+ */
+interface ToolProvider {
+  /** Optional namespace shown in guest code. Defaults to `codemode`. */
+  name?: string;
+  /** Raw tools keyed by their original names. */
+  tools: Record<string, ToolDescriptor>;
+  /** Optional hand-authored type declarations overriding generated types. */
+  types?: string;
+}
+/**
+ * Tool descriptor after validation, sanitization, and execution wrapping.
+ */
+interface ResolvedToolDescriptor {
+  /** Optional human-readable description used in generated types and docs. */
+  description?: string;
+  /** Normalized JSON Schema validated before the tool is invoked. */
+  inputSchema?: JsonSchema;
+  /** Normalized JSON Schema validated after the tool resolves. */
+  outputSchema?: JsonSchema;
+  /** Original upstream tool name. */
+  originalName: string;
+  /** Sanitized tool name visible in guest code. */
+  safeName: string;
+  /** Wrapped tool execution function used by executors. */
+  execute: (input: unknown, context: ToolExecutionContext) => Promise<unknown>;
+}
+/**
+ * Fully resolved provider consumed by executors and MCP adapters.
+ */
+interface ResolvedToolProvider {
+  /** Validated namespace visible in guest code. */
+  name: string;
+  /** Mapping from upstream tool names to sanitized guest names. */
+  originalToSafeName: Record<string, string>;
+  /** Reverse mapping from sanitized guest names to upstream tool names. */
+  safeToOriginalName: Record<string, string>;
+  /** Wrapped tools keyed by their sanitized names. */
+  tools: Record<string, ResolvedToolDescriptor>;
+  /** Generated or user-supplied type declarations for the provider namespace. */
+  types: string;
+}
+/**
+ * Tool shape consumed by JSON Schema type generation.
+ */
+type TypegenToolDescriptor = Pick<ResolvedToolDescriptor, "description" | "inputSchema" | "outputSchema"> & Partial<Pick<ResolvedToolDescriptor, "execute">>;
+//#endregion
+//#region src/runner.d.ts
+/**
+ * Transport-safe metadata for one exposed tool.
+ */
+interface ProviderToolManifest {
+  description?: string;
+  originalName: string;
+  safeName: string;
+}
+/**
+ * Namespace manifest shared with runner implementations.
+ */
+interface ProviderManifest {
+  name: string;
+  tools: Record<string, ProviderToolManifest>;
+  types: string;
+}
+/**
+ * Execution limits forwarded to runner implementations.
+ */
+interface ExecutorRuntimeOptions {
+  maxLogChars?: number;
+  maxLogLines?: number;
+  memoryLimitBytes?: number;
+  timeoutMs?: number;
+}
+/**
+ * Public execution options accepted by executors per call.
+ */
+interface ExecutionOptions extends ExecutorRuntimeOptions {
+  signal?: AbortSignal;
+}
+/**
+ * Tool invocation request emitted from a runner.
+ */
+interface ToolCall {
+  input: unknown;
+  providerName: string;
+  safeToolName: string;
+}
+/**
+ * Trusted host response to a tool invocation request.
+ */
+type ToolCallResult = {
+  ok: true;
+  result: unknown;
+} | {
+  error: ExecuteError;
+  ok: false;
+};
+/**
+ * Converts resolved providers into manifest metadata that reveals only namespace details.
+ */
+declare function extractProviderManifests(providers: ResolvedToolProvider[]): ProviderManifest[];
+/**
+ * Creates a host-side dispatcher for runner-emitted tool calls.
+ */
+declare function createToolCallDispatcher(providers: ResolvedToolProvider[], signal: AbortSignal): (call: ToolCall) => Promise<ToolCallResult>;
+//#endregion
+//#region src/executor/executor.d.ts
+/**
+ * Executes JavaScript against one or more resolved tool providers.
+ */
+interface Executor {
+  execute(code: string, providers: ResolvedToolProvider[], options?: ExecutionOptions): Promise<ExecuteResult>;
+}
+//#endregion
+export { ToolExecutionContext as _, ProviderToolManifest as a, TypegenToolDescriptor as b, createToolCallDispatcher as c, ExecuteErrorCode as d, ExecuteResult as f, ToolDescriptor as g, ResolvedToolProvider as h, ProviderManifest as i, extractProviderManifests as l, ResolvedToolDescriptor as m, ExecutionOptions as n, ToolCall as o, JsonSchema as p, ExecutorRuntimeOptions as r, ToolCallResult as s, Executor as t, ExecuteError as u, ToolProvider as v, ToolSchema as y };
+//# sourceMappingURL=executor-DcnjQGwA.d.cts.map

package/dist/executor-DcnjQGwA.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-DcnjQGwA.d.cts","names":[],"sources":["../src/types.ts","../src/runner.ts","../src/executor/executor.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAKY,KALA,UAAA,GAAa,MAKH,CAAA,MAAA,EAAA,OAAA,CAAA;;;;AAAwC,KAAlD,UAAA,GAAa,UAAqC,GAAxB,UAAwB,GAAX,WAAW;AAK9D;AAYA;AAUA;AAiBiB,KAvCL,gBAAA,GAuCyB,SAE3B,GAAA,cAAW,GAAA,kBAAA,GAAA,YAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,gBAAA;AAYrB;;;AAUa,UAnDI,YAAA,CAmDJ;EACN;EAAO,IAAA,EAlDN,gBAkDM;EAMG;EAYA,OAAA,EAAA,MAAA;;;;;AAYoD,KAxEzD,aAwEyD,CAAA,IAAA,OAAA,CAAA,GAAA;EAMpD,UAAA,EAAA,MAAA;EAIK,IAAA,EAAA,MAAA,EAAA;EAEA,EAAA,EAAA,IAAA;EAEE,MAAA,EAjFV,CAiFU;CAAf,GAAA;EAAM,UAAA,EAAA,MAAA;EAQH,KAAA,EArFC,YAqFD;EACV,IAAA,EAAA,MAAA,EAAA;EADkC,EAAA,EAAA,KAAA;CAIrB;;;;UAjFE,oBAAA;;UAEP;ECzCO;EASA,YAAA,EAAA,MAAgB;EAShB;EAUA,YAAA,EAAA,MAAiB;EAOjB;EASL,gBAAA,EAAc,MAAA;AA2B1B;AAsBA;;;AAGU,UD3CO,cAAA,CC2CP;EAAqB;EAAR,WAAA,CAAA,EAAA,MAAA;EAAO;gBDvCd;;iBAEC;EEpEA;EAGF,OAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EFqEF,oBErEE,EAAA,GFsER,OEtEQ,CAAA,OAAA,CAAA,GAAA,OAAA;;;;;UF4EE,YAAA;;;;SAIR,eAAe;;;;;;;UAQP,sBAAA;;;;gBAID;;iBAEC;;;;;;qCAMoB,yBAAyB;;;;;UAM7C,oBAAA;;;;sBAIK;;sBAEA;;SAEb,eAAe;;;;;;;KAQZ,qBAAA,GAAwB,KAClC,0EAGA,QAAQ,KAAK;;;;;AAlIf;AAKY,UCKK,oBAAA,CDLK;EAAG,WAAA,CAAA,EAAA,MAAA;EAAa,YAAA,EAAA,MAAA;EAAa,QAAA,EAAA,MAAA;;AAKnD;AAYA;AAUA;AAiBiB,UC9BA,gBAAA,CD8BoB;EAcpB,IAAA,EAAA,MAAA;EAID,KAAA,EC9CP,MD8CO,CAAA,MAAA,EC9CQ,oBD8CR,CAAA;EAEC,KAAA,EAAA,MAAA;;;;AAWjB;AAYiB,UChEA,sBAAA,CDgEsB;EAIvB,WAAA,CAAA,EAAA,MAAA;EAEC,WAAA,CAAA,EAAA,MAAA;EAMoB,gBAAA,CAAA,EAAA,MAAA;EAAyB,SAAA,CAAA,EAAA,MAAA;;AAM9D;;;AAQwB,UChFP,gBAAA,SAAyB,sBDgFlB,CAAA;EAAf,MAAA,CAAA,EC/EE,WD+EF;;AAQT;;;AAIe,UCrFE,QAAA,CDqFF;EAAL,KAAA,EAAA,OAAA;EAAR,YAAA,EAAA,MAAA;EAAO,YAAA,EAAA,MAAA;;;;ACxHT;AASiB,KAmCL,cAAA,GAnCqB;EAShB,EAAA,EAAA,IAAA;EAUA,MAAA,EAAA,OAAA;AAOjB,CAAA,GAAiB;EASL,KAAA,EAMC,YANa;EA2BV,EAAA,EAAA,KAAA;AAsBhB,CAAA;;;;AAG+B,iBAzBf,wBAAA,CAyBe,SAAA,EAxBlB,oBAwBkB,EAAA,CAAA,EAvB5B,gBAuB4B,EAAA;;;;iBAHf,wBAAA,YACH,gCACH,qBACA,aAAa,QAAQ;;;;AD1G/B;AAKA;AAAyB,UEJR,QAAA,CFIQ;EAAa,OAAA,CAAA,IAAA,EAAA,MAAA,EAAA,SAAA,EEDvB,oBFCuB,EAAA,EAAA,OAAA,CAAA,EEAxB,gBFAwB,CAAA,EECjC,OFDiC,CECzB,aFDyB,CAAA"}