@dxos/assistant-toolkit 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/dist/lib/neutral/chunk-TKJH3CAH.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/agent/definitions.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { AiService, GenericToolkit, ModelName } from '@dxos/ai';\nimport { Prompt } from '@dxos/blueprints';\nimport { Database, Feed, Ref } from '@dxos/echo';\nimport { Trace } from '@dxos/functions';\nimport { Operation, OperationRegistry } from '@dxos/operation';\n\nimport * as Chat from '../../types/Chat';\n\nexport const AgentPrompt = Operation.make({\n  meta: {\n    key: 'org.dxos.function.prompt',\n    name: 'Agent',\n    description: 'Agentic worker that executes a provided prompt using blueprints and tools.',\n  },\n  input: Schema.Struct({\n    prompt: Ref.Ref(Prompt.Prompt),\n\n    /**\n     * When set, runs in this chat (history, queue, and bound context). Prompt blueprints and context objects are merged into the conversation for this request.\n     */\n    chat: Schema.optional(Ref.Ref(Chat.Chat)),\n\n    /**\n     * @default @anthropic/claude-opus-4-6\n     */\n\n    model: Schema.optional(ModelName),\n    /**\n     * Input object or data.\n     * References get auto-resolved.\n     */\n    input: Schema.Any.pipe(Schema.annotations({ title: 'Input' })),\n\n    systemInstructions: Schema.optional(Schema.String).annotations({\n      description: 'Additional system instructions to add to the system prompt.',\n    }),\n  }),\n  output: Schema.Any,\n  services: [\n    AiService.AiService,\n    Database.Service,\n    Feed.FeedService,\n    GenericToolkit.GenericToolkitProvider,\n    OperationRegistry.Service,\n    Trace.TraceService,\n  ],\n});\n"],
+  "mappings": ";;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,WAAWC,gBAAgBC,iBAAiB;AACrD,SAASC,cAAc;AACvB,SAASC,UAAUC,MAAMC,WAAW;AACpC,SAASC,aAAa;AACtB,SAASC,WAAWC,yBAAyB;AAItC,IAAMC,cAAcC,UAAUC,KAAK;EACxCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBC,QAAQC,IAAIA,IAAIC,OAAOA,MAAM;;;;IAK7BC,MAAaC,gBAASH,IAAIA,IAASI,IAAI,CAAA;;;;IAMvCC,OAAcF,gBAASG,SAAAA;;;;;IAKvBT,OAAcU,WAAIC,KAAYC,mBAAY;MAAEC,OAAO;IAAQ,CAAA,CAAA;IAE3DC,oBAA2BR,gBAAgBS,aAAM,EAAEH,YAAY;MAC7Db,aAAa;IACf,CAAA;EACF,CAAA;EACAiB,QAAeN;EACfO,UAAU;IACRC,UAAUA;IACVC,SAASC;IACTC,KAAKC;IACLC,eAAeC;IACfC,kBAAkBL;IAClBM,MAAMC;;AAEV,CAAA;",
+  "names": ["Schema", "AiService", "GenericToolkit", "ModelName", "Prompt", "Database", "Feed", "Ref", "Trace", "Operation", "OperationRegistry", "AgentPrompt", "Operation", "make", "meta", "key", "name", "description", "input", "Struct", "prompt", "Ref", "Prompt", "chat", "optional", "Chat", "model", "ModelName", "Any", "pipe", "annotations", "title", "systemInstructions", "String", "output", "services", "AiService", "Database", "Service", "Feed", "FeedService", "GenericToolkit", "GenericToolkitProvider", "OperationRegistry", "Trace", "TraceService"]
+}

package/dist/lib/neutral/chunk-U26AX7D7.mjs

@@ -0,0 +1,76 @@
+import {
+  Project_exports
+} from "./chunk-2SH4XUQR.mjs";
+
+// src/blueprints/project-wizard/functions/definitions.ts
+import * as Schema from "effect/Schema";
+import { Blueprint } from "@dxos/blueprints";
+import { Database, Feed, Obj, Ref } from "@dxos/echo";
+import { QueueService } from "@dxos/functions";
+import { Operation } from "@dxos/operation";
+var ProjectRules = Operation.make({
+  meta: {
+    key: "org.dxos.function.project-wizard.project-rules",
+    name: "Project rules",
+    description: "Gets the rules for creating a project."
+  },
+  input: Schema.Struct({}),
+  output: Schema.String
+});
+var CreateProject = Operation.make({
+  meta: {
+    key: "org.dxos.function.project-wizard.create-project",
+    name: "Create project",
+    description: "Creates a new project."
+  },
+  input: Schema.Struct({
+    name: Schema.String.annotations({
+      description: "The name of the project to create."
+    }),
+    spec: Schema.String.annotations({
+      description: "The goal of the project. Be specic but not to verbose. The agent will use this as a core objective and set of rules to follow."
+    }),
+    blueprints: Schema.Array(Schema.String).annotations({
+      description: "The keys blueprints to use for the project.",
+      examples: [
+        [
+          "org.dxos.blueprint.markdown",
+          "org.dxos.blueprint.database"
+        ]
+      ]
+    }),
+    subscriptions: Schema.Array(Ref.Ref(Obj.Unknown)).annotations({
+      description: "The objects to subscribe to for the project. Can be references to mailboxes."
+    })
+  }),
+  output: Project_exports.Project,
+  services: [
+    Blueprint.RegistryService,
+    Database.Service,
+    QueueService,
+    Feed.FeedService
+  ]
+});
+var SyncTriggers = Operation.make({
+  meta: {
+    key: "org.dxos.function.project.sync-triggers",
+    name: "Sync triggers",
+    description: "Synchronizes triggers in the database with the project subscriptions. Call this after editing the subscriptions array."
+  },
+  input: Schema.Struct({
+    project: Ref.Ref(Project_exports.Project).annotations({
+      description: "The project whose triggers should be synced."
+    })
+  }),
+  output: Schema.Void,
+  services: [
+    Database.Service
+  ]
+});
+
+export {
+  ProjectRules,
+  CreateProject,
+  SyncTriggers
+};
+//# sourceMappingURL=chunk-U26AX7D7.mjs.map

package/dist/lib/neutral/chunk-U26AX7D7.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/blueprints/project-wizard/functions/definitions.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Blueprint } from '@dxos/blueprints';\nimport { Database, Feed, Obj, Ref } from '@dxos/echo';\nimport { QueueService } from '@dxos/functions';\nimport { Operation } from '@dxos/operation';\n\nimport { Project } from '../../../types';\n\nexport const ProjectRules = Operation.make({\n  meta: {\n    key: 'org.dxos.function.project-wizard.project-rules',\n    name: 'Project rules',\n    description: 'Gets the rules for creating a project.',\n  },\n  input: Schema.Struct({}),\n  output: Schema.String,\n});\n\nexport const CreateProject = Operation.make({\n  meta: {\n    key: 'org.dxos.function.project-wizard.create-project',\n    name: 'Create project',\n    description: 'Creates a new project.',\n  },\n  input: Schema.Struct({\n    name: Schema.String.annotations({\n      description: 'The name of the project to create.',\n    }),\n    spec: Schema.String.annotations({\n      description:\n        'The goal of the project. Be specic but not to verbose. The agent will use this as a core objective and set of rules to follow.',\n    }),\n    blueprints: Schema.Array(Schema.String).annotations({\n      description: 'The keys blueprints to use for the project.',\n      examples: [['org.dxos.blueprint.markdown', 'org.dxos.blueprint.database']],\n    }),\n    subscriptions: Schema.Array(Ref.Ref(Obj.Unknown)).annotations({\n      description: 'The objects to subscribe to for the project. Can be references to mailboxes.',\n    }),\n  }),\n  output: Project.Project,\n  services: [Blueprint.RegistryService, Database.Service, QueueService, Feed.FeedService],\n});\n\nexport const SyncTriggers = Operation.make({\n  meta: {\n    key: 'org.dxos.function.project.sync-triggers',\n    name: 'Sync triggers',\n    description:\n      'Synchronizes triggers in the database with the project subscriptions. Call this after editing the subscriptions array.',\n  },\n  input: Schema.Struct({\n    project: Ref.Ref(Project.Project).annotations({\n      description: 'The project whose triggers should be synced.',\n    }),\n  }),\n  output: Schema.Void,\n  services: [Database.Service],\n});\n"],
+  "mappings": ";;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,UAAUC,MAAMC,KAAKC,WAAW;AACzC,SAASC,oBAAoB;AAC7B,SAASC,iBAAiB;AAInB,IAAMC,eAAeC,UAAUC,KAAK;EACzCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO,CAAC,CAAA;EACtBC,QAAeC;AACjB,CAAA;AAEO,IAAMC,gBAAgBV,UAAUC,KAAK;EAC1CC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBH,MAAaK,cAAOE,YAAY;MAC9BN,aAAa;IACf,CAAA;IACAO,MAAaH,cAAOE,YAAY;MAC9BN,aACE;IACJ,CAAA;IACAQ,YAAmBC,aAAaL,aAAM,EAAEE,YAAY;MAClDN,aAAa;MACbU,UAAU;QAAC;UAAC;UAA+B;;;IAC7C,CAAA;IACAC,eAAsBF,aAAMG,IAAIA,IAAIC,IAAIC,OAAO,CAAA,EAAGR,YAAY;MAC5DN,aAAa;IACf,CAAA;EACF,CAAA;EACAG,QAAQY,gBAAQA;EAChBC,UAAU;IAACC,UAAUC;IAAiBC,SAASC;IAASC;IAAcC,KAAKC;;AAC7E,CAAA;AAEO,IAAMC,eAAe7B,UAAUC,KAAK;EACzCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aACE;EACJ;EACAC,OAAcC,cAAO;IACnBuB,SAASb,IAAIA,IAAIG,gBAAQA,OAAO,EAAET,YAAY;MAC5CN,aAAa;IACf,CAAA;EACF,CAAA;EACAG,QAAeuB;EACfV,UAAU;IAACG,SAASC;;AACtB,CAAA;",
+  "names": ["Schema", "Blueprint", "Database", "Feed", "Obj", "Ref", "QueueService", "Operation", "ProjectRules", "Operation", "make", "meta", "key", "name", "description", "input", "Struct", "output", "String", "CreateProject", "annotations", "spec", "blueprints", "Array", "examples", "subscriptions", "Ref", "Obj", "Unknown", "Project", "services", "Blueprint", "RegistryService", "Database", "Service", "QueueService", "Feed", "FeedService", "SyncTriggers", "project", "Void"]
+}

package/dist/lib/neutral/chunk-VBSCQN37.mjs

@@ -0,0 +1,52 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/types/Chat.ts
+var Chat_exports = {};
+__export(Chat_exports, {
+  Chat: () => Chat,
+  CompanionTo: () => CompanionTo,
+  LegacyCompanionTo: () => LegacyCompanionTo,
+  make: () => make
+});
+import * as Schema from "effect/Schema";
+import { Annotation, Feed, Obj, Ref, Type } from "@dxos/echo";
+import { FormInputAnnotation, LabelAnnotation } from "@dxos/echo/internal";
+var Chat = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  feed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false))
+}).pipe(Type.object({
+  typename: "org.dxos.type.assistant.chat",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "name"
+]), Annotation.IconAnnotation.set({
+  icon: "ph--atom--regular",
+  hue: "sky"
+}));
+var make = (props) => Obj.make(Chat, props);
+var LegacyCompanionTo = Schema.Struct({
+  id: Obj.ID
+}).pipe(Type.relation({
+  typename: "org.dxos.relation.assistant.companion-to",
+  version: "0.1.0",
+  source: Chat,
+  target: Obj.Unknown
+}));
+var CompanionTo = Schema.Struct({
+  id: Obj.ID
+}).pipe(Type.relation({
+  typename: "org.dxos.relation.assistant.companionTo",
+  version: "0.1.0",
+  source: Chat,
+  target: Obj.Unknown
+}));
+
+export {
+  Chat,
+  make,
+  CompanionTo,
+  Chat_exports
+};
+//# sourceMappingURL=chunk-VBSCQN37.mjs.map

package/dist/lib/neutral/chunk-VBSCQN37.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/Chat.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { Annotation, Feed, Obj, Ref, Type } from '@dxos/echo';\nimport { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';\n\n/**\n * AI chat.\n */\nexport const Chat = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n  feed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false)),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.assistant.chat',\n    version: '0.1.0',\n  }),\n  LabelAnnotation.set(['name']),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--atom--regular',\n    hue: 'sky',\n  }),\n);\n\nexport interface Chat extends Schema.Schema.Type<typeof Chat> {}\n\nexport const make = (props: Obj.MakeProps<typeof Chat>) => Obj.make(Chat, props);\n\n/** @deprecated Use CompanionTo instead. */\nexport const LegacyCompanionTo = Schema.Struct({\n  id: Obj.ID,\n}).pipe(\n  Type.relation({\n    typename: 'org.dxos.relation.assistant.companion-to',\n    version: '0.1.0',\n    source: Chat,\n    target: Obj.Unknown,\n  }),\n);\n\nexport interface LegacyCompanionTo extends Schema.Schema.Type<typeof LegacyCompanionTo> {}\n\n/**\n * Relation between a Chat and companion objects (e.g., artifacts).\n */\nexport const CompanionTo = Schema.Struct({\n  id: Obj.ID,\n}).pipe(\n  Type.relation({\n    typename: 'org.dxos.relation.assistant.companionTo',\n    version: '0.1.0',\n    source: Chat,\n    target: Obj.Unknown,\n  }),\n);\n\nexport interface CompanionTo extends Schema.Schema.Type<typeof CompanionTo> {}\n"],
+  "mappings": ";;;;;AAAA;;;;;;;AAMA,YAAYA,YAAY;AAExB,SAASC,YAAYC,MAAMC,KAAKC,KAAKC,YAAY;AACjD,SAASC,qBAAqBC,uBAAuB;AAK9C,IAAMC,OAAcC,cAAO;EAChCC,MAAaC,cAAOC,KAAYC,eAAQ;EACxCC,MAAMC,IAAIA,IAAIC,KAAKA,IAAI,EAAEJ,KAAKK,oBAAoBC,IAAI,KAAA,CAAA;AACxD,CAAA,EAAGN,KACDO,KAAKC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACAC,gBAAgBL,IAAI;EAAC;CAAO,GAC5BM,WAAWC,eAAeP,IAAI;EAC5BQ,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAKK,IAAMC,OAAO,CAACC,UAAsCC,IAAIF,KAAKpB,MAAMqB,KAAAA;AAGnE,IAAME,oBAA2BtB,cAAO;EAC7CuB,IAAIF,IAAIG;AACV,CAAA,EAAGrB,KACDO,KAAKe,SAAS;EACZb,UAAU;EACVC,SAAS;EACTa,QAAQ3B;EACR4B,QAAQN,IAAIO;AACd,CAAA,CAAA;AAQK,IAAMC,cAAqB7B,cAAO;EACvCuB,IAAIF,IAAIG;AACV,CAAA,EAAGrB,KACDO,KAAKe,SAAS;EACZb,UAAU;EACVC,SAAS;EACTa,QAAQ3B;EACR4B,QAAQN,IAAIO;AACd,CAAA,CAAA;",
+  "names": ["Schema", "Annotation", "Feed", "Obj", "Ref", "Type", "FormInputAnnotation", "LabelAnnotation", "Chat", "Struct", "name", "String", "pipe", "optional", "feed", "Ref", "Feed", "FormInputAnnotation", "set", "Type", "object", "typename", "version", "LabelAnnotation", "Annotation", "IconAnnotation", "icon", "hue", "make", "props", "Obj", "LegacyCompanionTo", "id", "ID", "relation", "source", "target", "Unknown", "CompanionTo"]
+}

package/dist/lib/neutral/chunk-VDEDVOS6.mjs

@@ -0,0 +1,39 @@
+// src/functions/exa/definitions.ts
+import * as Schema from "effect/Schema";
+import { CredentialsService } from "@dxos/functions";
+import { Operation } from "@dxos/operation";
+var ExaSearch = Operation.make({
+  meta: {
+    key: "org.dxos.function.exa-search",
+    name: "Exa Search",
+    description: "Search the web for information"
+  },
+  input: Schema.Struct({
+    query: Schema.String.annotations({
+      description: "The query to search for."
+    })
+  }),
+  output: Schema.Unknown,
+  services: [
+    CredentialsService
+  ]
+});
+var ExaMock = Operation.make({
+  meta: {
+    key: "org.dxos.function.exa-mock",
+    name: "Exa mock",
+    description: "Search the web for information"
+  },
+  input: Schema.Struct({
+    query: Schema.String.annotations({
+      description: "The query to search for."
+    })
+  }),
+  output: Schema.Unknown
+});
+
+export {
+  ExaSearch,
+  ExaMock
+};
+//# sourceMappingURL=chunk-VDEDVOS6.mjs.map

package/dist/lib/neutral/chunk-VDEDVOS6.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/exa/definitions.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { CredentialsService } from '@dxos/functions';\nimport { Operation } from '@dxos/operation';\n\nexport const ExaSearch = Operation.make({\n  meta: {\n    key: 'org.dxos.function.exa-search',\n    name: 'Exa Search',\n    description: 'Search the web for information',\n  },\n  input: Schema.Struct({\n    query: Schema.String.annotations({\n      description: 'The query to search for.',\n    }),\n  }),\n  output: Schema.Unknown,\n  services: [CredentialsService],\n});\n\nexport const ExaMock = Operation.make({\n  meta: {\n    key: 'org.dxos.function.exa-mock',\n    name: 'Exa mock',\n    description: 'Search the web for information',\n  },\n  input: Schema.Struct({\n    query: Schema.String.annotations({\n      description: 'The query to search for.',\n    }),\n  }),\n  output: Schema.Unknown,\n});\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAExB,SAASC,0BAA0B;AACnC,SAASC,iBAAiB;AAEnB,IAAMC,YAAYC,UAAUC,KAAK;EACtCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBC,OAAcC,cAAOC,YAAY;MAC/BL,aAAa;IACf,CAAA;EACF,CAAA;EACAM,QAAeC;EACfC,UAAU;IAACC;;AACb,CAAA;AAEO,IAAMC,UAAUf,UAAUC,KAAK;EACpCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBC,OAAcC,cAAOC,YAAY;MAC/BL,aAAa;IACf,CAAA;EACF,CAAA;EACAM,QAAeC;AACjB,CAAA;",
+  "names": ["Schema", "CredentialsService", "Operation", "ExaSearch", "Operation", "make", "meta", "key", "name", "description", "input", "Struct", "query", "String", "annotations", "output", "Unknown", "services", "CredentialsService", "ExaMock"]
+}

package/dist/lib/neutral/chunk-VHYUC3HO.mjs

@@ -0,0 +1,70 @@
+import {
+  AddArtifact
+} from "./chunk-B2PLQKOJ.mjs";
+
+// src/blueprints/project/blueprint.ts
+import { Blueprint, Template } from "@dxos/blueprints";
+import { trim } from "@dxos/util";
+
+// src/blueprints/project/functions/index.ts
+import { OperationHandlerSet } from "@dxos/operation";
+var ProjectHandlers = OperationHandlerSet.lazy(() => import("./add-artifact-W2CRMEAZ.mjs"), () => import("./agent-CT44JSYM.mjs"), () => import("./get-context-LUOU7M3Z.mjs"), () => import("./qualifier-KIBSTV6F.mjs"));
+
+// src/blueprints/project/blueprint.ts
+var BLUEPRINT_KEY = "org.dxos.blueprint.project";
+var make = () => Blueprint.make({
+  key: BLUEPRINT_KEY,
+  name: "Project blueprint",
+  instructions: Template.make({
+    source: trim`
+        You work on an project. Each project has a spec - the goal of the project.
+        The project plan shows the current progress of the project.
+        Project has an number of associated artifacts you can read/write.
+        You can edit them if necessary.
+
+        IMPORTANT: When creating a new artifact, always add it to the project using the add-artifact function.
+
+        {{#with project}}
+        <project id="{{id}}" name="{{name}}">
+          <spec>
+            {{spec}}
+          </spec>
+          <plan>
+            {{plan}}
+          </plan>
+
+          <artifacts>
+          {{#each artifacts}}
+            <artifact type="{{type}}" dxn="{{dxn}}">
+              {{name}}
+            </artifact>
+          {{/each}}
+          </artifacts>
+        </project>
+        {{/with}}
+      `,
+    inputs: [
+      {
+        name: "project",
+        kind: "function",
+        function: "org.dxos.function.project.get-context"
+      }
+    ]
+  }),
+  tools: Blueprint.toolDefinitions({
+    operations: [
+      AddArtifact
+    ]
+  })
+});
+var blueprint = {
+  key: BLUEPRINT_KEY,
+  make
+};
+var blueprint_default = blueprint;
+
+export {
+  ProjectHandlers,
+  blueprint_default
+};
+//# sourceMappingURL=chunk-VHYUC3HO.mjs.map

package/dist/lib/neutral/chunk-VHYUC3HO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/blueprints/project/blueprint.ts", "../../../src/blueprints/project/functions/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { type AppCapabilities } from '@dxos/app-toolkit';\nimport { Blueprint, Template } from '@dxos/blueprints';\nimport { trim } from '@dxos/util';\n\nimport { AddArtifact } from './functions';\n\nconst BLUEPRINT_KEY = 'org.dxos.blueprint.project';\n\n/**\n * Creates the Project blueprint. This is a function to avoid circular dependency issues.\n */\n// TODO(dmaretskyi): Combine with Project Wizard\nconst make = () =>\n  Blueprint.make({\n    key: BLUEPRINT_KEY,\n    name: 'Project blueprint',\n    instructions: Template.make({\n      source: trim`\n        You work on an project. Each project has a spec - the goal of the project.\n        The project plan shows the current progress of the project.\n        Project has an number of associated artifacts you can read/write.\n        You can edit them if necessary.\n\n        IMPORTANT: When creating a new artifact, always add it to the project using the add-artifact function.\n\n        {{#with project}}\n        <project id=\"{{id}}\" name=\"{{name}}\">\n          <spec>\n            {{spec}}\n          </spec>\n          <plan>\n            {{plan}}\n          </plan>\n\n          <artifacts>\n          {{#each artifacts}}\n            <artifact type=\"{{type}}\" dxn=\"{{dxn}}\">\n              {{name}}\n            </artifact>\n          {{/each}}\n          </artifacts>\n        </project>\n        {{/with}}\n      `,\n      inputs: [\n        {\n          name: 'project',\n          kind: 'function',\n          function: 'org.dxos.function.project.get-context',\n        },\n      ],\n    }),\n    tools: Blueprint.toolDefinitions({ operations: [AddArtifact] }),\n  });\n\nconst blueprint: AppCapabilities.BlueprintDefinition = {\n  key: BLUEPRINT_KEY,\n  make,\n};\n\nexport default blueprint;\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { OperationHandlerSet } from '@dxos/operation';\n\nexport * from './definitions';\n\nexport const ProjectHandlers = OperationHandlerSet.lazy(\n  () => import('./add-artifact'),\n  () => import('./agent'),\n  () => import('./get-context'),\n  () => import('./qualifier'),\n);\n"],
+  "mappings": ";;;;;AAKA,SAASA,WAAWC,gBAAgB;AACpC,SAASC,YAAY;;;ACFrB,SAASC,2BAA2B;AAI7B,IAAMC,kBAAkBC,oBAAoBC,KACjD,MAAM,OAAO,6BAAA,GACb,MAAM,OAAO,sBAAA,GACb,MAAM,OAAO,4BAAA,GACb,MAAM,OAAO,0BAAA,CAAA;;;ADFf,IAAMC,gBAAgB;AAMtB,IAAMC,OAAO,MACXC,UAAUD,KAAK;EACbE,KAAKH;EACLI,MAAM;EACNC,cAAcC,SAASL,KAAK;IAC1BM,QAAQC;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BRC,QAAQ;MACN;QACEL,MAAM;QACNM,MAAM;QACNC,UAAU;MACZ;;EAEJ,CAAA;EACAC,OAAOV,UAAUW,gBAAgB;IAAEC,YAAY;MAACC;;EAAa,CAAA;AAC/D,CAAA;AAEF,IAAMC,YAAiD;EACrDb,KAAKH;EACLC;AACF;AAEA,IAAA,oBAAee;",
+  "names": ["Blueprint", "Template", "trim", "OperationHandlerSet", "ProjectHandlers", "OperationHandlerSet", "lazy", "BLUEPRINT_KEY", "make", "Blueprint", "key", "name", "instructions", "Template", "source", "trim", "inputs", "kind", "function", "tools", "toolDefinitions", "operations", "AddArtifact", "blueprint"]
+}

package/dist/lib/neutral/chunk-XT5ZSUS6.mjs

@@ -0,0 +1,363 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/crud/graph.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Toolkit 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 { Entity, Filter, Obj, Query, Type } from "@dxos/echo";
+import { Database } 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 { ContextQueueService } from "@dxos/functions";
+import { DXN, ObjectId } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { deepMapValues, isNonNullable, trim } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/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 = Toolkit.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
+  ]
+}));
+var LocalSearchHandler = LocalSearchToolkit.toLayer({
+  search_local_search: Effect.fn(function* ({ query: query2 }) {
+    const objects = yield* Database.runQuery(Query.select(Filter.text(query2, {
+      type: "vector"
+    })));
+    const results = [
+      ...objects
+    ];
+    const option = yield* Effect.serviceOption(ContextQueueService);
+    if (Option.isSome(option)) {
+      const queueObjects = yield* Effect.promise(() => option.value.queue.queryObjects());
+      results.push(...queueObjects);
+    }
+    return trim`
+      <local_context>
+        ${JSON.stringify(results, null, 2)}
+      </local_context>
+    `;
+  })
+});
+var GraphWriterSchema = class extends Context.Tag("@dxos/assistant/GraphWriterSchema")() {
+};
+var makeGraphWriterToolkit = ({ schema }) => {
+  return Toolkit.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,
+      ContextQueueService
+    ]
+  }).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 { queue } = yield* ContextQueueService;
+      const data = yield* Effect.promise(() => sanitizeObjects(schema, input, db, queue));
+      yield* Effect.promise(() => queue.append(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 = async (types, data, db, queue) => {
+  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
+        }, {
+          F: __dxlog_file,
+          L: 273,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      }
+      const targetDxn = resolveId(data2.target);
+      if (!targetDxn) {
+        log.warn("target not found", {
+          target: data2.target
+        }, {
+          F: __dxlog_file,
+          L: 277,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      }
+      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 = await db.query(Query.select(Filter.id(...existingIds))).run();
+  const queueObjects = await queue?.getObjectsById([
+    ...existingIds
+  ]) ?? [];
+  const objects = [
+    ...dbObjects,
+    ...queueObjects
+  ].filter(isNonNullable);
+  log.info("objects", {
+    dbObjects,
+    queueObjects,
+    existingIds
+  }, {
+    F: __dxlog_file,
+    L: 298,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  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/blueprints/research/types/ResearchGraph.ts
+var ResearchGraph_exports = {};
+__export(ResearchGraph_exports, {
+  LegacyResearchGraph: () => LegacyResearchGraph,
+  ResearchGraph: () => ResearchGraph,
+  contextQueueLayer: () => contextQueueLayer,
+  create: () => create,
+  query: () => query
+});
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema2 from "effect/Schema";
+import { Database as Database2, Obj as Obj2, Query as Query2, Ref, Type as Type2 } from "@dxos/echo";
+import { Queue } from "@dxos/echo-db";
+import { SystemTypeAnnotation } from "@dxos/echo/internal";
+import { ContextQueueService as ContextQueueService2, QueueService } from "@dxos/functions";
+var LegacyResearchGraph = Schema2.Struct({
+  queue: Ref.Ref(Queue)
+}).pipe(Type2.object({
+  typename: "org.dxos.type.research-graph",
+  version: "0.1.0"
+}), SystemTypeAnnotation.set(true));
+var ResearchGraph = Schema2.Struct({
+  queue: Ref.Ref(Queue)
+}).pipe(Type2.object({
+  typename: "org.dxos.type.researchGraph",
+  version: "0.1.0"
+}), SystemTypeAnnotation.set(true));
+var create = Effect2.fn("createResearchGraph")(function* () {
+  const queue = yield* QueueService.createQueue();
+  return yield* Database2.add(Obj2.make(ResearchGraph, {
+    queue: Ref.fromDXN(queue.dxn)
+  }));
+});
+var query = Effect2.fn("queryResearchGraph")(function* () {
+  const objects = yield* Database2.runQuery(Query2.type(ResearchGraph));
+  return objects.at(0);
+});
+var contextQueueLayer = Layer.unwrapEffect(Effect2.gen(function* () {
+  const researchGraph = (yield* query()) ?? (yield* create());
+  const researchQueue = yield* Database2.load(researchGraph.queue);
+  return ContextQueueService2.layer(researchQueue);
+}));
+
+// src/blueprints/research/types/index.ts
+import { Text } from "@dxos/schema";
+import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Pipeline, Task } from "@dxos/types";
+var ResearchDataTypes = [
+  // Objects
+  Event.Event,
+  Task.Task,
+  Text.Text,
+  // TODO(wittjosiah): Until views (e.g., Table) support relations this needs to be expressed via organization ref.
+  // Employer.Employer,
+  // Organization.Organization,
+  LegacyPerson,
+  LegacyOrganization,
+  Pipeline.Pipeline,
+  // Relations
+  HasRelationship.HasRelationship,
+  HasConnection.HasConnection
+];
+
+export {
+  Subgraph,
+  findRelatedSchema,
+  LocalSearchToolkit,
+  LocalSearchHandler,
+  makeGraphWriterToolkit,
+  makeGraphWriterHandler,
+  createExtractionSchema,
+  getSanitizedSchemaName,
+  sanitizeObjects,
+  ResearchGraph_exports,
+  ResearchDataTypes
+};
+//# sourceMappingURL=chunk-XT5ZSUS6.mjs.map