@dxos/assistant-toolkit 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,914 @@
+import {
+  AgentPrompt
+} from "./chunk-COL54UJ3.mjs";
+import {
+  DeleteMemory,
+  QueryMemories,
+  SaveMemory
+} from "./chunk-EJAQUAKM.mjs";
+import {
+  EnableBlueprints,
+  QueryBlueprints,
+  UpdateBlueprints
+} from "./chunk-ANSF2BHN.mjs";
+import {
+  AgentRules,
+  CreateAgent,
+  SyncTriggers
+} from "./chunk-BCT55UTL.mjs";
+import {
+  SyncIssues,
+  syncObjects
+} from "./chunk-MMQ7HFL4.mjs";
+import {
+  UpdateTasks
+} from "./chunk-PLGEBNTO.mjs";
+import {
+  Fetch
+} from "./chunk-WLR3BGO4.mjs";
+import {
+  ContextAdd,
+  ContextRemove,
+  Load,
+  ObjectCreate,
+  ObjectDelete,
+  ObjectUpdate,
+  Query,
+  RelationCreate,
+  RelationDelete,
+  SchemaAdd,
+  SchemaList,
+  TagAdd,
+  TagRemove
+} from "./chunk-7UCYAP3T.mjs";
+import {
+  FetchMessages
+} from "./chunk-ZFXLTBZG.mjs";
+import {
+  AgentBlueprintHandlers,
+  blueprint_default
+} from "./chunk-W2722TC5.mjs";
+import {
+  AddArtifact,
+  AgentWorker,
+  GetContext,
+  Qualifier
+} from "./chunk-KS3IA6FQ.mjs";
+import {
+  Agent_exports,
+  McpServer_exports,
+  Plan_exports
+} from "./chunk-5GPL2WXU.mjs";
+import {
+  Chat_exports
+} from "./chunk-NR3GTWRC.mjs";
+import {
+  Memory_exports
+} from "./chunk-KGU725LW.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/blueprints/discord/blueprint.ts
+import { Blueprint } from "@dxos/compute";
+import { Ref } from "@dxos/echo";
+import { Text } from "@dxos/schema";
+import { trim } from "@dxos/util";
+
+// src/blueprints/discord/functions/index.ts
+import { OperationHandlerSet } from "@dxos/compute";
+var DiscordHandlers = OperationHandlerSet.lazy(() => import("./fetch-messages-QOBBCTGC.mjs"));
+
+// src/blueprints/discord/blueprint.ts
+var BLUEPRINT_KEY = "org.dxos.blueprint.discord";
+var instructions = trim`
+  You are able to fetch messages from Discord servers.
+
+  Known servers:
+
+  DXOS serverId: 837138313172353095
+`;
+var make = () => Blueprint.make({
+  key: BLUEPRINT_KEY,
+  name: "Discord",
+  description: "Discord integration.",
+  instructions: {
+    source: Ref.make(Text.make({
+      content: instructions
+    }))
+  },
+  tools: Blueprint.toolDefinitions({
+    operations: [
+      FetchMessages
+    ]
+  })
+});
+var blueprint = {
+  key: BLUEPRINT_KEY,
+  make
+};
+var blueprint_default2 = blueprint;
+
+// src/blueprints/linear/blueprint.ts
+import { Blueprint as Blueprint2 } from "@dxos/compute";
+import { Ref as Ref2 } from "@dxos/echo";
+import { Text as Text2 } from "@dxos/schema";
+import { trim as trim2 } from "@dxos/util";
+
+// src/blueprints/linear/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/compute";
+var LinearHandlers = OperationHandlerSet2.lazy(() => import("./sync-issues-DWY76B3M.mjs"));
+
+// src/blueprints/linear/blueprint.ts
+var BLUEPRINT_KEY2 = "org.dxos.blueprint.linear";
+var instructions2 = trim2`
+  You are able to sync Linear workspaces.
+  Sometimes sync does not complete in one go and you need to call the function again.
+
+  Known workspaces:
+
+  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
+`;
+var make2 = () => Blueprint2.make({
+  key: BLUEPRINT_KEY2,
+  name: "Linear",
+  description: "Syncs Linear workspaces.",
+  instructions: {
+    source: Ref2.make(Text2.make({
+      content: instructions2
+    }))
+  },
+  tools: Blueprint2.toolDefinitions({
+    operations: [
+      SyncIssues
+    ]
+  })
+});
+var blueprint2 = {
+  key: BLUEPRINT_KEY2,
+  make: make2
+};
+var blueprint_default3 = blueprint2;
+
+// src/blueprints/planning/blueprint.ts
+import { Blueprint as Blueprint3 } from "@dxos/compute";
+
+// src/blueprints/planning/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet3 } from "@dxos/compute";
+var PlanningHandlers = OperationHandlerSet3.lazy(() => import("./update-tasks-QQUR53RN.mjs"));
+
+// src/blueprints/planning/blueprint.ts
+var BLUEPRINT_KEY3 = "org.dxos.blueprint.planning";
+var make3 = () => Blueprint3.make({
+  key: BLUEPRINT_KEY3,
+  name: "Planning",
+  description: "Plans and tracks complex tasks using artifacts.",
+  tools: Blueprint3.toolDefinitions({
+    operations: [
+      UpdateTasks
+    ]
+  })
+});
+var blueprint3 = {
+  key: BLUEPRINT_KEY3,
+  make: make3
+};
+var blueprint_default4 = blueprint3;
+
+// src/blueprints/websearch/blueprint.ts
+import { Blueprint as Blueprint4 } from "@dxos/compute";
+import { Ref as Ref3 } from "@dxos/echo";
+import { Text as Text3 } from "@dxos/schema";
+
+// src/blueprints/websearch/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/compute";
+var WebSearchHandlers = OperationHandlerSet4.lazy(() => import("./fetch-KHMHV7JR.mjs"));
+
+// src/blueprints/websearch/blueprint.ts
+var BLUEPRINT_KEY4 = "org.dxos.blueprint.web-search";
+var make4 = () => Blueprint4.make({
+  key: BLUEPRINT_KEY4,
+  name: "Web Search",
+  description: "Search the web.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref3.make(Text3.make())
+  },
+  tools: Blueprint4.toolDefinitions({
+    operations: [
+      Fetch
+    ],
+    tools: [
+      "AnthropicWebSearch"
+    ]
+  })
+});
+var blueprint4 = {
+  key: BLUEPRINT_KEY4,
+  make: make4
+};
+var blueprint_default5 = blueprint4;
+
+// src/blueprints/websearch/toolkit.ts
+import * as AnthropicTool from "@effect/ai-anthropic/AnthropicTool";
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Layer from "effect/Layer";
+import { OpaqueToolkit } from "@dxos/ai";
+var WebSearchToolkit = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
+var WebSearchToolkitOpaque = OpaqueToolkit.make(WebSearchToolkit, Layer.empty);
+
+// src/blueprints/browser/blueprint.ts
+import { Blueprint as Blueprint5 } from "@dxos/compute";
+import { Ref as Ref4 } from "@dxos/echo";
+import { Text as Text4 } from "@dxos/schema";
+import { trim as trim3 } from "@dxos/util";
+var BLUEPRINT_KEY5 = "org.dxos.blueprint.browser";
+var instructions3 = trim3`
+  You are able to connect and use a virtual browser with persistent session.
+  Browser tools are provided via MCP.
+`;
+var make6 = () => Blueprint5.make({
+  key: BLUEPRINT_KEY5,
+  name: "Browser",
+  description: "Access to a real isolated browser.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref4.make(Text4.make({
+      content: instructions3
+    }))
+  },
+  mcpServers: [
+    {
+      // https://dash.cloudflare.com/950816f3f59b079880a1ae33fb0ec320/workers/services/view/playwright-mcp-example/production
+      url: "https://playwright-mcp-example.dxos.workers.dev/sse",
+      protocol: "sse"
+    }
+  ]
+});
+var blueprint5 = {
+  key: BLUEPRINT_KEY5,
+  make: make6
+};
+var blueprint_default6 = blueprint5;
+
+// src/blueprints/database/blueprint.ts
+import { Blueprint as Blueprint6 } from "@dxos/compute";
+import { Ref as Ref5 } from "@dxos/echo";
+import { Text as Text5 } from "@dxos/schema";
+import { trim as trim4 } from "@dxos/util";
+
+// src/blueprints/database/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/compute";
+var DatabaseHandlers = OperationHandlerSet5.lazy(() => import("./context-add-S5MBW2NA.mjs"), () => import("./context-remove-35O5T5N5.mjs"), () => import("./load-GAT3T2AD.mjs"), () => import("./object-create-PL3WRP74.mjs"), () => import("./object-delete-PZJQN5KW.mjs"), () => import("./object-update-R43N3VJX.mjs"), () => import("./query-MP5NSQKO.mjs"), () => import("./relation-create-YAAAFTR2.mjs"), () => import("./relation-delete-IEPKERFR.mjs"), () => import("./schema-add-5BNIINRS.mjs"), () => import("./schema-list-54UK7S4R.mjs"), () => import("./tag-add-NLVRGTC6.mjs"), () => import("./tag-remove-N4HFBIA2.mjs"));
+
+// src/blueprints/database/blueprint.ts
+var BLUEPRINT_KEY6 = "org.dxos.blueprint.database";
+var instructions4 = trim4`
+  You can query, create, update, and delete objects in ECHO.
+  You can manage schemas, relations, tags, and add objects to the chat context.
+`;
+var make7 = () => Blueprint6.make({
+  key: BLUEPRINT_KEY6,
+  name: "Database",
+  description: "Query and manipulate objects in the ECHO database.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref5.make(Text5.make({
+      content: instructions4
+    }))
+  },
+  tools: Blueprint6.toolDefinitions({
+    operations: [
+      ContextAdd,
+      ContextRemove,
+      Load,
+      ObjectCreate,
+      ObjectDelete,
+      ObjectUpdate,
+      Query,
+      RelationCreate,
+      RelationDelete,
+      SchemaAdd,
+      SchemaList,
+      TagAdd,
+      TagRemove
+    ]
+  })
+});
+var blueprint6 = {
+  key: BLUEPRINT_KEY6,
+  make: make7
+};
+var blueprint_default7 = blueprint6;
+
+// src/blueprints/memory/blueprint.ts
+import { Blueprint as Blueprint7 } from "@dxos/compute";
+import { Ref as Ref6 } from "@dxos/echo";
+import { Text as Text6 } from "@dxos/schema";
+import { trim as trim5 } from "@dxos/util";
+
+// src/blueprints/memory/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet6 } from "@dxos/compute";
+var MemoryHandlers = OperationHandlerSet6.lazy(() => import("./save-GWAPLT3Z.mjs"), () => import("./query-U56GNEV6.mjs"), () => import("./delete-J3PMWP7Z.mjs"));
+
+// src/blueprints/memory/blueprint.ts
+var BLUEPRINT_KEY7 = "org.dxos.blueprint.memory";
+var instructions5 = trim5`
+  You have the ability to save and recall memories.
+  Memories are persistent knowledge units stored in the database.
+  Use memories to remember facts, user preferences, decisions, and any knowledge that should persist across conversations.
+
+  When the user asks you to remember something, save it as a memory with a descriptive title.
+  When the user asks about something you might have stored, query your memories first.
+  You can also delete outdated or incorrect memories.
+`;
+var make8 = () => Blueprint7.make({
+  key: BLUEPRINT_KEY7,
+  name: "Memory",
+  description: "Persistent memory storage and retrieval.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref6.make(Text6.make({
+      content: instructions5
+    }))
+  },
+  tools: Blueprint7.toolDefinitions({
+    operations: [
+      SaveMemory,
+      QueryMemories,
+      DeleteMemory
+    ]
+  })
+});
+var blueprint7 = {
+  key: BLUEPRINT_KEY7,
+  make: make8
+};
+var blueprint_default8 = blueprint7;
+
+// src/blueprints/automation/blueprint.ts
+import { Blueprint as Blueprint8, Trigger, Operation } from "@dxos/compute";
+import { Ref as Ref7 } from "@dxos/echo";
+import { Text as Text7 } from "@dxos/schema";
+import { trim as trim6 } from "@dxos/util";
+var BLUEPRINT_KEY8 = "dxos.org/blueprint/automation";
+var instructions6 = trim6`
+  Automation allows you to automatically initiate actions based on events.
+  Automations are configured by creating a trigger that references a function.
+  Whenever event that matches the trigger occurs, the function is invoked.
+
+  ## Configuration
+
+  Triggers are configured by the properties of the Trigger object.
+  - enabled: Must be true for trigger to run.
+  - spec: Events that the trigger matches.
+  - function: Ref to a ${Operation.PersistentOperation.typename} object that will be invoked. Query the functions present in the space first, and reference them in the trigger.
+  - input: The spec of the input data that will be passed to the function.
+
+  ## Input patterns
+
+  Input to the invoked function is defined by the input property of the Trigger object.
+  It's an object that supports constants or template strings.
+
+  Example:
+
+  {
+    item: '{{event.item}}',
+    instructions: 'Summarize and perform entity-extraction'
+    mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
+  }
+
+  ## Trigger kinds
+
+  - Timer: Triggered by a cron schedule.
+  - Queue: Subscribes and processes items begginging to end.
+            Note: queues are the same as feeds. The queue DXN should be of form: dxn:queue:data:<space-id>:<queue-id>.
+  - Subscription: Subscribes and processes database items based on a query.
+
+  Avoid: email and webhook triggers.
+
+  ## Editing triggers
+
+  Triggers are represented as objects of type ${Trigger.Trigger.typename}.
+  You need access to the Database blueprint to manipulate triggers.
+  Read trigger schema before manipulating triggers.
+  Having a Trigger object in the database is enough to setup an automation. 
+
+  ## Examples
+
+  Timer:
+
+  {
+    "function": { "/": "dxn:echo:AAA:ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "timer",
+      "cron": "*/5 * * * *"
+    }
+  }
+
+  Queue:
+
+  {
+    "function": { "/": "dxn:echo:AAA:ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "queue",
+      "queue": "dxn:queue:data:XXX:YYY"
+    }
+  }
+
+  Subscription:
+
+  {
+    "function": { "/": "dxn:echo:AAA:ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "subscription",
+      "query": { "ast": { "type": "select", "filter": { "type": "object", "typename": "dxn:type:org.dxos.type.person" } } }
+    }
+  }
+`;
+var make9 = () => Blueprint8.make({
+  key: BLUEPRINT_KEY8,
+  name: "Triggers",
+  description: "Trigger management and automation.",
+  instructions: {
+    source: Ref7.make(Text7.make({
+      content: instructions6
+    }))
+  }
+});
+var blueprint8 = {
+  key: BLUEPRINT_KEY8,
+  make: make9
+};
+var blueprint_default9 = blueprint8;
+
+// src/blueprints/blueprint-manager/blueprint.ts
+import { Blueprint as Blueprint9, Template } from "@dxos/compute";
+import { trim as trim7 } from "@dxos/util";
+
+// src/blueprints/blueprint-manager/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet7 } from "@dxos/compute";
+var BlueprintManagerHandlers = OperationHandlerSet7.lazy(() => import("./query-blueprints-PLWYVOI3.mjs"), () => import("./enable-blueprints-IVKST3WH.mjs"), () => import("./update-blueprints-2SNK6HLG.mjs"));
+
+// src/blueprints/blueprint-manager/blueprint.ts
+var BLUEPRINT_KEY9 = "org.dxos.blueprint.blueprint-manager";
+var make10 = () => Blueprint9.make({
+  key: BLUEPRINT_KEY9,
+  name: "Blueprint Manager",
+  description: "Query and enable blueprints in the current conversation.",
+  instructions: Template.make({
+    source: trim7`
+        You can query available blueprints and enable them in the current conversation.
+        Use [query-blueprints] to refresh the list of available blueprints.
+        Use [refresh-blueprints] to update blueprint objects stored in the database from the built-in registry when they have drifted.
+        Use [enable-blueprints] to enable blueprints by their keys. Always call [query-blueprints] first.
+        Only blueprints with agentCanEnable=true can be enabled by the agent.
+
+        <available_blueprints>
+        {{#each blueprints}}
+        - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
+        {{/each}}
+        </available_blueprints>
+
+        NOTE: You must enable the blueprint to use it, only then the tools from that blueprint will appear.
+      `,
+    inputs: [
+      {
+        name: "blueprints",
+        kind: "operation",
+        operation: QueryBlueprints.meta.key
+      }
+    ]
+  }),
+  tools: Blueprint9.toolDefinitions({
+    operations: [
+      QueryBlueprints,
+      EnableBlueprints,
+      UpdateBlueprints
+    ]
+  })
+});
+var blueprint9 = {
+  key: BLUEPRINT_KEY9,
+  make: make10
+};
+var blueprint_default10 = blueprint9;
+
+// src/blueprints/project-wizard/blueprint.ts
+import { Blueprint as Blueprint10, Template as Template2 } from "@dxos/compute";
+import { trim as trim8 } from "@dxos/util";
+
+// src/blueprints/project-wizard/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet8 } from "@dxos/compute";
+var AgentWizardHandlers = OperationHandlerSet8.lazy(() => import("./create-project-3AGXJ4TD.mjs"), () => import("./project-rules-KSVSOZJV.mjs"), () => import("./sync-triggers-NOIQLELD.mjs"));
+
+// src/blueprints/project-wizard/blueprint.ts
+var BLUEPRINT_KEY10 = "org.dxos.blueprint.agent-wizard";
+var make11 = () => Blueprint10.make({
+  key: BLUEPRINT_KEY10,
+  name: "Agent Wizard",
+  description: "Help the user create a new agent (subscriptions, optional cron timer, sync-triggers after edits).",
+  agentCanEnable: true,
+  instructions: Template2.make({
+    source: trim8`
+        You are a wizard that helps the user create a new agent.
+
+        Agents are goal oriented and autonomously driven.
+        Each agent has instructions - the goal of the agent.
+        The instructions also typically describe what actions to perform in reaction to events (emails).
+        The agent has a number of associated artifacts to work with.
+        Agents can subscribe to emails.
+
+        Agents have a \`cron\` field: when set, the agent runs on a timer on that schedule (standard cron syntax).
+        Use \`cron\` when the user wants the agent to run periodically (e.g. "every morning", "once a day", "every 5 minutes").
+        Examples: \`0 9 * * *\` for daily at 09:00, or \`*/5 * * * *\` for every 5 minutes.
+        Timer triggers bypass the qualifier and invoke the agent worker directly on the schedule.
+
+        The agent itself is an ECHO object and can be edited like any other object using the database blueprint.
+        You can edit the agent's instructions, name, and other properties directly.
+        If you edit the agent's \`enabled\` field, \`filterEvents\` field, subscriptions array, or \`cron\` field, you MUST call the sync-triggers function afterward to synchronize the triggers (\`enabled\` is applied to all triggers).
+
+        IMPORTANT: Before attempting to create an agent call the [agent-rules] tool to get the rules for creating an agent.
+      `
+  }),
+  tools: Blueprint10.toolDefinitions({
+    operations: [
+      AgentRules,
+      CreateAgent,
+      SyncTriggers
+    ]
+  })
+});
+var blueprint10 = {
+  key: BLUEPRINT_KEY10,
+  make: make11
+};
+var blueprint_default11 = blueprint10;
+
+// src/crud/graph.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Toolkit2 from "@effect/ai/Toolkit";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Database, Entity, Feed, Filter, Obj, Query as Query2, Type } from "@dxos/echo";
+import { isEncodedReference } from "@dxos/echo-protocol";
+import { ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId, createObject, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/internal";
+import { mapAst } from "@dxos/effect";
+import { DXN, ObjectId } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { deepMapValues, isNonNullable, trim as trim9 } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant-toolkit/src/crud/graph.ts";
+var Subgraph = Schema.Struct({
+  /** Objects and relations. */
+  objects: Schema.Array(Schema.Any)
+});
+var findRelatedSchema = async (db, anchor) => {
+  const allSchemas = await db.graph.schemaRegistry.query().run();
+  return allSchemas.filter((schema) => {
+    if (getTypeAnnotation(schema)?.kind !== Entity.Kind.Relation) {
+      return false;
+    }
+    return isSchemaAddressableByDXN(anchor, DXN.parse(getTypeAnnotation(schema).sourceSchema)) || isSchemaAddressableByDXN(anchor, DXN.parse(getTypeAnnotation(schema).targetSchema));
+  }).map((schema) => ({
+    kind: "relation",
+    schema
+  }));
+};
+var isSchemaAddressableByDXN = (schema, dxn) => {
+  if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
+    return true;
+  }
+  const t = dxn.asTypeDXN();
+  if (t) {
+    return t.type === Type.getTypename(schema);
+  }
+  return false;
+};
+var LocalSearchToolkit = Toolkit2.make(Tool.make("search_local_search", {
+  description: "Search the local database for information using a vector index",
+  parameters: {
+    query: Schema.String.annotations({
+      description: "The query to search for. Could be a question or a topic or a set of keywords."
+    })
+  },
+  success: Schema.Unknown,
+  failure: Schema.Never,
+  dependencies: [
+    Database.Service,
+    Feed.FeedService
+  ]
+}));
+var LocalSearchHandler = LocalSearchToolkit.toLayer({
+  search_local_search: Effect.fn(function* ({ query }) {
+    const objects = yield* Database.runQuery(Query2.select(Filter.text(query, {
+      type: "vector"
+    })));
+    const results = [
+      ...objects
+    ];
+    const feedOption = yield* Effect.serviceOption(Feed.ContextFeedService);
+    if (Option.isSome(feedOption)) {
+      const feedObjects = yield* Feed.runQuery(feedOption.value.feed, Filter.everything());
+      results.push(...feedObjects);
+    }
+    return trim9`
+      <local_context>
+        ${JSON.stringify(results, null, 2)}
+      </local_context>
+    `;
+  })
+});
+var GraphWriterSchema = class extends Context.Tag("@dxos/assistant/GraphWriterSchema")() {
+};
+var makeGraphWriterToolkit = ({ schema }) => {
+  return Toolkit2.make(Tool.make("graph_writer", {
+    description: "Write to the local graph database",
+    parameters: createExtractionSchema(schema).fields,
+    success: Schema.Unknown,
+    failure: Schema.Never,
+    dependencies: [
+      Database.Service,
+      Feed.ContextFeedService,
+      Feed.FeedService
+    ]
+  }).annotateContext(Context.make(GraphWriterSchema, {
+    schema
+  })));
+};
+var makeGraphWriterHandler = (toolkit, { onAppend } = {}) => {
+  const { schema } = Context.get(toolkit.tools.graph_writer.annotations, GraphWriterSchema);
+  return toolkit.toLayer({
+    graph_writer: Effect.fn(function* (input) {
+      const { db } = yield* Database.Service;
+      const { feed } = yield* Feed.ContextFeedService;
+      const data = yield* sanitizeObjects(schema, input, db, feed);
+      yield* Feed.append(feed, data);
+      const dxns = data.map((obj) => Obj.getDXN(obj));
+      onAppend?.(dxns);
+      return dxns;
+    })
+  });
+};
+var createExtractionSchema = (types) => {
+  return Schema.Struct({
+    ...Object.fromEntries(types.map(preprocessSchema).map((schema, index) => [
+      `objects_${getSanitizedSchemaName(types[index])}`,
+      Schema.optional(Schema.Array(schema)).annotations({
+        description: `The objects of type: ${Type.getDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ""))}`
+      })
+    ]))
+  });
+};
+var getSanitizedSchemaName = (schema) => {
+  return Type.getDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
+};
+var sanitizeObjects = (types, data, db, feed) => Effect.gen(function* () {
+  const entries = types.map((type) => data[`objects_${getSanitizedSchemaName(type)}`]?.map((object) => ({
+    data: object,
+    schema: type
+  })) ?? []).flat();
+  const idMap = /* @__PURE__ */ new Map();
+  const existingIds = /* @__PURE__ */ new Set();
+  const enitties = /* @__PURE__ */ new Map();
+  const resolveId = (id) => {
+    if (ObjectId.isValid(id)) {
+      existingIds.add(id);
+      return DXN.fromLocalObjectId(id);
+    }
+    const mappedId = idMap.get(id);
+    if (mappedId) {
+      return DXN.fromLocalObjectId(mappedId);
+    }
+    return void 0;
+  };
+  const res = entries.map((entry) => {
+    if (ObjectId.isValid(entry.data.id)) {
+      return entry;
+    }
+    idMap.set(entry.data.id, ObjectId.random());
+    entry.data.id = idMap.get(entry.data.id);
+    return entry;
+  }).map((entry) => {
+    const data2 = deepMapValues(entry.data, (value, recurse) => {
+      if (isEncodedReference(value)) {
+        const ref = value["/"];
+        const id = resolveId(ref);
+        if (id) {
+          return {
+            "/": id.toString()
+          };
+        } else {
+          return {
+            "/": `search:?q=${encodeURIComponent(ref)}`
+          };
+        }
+      }
+      return recurse(value);
+    });
+    if (Entity.getKind(entry.schema) === "relation") {
+      const sourceDXN = resolveId(data2.source);
+      if (!sourceDXN) {
+        log.warn("source not found", {
+          source: data2.source
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 193, S: this });
+      }
+      const targetDXN = resolveId(data2.target);
+      if (!targetDXN) {
+        log.warn("target not found", {
+          target: data2.target
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 199, S: this });
+      }
+      delete data2.source;
+      delete data2.target;
+      data2[RelationSourceDXNId] = sourceDXN;
+      data2[RelationTargetDXNId] = targetDXN;
+    }
+    return {
+      data: data2,
+      schema: entry.schema
+    };
+  }).filter((object) => !existingIds.has(object.data.id));
+  const dbObjects = yield* Effect.promise(() => db.query(Query2.select(Filter.id(...existingIds))).run());
+  const feedObjects = feed && existingIds.size > 0 ? yield* Feed.runQuery(feed, Filter.id(...existingIds)) : [];
+  const objects = [
+    ...dbObjects,
+    ...feedObjects
+  ].filter(isNonNullable);
+  log.info("objects", {
+    dbObjects,
+    feedObjects,
+    existingIds
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 221, S: this });
+  const missing = Array.from(existingIds).filter((id) => !objects.some((object) => object.id === id));
+  if (missing.length > 0) {
+    throw new Error(`Object IDs do not point to existing objects: ${missing.join(", ")}`);
+  }
+  return res.flatMap(({ data: data2, schema }) => {
+    let skip = false;
+    if (RelationSourceDXNId in data2) {
+      const id = data2[RelationSourceDXNId].asEchoDXN()?.echoId;
+      const obj = objects.find((object) => object.id === id) ?? enitties.get(id);
+      if (obj) {
+        delete data2[RelationSourceDXNId];
+        data2[RelationSourceId] = obj;
+      } else {
+        skip = true;
+      }
+    }
+    if (RelationTargetDXNId in data2) {
+      const id = data2[RelationTargetDXNId].asEchoDXN()?.echoId;
+      const obj = objects.find((object) => object.id === id) ?? enitties.get(id);
+      if (obj) {
+        delete data2[RelationTargetDXNId];
+        data2[RelationTargetId] = obj;
+      } else {
+        skip = true;
+      }
+    }
+    if (!skip) {
+      const obj = createObject(schema, data2);
+      enitties.set(obj.id, obj);
+      return [
+        obj
+      ];
+    }
+    return [];
+  });
+});
+var SoftRef = Schema.Struct({
+  "/": Schema.String
+}).annotations({
+  description: "Reference to another object."
+});
+var preprocessSchema = (schema) => {
+  const isRelationSchema = Entity.getKind(schema) === "relation";
+  const go = (ast, visited = /* @__PURE__ */ new Set()) => {
+    if (visited.has(ast)) {
+      return ast;
+    }
+    visited.add(ast);
+    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
+      return SoftRef.ast;
+    }
+    return mapAst(ast, (child) => go(child, visited));
+  };
+  return Schema.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema.omit("id"), Schema.extend(Schema.Struct({
+    id: Schema.String.annotations({
+      description: "The id of this object. Come up with a unique id based on your judgement."
+    })
+  })), isRelationSchema ? Schema.extend(Schema.Struct({
+    source: Schema.String.annotations({
+      description: "The id of the source object for this relation."
+    }),
+    target: Schema.String.annotations({
+      description: "The id of the target object for this relation."
+    })
+  })) : Function.identity);
+};
+
+// src/functions/agent/index.ts
+import { OperationHandlerSet as OperationHandlerSet9 } from "@dxos/compute";
+var AgentHandlers = OperationHandlerSet9.lazy(() => import("./prompt-INL55Q2B.mjs"));
+
+// src/toolkits/WebToolkit.ts
+var WebToolkit_exports = {};
+__export(WebToolkit_exports, {
+  WebToolkit: () => WebToolkit,
+  layer: () => layer
+});
+import * as AnthropicTool2 from "@effect/ai-anthropic/AnthropicTool";
+import * as Tool2 from "@effect/ai/Tool";
+import * as Toolkit3 from "@effect/ai/Toolkit";
+import * as Effect2 from "effect/Effect";
+import * as Schema2 from "effect/Schema";
+var WebToolkit = Toolkit3.make(AnthropicTool2.WebSearch_20250305({}).pipe(), Tool2.make("WebFetch", {
+  parameters: {
+    url: Schema2.String
+  },
+  success: Schema2.String
+}));
+var layer = WebToolkit.toLayer({
+  WebFetch: Effect2.fnUntraced(function* ({ url }) {
+    const response = yield* Effect2.promise(() => fetch(url).then((response2) => response2.text()));
+    return response;
+  })
+});
+export {
+  AddArtifact,
+  Agent_exports as Agent,
+  blueprint_default as AgentBlueprint,
+  AgentBlueprintHandlers,
+  AgentHandlers,
+  AgentPrompt,
+  AgentRules,
+  blueprint_default11 as AgentWizardBlueprint,
+  AgentWizardHandlers,
+  AgentWorker,
+  blueprint_default9 as AutomationBlueprint,
+  blueprint_default10 as BlueprintManagerBlueprint,
+  BlueprintManagerHandlers,
+  blueprint_default6 as BrowserBlueprint,
+  Chat_exports as Chat,
+  ContextAdd,
+  ContextRemove,
+  CreateAgent,
+  blueprint_default7 as DatabaseBlueprint,
+  DatabaseHandlers,
+  Load as DatabaseLoad,
+  Query as DatabaseQuery,
+  DeleteMemory,
+  blueprint_default2 as DiscordBlueprint,
+  DiscordHandlers,
+  EnableBlueprints,
+  FetchMessages,
+  GetContext,
+  blueprint_default3 as LinearBlueprint,
+  LinearHandlers,
+  LocalSearchHandler,
+  LocalSearchToolkit,
+  McpServer_exports as McpServer,
+  Memory_exports as Memory,
+  blueprint_default8 as MemoryBlueprint,
+  MemoryHandlers,
+  ObjectCreate,
+  ObjectDelete,
+  ObjectUpdate,
+  Plan_exports as Plan,
+  blueprint_default4 as PlanningBlueprint,
+  PlanningHandlers,
+  UpdateTasks as PlanningUpdateTasks,
+  Qualifier,
+  QueryBlueprints,
+  QueryMemories,
+  RelationCreate,
+  RelationDelete,
+  SaveMemory,
+  SchemaAdd,
+  SchemaList,
+  Subgraph,
+  SyncIssues,
+  SyncTriggers,
+  TagAdd,
+  TagRemove,
+  blueprint_default5 as WebSearchBlueprint,
+  Fetch as WebSearchFetch,
+  WebSearchHandlers,
+  WebSearchToolkit,
+  WebSearchToolkitOpaque,
+  WebToolkit_exports as WebToolkit,
+  createExtractionSchema,
+  findRelatedSchema,
+  getSanitizedSchemaName,
+  makeGraphWriterHandler,
+  makeGraphWriterToolkit,
+  sanitizeObjects,
+  syncObjects
+};
+//# sourceMappingURL=index.mjs.map