@dxos/assistant 0.8.3-main.672df60 → 0.8.3-main.7f5a14c

package/dist/lib/browser/index.mjs

@@ -1625,13 +1625,13 @@ var preprocessSchema = (schema) => {
     })
   })) : identity);
 };
-var createGraphWriterTool = ({ db, queue, 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, queue);
+      const data = await sanitizeObjects(schema, input, db, queue);
       return ToolResult3.Success(await onDone(data));
     }
   });
@@ -1700,7 +1700,7 @@ var researchFn = defineFunction3({
     }));
     const graphWriteTool = createGraphWriterTool({
       db,
-      schemaTypes: DataTypes
+      schema: DataTypes
     });
     log8.info("graphWriteTool", {
       schema: graphWriteTool.parameters
@@ -1732,19 +1732,18 @@ var createArtifactElement = (id) => `<artifact id=${id} />`;
 
 // packages/core/assistant/src/blueprint/blueprint.ts
 import { Schema as Schema8 } from "effect";
-import { Obj, Type } from "@dxos/echo";
-import { ObjectId as ObjectId4 } from "@dxos/keys";
-var BlueprintStepSchema = Schema8.Struct({
-  id: ObjectId4,
+import { Key, Obj, Type } from "@dxos/echo";
+var BlueprintStep = Schema8.Struct({
+  id: Key.ObjectId,
   instructions: Schema8.String,
-  tools: Schema8.Array(Schema8.String)
+  tools: Schema8.optional(Schema8.Array(Schema8.String))
 });
-var BlueprintSchema = Schema8.Struct({
-  steps: Schema8.Array(BlueprintStepSchema.pipe(Schema8.omit("id")))
+var BlueprintDefinition = Schema8.Struct({
+  steps: Schema8.Array(BlueprintStep.pipe(Schema8.omit("id")))
 });
 var Blueprint = Schema8.Struct({
   name: Schema8.optional(Schema8.String),
-  steps: Schema8.Array(BlueprintStepSchema)
+  steps: Schema8.Array(BlueprintStep)
 }).pipe(Type.Obj({
   typename: "dxos.org/type/Blueprint",
   version: "0.1.0"
@@ -1757,7 +1756,7 @@ var Blueprint = Schema8.Struct({
     }
     step(instructions, options) {
       this._steps.push({
-        id: ObjectId4.random(),
+        id: Key.ObjectId.random(),
         instructions,
         tools: options?.tools ?? []
       });
@@ -1795,6 +1794,16 @@ 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: [],
@@ -1810,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: 71,
+      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 = Schema9.Struct({
       status: Schema9.Literal("done", "bailed", "skipped").annotations({
         description: "The status of the task completion"
@@ -1853,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)
     });
@@ -1871,19 +1902,16 @@ var BlueprintMachine = class {
         ]
       })
     ] : [];
-    inputMessages.forEach((message) => this.message.emit(message));
-    const tools = nextStep.tools.map((tool) => this.registry.get(tool)).filter(isNonNullable2);
+    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
@@ -1893,7 +1921,7 @@ var BlueprintMachine = class {
         report
       ],
       artifacts: [],
-      client: options.aiService,
+      client: options.aiClient,
       prompt: nextStep.instructions
     });
     const { messages: trimmedHistory, call: lastBlock } = popLastToolCall(messages);
@@ -1954,8 +1982,12 @@ 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 Logger = class {
+var DEFAULT_LOGGER = {
+  log: log10.info
+};
+var BufferedLogger = class {
   constructor() {
     this._messages = signal([]);
   }
@@ -1972,6 +2004,41 @@ var Logger = class {
     ];
   }
 };
+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...");
@@ -2034,13 +2101,14 @@ export {
   AISession,
   Blueprint,
   BlueprintBuilder,
+  BlueprintDefinition,
+  BlueprintLoggerAdapter,
   BlueprintMachine,
   BlueprintParser,
-  BlueprintSchema,
-  BlueprintStepSchema,
+  BlueprintStep,
+  BufferedLogger,
   ExtractionInput,
   ExtractionOutput,
-  Logger,
   ReferencedQuotes,
   Subgraph,
   VersionPin,