@rafads/execution 1.5.38

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createExecutionEngine, formatExecuteResult, formatPausedExecution, formatTtlDuration, type ExecutionEngine, type ExecutionEngineConfig, type ExecutionResult, type PausedExecution, type PausedExecutionDeadline, type ResumeResponse, } from "./engine";
+export { buildExecuteDescription, INTEGRATION_INVENTORY_HEADER } from "./description";
+export { EXECUTE_SKILL, SKILLS, findSkill, renderSkillsIndex, type Skill } from "./skills";
+export { ExecutionToolError } from "./errors";
+export { defaultToolDiscoveryProvider, makeExecutorToolInvoker, searchTools, listExecutorIntegrations, describeTool, type ToolDiscoveryInput, type ToolDiscoveryProvider, type PagedResult, type ToolDiscoveryResult, } from "./tool-invoker";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,WAAW,EACX,wBAAwB,EACxB,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,82 @@
+import {
+  ExecutionToolError,
+  buildExecuteDescription,
+  createExecutionEngine,
+  formatExecuteResult,
+  formatPausedExecution
+} from "./chunk-EVYEEDLB.js";
+
+// src/promise.ts
+import { Effect } from "effect";
+var fromPromise = (try_) => (
+  // oxlint-disable-next-line executor/no-effect-escape-hatch -- boundary: Promise executor facade has already erased the SDK typed error channel
+  Effect.tryPromise({ try: try_, catch: (cause) => cause }).pipe(Effect.orDie)
+);
+var wrapPromiseExecutor = (pe) => {
+  const adapter = {
+    integrations: {
+      list: () => fromPromise(() => pe.integrations.list()),
+      get: (slug) => fromPromise(() => pe.integrations.get(slug)),
+      update: (slug, patch) => fromPromise(() => pe.integrations.update(slug, patch)),
+      remove: (slug) => fromPromise(() => pe.integrations.remove(slug)),
+      detect: (url) => fromPromise(() => pe.integrations.detect(url))
+    },
+    connections: {
+      create: (input) => fromPromise(() => pe.connections.create(input)),
+      list: (filter) => fromPromise(() => pe.connections.list(filter)),
+      get: (ref) => fromPromise(() => pe.connections.get(ref)),
+      update: (ref, input) => fromPromise(() => pe.connections.update(ref, input)),
+      remove: (ref) => fromPromise(() => pe.connections.remove(ref)),
+      refresh: (ref) => fromPromise(() => pe.connections.refresh(ref))
+    },
+    tools: {
+      list: (filter) => fromPromise(() => pe.tools.list(filter)),
+      schema: (address) => fromPromise(() => pe.tools.schema(address))
+    },
+    providers: {
+      list: () => fromPromise(() => pe.providers.list()),
+      items: (key) => fromPromise(() => pe.providers.items(key))
+    },
+    policies: {
+      list: () => fromPromise(() => pe.policies.list()),
+      create: (input) => fromPromise(() => pe.policies.create(input)),
+      update: (input) => fromPromise(() => pe.policies.update(input)),
+      remove: (input) => fromPromise(() => pe.policies.remove(input)),
+      resolve: (address) => fromPromise(() => pe.policies.resolve(address))
+    },
+    execute: (address, args, options) => fromPromise(() => pe.execute(address, args, options)),
+    close: () => fromPromise(() => pe.close())
+  };
+  return adapter;
+};
+var toPromiseExecutionEngine = (engine) => ({
+  execute: (code, options) => Effect.runPromise(
+    engine.execute(code, {
+      onElicitation: (ctx) => (
+        // oxlint-disable-next-line executor/no-effect-escape-hatch -- boundary: host-provided Promise elicitation callback is outside the Effect error model
+        Effect.tryPromise(() => options.onElicitation(ctx)).pipe(Effect.orDie)
+      )
+    })
+  ),
+  executeWithPause: (code, options) => Effect.runPromise(engine.executeWithPause(code, options)),
+  resume: (executionId, response) => Effect.runPromise(engine.resume(executionId, response)),
+  getPausedExecution: (executionId) => Effect.runPromise(engine.getPausedExecution(executionId)),
+  pausedExecutionCount: () => Effect.runPromise(engine.pausedExecutionCount()),
+  hasPausedExecutions: () => Effect.runPromise(engine.hasPausedExecutions()),
+  getDescription: () => Effect.runPromise(engine.getDescription)
+});
+var createExecutionEngine2 = (config) => toPromiseExecutionEngine(
+  createExecutionEngine({
+    executor: wrapPromiseExecutor(config.executor),
+    codeExecutor: config.codeExecutor
+  })
+);
+export {
+  ExecutionToolError,
+  buildExecuteDescription,
+  createExecutionEngine2 as createExecutionEngine,
+  formatExecuteResult,
+  formatPausedExecution,
+  toPromiseExecutionEngine
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/promise.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// @rafads/execution/promise — Promise-native surface for the execution\n// engine.\n// ---------------------------------------------------------------------------\n//\n// `engine.ts` is Effect-native; this module runs each method with\n// `Effect.runPromise` at the boundary so hosts that can't compose Effects\n// (the MCP SDK tool handlers, plain async call sites) can still use the\n// engine. Callers already inside an Effect context should import directly\n// from `@rafads/execution` to keep trace context intact.\n// ---------------------------------------------------------------------------\n\nimport { Effect } from \"effect\";\nimport type * as Cause from \"effect/Cause\";\n\nimport type {\n  ElicitationContext,\n  ElicitationResponse,\n  Executor as EffectExecutor,\n} from \"@rafads/sdk/core\";\nimport type { Executor as PromiseExecutor } from \"@rafads/sdk/promise\";\nimport type { CodeExecutionError, CodeExecutor, ExecuteResult } from \"@rafads/codemode-core\";\n\nimport {\n  createExecutionEngine as createEffectExecutionEngine,\n  type ExecutionEngine as EffectExecutionEngine,\n  type ExecutionResult,\n  type PausedExecution,\n  type ResumeResponse,\n} from \"./engine\";\n\nexport type ElicitationHandler = (ctx: ElicitationContext) => Promise<ElicitationResponse>;\n\nexport type ExecutionEngineConfig<E extends Cause.YieldableError = CodeExecutionError> = {\n  readonly executor: PromiseExecutor;\n  readonly codeExecutor: CodeExecutor<E>;\n};\n\nexport type ExecutionEngine = {\n  readonly execute: (\n    code: string,\n    options: { readonly onElicitation: ElicitationHandler },\n  ) => Promise<ExecuteResult>;\n  readonly executeWithPause: (\n    code: string,\n    options?: { readonly autoApprove?: boolean },\n  ) => Promise<ExecutionResult>;\n  readonly resume: (\n    executionId: string,\n    response: ResumeResponse,\n  ) => Promise<ExecutionResult | null>;\n  readonly getPausedExecution: (executionId: string) => Promise<PausedExecution | null>;\n  readonly pausedExecutionCount: () => Promise<number>;\n  readonly hasPausedExecutions: () => Promise<boolean>;\n  readonly getDescription: () => Promise<string>;\n};\n\n/**\n * Wrap a Promise thunk into the Effect shape the engine consumes. The Promise\n * executor façade has already erased the SDK typed error channel (rejections\n * carry the tagged error as the rejected value), so we re-orphan it as a defect.\n */\nconst fromPromise = <A>(try_: () => Promise<A>): Effect.Effect<A> =>\n  // oxlint-disable-next-line executor/no-effect-escape-hatch -- boundary: Promise executor facade has already erased the SDK typed error channel\n  Effect.tryPromise({ try: try_, catch: (cause) => cause }).pipe(Effect.orDie);\n\n// ---------------------------------------------------------------------------\n// wrapPromiseExecutor — adapt the v2 Promise `Executor` back into an Effect\n// `Executor` so the Effect-native engine can drive it. The engine only touches\n// `execute`, `tools.list`, `tools.schema`, and `integrations.list`; we wrap\n// those and orphan the typed error channel. The remaining surface is filled\n// with the same Promise-backed wrappers where the shapes line up so the cast to\n// `EffectExecutor` is structurally honest for the methods callers can reach.\n// ---------------------------------------------------------------------------\n\nconst wrapPromiseExecutor = (pe: PromiseExecutor): EffectExecutor => {\n  const adapter = {\n    integrations: {\n      list: () => fromPromise(() => pe.integrations.list()),\n      get: (slug: Parameters<PromiseExecutor[\"integrations\"][\"get\"]>[0]) =>\n        fromPromise(() => pe.integrations.get(slug)),\n      update: (\n        slug: Parameters<PromiseExecutor[\"integrations\"][\"update\"]>[0],\n        patch: Parameters<PromiseExecutor[\"integrations\"][\"update\"]>[1],\n      ) => fromPromise(() => pe.integrations.update(slug, patch)),\n      remove: (slug: Parameters<PromiseExecutor[\"integrations\"][\"remove\"]>[0]) =>\n        fromPromise(() => pe.integrations.remove(slug)),\n      detect: (url: Parameters<PromiseExecutor[\"integrations\"][\"detect\"]>[0]) =>\n        fromPromise(() => pe.integrations.detect(url)),\n    },\n    connections: {\n      create: (input: Parameters<PromiseExecutor[\"connections\"][\"create\"]>[0]) =>\n        fromPromise(() => pe.connections.create(input)),\n      list: (filter?: Parameters<PromiseExecutor[\"connections\"][\"list\"]>[0]) =>\n        fromPromise(() => pe.connections.list(filter)),\n      get: (ref: Parameters<PromiseExecutor[\"connections\"][\"get\"]>[0]) =>\n        fromPromise(() => pe.connections.get(ref)),\n      update: (\n        ref: Parameters<PromiseExecutor[\"connections\"][\"update\"]>[0],\n        input: Parameters<PromiseExecutor[\"connections\"][\"update\"]>[1],\n      ) => fromPromise(() => pe.connections.update(ref, input)),\n      remove: (ref: Parameters<PromiseExecutor[\"connections\"][\"remove\"]>[0]) =>\n        fromPromise(() => pe.connections.remove(ref)),\n      refresh: (ref: Parameters<PromiseExecutor[\"connections\"][\"refresh\"]>[0]) =>\n        fromPromise(() => pe.connections.refresh(ref)),\n    },\n    tools: {\n      list: (filter?: Parameters<PromiseExecutor[\"tools\"][\"list\"]>[0]) =>\n        fromPromise(() => pe.tools.list(filter)),\n      schema: (address: Parameters<PromiseExecutor[\"tools\"][\"schema\"]>[0]) =>\n        fromPromise(() => pe.tools.schema(address)),\n    },\n    providers: {\n      list: () => fromPromise(() => pe.providers.list()),\n      items: (key: Parameters<PromiseExecutor[\"providers\"][\"items\"]>[0]) =>\n        fromPromise(() => pe.providers.items(key)),\n    },\n    policies: {\n      list: () => fromPromise(() => pe.policies.list()),\n      create: (input: Parameters<PromiseExecutor[\"policies\"][\"create\"]>[0]) =>\n        fromPromise(() => pe.policies.create(input)),\n      update: (input: Parameters<PromiseExecutor[\"policies\"][\"update\"]>[0]) =>\n        fromPromise(() => pe.policies.update(input)),\n      remove: (input: Parameters<PromiseExecutor[\"policies\"][\"remove\"]>[0]) =>\n        fromPromise(() => pe.policies.remove(input)),\n      resolve: (address: Parameters<PromiseExecutor[\"policies\"][\"resolve\"]>[0]) =>\n        fromPromise(() => pe.policies.resolve(address)),\n    },\n    execute: (\n      address: Parameters<PromiseExecutor[\"execute\"]>[0],\n      args: Parameters<PromiseExecutor[\"execute\"]>[1],\n      options?: Parameters<PromiseExecutor[\"execute\"]>[2],\n    ) => fromPromise(() => pe.execute(address, args, options)),\n    close: () => fromPromise(() => pe.close()),\n  };\n  // oxlint-disable-next-line executor/no-double-cast -- boundary: the Promise executor mirrors the Effect surface structurally; the engine only reaches execute/tools/integrations, all wrapped here\n  return adapter as unknown as EffectExecutor;\n};\n\n/**\n * Promise-wrap an Effect-native `ExecutionEngine` (from `./engine`).\n * Exposed separately so callers that already hold an Effect engine\n * (apps/cloud's execution-stack composes both) can convert it for hosts\n * that need the Promise surface (host-mcp).\n */\nexport const toPromiseExecutionEngine = <E extends Cause.YieldableError>(\n  engine: EffectExecutionEngine<E>,\n): ExecutionEngine => ({\n  execute: (code, options) =>\n    Effect.runPromise(\n      engine.execute(code, {\n        onElicitation: (ctx) =>\n          // oxlint-disable-next-line executor/no-effect-escape-hatch -- boundary: host-provided Promise elicitation callback is outside the Effect error model\n          Effect.tryPromise(() => options.onElicitation(ctx)).pipe(Effect.orDie),\n      }),\n    ),\n  executeWithPause: (code, options) => Effect.runPromise(engine.executeWithPause(code, options)),\n  resume: (executionId, response) => Effect.runPromise(engine.resume(executionId, response)),\n  getPausedExecution: (executionId) => Effect.runPromise(engine.getPausedExecution(executionId)),\n  pausedExecutionCount: () => Effect.runPromise(engine.pausedExecutionCount()),\n  hasPausedExecutions: () => Effect.runPromise(engine.hasPausedExecutions()),\n  getDescription: () => Effect.runPromise(engine.getDescription),\n});\n\nexport const createExecutionEngine = <E extends Cause.YieldableError = CodeExecutionError>(\n  config: ExecutionEngineConfig<E>,\n): ExecutionEngine =>\n  toPromiseExecutionEngine(\n    createEffectExecutionEngine({\n      executor: wrapPromiseExecutor(config.executor),\n      codeExecutor: config.codeExecutor,\n    }),\n  );\n\n// ---------------------------------------------------------------------------\n// Re-exports — plain types/helpers that don't carry Effect signatures.\n// ---------------------------------------------------------------------------\n\nexport { formatExecuteResult, formatPausedExecution } from \"./engine\";\n\nexport type { ExecutionResult, PausedExecution, ResumeResponse, ExecuteResult };\n\nexport { buildExecuteDescription } from \"./description\";\nexport { ExecutionToolError } from \"./errors\";\n"],"mappings":"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","names":["createExecutionEngine"]}

package/dist/promise.d.ts

@@ -0,0 +1,36 @@
+import type * as Cause from "effect/Cause";
+import type { ElicitationContext, ElicitationResponse } from "@rafads/sdk/core";
+import type { Executor as PromiseExecutor } from "@rafads/sdk/promise";
+import type { CodeExecutionError, CodeExecutor, ExecuteResult } from "@rafads/codemode-core";
+import { type ExecutionEngine as EffectExecutionEngine, type ExecutionResult, type PausedExecution, type ResumeResponse } from "./engine";
+export type ElicitationHandler = (ctx: ElicitationContext) => Promise<ElicitationResponse>;
+export type ExecutionEngineConfig<E extends Cause.YieldableError = CodeExecutionError> = {
+    readonly executor: PromiseExecutor;
+    readonly codeExecutor: CodeExecutor<E>;
+};
+export type ExecutionEngine = {
+    readonly execute: (code: string, options: {
+        readonly onElicitation: ElicitationHandler;
+    }) => Promise<ExecuteResult>;
+    readonly executeWithPause: (code: string, options?: {
+        readonly autoApprove?: boolean;
+    }) => Promise<ExecutionResult>;
+    readonly resume: (executionId: string, response: ResumeResponse) => Promise<ExecutionResult | null>;
+    readonly getPausedExecution: (executionId: string) => Promise<PausedExecution | null>;
+    readonly pausedExecutionCount: () => Promise<number>;
+    readonly hasPausedExecutions: () => Promise<boolean>;
+    readonly getDescription: () => Promise<string>;
+};
+/**
+ * Promise-wrap an Effect-native `ExecutionEngine` (from `./engine`).
+ * Exposed separately so callers that already hold an Effect engine
+ * (apps/cloud's execution-stack composes both) can convert it for hosts
+ * that need the Promise surface (host-mcp).
+ */
+export declare const toPromiseExecutionEngine: <E extends Cause.YieldableError>(engine: EffectExecutionEngine<E>) => ExecutionEngine;
+export declare const createExecutionEngine: <E extends Cause.YieldableError = CodeExecutionError>(config: ExecutionEngineConfig<E>) => ExecutionEngine;
+export { formatExecuteResult, formatPausedExecution } from "./engine";
+export type { ExecutionResult, PausedExecution, ResumeResponse, ExecuteResult };
+export { buildExecuteDescription } from "./description";
+export { ExecutionToolError } from "./errors";
+//# sourceMappingURL=promise.d.ts.map

package/dist/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE7F,OAAO,EAEL,KAAK,eAAe,IAAI,qBAAqB,EAC7C,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAE3F,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,KAAK,CAAC,cAAc,GAAG,kBAAkB,IAAI;IACvF,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,kBAAkB,CAAA;KAAE,KACpD,OAAO,CAAC,aAAa,CAAC,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,KACzC,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,CACf,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,cAAc,KACrB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACrC,QAAQ,CAAC,kBAAkB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACtF,QAAQ,CAAC,oBAAoB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,QAAQ,CAAC,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAChD,CAAC;AAoFF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,KAAK,CAAC,cAAc,EACrE,QAAQ,qBAAqB,CAAC,CAAC,CAAC,KAC/B,eAeD,CAAC;AAEH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,KAAK,CAAC,cAAc,GAAG,kBAAkB,EACvF,QAAQ,qBAAqB,CAAC,CAAC,CAAC,KAC/B,eAMA,CAAC;AAMJ,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEtE,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;AAEhF,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC"}

package/dist/skills.d.ts

@@ -0,0 +1,33 @@
+/**
+ * On-demand documentation served through the MCP `skills` tool.
+ *
+ * The long-form how-to for calling integrations used to live in the `execute`
+ * tool description, which every session loads into its prompt up front. That
+ * is pure context bloat: a model that never calls `execute` still pays for the
+ * whole calling-convention essay. Moving it behind a tool lets the `execute`
+ * description carry only the live connection inventory plus a pointer here, and
+ * the model fetches the full guide the moment it actually needs it.
+ *
+ * A skill is a static, named markdown document. The registry is intentionally
+ * tiny and hand-curated, not a plugin surface: add an entry only when a tool
+ * genuinely needs its own how-to behind the same `skills` door.
+ */
+export interface Skill {
+    /** Stable identifier the model passes to the `skills` tool. */
+    readonly name: string;
+    /** One-line summary, shown when the `skills` tool lists what is available. */
+    readonly summary: string;
+    /** The full markdown body returned when the skill is fetched by name. */
+    readonly body: string;
+}
+export declare const EXECUTE_SKILL: Skill;
+export declare const RESOLVE_SKILL: Skill;
+/** The full skill catalog. Hand-curated; keep it small. */
+export declare const SKILLS: readonly Skill[];
+/** Look up a skill by its exact name. */
+export declare const findSkill: (name: string) => Skill | undefined;
+/** The index the `skills` tool returns when called without a name (or with an
+ *  unknown one): every skill's name and one-line summary, plus how to fetch
+ *  the body. */
+export declare const renderSkillsIndex: () => string;
+//# sourceMappingURL=skills.d.ts.map

package/dist/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../src/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,KAAK;IACpB,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AA2CD,eAAO,MAAM,aAAa,EAAE,KAK3B,CAAC;AAqCF,eAAO,MAAM,aAAa,EAAE,KAK3B,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,MAAM,EAAE,SAAS,KAAK,EAAmC,CAAC;AAEvE,yCAAyC;AACzC,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,KAAK,GAAG,SACJ,CAAC;AAE9C;;gBAEgB;AAChB,eAAO,MAAM,iBAAiB,QAAO,MAKvB,CAAC"}

package/dist/skills.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=skills.test.d.ts.map

package/dist/skills.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.test.d.ts","sourceRoot":"","sources":["../src/skills.test.ts"],"names":[],"mappings":""}

package/dist/tool-invoker.d.ts

@@ -0,0 +1,105 @@
+import { Effect } from "effect";
+import type { Executor, InvokeOptions } from "@rafads/sdk/core";
+import type { SandboxToolInvoker } from "@rafads/codemode-core";
+import { ExecutionToolError } from "./errors";
+type DescribedTool = {
+    readonly path: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly inputTypeScript?: string;
+    readonly outputTypeScript?: string;
+    readonly typeScriptDefinitions?: Record<string, string>;
+    /** Set when the path resolves to no tool — mirrors invoke's tool_not_found. */
+    readonly error?: {
+        readonly code: "tool_not_found";
+        readonly message: string;
+        readonly suggestions?: readonly string[];
+    };
+};
+/**
+ * Bridges QuickJS `tools.<integration>.<owner>.<connection>.<tool>(args)` calls
+ * into `executor.execute(address, args)`.
+ *
+ * Wrapped in `Effect.fn("mcp.tool.dispatch")` so every tool call becomes a
+ * span in the Effect tracer. Attributes:
+ *   - `mcp.tool.name`         — full tool path (e.g. "github.org.main.getRepo")
+ *   - `mcp.tool.integration`  — first segment of the path (namespace)
+ *
+ * `mcp.tool.kind` (openapi | mcp | graphql | code) is NOT annotated here
+ * because it would require an `integrations.list()` lookup on every invocation.
+ * Callers that already know the integration kind can annotate at their own span.
+ */
+export declare const makeExecutorToolInvoker: (executor: Executor, options: {
+    readonly invokeOptions: InvokeOptions;
+}) => SandboxToolInvoker;
+export type ToolDiscoveryResult = {
+    readonly path: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly integration: string;
+    readonly score: number;
+};
+export type ExecutorIntegrationListItem = {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly kind: string;
+    readonly canRemove?: boolean;
+    readonly canRefresh?: boolean;
+    readonly toolCount: number;
+};
+export type ToolDiscoveryInput = {
+    readonly executor: Executor;
+    readonly query: string;
+    readonly namespace?: string;
+    readonly limit: number;
+    readonly offset: number;
+};
+export interface ToolDiscoveryProvider {
+    readonly searchTools: (input: ToolDiscoveryInput) => Effect.Effect<PagedResult<ToolDiscoveryResult>, ExecutionToolError>;
+}
+/**
+ * Page of results from a list-style discovery tool. Shared by
+ * `tools.search` and `tools.executor.integrations.list` so the model sees one
+ * consistent shape:
+ *
+ *   - `items`      — the page (slice).
+ *   - `total`      — count after filtering, before pagination. The model
+ *                    can use this to detect truncation.
+ *   - `hasMore`    — convenience flag for `(offset + items.length) < total`.
+ *   - `nextOffset` — concrete offset for the next page when `hasMore`,
+ *                    `null` otherwise. Pre-computing it removes a class of
+ *                    off-by-one mistakes when the model paginates.
+ */
+export type PagedResult<T> = {
+    readonly items: readonly T[];
+    readonly total: number;
+    readonly hasMore: boolean;
+    readonly nextOffset: number | null;
+};
+/** What `tools.search()` calls inside the sandbox. */
+export declare const searchTools: (executor: Executor, query: string, limit?: any, options?: {
+    readonly namespace?: string;
+    readonly offset?: number;
+} | undefined) => Effect.Effect<PagedResult<ToolDiscoveryResult>, ExecutionToolError, never>;
+export declare const defaultToolDiscoveryProvider: ToolDiscoveryProvider;
+/** What `tools.executor.integrations.list()` calls inside the sandbox. v2: the
+ *  integrations are the integration catalog; tool counts come from the
+ *  per-connection tool list. */
+export declare const listExecutorIntegrations: (executor: Executor, options?: {
+    readonly query?: string;
+    readonly limit?: number;
+    readonly offset?: number;
+} | undefined) => Effect.Effect<PagedResult<{
+    kind: string;
+    canRemove: boolean;
+    canRefresh: boolean;
+    toolCount: number;
+    description?: string | undefined;
+    id: string;
+    name: string;
+}>, ExecutionToolError, never>;
+/** What `tools.describe.tool()` calls inside the sandbox. */
+export declare const describeTool: (executor: Executor, path: string) => Effect.Effect<DescribedTool, import("@rafads/sdk/core").StorageFailure | ExecutionToolError, never>;
+export {};
+//# sourceMappingURL=tool-invoker.d.ts.map

package/dist/tool-invoker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-invoker.d.ts","sourceRoot":"","sources":["../src/tool-invoker.ts"],"names":[],"mappings":"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"}

package/dist/tool-invoker.leak.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-invoker.leak.test.d.ts.map

package/dist/tool-invoker.leak.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-invoker.leak.test.d.ts","sourceRoot":"","sources":["../src/tool-invoker.leak.test.ts"],"names":[],"mappings":""}

package/dist/tool-invoker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-invoker.test.d.ts.map

package/dist/tool-invoker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-invoker.test.d.ts","sourceRoot":"","sources":["../src/tool-invoker.test.ts"],"names":[],"mappings":""}

package/dist/use-need.d.ts

@@ -0,0 +1,59 @@
+import { Effect } from "effect";
+type InvokeFn = (input: {
+    readonly path: string;
+    readonly args: unknown;
+}) => Effect.Effect<unknown, unknown, never>;
+export interface UseNeedArgs {
+    readonly need: string;
+    readonly not?: readonly string[];
+    readonly compare?: boolean;
+}
+/** The one card a reply carries. `sponsored` is the label — mandatory,
+ *  machine-readable, on every reply that names a provider. */
+interface ProviderCard {
+    readonly id: string;
+    readonly name: string;
+    readonly domain: string;
+    readonly category: string;
+    readonly sponsored: boolean;
+    readonly offer?: {
+        readonly terms: string;
+        readonly url: string;
+    };
+    readonly verifiedAt: string;
+}
+export type UseNeedReply = {
+    readonly status: "ready";
+    readonly provider: ProviderCard;
+    readonly alternativesCount: number;
+    readonly toolsPath: string | undefined;
+    readonly instructions: string;
+} | {
+    readonly status: "pending";
+    readonly provider: ProviderCard;
+    readonly alternativesCount: number;
+    readonly url: string;
+    readonly instructions: string;
+} | {
+    readonly status: "compare";
+    readonly candidates: readonly ProviderCard[];
+    readonly instructions: string;
+} | {
+    readonly status: "manual";
+    readonly provider: ProviderCard;
+    readonly alternativesCount: number;
+    readonly installCommand: string;
+    readonly instructions: string;
+} | {
+    readonly status: "no_match";
+    readonly categories: readonly string[];
+    readonly instructions: string;
+} | {
+    readonly status: "error";
+    readonly step: string;
+    readonly message: string;
+    readonly instructions: string;
+};
+export declare const runUseNeed: (invoke: InvokeFn, rawArgs: unknown) => Effect.Effect<UseNeedReply>;
+export {};
+//# sourceMappingURL=use-need.d.ts.map

package/dist/use-need.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-need.d.ts","sourceRoot":"","sources":["../src/use-need.ts"],"names":[],"mappings":"AA+BA,OAAO,EAAS,MAAM,EAA6B,MAAM,QAAQ,CAAC;AAYlE,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;8DAC8D;AAC9D,UAAU,YAAY;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,YAAY,GACpB;IACE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC;AA2FN,eAAO,MAAM,UAAU,GAAI,QAAQ,QAAQ,EAAE,SAAS,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,YAAY,CA8MtF,CAAC"}

package/dist/use-need.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-need.test.d.ts.map

package/dist/use-need.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-need.test.d.ts","sourceRoot":"","sources":["../src/use-need.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@rafads/execution",
+  "version": "1.5.38",
+  "homepage": "https://github.com/UsefulSoftwareCo/executor/tree/main/packages/core/execution",
+  "bugs": {
+    "url": "https://github.com/UsefulSoftwareCo/executor/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/UsefulSoftwareCo/executor.git",
+    "directory": "packages/core/execution"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/promise.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./core": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/core.js"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup && tsc --declaration --emitDeclarationOnly --outDir dist --rootDir src",
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run",
+    "typecheck:slow": "bunx tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@rafads/codemode-core": "1.5.38",
+    "@rafads/sdk": "1.5.38"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.59",
+    "@rafads/runtime-quickjs": "1.5.38",
+    "@types/node": "^24.3.1",
+    "bun-types": "^1.2.22",
+    "effect": "4.0.0-beta.59",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-beta.59"
+  }
+}