@dxos/compute 0.8.4-main.cb12b3f963 → 0.8.4-main.dfabb4ec29

package/dist/lib/neutral/index.mjs

@@ -1,9 +1,11 @@
 import {
   StorageService_exports
-} from "./chunk-DDEBBRCI.mjs";
+} from "./chunk-XEVFBI6S.mjs";
 import {
   FunctionError,
   FunctionNotFoundError,
+  FunctionsAiMemoizationMissError,
+  FunctionsAiUpstreamError,
   InvalidOperationInputError,
   InvalidOperationOutputError,
   InvokerNotInitializedError,
@@ -14,13 +16,13 @@ import {
   TriggerStateNotFoundError,
   getHandler,
   getHandlerByKey
-} from "./chunk-N462A6NO.mjs";
+} from "./chunk-JTZYM2QW.mjs";
 import {
   Operation_exports,
   PersistentOperation,
   deserialize,
   invoke
-} from "./chunk-QPCDM7MF.mjs";
+} from "./chunk-VIRNEVFD.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -29,7 +31,6 @@ import {
 var Blueprint_exports = {};
 __export(Blueprint_exports, {
   Blueprint: () => Blueprint,
-  McpServer: () => McpServer,
   NotFoundError: () => NotFoundError,
   Registry: () => Registry,
   RegistryService: () => RegistryService,
@@ -40,12 +41,43 @@ __export(Blueprint_exports, {
 });
 import * as Context2 from "effect/Context";
 import * as Effect3 from "effect/Effect";
-import * as Schema2 from "effect/Schema";
+import * as Schema3 from "effect/Schema";
 import { ToolId } from "@dxos/ai";
 import { Annotation, Database as Database3, Filter, Obj, Type } from "@dxos/echo";
 import { BaseError } from "@dxos/errors";
 import { log as log2 } from "@dxos/log";
 
+// src/McpServer.ts
+var McpServer_exports = {};
+__export(McpServer_exports, {
+  McpServer: () => McpServer
+});
+import * as Schema from "effect/Schema";
+var McpServer = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional).annotations({
+    description: "Human-readable name of the MCP server"
+  }),
+  url: Schema.String.annotations({
+    description: "URL of the MCP server"
+  }),
+  /**
+  * Transport protocol. Prefer `'http'` (Streamable HTTP) for new servers; `'sse'` is
+  * kept for compatibility with servers that haven't migrated and is deprecated per
+  * the MCP SDK. Clients support both during the migration period.
+  */
+  protocol: Schema.Union(Schema.Literal("http"), Schema.Literal("sse")).annotations({
+    description: 'Transport protocol of the MCP server (prefer "http"; "sse" deprecated)'
+  }),
+  /**
+  * Optional API key sent with requests.
+  * Persisted in plaintext when stored on a space-replicated ECHO object — see the
+  * `@dxos/assistant-toolkit` `McpServer` type for security implications.
+  */
+  apiKey: Schema.optional(Schema.String).annotations({
+    description: "Optional API key sent with requests"
+  })
+});
+
 // src/Template.ts
 var Template_exports = {};
 __export(Template_exports, {
@@ -57,13 +89,12 @@ __export(Template_exports, {
   processTemplate: () => processTemplate
 });
 import * as Effect2 from "effect/Effect";
-import * as Record from "effect/Record";
-import * as Schema from "effect/Schema";
-import handlebars from "handlebars";
+import * as Schema2 from "effect/Schema";
 import { Database as Database2, Ref } from "@dxos/echo";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
 import { Text } from "@dxos/schema";
+import Handlebars from "@dxos/vendor-kbn-handlebars";
 
 // src/OperationRegistry.ts
 var OperationRegistry_exports = {};
@@ -91,21 +122,25 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
 
 // src/Template.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/compute/src/Template.ts";
-var InputKind = Schema.Literal("value", "pass-through", "retriever", "function", "query", "resolver", "context", "schema");
-var Input = Schema.Struct({
-  name: Schema.String,
-  kind: Schema.optional(InputKind),
-  default: Schema.optional(Schema.Any),
+var InputKind = Schema2.Literal("value", "operation");
+var Input = Schema2.Struct({
+  name: Schema2.String,
+  kind: InputKind,
+  default: Schema2.optional(Schema2.Any),
   /**
-  * Function to call if the kind is 'function'.
+  * Operation key invoked when `kind === 'operation'`. The referenced operation must accept void input —
+  * template inputs have no mechanism for passing arguments.
   */
-  function: Schema.optional(Schema.String)
+  operation: Schema2.optional(Schema2.String)
 });
-var Template = Schema.Struct({
+var Template = Schema2.Struct({
   source: Ref.Ref(Text.Text).annotations({
-    description: "Handlebars template source"
+    description: "Markdown + Handlebars template."
   }),
-  inputs: Schema.optional(Schema.Array(Input))
+  /**
+  * NOTE: We use an array rather than map so that updating variable names in the template doesn't disconnect existing inputs.
+  */
+  inputs: Schema2.optional(Schema2.Array(Input))
 });
 var make = ({ id, source, inputs = [] } = {}) => ({
   source: Ref.make(Text.make({
@@ -115,64 +150,65 @@ var make = ({ id, source, inputs = [] } = {}) => ({
   inputs
 });
 var process = (source, variables = {}) => {
-  invariant(typeof source === "string", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 47, S: void 0, A: ["typeof source === 'string'", ""] });
+  invariant(typeof source === "string", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 50, S: void 0, A: ["typeof source === 'string'", ""] });
   let section = 0;
+  const handlebars = Handlebars.create();
   handlebars.registerHelper("section", () => String(++section));
-  const template = handlebars.compile(source.trim());
+  const template = handlebars.compileAST(source.trim());
   const output = template(variables);
   return output.trim().replace(/(\n\s*){3,}/g, "\n\n");
 };
 var processTemplate = (template) => Effect2.gen(function* () {
-  const variables = yield* Effect2.forEach(template.inputs ?? [], (input) => Effect2.gen(function* () {
-    if (input.kind === "function") {
-      const fn = yield* resolve(input.function).pipe(Effect2.flatten, Effect2.catchTag("NoSuchElementException", () => Effect2.fail(new FunctionNotFoundError(input.function))));
-      const result = yield* invoke(fn, {}).pipe(Effect2.orDie);
-      return [
-        input.name,
-        result
-      ];
-    } else {
-      return yield* Effect2.dieMessage(`Unsupported input kind: ${input.kind}`);
+  const entries = yield* Effect2.forEach(template.inputs ?? [], (input) => Effect2.gen(function* () {
+    switch (input.kind) {
+      case "value": {
+        return [
+          input.name,
+          input.default
+        ];
+      }
+      case "operation": {
+        invariant(input.operation, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 70, S: this, A: ["input.operation", ""] });
+        const fn = yield* resolve(input.operation).pipe(Effect2.flatten, Effect2.catchTag("NoSuchElementException", () => Effect2.fail(new FunctionNotFoundError(input.operation))));
+        const result = yield* invoke(fn, void 0).pipe(Effect2.orDie);
+        return [
+          input.name,
+          result
+        ];
+      }
+      default: {
+        return yield* Effect2.dieMessage(`Unsupported input kind: ${input.kind}`);
+      }
     }
-  })).pipe(Effect2.map(Record.fromEntries));
+  }));
+  const variables = Object.fromEntries(entries);
   log("processTemplate", {
     variables
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67, S: this });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 86, S: this });
   return process((yield* Database2.load(template.source)).content, variables);
 });
 
 // src/Blueprint.ts
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/compute/src/Blueprint.ts";
-var McpServer = Schema2.Struct({
-  /**
-  * URL of the MCP server.
-  */
-  url: Schema2.String.annotations({
-    description: "URL of the MCP server"
-  }),
-  protocol: Schema2.Union(Schema2.Literal("sse"), Schema2.Literal("http")).annotations({
-    description: "Protocol of the MCP server"
-  })
-});
-var Blueprint = Schema2.Struct({
+var Blueprint = Schema3.Struct({
   /**
   * Global registry ID.
   * NOTE: The `key` property refers to the original registry entry.
   */
   // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
-  key: Schema2.String.annotations({
+  key: Schema3.String.annotations({
     description: "Unique registration key for the blueprint"
   }),
   /**
   * Human-readable name of the blueprint.
   */
-  name: Schema2.String.annotations({
+  name: Schema3.String.annotations({
     description: "Human-readable name of the blueprint"
   }),
   /**
   * Description of the blueprint's purpose and functionality.
   */
-  description: Schema2.optional(Schema2.String).annotations({
+  description: Schema3.optional(Schema3.String).annotations({
     description: "Description of the blueprint's purpose and functionality"
   }),
   /**
@@ -185,21 +221,20 @@ var Blueprint = Schema2.Struct({
   /**
   * Array of tools that the AI assistant can use when this blueprint is active.
   */
-  tools: Schema2.Array(ToolId).annotations({
+  tools: Schema3.Array(ToolId).annotations({
     description: "Array of tools that the AI assistant can use when this blueprint is active"
   }),
   /**
   * Whether an agent is allowed to auto-enable this blueprint in a conversation.
   */
-  agentCanEnable: Schema2.optional(Schema2.Boolean).annotations({
+  agentCanEnable: Schema3.optional(Schema3.Boolean).annotations({
     description: "Whether an agent is allowed to auto-enable this blueprint in a conversation."
   }),
   /**
   * Array of MCP servers that the AI assistant can use when this blueprint is active.
   */
-  mcpServers: Schema2.optional(Schema2.Array(McpServer))
+  mcpServers: Schema3.optional(Schema3.Array(McpServer))
 }).pipe(Type.object({
-  // TODO(burdon): Is this a DXN? Need to create a Format type for these IDs.
   typename: "org.dxos.type.blueprint",
   version: "0.1.0"
 }), Annotation.LabelAnnotation.set([
@@ -225,7 +260,7 @@ var Registry = class {
       if (seen.has(blueprint.key)) {
         log2.warn("duplicate blueprint", {
           key: blueprint.key
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 99, S: this });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 89, S: this });
       } else {
         seen.add(blueprint.key);
         this._blueprints.push(blueprint);
@@ -326,7 +361,7 @@ __export(Process_exports, {
 });
 import * as Context5 from "effect/Context";
 import * as Effect6 from "effect/Effect";
-import * as Schema4 from "effect/Schema";
+import * as Schema5 from "effect/Schema";
 import { assertArgument } from "@dxos/invariant";
 import { log as log4 } from "@dxos/log";
 
@@ -355,7 +390,7 @@ __export(Trace_exports, {
 import * as Context4 from "effect/Context";
 import * as Effect5 from "effect/Effect";
 import * as Layer2 from "effect/Layer";
-import * as Schema3 from "effect/Schema";
+import * as Schema4 from "effect/Schema";
 import { Annotation as Annotation2, Obj as Obj2, Type as Type2 } from "@dxos/echo";
 import { log as log3 } from "@dxos/log";
 var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/compute/src/Trace.ts";
@@ -378,35 +413,35 @@ var EventType = (key, opts) => {
     isEphemeral: opts.isEphemeral
   };
 };
-var Event = Schema3.Struct({
-  timestamp: Schema3.Number,
-  type: Schema3.String,
-  data: Schema3.Unknown
+var Event = Schema4.Struct({
+  timestamp: Schema4.Number,
+  type: Schema4.String,
+  data: Schema4.Unknown
 });
 var isOfType = (eventType, event) => {
   return event.type === eventType.key;
 };
-var Meta = Schema3.Struct({
-  pid: Schema3.optional(Schema3.String),
-  parentPid: Schema3.optional(Schema3.String),
-  processName: Schema3.optional(Schema3.String),
+var Meta = Schema4.Struct({
+  pid: Schema4.optional(Schema4.String),
+  parentPid: Schema4.optional(Schema4.String),
+  processName: Schema4.optional(Schema4.String),
   /**
   * ID of the conversation feed object if present.
   */
-  conversationId: Schema3.optional(Obj2.ID),
+  conversationId: Schema4.optional(Obj2.ID),
   /**
   * ID of the trigger object if invocation resulted from a trigger.
   */
-  triggerId: Schema3.optional(Obj2.ID),
+  triggerId: Schema4.optional(Obj2.ID),
   /**
   * ID of the tool call that created the current process.
   */
-  toolCallId: Schema3.optional(Schema3.String)
+  toolCallId: Schema4.optional(Schema4.String)
 });
-var MessageData = Schema3.Struct({
+var MessageData = Schema4.Struct({
   meta: Meta,
-  isEphemeral: Schema3.Boolean,
-  events: Schema3.Array(Event)
+  isEphemeral: Schema4.Boolean,
+  events: Schema4.Array(Event)
 });
 var Message = MessageData.pipe(Type2.object({
   typename: "org.dxos.type.traceMessage",
@@ -450,31 +485,31 @@ var testTraceService = (opts = {}) => Layer2.effect(TraceService, Effect5.gen(fu
   };
 }));
 var OperationStart = EventType("operation.start", {
-  schema: Schema3.Struct({
+  schema: Schema4.Struct({
     /** Operation key. */
-    key: Schema3.String,
+    key: Schema4.String,
     /** Human-readable operation name. */
-    name: Schema3.optional(Schema3.String)
+    name: Schema4.optional(Schema4.String)
   }),
   isEphemeral: false
 });
 var OperationEnd = EventType("operation.end", {
-  schema: Schema3.Struct({
+  schema: Schema4.Struct({
     /** Operation key. */
-    key: Schema3.String,
+    key: Schema4.String,
     /** Human-readable operation name. */
-    name: Schema3.optional(Schema3.String),
+    name: Schema4.optional(Schema4.String),
     /** Outcome of the operation. */
-    outcome: Schema3.Literal("success", "failure"),
+    outcome: Schema4.Literal("success", "failure"),
     /** Error message if the operation failed. */
-    error: Schema3.optional(Schema3.String)
+    error: Schema4.optional(Schema4.String)
   }),
   isEphemeral: false
 });
 var StatusUpdate = EventType("status.update", {
-  schema: Schema3.Struct({
+  schema: Schema4.Struct({
     /** Human-readable status message. */
-    message: Schema3.String
+    message: Schema4.String
   }),
   isEphemeral: true
 });
@@ -484,7 +519,7 @@ var emitStatus = (message) => write(StatusUpdate, {
 
 // src/Process.ts
 var __dxlog_file4 = "/__w/dxos/dxos/packages/core/compute/compute/src/Process.ts";
-var ID = Schema4.String.pipe(Schema4.brand("ProcessId"));
+var ID = Schema5.String.pipe(Schema5.brand("ProcessId"));
 var ProcessTypeId = "~@dxos/functions/Process";
 var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
 var make4 = (opts, create) => {
@@ -552,12 +587,12 @@ var State = /* @__PURE__ */ (function(State2) {
 var ProcessMonitorService = class extends Context5.Tag("@dxos/functions/ProcessMonitorService")() {
 };
 var SpawnedEvent = EventType("process.spawned", {
-  schema: Schema4.Void,
+  schema: Schema5.Void,
   isEphemeral: false
 });
 var ExitedEvent = EventType("process.exited", {
-  schema: Schema4.Struct({
-    outcome: Schema4.Literal("succeeded", "failed", "terminated")
+  schema: Schema5.Struct({
+    outcome: Schema5.Literal("succeeded", "failed", "terminated")
   }),
   isEphemeral: false
 });
@@ -626,18 +661,18 @@ __export(Routine_exports, {
   Routine: () => Routine,
   make: () => make5
 });
-import * as Schema5 from "effect/Schema";
+import * as Schema6 from "effect/Schema";
 import { Annotation as Annotation3, JsonSchema, Obj as Obj3, Ref as Ref2, Type as Type3 } from "@dxos/echo";
-var Routine = Schema5.Struct({
+var Routine = Schema6.Struct({
   /**
   * Name of the routine.
   */
-  name: Schema5.optional(Schema5.String),
+  name: Schema6.optional(Schema6.String),
   /**
   * Description of the routine's purpose and functionality.
   * Allows AI agents to execute routines automatically as tools.
   */
-  description: Schema5.optional(Schema5.String),
+  description: Schema6.optional(Schema6.String),
   /**
   * Input schema of the routine.
   */
@@ -650,15 +685,16 @@ var Routine = Schema5.Struct({
   * Natural language instructions for the routine.
   * These should provide concrete course of action for the AI to follow.
   */
+  // TODO(burdon): Form editor.
   instructions: Template.pipe(Annotation3.FormInputAnnotation.set(false)),
   /**
   * Blueprints that the routine may utilize.
   */
-  blueprints: Schema5.Array(Ref2.Ref(Blueprint)),
+  blueprints: Schema6.Array(Ref2.Ref(Blueprint)),
   /**
   * Additional context that the routine may utilize.
   */
-  context: Schema5.Array(Schema5.Any).pipe(Annotation3.FormInputAnnotation.set(false))
+  context: Schema6.Array(Schema6.Any).pipe(Annotation3.FormInputAnnotation.set(false))
 }).pipe(Type3.object({
   typename: "org.dxos.type.routine",
   version: "0.1.0"
@@ -671,8 +707,8 @@ var Routine = Schema5.Struct({
 var make5 = (params) => Obj3.make(Routine, {
   name: params.name,
   description: params.description,
-  input: JsonSchema.toJsonSchema(params.input ?? Schema5.Void),
-  output: JsonSchema.toJsonSchema(params.output ?? Schema5.Void),
+  input: JsonSchema.toJsonSchema(params.input ?? Schema6.Void),
+  output: JsonSchema.toJsonSchema(params.output ?? Schema6.Void),
   instructions: make({
     source: params.instructions
   }),
@@ -686,16 +722,16 @@ __export(Script_exports, {
   Script: () => Script,
   make: () => make6
 });
-import * as Schema6 from "effect/Schema";
+import * as Schema7 from "effect/Schema";
 import { Annotation as Annotation4, Obj as Obj4, Ref as Ref3, Type as Type4 } from "@dxos/echo";
 import { FormInputAnnotation } from "@dxos/echo/internal";
 import { Text as Text2 } from "@dxos/schema";
-var Script = Schema6.Struct({
-  name: Schema6.String.pipe(Schema6.optional),
-  description: Schema6.String.pipe(Schema6.optional),
+var Script = Schema7.Struct({
+  name: Schema7.String.pipe(Schema7.optional),
+  description: Schema7.String.pipe(Schema7.optional),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema6.Boolean.pipe(FormInputAnnotation.set(false), Schema6.optional),
+  changed: Schema7.Boolean.pipe(FormInputAnnotation.set(false), Schema7.optional),
   source: Ref3.Ref(Text2.Text).pipe(FormInputAnnotation.set(false))
 }).pipe(Type4.object({
   typename: "org.dxos.type.script",
@@ -806,7 +842,7 @@ __export(Trigger_exports, {
   specTimer: () => specTimer,
   specWebhook: () => specWebhook
 });
-import * as Schema7 from "effect/Schema";
+import * as Schema8 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import { Annotation as Annotation5, Feed, Obj as Obj5, QueryAST, Ref as Ref4, Type as Type5 } from "@dxos/echo";
 import { OptionsAnnotationId, SystemTypeAnnotation } from "@dxos/echo/internal";
@@ -822,14 +858,14 @@ var Kinds = [
 var kindLiteralAnnotations = {
   title: "Kind"
 };
-var EmailSpec = Schema7.Struct({
-  kind: Schema7.Literal("email").annotations(kindLiteralAnnotations)
+var EmailSpec = Schema8.Struct({
+  kind: Schema8.Literal("email").annotations(kindLiteralAnnotations)
 });
 var specEmail = () => ({
   kind: "email"
 });
-var QueueSpec = Schema7.Struct({
-  kind: Schema7.Literal("queue").annotations(kindLiteralAnnotations),
+var QueueSpec = Schema8.Struct({
+  kind: Schema8.Literal("queue").annotations(kindLiteralAnnotations),
   // TODO(dmaretskyi): Rename to `feed` and change to a reference.
   queue: DXN.Schema
 });
@@ -838,21 +874,21 @@ var specQueue = (queueDxn) => ({
   queue: queueDxn
 });
 var specFeed = (feed) => specQueue(Feed.getQueueDxn(feed)?.toString() ?? failedInvariant(new Error("Could not extract DXN from feed")));
-var SubscriptionSpec = Schema7.Struct({
-  kind: Schema7.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: Schema7.Struct({
-    raw: Schema7.optional(Schema7.String.annotations({
+var SubscriptionSpec = Schema8.Struct({
+  kind: Schema8.Literal("subscription").annotations(kindLiteralAnnotations),
+  query: Schema8.Struct({
+    raw: Schema8.optional(Schema8.String.annotations({
       title: "Query"
     })),
     ast: QueryAST.Query
   }),
-  options: Schema7.optional(Schema7.Struct({
+  options: Schema8.optional(Schema8.Struct({
     // Watch changes to object (not just creation).
-    deep: Schema7.optional(Schema7.Boolean.annotations({
+    deep: Schema8.optional(Schema8.Boolean.annotations({
       title: "Nested"
     })),
     // Debounce changes (delay in ms).
-    delay: Schema7.optional(Schema7.Number.annotations({
+    delay: Schema8.optional(Schema8.Number.annotations({
       title: "Delay"
     }))
   }).annotations({
@@ -869,9 +905,9 @@ var specSubscription = (query, options) => ({
     delay: options.delay
   } : void 0
 });
-var TimerSpec = Schema7.Struct({
-  kind: Schema7.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema7.String.annotations({
+var TimerSpec = Schema8.Struct({
+  kind: Schema8.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema8.String.annotations({
     title: "Cron",
     [SchemaAST.ExamplesAnnotationId]: [
       "0 0 * * *"
@@ -882,16 +918,16 @@ var specTimer = (cron) => ({
   kind: "timer",
   cron
 });
-var WebhookSpec = Schema7.Struct({
-  kind: Schema7.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema7.optional(Schema7.String.annotations({
+var WebhookSpec = Schema8.Struct({
+  kind: Schema8.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: Schema8.optional(Schema8.String.annotations({
     title: "Method",
     [OptionsAnnotationId]: [
       "GET",
       "POST"
     ]
   })),
-  port: Schema7.optional(Schema7.Number.annotations({
+  port: Schema8.optional(Schema8.Number.annotations({
     title: "Port"
   }))
 });
@@ -900,15 +936,15 @@ var specWebhook = (opts) => ({
   method: opts?.method,
   port: opts?.port
 });
-var Spec = Schema7.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+var Spec = Schema8.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
   title: "Trigger"
 });
-var TriggerSchema = Schema7.Struct({
+var TriggerSchema = Schema8.Struct({
   /**
   * Function or workflow to invoke.
   */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema7.optional(Ref4.Ref(Obj5.Unknown).annotations({
+  function: Schema8.optional(Ref4.Ref(Obj5.Unknown).annotations({
     title: "Function"
   })),
   /**
@@ -916,16 +952,16 @@ var TriggerSchema = Schema7.Struct({
   * Specifies the input node in the circuit.
   * @deprecated Remove and enforce a single input node in all compute graphSchema.
   */
-  inputNodeId: Schema7.optional(Schema7.String.annotations({
+  inputNodeId: Schema8.optional(Schema8.String.annotations({
     title: "Input Node ID"
   })),
   // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
   //  Need lint rule; or agent rule to require PR review for "boolean" key word.
-  enabled: Schema7.optional(Schema7.Boolean.annotations({
+  enabled: Schema8.optional(Schema8.Boolean.annotations({
     title: "Enabled"
   })),
-  spec: Schema7.optional(Spec),
-  concurrency: Schema7.optional(Schema7.Number.annotations({
+  spec: Schema8.optional(Spec),
+  concurrency: Schema8.optional(Schema8.Number.annotations({
     title: "Concurrency",
     default: 1,
     description: "Maximum number of concurrent invocations of the trigger. For Feed triggers, this will process Feed items in parallel."
@@ -941,9 +977,9 @@ var TriggerSchema = Schema7.Struct({
   *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
   * }
   */
-  input: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.Any
+  input: Schema8.optional(Schema8.Record({
+    key: Schema8.String,
+    value: Schema8.Any
   }))
 }).pipe(Type5.object({
   typename: "org.dxos.type.trigger",
@@ -965,26 +1001,26 @@ __export(TriggerEvent_exports, {
   TriggerEvent: () => TriggerEvent,
   WebhookEvent: () => WebhookEvent
 });
-import * as Schema8 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
 import { DXN as DXN2, Obj as Obj6, Ref as Ref5 } from "@dxos/echo";
-var EmailEvent = Schema8.Struct({
-  from: Schema8.String,
-  to: Schema8.String,
-  subject: Schema8.String,
-  created: Schema8.String,
-  body: Schema8.String
+var EmailEvent = Schema9.Struct({
+  from: Schema9.String,
+  to: Schema9.String,
+  subject: Schema9.String,
+  created: Schema9.String,
+  body: Schema9.String
 });
-var QueueEvent = Schema8.Struct({
+var QueueEvent = Schema9.Struct({
   queue: DXN2.Schema,
-  item: Schema8.Any,
-  cursor: Schema8.String
+  item: Schema9.Any,
+  cursor: Schema9.String
 });
-var SubscriptionEvent = Schema8.Struct({
+var SubscriptionEvent = Schema9.Struct({
   /**
   * Type of the mutation.
   */
   // TODO(dmaretskyi): Specify enum.
-  type: Schema8.String,
+  type: Schema9.String,
   /**
   * Reference to the object that was changed or created.
   */
@@ -992,29 +1028,32 @@ var SubscriptionEvent = Schema8.Struct({
   /**
   * @deprecated
   */
-  changedObjectId: Schema8.optional(Schema8.String)
+  changedObjectId: Schema9.optional(Schema9.String)
 });
-var TimerEvent = Schema8.Struct({
-  tick: Schema8.Number
+var TimerEvent = Schema9.Struct({
+  tick: Schema9.Number
 });
-var WebhookEvent = Schema8.Struct({
-  url: Schema8.String,
-  method: Schema8.Literal("GET", "POST"),
-  headers: Schema8.Record({
-    key: Schema8.String,
-    value: Schema8.String
+var WebhookEvent = Schema9.Struct({
+  url: Schema9.String,
+  method: Schema9.Literal("GET", "POST"),
+  headers: Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.String
   }),
-  bodyText: Schema8.String
+  bodyText: Schema9.String
 });
-var TriggerEvent = Schema8.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+var TriggerEvent = Schema9.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
 export {
   Blueprint_exports as Blueprint,
   Credential_exports as Credential,
   FunctionError,
   FunctionNotFoundError,
+  FunctionsAiMemoizationMissError,
+  FunctionsAiUpstreamError,
   InvalidOperationInputError,
   InvalidOperationOutputError,
   InvokerNotInitializedError,
+  McpServer_exports as McpServer,
   NoHandlerError,
   Operation_exports as Operation,
   OperationHandlerSet_exports as OperationHandlerSet,