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

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

@@ -0,0 +1,694 @@
+import {
+  EnableBlueprints,
+  QueryBlueprints,
+  UpdateBlueprints
+} from "./chunk-6DPL2YY5.mjs";
+import {
+  CreateProject,
+  ProjectRules,
+  SyncTriggers
+} from "./chunk-U26AX7D7.mjs";
+import {
+  DeleteMemory,
+  QueryMemories,
+  SaveMemory
+} from "./chunk-BO4ZVH7M.mjs";
+import {
+  ContextAdd,
+  ContextRemove,
+  Load,
+  ObjectCreate,
+  ObjectDelete,
+  ObjectUpdate,
+  Query,
+  RelationCreate,
+  RelationDelete,
+  SchemaAdd,
+  SchemaList,
+  TagAdd,
+  TagRemove
+} from "./chunk-AKMBURAD.mjs";
+import {
+  SyncIssues
+} from "./chunk-LI6VMCJW.mjs";
+import {
+  UpdateTasks
+} from "./chunk-KW45RMNS.mjs";
+import {
+  DocumentCreate,
+  Research
+} from "./chunk-ILZ2ODWC.mjs";
+import {
+  Fetch
+} from "./chunk-MEZ4UFR6.mjs";
+import {
+  Create,
+  Read,
+  Update
+} from "./chunk-6FL4C6KD.mjs";
+import {
+  FetchMessages
+} from "./chunk-AGG6OZNB.mjs";
+
+// src/blueprints/markdown/functions/index.ts
+import { OperationHandlerSet } from "@dxos/operation";
+var MarkdownHandlers = OperationHandlerSet.lazy(() => import("./create-P6I22VS5.mjs"), () => import("./read-JJN7YXHI.mjs"), () => import("./update-HZ7A3ZA5.mjs"));
+
+// src/blueprints/markdown/blueprint.ts
+import { Blueprint } from "@dxos/blueprints";
+import { Ref } from "@dxos/echo";
+import { Text } from "@dxos/schema";
+import { trim } from "@dxos/util";
+var BLUEPRINT_KEY = "org.dxos.blueprint.markdown";
+var instructions = trim`
+  You read, write & create markdown documents.
+`;
+var make = () => Blueprint.make({
+  key: BLUEPRINT_KEY,
+  name: "Markdown",
+  description: "Work with markdown documents.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref.make(Text.make(instructions))
+  },
+  tools: Blueprint.toolDefinitions({
+    operations: [
+      Create,
+      Read,
+      Update
+    ]
+  })
+});
+var blueprint = {
+  key: BLUEPRINT_KEY,
+  make
+};
+var blueprint_default = blueprint;
+
+// src/blueprints/design/blueprint.ts
+import { Blueprint as Blueprint2 } from "@dxos/blueprints";
+import { Ref as Ref2 } from "@dxos/echo";
+import { Text as Text2 } from "@dxos/schema";
+import { trim as trim2 } from "@dxos/util";
+var BLUEPRINT_KEY2 = "org.dxos.blueprint.design";
+var instructions2 = trim2`
+  You manage a design spec based on the conversation.
+  The design spec is a markdown document that is used to record the tasks.
+  The design spec document follows a hierarchical structure, with nested markdown bulleted sections.
+  Use the appropriate tools to read and write the design spec document.
+  Maintain the document so that it can convey all relevant points from the conversation.
+  When replying to the user, be terse with your comments about design doc handling.
+  Do not announce when you read or write the design spec document.
+`;
+var make2 = () => Blueprint2.make({
+  key: BLUEPRINT_KEY2,
+  name: "Design Spec",
+  description: "Preserve the conversation in the design spec.",
+  instructions: {
+    source: Ref2.make(Text2.make(instructions2))
+  },
+  tools: Blueprint2.toolDefinitions({
+    operations: [
+      Create,
+      Read,
+      Update
+    ]
+  })
+});
+var blueprint2 = {
+  key: BLUEPRINT_KEY2,
+  make: make2
+};
+var blueprint_default2 = blueprint2;
+
+// src/blueprints/discord/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/operation";
+var DiscordHandlers = OperationHandlerSet2.lazy(() => import("./fetch-messages-AFX7ZAVE.mjs"));
+
+// src/blueprints/discord/blueprint.ts
+import { Blueprint as Blueprint3 } from "@dxos/blueprints";
+import { Ref as Ref3 } from "@dxos/echo";
+import { Text as Text3 } from "@dxos/schema";
+import { trim as trim3 } from "@dxos/util";
+var BLUEPRINT_KEY3 = "org.dxos.blueprint.discord";
+var instructions3 = trim3`
+  You are able to fetch messages from Discord servers.
+
+  Known servers:
+
+  DXOS serverId: 837138313172353095
+`;
+var make3 = () => Blueprint3.make({
+  key: BLUEPRINT_KEY3,
+  name: "Discord",
+  description: "Discord integration.",
+  instructions: {
+    source: Ref3.make(Text3.make(instructions3))
+  },
+  tools: Blueprint3.toolDefinitions({
+    operations: [
+      FetchMessages
+    ]
+  })
+});
+var blueprint3 = {
+  key: BLUEPRINT_KEY3,
+  make: make3
+};
+var blueprint_default3 = blueprint3;
+
+// src/blueprints/linear/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet3 } from "@dxos/operation";
+var LinearHandlers = OperationHandlerSet3.lazy(() => import("./sync-issues-GQFVEV4W.mjs"));
+
+// src/blueprints/linear/blueprint.ts
+import { Blueprint as Blueprint4 } from "@dxos/blueprints";
+import { Ref as Ref4 } from "@dxos/echo";
+import { Text as Text4 } from "@dxos/schema";
+import { trim as trim4 } from "@dxos/util";
+var BLUEPRINT_KEY4 = "org.dxos.blueprint.linear";
+var instructions4 = trim4`
+  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 make4 = () => Blueprint4.make({
+  key: BLUEPRINT_KEY4,
+  name: "Linear",
+  description: "Syncs Linear workspaces.",
+  instructions: {
+    source: Ref4.make(Text4.make(instructions4))
+  },
+  tools: Blueprint4.toolDefinitions({
+    operations: [
+      SyncIssues
+    ]
+  })
+});
+var blueprint4 = {
+  key: BLUEPRINT_KEY4,
+  make: make4
+};
+var blueprint_default4 = blueprint4;
+
+// src/blueprints/planning/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/operation";
+var PlanningHandlers = OperationHandlerSet4.lazy(() => import("./update-tasks-D5XKU3TE.mjs"));
+
+// src/blueprints/planning/blueprint.ts
+import { Blueprint as Blueprint5 } from "@dxos/blueprints";
+var BLUEPRINT_KEY5 = "org.dxos.blueprint.planning";
+var make5 = () => Blueprint5.make({
+  key: BLUEPRINT_KEY5,
+  name: "Planning",
+  description: "Plans and tracks complex tasks with artifact management.",
+  tools: Blueprint5.toolDefinitions({
+    operations: [
+      UpdateTasks
+    ]
+  })
+});
+var blueprint5 = {
+  key: BLUEPRINT_KEY5,
+  make: make5
+};
+var blueprint_default5 = blueprint5;
+
+// src/blueprints/research/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/operation";
+var ResearchHandlers = OperationHandlerSet5.lazy(() => import("./document-create-53ZVNGFR.mjs"), () => import("./research-7JQEX7MU.mjs"));
+
+// src/blueprints/research/blueprint.ts
+import { Blueprint as Blueprint6 } from "@dxos/blueprints";
+import { Ref as Ref5 } from "@dxos/echo";
+import { Text as Text5 } from "@dxos/schema";
+import { trim as trim5 } from "@dxos/util";
+var BLUEPRINT_KEY6 = "org.dxos.blueprint.research";
+var instructions5 = trim5`
+  {{! Research }}
+
+  You are an analyst that does research tasks using tools that scrape the web and create structured data.
+  Structured data extraction is an experimental feature -- only enable it if the user explicitly requests it in the prompt.
+  Prefer updating existing notes instead of creating new ones.
+
+  <structured_mode>
+    When you are done, reply with the created objects.
+    Do not print the data, instead reply with inline references to the created objects.
+    Those will be later substituted with the pills representing the created objects.
+    Print the rest of the created objects as block references after the main note.
+
+    <example>
+      Based on my research, Google was founded by @dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M and @dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK46K31DDW62PBW9H2ZQ
+
+      <object><dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn></object>
+      <object><dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK46K31DDW62PBW9H2ZQ</dxn></object>
+      <object><dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK46K31DDW62PBW92333</dxn></object>
+    </example>
+  </structured_mode>
+
+  <unstructured_mode>
+    Reply normally with the text mode of the result of your research.
+  </unstructured_mode>
+`;
+var make6 = () => Blueprint6.make({
+  key: BLUEPRINT_KEY6,
+  name: "Research",
+  description: "Researches the web and creates structured data.",
+  instructions: {
+    source: Ref5.make(Text5.make(instructions5))
+  },
+  tools: Blueprint6.toolDefinitions({
+    operations: [
+      DocumentCreate,
+      Research
+    ]
+  })
+});
+var blueprint6 = {
+  key: BLUEPRINT_KEY6,
+  make: make6
+};
+var blueprint_default6 = blueprint6;
+
+// src/blueprints/websearch/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet6 } from "@dxos/operation";
+var WebSearchHandlers = OperationHandlerSet6.lazy(() => import("./fetch-TLKREIZA.mjs"));
+
+// src/blueprints/websearch/blueprint.ts
+import { Blueprint as Blueprint7 } from "@dxos/blueprints";
+import { Ref as Ref6 } from "@dxos/echo";
+import { Text as Text6 } from "@dxos/schema";
+var BLUEPRINT_KEY7 = "org.dxos.blueprint.web-search";
+var make7 = () => Blueprint7.make({
+  key: BLUEPRINT_KEY7,
+  name: "Web Search",
+  description: "Search the web.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref6.make(Text6.make())
+  },
+  tools: Blueprint7.toolDefinitions({
+    operations: [
+      Fetch
+    ],
+    tools: [
+      "AnthropicWebSearch"
+    ]
+  })
+});
+var blueprint7 = {
+  key: BLUEPRINT_KEY7,
+  make: make7
+};
+var blueprint_default7 = blueprint7;
+
+// 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 { GenericToolkit } from "@dxos/ai";
+var WebSearchToolkit = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
+var WebSearchToolkitGeneric = GenericToolkit.make(WebSearchToolkit, Layer.empty);
+
+// src/blueprints/browser/blueprint.ts
+import { Blueprint as Blueprint8 } from "@dxos/blueprints";
+import { Ref as Ref7 } from "@dxos/echo";
+import { Text as Text7 } from "@dxos/schema";
+import { trim as trim6 } from "@dxos/util";
+var BLUEPRINT_KEY8 = "org.dxos.blueprint.browser";
+var instructions6 = trim6`
+  You are able to connect and use a virtual browser with persistent session.
+  Browser tools are provided via MCP.
+`;
+var make9 = () => Blueprint8.make({
+  key: BLUEPRINT_KEY8,
+  name: "Browser",
+  description: "Access to a real isolated browser.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref7.make(Text7.make(instructions6))
+  },
+  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 blueprint8 = {
+  key: BLUEPRINT_KEY8,
+  make: make9
+};
+var blueprint_default8 = blueprint8;
+
+// src/blueprints/database/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet7 } from "@dxos/operation";
+var DatabaseHandlers = OperationHandlerSet7.lazy(() => import("./context-add-U5LSEQLG.mjs"), () => import("./context-remove-3YGXLVRA.mjs"), () => import("./load-KHLICMGJ.mjs"), () => import("./object-create-7J7D53FT.mjs"), () => import("./object-delete-QFXUHJ2D.mjs"), () => import("./object-update-C73HRM5F.mjs"), () => import("./query-ZMWWZ4I3.mjs"), () => import("./relation-create-YWV2TUKS.mjs"), () => import("./relation-delete-JGGA4CYQ.mjs"), () => import("./schema-add-7WKPPKW4.mjs"), () => import("./schema-list-MIAIKERK.mjs"), () => import("./tag-add-IKD4ADDM.mjs"), () => import("./tag-remove-PCSKCFT2.mjs"));
+
+// src/blueprints/database/blueprint.ts
+import { Blueprint as Blueprint9 } from "@dxos/blueprints";
+import { Ref as Ref8 } from "@dxos/echo";
+import { Text as Text8 } from "@dxos/schema";
+import { trim as trim7 } from "@dxos/util";
+var BLUEPRINT_KEY9 = "org.dxos.blueprint.database";
+var instructions7 = trim7`
+  You can query, create, update, and delete objects in ECHO.
+  You can manage schemas, relations, tags, and add objects to the chat context.
+`;
+var make10 = () => Blueprint9.make({
+  key: BLUEPRINT_KEY9,
+  name: "Database",
+  description: "Query and manipulate objects in the ECHO database.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref8.make(Text8.make(instructions7))
+  },
+  tools: Blueprint9.toolDefinitions({
+    operations: [
+      ContextAdd,
+      ContextRemove,
+      Load,
+      ObjectCreate,
+      ObjectDelete,
+      ObjectUpdate,
+      Query,
+      RelationCreate,
+      RelationDelete,
+      SchemaAdd,
+      SchemaList,
+      TagAdd,
+      TagRemove
+    ]
+  })
+});
+var blueprint9 = {
+  key: BLUEPRINT_KEY9,
+  make: make10
+};
+var blueprint_default9 = blueprint9;
+
+// src/blueprints/memory/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet8 } from "@dxos/operation";
+var MemoryHandlers = OperationHandlerSet8.lazy(() => import("./save-ZWWNTBOD.mjs"), () => import("./query-MN5B3MQF.mjs"), () => import("./delete-LHMZDJFA.mjs"));
+
+// src/blueprints/memory/blueprint.ts
+import { Blueprint as Blueprint10 } from "@dxos/blueprints";
+import { Ref as Ref9 } from "@dxos/echo";
+import { Text as Text9 } from "@dxos/schema";
+import { trim as trim8 } from "@dxos/util";
+var BLUEPRINT_KEY10 = "dxos.org/blueprint/memory";
+var instructions8 = trim8`
+  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 make11 = () => Blueprint10.make({
+  key: BLUEPRINT_KEY10,
+  name: "Memory",
+  description: "Persistent memory storage and retrieval.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref9.make(Text9.make(instructions8))
+  },
+  tools: Blueprint10.toolDefinitions({
+    operations: [
+      SaveMemory,
+      QueryMemories,
+      DeleteMemory
+    ]
+  })
+});
+var blueprint10 = {
+  key: BLUEPRINT_KEY10,
+  make: make11
+};
+var blueprint_default10 = blueprint10;
+
+// src/blueprints/automation/blueprint.ts
+import { Blueprint as Blueprint11 } from "@dxos/blueprints";
+import { Ref as Ref10 } from "@dxos/echo";
+import { Trigger } from "@dxos/functions";
+import { Operation } from "@dxos/operation";
+import { Text as Text10 } from "@dxos/schema";
+import { trim as trim9 } from "@dxos/util";
+var BLUEPRINT_KEY11 = "dxos.org/blueprint/automation";
+var instructions9 = trim9`
+  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 make12 = () => Blueprint11.make({
+  key: BLUEPRINT_KEY11,
+  name: "Triggers",
+  description: "Trigger management and automation.",
+  instructions: {
+    source: Ref10.make(Text10.make(instructions9))
+  }
+});
+var blueprint11 = {
+  key: BLUEPRINT_KEY11,
+  make: make12
+};
+var blueprint_default11 = blueprint11;
+
+// src/blueprints/blueprint-manager/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet9 } from "@dxos/operation";
+var BlueprintManagerHandlers = OperationHandlerSet9.lazy(() => import("./query-blueprints-EKHEZAGD.mjs"), () => import("./enable-blueprints-4UMPKGUD.mjs"), () => import("./update-blueprints-ZNWR7BBN.mjs"));
+
+// src/blueprints/blueprint-manager/blueprint.ts
+import { Blueprint as Blueprint12, Template } from "@dxos/blueprints";
+import { trim as trim10 } from "@dxos/util";
+var BLUEPRINT_KEY12 = "org.dxos.blueprint.blueprint-manager";
+var make13 = () => Blueprint12.make({
+  key: BLUEPRINT_KEY12,
+  name: "Blueprint Manager",
+  description: "Query and enable blueprints in the current conversation.",
+  instructions: Template.make({
+    source: trim10`
+        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: "function",
+        function: QueryBlueprints.meta.key
+      }
+    ]
+  }),
+  tools: Blueprint12.toolDefinitions({
+    operations: [
+      QueryBlueprints,
+      EnableBlueprints,
+      UpdateBlueprints
+    ]
+  })
+});
+var blueprint12 = {
+  key: BLUEPRINT_KEY12,
+  make: make13
+};
+var blueprint_default12 = blueprint12;
+
+// src/blueprints/project-wizard/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet10 } from "@dxos/operation";
+var ProjectWizardHandlers = OperationHandlerSet10.lazy(() => import("./create-project-NESP7QHJ.mjs"), () => import("./project-rules-IYRR6OQE.mjs"), () => import("./sync-triggers-MBKM6VIQ.mjs"));
+
+// src/blueprints/project-wizard/blueprint.ts
+import { Blueprint as Blueprint13, Template as Template2 } from "@dxos/blueprints";
+import { trim as trim11 } from "@dxos/util";
+var BLUEPRINT_KEY13 = "org.dxos.blueprint.project-wizard";
+var make14 = () => Blueprint13.make({
+  key: BLUEPRINT_KEY13,
+  name: "Project Wizard",
+  description: "Help the user create a new project.",
+  agentCanEnable: true,
+  instructions: Template2.make({
+    source: trim11`
+        You are a wizard that helps the user create a new project.
+
+        Projects are goal oriented and autonomously driven by the agent.
+        Each project has a spec - the goal of the project.
+        The spec also typically describes what actions to perform in reaction to events (emails).
+        The project has a number of associated artifacts to work with. 
+        Projects can subscribe to emails.
+
+        The project itself is an ECHO object and can be edited like any other object using the database blueprint.
+        You can edit the project's spec, name, and other properties directly.
+        If you edit the project's subscriptions array, you MUST call the sync-triggers function afterward to synchronize the triggers.
+
+        IMPORTANT: Before attempting to create a project call the [project-rules] tool to get the rules for creating a project.
+      `
+  }),
+  tools: Blueprint13.toolDefinitions({
+    operations: [
+      ProjectRules,
+      CreateProject,
+      SyncTriggers
+    ]
+  })
+});
+var blueprint13 = {
+  key: BLUEPRINT_KEY13,
+  make: make14
+};
+var blueprint_default13 = blueprint13;
+
+// src/functions/entity-extraction/definitions.ts
+import * as Schema from "effect/Schema";
+import { AiService } from "@dxos/ai";
+import { Database, Obj } from "@dxos/echo";
+import { FunctionInvocationService, QueueService, TracingService } from "@dxos/functions";
+import { Trace } from "@dxos/functions";
+import { Operation as Operation2 } from "@dxos/operation";
+import { Message } from "@dxos/types";
+var EntityExtraction = Operation2.make({
+  meta: {
+    key: "org.dxos.functions.entity-extraction",
+    name: "Entity Extraction",
+    description: "Extracts entities from emails and transcripts."
+  },
+  input: Schema.Struct({
+    source: Message.Message.annotations({
+      description: "Email or transcript to extract entities from."
+    }),
+    // TODO(dmaretskyi): Consider making this an array of blueprints instead.
+    instructions: Schema.optional(Schema.String).annotations({
+      description: "Instructions extraction process."
+    })
+  }),
+  output: Schema.Struct({
+    entities: Schema.optional(Schema.Array(Obj.Unknown).annotations({
+      description: "Extracted entities."
+    }))
+  }),
+  services: [
+    AiService.AiService,
+    Database.Service,
+    TracingService,
+    FunctionInvocationService,
+    QueueService,
+    Trace.TraceService
+  ]
+});
+
+export {
+  MarkdownHandlers,
+  blueprint_default,
+  blueprint_default2,
+  DiscordHandlers,
+  blueprint_default3,
+  LinearHandlers,
+  blueprint_default4,
+  PlanningHandlers,
+  blueprint_default5,
+  ResearchHandlers,
+  blueprint_default6,
+  WebSearchHandlers,
+  blueprint_default7,
+  WebSearchToolkit,
+  WebSearchToolkitGeneric,
+  blueprint_default8,
+  DatabaseHandlers,
+  blueprint_default9,
+  MemoryHandlers,
+  blueprint_default10,
+  blueprint_default11,
+  BlueprintManagerHandlers,
+  blueprint_default12,
+  ProjectWizardHandlers,
+  blueprint_default13,
+  EntityExtraction
+};
+//# sourceMappingURL=chunk-A4AVXKBT.mjs.map