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

package/dist/lib/node/index.cjs

@@ -32,9 +32,12 @@ __export(node_exports, {
   AISession: () => AISession,
   Blueprint: () => Blueprint,
   BlueprintBuilder: () => BlueprintBuilder,
+  BlueprintDefinition: () => BlueprintDefinition,
+  BlueprintLoggerAdapter: () => BlueprintLoggerAdapter,
   BlueprintMachine: () => BlueprintMachine,
   BlueprintParser: () => BlueprintParser,
   BlueprintStep: () => BlueprintStep,
+  BufferedLogger: () => BufferedLogger,
   ExtractionInput: () => ExtractionInput,
   ExtractionOutput: () => ExtractionOutput,
   ReferencedQuotes: () => ReferencedQuotes,
@@ -59,7 +62,8 @@ __export(node_exports, {
   processTranscriptMessage: () => processTranscriptMessage,
   researchFn: () => researchFn,
   sanitizeObjects: () => sanitizeObjects,
-  setConsolePrinter: () => setConsolePrinter
+  setConsolePrinter: () => setConsolePrinter,
+  setLogger: () => setLogger
 });
 module.exports = __toCommonJS(node_exports);
 var import_effect = require("effect");
@@ -112,16 +116,18 @@ var import_keys2 = require("@dxos/keys");
 var import_log8 = require("@dxos/log");
 var import_util = require("@dxos/util");
 var import_effect9 = require("effect");
-var import_ai6 = require("@dxos/ai");
-var import_debug = require("@dxos/debug");
-var import_keys3 = require("@dxos/keys");
+var import_echo = require("@dxos/echo");
 var import_effect10 = require("effect");
-var import_ai7 = require("@dxos/ai");
+var import_ai6 = require("@dxos/ai");
 var import_async4 = require("@dxos/async");
 var import_echo_schema9 = require("@dxos/echo-schema");
 var import_log9 = require("@dxos/log");
+var import_util2 = require("@dxos/util");
+var import_signals_core = require("@preact/signals-core");
 var import_chalk = __toESM(require("chalk"));
-var import_ai8 = require("@dxos/ai");
+var import_ai7 = require("@dxos/ai");
+var import_async5 = require("@dxos/async");
+var import_log10 = require("@dxos/log");
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/assistant/src/extraction/extraction.ts";
 var ExtractionInput = import_effect.Schema.Struct({
   message: import_schema.DataType.Message,
@@ -1466,7 +1472,7 @@ var isSchemaAddressableByDxn = (schema, dxn) => {
   }
   return false;
 };
-var createLocalSearchTool = (db) => {
+var createLocalSearchTool = (db, queue) => {
   return (0, import_ai5.createTool)("search", {
     name: "local_search",
     description: "Search the local database for information using a vector index",
@@ -1479,9 +1485,16 @@ var createLocalSearchTool = (db) => {
       const { objects } = await db.query(import_echo_schema8.Query.select(import_echo_schema8.Filter.text(query, {
         type: "vector"
       }))).run();
+      const results = [
+        ...objects
+      ];
+      if (queue) {
+        const queueObjects = await queue.queryObjects();
+        results.push(...queueObjects);
+      }
       return import_ai5.ToolResult.Success(`
         <local_context>
-          ${JSON.stringify(objects, null, 2)}
+          ${JSON.stringify(results, null, 2)}
         </local_context>
         `);
     }
@@ -1500,13 +1513,14 @@ var createExtractionSchema = (types) => {
 var getSanitizedSchemaName = (schema) => {
   return (0, import_echo_schema8.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 (import_echo_schema8.ObjectId.isValid(id)) {
       existingIds.add(id);
@@ -1549,7 +1563,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)
         });
@@ -1560,25 +1574,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[import_echo_schema8.RelationSourceId] = sourceDxn;
-      data2[import_echo_schema8.RelationTargetId] = targetDxn;
+      data2[import_echo_schema8.RelationSourceDXNId] = sourceDxn;
+      data2[import_echo_schema8.RelationTargetDXNId] = targetDxn;
     }
-    return (0, import_echo_schema8.create)(entry.schema, data2);
-  }).filter((object) => !existingIds.has(object.id));
-  const { objects } = await db.query(import_echo_schema8.Query.select(import_echo_schema8.Filter.ids(...existingIds))).run();
+    return {
+      data: data2,
+      schema: entry.schema
+    };
+  }).filter((object) => !existingIds.has(object.data.id));
+  const { objects: dbObjects } = await db.query(import_echo_schema8.Query.select(import_echo_schema8.Filter.ids(...existingIds))).run();
+  const queueObjects = await queue?.getObjectsById([
+    ...existingIds
+  ]) ?? [];
+  const objects = [
+    ...dbObjects,
+    ...queueObjects
+  ].filter(import_util.isNonNullable);
   import_log8.log.info("objects", {
-    objects,
+    dbObjects,
+    queueObjects,
     existingIds
   }, {
     F: __dxlog_file7,
-    L: 223,
+    L: 241,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -1586,7 +1611,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 (import_echo_schema8.RelationSourceDXNId in data2) {
+      const id = data2[import_echo_schema8.RelationSourceDXNId].asEchoDXN()?.echoId;
+      const obj = objects.find((object) => object.id === id) ?? enitties.get(id);
+      if (obj) {
+        delete data2[import_echo_schema8.RelationSourceDXNId];
+        data2[import_echo_schema8.RelationSourceId] = obj;
+      } else {
+        skip = true;
+      }
+    }
+    if (import_echo_schema8.RelationTargetDXNId in data2) {
+      const id = data2[import_echo_schema8.RelationTargetDXNId].asEchoDXN()?.echoId;
+      const obj = objects.find((object) => object.id === id) ?? enitties.get(id);
+      if (obj) {
+        delete data2[import_echo_schema8.RelationTargetDXNId];
+        data2[import_echo_schema8.RelationTargetId] = obj;
+      } else {
+        skip = true;
+      }
+    }
+    if (!skip) {
+      const obj = (0, import_echo_schema8.create)(schema, data2);
+      enitties.set(obj.id, obj);
+      return [
+        obj
+      ];
+    }
+    return [];
+  });
 };
 var SoftRef = import_effect7.Schema.Struct({
   "/": import_effect7.Schema.String
@@ -1614,13 +1669,13 @@ var preprocessSchema = (schema) => {
     })
   })) : import_effect7.identity);
 };
-var createGraphWriterTool = ({ db, schemaTypes, onDone = async (x) => x }) => {
+var createGraphWriterTool = ({ db, queue, schema, onDone = async (x) => x }) => {
   return (0, import_ai5.createTool)("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 import_ai5.ToolResult.Success(await onDone(data));
     }
   });
@@ -1685,7 +1740,7 @@ var researchFn = (0, import_functions3.defineFunction)({
     }));
     const graphWriteTool = createGraphWriterTool({
       db,
-      schemaTypes: import_schema4.DataTypes
+      schema: import_schema4.DataTypes
     });
     import_log7.log.info("graphWriteTool", {
       schema: graphWriteTool.parameters
@@ -1713,14 +1768,20 @@ var researchFn = (0, import_functions3.defineFunction)({
 });
 var createArtifactElement = (id) => `<artifact id=${id} />`;
 var BlueprintStep = import_effect9.Schema.Struct({
-  id: import_effect9.Schema.String,
+  id: import_echo.Key.ObjectId,
   instructions: import_effect9.Schema.String,
-  // TODO(burdon): ExecutableTool can't be serialized.
-  tools: import_effect9.Schema.Array(import_ai6.Tool).pipe(import_effect9.Schema.mutable)
+  tools: import_effect9.Schema.optional(import_effect9.Schema.Array(import_effect9.Schema.String))
 });
-var Blueprint = import_effect9.Schema.Struct({
-  steps: import_effect9.Schema.Array(BlueprintStep).pipe(import_effect9.Schema.mutable)
+var BlueprintDefinition = import_effect9.Schema.Struct({
+  steps: import_effect9.Schema.Array(BlueprintStep.pipe(import_effect9.Schema.omit("id")))
 });
+var Blueprint = import_effect9.Schema.Struct({
+  name: import_effect9.Schema.optional(import_effect9.Schema.String),
+  steps: import_effect9.Schema.Array(BlueprintStep)
+}).pipe(import_echo.Type.Obj({
+  typename: "dxos.org/type/Blueprint",
+  version: "0.1.0"
+}));
 (function(BlueprintBuilder2) {
   BlueprintBuilder2.create = () => new Builder();
   class Builder {
@@ -1729,40 +1790,27 @@ var Blueprint = import_effect9.Schema.Struct({
     }
     step(instructions, options) {
       this._steps.push({
-        id: import_keys3.ObjectId.random(),
+        id: import_echo.Key.ObjectId.random(),
         instructions,
         tools: options?.tools ?? []
       });
       return this;
     }
     build() {
-      return {
+      return import_echo.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) ?? (0, import_debug.raise)(new Error(`Tool not found: ${tool}`)))
+          tools: step.tools ?? []
         });
       }
       return builder.build();
@@ -1772,13 +1820,24 @@ var Blueprint = import_effect9.Schema.Struct({
 var BlueprintBuilder;
 var BlueprintParser;
 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 import_async4.Event();
     this.end = new import_async4.Event();
@@ -1786,39 +1845,61 @@ var BlueprintMachine = class {
     this.stepComplete = new import_async4.Event();
     this.message = new import_async4.Event();
     this.block = new import_async4.Event();
-    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) {
     import_log9.log.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
+      });
+      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
       });
-      this.stepComplete.emit(this.blueprint.steps.find((step) => step.id === this.state.trace.at(-1)?.stepId));
-      if (this.state.state === "bail") {
+      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 = import_effect10.Schema.Struct({
       status: import_effect10.Schema.Literal("done", "bailed", "skipped").annotations({
         description: "The status of the task completion"
@@ -1827,11 +1908,11 @@ var BlueprintMachine = class {
         description: "A comment about the task completion. If you bailed, you must explain why in detail (min couple of sentences)."
       })
     });
-    const report = (0, import_ai7.createTool)("system", {
+    const report = (0, import_ai6.createTool)("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) => import_ai7.ToolResult.Break(input)
+      execute: async (input) => import_ai6.ToolResult.Break(input)
     });
     const session = new AISession({
       operationModel: "configured"
@@ -1840,35 +1921,33 @@ var BlueprintMachine = class {
     session.message.pipeInto(this.message);
     session.block.pipeInto(this.block);
     const inputMessages = options.input ? [
-      (0, import_echo_schema9.create)(import_ai7.Message, {
+      (0, import_echo_schema9.create)(import_ai6.Message, {
         role: "user",
         content: [
           taggedDataBlock("input", options.input)
         ]
       })
     ] : [];
-    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(import_util2.isNonNullable) ?? [];
     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);
@@ -1924,22 +2003,90 @@ var popLastToolCall = (messages) => {
   };
 };
 import_chalk.default.level = 2;
-var setConsolePrinter = (machine, extraLogging = false) => {
-  const printer = new import_ai8.ConsolePrinter();
-  if (extraLogging) {
-    machine.stepStart.on((step) => console.log(`
-${import_chalk.default.magenta(`${import_chalk.default.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));
+var DEFAULT_LOGGER = {
+  log: import_log10.log.info
+};
+var BufferedLogger = class {
+  constructor() {
+    this._messages = (0, import_signals_core.signal)([]);
+  }
+  get messages() {
+    return this._messages;
+  }
+  clear() {
+    this._messages.value = [];
+  }
+  log(message) {
+    this._messages.value = [
+      ...this._messages.value,
+      message
+    ];
   }
-  machine.begin.on(() => printTrace(machine.blueprint, machine.state));
-  machine.stepComplete.on(() => printTrace(machine.blueprint, machine.state));
 };
+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 (0, import_async5.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 import_ai7.ConsolePrinter();
+  return (0, import_async5.combine)(machine.begin.on(() => printTrace(machine.blueprint, machine.state)), machine.stepStart.on((step) => console.log(`
+${import_chalk.default.magenta(`${import_chalk.default.bold(`STEP ${machine.blueprint.steps.indexOf(step) + 1} of ${machine.blueprint.steps.length}:`)} ${step.instructions}`)}
+`)), 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(import_chalk.default.bold("\nThe Blueprint:"));
-  blueprint.steps.forEach((step, index) => {
+  console.group(import_chalk.default.bold("\nBlueprint"));
+  blueprint.steps.forEach((step) => {
     const traceStep = state.trace.find((t) => t.stepId === step.id);
     let color = import_chalk.default.gray;
     let bullet = "\u25CB";
@@ -1962,11 +2109,11 @@ var printTrace = (blueprint, state) => {
     console.log(color(`
 ${bullet} ${step.instructions}`));
     if (traceStep?.comment) {
-      console.log(import_chalk.default.white(`    \u21B3 ${traceStep.comment}`));
+      console.log(import_chalk.default.white(`  \u21B3 ${traceStep.comment}`));
     }
   });
-  console.log("\n");
-  console.log("\n==============================================\n");
+  console.groupEnd();
+  console.log(BREAK_LINE);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1974,9 +2121,12 @@ ${bullet} ${step.instructions}`));
   AISession,
   Blueprint,
   BlueprintBuilder,
+  BlueprintDefinition,
+  BlueprintLoggerAdapter,
   BlueprintMachine,
   BlueprintParser,
   BlueprintStep,
+  BufferedLogger,
   ExtractionInput,
   ExtractionOutput,
   ReferencedQuotes,
@@ -2001,6 +2151,7 @@ ${bullet} ${step.instructions}`));
   processTranscriptMessage,
   researchFn,
   sanitizeObjects,
-  setConsolePrinter
+  setConsolePrinter,
+  setLogger
 });
 //# sourceMappingURL=index.cjs.map