@executor-js/execution 1.4.32 → 1.5.0

package/README.md

@@ -51,6 +51,25 @@ console.log(result);
 // { result: 12, logs: [...] }
 ```
 
+## Custom tool discovery
+
+`tools.search(...)` uses Executor's built-in lexical tool discovery by default. Hosts can provide their own implementation, such as an indexed or semantic search provider, without replacing the sandbox runtime:
+
+```ts
+import { createExecutionEngine, type ToolDiscoveryProvider } from "@executor-js/execution";
+
+const toolDiscoveryProvider: ToolDiscoveryProvider = {
+  searchTools: ({ query, namespace, limit, offset }) =>
+    mySearchIndex.searchTools({ query, namespace, limit, offset }),
+};
+
+const engine = createExecutionEngine({
+  executor,
+  codeExecutor: makeQuickJsExecutor(),
+  toolDiscoveryProvider,
+});
+```
+
 ## Pause/resume for elicitation
 
 When the host doesn't support inline elicitation, use `executeWithPause` to intercept the first request as a pause point:

package/dist/{chunk-OLPHXJSA.js → chunk-Q2R6Q3HF.js}

@@ -7,7 +7,13 @@ var ExecutionToolError = class extends Data.TaggedError("ExecutionToolError") {
 // src/tool-invoker.ts
 import { Effect, Predicate } from "effect";
 import * as Cause from "effect/Cause";
-import { isToolResult, ToolResult } from "@executor-js/sdk/core";
+import {
+  authToolFailure,
+  isToolResult,
+  ToolResult,
+  ToolAddress,
+  parseToolAddress
+} from "@executor-js/sdk/core";
 var OPAQUE_DEFECT_MESSAGE = "Internal tool error";
 var TOOL_ERROR_TYPESCRIPT = "{ code: string; message: string; status?: number; details?: unknown; retryable?: boolean }";
 var wrapOutputTypeScript = (outputTypeScript) => `{ ok: true; data: ${outputTypeScript ?? "unknown"} } | { ok: false; error: ToolError }`;
@@ -15,6 +21,56 @@ var withToolResultDefinitions = (definitions) => ({
   ...definitions ?? {},
   ToolError: TOOL_ERROR_TYPESCRIPT
 });
+var ADDRESS_PREFIX = "tools.";
+var pathToAddress = (path) => {
+  if (path.startsWith(ADDRESS_PREFIX)) return ToolAddress.make(path);
+  if (parseToolAddress(`${ADDRESS_PREFIX}${path}`)) {
+    return ToolAddress.make(`${ADDRESS_PREFIX}${path}`);
+  }
+  return ToolAddress.make(path);
+};
+var addressToPath = (address) => address.startsWith(ADDRESS_PREFIX) ? address.slice(ADDRESS_PREFIX.length) : address;
+var BUILTIN_TOOL_DESCRIPTIONS = /* @__PURE__ */ new Map([
+  [
+    "search",
+    {
+      path: "search",
+      name: "search",
+      description: "Search available Executor tools.",
+      inputTypeScript: "{ query: string; namespace?: string; limit?: number; offset?: number; }",
+      outputTypeScript: "{ items: ToolDiscoveryResult[]; total: number; hasMore: boolean; nextOffset: number | null; }",
+      typeScriptDefinitions: {
+        ToolDiscoveryResult: "{ path: string; name: string; description?: string; integration: string; score: number; }"
+      }
+    }
+  ],
+  [
+    "executor.sources.list",
+    {
+      path: "executor.sources.list",
+      name: "executor.sources.list",
+      description: "List configured Executor integrations.",
+      inputTypeScript: "{ query?: string; limit?: number; offset?: number; }",
+      outputTypeScript: "{ items: ExecutorSourceListItem[]; total: number; hasMore: boolean; nextOffset: number | null; }",
+      typeScriptDefinitions: {
+        ExecutorSourceListItem: "{ id: string; name: string; kind: string; canRemove?: boolean; canRefresh?: boolean; toolCount: number; }"
+      }
+    }
+  ],
+  [
+    "describe.tool",
+    {
+      path: "describe.tool",
+      name: "describe.tool",
+      description: "Describe a tool's compact TypeScript input and output shapes.",
+      inputTypeScript: "{ path: string; }",
+      outputTypeScript: "DescribedTool",
+      typeScriptDefinitions: {
+        DescribedTool: "{ path: string; name: string; description?: string; inputTypeScript?: string; outputTypeScript?: string; typeScriptDefinitions?: { [k: string]: string; }; }"
+      }
+    }
+  ]
+]);
 var newCorrelationId = () => {
   return Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
 };
@@ -23,19 +79,28 @@ var validationIssues = (value) => {
   const issues = value.issues;
   return Array.isArray(issues) ? issues : null;
 };
+var credentialResolutionToolFailure = (input) => authToolFailure({
+  code: input.reauthRequired === true ? "oauth_reauth_required" : "oauth_refresh_failed",
+  message: input.reauthRequired === true ? `OAuth connection "${input.label}" requires reauthorization: ${input.message}` : `OAuth connection "${input.label}" could not be resolved: ${input.message}`,
+  credential: {
+    kind: "oauth",
+    label: input.label
+  }
+});
 var expectedToolFailure = (value) => {
-  if (Predicate.isTagged(value, "ToolNotFoundError") && "toolId" in value) {
-    const suggestions = "suggestions" in value && Array.isArray(value.suggestions) ? value.suggestions : void 0;
+  if (Predicate.isTagged(value, "ToolNotFoundError") && "address" in value) {
+    const suggestions = "suggestions" in value && Array.isArray(value.suggestions) ? value.suggestions.map((suggestion) => addressToPath(String(suggestion))) : void 0;
+    const address = addressToPath(String(value.address));
     return {
       code: "tool_not_found",
-      message: `Tool not found: ${String(value.toolId)}`,
-      details: { toolId: value.toolId, ...suggestions ? { suggestions } : {} }
+      message: `Tool not found: ${address}`,
+      details: { path: address, ...suggestions ? { suggestions } : {} }
     };
   }
-  if (Predicate.isTagged(value, "ToolBlockedError") && "toolId" in value) {
+  if (Predicate.isTagged(value, "ToolBlockedError") && "address" in value) {
     return {
       code: "tool_blocked",
-      message: `Tool blocked by policy: ${String(value.toolId)}`,
+      message: `Tool blocked by policy: ${addressToPath(String(value.address))}`,
       details: value
     };
   }
@@ -51,17 +116,29 @@ var expectedToolFailure = (value) => {
   }
   return null;
 };
-var extractSourceNamespace = (path) => {
-  const idx = path.indexOf(".");
-  return idx === -1 ? path : path.slice(0, idx);
+var extractNamespace = (path) => {
+  const normalized = addressToPath(path);
+  const idx = normalized.indexOf(".");
+  return idx === -1 ? normalized : normalized.slice(0, idx);
 };
 var makeExecutorToolInvoker = (executor, options) => ({
   invoke: Effect.fn("mcp.tool.dispatch")(function* ({ path, args }) {
     yield* Effect.annotateCurrentSpan({
       "mcp.tool.name": path,
-      "mcp.tool.source_id": extractSourceNamespace(path)
+      "mcp.tool.integration": extractNamespace(path)
     });
-    const result = yield* executor.tools.invoke(path, args, options.invokeOptions).pipe(
+    const address = pathToAddress(path);
+    const result = yield* executor.execute(address, args, options.invokeOptions).pipe(
+      Effect.catchTag(
+        "CredentialResolutionError",
+        (err) => Effect.succeed(
+          credentialResolutionToolFailure({
+            label: `${err.integration}.${err.owner}.${err.name}`,
+            message: err.message,
+            reauthRequired: err.reauthRequired
+          })
+        )
+      ),
       Effect.catchCause((cause) => {
         const err = cause.reasons.find(Cause.isFailReason)?.error;
         const expected = expectedToolFailure(err);
@@ -71,7 +148,7 @@ var makeExecutorToolInvoker = (executor, options) => ({
         if (isElicitationDeclinedError(err)) {
           return Effect.fail(
             new ExecutionToolError({
-              message: `Tool "${err.toolId}" requires approval but the request was ${err.action === "cancel" ? "cancelled" : "declined"} by the user.`,
+              message: `Tool "${addressToPath(String(err.address))}" requires approval but the request was ${err.action === "cancel" ? "cancelled" : "declined"} by the user.`,
               cause: err
             })
           );
@@ -99,7 +176,7 @@ var makeExecutorToolInvoker = (executor, options) => ({
     return { ok: true, data: result };
   })
 });
-var isElicitationDeclinedError = (value) => Predicate.isTagged(value, "ElicitationDeclinedError") && value !== null && typeof value === "object" && "toolId" in value && typeof value.toolId === "string" && "action" in value && (value.action === "cancel" || value.action === "decline");
+var isElicitationDeclinedError = (value) => Predicate.isTagged(value, "ElicitationDeclinedError") && value !== null && typeof value === "object" && "address" in value && typeof value.address === "string" && "action" in value && (value.action === "cancel" || value.action === "decline");
 var paginate = (all, offset, limit) => {
   const total = all.length;
   const start = Math.min(Math.max(offset, 0), total);
@@ -113,9 +190,15 @@ var paginate = (all, offset, limit) => {
     nextOffset: hasMore ? consumed : null
   };
 };
+var toSearchableTool = (tool) => ({
+  path: addressToPath(String(tool.address)),
+  integration: String(tool.integration),
+  name: String(tool.name),
+  description: tool.description
+});
 var SEARCH_FIELD_WEIGHTS = {
   path: 12,
-  sourceId: 8,
+  integration: 8,
   name: 10,
   description: 5
 };
@@ -175,10 +258,10 @@ var matchesNamespace = (tool, namespace) => {
   if (namespaceTokens.length === 0) {
     return true;
   }
-  const sourceTokens = tokenizeSearchText(tool.sourceId);
-  const pathTokens = tokenizeSearchText(tool.id);
+  const integrationTokens = tokenizeSearchText(tool.integration);
+  const pathTokens = tokenizeSearchText(tool.path);
   const isPrefixMatch = (tokens) => namespaceTokens.every((token, index) => tokens[index] === token);
-  return isPrefixMatch(sourceTokens) || isPrefixMatch(pathTokens);
+  return isPrefixMatch(integrationTokens) || isPrefixMatch(pathTokens);
 };
 var scoreToolMatch = (tool, query) => {
   const normalizedQuery = normalizeSearchText(query);
@@ -186,13 +269,13 @@ var scoreToolMatch = (tool, query) => {
   if (normalizedQuery.length === 0 || queryTokens.length === 0) {
     return null;
   }
-  const path = prepareField(tool.id);
-  const sourceId = prepareField(tool.sourceId);
+  const path = prepareField(tool.path);
+  const integration = prepareField(tool.integration);
   const name = prepareField(tool.name);
   const description = prepareField(tool.description);
   const fieldScores = [
     scorePreparedField(normalizedQuery, queryTokens, path, SEARCH_FIELD_WEIGHTS.path),
-    scorePreparedField(normalizedQuery, queryTokens, sourceId, SEARCH_FIELD_WEIGHTS.sourceId),
+    scorePreparedField(normalizedQuery, queryTokens, integration, SEARCH_FIELD_WEIGHTS.integration),
     scorePreparedField(normalizedQuery, queryTokens, name, SEARCH_FIELD_WEIGHTS.name),
     scorePreparedField(normalizedQuery, queryTokens, description, SEARCH_FIELD_WEIGHTS.description)
   ];
@@ -222,14 +305,14 @@ var scoreToolMatch = (tool, query) => {
   if (path.tokens[0] === queryTokens[0] || name.tokens[0] === queryTokens[0]) {
     score += 8;
   }
-  if (normalizeSearchText(tool.id) === normalizedQuery || normalizeSearchText(tool.name) === normalizedQuery) {
+  if (normalizeSearchText(tool.path) === normalizedQuery || normalizeSearchText(tool.name) === normalizedQuery) {
     score += 20;
   }
   return {
-    path: tool.id,
+    path: tool.path,
     name: tool.name,
     description: tool.description,
-    sourceId: tool.sourceId,
+    integration: tool.integration,
     score
   };
 };
@@ -258,7 +341,8 @@ var searchTools = Effect.fn("executor.tools.search")(function* (executor, query,
       })
     )
   );
-  const ranked = all.filter((tool) => matchesNamespace(tool, options?.namespace)).map((tool) => scoreToolMatch(tool, query)).filter(Predicate.isNotNull).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+  const searchable = all.map(toSearchableTool);
+  const ranked = searchable.filter((tool) => matchesNamespace(tool, options?.namespace)).map((tool) => scoreToolMatch(tool, query)).filter(Predicate.isNotNull).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
   const page = paginate(ranked, offset, limit);
   yield* Effect.annotateCurrentSpan({
     "executor.search.candidate_count": all.length,
@@ -268,48 +352,53 @@ var searchTools = Effect.fn("executor.tools.search")(function* (executor, query,
   });
   return page;
 });
+var defaultToolDiscoveryProvider = {
+  searchTools: ({ executor, query, namespace, limit, offset }) => searchTools(executor, query, limit, { namespace, offset })
+};
 var listExecutorSources = Effect.fn("executor.sources.list")(function* (executor, options) {
   const normalizedQuery = normalizeSearchText(options?.query ?? "");
   const limit = options?.limit ?? 50;
   const offset = options?.offset ?? 0;
-  const sources = yield* executor.sources.list().pipe(
+  const integrations = yield* executor.integrations.list().pipe(
     Effect.mapError(
       (cause) => new ExecutionToolError({
-        message: "Failed to list executor sources",
+        message: "Failed to list executor integrations",
         cause
       })
     )
   );
-  const filtered = normalizedQuery.length === 0 ? sources : sources.filter((source) => {
-    const haystack = normalizeSearchText([source.id, source.name, source.kind].join(" "));
+  const filtered = normalizedQuery.length === 0 ? integrations : integrations.filter((integration) => {
+    const haystack = normalizeSearchText(
+      [String(integration.slug), integration.description, integration.kind].join(" ")
+    );
     return tokenizeSearchText(normalizedQuery).every((token) => haystack.includes(token));
   });
   const allTools = yield* executor.tools.list({ includeAnnotations: false }).pipe(
     Effect.mapError(
       (cause) => new ExecutionToolError({
-        message: "Failed to list tools for source counts",
+        message: "Failed to list tools for integration counts",
         cause
       })
     )
   );
-  const toolCountBySource = /* @__PURE__ */ new Map();
+  const toolCountByIntegration = /* @__PURE__ */ new Map();
   for (const tool of allTools) {
-    toolCountBySource.set(tool.sourceId, (toolCountBySource.get(tool.sourceId) ?? 0) + 1);
+    const key = String(tool.integration);
+    toolCountByIntegration.set(key, (toolCountByIntegration.get(key) ?? 0) + 1);
   }
   const sortedWithCounts = filtered.map(
-    (source) => ({
-      id: source.id,
-      name: source.name,
-      kind: source.kind,
-      runtime: source.runtime,
-      canRemove: source.canRemove,
-      canRefresh: source.canRefresh,
-      toolCount: toolCountBySource.get(source.id) ?? 0
+    (integration) => ({
+      id: String(integration.slug),
+      name: String(integration.slug),
+      kind: integration.kind,
+      canRemove: integration.canRemove,
+      canRefresh: integration.canRefresh,
+      toolCount: toolCountByIntegration.get(String(integration.slug)) ?? 0
     })
   ).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
   const page = paginate(sortedWithCounts, offset, limit);
   yield* Effect.annotateCurrentSpan({
-    "executor.sources.candidate_count": sources.length,
+    "executor.sources.candidate_count": integrations.length,
     "executor.sources.match_count": sortedWithCounts.length,
     "executor.sources.result_count": page.items.length,
     "executor.sources.has_more": page.hasMore
@@ -318,7 +407,10 @@ var listExecutorSources = Effect.fn("executor.sources.list")(function* (executor
 });
 var describeTool = Effect.fn("executor.tools.describe")(function* (executor, path) {
   yield* Effect.annotateCurrentSpan({ "mcp.tool.name": path });
-  const schema = yield* executor.tools.schema(path);
+  const builtin = BUILTIN_TOOL_DESCRIPTIONS.get(path);
+  if (builtin) return builtin;
+  const address = pathToAddress(path);
+  const schema = yield* executor.tools.schema(address);
   if (schema === null) {
     return { path, name: path };
   }
@@ -335,23 +427,38 @@ var describeTool = Effect.fn("executor.tools.describe")(function* (executor, pat
 // src/description.ts
 import { Effect as Effect2 } from "effect";
 var buildExecuteDescription = (executor) => Effect2.gen(function* () {
-  const sources = yield* executor.sources.list().pipe(
+  const connections = yield* executor.connections.list().pipe(
     // oxlint-disable-next-line executor/no-effect-escape-hatch -- boundary: ExecutionEngine.getDescription currently exposes no error channel; engine typed-error widening is covered separately
     Effect2.orDie,
-    Effect2.withSpan("executor.sources.list")
+    Effect2.withSpan("executor.connections.list")
   );
-  const description = yield* Effect2.sync(() => formatDescription(sources)).pipe(
+  const description = yield* Effect2.sync(
+    () => formatDescription(connections.map((connection) => connectionPath(connection)))
+  ).pipe(
     Effect2.withSpan("schema.compile.description", {
-      attributes: { "executor.source_count": sources.length }
+      attributes: { "executor.connection_count": connections.length }
     })
   );
   yield* Effect2.annotateCurrentSpan({
-    "executor.source_count": sources.length,
-    "schema.kind": "execute"
+    "executor.connection_count": connections.length,
+    "schema.kind": "execute",
+    // Connection inventory so a failing session build (which runs this during
+    // init) names the callable prefixes it resolved without listing tools.
+    "executor.connection_addresses": connections.map((connection) => connectionPath(connection)).slice(0, 50).join(","),
+    "executor.connection_integrations": [
+      ...new Set(connections.map((connection) => String(connection.integration)))
+    ].join(","),
+    "executor.connection_owners": [
+      ...new Set(connections.map((connection) => connection.owner))
+    ].join(",")
   });
   return description;
 }).pipe(Effect2.withSpan("schema.describe.execute"));
-var formatDescription = (sources) => {
+var connectionPath = (connection) => {
+  const address = String(connection.address);
+  return address.startsWith("tools.") ? address.slice("tools.".length) : address;
+};
+var formatDescription = (connectionPrefixes) => {
   const lines = [
     "Execute TypeScript in a sandboxed runtime with access to configured API tools.",
     "",
@@ -361,35 +468,36 @@ var formatDescription = (sources) => {
     '2. `const path = matches[0]?.path; if (!path) return "No matching tools found.";`',
     "3. `const details = await tools.describe.tool({ path });`",
     "4. Use `details.inputTypeScript` / `details.outputTypeScript` and `details.typeScriptDefinitions` for compact shapes.",
-    "5. Use `tools.executor.sources.list()` when you need configured source inventory.",
+    "5. Use `tools.executor.coreTools.connections.list({})` when you need live saved-connection inventory.",
     "6. Call the tool: `const result = await tools.<path>(input);`",
     "",
     "## Rules",
     "",
     "- `tools.search()` returns paginated, ranked matches: `{ items, total, hasMore, nextOffset }`. Best-first. Use short intent phrases like `github issues`, `repo details`, or `create calendar event`.",
     '- When you already know the namespace, narrow with `tools.search({ namespace: "github", query: "issues" })`.',
-    "- `tools.executor.sources.list()` returns the same paged shape: `{ items: [{ id, toolCount, ... }], total, hasMore, nextOffset }`.",
+    "- `tools.executor.coreTools.connections.list({})` returns saved connections with `{ address, integration, owner, name, ... }`. The `address` field includes the leading `tools.` root.",
     "- Tool calls return a value union: `{ ok: true, data }` for success or `{ ok: false, error: { code, message, status?, details?, retryable? } }` for expected tool/domain failures. Branch on `result.ok`.",
-    "- If `hasMore` is true and you didn't find what you need, fetch the next page: `tools.search({ query, offset: nextOffset, limit })`. Same `offset` parameter on `tools.executor.sources.list({ offset, limit })`.",
-    "- Always use the namespace prefix when calling tools: `tools.<namespace>.<tool>(args)`. Example: `tools.home_assistant_rest_api.states.getState(...)` \u2014 not `tools.states.getState(...)`.",
-    "- The `tools` object is a lazy proxy \u2014 `Object.keys(tools)` won't work. Use `tools.search()` or `tools.executor.sources.list()` instead.",
-    '- Pass an object to system tools, e.g. `tools.search({ query: "..." })`, `tools.executor.sources.list()`, and `tools.describe.tool({ path })`.',
+    "- If `tools.search()` returns `hasMore: true` and you didn't find what you need, fetch the next page: `tools.search({ query, offset: nextOffset, limit })`.",
+    "- Always use the full address when calling tools: `tools.<integration>.<owner>.<connection>.<tool>(args)`. The `path` returned by `tools.search()` / `tools.describe.tool()` is already the exact path under `tools` \u2014 call `tools[path]` rather than guessing segments.",
+    "- The `tools` object is a lazy proxy \u2014 `Object.keys(tools)` won't work. Use `tools.search()` or `tools.executor.coreTools.connections.list({})` instead.",
+    '- Pass an object to system tools, e.g. `tools.search({ query: "..." })`, `tools.executor.coreTools.connections.list({})`, and `tools.describe.tool({ path })`.',
     "- `tools.describe.tool()` returns compact TypeScript shapes. Use `inputTypeScript`, `outputTypeScript`, and `typeScriptDefinitions`.",
     "- For tools that return large collections (e.g. `getStates`, `getAll`), filter results in code rather than calling per-item tools.",
     "- Do not use `fetch` \u2014 all API calls go through `tools.*`.",
     "- If execution pauses for interaction, resume it with the returned `resumePayload`.",
     "- TypeScript type syntax (`: T`, `as T`, generics, interfaces, type aliases) is stripped before execution \u2014 feel free to write idiomatic TypeScript using the shapes from `tools.describe.tool()`. Decorators and `enum` are not supported."
   ];
-  if (sources.length > 0) {
+  if (connectionPrefixes.length > 0) {
     lines.push("");
-    lines.push("## Available namespaces");
+    lines.push("## Available connection prefixes");
     lines.push("");
-    const sorted = [...sources].sort((a, b) => a.id.localeCompare(b.id)).slice(0, 50);
-    for (const source of sorted) {
-      lines.push(`- \`${source.id}\``);
+    lines.push("These are paths under `tools.`; append the final tool segment.");
+    const sorted = [...connectionPrefixes].sort((a, b) => a.localeCompare(b)).slice(0, 50);
+    for (const prefix of sorted) {
+      lines.push(`- \`${prefix}\``);
     }
-    if (sources.length > sorted.length) {
-      lines.push(`- ... ${sources.length - sorted.length} more`);
+    if (connectionPrefixes.length > sorted.length) {
+      lines.push(`- ... ${connectionPrefixes.length - sorted.length} more`);
     }
   }
   return lines.join("\n");
@@ -463,7 +571,7 @@ instructions: ${instructions}`);
         kind: isUrlElicitation ? "url" : "form",
         message: req.message,
         instructions,
-        toolId: String(paused.elicitationContext.toolId),
+        address: String(paused.elicitationContext.address),
         args: paused.elicitationContext.args,
         ...isUrlElicitation ? { url: req.url } : {},
         ...isFormElicitation ? { requestedSchema: req.requestedSchema } : {}
@@ -494,7 +602,7 @@ var readOptionalOffset = (value, toolName) => {
   }
   return Math.floor(value);
 };
-var makeFullInvoker = (executor, invokeOptions) => {
+var makeFullInvoker = (executor, invokeOptions, toolDiscoveryProvider) => {
   const base = makeExecutorToolInvoker(executor, { invokeOptions });
   return {
     invoke: ({ path, args }) => {
@@ -528,7 +636,10 @@ var makeFullInvoker = (executor, invokeOptions) => {
         if (Predicate2.isTagged(offset, "ExecutionToolError")) {
           return Effect3.fail(offset);
         }
-        return searchTools(executor, args.query ?? "", limit, {
+        return toolDiscoveryProvider.searchTools({
+          executor,
+          query: args.query ?? "",
+          limit,
           namespace: args.namespace,
           offset
         }).pipe(
@@ -609,7 +720,7 @@ var makeFullInvoker = (executor, invokeOptions) => {
   };
 };
 var createExecutionEngine = (config) => {
-  const { executor, codeExecutor } = config;
+  const { executor, codeExecutor, toolDiscoveryProvider = defaultToolDiscoveryProvider } = config;
   const pausedExecutions = /* @__PURE__ */ new Map();
   let nextId = 0;
   const awaitCompletionOrPause = (fiber, pauseQueue) => Effect3.raceFirst(
@@ -641,7 +752,11 @@ var createExecutionEngine = (config) => {
       yield* Queue.offer(pauseQueue, paused);
       return yield* Deferred.await(responseDeferred);
     });
-    const invoker = makeFullInvoker(executor, { onElicitation: elicitationHandler });
+    const invoker = makeFullInvoker(
+      executor,
+      { onElicitation: elicitationHandler },
+      toolDiscoveryProvider
+    );
     fiber = yield* Effect3.forkDetach(
       codeExecutor.execute(code, invoker).pipe(Effect3.withSpan("executor.code.exec"))
     );
@@ -665,9 +780,13 @@ var createExecutionEngine = (config) => {
       "mcp.execute.mode": "inline",
       "mcp.execute.code_length": code.length
     });
-    const invoker = makeFullInvoker(executor, {
-      onElicitation: options.onElicitation
-    });
+    const invoker = makeFullInvoker(
+      executor,
+      {
+        onElicitation: options.onElicitation
+      },
+      toolDiscoveryProvider
+    );
     return yield* codeExecutor.execute(code, invoker).pipe(Effect3.withSpan("executor.code.exec"));
   });
   return {
@@ -683,6 +802,7 @@ export {
   ExecutionToolError,
   makeExecutorToolInvoker,
   searchTools,
+  defaultToolDiscoveryProvider,
   listExecutorSources,
   describeTool,
   buildExecuteDescription,
@@ -690,4 +810,4 @@ export {
   formatPausedExecution,
   createExecutionEngine
 };
-//# sourceMappingURL=chunk-OLPHXJSA.js.map
+//# sourceMappingURL=chunk-Q2R6Q3HF.js.map