apps 0.0.1-beta.84 → 0.0.1-beta.86

package/js/chunk-IGOYMUWZ.js

@@ -1,394 +0,0 @@
-import {
-  prepareElicitation
-} from "./chunk-OHBKJ54H.js";
-import {
-  bodyUpstreamError,
-  fromPromise
-} from "./chunk-W6XCQAXP.js";
-import {
-  ElicitationFailed,
-  McpError,
-  McpServerHeader,
-  McpToolMetadata,
-  McpToolResult,
-  RouterIcon,
-  ToolResultObservation,
-  defaultElicitationLimits,
-  defaultMcpClientLimits,
-  mcpSdkTimerCeilingMs
-} from "./chunk-NG56RPCA.js";
-import {
-  jsonSchemaDecoder,
-  nestJsonSchema,
-  preparedJsonSchemaDecoder
-} from "./chunk-KGCTYL2S.js";
-import {
-  owned
-} from "./chunk-QWQM3CLH.js";
-import {
-  JsonObject
-} from "./chunk-H2CJWXA3.js";
-import {
-  Clock_exports,
-  Deferred_exports,
-  Effect_exports,
-  Exit_exports,
-  Option_exports,
-  Queue_exports,
-  Schema_exports
-} from "./chunk-IFJU5SYQ.js";
-
-// src/implementation/mcp-tools.ts
-var resultFields = {
-  content: { type: "array", items: { type: "object" } },
-  structuredContent: { type: "object" },
-  isError: { type: "boolean" },
-  _meta: { type: "object" }
-};
-var definitionReference = /^#\/(?:\$defs|definitions)\/[^/]+$/;
-var locating = /* @__PURE__ */ new Set(["$id", "$anchor", "$dynamicAnchor", "$recursiveAnchor"]);
-var onlyDefinitionReferences = (value) => Array.isArray(value) ? value.every(onlyDefinitionReferences) : value === null || typeof value !== "object" ? true : Object.entries(value).every(
-  ([key, item]) => locating.has(key) || key === "$dynamicRef" || key === "$recursiveRef" ? false : key === "$ref" ? typeof item === "string" && definitionReference.test(item) : onlyDefinitionReferences(item)
-);
-var placed = (structuredContent, pointer) => {
-  if (onlyDefinitionReferences(structuredContent)) {
-    const { $defs, definitions, $schema: _draft, ...schema } = structuredContent;
-    return {
-      schema,
-      root: {
-        ...$defs === void 0 ? {} : { $defs },
-        ...definitions === void 0 ? {} : { definitions }
-      }
-    };
-  }
-  try {
-    return { schema: nestJsonSchema(structuredContent, pointer), root: {} };
-  } catch {
-    return { schema: structuredContent, root: {} };
-  }
-};
-var resultSchema = (structuredContent) => {
-  if (structuredContent === void 0)
-    return { type: "object", properties: resultFields, required: ["content"] };
-  const { schema, root } = placed(structuredContent, "#/anyOf/0/properties/structuredContent");
-  return {
-    // The envelope's keywords mean the same in every draft, so the server's draft applies.
-    ...structuredContent.$schema === void 0 ? {} : { $schema: structuredContent.$schema },
-    ...root,
-    anyOf: [
-      {
-        type: "object",
-        properties: { ...resultFields, structuredContent: schema, isError: { const: false } },
-        required: ["content", "structuredContent"]
-      },
-      {
-        type: "object",
-        properties: { ...resultFields, isError: { const: true } },
-        required: ["content", "isError"]
-      }
-    ]
-  };
-};
-var adaptMcpTool = (client, tool) => Effect_exports.gen(function* () {
-  const decoder = yield* jsonSchemaDecoder(tool.inputSchema).pipe(
-    Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
-  );
-  const output = preparedJsonSchemaDecoder(resultSchema(tool.outputSchema));
-  const { outputSchema: _upstream, ...metadata } = tool;
-  const adapted = {
-    ...metadata,
-    description: tool.description ?? tool.title ?? tool.name,
-    input: decoder,
-    output: output.decoder,
-    ...tool.annotations?.readOnlyHint === void 0 ? {} : { readOnly: tool.annotations.readOnlyHint },
-    run: (context, input) => Effect_exports.gen(function* () {
-      const arguments_ = yield* Schema_exports.decodeUnknownEffect(decoder)(input).pipe(
-        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonObject)),
-        Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_input" }))
-      );
-      yield* output.compile.pipe(
-        Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
-      );
-      const result = yield* client.call(tool.name, arguments_, context);
-      if (result.isError === true) {
-        (yield* ToolResultObservation).failed();
-        yield* Effect_exports.annotateCurrentSpan({
-          "executor.outcome": "failed",
-          "error.type": "McpToolError"
-        });
-      }
-      return result;
-    })
-  };
-  return adapted;
-});
-var adaptMcpTools = (client) => Effect_exports.gen(function* () {
-  const { tools: metadata } = yield* client.list;
-  const entries = yield* Effect_exports.forEach(
-    metadata,
-    (tool) => adaptMcpTool(client, tool).pipe(Effect_exports.map((adapted) => [tool.name, adapted]))
-  );
-  return Object.fromEntries(entries);
-});
-
-// src/implementation/mcp-client.ts
-import {
-  ErrorCode as ErrorCode2,
-  ListToolsResultSchema,
-  McpError as ProtocolError2
-} from "@modelcontextprotocol/sdk/types.js";
-
-// src/implementation/mcp-call.ts
-import {
-  ElicitRequestSchema,
-  ElicitResultSchema,
-  ErrorCode,
-  McpError as ProtocolError
-} from "@modelcontextprotocol/sdk/types.js";
-function callBudget(timeoutMs) {
-  return Effect_exports.gen(function* () {
-    const clock = yield* Clock_exports.Clock;
-    const changes = yield* Queue_exports.unbounded();
-    let remaining = timeoutMs, updated = clock.currentTimeMillisUnsafe(), waiting = 0;
-    const account = () => {
-      const now = clock.currentTimeMillisUnsafe();
-      if (waiting === 0) remaining -= Math.max(0, now - updated);
-      updated = now;
-      return remaining;
-    };
-    return {
-      waitForInput: (input) => Effect_exports.acquireUseRelease(
-        Effect_exports.sync(() => {
-          account();
-          waiting++;
-        }).pipe(Effect_exports.andThen(Queue_exports.offer(changes, void 0))),
-        () => input,
-        () => Effect_exports.sync(() => {
-          account();
-          waiting--;
-        }).pipe(Effect_exports.andThen(Queue_exports.offer(changes, void 0)))
-      ),
-      expired: Effect_exports.gen(function* () {
-        while (true) {
-          const left = account();
-          if (waiting === 0 && left <= 0)
-            return yield* new McpError({ phase: "call", reason: "timeout" });
-          if (waiting > 0) yield* Queue_exports.take(changes);
-          else yield* Queue_exports.take(changes).pipe(Effect_exports.raceFirst(Effect_exports.sleep(Math.max(1, left))));
-        }
-      })
-    };
-  });
-}
-var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_exports.scoped(
-  Effect_exports.gen(function* () {
-    const budget = yield* callBudget(timeoutMs);
-    const failed = yield* Deferred_exports.make();
-    const runtime = yield* Effect_exports.context();
-    const callbacks = /* @__PURE__ */ new Set();
-    const lifetime = yield* Effect_exports.acquireRelease(
-      Effect_exports.sync(() => new AbortController()),
-      (controller) => (
-        // oxlint-disable-next-line executor/authored-code-through-adapter -- the MCP SDK's elicitation callbacks
-        Effect_exports.promise(async () => {
-          controller.abort();
-          client.removeRequestHandler("elicitation/create");
-          await Promise.allSettled(callbacks);
-        })
-      )
-    );
-    client.setRequestHandler(ElicitRequestSchema, (request, extra) => {
-      const signal = AbortSignal.any([lifetime.signal, extra.signal]);
-      const interaction = Effect_exports.gen(function* () {
-        const form = yield* prepareElicitation({
-          ...request.params,
-          mode: request.params.mode ?? "form"
-        });
-        const deliver = context.elicit;
-        if (deliver === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
-        const answer = yield* budget.waitForInput(
-          fromPromise(
-            deliver,
-            "elicitation"
-          )(form.request).pipe(
-            Effect_exports.mapError(
-              (error) => Option_exports.getOrElse(
-                Schema_exports.decodeUnknownOption(ElicitationFailed)(error),
-                () => new ElicitationFailed({ reason: "transport" })
-              )
-            ),
-            Effect_exports.timeoutOrElse({
-              duration: defaultElicitationLimits.timeoutMs,
-              orElse: () => Effect_exports.fail(new ElicitationFailed({ reason: "expired" }))
-            })
-          )
-        ).pipe(Effect_exports.withSpan("provider.mcp.elicitation"));
-        return yield* form.respond(answer).pipe(
-          Effect_exports.flatMap(
-            (response) => Effect_exports.try({
-              try: () => ElicitResultSchema.parse(response),
-              catch: () => new ElicitationFailed({ reason: "invalid-response" })
-            })
-          )
-        );
-      }).pipe(Effect_exports.tapError((error) => Deferred_exports.fail(failed, error)));
-      const callback = Effect_exports.runPromiseWith(runtime)(interaction, { signal }).catch(() => {
-        if (!lifetime.signal.aborted)
-          Effect_exports.runSync(Deferred_exports.fail(failed, new ElicitationFailed({ reason: "transport" })));
-        throw new ProtocolError(ErrorCode.InternalError, "User input could not be delivered");
-      });
-      callbacks.add(callback);
-      return callback.finally(() => callbacks.delete(callback));
-    });
-    return yield* Effect_exports.tryPromise({
-      try: (signal) => client.callTool({ name, arguments: input }, void 0, {
-        signal: AbortSignal.any([signal, lifetime.signal]),
-        timeout: mcpSdkTimerCeilingMs
-      }),
-      catch: (error) => failure("call", error)
-    }).pipe(
-      Effect_exports.raceFirst(Deferred_exports.await(failed)),
-      Effect_exports.raceFirst(budget.expired),
-      Effect_exports.flatMap(
-        (result) => Schema_exports.decodeUnknownEffect(McpToolResult)(result).pipe(
-          Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_response" }))
-        )
-      ),
-      Effect_exports.tap(
-        (result) => Effect_exports.annotateCurrentSpan("mcp.tool.is_error", result.isError === true)
-      )
-    );
-  })
-).pipe(
-  owned("upstream", "provider.mcp.request", {
-    kind: "client",
-    attributes: {
-      "rpc.system.name": "jsonrpc",
-      "rpc.method": "tools/call",
-      "mcp.tool.name": name
-    }
-  })
-);
-
-// src/implementation/mcp-client.ts
-var clientCodes = /* @__PURE__ */ new Set([
-  ErrorCode2.RequestTimeout,
-  ErrorCode2.ConnectionClosed
-]);
-var answeredError = (error) => {
-  if (!(error instanceof ProtocolError2) || clientCodes.has(error.code)) return void 0;
-  const prefix = `MCP error ${error.code}: `;
-  return bodyUpstreamError({
-    error: {
-      code: error.code,
-      message: error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message
-    }
-  });
-};
-var mcpJsonSchemaValidator = {
-  getValidator(document) {
-    const decoder = Effect_exports.runSync(jsonSchemaDecoder(document));
-    return (input) => {
-      const result = Effect_exports.runSyncExit(Schema_exports.decodeUnknownEffect(decoder)(input));
-      if (Exit_exports.isFailure(result))
-        return {
-          valid: false,
-          data: void 0,
-          errorMessage: "Value does not match the supported JSON Schema"
-        };
-      return { valid: true, data: result.value, errorMessage: void 0 };
-    };
-  }
-};
-function mcpClient(withClient, timeoutMs, failure) {
-  const list = withClient(
-    "discover",
-    (client) => Effect_exports.gen(function* () {
-      const tools = /* @__PURE__ */ new Map();
-      const cursors = /* @__PURE__ */ new Set();
-      let cursor;
-      do {
-        const page = yield* Effect_exports.tryPromise({
-          // This session only reads metadata. listTools() also eagerly compiles
-          // every output validator; mcpRouter validates the selected tool on call.
-          try: (signal) => client.request(
-            { method: "tools/list", params: cursor === void 0 ? {} : { cursor } },
-            ListToolsResultSchema,
-            { signal, timeout: timeoutMs }
-          ),
-          catch: (error) => failure("discover", error)
-        }).pipe(
-          owned("upstream", "provider.mcp.request", {
-            kind: "client",
-            attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
-          })
-        );
-        const metadata = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(McpToolMetadata))(
-          page.tools
-        ).pipe(
-          Effect_exports.mapError(() => new McpError({ phase: "discover", reason: "invalid_response" }))
-        );
-        for (const tool of metadata) {
-          if (!tool.name || tools.has(tool.name) || tools.size >= defaultMcpClientLimits.maxTools)
-            return yield* new McpError({ phase: "discover", reason: "invalid_response" });
-          tools.set(tool.name, tool);
-        }
-        cursor = page.nextCursor;
-        if (cursor !== void 0) {
-          if (cursors.has(cursor) || cursors.size >= defaultMcpClientLimits.maxPaginationCursors)
-            return yield* new McpError({ phase: "discover", reason: "invalid_response" });
-          cursors.add(cursor);
-        }
-      } while (cursor !== void 0);
-      const info = client.getServerVersion();
-      const instructions = client.getInstructions();
-      const icons = info?.icons?.flatMap(
-        (icon) => Option_exports.toArray(Schema_exports.decodeUnknownOption(RouterIcon)(icon))
-      );
-      const server = Schema_exports.decodeUnknownOption(McpServerHeader)({
-        ...info?.name === void 0 ? {} : { name: info.name },
-        ...info?.title === void 0 ? {} : { title: info.title },
-        ...info?.version === void 0 ? {} : { version: info.version },
-        ...info?.description === void 0 ? {} : { description: info.description },
-        ...info?.websiteUrl === void 0 ? {} : { websiteUrl: info.websiteUrl },
-        ...icons === void 0 ? {} : { icons },
-        ...instructions === void 0 ? {} : { instructions }
-      });
-      return {
-        tools: [...tools.values()],
-        server: Option_exports.getOrElse(server, () => ({}))
-      };
-    })
-  ).pipe(owned("upstream", "provider.mcp.discover"));
-  const check = withClient(
-    "discover",
-    (client) => (
-      // oxlint-disable-next-line executor/authored-code-through-adapter -- MCP SDK
-      Effect_exports.tryPromise({
-        try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
-          signal,
-          timeout: timeoutMs
-        }),
-        catch: (error) => failure("discover", error)
-      }).pipe(
-        Effect_exports.asVoid,
-        owned("upstream", "provider.mcp.request", {
-          kind: "client",
-          attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
-        })
-      )
-    )
-  ).pipe(owned("upstream", "provider.mcp.check"));
-  const call = (name, input, context) => withClient("call", (client) => mcpCall(client, name, input, context, timeoutMs, failure)).pipe(
-    owned("upstream", "provider.mcp.call", { attributes: { "mcp.tool.name": name } })
-  );
-  return { list, check, call };
-}
-
-export {
-  adaptMcpTool,
-  adaptMcpTools,
-  answeredError,
-  mcpJsonSchemaValidator,
-  mcpClient
-};

package/js/mcp/stdio.js

@@ -1,138 +0,0 @@
-import {
-  adaptMcpTools,
-  answeredError,
-  mcpClient,
-  mcpJsonSchemaValidator
-} from "../chunk-IGOYMUWZ.js";
-import {
-  protocolRouter
-} from "../chunk-T2B6GUVY.js";
-import "../chunk-BCSNKUAC.js";
-import "../chunk-OHBKJ54H.js";
-import "../chunk-PL5KOEZD.js";
-import "../chunk-JKH7ALFN.js";
-import "../chunk-I6Q7ZPKJ.js";
-import "../chunk-XBG7HHXC.js";
-import "../chunk-AIXYBMMI.js";
-import "../chunk-HNCCRVIT.js";
-import "../chunk-W6XCQAXP.js";
-import {
-  McpError,
-  ProcessConfig
-} from "../chunk-NG56RPCA.js";
-import "../chunk-Q4IZAUIF.js";
-import "../chunk-H72MEDMN.js";
-import "../chunk-KGCTYL2S.js";
-import {
-  owned
-} from "../chunk-QWQM3CLH.js";
-import "../chunk-PD6I2SDG.js";
-import "../chunk-5FHWNLCI.js";
-import "../chunk-H2CJWXA3.js";
-import "../chunk-TUMGL2OC.js";
-import "../chunk-EOPQ727L.js";
-import {
-  Effect_exports,
-  Schema_exports
-} from "../chunk-IFJU5SYQ.js";
-import "../chunk-CZ7CSFO4.js";
-
-// src/implementation/mcp-stdio.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { ErrorCode, McpError as ProtocolError } from "@modelcontextprotocol/sdk/types.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-var OwnedTransport = class extends StdioClientTransport {
-  closing;
-  exited;
-  start() {
-    const previous = this.onclose;
-    this.exited = new Promise((resolve) => {
-      this.onclose = () => {
-        resolve();
-        previous?.();
-      };
-    });
-    return super.start();
-  }
-  close() {
-    return this.closing ??= (async () => {
-      const started = this.pid !== null;
-      await super.close();
-      if (started) await this.exited;
-    })();
-  }
-};
-var failure = (phase, error) => {
-  const upstream = answeredError(error);
-  return new McpError({
-    phase,
-    reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
-    ...upstream === void 0 ? {} : { upstream }
-  });
-};
-function withClient(config, mode, use) {
-  return Effect_exports.scoped(
-    Effect_exports.gen(function* () {
-      const { client, transport } = yield* Effect_exports.acquireRelease(
-        Effect_exports.sync(() => ({
-          client: new Client(
-            { name: "executor-app", version: "1" },
-            {
-              jsonSchemaValidator: mcpJsonSchemaValidator,
-              capabilities: mode === "call" ? { elicitation: { form: {} } } : {}
-            }
-          ),
-          transport: new OwnedTransport({
-            command: config.command,
-            args: [...config.args],
-            env: { ...config.env },
-            ...config.cwd === void 0 ? {} : { cwd: config.cwd },
-            stderr: "ignore"
-          })
-        })),
-        ({ client: client2, transport: transport2 }) => (
-          // oxlint-disable-next-line executor/authored-code-through-adapter -- MCP SDK
-          Effect_exports.tryPromise(async () => {
-            try {
-              await client2.close();
-            } finally {
-              await transport2.close();
-            }
-          }).pipe(owned("upstream", "provider.mcp.close"), Effect_exports.orDie)
-        )
-      );
-      yield* Effect_exports.tryPromise({
-        try: (signal) => client.connect(transport, { signal, timeout: config.timeoutMs }),
-        catch: (error) => failure("connect", error)
-      }).pipe(Effect_exports.timeout(config.timeoutMs), owned("upstream", "provider.mcp.connect"));
-      return yield* use(client);
-    })
-  ).pipe(
-    owned("upstream", "provider.mcp.session", {
-      attributes: { "mcp.transport": "stdio", "mcp.operation": mode }
-    }),
-    (operation) => mode === "discover" ? operation.pipe(Effect_exports.timeout(config.timeoutMs)) : operation,
-    Effect_exports.catchTag(
-      "TimeoutError",
-      () => Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
-    )
-  );
-}
-var stdioToolsEffect = (input) => Effect_exports.gen(function* () {
-  const config = yield* Schema_exports.decodeUnknownEffect(ProcessConfig)(input).pipe(
-    Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" }))
-  );
-  return yield* adaptMcpTools(
-    mcpClient((mode, use) => withClient(config, mode, use), config.timeoutMs, failure)
-  );
-});
-
-// src/mcp-stdio.ts
-var stdioRouter = (config, signal, kinds = {}) => Effect_exports.runPromise(
-  stdioToolsEffect(config).pipe(Effect_exports.map((tools) => protocolRouter(tools, kinds))),
-  signal === void 0 ? {} : { signal }
-);
-export {
-  McpError,
-  stdioRouter
-};

package/types/apps/src/implementation/mcp-stdio.d.ts

@@ -1,4 +0,0 @@
-import { Effect } from "effect";
-import { McpError, ProcessConfig } from "../contracts/mcp.js";
-/** Each discovery/call owns and closes its subprocess. Deployment never starts it. */
-export declare const stdioToolsEffect: (input: ProcessConfig) => Effect.Effect<Readonly<Record<string, import("../contracts/mcp.js").McpTool>>, import("../index.js").ProviderError | import("../index.js").NetworkRefused | McpError, never>;

package/types/apps/src/mcp-stdio.d.ts

@@ -1,5 +0,0 @@
-import type { ProcessConfig } from "./contracts/mcp.js";
-import { type OperationKinds } from "./implementation/protocol-operations.js";
-export { McpError, type McpToolContext, type ProcessConfig } from "./contracts/mcp.js";
-/** Discover an account's tools as a router; each discovery and call owns and closes its subprocess. */
-export declare const stdioRouter: (config: ProcessConfig, signal?: AbortSignal, kinds?: OperationKinds) => Promise<import("./index.js").RouterDeclaration<unknown, unknown>>;