@rafads/execution 1.5.38

package/dist/chunk-EVYEEDLB.js

@@ -0,0 +1,1226 @@
+// src/errors.ts
+import * as Data from "effect/Data";
+import { CodeExecutionError } from "@rafads/codemode-core";
+var ExecutionToolError = class extends Data.TaggedError("ExecutionToolError") {
+};
+
+// src/tool-invoker.ts
+import { Effect, Predicate } from "effect";
+import * as Cause from "effect/Cause";
+import {
+  annotateToolResultOutcome,
+  authToolFailure,
+  isUserActionableError,
+  isToolResult,
+  ToolResult,
+  ToolAddress,
+  parseToolAddress
+} from "@rafads/sdk/core";
+var OPAQUE_DEFECT_MESSAGE = "Internal tool error";
+var TOOL_DESCRIBE_SUGGESTION_LIMIT = 5;
+var TOOL_ERROR_TYPESCRIPT = "{ code: string; message: string; status?: number; details?: unknown; retryable?: boolean }";
+var TOOL_HTTP_META_TYPESCRIPT = "{ status: number; headers: { [k: string]: string; } }";
+var TOOL_FILE_TYPESCRIPT = '{ _tag: "ToolFile"; name?: string; mimeType: string; encoding: "base64"; data: string; byteLength: number; }';
+var wrapOutputTypeScript = (outputTypeScript) => `{ ok: true; data: ${outputTypeScript ?? "unknown"}; http?: ToolHttpMeta } | { ok: false; error: ToolError }`;
+var withToolResultDefinitions = (definitions) => ({
+  ...definitions ?? {},
+  ToolError: TOOL_ERROR_TYPESCRIPT,
+  ToolHttpMeta: TOOL_HTTP_META_TYPESCRIPT,
+  ToolFile: TOOL_FILE_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. An empty query with a namespace enumerates that integration's full catalog, sorted by path.",
+      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.integrations.list",
+    {
+      path: "executor.integrations.list",
+      name: "executor.integrations.list",
+      description: "List configured Executor integrations.",
+      inputTypeScript: "{ query?: string; limit?: number; offset?: number; }",
+      outputTypeScript: "{ items: ExecutorIntegrationListItem[]; total: number; hasMore: boolean; nextOffset: number | null; }",
+      typeScriptDefinitions: {
+        ExecutorIntegrationListItem: "{ id: string; name: string; description?: 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; }; error?: { code: "tool_not_found"; message: string; suggestions?: string[]; }; }'
+      }
+    }
+  ],
+  [
+    "use",
+    {
+      path: "use",
+      name: "use",
+      description: 'Make an external service capability work in ONE call: state the need ("transactional email", "a database", or a provider name like "resend") and get back a wired, callable integration \u2014 resolve, add, and connect handled internally. Returns ready (tools callable now), pending (one human credential click left; re-press to check), compare (full ranked set, on request), or an honest no_match with the catalog taxonomy. The answer is ONE verified provider with a machine-readable `sponsored` label and the count of alternatives; override by pressing again with not: ["<id>"].',
+      inputTypeScript: "{ need: string; not?: string[]; compare?: boolean; }",
+      outputTypeScript: "UseNeedReply",
+      typeScriptDefinitions: {
+        UseNeedReply: '{ status: "ready"; provider: ProviderCard; alternativesCount: number; toolsPath?: string; instructions: string; } | { status: "pending"; provider: ProviderCard; alternativesCount: number; url: string; instructions: string; } | { status: "compare"; candidates: ProviderCard[]; instructions: string; } | { status: "no_match"; categories: string[]; instructions: string; } | { status: "error"; step: string; message: string; instructions: string; }',
+        ProviderCard: "{ id: string; name: string; domain: string; category: string; sponsored: boolean; offer?: { terms: string; url: string; }; verifiedAt: string; }"
+      }
+    }
+  ]
+]);
+var newCorrelationId = () => {
+  return Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
+};
+var validationIssues = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const issues = value.issues;
+  return Array.isArray(issues) ? issues : null;
+};
+var openApiPreflightMessage = (value) => {
+  if (!Predicate.isTagged(value, "OpenApiInvocationError")) return null;
+  const err = value;
+  if (err.cause !== void 0) return null;
+  if (!Predicate.isTagged(err.statusCode, "None")) return null;
+  return typeof err.message === "string" && err.message.length > 0 ? err.message : 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 bindingToolFailure = (value) => {
+  if (!Predicate.isTagged(value, "BindingError")) return null;
+  const maybeBinding = value;
+  const details = {};
+  if (typeof maybeBinding.role === "string") details.role = maybeBinding.role;
+  if (typeof maybeBinding.integration === "string") details.integration = maybeBinding.integration;
+  if (typeof maybeBinding.requestedConnection === "string") {
+    details.requestedConnection = maybeBinding.requestedConnection;
+  }
+  return {
+    code: "binding_error",
+    message: typeof maybeBinding.message === "string" ? maybeBinding.message : "Tool binding failed.",
+    ...Object.keys(details).length > 0 ? { details } : {}
+  };
+};
+var expectedToolFailure = (value) => {
+  if (isUserActionableError(value)) {
+    return {
+      code: value.code,
+      message: value.userMessage
+    };
+  }
+  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: ${address}`,
+      details: { path: address, ...suggestions ? { suggestions } : {} }
+    };
+  }
+  if (Predicate.isTagged(value, "ToolBlockedError") && "address" in value) {
+    return {
+      code: "tool_blocked",
+      message: `Tool blocked by policy: ${addressToPath(String(value.address))}`,
+      details: value
+    };
+  }
+  if (Predicate.isTagged(value, "ToolInvocationError")) {
+    const cause = value.cause;
+    if (isUserActionableError(cause)) {
+      return {
+        code: cause.code,
+        message: cause.userMessage
+      };
+    }
+    const binding = bindingToolFailure(cause);
+    if (binding) return binding;
+    const issues = validationIssues(cause);
+    if (issues) {
+      return {
+        code: "invalid_tool_arguments",
+        message: "Tool arguments did not match the input schema.",
+        details: { issues }
+      };
+    }
+    const preflight = openApiPreflightMessage(cause);
+    if (preflight) {
+      return {
+        code: "invalid_tool_arguments",
+        message: preflight
+      };
+    }
+  }
+  return null;
+};
+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.integration": extractNamespace(path)
+    });
+    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);
+        if (expected) {
+          return Effect.succeed(ToolResult.fail(expected));
+        }
+        if (isElicitationDeclinedError(err)) {
+          return Effect.fail(
+            new ExecutionToolError({
+              message: `Tool "${addressToPath(String(err.address))}" requires approval but the request was ${err.action === "cancel" ? "cancelled" : "declined"} by the user.`,
+              cause: err
+            })
+          );
+        }
+        const correlationId = newCorrelationId();
+        return Effect.logError("tool dispatch failed", cause).pipe(
+          Effect.annotateLogs({
+            "executor.correlation_id": correlationId,
+            "mcp.tool.name": path
+          }),
+          Effect.flatMap(
+            () => Effect.fail(
+              new ExecutionToolError({
+                message: `${OPAQUE_DEFECT_MESSAGE} [${correlationId}]`,
+                cause: err ?? cause
+              })
+            )
+          )
+        );
+      })
+    );
+    yield* annotateToolResultOutcome(result);
+    if (isToolResult(result)) {
+      return result;
+    }
+    return { ok: true, data: result };
+  })
+});
+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);
+  const items = all.slice(start, start + limit);
+  const consumed = start + items.length;
+  const hasMore = consumed < total;
+  return {
+    items,
+    total,
+    hasMore,
+    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,
+  integration: 8,
+  name: 10,
+  description: 5
+};
+var normalizeSearchText = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_./:-]+/g, " ").toLowerCase().trim();
+var tokenizeSearchText = (value) => normalizeSearchText(value).split(/[^a-z0-9]+/).map((token) => token.trim()).filter(Boolean);
+var prepareField = (value) => ({
+  raw: normalizeSearchText(value ?? ""),
+  tokens: tokenizeSearchText(value ?? "")
+});
+var scorePreparedField = (query, queryTokens, field, weight) => {
+  if (field.raw.length === 0) {
+    return {
+      score: 0,
+      matchedTokens: /* @__PURE__ */ new Set(),
+      exactPhraseMatch: false
+    };
+  }
+  let score = 0;
+  const matchedTokens = /* @__PURE__ */ new Set();
+  const exactPhraseMatch = query.length > 0 && field.raw.includes(query);
+  if (query.length > 0) {
+    if (field.raw === query) {
+      score += weight * 14;
+    } else if (field.raw.startsWith(query)) {
+      score += weight * 9;
+    } else if (exactPhraseMatch) {
+      score += weight * 6;
+    }
+  }
+  for (const token of queryTokens) {
+    if (field.tokens.includes(token)) {
+      score += weight * 4;
+      matchedTokens.add(token);
+      continue;
+    }
+    if (field.tokens.some((candidate) => candidate.startsWith(token) || token.startsWith(candidate))) {
+      score += weight * 2;
+      matchedTokens.add(token);
+      continue;
+    }
+    if (field.raw.includes(token)) {
+      score += weight;
+      matchedTokens.add(token);
+    }
+  }
+  return {
+    score,
+    matchedTokens,
+    exactPhraseMatch
+  };
+};
+var matchesNamespace = (tool, namespace) => {
+  if (!namespace || normalizeSearchText(namespace).length === 0) {
+    return true;
+  }
+  const namespaceTokens = tokenizeSearchText(namespace);
+  if (namespaceTokens.length === 0) {
+    return true;
+  }
+  const integrationTokens = tokenizeSearchText(tool.integration);
+  const pathTokens = tokenizeSearchText(tool.path);
+  const isPrefixMatch = (tokens) => namespaceTokens.every((token, index) => tokens[index] === token);
+  return isPrefixMatch(integrationTokens) || isPrefixMatch(pathTokens);
+};
+var scoreToolMatch = (tool, query) => {
+  const normalizedQuery = normalizeSearchText(query);
+  const queryTokens = tokenizeSearchText(query);
+  if (normalizedQuery.length === 0 || queryTokens.length === 0) {
+    return null;
+  }
+  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, integration, SEARCH_FIELD_WEIGHTS.integration),
+    scorePreparedField(normalizedQuery, queryTokens, name, SEARCH_FIELD_WEIGHTS.name),
+    scorePreparedField(normalizedQuery, queryTokens, description, SEARCH_FIELD_WEIGHTS.description)
+  ];
+  const matchedTokens = /* @__PURE__ */ new Set();
+  let score = 0;
+  let exactPhraseMatch = false;
+  for (const fieldScore of fieldScores) {
+    score += fieldScore.score;
+    exactPhraseMatch ||= fieldScore.exactPhraseMatch;
+    for (const token of fieldScore.matchedTokens) {
+      matchedTokens.add(token);
+    }
+  }
+  if (matchedTokens.size === 0) {
+    return null;
+  }
+  const coverage = matchedTokens.size / queryTokens.length;
+  const minimumCoverage = queryTokens.length <= 2 ? 1 : 0.6;
+  if (coverage < minimumCoverage && !exactPhraseMatch) {
+    return null;
+  }
+  if (coverage === 1) {
+    score += 25;
+  } else {
+    score += Math.round(coverage * 10);
+  }
+  if (path.tokens[0] === queryTokens[0] || name.tokens[0] === queryTokens[0]) {
+    score += 8;
+  }
+  if (normalizeSearchText(tool.path) === normalizedQuery || normalizeSearchText(tool.name) === normalizedQuery) {
+    score += 20;
+  }
+  return {
+    path: tool.path,
+    name: tool.name,
+    description: tool.description,
+    integration: tool.integration,
+    score
+  };
+};
+var searchTools = Effect.fn("executor.tools.search")(function* (executor, query, limit = 12, options) {
+  const offset = options?.offset ?? 0;
+  yield* Effect.annotateCurrentSpan({
+    "executor.search.query_length": query.length,
+    "executor.search.limit": limit,
+    "executor.search.offset": offset,
+    ...options?.namespace ? { "executor.search.namespace": options.namespace } : {}
+  });
+  const emptyQuery = normalizeSearchText(query).length === 0;
+  const hasNamespace = options?.namespace !== void 0 && normalizeSearchText(options.namespace).length > 0;
+  if (emptyQuery && !hasNamespace) {
+    return {
+      items: [],
+      total: 0,
+      hasMore: false,
+      nextOffset: null
+    };
+  }
+  const all = yield* executor.tools.list({ includeAnnotations: false }).pipe(
+    Effect.mapError(
+      (cause) => new ExecutionToolError({
+        message: "Failed to list tools for search",
+        cause
+      })
+    )
+  );
+  const searchable = all.map(toSearchableTool);
+  const ranked = emptyQuery ? searchable.filter((tool) => tool.integration === options?.namespace?.trim()).sort((left, right) => left.path.localeCompare(right.path)).map((tool) => ({
+    path: tool.path,
+    name: tool.name,
+    integration: tool.integration,
+    score: 0,
+    ...tool.description !== void 0 ? { description: tool.description } : {}
+  })) : 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,
+    "executor.search.match_count": ranked.length,
+    "executor.search.result_count": page.items.length,
+    "executor.search.has_more": page.hasMore
+  });
+  return page;
+});
+var defaultToolDiscoveryProvider = {
+  searchTools: ({ executor, query, namespace, limit, offset }) => searchTools(executor, query, limit, { namespace, offset })
+};
+var listExecutorIntegrations = Effect.fn("executor.integrations.list")(function* (executor, options) {
+  const normalizedQuery = normalizeSearchText(options?.query ?? "");
+  const limit = options?.limit ?? 50;
+  const offset = options?.offset ?? 0;
+  const integrations = yield* executor.integrations.list().pipe(
+    Effect.mapError(
+      (cause) => new ExecutionToolError({
+        message: "Failed to list executor integrations",
+        cause
+      })
+    )
+  );
+  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 integration counts",
+        cause
+      })
+    )
+  );
+  const toolCountByIntegration = /* @__PURE__ */ new Map();
+  for (const tool of allTools) {
+    const key = String(tool.integration);
+    toolCountByIntegration.set(key, (toolCountByIntegration.get(key) ?? 0) + 1);
+  }
+  const sortedWithCounts = filtered.map(
+    (integration) => ({
+      id: String(integration.slug),
+      name: String(integration.slug),
+      // The integration's catalog description — user-editable context the
+      // agent can use to pick an integration. Omitted when it just repeats the
+      // slug or display name (no information beyond identity).
+      ...integration.description && integration.description.toLowerCase() !== String(integration.slug).toLowerCase() && integration.description.toLowerCase() !== integration.name.toLowerCase() ? { description: integration.description } : {},
+      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.integrations.candidate_count": integrations.length,
+    "executor.integrations.match_count": sortedWithCounts.length,
+    "executor.integrations.result_count": page.items.length,
+    "executor.integrations.has_more": page.hasMore
+  });
+  return page;
+});
+var describeTool = Effect.fn("executor.tools.describe")(function* (executor, path) {
+  yield* Effect.annotateCurrentSpan({ "mcp.tool.name": 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) {
+    const lastDot = path.lastIndexOf(".");
+    const leaf = lastDot === -1 ? path : path.slice(lastDot + 1);
+    const scoped = yield* searchTools(executor, leaf, TOOL_DESCRIBE_SUGGESTION_LIMIT, {
+      namespace: extractNamespace(path)
+    });
+    const matches = scoped.items.length > 0 ? scoped.items : (yield* searchTools(executor, leaf, TOOL_DESCRIBE_SUGGESTION_LIMIT)).items;
+    const suggestions = matches.map((item) => item.path);
+    const notFound = {
+      path,
+      name: path,
+      error: {
+        code: "tool_not_found",
+        message: `Tool not found: ${path}`,
+        ...suggestions.length > 0 ? { suggestions } : {}
+      }
+    };
+    return notFound;
+  }
+  const described = {
+    path,
+    name: schema.name ?? path,
+    description: schema.description,
+    inputTypeScript: schema.inputTypeScript,
+    outputTypeScript: wrapOutputTypeScript(schema.outputTypeScript),
+    typeScriptDefinitions: withToolResultDefinitions(schema.typeScriptDefinitions)
+  };
+  return described;
+});
+
+// src/description.ts
+import { Effect as Effect2 } from "effect";
+var INTEGRATION_INVENTORY_HEADER = "## Available integrations";
+var buildExecuteDescription = (executor) => Effect2.gen(function* () {
+  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.connections.list")
+  );
+  const description = yield* Effect2.sync(() => {
+    const lines = [
+      "Execute TypeScript in a sandboxed runtime with access to connected service integrations.",
+      "",
+      'Before writing code, call `skills({ name: "execute" })` for the workflow on how to use this tool.',
+      "",
+      'When the task needs an external service capability \u2014 sending email, a database, auth, payments, SMS, DNS, hosting, storage, search \u2014 and no connected integration covers it, do not pick a provider from memory or send the user off to sign up somewhere: press the button. `await tools.use({ need: "transactional email" })` returns a wired, working integration in one call (or one remaining human credential click). `skills({ name: "resolve" })` has details and the manual stepwise flow.'
+    ];
+    const inventory = formatIntegrationInventory(connections);
+    if (inventory.length > 0) {
+      lines.push("");
+      lines.push(inventory);
+    }
+    return lines.join("\n");
+  }).pipe(
+    Effect2.withSpan("schema.compile.description", {
+      attributes: { "executor.connection_count": connections.length }
+    })
+  );
+  yield* Effect2.annotateCurrentSpan({
+    "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 connectionPath = (connection) => {
+  const address = String(connection.address);
+  return address.startsWith("tools.") ? address.slice("tools.".length) : address;
+};
+var INVENTORY_LIMIT = 50;
+var formatIntegrationInventory = (connections) => {
+  const slugs = [...new Set(connections.map((connection) => String(connection.integration)))].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  if (slugs.length === 0) return "";
+  const shown = slugs.slice(0, INVENTORY_LIMIT);
+  const lines = [
+    INTEGRATION_INVENTORY_HEADER,
+    "",
+    "Integrations you have connected. Their tools live under `tools.<integration>.\u2026`.",
+    ...shown.map((slug) => `- \`${slug}\``)
+  ];
+  if (slugs.length > shown.length) {
+    lines.push(`- ... ${slugs.length - shown.length} more`);
+  }
+  return lines.join("\n");
+};
+
+// src/engine.ts
+import { Deferred, Effect as Effect4, Fiber, Predicate as Predicate3, Queue } from "effect";
+import * as Exit from "effect/Exit";
+
+// src/use-need.ts
+import { Cause as Cause2, Effect as Effect3, Option, Predicate as Predicate2, Schema } from "effect";
+var RESOLVE_PATH = "executor.coreTools.integrations.resolve";
+var CONNECTIONS_LIST_PATH = "executor.coreTools.connections.list";
+var INTEGRATIONS_LIST_PATH = "executor.coreTools.integrations.list";
+var CONNECTION_CREATE_PATH = "executor.coreTools.connections.create";
+var CREATE_HANDOFF_PATH = "executor.coreTools.connections.createHandoff";
+var OPENAPI_ADD_PATH = "executor.openapi.addSpec";
+var MCP_ADD_PATH = "executor.mcp.addServer";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var StepErrorShape = Schema.Struct({
+  message: Schema.optional(Schema.String),
+  code: Schema.optional(Schema.String)
+});
+var decodeStepError = Schema.decodeUnknownOption(StepErrorShape);
+var unwrap = (step, result) => {
+  if (!isRecord(result)) return { step, message: "tool returned a non-object result" };
+  if (result.ok === true && isRecord(result.data)) return result.data;
+  if (result.ok === false) {
+    const { message, code } = Option.getOrElse(
+      decodeStepError(result.error),
+      () => ({})
+    );
+    return {
+      step,
+      message: message ?? "tool call failed",
+      ...code !== void 0 ? { code } : {}
+    };
+  }
+  return result;
+};
+var isFailure = (value) => "step" in value && "message" in value && typeof value.step === "string" && !("ok" in value);
+var ResolveEntry = Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  domain: Schema.String,
+  category: Schema.String,
+  sponsored: Schema.Boolean,
+  offer: Schema.optional(Schema.Struct({ terms: Schema.String, url: Schema.String })),
+  verifiedAt: Schema.String,
+  suggestedSlug: Schema.String,
+  addPath: Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("openapi"), specUrl: Schema.String }),
+    Schema.Struct({ kind: Schema.Literal("mcp"), serverUrl: Schema.String }),
+    Schema.Struct({ kind: Schema.Literal("cli"), package: Schema.String })
+  ]),
+  authTemplate: Schema.optional(Schema.String),
+  connect: Schema.optional(Schema.Struct({ auth: Schema.String, instructions: Schema.String }))
+});
+var decodeResolveEntry = Schema.decodeUnknownOption(ResolveEntry);
+var asEntry = (value) => Option.getOrUndefined(decodeResolveEntry(value));
+var toCard = (entry) => ({
+  id: entry.id,
+  name: entry.name,
+  domain: entry.domain,
+  category: entry.category,
+  sponsored: entry.sponsored,
+  ...entry.offer !== void 0 ? { offer: entry.offer } : {},
+  verifiedAt: entry.verifiedAt
+});
+var labelLine = (entry) => entry.sponsored ? `${entry.name} is a SPONSORED placement (verified; it holds the default slot only at quality >= the best organic option${entry.offer ? `; offer: ${entry.offer.terms}` : ""}).` : `${entry.name} is the organic (unsponsored) best for this category.`;
+var overrideLine = (need, entry, alternativesCount) => alternativesCount > 0 ? `${alternativesCount} verified alternative${alternativesCount === 1 ? "" : "s"} exist${alternativesCount === 1 ? "s" : ""} \u2014 to override, press again with not: ["${entry.id}"], or pass compare: true to see the full ranked set for "${need}".` : `No other verified providers cover this need right now.`;
+var runUseNeed = (invoke, rawArgs) => Effect3.gen(function* () {
+  if (!isRecord(rawArgs) || typeof rawArgs.need !== "string" || rawArgs.need.length === 0) {
+    return {
+      status: "error",
+      step: "arguments",
+      message: 'tools.use expects { need: string; not?: string[]; compare?: boolean } \u2014 e.g. tools.use({ need: "transactional email" })',
+      instructions: "Call again with a need string."
+    };
+  }
+  const need = rawArgs.need;
+  const not = Array.isArray(rawArgs.not) ? rawArgs.not.filter((entry2) => typeof entry2 === "string") : [];
+  const compare = rawArgs.compare === true;
+  const fail = (failure) => ({
+    status: "error",
+    step: failure.step,
+    message: failure.message,
+    instructions: "The step named above failed. You can retry, or fall back to the workshop tools (integrations.resolve, openapi.addSpec, connections.createHandoff) to do it stepwise."
+  });
+  const dispatch = (step, path, args) => invoke({ path, args }).pipe(
+    Effect3.map((result) => unwrap(step, result)),
+    Effect3.catchCause((cause) => {
+      const failure = cause.reasons.find(Cause2.isFailReason)?.error;
+      const { message } = Predicate2.isError(failure) ? failure : Option.getOrElse(decodeStepError(failure), () => ({}));
+      return Effect3.succeed({ step, message: message ?? "tool call failed" });
+    })
+  );
+  const resolved = yield* dispatch("resolve", RESOLVE_PATH, { need, exclude: not });
+  if (isFailure(resolved)) return fail(resolved);
+  if (resolved.matched !== true) {
+    const categories = Array.isArray(resolved.categories) ? resolved.categories.filter((c) => typeof c === "string") : [];
+    return {
+      status: "no_match",
+      categories,
+      instructions: categories.length > 0 ? `No verified provider matches "${need}". The catalog covers: ${categories.join(", ")}. Press again phrasing the need with one of these, or name a provider directly.` : `No provider catalog is configured in this runtime; fall back to asking the user.`
+    };
+  }
+  const entry = asEntry(resolved.default);
+  if (entry === void 0) {
+    return fail({ step: "resolve", message: "resolver returned a match without a default" });
+  }
+  const alternatives = Array.isArray(resolved.alternatives) ? resolved.alternatives : [];
+  const alternativesCount = alternatives.length;
+  const phrasing = resolved.phrasing === "brand" ? "brand" : "category";
+  if (compare) {
+    const candidates = [entry, ...alternatives.map(asEntry).filter(Predicate2.isNotUndefined)].map(
+      toCard
+    );
+    return {
+      status: "compare",
+      candidates,
+      instructions: "Ranked by verified quality; serving order. Sponsored entries are labeled. Press use() again naming your choice (brand phrasing is honored verbatim)."
+    };
+  }
+  const connectionsResult = yield* dispatch("connections.list", CONNECTIONS_LIST_PATH, {});
+  if (isFailure(connectionsResult)) return fail(connectionsResult);
+  const connections = Array.isArray(connectionsResult.connections) ? connectionsResult.connections.filter(isRecord) : [];
+  const rankedEntries = [entry, ...alternatives.map(asEntry).filter(Predicate2.isNotUndefined)];
+  const candidateSlugs = phrasing === "brand" ? [entry.suggestedSlug] : rankedEntries.map((e) => e.suggestedSlug);
+  for (const slug of candidateSlugs) {
+    const existing = connections.find((connection) => connection.integration === slug);
+    if (existing !== void 0) {
+      const adopted = rankedEntries.find((e) => e.suggestedSlug === slug) ?? entry;
+      return {
+        status: "ready",
+        provider: toCard(adopted),
+        alternativesCount,
+        toolsPath: typeof existing.address === "string" ? existing.address : void 0,
+        instructions: `Already wired: you have a ${adopted.name} connection. ${labelLine(adopted)} Call its tools under the address above (tools.search({ namespace: "${slug}" }) enumerates them).`
+      };
+    }
+  }
+  if (entry.addPath.kind === "cli") {
+    const pkg = entry.addPath.package;
+    const installCommand = `npm install -g ${pkg}`;
+    const authNote = entry.authTemplate !== void 0 && entry.authTemplate.length > 0 ? ` \u2014 auth: ${entry.authTemplate}` : entry.connect?.instructions ?? "";
+    return {
+      status: "manual",
+      provider: toCard(entry),
+      alternativesCount,
+      installCommand,
+      instructions: `${labelLine(entry)} ${entry.name} ships as a CLI (npm package ${pkg}), not an API integration: install it in YOUR environment (\`${installCommand}\`, or ad hoc via \`npx -y ${pkg}\`), then authenticate per its own flow${authNote}. It will not appear under raf's tools. ${overrideLine(need, entry, alternativesCount)}`
+    };
+  }
+  const integrationsResult = yield* dispatch("integrations.list", INTEGRATIONS_LIST_PATH, {});
+  if (isFailure(integrationsResult)) return fail(integrationsResult);
+  const integrations = Array.isArray(integrationsResult.integrations) ? integrationsResult.integrations.filter(isRecord) : [];
+  const alreadyAdded = integrations.some(
+    (integration) => integration.slug === entry.suggestedSlug
+  );
+  if (!alreadyAdded) {
+    if (entry.addPath.kind === "openapi") {
+      const added = yield* dispatch("openapi.addSpec", OPENAPI_ADD_PATH, {
+        spec: { kind: "url", url: entry.addPath.specUrl },
+        slug: entry.suggestedSlug,
+        name: entry.name
+      });
+      if (isFailure(added) && added.code !== "integration_already_exists") return fail(added);
+    } else if (entry.addPath.kind === "mcp") {
+      const added = yield* dispatch("mcp.addServer", MCP_ADD_PATH, {
+        name: entry.name,
+        endpoint: entry.addPath.serverUrl,
+        slug: entry.suggestedSlug
+      });
+      if (isFailure(added) && added.code !== "integration_already_exists") return fail(added);
+    }
+  }
+  if (entry.connect?.auth === "none") {
+    const owner = connections.map((connection) => connection.owner).find((value) => typeof value === "string");
+    if (owner !== void 0) {
+      const created = yield* dispatch("connections.create", CONNECTION_CREATE_PATH, {
+        owner,
+        name: "main",
+        integration: entry.suggestedSlug,
+        template: "none"
+      });
+      if (!isFailure(created)) {
+        return {
+          status: "ready",
+          provider: toCard(entry),
+          alternativesCount,
+          toolsPath: `tools.${entry.suggestedSlug}.${owner}.main`,
+          instructions: `${entry.name} is wired (no auth needed). ${labelLine(entry)} ${overrideLine(need, entry, alternativesCount)} Find its tools with tools.search({ namespace: "${entry.suggestedSlug}" }).`
+        };
+      }
+    }
+  }
+  const handoff = yield* dispatch("connections.createHandoff", CREATE_HANDOFF_PATH, {
+    integration: entry.suggestedSlug
+  });
+  if (isFailure(handoff)) return fail(handoff);
+  const url = typeof handoff.url === "string" ? handoff.url : "";
+  return {
+    status: "pending",
+    provider: toCard(entry),
+    alternativesCount,
+    url,
+    instructions: `${labelLine(entry)} One human step left: give the user this URL \u2014 they mint the ${entry.name} credential and enter it in the web UI (never paste secrets into chat). Press use({ need: "${need}" }) again any time to check: it returns ready once the connection exists. ${overrideLine(need, entry, alternativesCount)}`
+  };
+});
+
+// src/engine.ts
+var acceptAllHandler = () => Effect4.succeed({ action: "accept" });
+var MAX_PREVIEW_CHARS = 3e4;
+var truncate = (value, max) => value.length > max ? `${value.slice(0, max)}
+... [truncated ${value.length - max} chars]` : value;
+var formatExecuteResult = (result) => {
+  const resultText = result.result != null ? typeof result.result === "string" ? result.result : JSON.stringify(result.result, null, 2) : null;
+  const logText = result.logs && result.logs.length > 0 ? result.logs.join("\n") : null;
+  const emitted = result.output?.length ?? 0;
+  const emittedNote = emitted > 0 ? `${emitted} item${emitted === 1 ? "" : "s"} emitted to the user` : null;
+  const emittedField = emitted > 0 ? { emitted } : {};
+  if (result.error) {
+    const parts2 = [`Error: ${result.error}`, ...logText ? [`
+Logs:
+${logText}`] : []];
+    return {
+      text: truncate(parts2.join("\n"), MAX_PREVIEW_CHARS),
+      structured: {
+        status: "error",
+        error: result.error,
+        ...emittedField,
+        logs: result.logs ?? []
+      },
+      isError: true
+    };
+  }
+  const resultPart = resultText ? truncate(resultText, MAX_PREVIEW_CHARS) : emittedNote ? `(no return value; ${emittedNote})` : "(no result)";
+  const parts = [resultPart, ...logText ? [`
+Logs:
+${logText}`] : []];
+  return {
+    text: parts.join("\n"),
+    structured: {
+      status: "completed",
+      result: result.result ?? null,
+      ...emittedField,
+      logs: result.logs ?? []
+    },
+    isError: false
+  };
+};
+var formatPausedExecution = (paused, options) => {
+  const req = paused.elicitationContext.request;
+  const lines = [`Execution paused: ${req.message}`];
+  const deadline = options?.deadline;
+  const isUrlElicitation = Predicate3.isTagged(req, "UrlElicitation");
+  const isFormElicitation = Predicate3.isTagged(req, "FormElicitation");
+  const requestedSchema = isFormElicitation ? req.requestedSchema : void 0;
+  const hasRequestedSchema = requestedSchema !== void 0 && Object.keys(requestedSchema).length > 0;
+  const baseInstructions = isUrlElicitation ? `The user needs to open this URL in a browser and complete the flow. After the user finishes, call the resume tool with executionId "${paused.id}" and action "accept".` : hasRequestedSchema ? `Ask the user for values matching requestedSchema. Then call the resume tool with executionId "${paused.id}", action "accept", and content matching requestedSchema. If the user declines, call resume with action "decline" or "cancel".` : `This is a model-side confirmation gate; there is no browser form to open. Ask the user whether to approve the paused tool call. If the user approves, call the resume tool with executionId "${paused.id}" and action "accept". If the user declines, call resume with action "decline" or "cancel".`;
+  const deadlineInstructions = deadline ? ` Resume before ${deadline.expiresAt}; this approval window lasts ${formatTtlDuration(deadline.ttlMs)}.` : "";
+  const instructions = `${baseInstructions}${deadlineInstructions}`;
+  if (isUrlElicitation) {
+    lines.push(`
+Open this URL in a browser:
+${req.url}`);
+    lines.push('\nAfter the browser flow, call the resume tool with action "accept".');
+  } else if (hasRequestedSchema) {
+    lines.push(
+      "\nAsk the user for a response matching the requested schema, then call the resume tool."
+    );
+    lines.push(`
+Requested schema:
+${JSON.stringify(requestedSchema, null, 2)}`);
+  } else {
+    lines.push(
+      '\nThis is a model-side confirmation gate; no browser form is waiting. Ask the user whether to approve, then call the resume tool with action "accept", "decline", or "cancel".'
+    );
+  }
+  lines.push(`
+executionId: ${paused.id}`);
+  if (deadline) {
+    lines.push(
+      `
+resumeDeadline: ${deadline.expiresAt} (${formatTtlDuration(deadline.ttlMs)} approval window)`
+    );
+  }
+  lines.push(`
+instructions: ${instructions}`);
+  return {
+    text: lines.join("\n"),
+    structured: {
+      status: "waiting_for_interaction",
+      executionId: paused.id,
+      ...deadline ? { expiresAt: deadline.expiresAt, ttlMs: deadline.ttlMs } : {},
+      interaction: {
+        kind: isUrlElicitation ? "url" : "form",
+        message: req.message,
+        instructions,
+        address: String(paused.elicitationContext.address),
+        args: paused.elicitationContext.args,
+        ...isUrlElicitation ? { url: req.url } : {},
+        ...isFormElicitation ? { requestedSchema: req.requestedSchema } : {}
+      }
+    }
+  };
+};
+var formatTtlDuration = (ttlMs) => {
+  const seconds = Math.max(1, Math.round(ttlMs / 1e3));
+  if (seconds % 60 === 0) {
+    const minutes = seconds / 60;
+    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+  }
+  return `${seconds} second${seconds === 1 ? "" : "s"}`;
+};
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readOptionalLimit = (value, toolName) => {
+  if (value === void 0) {
+    return 12;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return new ExecutionToolError({
+      message: `${toolName} limit must be a positive number when provided`
+    });
+  }
+  return Math.floor(value);
+};
+var readOptionalOffset = (value, toolName) => {
+  if (value === void 0) {
+    return 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return new ExecutionToolError({
+      message: `${toolName} offset must be a non-negative number when provided`
+    });
+  }
+  return Math.floor(value);
+};
+var makeFullInvoker = (executor, invokeOptions, toolDiscoveryProvider) => {
+  const base = makeExecutorToolInvoker(executor, { invokeOptions });
+  return {
+    invoke: ({ path, args }) => {
+      if (path === "search") {
+        if (!isRecord2(args)) {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.search expects an object: { query?: string; namespace?: string; limit?: number; offset?: number }"
+            })
+          );
+        }
+        if (args.query !== void 0 && typeof args.query !== "string") {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.search query must be a string when provided"
+            })
+          );
+        }
+        if (args.namespace !== void 0 && typeof args.namespace !== "string") {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.search namespace must be a string when provided"
+            })
+          );
+        }
+        const limit = readOptionalLimit(args.limit, "tools.search");
+        if (Predicate3.isTagged(limit, "ExecutionToolError")) {
+          return Effect4.fail(limit);
+        }
+        const offset = readOptionalOffset(args.offset, "tools.search");
+        if (Predicate3.isTagged(offset, "ExecutionToolError")) {
+          return Effect4.fail(offset);
+        }
+        return toolDiscoveryProvider.searchTools({
+          executor,
+          query: args.query ?? "",
+          limit,
+          namespace: args.namespace,
+          offset
+        }).pipe(
+          Effect4.withSpan("mcp.tool.dispatch", {
+            attributes: { "mcp.tool.name": path, "executor.tool.builtin": true }
+          })
+        );
+      }
+      if (path === "executor.integrations.list") {
+        if (args !== void 0 && !isRecord2(args)) {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.executor.integrations.list expects an object: { query?: string; limit?: number; offset?: number }"
+            })
+          );
+        }
+        if (isRecord2(args) && args.query !== void 0 && typeof args.query !== "string") {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.executor.integrations.list query must be a string when provided"
+            })
+          );
+        }
+        const limit = readOptionalLimit(
+          isRecord2(args) ? args.limit : void 0,
+          "tools.executor.integrations.list"
+        );
+        if (Predicate3.isTagged(limit, "ExecutionToolError")) {
+          return Effect4.fail(limit);
+        }
+        const offset = readOptionalOffset(
+          isRecord2(args) ? args.offset : void 0,
+          "tools.executor.integrations.list"
+        );
+        if (Predicate3.isTagged(offset, "ExecutionToolError")) {
+          return Effect4.fail(offset);
+        }
+        return listExecutorIntegrations(executor, {
+          query: isRecord2(args) && typeof args.query === "string" ? args.query : void 0,
+          limit,
+          offset
+        }).pipe(
+          Effect4.withSpan("mcp.tool.dispatch", {
+            attributes: { "mcp.tool.name": path, "executor.tool.builtin": true }
+          })
+        );
+      }
+      if (path === "use") {
+        return runUseNeed((input) => base.invoke(input), args).pipe(
+          Effect4.withSpan("mcp.tool.dispatch", {
+            attributes: { "mcp.tool.name": path, "executor.tool.builtin": true }
+          })
+        );
+      }
+      if (path === "describe.tool") {
+        if (!isRecord2(args)) {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.describe.tool expects an object: { path: string }"
+            })
+          );
+        }
+        if (typeof args.path !== "string" || args.path.trim().length === 0) {
+          return Effect4.fail(new ExecutionToolError({ message: "describe.tool requires a path" }));
+        }
+        if ("includeSchemas" in args) {
+          return Effect4.fail(
+            new ExecutionToolError({
+              message: "tools.describe.tool no longer accepts includeSchemas"
+            })
+          );
+        }
+        return describeTool(executor, args.path).pipe(
+          Effect4.withSpan("mcp.tool.dispatch", {
+            attributes: {
+              "mcp.tool.name": path,
+              "executor.tool.builtin": true,
+              "executor.tool.target_path": args.path
+            }
+          })
+        );
+      }
+      return base.invoke({ path, args });
+    }
+  };
+};
+var withToolCallHook = (invoker, onToolCall) => {
+  if (onToolCall === void 0) return invoker;
+  const report = (path, ok) => {
+    try {
+      onToolCall({ path, ok });
+    } catch {
+    }
+  };
+  return {
+    invoke: (input) => invoker.invoke(input).pipe(
+      Effect4.tap(
+        (result) => Effect4.sync(() => report(input.path, !(isRecord2(result) && result.ok === false)))
+      ),
+      Effect4.tapCause(() => Effect4.sync(() => report(input.path, false)))
+    )
+  };
+};
+var createExecutionEngine = (config) => {
+  const {
+    executor,
+    codeExecutor,
+    toolDiscoveryProvider = defaultToolDiscoveryProvider,
+    onToolCall
+  } = config;
+  const pausedExecutions = /* @__PURE__ */ new Map();
+  const settledOutcomes = /* @__PURE__ */ new Map();
+  const SETTLED_OUTCOME_LIMIT = 64;
+  const settledExecutionIds = /* @__PURE__ */ new Set();
+  const SETTLED_EXECUTION_ID_LIMIT = 1024;
+  const pendingResumes = /* @__PURE__ */ new Map();
+  const recordSettledOutcome = (executionId, exit) => {
+    settledExecutionIds.add(executionId);
+    while (settledExecutionIds.size > SETTLED_EXECUTION_ID_LIMIT) {
+      const oldest = settledExecutionIds.keys().next().value;
+      if (oldest === void 0) break;
+      settledExecutionIds.delete(oldest);
+    }
+    settledOutcomes.set(executionId, exit);
+    while (settledOutcomes.size > SETTLED_OUTCOME_LIMIT) {
+      const oldest = settledOutcomes.keys().next().value;
+      if (oldest === void 0) break;
+      settledOutcomes.delete(oldest);
+    }
+  };
+  const awaitCompletionOrPause = (fiber, pauseQueue) => Effect4.raceFirst(
+    Fiber.join(fiber).pipe(
+      Effect4.map((result) => ({ status: "completed", result }))
+    ),
+    Queue.take(pauseQueue).pipe(
+      Effect4.map((paused) => ({ status: "paused", execution: paused }))
+    )
+  );
+  const startPausableExecution = Effect4.fn("mcp.execute")(function* (code, options) {
+    yield* Effect4.annotateCurrentSpan({
+      "mcp.execute.mode": "pausable",
+      "mcp.execute.code_length": code.length
+    });
+    if (options?.autoApprove) {
+      yield* Effect4.annotateCurrentSpan({ "mcp.execute.auto_approve": true });
+      const result = yield* runInlineExecution(code, { onElicitation: acceptAllHandler });
+      return { status: "completed", result };
+    }
+    const pauseQueue = yield* Queue.unbounded();
+    let fiber;
+    const elicitationHandler = (ctx) => Effect4.gen(function* () {
+      const responseDeferred = yield* Deferred.make();
+      const id = `exec_${crypto.randomUUID()}`;
+      const paused = {
+        id,
+        elicitationContext: ctx,
+        response: responseDeferred,
+        fiber,
+        pauseQueue
+      };
+      pausedExecutions.set(id, paused);
+      yield* Queue.offer(pauseQueue, paused);
+      return yield* Deferred.await(responseDeferred);
+    });
+    const invoker = withToolCallHook(
+      makeFullInvoker(executor, { onElicitation: elicitationHandler }, toolDiscoveryProvider),
+      onToolCall
+    );
+    fiber = yield* Effect4.forkDetach(
+      codeExecutor.execute(code, invoker).pipe(Effect4.withSpan("executor.code.exec"))
+    );
+    const sandboxFiber = fiber;
+    yield* Effect4.forkDetach(
+      Fiber.await(sandboxFiber).pipe(
+        Effect4.flatMap(
+          (exit) => Effect4.sync(() => {
+            const outcome = Exit.map(
+              exit,
+              (result) => ({ status: "completed", result })
+            );
+            for (const [id, paused] of pausedExecutions) {
+              if (paused.fiber !== sandboxFiber) continue;
+              pausedExecutions.delete(id);
+              recordSettledOutcome(id, outcome);
+            }
+          })
+        )
+      )
+    );
+    return yield* awaitCompletionOrPause(fiber, pauseQueue);
+  });
+  const resumeExecution = Effect4.fn("mcp.execute.resume")(function* (executionId, response) {
+    yield* Effect4.annotateCurrentSpan({
+      "mcp.execute.resume.action": response.action
+    });
+    const settled = settledOutcomes.get(executionId);
+    if (settled) {
+      yield* Effect4.annotateCurrentSpan({ "mcp.execute.resume.replayed": true });
+      return yield* settled;
+    }
+    const pending = pendingResumes.get(executionId);
+    if (pending) {
+      yield* Effect4.annotateCurrentSpan({ "mcp.execute.resume.joined_inflight": true });
+      return yield* Deferred.await(pending);
+    }
+    const paused = pausedExecutions.get(executionId);
+    if (!paused) return null;
+    pausedExecutions.delete(executionId);
+    const inflight = yield* Deferred.make();
+    pendingResumes.set(executionId, inflight);
+    yield* Deferred.succeed(paused.response, {
+      action: response.action,
+      content: response.content
+    });
+    return yield* awaitCompletionOrPause(paused.fiber, paused.pauseQueue).pipe(
+      Effect4.onExit(
+        (exit) => Effect4.gen(function* () {
+          recordSettledOutcome(executionId, exit);
+          pendingResumes.delete(executionId);
+          yield* Deferred.done(inflight, exit);
+        })
+      )
+    );
+  });
+  const runInlineExecution = Effect4.fn("mcp.execute")(function* (code, options) {
+    yield* Effect4.annotateCurrentSpan({
+      "mcp.execute.mode": "inline",
+      "mcp.execute.code_length": code.length
+    });
+    const invoker = withToolCallHook(
+      makeFullInvoker(
+        executor,
+        {
+          onElicitation: options.onElicitation
+        },
+        toolDiscoveryProvider
+      ),
+      onToolCall
+    );
+    return yield* codeExecutor.execute(code, invoker).pipe(Effect4.withSpan("executor.code.exec"));
+  });
+  return {
+    execute: runInlineExecution,
+    executeWithPause: startPausableExecution,
+    resume: resumeExecution,
+    isExecutionSettled: (executionId) => Effect4.sync(() => settledExecutionIds.has(executionId)),
+    getPausedExecution: (executionId) => Effect4.sync(() => pausedExecutions.get(executionId) ?? null),
+    pausedExecutionCount: () => Effect4.sync(() => pausedExecutions.size),
+    hasPausedExecutions: () => Effect4.sync(() => pausedExecutions.size > 0),
+    getDescription: buildExecuteDescription(executor)
+  };
+};
+
+export {
+  ExecutionToolError,
+  makeExecutorToolInvoker,
+  searchTools,
+  defaultToolDiscoveryProvider,
+  listExecutorIntegrations,
+  describeTool,
+  INTEGRATION_INVENTORY_HEADER,
+  buildExecuteDescription,
+  formatExecuteResult,
+  formatPausedExecution,
+  formatTtlDuration,
+  createExecutionEngine
+};
+//# sourceMappingURL=chunk-EVYEEDLB.js.map