@dxos/assistant 0.8.2 → 0.8.3-main.7f5a14c

package/dist/lib/browser/index.mjs

@@ -1394,11 +1394,11 @@ import { DataTypes } from "@dxos/schema";
 import { Schema as Schema6, identity, Option as Option2, SchemaAST } from "effect";
 import { createTool as createTool3, ToolResult as ToolResult3 } from "@dxos/ai";
 import { isEncodedReference } from "@dxos/echo-protocol";
-import { EntityKind, getSchemaTypename, getTypeAnnotation, getTypeIdentifierAnnotation, create as create4, Filter as Filter2, getEntityKind, getSchemaDXN, ObjectId as ObjectId3, Query as Query2, ReferenceAnnotationId, RelationSourceId, RelationTargetId } from "@dxos/echo-schema";
+import { EntityKind, getSchemaTypename, getTypeAnnotation, getTypeIdentifierAnnotation, create as create4, Filter as Filter2, getEntityKind, getSchemaDXN, ObjectId as ObjectId3, Query as Query2, ReferenceAnnotationId, RelationSourceDXNId, RelationTargetDXNId, RelationSourceId, RelationTargetId } from "@dxos/echo-schema";
 import { mapAst } from "@dxos/effect";
 import { DXN as DXN2 } from "@dxos/keys";
 import { log as log7 } from "@dxos/log";
-import { deepMapValues } from "@dxos/util";
+import { deepMapValues, isNonNullable } from "@dxos/util";
 var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/research/graph.ts";
 var Subgraph = Schema6.Struct({
   /** Objects and relations. */
@@ -1428,7 +1428,7 @@ var isSchemaAddressableByDxn = (schema, dxn) => {
   }
   return false;
 };
-var createLocalSearchTool = (db) => {
+var createLocalSearchTool = (db, queue) => {
   return createTool3("search", {
     name: "local_search",
     description: "Search the local database for information using a vector index",
@@ -1441,9 +1441,16 @@ var createLocalSearchTool = (db) => {
       const { objects } = await db.query(Query2.select(Filter2.text(query, {
         type: "vector"
       }))).run();
+      const results = [
+        ...objects
+      ];
+      if (queue) {
+        const queueObjects = await queue.queryObjects();
+        results.push(...queueObjects);
+      }
       return ToolResult3.Success(`
         <local_context>
-          ${JSON.stringify(objects, null, 2)}
+          ${JSON.stringify(results, null, 2)}
         </local_context>
         `);
     }
@@ -1462,13 +1469,14 @@ var createExtractionSchema = (types) => {
 var getSanitizedSchemaName = (schema) => {
   return getSchemaDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
 };
-var sanitizeObjects = async (types, data, db) => {
+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 (ObjectId3.isValid(id)) {
       existingIds.add(id);
@@ -1511,7 +1519,7 @@ var sanitizeObjects = async (types, data, db) => {
           source: data2.source
         }, {
           F: __dxlog_file7,
-          L: 205,
+          L: 216,
           S: void 0,
           C: (f, a) => f(...a)
         });
@@ -1522,25 +1530,36 @@ var sanitizeObjects = async (types, data, db) => {
           target: data2.target
         }, {
           F: __dxlog_file7,
-          L: 209,
+          L: 220,
           S: void 0,
           C: (f, a) => f(...a)
         });
       }
       delete data2.source;
       delete data2.target;
-      data2[RelationSourceId] = sourceDxn;
-      data2[RelationTargetId] = targetDxn;
+      data2[RelationSourceDXNId] = sourceDxn;
+      data2[RelationTargetDXNId] = targetDxn;
     }
-    return create4(entry.schema, data2);
-  }).filter((object) => !existingIds.has(object.id));
-  const { objects } = await db.query(Query2.select(Filter2.ids(...existingIds))).run();
+    return {
+      data: data2,
+      schema: entry.schema
+    };
+  }).filter((object) => !existingIds.has(object.data.id));
+  const { objects: dbObjects } = await db.query(Query2.select(Filter2.ids(...existingIds))).run();
+  const queueObjects = await queue?.getObjectsById([
+    ...existingIds
+  ]) ?? [];
+  const objects = [
+    ...dbObjects,
+    ...queueObjects
+  ].filter(isNonNullable);
   log7.info("objects", {
-    objects,
+    dbObjects,
+    queueObjects,
     existingIds
   }, {
     F: __dxlog_file7,
-    L: 223,
+    L: 241,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -1548,7 +1567,37 @@ var sanitizeObjects = async (types, data, db) => {
   if (missing.length > 0) {
     throw new Error(`Object IDs do not point to existing objects: ${missing.join(", ")}`);
   }
-  return res;
+  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 = create4(schema, data2);
+      enitties.set(obj.id, obj);
+      return [
+        obj
+      ];
+    }
+    return [];
+  });
 };
 var SoftRef = Schema6.Struct({
   "/": Schema6.String
@@ -1576,13 +1625,13 @@ var preprocessSchema = (schema) => {
     })
   })) : identity);
 };
-var createGraphWriterTool = ({ db, schemaTypes, onDone = async (x) => x }) => {
+var createGraphWriterTool = ({ db, queue, schema, onDone = async (x) => x }) => {
   return createTool3("graph", {
     name: "writer",
     description: "Write to the local graph database",
-    schema: createExtractionSchema(schemaTypes),
+    schema: createExtractionSchema(schema),
     execute: async (input) => {
-      const data = await sanitizeObjects(schemaTypes, input, db);
+      const data = await sanitizeObjects(schema, input, db, queue);
       return ToolResult3.Success(await onDone(data));
     }
   });
@@ -1651,7 +1700,7 @@ var researchFn = defineFunction3({
     }));
     const graphWriteTool = createGraphWriterTool({
       db,
-      schemaTypes: DataTypes
+      schema: DataTypes
     });
     log8.info("graphWriteTool", {
       schema: graphWriteTool.parameters
@@ -1683,18 +1732,22 @@ var createArtifactElement = (id) => `<artifact id=${id} />`;
 
 // packages/core/assistant/src/blueprint/blueprint.ts
 import { Schema as Schema8 } from "effect";
-import { Tool } from "@dxos/ai";
-import { raise } from "@dxos/debug";
-import { ObjectId as ObjectId4 } from "@dxos/keys";
+import { Key, Obj, Type } from "@dxos/echo";
 var BlueprintStep = Schema8.Struct({
-  id: Schema8.String,
+  id: Key.ObjectId,
   instructions: Schema8.String,
-  // TODO(burdon): ExecutableTool can't be serialized.
-  tools: Schema8.Array(Tool).pipe(Schema8.mutable)
+  tools: Schema8.optional(Schema8.Array(Schema8.String))
 });
-var Blueprint = Schema8.Struct({
-  steps: Schema8.Array(BlueprintStep).pipe(Schema8.mutable)
+var BlueprintDefinition = Schema8.Struct({
+  steps: Schema8.Array(BlueprintStep.pipe(Schema8.omit("id")))
 });
+var Blueprint = Schema8.Struct({
+  name: Schema8.optional(Schema8.String),
+  steps: Schema8.Array(BlueprintStep)
+}).pipe(Type.Obj({
+  typename: "dxos.org/type/Blueprint",
+  version: "0.1.0"
+}));
 (function(BlueprintBuilder2) {
   BlueprintBuilder2.create = () => new Builder();
   class Builder {
@@ -1703,40 +1756,27 @@ var Blueprint = Schema8.Struct({
     }
     step(instructions, options) {
       this._steps.push({
-        id: ObjectId4.random(),
+        id: Key.ObjectId.random(),
         instructions,
         tools: options?.tools ?? []
       });
       return this;
     }
     build() {
-      return {
+      return Obj.make(Blueprint, {
         steps: this._steps
-      };
+      });
     }
   }
 })(BlueprintBuilder || (BlueprintBuilder = {}));
 (function(BlueprintParser2) {
-  BlueprintParser2.create = (tools = []) => new Parser(tools);
+  BlueprintParser2.create = () => new Parser();
   class Parser {
-    constructor(_tools) {
-      this._tools = _tools;
-    }
-    toJSON() {
-      return {
-        tools: this._tools.map((tool) => ({
-          name: tool.name,
-          namespace: tool.namespace,
-          type: tool.type
-        }))
-      };
-    }
     parse({ steps }) {
       const builder = BlueprintBuilder.create();
       for (const step of steps) {
         builder.step(step.instructions, {
-          // TODO(burdon): Tool resolution is duplicated in the session and ollama-client.
-          tools: step.tools?.map((tool) => this._tools.find(({ id }) => id === tool) ?? raise(new Error(`Tool not found: ${tool}`)))
+          tools: step.tools ?? []
         });
       }
       return builder.build();
@@ -1752,14 +1792,26 @@ import { createTool as createTool4, Message as Message3, ToolResult as ToolResul
 import { Event as Event2 } from "@dxos/async";
 import { create as create6 } from "@dxos/echo-schema";
 import { log as log9 } from "@dxos/log";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
 var __dxlog_file9 = "/home/runner/work/dxos/dxos/packages/core/assistant/src/blueprint/machine.ts";
+var SYSTEM_PROMPT = `
+You are a smart Rule-Following Agent.
+Rule-Following Agent executes the command that the user sent in the last message.
+After doing the work, the Rule-Following Agent calls report tool.
+If the Rule-Following agent believes that no action is needed, it calls the report tool with "skipped" status.
+If the Rule-Following Agent is unable to perform the task, it calls the report tool with "bail" status.
+Rule-Following Agent explains the reason it is unable to perform the task before bailing.
+The Rule-Following Agent can express creativity and imagination in the way it performs the task.
+The Rule-Following Agent precisely follows the instructions.
+`;
 var INITIAL_STATE = {
   state: "working",
   history: [],
   trace: []
 };
 var BlueprintMachine = class {
-  constructor(blueprint) {
+  constructor(registry, blueprint) {
+    this.registry = registry;
     this.blueprint = blueprint;
     this.begin = new Event2();
     this.end = new Event2();
@@ -1767,39 +1819,61 @@ var BlueprintMachine = class {
     this.stepComplete = new Event2();
     this.message = new Event2();
     this.block = new Event2();
-    this.state = structuredClone(INITIAL_STATE);
+    this._state = structuredClone(INITIAL_STATE);
+  }
+  get state() {
+    return this._state;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+    return this;
   }
   async runToCompletion(options) {
     log9.info("runToCompletion", options, {
       F: __dxlog_file9,
-      L: 67,
+      L: 106,
       S: this,
       C: (f, a) => f(...a)
     });
     this.begin.emit();
+    this.logger?.log({
+      type: "begin"
+    });
     let firstStep = true;
-    while (this.state.state !== "done") {
+    while (this._state.state !== "done") {
       const input = firstStep ? options.input : void 0;
       firstStep = false;
-      this.state = await this._execStep(this.state, {
+      this._state = await this._execStep(this._state, {
         input,
-        aiService: options.aiService
+        aiClient: options.aiClient
       });
-      this.stepComplete.emit(this.blueprint.steps.find((step) => step.id === this.state.trace.at(-1)?.stepId));
-      if (this.state.state === "bail") {
+      const step = this.blueprint.steps.find((step2) => step2.id === this._state.trace.at(-1)?.stepId);
+      this.stepComplete.emit(step);
+      this.logger?.log({
+        type: "step-complete",
+        step
+      });
+      if (this._state.state === "bail") {
         throw new Error("Agent unable to follow the blueprint");
       }
     }
     this.end.emit();
+    this.logger?.log({
+      type: "end"
+    });
   }
   async _execStep(state, options) {
-    const prevStep = this.blueprint.steps.findIndex((step) => step.id === this.state.trace.at(-1)?.stepId);
+    const prevStep = this.blueprint.steps.findIndex((step) => step.id === this._state.trace.at(-1)?.stepId);
     if (prevStep === this.blueprint.steps.length - 1) {
       throw new Error("Done execution blueprint");
     }
     const nextStep = this.blueprint.steps[prevStep + 1];
     const onLastStep = prevStep === this.blueprint.steps.length - 2;
     this.stepStart.emit(nextStep);
+    this.logger?.log({
+      type: "step-start",
+      step: nextStep
+    });
     const ReportSchema = Schema9.Struct({
       status: Schema9.Literal("done", "bailed", "skipped").annotations({
         description: "The status of the task completion"
@@ -1810,7 +1884,7 @@ var BlueprintMachine = class {
     });
     const report = createTool4("system", {
       name: "report",
-      description: "This tool reports that the agent has completed the task or is unable to do so",
+      description: "This tool reports that the agent has completed the task or is unable to do so.",
       schema: ReportSchema,
       execute: async (input) => ToolResult4.Break(input)
     });
@@ -1828,28 +1902,26 @@ var BlueprintMachine = class {
         ]
       })
     ] : [];
-    inputMessages.forEach((message) => this.message.emit(message));
+    inputMessages.forEach((message) => {
+      this.message.emit(message);
+      this.logger?.log({
+        type: "message",
+        message
+      });
+    });
+    const tools = nextStep.tools?.map((tool) => this.registry.get(tool)).filter(isNonNullable2) ?? [];
     const messages = await session.run({
-      systemPrompt: `
-        You are a smart Rule-Following Agent.
-        Rule-Following Agent executes the command that the user sent in the last message.
-        After doing the work, the Rule-Following Agent calls report tool.
-        If the Rule-Following agent believes that no action is needed, it calls the report tool with "skipped" status.
-        If the Rule-Following Agent is unable to perform the task, it calls the report tool with "bail" status.
-        Rule-Following Agent explains the reason it is unable to perform the task before bailing.
-        The Rule-Following Agent can express creativity and imagination in the way it performs the task.
-        The Rule-Following Agent precisely follows the instructions.
-      `,
+      systemPrompt: SYSTEM_PROMPT,
       history: [
         ...state.history,
         ...inputMessages
       ],
       tools: [
-        ...nextStep.tools,
+        ...tools,
         report
       ],
       artifacts: [],
-      client: options.aiService,
+      client: options.aiClient,
       prompt: nextStep.instructions
     });
     const { messages: trimmedHistory, call: lastBlock } = popLastToolCall(messages);
@@ -1906,25 +1978,96 @@ var popLastToolCall = (messages) => {
 };
 
 // packages/core/assistant/src/blueprint/logger.ts
+import { signal } from "@preact/signals-core";
 import chalk from "chalk";
 import { ConsolePrinter as ConsolePrinter2 } from "@dxos/ai";
+import { combine } from "@dxos/async";
+import { log as log10 } from "@dxos/log";
 chalk.level = 2;
-var setConsolePrinter = (machine, extraLogging = false) => {
+var DEFAULT_LOGGER = {
+  log: log10.info
+};
+var BufferedLogger = class {
+  constructor() {
+    this._messages = signal([]);
+  }
+  get messages() {
+    return this._messages;
+  }
+  clear() {
+    this._messages.value = [];
+  }
+  log(message) {
+    this._messages.value = [
+      ...this._messages.value,
+      message
+    ];
+  }
+};
+var BlueprintLoggerAdapter = class {
+  constructor(logger = DEFAULT_LOGGER) {
+    this.logger = logger;
+  }
+  log(event) {
+    switch (event.type) {
+      case "begin":
+        this.logger.log("begin");
+        break;
+      case "end":
+        this.logger.log("end");
+        break;
+      case "step-start":
+        this.logger.log("step-start", {
+          step: event.step
+        });
+        break;
+      case "step-complete":
+        this.logger.log("step-complete", {
+          step: event.step
+        });
+        break;
+      case "message":
+        this.logger.log("message", {
+          message: event.message
+        });
+        break;
+      case "block":
+        this.logger.log("block", {
+          block: event.block
+        });
+        break;
+    }
+  }
+};
+var setLogger = (machine, logger) => {
+  return combine(machine.begin.on(() => {
+    logger.log("Starting...");
+  }), machine.stepStart.on((step) => {
+    const index = machine.blueprint.steps.indexOf(step);
+    logger.log(`Step ${index + 1} of ${machine.blueprint.steps.length}`);
+    logger.log(`Instructions: ${step.instructions}`);
+  }), machine.stepComplete.on((step) => {
+    const trace = machine.state.trace.find((t) => t.stepId === step.id);
+    logger.log(`Complete: ${trace?.comment}`);
+  }), machine.end.on(() => {
+    logger.log("OK");
+  }));
+};
+var setConsolePrinter = (machine, verbose = false) => {
   const printer = new ConsolePrinter2();
-  if (extraLogging) {
-    machine.stepStart.on((step) => console.log(`
+  return combine(machine.begin.on(() => printTrace(machine.blueprint, machine.state)), machine.stepStart.on((step) => console.log(`
 ${chalk.magenta(`${chalk.bold(`STEP ${machine.blueprint.steps.indexOf(step) + 1} of ${machine.blueprint.steps.length}:`)} ${step.instructions}`)}
-`));
-    machine.message.on((msg) => printer.printMessage(msg));
-    machine.block.on((block) => printer.printContentBlock(block));
-  }
-  machine.begin.on(() => printTrace(machine.blueprint, machine.state));
-  machine.stepComplete.on(() => printTrace(machine.blueprint, machine.state));
+`)), machine.stepComplete.on(() => printTrace(machine.blueprint, machine.state)), machine.end.on(() => console.log("DONE")), verbose ? [
+    machine.message.on((msg) => printer.printMessage(msg)),
+    machine.block.on((block) => printer.printContentBlock(block))
+  ] : []);
 };
+var BREAK_LINE = `
+${"_".repeat(80)}
+`;
 var printTrace = (blueprint, state) => {
-  console.log("\n==============================================\n");
-  console.log(chalk.bold("\nThe Blueprint:"));
-  blueprint.steps.forEach((step, index) => {
+  console.group(chalk.bold("\nBlueprint"));
+  blueprint.steps.forEach((step) => {
     const traceStep = state.trace.find((t) => t.stepId === step.id);
     let color = chalk.gray;
     let bullet = "\u25CB";
@@ -1947,20 +2090,23 @@ var printTrace = (blueprint, state) => {
     console.log(color(`
 ${bullet} ${step.instructions}`));
     if (traceStep?.comment) {
-      console.log(chalk.white(`    \u21B3 ${traceStep.comment}`));
+      console.log(chalk.white(`  \u21B3 ${traceStep.comment}`));
     }
   });
-  console.log("\n");
-  console.log("\n==============================================\n");
+  console.groupEnd();
+  console.log(BREAK_LINE);
 };
 export {
   AIServiecOverloadedError,
   AISession,
   Blueprint,
   BlueprintBuilder,
+  BlueprintDefinition,
+  BlueprintLoggerAdapter,
   BlueprintMachine,
   BlueprintParser,
   BlueprintStep,
+  BufferedLogger,
   ExtractionInput,
   ExtractionOutput,
   ReferencedQuotes,
@@ -1985,6 +2131,7 @@ export {
   processTranscriptMessage,
   researchFn,
   sanitizeObjects,
-  setConsolePrinter
+  setConsolePrinter,
+  setLogger
 };
 //# sourceMappingURL=index.mjs.map