@dxos/assistant 0.8.4-main.84f28bd → 0.8.4-main.9735255

package/dist/lib/node-esm/chunk-CC7ER6Q3.mjs

@@ -0,0 +1,579 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/session/artifact-diff.ts
+import * as Context from "effect/Context";
+var ArtifactDiffResolver = class extends Context.Tag("@dxos/assistant/ArtifactDiffResolver")() {
+};
+
+// src/session/observer.ts
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+var GenerationObserver = Object.freeze({
+  make: ({ onBegin = Function.constant(Effect.void), onPart = Function.constant(Effect.void), onBlock = Function.constant(Effect.void), onEnd = Function.constant(Effect.void), onMessage = Function.constant(Effect.void) } = {}) => ({
+    onBegin,
+    onPart,
+    onBlock,
+    onEnd,
+    onMessage
+  }),
+  noop: () => GenerationObserver.make(),
+  /**
+  * Debug printer to be used in unit-tests and browser devtools.
+  */
+  fromPrinter: (printer) => GenerationObserver.make({
+    onBlock: (block) => Effect.sync(() => {
+      if (block.pending) {
+        return;
+      }
+      printer.printContentBlock(block);
+    }),
+    onMessage: (message) => Effect.sync(() => {
+      if (message.sender.role === "assistant") {
+        return;
+      }
+      printer.printMessage(message);
+    })
+  })
+});
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var AiModelError = class extends BaseError.extend("AiModelError", "AI model error") {
+};
+var AiAssistantError = class extends BaseError.extend("AiAssistantError", "AI assistant error") {
+};
+
+// src/session/session.ts
+import * as LanguageModel from "@effect/ai/LanguageModel";
+import * as Chunk from "effect/Chunk";
+import * as Effect3 from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { AiParser, AiPreprocessor, callTool, getToolCalls } from "@dxos/ai";
+import { todo } from "@dxos/debug";
+import { Obj as Obj2 } from "@dxos/echo";
+import { TracingService } from "@dxos/functions";
+import { log as log2 } from "@dxos/log";
+import { Message as Message2 } from "@dxos/types";
+
+// src/session/format.ts
+import * as Effect2 from "effect/Effect";
+import * as Function2 from "effect/Function";
+import * as Option from "effect/Option";
+import { Template } from "@dxos/blueprints";
+import { Obj } from "@dxos/echo";
+import { ObjectVersion } from "@dxos/echo-db";
+import { log } from "@dxos/log";
+import { Message } from "@dxos/types";
+import { trim } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/session/format.ts";
+var formatSystemPrompt = ({ system, blueprints = [], objects = [] }) => Effect2.gen(function* () {
+  const blueprintDefs = yield* Function2.pipe(blueprints, Effect2.forEach((blueprint) => Effect2.succeed(blueprint.instructions)), Effect2.flatMap(Effect2.forEach((template) => Effect2.gen(function* () {
+    return trim`
+            <blueprint>
+              ${yield* Template.processTemplate(template)}
+            </blueprint>
+          `;
+  }))), Effect2.map((blueprints2) => blueprints2.length > 0 ? [
+    "## Blueprints Definitions",
+    ...blueprints2
+  ].join("\n\n") : void 0));
+  const objectDefs = yield* Function2.pipe(objects, Effect2.forEach((object) => Effect2.succeed(trim`
+          <object>
+            <dxn>${Obj.getDXN(object)}</dxn>
+            <typename>${Obj.getTypename(object)}</typename>
+          </object>
+        `)), Effect2.map((objects2) => objects2.length > 0 ? [
+    "## Context Objects",
+    ...objects2
+  ].join("\n\n") : void 0));
+  return yield* Function2.pipe(Effect2.succeed([
+    system,
+    blueprintDefs,
+    objectDefs
+  ].filter((def) => def !== void 0)), Effect2.map((parts) => parts.join("\n\n")));
+});
+var formatUserPrompt = ({ prompt, history = [] }) => Effect2.gen(function* () {
+  const blocks = [];
+  const artifactDiffResolver = yield* Effect2.serviceOption(ArtifactDiffResolver);
+  if (Option.isSome(artifactDiffResolver)) {
+    const versions = gatherObjectVersions(history);
+    const artifactDiff = yield* Effect2.tryPromise({
+      try: () => artifactDiffResolver.value.resolve([
+        ...versions.entries()
+      ].map(([id, version]) => ({
+        id,
+        lastVersion: version
+      }))),
+      catch: AiAssistantError.wrap({
+        message: "Artifact diff resolution error"
+      })
+    });
+    log("version", {
+      artifactDiff,
+      versions
+    }, {
+      F: __dxlog_file,
+      L: 94,
+      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;
+      }
+      blocks.push({
+        _tag: "anchor",
+        objectId: id,
+        version
+      });
+    }
+    if (artifactDiff.size > 0) {
+      blocks.push(createArtifactUpdateBlock(artifactDiff));
+    }
+  }
+  return Obj.make(Message.Message, {
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    sender: {
+      role: "user"
+    },
+    blocks: [
+      ...blocks,
+      {
+        _tag: "text",
+        text: prompt
+      }
+    ]
+  });
+});
+var gatherObjectVersions = (messages) => {
+  const artifactIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      if (block._tag === "anchor") {
+        artifactIds.set(block.objectId, block.version);
+      }
+    }
+  }
+  return artifactIds;
+};
+var createArtifactUpdateBlock = (artifactDiff) => {
+  return {
+    _tag: "text",
+    // TODO(dmaretskyi): Does this need to be a special content-block?
+    disposition: "artifact-update",
+    text: trim`
+      The following artifacts have been updated since the last message:
+      ${[
+      ...artifactDiff.entries()
+    ].map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `
+${diff}` : ""}</changed-artifact>`).join("\n")}
+    `
+  };
+};
+
+// src/session/session.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant/src/session/session.ts";
+var AiSession = class {
+  _options;
+  /** Prevents concurrent execution of session. */
+  _semaphore = Effect3.runSync(Effect3.makeSemaphore(1));
+  /** Message history from queue. */
+  // TODO(burdon): Evolve into supporting a git-like graph of messages.
+  _history = [];
+  /** Pending messages for this session (incl. the current prompt). */
+  _pending = [];
+  _started = 0;
+  _ended = 0;
+  _toolCalls = 0;
+  constructor(_options = {}) {
+    this._options = _options;
+  }
+  get duration() {
+    return this._ended - this._started;
+  }
+  get toolCalls() {
+    return this._toolCalls;
+  }
+  run = ({ prompt, system: systemTemplate, history = [], objects = [], blueprints = [], toolkit, observer = GenerationObserver.noop() }) => Effect3.gen(this, function* () {
+    this._started = Date.now();
+    this._history = [
+      ...history
+    ];
+    this._pending = [];
+    const pending = this._pending;
+    const submitMessage = Effect3.fnUntraced(function* (message) {
+      pending.push(message);
+      yield* observer.onMessage(message);
+      yield* TracingService.emitConverationMessage(message);
+      return message;
+    });
+    const promptMessage = yield* submitMessage(yield* formatUserPrompt({
+      prompt,
+      history
+    }));
+    const system = yield* formatSystemPrompt({
+      system: systemTemplate,
+      blueprints,
+      objects
+    }).pipe(Effect3.orDie);
+    do {
+      log2("request", {
+        prompt: promptMessage,
+        system: {
+          snippet: createSnippet(system),
+          length: system.length
+        },
+        pending: this._pending.length,
+        history: this._history.length,
+        objects: objects?.length ?? 0
+      }, {
+        F: __dxlog_file2,
+        L: 126,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const prompt2 = yield* AiPreprocessor.preprocessPrompt([
+        ...this._history,
+        ...this._pending
+      ], {
+        system
+      });
+      const blocks = yield* LanguageModel.streamText({
+        prompt: prompt2,
+        toolkit,
+        disableToolCallResolution: true
+      }).pipe(
+        // TOOD(dmaretskyi): Error mapping.
+        AiParser.parseResponse({
+          onBegin: () => observer.onBegin(),
+          onBlock: (block) => observer.onBlock(block),
+          onPart: (part) => observer.onPart(part),
+          onEnd: (summary) => observer.onEnd(summary)
+        }),
+        Stream.runCollect,
+        Effect3.map(Chunk.toArray)
+      );
+      const response = yield* submitMessage(Obj2.make(Message2.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "assistant"
+        },
+        blocks
+      }));
+      const toolCalls = getToolCalls(response);
+      if (toolCalls.length === 0) {
+        break;
+      } else if (!toolkit) {
+        throw new Error("No toolkit provided");
+      }
+      const toolResults = yield* Effect3.forEach(toolCalls, (toolCall) => {
+        return callTool(toolkit, toolCall).pipe(Effect3.provide(TracingService.layerSubframe((context) => ({
+          ...context,
+          parentMessage: response.id,
+          toolCallId: toolCall.toolCallId
+        }))));
+      });
+      yield* submitMessage(Obj2.make(Message2.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "tool"
+        },
+        blocks: toolResults
+      }));
+      this._toolCalls++;
+    } while (true);
+    this._ended = Date.now();
+    log2("done", {
+      pending: this._pending.length,
+      duration: this.duration,
+      tools: this._toolCalls
+    }, {
+      F: __dxlog_file2,
+      L: 202,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return this._pending;
+  }).pipe(this._semaphore.withPermits(1), Effect3.withSpan("AiSession.run"));
+  /**
+  * @deprecated
+  */
+  // TODO(burdon): Implement or remove.
+  async runStructured(_schema, _options) {
+    return todo();
+  }
+};
+var createSnippet = (text, len = 32) => text.length <= len * 2 ? text : [
+  text.slice(0, len),
+  "...",
+  text.slice(-len)
+].join("");
+
+// src/session/toolkit.ts
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Effect4 from "effect/Effect";
+import { ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { isTruthy } from "@dxos/util";
+var createToolkit = ({ toolkit: toolkitProp, blueprints = [] }) => Effect4.gen(function* () {
+  const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
+  const blueprintToolHandler = yield* blueprintToolkit.toContext(ToolExecutionService.handlersFor(blueprintToolkit));
+  const toolkit = Toolkit.merge(...[
+    toolkitProp,
+    blueprintToolkit
+  ].filter(isTruthy));
+  return yield* toolkit.pipe(Effect4.provide(blueprintToolHandler));
+});
+
+// src/session/version-pin.ts
+import * as Schema from "effect/Schema";
+import { getVersion } from "@dxos/echo-db";
+import { ObjectId } from "@dxos/keys";
+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 DISPOSITION = "version-pin";
+  static fromObject(object) {
+    return VersionPin.make({
+      objectId: object.id,
+      version: getVersion(object)
+    });
+  }
+  static createBlock(pin) {
+    return {
+      _tag: "json",
+      disposition: VersionPin.DISPOSITION,
+      data: JSON.stringify(pin)
+    };
+  }
+};
+
+// src/session/GenericToolkit.ts
+var GenericToolkit_exports = {};
+__export(GenericToolkit_exports, {
+  TypeId: () => TypeId,
+  make: () => make,
+  merge: () => merge3
+});
+import * as Toolkit2 from "@effect/ai/Toolkit";
+import * as Effect5 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Pipeable from "effect/Pipeable";
+var TypeId = "~@dxos/assistant/GenericToolkit";
+var make = (toolkit, layer) => {
+  return {
+    [TypeId]: TypeId,
+    toolkit,
+    layer,
+    handlers: toolkit.pipe(Effect5.provide(layer)),
+    pipe() {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+var merge3 = (...toolkits) => {
+  return make(Toolkit2.merge(...toolkits.map((t) => t.toolkit)), Layer.mergeAll(...toolkits.map((t) => t.layer)));
+};
+
+// src/types/artifact.ts
+import * as Schema2 from "effect/Schema";
+import { Type } from "@dxos/echo";
+import { Database } from "@dxos/echo";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { trim as trim2 } from "@dxos/util";
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var ArtifactId = class extends Schema2.String.annotations({
+  // TODO(dmaretskyi): This section gets overriden.
+  description: trim2`
+    The ID of the referenced object. Formats accepted:
+    - DXN (dxn:echo:@:XXXXX). DXNs can be prepended with an @ symbol for compatibility with in-text references.
+    - space ID, object ID tuple (spaceID:objectID)
+    - Only object ID that is assumed to be in the current space (XXXXX)
+  `,
+  examples: [
+    "dxn:echo:@:XXXXX",
+    "@dxn:echo:@:XXXXX",
+    "spaceID:objectID",
+    "XXXXX"
+  ]
+}) {
+  static toDXN(reference, owningSpaceId) {
+    if (reference.startsWith("@dxn:")) {
+      return DXN.parse(reference.slice(1));
+    } else if (reference.startsWith("dxn:")) {
+      return DXN.parse(reference);
+    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {
+      const [spaceId, objectId] = reference.split(":");
+      return new DXN(DXN.kind.ECHO, [
+        spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId,
+        objectId
+      ]);
+    } else if (/^[A-Z0-9]+$/.test(reference)) {
+      return DXN.fromLocalObjectId(reference);
+    } else {
+      throw new Error(`Unable to parse object reference: ${reference}`);
+    }
+  }
+  /**
+  * Resolves an artifact ID to an object.
+  */
+  static resolve(schema, ref) {
+    const dxn = ArtifactId.toDXN(ref);
+    return Database.Service.resolve(dxn, schema);
+  }
+};
+var RefFromLLM = Schema2.transform(ArtifactId, Type.Ref(Type.Obj), {
+  decode: (fromA, fromI) => EncodedReference.fromDXN(ArtifactId.toDXN(fromA)),
+  encode: (toI, toA) => EncodedReference.toDXN(toI).toString(),
+  strict: false
+});
+
+// src/functions/services.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Context2 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Record from "effect/Record";
+import * as Schema3 from "effect/Schema";
+import { AiToolNotFoundError, ToolExecutionService as ToolExecutionService2, ToolResolverService as ToolResolverService2 } from "@dxos/ai";
+import { todo as todo2 } from "@dxos/debug";
+import { Query, Type as Type2 } from "@dxos/echo";
+import { Database as Database2 } from "@dxos/echo";
+import { Function as Function3, FunctionDefinition, FunctionInvocationService } from "@dxos/functions";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
+var makeToolResolverFromFunctions = (functions, toolkit) => {
+  return Layer2.effect(ToolResolverService2, Effect6.gen(function* () {
+    const dbService = yield* Database2.Service;
+    return {
+      resolve: (id) => Effect6.gen(function* () {
+        const tool = toolkit.tools[id];
+        if (tool) {
+          return tool;
+        }
+        const [dbFunction] = yield* Database2.Service.runQuery(Query.type(Function3.Function, {
+          key: id
+        }));
+        const functionDef = dbFunction ? FunctionDefinition.deserialize(dbFunction) : functions.find((fn2) => fn2.key === id);
+        if (!functionDef) {
+          return yield* Effect6.fail(new AiToolNotFoundError(id));
+        }
+        return projectFunctionToTool(functionDef);
+      }).pipe(Effect6.provideService(Database2.Service, dbService))
+    };
+  }));
+};
+var makeToolExecutionServiceFromFunctions = (toolkit, handlersLayer) => {
+  return Layer2.effect(ToolExecutionService2, Effect6.gen(function* () {
+    const toolkitHandler = yield* toolkit.pipe(Effect6.provide(handlersLayer));
+    invariant(isHandlerLike(toolkitHandler), void 0, {
+      F: __dxlog_file3,
+      L: 77,
+      S: this,
+      A: [
+        "isHandlerLike(toolkitHandler)",
+        ""
+      ]
+    });
+    const functionInvocationService = yield* FunctionInvocationService;
+    return {
+      handlersFor: (toolkit2) => {
+        const makeHandler = (tool) => {
+          return Effect6.fn(`toolFunctionHandler ${tool.name}`)(function* (input) {
+            if (toolkitHandler.tools[tool.name]) {
+              if (Tool.isProviderDefined(tool)) {
+                throw new Error("Attempted to call a provider-defined tool");
+              }
+              const { result } = yield* toolkitHandler.handle(tool.name, input);
+              return result;
+            }
+            const { definition: functionDef } = Context2.get(FunctionToolAnnotation)(tool.annotations);
+            return yield* functionInvocationService.invokeFunction(functionDef, input).pipe(Effect6.catchAllDefect((defect) => Effect6.fail(defect)));
+          });
+        };
+        return toolkit2.of(Record.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
+      }
+    };
+  }));
+};
+var FunctionToolAnnotation = class extends Context2.Tag("@dxos/assistant/FunctionToolAnnotation")() {
+};
+var toolCache = /* @__PURE__ */ new WeakMap();
+var projectFunctionToTool = (fn2) => {
+  if (toolCache.has(fn2)) {
+    return toolCache.get(fn2);
+  }
+  const tool = Tool.make(makeToolName(fn2.name), {
+    description: fn2.description,
+    parameters: createStructFieldsFromSchema(fn2.inputSchema),
+    // TODO(dmaretskyi): Include output schema.
+    failure: Schema3.Any
+  }).annotate(FunctionToolAnnotation, {
+    definition: fn2
+  });
+  toolCache.set(fn2, tool);
+  return tool;
+};
+var makeToolName = (name) => {
+  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-");
+  invariant(toolName.match(/^[a-z_][a-z0-9-_]*$/), void 0, {
+    F: __dxlog_file3,
+    L: 148,
+    S: void 0,
+    A: [
+      "toolName.match(/^[a-z_][a-z0-9-_]*$/)",
+      ""
+    ]
+  });
+  return toolName;
+};
+var createStructFieldsFromSchema = (schema) => {
+  switch (schema.ast._tag) {
+    case "TypeLiteral":
+      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [
+        prop.name,
+        Schema3.make(mapSchemaTypeForLLM(prop.type))
+      ]));
+    case "VoidKeyword":
+      return {};
+    default:
+      return todo2(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
+};
+var mapSchemaTypeForLLM = (ast) => {
+  if (Type2.Ref.isRefSchemaAST(ast)) {
+    return RefFromLLM.ast;
+  }
+  return ast;
+};
+var isHandlerLike = (value) => {
+  return typeof value.tools === "object" && typeof value.handle === "function";
+};
+
+export {
+  ArtifactDiffResolver,
+  GenerationObserver,
+  AiModelError,
+  AiAssistantError,
+  AiSession,
+  createToolkit,
+  VersionPin,
+  GenericToolkit_exports,
+  createArtifactElement,
+  ArtifactId,
+  RefFromLLM,
+  makeToolResolverFromFunctions,
+  makeToolExecutionServiceFromFunctions
+};
+//# sourceMappingURL=chunk-CC7ER6Q3.mjs.map