@dxos/compute 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/dist/lib/neutral/index.mjs

@@ -1,8 +1,11 @@
+import {
+  AgentService_exports
+} from "./chunk-VSAZPWSJ.mjs";
 import {
   StorageService_exports,
-  key,
+  cell,
   withDefault
-} from "./chunk-XEVFBI6S.mjs";
+} from "./chunk-PF7XP7XP.mjs";
 import {
   FunctionError,
   FunctionNotFoundError,
@@ -20,35 +23,36 @@ import {
   getHandlerByKey
 } from "./chunk-Z3Y7FQGN.mjs";
 import {
+  NotifyOptions,
   Operation_exports,
   PersistentOperation,
   deserialize,
   invoke,
   isIdempotent
-} from "./chunk-QZS4G6PE.mjs";
+} from "./chunk-EVROJER7.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
 
-// src/Blueprint.ts
-var Blueprint_exports = {};
-__export(Blueprint_exports, {
-  Blueprint: () => Blueprint,
-  Blueprint_v0_1_0: () => Blueprint_v0_1_0,
+// src/Skill.ts
+var Skill_exports = {};
+__export(Skill_exports, {
+  Hook: () => Hook,
+  HookSpec: () => HookSpec,
   NotFoundError: () => NotFoundError,
+  Skill: () => Skill,
   getKey: () => getKey,
   getVersion: () => getVersion,
-  make: () => make2,
-  migrations: () => migrations,
+  make: () => make3,
   registryURI: () => registryURI,
   resolve: () => resolve,
   toolDefinitions: () => toolDefinitions,
   upsert: () => upsert
 });
 import * as Effect2 from "effect/Effect";
-import * as Schema3 from "effect/Schema";
+import * as Schema4 from "effect/Schema";
 import { ToolId } from "@dxos/ai";
-import { DXN as DXN2, Annotation, Database as Database2, Filter as Filter2, Migration, Obj, Registry as Registry2, Type, URI } from "@dxos/echo";
+import { Annotation as Annotation2, Database as Database2, DXN as DXN3, Filter as Filter2, Obj as Obj2, Ref as Ref3, Registry as Registry2, Type as Type2, URI } from "@dxos/echo";
 import { BaseError } from "@dxos/errors";
 
 // src/McpServer.ts
@@ -147,8 +151,8 @@ var processTemplate = (template) => Effect.gen(function* () {
       }
       case "operation": {
         invariant(input.operation, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 69, S: this, A: ["input.operation", ""] });
-        const key2 = DXN.isDXN(input.operation) ? input.operation : `dxn:${input.operation}`;
-        const results = yield* Registry.runQuery(Filter.and(Filter.type(PersistentOperation), Filter.key(key2)));
+        const key = DXN.isDXN(input.operation) ? input.operation : `dxn:${input.operation}`;
+        const results = yield* Registry.runQuery(Filter.and(Filter.type(PersistentOperation), Filter.key(key)));
         if (results.length === 0) {
           return yield* Effect.fail(new FunctionNotFoundError(input.operation));
         }
@@ -171,130 +175,292 @@ var processTemplate = (template) => Effect.gen(function* () {
   return process((yield* Database.load(template.source)).content, variables);
 });
 
-// src/Blueprint.ts
-var Blueprint = Schema3.Struct({
+// src/Trigger.ts
+var Trigger_exports = {};
+__export(Trigger_exports, {
+  EmailSpec: () => EmailSpec,
+  FeedSpec: () => FeedSpec,
+  InputTemplate: () => InputTemplate,
+  Kinds: () => Kinds,
+  Spec: () => Spec,
+  SubscriptionSpec: () => SubscriptionSpec,
+  TimerSpec: () => TimerSpec,
+  Trigger: () => Trigger,
+  WebhookSpec: () => WebhookSpec,
+  make: () => make2,
+  specEmail: () => specEmail,
+  specFeed: () => specFeed,
+  specSubscription: () => specSubscription,
+  specTimer: () => specTimer,
+  specWebhook: () => specWebhook
+});
+import * as Schema3 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Annotation, DXN as DXN2, Feed, Obj, QueryAST, Ref as Ref2, Type } from "@dxos/echo";
+import { HiddenAnnotation } from "@dxos/echo/Annotation";
+import { OptionsAnnotationId } from "@dxos/echo/Format";
+
+// src/Runnable.ts
+var Runnable_exports = {};
+__export(Runnable_exports, {
+  Runnable: () => Runnable
+});
+var Runnable = PersistentOperation;
+
+// src/Trigger.ts
+var Kinds = [
+  "email",
+  "feed",
+  "subscription",
+  "timer",
+  "webhook"
+];
+var kindLiteralAnnotations = {
+  title: "Kind"
+};
+var EmailSpec = Schema3.Struct({
+  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
+});
+var specEmail = () => ({
+  kind: "email"
+});
+var FeedSpec = Schema3.Struct({
+  kind: Schema3.Literal("feed").annotations(kindLiteralAnnotations),
+  feed: Schema3.optional(Ref2.Ref(Feed.Feed).annotations({
+    title: "Feed"
+  }))
+});
+var specFeed = (feed) => ({
+  kind: "feed",
+  feed: Ref2.make(feed)
+});
+var SubscriptionSpec = Schema3.Struct({
+  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
+  // TODO(burdon): Issue.
+  query: Schema3.Struct({
+    raw: Schema3.optional(Schema3.String.annotations({
+      title: "Query"
+    })),
+    ast: QueryAST.Query
+  }),
+  options: Schema3.optional(Schema3.Struct({
+    // Watch changes to object (not just creation).
+    deep: Schema3.optional(Schema3.Boolean.annotations({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: Schema3.optional(Schema3.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+});
+var specSubscription = (query, options) => ({
+  kind: "subscription",
+  query: {
+    ast: query.ast
+  },
+  options: options ? {
+    deep: options.deep,
+    delay: options.delay
+  } : void 0
+});
+var TimerSpec = Schema3.Struct({
+  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema3.String.annotations({
+    title: "Cron",
+    [SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+});
+var specTimer = (cron) => ({
+  kind: "timer",
+  cron
+});
+var WebhookSpec = Schema3.Struct({
+  kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: Schema3.optional(Schema3.String.annotations({
+    title: "Method",
+    [OptionsAnnotationId]: [
+      "GET",
+      "POST"
+    ]
+  })),
+  port: Schema3.optional(Schema3.Number.annotations({
+    title: "Port"
+  }))
+});
+var specWebhook = (opts) => ({
+  kind: "webhook",
+  method: opts?.method,
+  port: opts?.port
+});
+var Spec = Schema3.Union(EmailSpec, FeedSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+  title: "Trigger"
+});
+var InputTemplate = Schema3.Record({
+  key: Schema3.String,
+  value: Schema3.Any
+});
+var Trigger = class extends Type.makeObject(DXN2.make("org.dxos.type.trigger", "0.1.0"))(Schema3.Struct({
+  /**
+   * Runnable (operation or workflow) to invoke.
+   */
+  runnable: Schema3.optional(Ref2.Ref(Runnable).annotations({
+    title: "Runnable"
+  })),
+  spec: Schema3.optional(Spec),
+  enabled: Schema3.optional(Schema3.Boolean),
+  concurrency: Schema3.Number.pipe(Schema3.annotations({
+    title: "Concurrency",
+    default: 1,
+    description: "Maximum number of concurrent invocations of the trigger."
+  }), Annotation.FormInputAnnotation.set(false), Schema3.optional),
+  /**
+   * Only used for workflowSchema.
+   * Specifies the input node in the circuit.
+   * @deprecated Remove and enforce a single input node in all compute graphSchema.
+   */
+  inputNodeId: Schema3.String.pipe(Schema3.annotations({
+    title: "Input Node ID"
+  }), Annotation.FormInputAnnotation.set(false), Schema3.optional),
+  /**
+   * Passed as the input data to the runnable.
+   */
+  input: InputTemplate.pipe(Annotation.FormInputAnnotation.set(false), Schema3.optional)
+}).pipe(Annotation.IconAnnotation.set({
+  icon: "ph--lightning--regular",
+  hue: "yellow"
+}), HiddenAnnotation.set(true))) {
+};
+var make2 = (props) => Obj.make(Trigger, props);
+
+// src/Skill.ts
+var Skill = class extends Type2.makeObject(DXN3.make("org.dxos.type.skill", "0.2.0"))(Schema4.Struct({
   /**
-  * Human-readable name of the blueprint.
-  */
-  name: Schema3.String.annotations({
-    description: "Human-readable name of the blueprint"
+   * Human-readable name of the skill.
+   */
+  name: Schema4.String.annotations({
+    description: "Human-readable name of the skill"
   }),
   /**
-  * Description of the blueprint's purpose and functionality.
-  */
-  description: Schema3.optional(Schema3.String).annotations({
-    description: "Description of the blueprint's purpose and functionality"
+   * Description of the skill's purpose and functionality.
+   */
+  description: Schema4.optional(Schema4.String).annotations({
+    description: "Description of the skill's purpose and functionality"
   }),
   /**
-  * Instructions that guide the AI assistant's behavior and responses.
-  * These are system prompts or guidelines that the AI should follow.
-  */
+   * Instructions that guide the AI assistant's behavior and responses.
+   * These are system prompts or guidelines that the AI should follow.
+   */
   instructions: Template.annotations({
     description: "Instructions that guide the AI assistant's behavior and responses"
   }),
   /**
-  * Array of tools that the AI assistant can use when this blueprint is active.
-  */
-  tools: Schema3.Array(ToolId).annotations({
-    description: "Array of tools that the AI assistant can use when this blueprint is active"
+   * Array of tools that the AI assistant can use when this skill is active.
+   */
+  tools: Schema4.Array(ToolId).annotations({
+    description: "Array of tools that the AI assistant can use when this skill is active"
   }),
   /**
-  * Whether an agent is allowed to auto-enable this blueprint in a conversation.
-  */
-  agentCanEnable: Schema3.optional(Schema3.Boolean).annotations({
-    description: "Whether an agent is allowed to auto-enable this blueprint in a conversation."
+   * Whether an agent is allowed to auto-enable this skill in a conversation.
+   */
+  agentCanEnable: Schema4.optional(Schema4.Boolean).annotations({
+    description: "Whether an agent is allowed to auto-enable this skill in a conversation."
   }),
   /**
-  * Array of MCP servers that the AI assistant can use when this blueprint is active.
-  */
-  mcpServers: Schema3.optional(Schema3.Array(McpServer))
-}).pipe(Annotation.LabelAnnotation.set([
+   * Array of MCP servers that the AI assistant can use when this skill is active.
+   */
+  mcpServers: Schema4.optional(Schema4.Array(McpServer)),
+  /**
+   * Hooks triggered automatically at certain points in the agent's lifecycle.
+   */
+  hooks: Schema4.optional(Schema4.Array(Schema4.suspend(() => Hook)))
+}).pipe(Annotation2.LabelAnnotation.set([
   "name"
-]), Annotation.IconAnnotation.set({
+]), Annotation2.IconAnnotation.set({
   icon: "ph--blueprint--regular",
   hue: "sky"
-}), Type.makeObject(DXN2.make("org.dxos.type.blueprint", "0.2.0")));
-var make2 = ({ key: key2, version, tools = [], instructions = make(), ...props }) => Obj.make(Blueprint, {
-  [Obj.Meta]: {
-    key: key2,
+}))) {
+};
+var HookSpec = Schema4.Union(
+  /**
+  * Triggered when the agent is about to start a request.
+  * A request is a series of agent/tool turns that the model drives.
+  */
+  Schema4.TaggedStruct("begin-request", {}),
+  /**
+  * Triggered when the agent has completed a request.
+  * A request is a series of agent/tool turns that the model drives.
+  */
+  Schema4.TaggedStruct("end-request", {})
+);
+var Hook = Schema4.Struct({
+  /**
+  * What to do when the hook is triggered.
+  *
+  * Can be a Ref to a PersistentOperation.
+  */
+  function: Schema4.optional(Ref3.Ref(Obj2.Unknown).annotations({
+    title: "Function"
+  })),
+  /**
+  * Controls when the hook is triggered.
+  */
+  spec: HookSpec,
+  /**
+  * Passed as the input data to the function.
+  * Must match the function's input schema.
+  */
+  input: InputTemplate.pipe(Annotation2.FormInputAnnotation.set(false), Schema4.optional)
+});
+var make3 = ({ key, version, tools = [], instructions = make(), ...props }) => Obj2.make(Skill, {
+  [Obj2.Meta]: {
+    key,
     version
   },
   tools,
   instructions,
   ...props
 });
-var getKey = (blueprint) => {
-  const key2 = Obj.getMeta(blueprint).key;
-  if (key2 === void 0) {
-    throw new Error("Blueprint is missing the meta key.");
+var getKey = (skill) => {
+  const key = Obj2.getMeta(skill).key;
+  if (key === void 0) {
+    throw new Error("Skill is missing the meta key.");
   }
-  return key2;
+  return key;
 };
-var getVersion = (blueprint) => Obj.getMeta(blueprint).version;
+var getVersion = (skill) => Obj2.getMeta(skill).version;
 var toolDefinitions = ({ tools = [], operations = [] }) => [
-  ...operations.map((op) => ToolId.make(DXN2.getName(op.meta.key))),
+  ...operations.map((op) => ToolId.make(DXN3.getName(op.meta.key))),
   ...tools.map((tool) => ToolId.make(tool))
 ];
-var registryURI = (key2) => DXN2.tryMake(`dxn:${key2}`) ?? URI.make(key2);
-var resolve = (key2) => Effect2.gen(function* () {
-  const results = yield* Registry2.runQuery(Filter2.and(Filter2.type(Blueprint), Filter2.key(key2)));
-  const blueprint = results[0];
-  if (!blueprint) {
+var registryURI = (key) => DXN3.tryMake(`dxn:${key}`) ?? URI.make(key);
+var resolve = (key) => Effect2.gen(function* () {
+  const results = yield* Registry2.runQuery(Filter2.and(Filter2.type(Skill), Filter2.key(key)));
+  const skill = results[0];
+  if (!skill) {
     return yield* Effect2.fail(new NotFoundError({
       context: {
-        key: key2
+        key
       }
     }));
   }
-  return blueprint;
+  return skill;
 });
-var upsert = (key2) => Effect2.gen(function* () {
-  const local = yield* Database2.query(Filter2.and(Filter2.type(Blueprint), Filter2.key(key2))).run;
+var upsert = (key) => Effect2.gen(function* () {
+  const local = yield* Database2.query(Filter2.and(Filter2.type(Skill), Filter2.key(key))).run;
   if (local.length > 0) {
     return local[0];
   }
-  return yield* Database2.add(Obj.clone(yield* resolve(key2), {
-    deep: true
+  return yield* Database2.add(Obj2.clone(yield* resolve(key), {
+    deep: "all"
   }));
 });
-var NotFoundError = class extends BaseError.extend("BlueprintNotFound", "Blueprint not found") {
+var NotFoundError = class extends BaseError.extend("SkillNotFound", "Skill not found") {
 };
-var Blueprint_v0_1_0 = Schema3.Struct({
-  /**
-  * Global registry ID.
-  * NOTE: The `key` property refers to the original registry entry.
-  */
-  key: Schema3.String.annotations({
-    description: "Unique registration key for the blueprint"
-  }),
-  name: Schema3.String.annotations({
-    description: "Human-readable name of the blueprint"
-  }),
-  description: Schema3.optional(Schema3.String),
-  instructions: Template,
-  tools: Schema3.Array(ToolId),
-  agentCanEnable: Schema3.optional(Schema3.Boolean),
-  mcpServers: Schema3.optional(Schema3.Array(McpServer))
-}).pipe(Type.makeObject(DXN2.make("org.dxos.type.blueprint", "0.1.0")));
-var _migration = Migration.define({
-  from: Blueprint_v0_1_0,
-  to: Blueprint,
-  transform: async (from) => ({
-    [Obj.Meta]: {
-      key: from.key,
-      version: "0.1.0"
-    },
-    name: from.name,
-    description: from.description,
-    instructions: from.instructions,
-    tools: from.tools,
-    agentCanEnable: from.agentCanEnable,
-    mcpServers: from.mcpServers
-  })
-});
-var migrations = [
-  _migration
-];
 
 // src/Credential.ts
 var Credential_exports = {};
@@ -340,20 +506,75 @@ var byokLayer = (providerHost) => Layer.effect(HttpClient.HttpClient, Effect4.ge
   }));
 }));
 
+// src/Instructions.ts
+var Instructions_exports = {};
+__export(Instructions_exports, {
+  Instructions: () => Instructions,
+  make: () => make5
+});
+import * as Schema5 from "effect/Schema";
+import { Annotation as Annotation3, DXN as DXN4, Format, JsonSchema, Obj as Obj3, Ref as Ref4, Type as Type3 } from "@dxos/echo";
+import { Text as Text2 } from "@dxos/schema";
+var Instructions = class extends Type3.makeObject(DXN4.make("org.dxos.type.instructions", "0.1.0"))(Schema5.Struct({
+  name: Schema5.optional(Schema5.String),
+  description: Schema5.optional(Schema5.String),
+  input: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Input schema"
+  }),
+  output: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Output schema"
+  }),
+  text: Ref4.Ref(Text2.Text).pipe(Format.FormatAnnotation.set(Format.TypeFormat.Markdown), Schema5.annotations({
+    title: "Instructions",
+    description: "Describe what the agent should do in each session."
+  })),
+  skills: Schema5.Array(Ref4.Ref(Skill)),
+  /**
+   * Context objects bound to the agent's session when this routine runs (sibling of `skills`).
+   * Generic `Ref.Ref(Obj.Unknown)` so any space object qualifies. Honored on every run path that
+   * executes a routine through the agent prompt, not only triggered automations.
+   */
+  objects: Schema5.Array(Ref4.Ref(Obj3.Unknown)).pipe(Schema5.annotations({
+    title: "Objects"
+  }), Schema5.optional)
+}).pipe(Annotation3.LabelAnnotation.set([
+  "name"
+]), Annotation3.IconAnnotation.set({
+  icon: "ph--scroll--regular",
+  hue: "sky"
+}), Annotation3.HiddenAnnotation.set(true))) {
+};
+var make5 = ({ name, description, input, output, text, skills = [], objects }) => {
+  const body = Text2.make({
+    content: text ?? ""
+  });
+  const instructions = Obj3.make(Instructions, {
+    name,
+    description,
+    input: JsonSchema.toJsonSchema(input ?? Schema5.Void),
+    output: JsonSchema.toJsonSchema(output ?? Schema5.Void),
+    text: Ref4.make(body),
+    skills,
+    objects
+  });
+  Obj3.setParent(body, instructions);
+  return instructions;
+};
+
 // src/LayerSpec.ts
 var LayerSpec_exports = {};
 __export(LayerSpec_exports, {
   TypeId: () => TypeId,
-  make: () => make4
+  make: () => make6
 });
 var TypeId = "~@dxos/functions/LayerSpec";
-var make4 = (opts, make11) => {
+var make6 = (opts, make12) => {
   return {
     [TypeId]: TypeId,
     affinity: opts.affinity,
     requires: opts.requires,
     provides: opts.provides,
-    make: make11
+    make: make12
   };
 };
 
@@ -375,7 +596,7 @@ var layer = Layer2.effect(Service, Effect5.gen(function* () {
   const database = yield* Database3.Service;
   const handlerSet = yield* OperationHandlerProvider;
   return {
-    resolve: (key2) => Database3.query(Query.select(Filter3.and(Filter3.type(PersistentOperation), Filter3.key(key2)))).first.pipe(Effect5.flatten, Effect5.map(deserialize), Effect5.catchTag("NoSuchElementException", () => getHandlerByKey(handlerSet, key2)), Effect5.option).pipe(Effect5.provideService(Database3.Service, database))
+    resolve: (key) => Database3.query(Query.select(Filter3.and(Filter3.type(PersistentOperation), Filter3.key(key)))).first.pipe(Effect5.flatten, Effect5.map(deserialize), Effect5.catchTag("NoSuchElementException", () => getHandlerByKey(handlerSet, key)), Effect5.option).pipe(Effect5.provideService(Database3.Service, database))
   };
 }));
 
@@ -383,21 +604,26 @@ var layer = Layer2.effect(Service, Effect5.gen(function* () {
 var Process_exports = {};
 __export(Process_exports, {
   ExitedEvent: () => ExitedEvent,
+  HarnessHostAnnotation: () => HarnessHostAnnotation,
   ID: () => ID,
+  NotifyAnnotation: () => NotifyAnnotation,
   ProcessMonitorService: () => ProcessMonitorService,
   ProcessTypeId: () => ProcessTypeId,
   SpawnedEvent: () => SpawnedEvent,
   State: () => State,
+  TargetAnnotation: () => TargetAnnotation,
   fromOperation: () => fromOperation,
   isProcess: () => isProcess,
-  make: () => make5,
+  make: () => make8,
   prettyProcessTree: () => prettyProcessTree
 });
+import * as RpcGroup from "@effect/rpc/RpcGroup";
 import * as Context4 from "effect/Context";
 import * as Effect7 from "effect/Effect";
-import * as Schema5 from "effect/Schema";
+import * as Schema7 from "effect/Schema";
+import { Annotation as Annotation5 } from "@dxos/echo";
 import { assertArgument as assertArgument2 } from "@dxos/invariant";
-import { DXN as DXN4 } from "@dxos/keys";
+import { DXN as DXN6, URI as URI2 } from "@dxos/keys";
 import { log as log3 } from "@dxos/log";
 
 // src/Trace.ts
@@ -433,8 +659,8 @@ __export(Trace_exports, {
 import * as Context3 from "effect/Context";
 import * as Effect6 from "effect/Effect";
 import * as Layer3 from "effect/Layer";
-import * as Schema4 from "effect/Schema";
-import { DXN as DXN3, Annotation as Annotation2, Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import * as Schema6 from "effect/Schema";
+import { Annotation as Annotation4, DXN as DXN5, Obj as Obj4, Ref as Ref5, Type as Type4 } from "@dxos/echo";
 import { log as log2 } from "@dxos/log";
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/compute/src/Trace.ts";
 var TraceService = class extends Context3.Tag("@dxos/functions/TraceService")() {
@@ -444,27 +670,27 @@ function write(eventType, payload) {
     log2("trace write", {
       key: eventType.key,
       isEphemeral: eventType.isEphemeral
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 20, S: this });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 21, S: this });
     const writer = yield* TraceService;
     writer.write(eventType, payload);
   });
 }
-var EventType = (key2, opts) => {
+var EventType = (key, opts) => {
   return {
-    key: key2,
+    key,
     schema: opts.schema,
     isEphemeral: opts.isEphemeral
   };
 };
-var Event = Schema4.Struct({
-  timestamp: Schema4.Number,
-  type: Schema4.String,
-  data: Schema4.Unknown
+var Event = Schema6.Struct({
+  timestamp: Schema6.Number,
+  type: Schema6.String,
+  data: Schema6.Unknown
 });
 var isOfType = (eventType, event) => {
   return event.type === eventType.key;
 };
-var RuntimeName = Schema4.String.pipe(Schema4.brand("@dxos/compute/Trace/RuntimeName"));
+var RuntimeName = Schema6.String.pipe(Schema6.brand("@dxos/compute/Trace/RuntimeName"));
 var CommonRuntimeName = {
   /**
   * Web app / CLI / Desktop app / Mobile app.
@@ -474,42 +700,43 @@ var CommonRuntimeName = {
   edgeWorkerLoader: RuntimeName.make("edge-worker-loader"),
   edgeWorkerForPlatforms: RuntimeName.make("edge-worker-for-platforms")
 };
-var Meta = Schema4.Struct({
-  pid: Schema4.optional(Schema4.String),
-  parentPid: Schema4.optional(Schema4.String),
-  processName: Schema4.optional(Schema4.String),
+var Meta = Schema6.Struct({
+  pid: Schema6.optional(Schema6.String),
+  parentPid: Schema6.optional(Schema6.String),
+  processName: Schema6.optional(Schema6.String),
   /**
   * Space the message was produced in.
   * Stored as a string to avoid circular dependency on `@dxos/keys`.
   */
-  space: Schema4.optional(Schema4.String),
+  space: Schema6.optional(Schema6.String),
   /**
-  * ID of the conversation feed object if present.
+  * Ref to the conversation feed object if present.
   */
-  conversationId: Schema4.optional(Obj2.ID),
+  conversation: Ref5.Ref(Obj4.Unknown).pipe(Schema6.optional),
   /**
-  * ID of the trigger object if invocation resulted from a trigger.
+  * Ref to the trigger object if invocation resulted from a trigger.
   */
-  triggerId: Schema4.optional(Obj2.ID),
+  trigger: Ref5.Ref(Trigger).pipe(Schema6.optional),
   /**
   * ID of the tool call that created the current process.
   */
-  toolCallId: Schema4.optional(Schema4.String),
+  toolCallId: Schema6.optional(Schema6.String),
   /**
   * Extensible name informing which runtime executed the code that produced the event.
   */
-  runtimeName: Schema4.optional(RuntimeName)
+  runtimeName: Schema6.optional(RuntimeName)
 });
 var isEdgeRuntime = (name) => name === CommonRuntimeName.edgeIntrinsic || name === CommonRuntimeName.edgeWorkerLoader || name === CommonRuntimeName.edgeWorkerForPlatforms;
-var MessageData = Schema4.Struct({
+var MessageData = Schema6.Struct({
   meta: Meta,
-  isEphemeral: Schema4.Boolean,
-  events: Schema4.Array(Event)
+  isEphemeral: Schema6.Boolean,
+  events: Schema6.Array(Event)
 });
-var Message = MessageData.pipe(Annotation2.IconAnnotation.set({
+var Message = class extends Type4.makeObject(DXN5.make("org.dxos.type.traceMessage", "0.1.0"))(MessageData.pipe(Annotation4.IconAnnotation.set({
   icon: "ph--note--regular",
   hue: "rose"
-}), Annotation2.HiddenAnnotation.set(true), Type2.makeObject(DXN3.make("org.dxos.type.traceMessage", "0.1.0")));
+}), Annotation4.HiddenAnnotation.set(true))) {
+};
 var flatten2 = (message) => {
   return message.events.map((event) => ({
     ...event,
@@ -555,7 +782,7 @@ var testTraceService = (opts = {}) => Layer3.effect(TraceService, Effect6.gen(fu
   const clock = opts.clock ?? Date.now;
   return {
     write: (event, data) => {
-      sink.write(Obj2.make(Message, {
+      sink.write(Obj4.make(Message, {
         meta: opts.meta ?? {},
         isEphemeral: event.isEphemeral,
         events: [
@@ -570,57 +797,57 @@ var testTraceService = (opts = {}) => Layer3.effect(TraceService, Effect6.gen(fu
   };
 }));
 var OperationStart = EventType("operation.start", {
-  schema: Schema4.Struct({
+  schema: Schema6.Struct({
     /** Operation key. */
-    key: Schema4.String,
+    key: Schema6.String,
     /** Human-readable operation name. */
-    name: Schema4.optional(Schema4.String),
+    name: Schema6.optional(Schema6.String),
     /** Phosphor icon identifier in `ph--<name>--<variant>` format. */
-    icon: Schema4.optional(Schema4.String)
+    icon: Schema6.optional(Schema6.String)
   }),
   isEphemeral: false
 });
 var OperationEnd = EventType("operation.end", {
-  schema: Schema4.Struct({
+  schema: Schema6.Struct({
     /** Operation key. */
-    key: Schema4.String,
+    key: Schema6.String,
     /** Human-readable operation name. */
-    name: Schema4.optional(Schema4.String),
+    name: Schema6.optional(Schema6.String),
     /** Phosphor icon identifier in `ph--<name>--<variant>` format. */
-    icon: Schema4.optional(Schema4.String),
+    icon: Schema6.optional(Schema6.String),
     /** Outcome of the operation. */
-    outcome: Schema4.Literal("success", "failure"),
+    outcome: Schema6.Literal("success", "failure"),
     /** Error message if the operation failed. */
-    error: Schema4.optional(Schema4.String)
+    error: Schema6.optional(Schema6.String)
   }),
   isEphemeral: false
 });
 var OperationInput = EventType("operation.input", {
-  schema: Schema4.Struct({
+  schema: Schema6.Struct({
     /** Operation key. */
-    key: Schema4.String,
+    key: Schema6.String,
     /** Human-readable operation name. */
-    name: Schema4.optional(Schema4.String),
+    name: Schema6.optional(Schema6.String),
     /** Raw operation input. Shape determined by the operation definition. */
-    input: Schema4.Unknown
+    input: Schema6.Unknown
   }),
   isEphemeral: true
 });
 var OperationOutput = EventType("operation.output", {
-  schema: Schema4.Struct({
+  schema: Schema6.Struct({
     /** Operation key. */
-    key: Schema4.String,
+    key: Schema6.String,
     /** Human-readable operation name. */
-    name: Schema4.optional(Schema4.String),
+    name: Schema6.optional(Schema6.String),
     /** Raw operation output. Shape determined by the operation definition. */
-    output: Schema4.Unknown
+    output: Schema6.Unknown
   }),
   isEphemeral: true
 });
 var StatusUpdate = EventType("status.update", {
-  schema: Schema4.Struct({
+  schema: Schema6.Struct({
     /** Human-readable status message. */
-    message: Schema4.String
+    message: Schema6.String
   }),
   isEphemeral: true
 });
@@ -630,26 +857,50 @@ var emitStatus = (message) => write(StatusUpdate, {
 
 // src/Process.ts
 var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/compute/src/Process.ts";
-var ID = Schema5.String.pipe(Schema5.brand("ProcessId"));
+var ID = Schema7.String.pipe(Schema7.brand("ProcessId"));
+var TargetAnnotation = Annotation5.make({
+  id: "org.dxos.process.target",
+  schema: URI2.Schema
+});
+var NotifyAnnotation = Annotation5.make({
+  id: "org.dxos.process.notify",
+  schema: NotifyOptions
+});
+var HarnessHostAnnotation = Annotation5.make({
+  id: "org.dxos.process.harnessHost",
+  schema: Schema7.Boolean
+});
 var ProcessTypeId = "~@dxos/functions/Process";
 var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
-var make5 = (opts, create) => {
+var make8 = (opts, create) => {
   assertArgument2(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), "key", "Invalid key");
   return {
     [ProcessTypeId]: {},
     ...opts,
+    rpcs: opts.rpcs ?? RpcGroup.make(),
     create: (ctx) => create(ctx).pipe(Effect7.map((partial) => ({
       onSpawn: () => Effect7.void,
       onInput: () => Effect7.void,
       onAlarm: () => Effect7.void,
       onChildEvent: () => Effect7.void,
-      ...partial
+      ...partial,
+      rpcHandlers: sanitizeRpcs(opts.rpcs, partial.rpcHandlers)
     })))
   };
 };
-var OperationStartedKey = key(Schema5.parseJson(Schema5.Boolean), "operation/started").pipe(withDefault(() => false));
-var fromOperation = (op, handler) => make5({
-  key: DXN4.getName(op.meta.key),
+var sanitizeRpcs = (defined, provided) => {
+  const needsRpcs = defined !== void 0 && defined.requests.size > 0;
+  if (!needsRpcs) {
+    return provided ?? Context4.empty();
+  }
+  if (!provided) {
+    throw new TypeError("Process declared RPCs but did not provide any handlers");
+  }
+  return provided;
+};
+var OperationStartedCell = cell(Schema7.parseJson(Schema7.Boolean), "operation/started").pipe(withDefault(() => false));
+var fromOperation = (op, handler) => make8({
+  key: DXN6.getName(op.meta.key),
   input: op.input,
   output: op.output,
   services: op.services
@@ -659,16 +910,16 @@ var fromOperation = (op, handler) => make5({
   return {
     onInput: (input) => Effect7.gen(function* () {
       if (!idempotent) {
-        const started = yield* OperationStartedKey.get;
+        const started = yield* OperationStartedCell.get;
         if (started) {
           return yield* Effect7.die(new Error(`non-idempotent operation "${op.meta.key}" was interrupted; cannot retry safely`));
         }
-        yield* OperationStartedKey.set(true);
+        yield* OperationStartedCell.set(true);
       }
       log3("operation process invoking", {
         key: op.meta.key,
         name: op.meta.name
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 66, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 104, S: this });
       yield* write(OperationStart, {
         key: op.meta.key,
         name: op.meta.name,
@@ -720,12 +971,12 @@ var State = /* @__PURE__ */ (function(State2) {
 var ProcessMonitorService = class extends Context4.Tag("@dxos/functions/ProcessMonitorService")() {
 };
 var SpawnedEvent = EventType("process.spawned", {
-  schema: Schema5.Void,
+  schema: Schema7.Void,
   isEphemeral: false
 });
 var ExitedEvent = EventType("process.exited", {
-  schema: Schema5.Struct({
-    outcome: Schema5.Literal("succeeded", "failed", "terminated")
+  schema: Schema7.Struct({
+    outcome: Schema7.Literal("succeeded", "failed", "terminated")
   }),
   isEphemeral: false
 });
@@ -742,10 +993,10 @@ var prettyProcessTree = (tree) => {
       roots.push(node);
       continue;
     }
-    const key2 = String(parent);
-    const siblings = childrenByParent.get(key2) ?? [];
+    const key = String(parent);
+    const siblings = childrenByParent.get(key) ?? [];
     siblings.push(node);
-    childrenByParent.set(key2, siblings);
+    childrenByParent.set(key, siblings);
   }
   const byPid = (a, b) => String(a.pid).localeCompare(String(b.pid));
   roots.sort(byPid);
@@ -788,74 +1039,33 @@ var prettyProcessTree = (tree) => {
   return lines.join("\n");
 };
 
-// src/Routine.ts
-var Routine_exports = {};
-__export(Routine_exports, {
-  Routine: () => Routine,
-  make: () => make6
-});
-import * as Schema6 from "effect/Schema";
-import { DXN as DXN5, Annotation as Annotation3, JsonSchema, Obj as Obj3, Ref as Ref2, Type as Type3, Format } from "@dxos/echo";
-import { Text as Text2 } from "@dxos/schema";
-var Routine = Schema6.Struct({
-  name: Schema6.optional(Schema6.String),
-  description: Schema6.optional(Schema6.String),
-  input: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
-    description: "Input schema"
-  }),
-  output: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
-    description: "Output schema"
-  }),
-  instructions: Ref2.Ref(Text2.Text).pipe(Annotation3.FormInputAnnotation.set(false), Format.FormatAnnotation.set(Format.TypeFormat.Markdown), Schema6.annotations({
-    title: "Instructions",
-    description: "Agent instructions"
-  })),
-  blueprints: Schema6.Array(Ref2.Ref(Blueprint)),
-  context: Schema6.Array(Schema6.Any).pipe(Annotation3.FormInputAnnotation.set(false))
-}).pipe(Annotation3.LabelAnnotation.set([
-  "name"
-]), Annotation3.IconAnnotation.set({
-  icon: "ph--scroll--regular",
-  hue: "sky"
-}), Type3.makeObject(DXN5.make("org.dxos.type.routine", "0.1.0")));
-var make6 = ({ name, description, input, output, instructions, blueprints = [], context = [] }) => Obj3.make(Routine, {
-  name,
-  description,
-  input: JsonSchema.toJsonSchema(input ?? Schema6.Void),
-  output: JsonSchema.toJsonSchema(output ?? Schema6.Void),
-  instructions: Ref2.make(Text2.make({
-    content: instructions ?? ""
-  })),
-  blueprints,
-  context
-});
-
 // src/Script.ts
 var Script_exports = {};
 __export(Script_exports, {
   Script: () => Script,
-  make: () => make7
+  make: () => make9
 });
-import * as Schema7 from "effect/Schema";
-import { DXN as DXN6, Annotation as Annotation4, Obj as Obj4, Ref as Ref3, Type as Type4 } from "@dxos/echo";
+import * as Schema8 from "effect/Schema";
+import { Annotation as Annotation6, DXN as DXN7, Obj as Obj5, Ref as Ref6, Type as Type5 } from "@dxos/echo";
 import { FormInputAnnotation } from "@dxos/echo/Annotation";
 import { Text as Text3 } from "@dxos/schema";
-var Script = Schema7.Struct({
-  name: Schema7.String.pipe(Schema7.optional),
-  description: Schema7.String.pipe(Schema7.optional),
+var Script = class extends Type5.makeObject(DXN7.make("org.dxos.type.script", "0.1.0"))(Schema8.Struct({
+  name: Schema8.String.pipe(Schema8.optional),
+  description: Schema8.String.pipe(Schema8.optional),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema7.Boolean.pipe(FormInputAnnotation.set(false), Schema7.optional),
-  source: Ref3.Ref(Text3.Text).pipe(FormInputAnnotation.set(false))
-}).pipe(Annotation4.LabelAnnotation.set([
+  changed: Schema8.Boolean.pipe(FormInputAnnotation.set(false), Schema8.optional),
+  source: Ref6.Ref(Text3.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Annotation6.LabelAnnotation.set([
   "name"
-]), Annotation4.IconAnnotation.set({
+]), Annotation6.IconAnnotation.set({
   icon: "ph--code--regular",
   hue: "sky"
-}), Type4.makeObject(DXN6.make("org.dxos.type.script", "0.1.0")));
-var make7 = ({ source = "", ...props } = {}) => Obj4.make(Script, {
+}))) {
+};
+var make9 = ({ source = "", ...props } = {}) => Obj5.make(Script, {
   ...props,
-  source: Ref3.make(Text3.make({
+  source: Ref6.make(Text3.make({
     content: source
   }))
 });
@@ -865,11 +1075,11 @@ var ServiceResolver_exports = {};
 __export(ServiceResolver_exports, {
   ServiceResolver: () => ServiceResolver,
   compose: () => compose,
-  empty: () => empty2,
+  empty: () => empty3,
   fromContext: () => fromContext,
   fromRequirements: () => fromRequirements,
   layerRequirements: () => layerRequirements,
-  make: () => make9,
+  make: () => make11,
   provide: () => provide,
   resolve: () => resolve3,
   resolveAll: () => resolveAll,
@@ -888,7 +1098,7 @@ var resolveAll = (tags, context) => Effect8.gen(function* () {
   return Context5.mergeAll(...services);
 });
 var succeed2 = (tag, getService) => {
-  return make9((tag1, context) => {
+  return make11((tag1, context) => {
     if (tag1.key !== tag.key) {
       return Effect8.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
     }
@@ -896,11 +1106,11 @@ var succeed2 = (tag, getService) => {
     return service;
   });
 };
-var make9 = (resolveFn) => ({
+var make11 = (resolveFn) => ({
   [ServiceResolverTypeId]: ServiceResolverTypeId,
   resolve: resolveFn
 });
-var fromContext = (ctx) => make9((tag, context) => Effect8.gen(function* () {
+var fromContext = (ctx) => make11((tag, context) => Effect8.gen(function* () {
   const service = Context5.getOption(ctx, tag);
   if (Option.isNone(service)) {
     return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
@@ -909,7 +1119,7 @@ var fromContext = (ctx) => make9((tag, context) => Effect8.gen(function* () {
 }));
 var fromRequirements = (...tags) => Effect8.contextWith((parentCtx) => {
   const available = new Set(tags.map((tag) => tag.key));
-  return make9((tag, context) => Effect8.gen(function* () {
+  return make11((tag, context) => Effect8.gen(function* () {
     let result = Context5.empty();
     if (!available.has(tag.key)) {
       return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
@@ -923,7 +1133,7 @@ var fromRequirements = (...tags) => Effect8.contextWith((parentCtx) => {
 });
 var layerRequirements = (...tags) => Layer4.effect(ServiceResolver, fromRequirements(...tags));
 var provide = (context, ...tags) => Layer4.scopedContext(resolveAll(tags, context));
-var compose = (...resolvers) => make9((tag, context) => Effect8.gen(function* () {
+var compose = (...resolvers) => make11((tag, context) => Effect8.gen(function* () {
   for (const resolver of resolvers) {
     const single = yield* resolver.resolve(tag, context).pipe(Effect8.either);
     if (Either.isRight(single)) {
@@ -932,173 +1142,10 @@ var compose = (...resolvers) => make9((tag, context) => Effect8.gen(function* ()
   }
   return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
 }));
-var empty2 = make9((tag, context) => {
+var empty3 = make11((tag, context) => {
   return Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
 });
 
-// src/Trigger.ts
-var Trigger_exports = {};
-__export(Trigger_exports, {
-  EmailSpec: () => EmailSpec,
-  FeedSpec: () => FeedSpec,
-  Kinds: () => Kinds,
-  Spec: () => Spec,
-  SubscriptionSpec: () => SubscriptionSpec,
-  TimerSpec: () => TimerSpec,
-  Trigger: () => Trigger,
-  WebhookSpec: () => WebhookSpec,
-  make: () => make10,
-  specEmail: () => specEmail,
-  specFeed: () => specFeed,
-  specSubscription: () => specSubscription,
-  specTimer: () => specTimer,
-  specWebhook: () => specWebhook
-});
-import * as Schema8 from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { DXN as DXN7, Annotation as Annotation5, Feed, Obj as Obj5, QueryAST, Ref as Ref4, Type as Type5 } from "@dxos/echo";
-import { HiddenAnnotation } from "@dxos/echo/Annotation";
-import { OptionsAnnotationId } from "@dxos/echo/Format";
-var Kinds = [
-  "email",
-  "feed",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var EmailSpec = Schema8.Struct({
-  kind: Schema8.Literal("email").annotations(kindLiteralAnnotations)
-});
-var specEmail = () => ({
-  kind: "email"
-});
-var FeedSpec = Schema8.Struct({
-  kind: Schema8.Literal("feed").annotations(kindLiteralAnnotations),
-  feed: Schema8.optional(Ref4.Ref(Feed.Feed).annotations({
-    title: "Feed"
-  }))
-});
-var specFeed = (feed) => ({
-  kind: "feed",
-  feed: Ref4.make(feed)
-});
-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: Schema8.optional(Schema8.Struct({
-    // Watch changes to object (not just creation).
-    deep: Schema8.optional(Schema8.Boolean.annotations({
-      title: "Nested"
-    })),
-    // Debounce changes (delay in ms).
-    delay: Schema8.optional(Schema8.Number.annotations({
-      title: "Delay"
-    }))
-  }).annotations({
-    title: "Options"
-  }))
-});
-var specSubscription = (query, options) => ({
-  kind: "subscription",
-  query: {
-    ast: query.ast
-  },
-  options: options ? {
-    deep: options.deep,
-    delay: options.delay
-  } : void 0
-});
-var TimerSpec = Schema8.Struct({
-  kind: Schema8.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema8.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-});
-var specTimer = (cron) => ({
-  kind: "timer",
-  cron
-});
-var WebhookSpec = Schema8.Struct({
-  kind: Schema8.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema8.optional(Schema8.String.annotations({
-    title: "Method",
-    [OptionsAnnotationId]: [
-      "GET",
-      "POST"
-    ]
-  })),
-  port: Schema8.optional(Schema8.Number.annotations({
-    title: "Port"
-  }))
-});
-var specWebhook = (opts) => ({
-  kind: "webhook",
-  method: opts?.method,
-  port: opts?.port
-});
-var Spec = Schema8.Union(EmailSpec, FeedSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var TriggerSchema = Schema8.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema8.optional(Ref4.Ref(Obj5.Unknown).annotations({
-    title: "Function"
-  })),
-  /**
-  * Only used for workflowSchema.
-  * Specifies the input node in the circuit.
-  * @deprecated Remove and enforce a single input node in all compute graphSchema.
-  */
-  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: Schema8.optional(Schema8.Boolean.annotations({
-    title: "Enabled"
-  })),
-  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."
-  })),
-  /**
-  * Passed as the input data to the function.
-  * Must match the function's input schema.
-  *
-  * @example
-  * {
-  *   item: '{{event.item}}',
-  *   instructions: 'Summarize and perform entity-extraction'
-  *   mailbox: { '/': 'echo://AAA/ZZZ' }
-  * }
-  */
-  input: Schema8.optional(Schema8.Record({
-    key: Schema8.String,
-    value: Schema8.Any
-  }))
-}).pipe(Annotation5.IconAnnotation.set({
-  icon: "ph--lightning--regular",
-  hue: "yellow"
-}), HiddenAnnotation.set(true), Type5.makeObject(DXN7.make("org.dxos.type.trigger", "0.1.0")));
-var Trigger = TriggerSchema;
-var make10 = (props) => Obj5.make(Trigger, props);
-
 // src/TriggerEvent.ts
 var TriggerEvent_exports = {};
 __export(TriggerEvent_exports, {
@@ -1110,7 +1157,7 @@ __export(TriggerEvent_exports, {
   WebhookEvent: () => WebhookEvent
 });
 import * as Schema9 from "effect/Schema";
-import { Feed as Feed2, Obj as Obj6, Ref as Ref5 } from "@dxos/echo";
+import { Feed as Feed2, Obj as Obj6, Ref as Ref7 } from "@dxos/echo";
 var EmailEvent = Schema9.Struct({
   from: Schema9.String,
   to: Schema9.String,
@@ -1119,7 +1166,7 @@ var EmailEvent = Schema9.Struct({
   body: Schema9.String
 });
 var FeedEvent = Schema9.Struct({
-  feed: Ref5.Ref(Feed2.Feed),
+  feed: Ref7.Ref(Feed2.Feed),
   item: Schema9.Any,
   cursor: Schema9.String
 });
@@ -1132,7 +1179,7 @@ var SubscriptionEvent = Schema9.Struct({
   /**
   * Reference to the object that was changed or created.
   */
-  subject: Ref5.Ref(Obj6.Unknown),
+  subject: Ref7.Ref(Obj6.Unknown),
   /**
   * @deprecated
   */
@@ -1152,13 +1199,14 @@ var WebhookEvent = Schema9.Struct({
 });
 var TriggerEvent = Schema9.Union(EmailEvent, FeedEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
 export {
-  Blueprint_exports as Blueprint,
+  AgentService_exports as AgentService,
   Credential_exports as Credential,
   FunctionError,
   FunctionNotFoundError,
   FunctionsAiMemoizationMissError,
   FunctionsAiUpstreamError,
   Header_exports as Header,
+  Instructions_exports as Instructions,
   InvalidOperationInputError,
   InvalidOperationOutputError,
   InvokerNotInitializedError,
@@ -1169,10 +1217,11 @@ export {
   OperationHandlerSet_exports as OperationHandlerSet,
   OperationRegistry_exports as OperationRegistry,
   Process_exports as Process,
-  Routine_exports as Routine,
+  Runnable_exports as Runnable,
   Script_exports as Script,
   ServiceNotAvailableError,
   ServiceResolver_exports as ServiceResolver,
+  Skill_exports as Skill,
   StorageService_exports as StorageService,
   Template_exports as Template,
   Trace_exports as Trace,