apps 0.0.1-beta.0

package/js/host.js

@@ -0,0 +1,193 @@
+import {
+  createAppHandler
+} from "./chunk-Q2FD5IBM.js";
+import "./chunk-X3YBZCJW.js";
+import "./chunk-R6JMJSVT.js";
+import "./chunk-C24KEZXR.js";
+import {
+  HostAccountsInvalid,
+  HostInputInvalid,
+  HostResponse,
+  ResolvedAccounts,
+  TrustedToolApproval
+} from "./chunk-22WRQZT7.js";
+import {
+  ElicitationFailed,
+  ElicitationReply,
+  WorkflowFailure,
+  WorkflowRpcResult,
+  WorkflowRun,
+  WorkflowRunId,
+  WorkflowRunPage
+} from "./chunk-HP7E42X6.js";
+import "./chunk-7JXHF5IF.js";
+import {
+  collectTelemetry,
+  withRemoteSpan
+} from "./chunk-OWD2YICM.js";
+import "./chunk-VFUZI3NY.js";
+import "./chunk-W7Q5EOTS.js";
+import "./chunk-BPEFS4YF.js";
+import "./chunk-EP6AEUZO.js";
+import "./chunk-36DNRFZQ.js";
+import {
+  Cause_exports,
+  Effect_exports,
+  Redacted_exports,
+  Scheduler_exports,
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/implementation/workflow-rpc.ts
+var isolatedWorkflowExecution = (run, deliver, signal) => {
+  const runId = Schema_exports.decodeUnknownSync(WorkflowRunId)(run);
+  const request = (input, callback) => Effect_exports.tryPromise({
+    try: () => deliver(input, callback),
+    catch: () => new WorkflowFailure({ reason: "engine", retryable: true })
+  }).pipe(
+    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(WorkflowRpcResult)),
+    Effect_exports.mapError(() => new WorkflowFailure({ reason: "engine", retryable: true })),
+    Effect_exports.flatMap(
+      (reply) => reply.ok ? Effect_exports.succeed(reply.value) : Effect_exports.fail(reply.error)
+    )
+  );
+  return {
+    runId,
+    driver: {
+      do: (name, options, work) => Effect_exports.gen(function* () {
+        const services = yield* Effect_exports.context();
+        return yield* request(
+          { operation: "do", name, options },
+          () => Effect_exports.runPromiseWith(services)(
+            work().pipe(
+              Effect_exports.matchCause({
+                onSuccess: (value) => ({ ok: true, value }),
+                onFailure: (cause) => {
+                  const error = Cause_exports.squash(cause);
+                  return {
+                    ok: false,
+                    error: Schema_exports.is(WorkflowFailure)(error) ? error : new WorkflowFailure({ reason: "execution", retryable: true })
+                  };
+                }
+              }),
+              Effect_exports.flatMap(Schema_exports.encodeEffect(WorkflowRpcResult))
+            ),
+            { signal }
+          )
+        );
+      }),
+      sleep: (name, duration) => request({ operation: "sleep", name, duration }).pipe(Effect_exports.asVoid),
+      sleepUntil: (name, timestamp) => request({ operation: "until", name, timestamp }).pipe(Effect_exports.asVoid)
+    },
+    resolve: () => request({ operation: "context" }).pipe(
+      Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(ResolvedAccounts)),
+      Effect_exports.map((accounts) => ({ accounts: Redacted_exports.make(accounts) })),
+      Effect_exports.mapError(
+        (error) => Schema_exports.is(WorkflowFailure)(error) ? error : new WorkflowFailure({ reason: "credentials", retryable: false })
+      )
+    ),
+    invoke: (input) => request({ operation: "invoke", ...input })
+  };
+};
+var isolatedWorkflowControls = (deliver) => {
+  const request = (input) => Effect_exports.tryPromise({
+    try: () => deliver(input),
+    catch: () => new WorkflowFailure({ reason: "engine", retryable: true })
+  }).pipe(
+    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(WorkflowRpcResult)),
+    Effect_exports.mapError(() => new WorkflowFailure({ reason: "engine", retryable: true })),
+    Effect_exports.flatMap(
+      (result) => result.ok ? Effect_exports.succeed(result.value) : Effect_exports.fail(result.error)
+    )
+  );
+  const run = (input) => request(input).pipe(
+    Effect_exports.flatMap(
+      (value) => Schema_exports.decodeUnknownEffect(WorkflowRun)(value).pipe(
+        Effect_exports.mapError(() => new WorkflowFailure({ reason: "engine", retryable: true }))
+      )
+    )
+  );
+  return {
+    start: (input) => run({ operation: "start", ...input }),
+    get: (input) => run({ operation: "get", ...input }),
+    terminate: (input) => run({ operation: "terminate", ...input }),
+    list: (input) => request({ operation: "list", ...input }).pipe(
+      Effect_exports.flatMap(
+        (value) => Schema_exports.decodeUnknownEffect(WorkflowRunPage)(value).pipe(
+          Effect_exports.mapError(() => new WorkflowFailure({ reason: "engine", retryable: true }))
+        )
+      )
+    )
+  };
+};
+
+// src/host.ts
+var hostContext = (accounts, approval) => ({
+  ...approval === void 0 ? {} : {
+    approval: Effect_exports.runSync(
+      Schema_exports.decodeUnknownEffect(TrustedToolApproval)(approval).pipe(
+        Effect_exports.mapError(() => new HostInputInvalid())
+      )
+    )
+  },
+  accounts: Effect_exports.runSync(
+    Schema_exports.decodeUnknownEffect(Schema_exports.RedactedFromValue(ResolvedAccounts))(accounts).pipe(
+      Effect_exports.mapError(() => new HostAccountsInvalid())
+    )
+  )
+});
+var createAppHandler2 = (app) => {
+  const handler = createAppHandler(app);
+  return (request, context) => {
+    const operation = handler(request, context).pipe(withRemoteSpan(request, "app.dispatch"));
+    return Effect_exports.runPromise(
+      context.telemetry === void 0 ? operation : operation.pipe(Effect_exports.provideContext(context.telemetry.context)),
+      { signal: request.signal }
+    );
+  };
+};
+var createIsolatedAppHandler = (app) => {
+  const handler = createAppHandler(app);
+  return (request, context) => Effect_exports.runPromise(
+    Effect_exports.gen(function* () {
+      const { value, telemetry } = yield* collectTelemetry(
+        handler(request, context).pipe(withRemoteSpan(request, "app.dispatch"))
+      );
+      const body = yield* Effect_exports.promise(() => value.json()).pipe(
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(HostResponse))
+      );
+      return Response.json({ ...body, telemetry }, { status: value.status });
+    }),
+    {
+      signal: request.signal,
+      // workerd delivers timers in order. A scheduler timer outside a transaction
+      // can block timers inside its closed input gate; microtasks avoid that queue.
+      scheduler: new Scheduler_exports.MixedScheduler("sync")
+    }
+  );
+};
+var isolatedElicitation = (deliver, lifetime) => (request) => Effect_exports.tryPromise({
+  try: () => deliver(request),
+  catch: () => {
+    lifetime.abort();
+    return new ElicitationFailed({ reason: "transport" });
+  }
+}).pipe(
+  Effect_exports.flatMap(
+    (reply) => Schema_exports.decodeUnknownEffect(ElicitationReply)(reply).pipe(
+      Effect_exports.mapError(() => new ElicitationFailed({ reason: "transport" }))
+    )
+  ),
+  Effect_exports.flatMap(
+    (reply) => reply.ok ? Effect_exports.succeed(reply.response) : Effect_exports.fail(reply.error)
+  )
+);
+export {
+  createAppHandler2 as createAppHandler,
+  createIsolatedAppHandler,
+  hostContext,
+  isolatedElicitation,
+  isolatedWorkflowControls,
+  isolatedWorkflowExecution
+};

package/js/index.js

@@ -0,0 +1,284 @@
+import {
+  defineApp,
+  defineDatabase,
+  table,
+  workflow
+} from "./chunk-X3YBZCJW.js";
+import "./chunk-R6JMJSVT.js";
+import {
+  mutation,
+  nativeOperation,
+  operationDeclaration,
+  query,
+  withApproval
+} from "./chunk-C24KEZXR.js";
+import {
+  CalendarSchedule,
+  ElicitationFailed,
+  Interval,
+  NonRetryableError,
+  OAuth2AccessToken,
+  OAuth2Config,
+  OAuth2Method,
+  Provider,
+  ScheduleTiming,
+  SecretsMethod,
+  WorkflowFailure
+} from "./chunk-HP7E42X6.js";
+import "./chunk-7JXHF5IF.js";
+import {
+  array,
+  boolean,
+  decoderOf,
+  id,
+  importedJsonSchema,
+  json,
+  jsonSchema,
+  literal,
+  nestJsonSchema,
+  number,
+  object,
+  parse,
+  record,
+  string,
+  userId,
+  withJsonSchemaDocument,
+  wrap
+} from "./chunk-BPEFS4YF.js";
+import "./chunk-EP6AEUZO.js";
+import {
+  JsonObject,
+  JsonValue,
+  ValidationError
+} from "./chunk-36DNRFZQ.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/contracts/http.ts
+var ResponseStatusError = class extends Schema_exports.TaggedError()(
+  "ResponseStatusError",
+  { status: Schema_exports.Number }
+) {
+  get message() {
+    return `Request failed with status ${this.status}`;
+  }
+};
+var ResponseDecodeError = class extends Schema_exports.TaggedError()(
+  "ResponseDecodeError",
+  {}
+) {
+  get message() {
+    return "Response body did not match the expected schema";
+  }
+};
+
+// src/implementation/http.ts
+var decodeJson = (response, schema) => Effect_exports.gen(function* () {
+  if (response.status < 200 || response.status >= 300) {
+    return yield* Effect_exports.fail(new ResponseStatusError({ status: response.status }));
+  }
+  const body = yield* response.json();
+  return yield* parse(schema, body).pipe(Effect_exports.mapError(() => new ResponseDecodeError()));
+});
+
+// src/implementation/provider.ts
+var secrets = (options) => new SecretsMethod(options);
+var oauth2 = (config, response) => parse(OAuth2Config, config).pipe(Effect_exports.map((config2) => new OAuth2Method({ config: config2, response })));
+var defineProvider = (options) => new Provider(options);
+
+// src/implementation/account-operations.ts
+var inputDocument = (operation) => {
+  const imported = importedJsonSchema(operation.input);
+  if (imported !== void 0) return Schema_exports.decodeUnknownSync(JsonObject)(imported);
+  const document = Schema_exports.toJsonSchemaDocument(operation.input);
+  return Schema_exports.decodeUnknownSync(JsonObject)({ ...document.schema, $defs: document.definitions });
+};
+var combine = (kind, groups) => Object.fromEntries(
+  [...groups].map(([name, accounts]) => {
+    const variants = [...accounts.values()];
+    const first = variants[0];
+    if (first === void 0)
+      throw new Error("An account operation must have at least one account");
+    const select = (input2) => {
+      const operation = accounts.get(input2.accountId);
+      if (operation === void 0)
+        throw new Error("Account selection must be decoded before execution");
+      return operation;
+    };
+    const outputs = variants.flatMap(
+      (operation) => operation.outputSchema === void 0 ? [] : [operation.outputSchema]
+    );
+    const input = Schema_exports.Union(
+      [...accounts].map(
+        ([accountId, operation]) => Schema_exports.Struct({ accountId: Schema_exports.Literal(accountId), input: operation.input })
+      )
+    );
+    const inputSchema = {
+      type: "object",
+      anyOf: [...accounts].map(([accountId, operation], index) => ({
+        type: "object",
+        properties: {
+          accountId: { type: "string", const: accountId },
+          input: nestJsonSchema(inputDocument(operation), `#/anyOf/${index}/properties/input`)
+        },
+        required: ["accountId", "input"]
+      }))
+    };
+    return [
+      name,
+      operationDeclaration({
+        kind,
+        ...first.description === void 0 ? {} : { description: first.description },
+        ...first.title === void 0 ? {} : { title: first.title },
+        ...first.annotations === void 0 || !variants.every(
+          (operation) => JSON.stringify(operation.annotations) === JSON.stringify(first.annotations)
+        ) ? {} : { annotations: first.annotations },
+        ...first._meta === void 0 || !variants.every(
+          (operation) => JSON.stringify(operation._meta) === JSON.stringify(first._meta)
+        ) ? {} : { _meta: first._meta },
+        input: withJsonSchemaDocument(input, inputSchema),
+        ...outputs.length !== variants.length ? {} : {
+          outputSchema: {
+            anyOf: outputs.map((output, index) => nestJsonSchema(output, `#/anyOf/${index}`))
+          }
+        },
+        approval: (context) => {
+          const operation = select(context.toolInput);
+          return operation.approval === void 0 ? Effect_exports.succeed("approved") : operation.approval({ ...context, toolInput: context.toolInput.input });
+        },
+        run: (context, input2) => {
+          const operation = select(input2);
+          return operation.run(context, input2.input).pipe(
+            Effect_exports.flatMap(
+              (output) => operation.output === void 0 ? Effect_exports.succeed(output) : Schema_exports.decodeUnknownEffect(operation.output)(output)
+            )
+          );
+        }
+      })
+    ];
+  })
+);
+var accountOperations = (accounts, discover, options) => Effect_exports.runPromise(
+  Effect_exports.gen(function* () {
+    const queries = /* @__PURE__ */ new Map();
+    const mutations = /* @__PURE__ */ new Map();
+    for (const account of accounts) {
+      const operations = yield* Effect_exports.tryPromise({
+        try: () => discover(account),
+        catch: (error) => error
+      });
+      for (const [source, target] of [
+        [operations.queries, queries],
+        [operations.mutations, mutations]
+      ]) {
+        for (const [name, declaration2] of Object.entries(source)) {
+          const operation = nativeOperation(declaration2);
+          if (operation === void 0)
+            return yield* Effect_exports.die(new Error("Expected a protocol operation"));
+          const group = target.get(name) ?? /* @__PURE__ */ new Map();
+          if (group.has(account.id))
+            return yield* Effect_exports.die(new Error("Account selections must be unique"));
+          group.set(account.id, operation);
+          target.set(name, group);
+        }
+      }
+    }
+    return { queries: combine("query", queries), mutations: combine("mutation", mutations) };
+  }),
+  options
+);
+
+// src/contracts/app.ts
+var NotImplemented = class extends Schema_exports.TaggedError()("NotImplemented", {
+  operation: Schema_exports.String
+}) {
+};
+
+// src/implementation/schedules.ts
+var declaration = (timing, operation, input) => {
+  const native = nativeOperation(operation);
+  if (native === void 0 || native.kind !== "mutation")
+    throw new Error("A schedule must reference a mutation");
+  Schema_exports.decodeUnknownSync(native.input)(input);
+  return { operation, timing, input: Schema_exports.decodeUnknownSync(JsonValue)(input) };
+};
+var interval = (duration, operation, input) => {
+  const value = Schema_exports.decodeUnknownSync(Interval)(duration);
+  const milliseconds = value.seconds !== void 0 ? value.seconds * 1e3 : value.minutes !== void 0 ? value.minutes * 6e4 : value.hours * 36e5;
+  return declaration(
+    Schema_exports.decodeUnknownSync(ScheduleTiming)({ kind: "interval", milliseconds }),
+    operation,
+    input
+  );
+};
+var cron = (calendar, operation, input) => declaration(
+  {
+    kind: "cron",
+    calendar: Schema_exports.decodeUnknownSync(CalendarSchedule)({
+      ...calendar,
+      timezone: calendar.timezone ?? "UTC"
+    })
+  },
+  operation,
+  input
+);
+
+// src/index.ts
+var OAuth2AccessToken2 = wrap(OAuth2AccessToken, false);
+var secrets2 = (options) => secrets({ label: options.label, fields: decoderOf(options.fields) });
+function oauth22(options) {
+  const { response = OAuth2AccessToken2, ...config } = options;
+  return Effect_exports.runSync(oauth2(config, decoderOf(response)));
+}
+var decodeJson2 = (response, schema) => {
+  const native = {
+    status: response.status,
+    json: () => Effect_exports.tryPromise({
+      try: () => response.json(),
+      catch: (error) => error
+    }).pipe(
+      Effect_exports.catch(
+        (error) => error instanceof SyntaxError ? Effect_exports.fail(new ResponseDecodeError()) : Effect_exports.die(error)
+      )
+    )
+  };
+  return Effect_exports.runPromise(decodeJson(native, decoderOf(schema)));
+};
+export {
+  ElicitationFailed,
+  NonRetryableError,
+  NotImplemented,
+  OAuth2AccessToken2 as OAuth2AccessToken,
+  ResponseDecodeError,
+  ResponseStatusError,
+  ValidationError,
+  WorkflowFailure,
+  accountOperations,
+  array,
+  boolean,
+  cron,
+  decodeJson2 as decodeJson,
+  defineApp,
+  defineDatabase,
+  defineProvider,
+  id,
+  interval,
+  json,
+  jsonSchema,
+  literal,
+  mutation,
+  number,
+  oauth22 as oauth2,
+  object,
+  query,
+  record,
+  secrets2 as secrets,
+  string,
+  table,
+  userId,
+  withApproval,
+  workflow
+};

package/js/mcp/effect.js

@@ -0,0 +1,23 @@
+import {
+  mcpToolsEffect
+} from "../chunk-WIDTG42X.js";
+import "../chunk-KWTCHVLT.js";
+import "../chunk-BCSNKUAC.js";
+import "../chunk-Q2FD5IBM.js";
+import "../chunk-X3YBZCJW.js";
+import "../chunk-R6JMJSVT.js";
+import "../chunk-C24KEZXR.js";
+import "../chunk-22WRQZT7.js";
+import "../chunk-HP7E42X6.js";
+import "../chunk-7JXHF5IF.js";
+import "../chunk-OWD2YICM.js";
+import "../chunk-VFUZI3NY.js";
+import "../chunk-W7Q5EOTS.js";
+import "../chunk-BPEFS4YF.js";
+import "../chunk-EP6AEUZO.js";
+import "../chunk-36DNRFZQ.js";
+import "../chunk-2OTCEKL2.js";
+import "../chunk-MLKGABMK.js";
+export {
+  mcpToolsEffect
+};

package/js/mcp/stdio.js

@@ -0,0 +1,123 @@
+import {
+  adaptMcpTools,
+  mcpClient,
+  mcpJsonSchemaValidator
+} from "../chunk-KWTCHVLT.js";
+import {
+  protocolOperations
+} from "../chunk-LOKGDT6B.js";
+import "../chunk-BCSNKUAC.js";
+import "../chunk-Q2FD5IBM.js";
+import "../chunk-X3YBZCJW.js";
+import "../chunk-R6JMJSVT.js";
+import "../chunk-C24KEZXR.js";
+import {
+  McpError,
+  ProcessConfig
+} from "../chunk-22WRQZT7.js";
+import "../chunk-HP7E42X6.js";
+import "../chunk-7JXHF5IF.js";
+import "../chunk-OWD2YICM.js";
+import "../chunk-VFUZI3NY.js";
+import "../chunk-W7Q5EOTS.js";
+import "../chunk-BPEFS4YF.js";
+import "../chunk-EP6AEUZO.js";
+import "../chunk-36DNRFZQ.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "../chunk-2OTCEKL2.js";
+import "../chunk-MLKGABMK.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) => new McpError({
+  phase,
+  reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request"
+});
+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 }) => Effect_exports.tryPromise(async () => {
+          try {
+            await client2.close();
+          } finally {
+            await transport2.close();
+          }
+        }).pipe(Effect_exports.withSpan("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), Effect_exports.withSpan("provider.mcp.connect"));
+      return yield* use(client);
+    })
+  ).pipe(
+    Effect_exports.withSpan("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 stdioOperations = (config, signal, kinds = {}) => Effect_exports.runPromise(
+  stdioToolsEffect(config).pipe(Effect_exports.map((tools) => protocolOperations(tools, kinds))),
+  signal === void 0 ? {} : { signal }
+);
+export {
+  McpError,
+  stdioOperations
+};

package/js/mcp.js

@@ -0,0 +1,37 @@
+import {
+  mcpToolsEffect
+} from "./chunk-WIDTG42X.js";
+import "./chunk-KWTCHVLT.js";
+import {
+  protocolOperations
+} from "./chunk-LOKGDT6B.js";
+import "./chunk-BCSNKUAC.js";
+import "./chunk-Q2FD5IBM.js";
+import "./chunk-X3YBZCJW.js";
+import "./chunk-R6JMJSVT.js";
+import "./chunk-C24KEZXR.js";
+import {
+  McpError
+} from "./chunk-22WRQZT7.js";
+import "./chunk-HP7E42X6.js";
+import "./chunk-7JXHF5IF.js";
+import "./chunk-OWD2YICM.js";
+import "./chunk-VFUZI3NY.js";
+import "./chunk-W7Q5EOTS.js";
+import "./chunk-BPEFS4YF.js";
+import "./chunk-EP6AEUZO.js";
+import "./chunk-36DNRFZQ.js";
+import {
+  Effect_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/mcp.ts
+var mcpOperations = (options, kinds = {}) => Effect_exports.runPromise(
+  mcpToolsEffect(options).pipe(Effect_exports.map((operations) => protocolOperations(operations, kinds))),
+  options.signal === void 0 ? {} : { signal: options.signal }
+);
+export {
+  McpError,
+  mcpOperations
+};