@dxos/assistant 0.8.2-main.f081794 → 0.8.2-main.f11618f

package/dist/lib/browser/index.mjs

@@ -32,12 +32,45 @@ import {
 } from "./chunk-DEIGOD4U.mjs";
 
 // packages/experimental/assistant/src/session/session.ts
-import { Schema as S } from "effect";
+import { Option, Schema as S } from "effect";
 import { defineTool, Message, ToolResult } from "@dxos/artifact";
 import { Event, synchronized } from "@dxos/async";
+import { ObjectVersion } from "@dxos/echo-db";
 import { create } from "@dxos/echo-schema";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
+
+// packages/experimental/assistant/src/session/version-pin.ts
+import { Schema } from "effect";
+import { getVersion } from "@dxos/echo-db";
+import { ObjectId } from "@dxos/echo-schema";
+var ObjectVersionSchema = Schema.Unknown;
+var VersionPinSchema = Schema.Struct({
+  // TODO(dmaretskyi): Use Ref when those support encoding.
+  objectId: ObjectId,
+  // TODO(dmaretskyi): Could be opaque
+  version: ObjectVersionSchema
+});
+var VersionPin = class extends VersionPinSchema {
+  static {
+    this.DISPOSITION = "version-pin";
+  }
+  static fromObject(object) {
+    return VersionPin.make({
+      objectId: object.id,
+      version: getVersion(object)
+    });
+  }
+  static createBlock(pin) {
+    return {
+      type: "json",
+      disposition: VersionPin.DISPOSITION,
+      json: JSON.stringify(pin)
+    };
+  }
+};
+
+// packages/experimental/assistant/src/session/session.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -61,152 +94,28 @@ var AISession = class _AISession {
     });
   }
   async run(options) {
-    const systemTools = [
-      defineTool("system", {
-        name: "query_artifact_definitions",
-        description: "Query the available artifact definitions",
-        schema: S.Struct({}),
-        execute: async () => {
-          return ToolResult.Success({
-            artifactDefinitions: options.artifacts.map((artifact) => ({
-              id: artifact.id,
-              name: artifact.name,
-              description: artifact.description
-            }))
-          });
-        }
-      })
-    ];
+    const systemTools = [];
     switch (this._options.operationModel) {
       case "planning":
-        systemTools.push(defineTool("system", {
-          name: "create_plan",
-          description: "Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.",
-          schema: S.Struct({
-            goal: S.String.annotations({
-              description: "The goal that the plan will achieve."
-            }),
-            steps: S.Array(S.Struct({
-              action: S.String.annotations({
-                description: "Complete, detailed action to perform."
-              }),
-              input: S.String.annotations({
-                description: "The required input data for this step. First step must not require any data."
-              }),
-              output: S.String.annotations({
-                description: "The output data from this step. This is passed to the next step as input."
-              }),
-              requiredArtifactIds: S.Array(S.String).annotations({
-                description: "The ids of the artifacts required to perform this step.",
-                examples: [
-                  [
-                    "artifact:dxos.org/example/Test"
-                  ]
-                ]
-              })
-            })).annotations({
-              description: "Steps"
-            })
-          }),
-          execute: async ({ goal, steps }) => {
-            const missingArtifactIds = steps.flatMap((step) => step.requiredArtifactIds).filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
-            if (missingArtifactIds.length > 0) {
-              return ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(", ")}`);
-            }
-            const stepResults = [];
-            for (const step of steps) {
-              log("executing step", {
-                action: step.action
-              }, {
-                F: __dxlog_file,
-                L: 160,
-                S: this,
-                C: (f, a) => f(...a)
-              });
-              const session = new _AISession({
-                operationModel: "immediate"
-              });
-              session.message.on((ev) => this.message.emit(ev));
-              session.block.on((ev) => this.block.emit(ev));
-              session.update.on((ev) => this.update.emit(ev));
-              session.streamEvent.on((ev) => this.streamEvent.emit(ev));
-              session.userMessage.on((ev) => this.userMessage.emit(ev));
-              const messages = await session.run({
-                client: options.client,
-                artifacts: options.artifacts,
-                tools: options.tools,
-                history: options.history,
-                extensions: options.extensions,
-                generationOptions: options.generationOptions,
-                requiredArtifactIds: step.requiredArtifactIds.slice(),
-                prompt: `
-                    You are an agent that executes the subtask in a plan.
-                    
-                    While you know the plan's goal only focus on your subtask
-                    Use the data from the previous step to complete your task.
-                    Return all of the data from "output" in your last message.
-                    
-                    Current step (that you need to complete):
-                    ${JSON.stringify({
-                  goal,
-                  input: step.input,
-                  output: step.output,
-                  yourTask: step.action
-                }, null, 2)}
-                    
-                    Previous step results:
-                    ${JSON.stringify(stepResults.at(-1))}.
-                  `
-              });
-              const result = messages.at(-1);
-              stepResults.push(result);
-            }
-            return ToolResult.Success({
-              stepResults
-            });
-          }
-        }));
+        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createPlanningTool(options));
         break;
-      case "immediate":
-        systemTools.push(defineTool("system", {
-          name: "require_artifact_definitions",
-          description: "Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.",
-          schema: S.Struct({
-            artifactDefinitionIds: S.Array(S.String).annotations({
-              description: "The ids of the artifact definitions to require",
-              examples: [
-                [
-                  "artifact:dxos.org/example/Test"
-                ]
-              ]
-            })
-          }),
-          execute: async ({ artifactDefinitionIds }) => {
-            const missingArtifactDefinitionIds = artifactDefinitionIds.filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
-            if (missingArtifactDefinitionIds.length > 0) {
-              return ToolResult.Error(`One or more artifact definition ids are invalid: ${missingArtifactDefinitionIds.join(", ")}`);
-            }
-            for (const artifactDefinitionId of artifactDefinitionIds) {
-              requiredArtifactIds.add(artifactDefinitionId);
-            }
-            return ToolResult.Success({});
+      case "importing":
+        systemTools.push(this._createQueryArtifactsTool(options.artifacts), this._createRequireTool(options.artifacts, (artifactDefinitionIds) => {
+          for (const artifactDefinitionId of artifactDefinitionIds) {
+            requiredArtifactIds.add(artifactDefinitionId);
           }
         }));
         break;
+      case "configured":
+        break;
+      default:
+        throw new TypeError(`Invalid operation model: ${this._options.operationModel}`);
     }
     this._history = [
       ...options.history
     ];
     this._pending = [
-      create(Message, {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: options.prompt
-          }
-        ]
-      })
+      await this._formatUserPrompt(options.artifactDiffResolver, options.prompt, options.history)
     ];
     this.userMessage.emit(this._pending.at(-1));
     this._stream = void 0;
@@ -226,7 +135,7 @@ var AISession = class _AISession {
           tools: tools.map((tool) => tool.name)
         }, {
           F: __dxlog_file,
-          L: 264,
+          L: 180,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -249,7 +158,7 @@ var AISession = class _AISession {
           pending: this._pending
         }, {
           F: __dxlog_file,
-          L: 289,
+          L: 205,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -257,7 +166,7 @@ var AISession = class _AISession {
         const message = this._pending.at(-1);
         invariant(message, void 0, {
           F: __dxlog_file,
-          L: 294,
+          L: 210,
           S: this,
           A: [
             "message",
@@ -267,7 +176,7 @@ var AISession = class _AISession {
         if (isToolUse(message)) {
           log("tool request...", void 0, {
             F: __dxlog_file,
-            L: 296,
+            L: 212,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -280,7 +189,7 @@ var AISession = class _AISession {
             response
           }, {
             F: __dxlog_file,
-            L: 303,
+            L: 219,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -300,7 +209,7 @@ var AISession = class _AISession {
     } catch (err) {
       log.catch(err, void 0, {
         F: __dxlog_file,
-        L: 315,
+        L: 231,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -321,6 +230,180 @@ var AISession = class _AISession {
     }
     return this._pending;
   }
+  async _formatUserPrompt(artifactDiffResolver, prompt, history) {
+    const prelude = [];
+    if (artifactDiffResolver) {
+      const versions = gatherObjectVersions(history);
+      const artifactDiff = await artifactDiffResolver(Array.from(versions.entries()).map(([id, version]) => ({
+        id,
+        lastVersion: version
+      })));
+      log.info("vision", {
+        artifactDiff,
+        versions
+      }, {
+        F: __dxlog_file,
+        L: 262,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      for (const [id, { version }] of [
+        ...artifactDiff.entries()
+      ]) {
+        if (ObjectVersion.equals(version, versions.get(id))) {
+          artifactDiff.delete(id);
+          continue;
+        }
+        prelude.push(VersionPin.createBlock(VersionPin.make({
+          objectId: id,
+          version
+        })));
+      }
+      if (artifactDiff.size > 0) {
+        prelude.push(createArtifactUpdateBlock(artifactDiff));
+      }
+    }
+    return create(Message, {
+      role: "user",
+      content: [
+        ...prelude,
+        {
+          type: "text",
+          text: prompt
+        }
+      ]
+    });
+  }
+  _createQueryArtifactsTool(artifacts) {
+    return defineTool("system", {
+      name: "query_artifact_definitions",
+      description: "Query the available artifact definitions",
+      schema: S.Struct({}),
+      execute: async () => {
+        return ToolResult.Success({
+          artifactDefinitions: artifacts.map((artifact) => ({
+            id: artifact.id,
+            name: artifact.name,
+            description: artifact.description
+          }))
+        });
+      }
+    });
+  }
+  _createRequireTool(artifacts, onRequire) {
+    return defineTool("system", {
+      name: "require_artifact_definitions",
+      description: "Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.",
+      schema: S.Struct({
+        artifactDefinitionIds: S.Array(S.String).annotations({
+          description: "The ids of the artifact definitions to require",
+          examples: [
+            [
+              "artifact:dxos.org/example/Test"
+            ]
+          ]
+        })
+      }),
+      execute: async ({ artifactDefinitionIds }) => {
+        const missingArtifactDefinitionIds = artifactDefinitionIds.filter((artifactId) => !artifacts.some((artifact) => artifact.id === artifactId));
+        if (missingArtifactDefinitionIds.length > 0) {
+          return ToolResult.Error(`One or more artifact definition ids are invalid: ${missingArtifactDefinitionIds.join(", ")}`);
+        }
+        onRequire(artifactDefinitionIds);
+        return ToolResult.Success({});
+      }
+    });
+  }
+  _createPlanningTool(options) {
+    return defineTool("system", {
+      name: "create_plan",
+      description: "Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.",
+      schema: S.Struct({
+        goal: S.String.annotations({
+          description: "The goal that the plan will achieve."
+        }),
+        steps: S.Array(S.Struct({
+          action: S.String.annotations({
+            description: "Complete, detailed action to perform."
+          }),
+          input: S.String.annotations({
+            description: "The required input data for this step. First step must not require any data."
+          }),
+          output: S.String.annotations({
+            description: "The output data from this step. This is passed to the next step as input."
+          }),
+          requiredArtifactIds: S.Array(S.String).annotations({
+            description: "The ids of the artifacts required to perform this step.",
+            examples: [
+              [
+                "artifact:dxos.org/example/Test"
+              ]
+            ]
+          })
+        })).annotations({
+          description: "Steps"
+        })
+      }),
+      execute: async ({ goal, steps }) => {
+        const missingArtifactIds = steps.flatMap((step) => step.requiredArtifactIds).filter((artifactId) => !options.artifacts.some((artifact) => artifact.id === artifactId));
+        if (missingArtifactIds.length > 0) {
+          return ToolResult.Error(`One or more artifact ids are invalid: ${missingArtifactIds.join(", ")}`);
+        }
+        const stepResults = [];
+        for (const step of steps) {
+          log("executing step", {
+            action: step.action
+          }, {
+            F: __dxlog_file,
+            L: 369,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          const session = new _AISession({
+            operationModel: "importing"
+          });
+          session.message.on((ev) => this.message.emit(ev));
+          session.block.on((ev) => this.block.emit(ev));
+          session.update.on((ev) => this.update.emit(ev));
+          session.streamEvent.on((ev) => this.streamEvent.emit(ev));
+          session.userMessage.on((ev) => this.userMessage.emit(ev));
+          const messages = await session.run({
+            client: options.client,
+            artifacts: options.artifacts,
+            tools: options.tools,
+            history: options.history,
+            extensions: options.extensions,
+            generationOptions: options.generationOptions,
+            requiredArtifactIds: step.requiredArtifactIds.slice(),
+            artifactDiffResolver: options.artifactDiffResolver,
+            prompt: `
+              You are an agent that executes the subtask in a plan.
+              
+              While you know the plan's goal only focus on your subtask
+              Use the data from the previous step to complete your task.
+              Return all of the data from "output" in your last message.
+              
+              Current step (that you need to complete):
+              ${JSON.stringify({
+              goal,
+              input: step.input,
+              output: step.output,
+              yourTask: step.action
+            }, null, 2)}
+              
+              Previous step results:
+              ${JSON.stringify(stepResults.at(-1))}.
+            `
+          });
+          const result = messages.at(-1);
+          stepResults.push(result);
+        }
+        return ToolResult.Success({
+          stepResults
+        });
+      }
+    });
+  }
   abort() {
     this._stream?.abort();
   }
@@ -338,21 +421,57 @@ var createBaseInstructions = ({ availableArtifacts, operationModel }) => `
   Decision-making:
 
   - Analyze the structure and type of the content in the user's message.
-  - Can you complete the task using the available artifacts?
-  - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
-  - Identify which artifacts are relevant to the user's request.
+  
+  
   ${operationModel === "planning" ? `
+      - Can you complete the task using the available artifacts?
+      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
+      - Identify which artifacts are relevant to the user's request.
         - Break down the user's request into a step-by-step plan that you will use to execute the user's request, the plan items should include artifacts which will be used to perform the actions.
-      ` : `
-      - Are the required artifacts already available?
-      - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
-      - The require'd artifact tools will be available for use after require.
-    `}
+      ` : ""}
+  ${operationModel === "importing" ? `
+      - Can you complete the task using the available artifacts?
+      - If you can't complete the task using the available artifacts, query the list of available artifacts using the appropriate tool.
+      - Identify which artifacts are relevant to the user's request.
+    - Are the required artifacts already available?
+    - If not, select which artifact(s) will be the most relevant and require them using the require_artifacts tool.
+    - The require'd artifact tools will be available for use after require.
+  ` : ""}
+  ${operationModel === "configured" ? `
+    - Select the most relevant artifact(s) to complete the task.
+    - Call the appropriate tool to use the artifact(s).
+  ` : ""}
 
   ${availableArtifacts.length > 0 ? `Artifacts already in context: ${availableArtifacts.join("\n")}` : ""}
 `;
 var AIServiecOverloadedError = class extends S.TaggedError()("AIServiecOverloadedError", {}) {
 };
+var gatherObjectVersions = (messages) => {
+  const artifactIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const block of message.content) {
+      if (block.type === "json" && block.disposition === VersionPin.DISPOSITION) {
+        const pin = VersionPin.pipe(S.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
+        if (!pin) {
+          continue;
+        }
+        artifactIds.set(pin.objectId, pin.version);
+      }
+    }
+  }
+  return artifactIds;
+};
+var createArtifactUpdateBlock = (artifactDiff) => {
+  return {
+    type: "text",
+    disposition: "artifact-update",
+    text: `
+      The following artifacts have been updated since the last message:
+      ${Array.from(artifactDiff.entries()).map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
+${diff}` : ""}</changed-artifact>`).join("\n")}
+    `
+  };
+};
 export {
   AIServiceEdgeClient,
   AIServiecOverloadedError,
@@ -372,6 +491,7 @@ export {
   OllamaClient,
   StreamTransform,
   ToolTypes,
+  VersionPin,
   createArtifactElement,
   createGenerationStream,
   emitMessageAsEvents,