@dxos/assistant 0.8.4-main.5acf9ea → 0.8.4-main.67995b8

package/dist/lib/browser/chunk-6WRGDEMH.mjs

@@ -0,0 +1,89 @@
+// src/extraction/extraction-ner-function/named-entity-recognition.ts
+import { pipeline } from "@xenova/transformers";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction-ner-function/named-entity-recognition.ts";
+var _ner;
+var getNer = () => {
+  if (!_ner) {
+    _ner = pipeline("ner", "Xenova/bert-base-NER").then((ner) => {
+      log.info("NER model is ready", void 0, {
+        F: __dxlog_file,
+        L: 23,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return ner;
+    });
+  }
+  return _ner;
+};
+var extractFullEntities = async (text) => {
+  const ner = await getNer();
+  const entities = await ner(text);
+  const tokenGroups = createTokenGroups(entities);
+  const combinedEntities = tokenGroups.map(combineNerTokens);
+  return combinedEntities;
+};
+var createTokenGroups = (tokens) => {
+  const tokenGroups = [];
+  const canBeCombined = (prevToken, currentToken) => {
+    const [currentState, currentEntity] = currentToken.entity.split("-");
+    const [prevState, prevEntity] = prevToken.entity.split("-");
+    if (prevEntity !== currentEntity) {
+      return false;
+    }
+    if (prevState === "O") {
+      return false;
+    }
+    if (currentState === "I") {
+      return true;
+    }
+    if ((prevState === "B" || prevState === "I") && currentState === "B") {
+      return currentToken.word.startsWith("#");
+    }
+    return false;
+  };
+  for (const token of tokens) {
+    if (tokenGroups.length === 0) {
+      tokenGroups.push([
+        token
+      ]);
+      continue;
+    }
+    const lastTokenGroup = tokenGroups.at(-1);
+    if (canBeCombined(lastTokenGroup.at(-1), token)) {
+      lastTokenGroup.push(token);
+      continue;
+    }
+    tokenGroups.push([
+      token
+    ]);
+  }
+  return tokenGroups;
+};
+var combineNerTokens = (group) => {
+  const combinedToken = {
+    entity: group.at(0).entity.split("-")[1],
+    score: group.reduce((acc, token) => acc + token.score, 0) / group.length,
+    index: group.at(0).index,
+    word: group.at(0).word,
+    start: group.at(0).start,
+    end: group.at(-1).end
+  };
+  for (const token of group.slice(1)) {
+    if (token.word.startsWith("#")) {
+      combinedToken.word += token.word.replace(/^#+/, "");
+    } else {
+      combinedToken.word += " " + token.word;
+    }
+  }
+  return combinedToken;
+};
+
+export {
+  getNer,
+  extractFullEntities,
+  createTokenGroups,
+  combineNerTokens
+};
+//# sourceMappingURL=chunk-6WRGDEMH.mjs.map

package/dist/lib/browser/chunk-6WRGDEMH.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/extraction/extraction-ner-function/named-entity-recognition.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport {\n  type TokenClassificationOutput,\n  type TokenClassificationPipelineType,\n  type TokenClassificationSingle,\n  pipeline,\n} from '@xenova/transformers';\n\nimport { log } from '@dxos/log';\n\nlet _ner: Promise<TokenClassificationPipelineType>;\n/**\n * Named Entity Recognition pipeline.\n * Initializes the pipeline on first call.\n * @returns The singleton promise that resolves to a token classification pipeline.\n */\nexport const getNer = () => {\n  if (!_ner) {\n    _ner = pipeline('ner', 'Xenova/bert-base-NER').then((ner) => {\n      log.info('NER model is ready');\n      return ner;\n    });\n  }\n  return _ner;\n};\n\n/**\n * Extracts entities from text using the named entity recognition pipeline and does simple grouping of tokens.\n */\nexport const extractFullEntities = async (text: string): Promise<TokenClassificationSingle[]> => {\n  const ner = await getNer();\n  const entities = (await ner(text)) as TokenClassificationOutput;\n  const tokenGroups = createTokenGroups(entities);\n  const combinedEntities = tokenGroups.map(combineNerTokens);\n  return combinedEntities;\n};\n\nexport const createTokenGroups = (tokens: TokenClassificationSingle[]): TokenClassificationSingle[][] => {\n  const tokenGroups: TokenClassificationSingle[][] = [];\n\n  const canBeCombined = (prevToken: TokenClassificationSingle, currentToken: TokenClassificationSingle) => {\n    const [currentState, currentEntity] = currentToken.entity.split('-'); // B, I, O\n    const [prevState, prevEntity] = prevToken.entity.split('-'); // B, I, O\n    if (prevEntity !== currentEntity) {\n      return false;\n    }\n    if (prevState === 'O') {\n      return false;\n    }\n    if (currentState === 'I') {\n      return true;\n    }\n    if ((prevState === 'B' || prevState === 'I') && currentState === 'B') {\n      return currentToken.word.startsWith('#');\n    }\n    return false;\n  };\n\n  for (const token of tokens) {\n    if (tokenGroups.length === 0) {\n      tokenGroups.push([token]);\n      continue;\n    }\n    const lastTokenGroup = tokenGroups.at(-1)!;\n    if (canBeCombined(lastTokenGroup.at(-1)!, token)) {\n      lastTokenGroup.push(token);\n      continue;\n    }\n    tokenGroups.push([token]);\n  }\n\n  return tokenGroups;\n};\n\nexport const combineNerTokens = (group: TokenClassificationSingle[]): TokenClassificationSingle => {\n  const combinedToken: TokenClassificationSingle = {\n    entity: group.at(0)!.entity.split('-')[1],\n    score: group.reduce((acc, token) => acc + token.score, 0) / group.length,\n    index: group.at(0)!.index,\n    word: group.at(0)!.word,\n    start: group.at(0)!.start,\n    end: group.at(-1)!.end,\n  };\n\n  for (const token of group.slice(1)) {\n    if (token.word.startsWith('#')) {\n      combinedToken.word += token.word.replace(/^#+/, '');\n    } else {\n      combinedToken.word += ' ' + token.word;\n    }\n  }\n\n  return combinedToken;\n};\n"],
+  "mappings": ";AAIA,SAIEA,gBACK;AAEP,SAASC,WAAW;;AAEpB,IAAIC;AAMG,IAAMC,SAAS,MAAA;AACpB,MAAI,CAACD,MAAM;AACTA,WAAOF,SAAS,OAAO,sBAAA,EAAwBI,KAAK,CAACC,QAAAA;AACnDJ,UAAIK,KAAK,sBAAA,QAAA;;;;;;AACT,aAAOD;IACT,CAAA;EACF;AACA,SAAOH;AACT;AAKO,IAAMK,sBAAsB,OAAOC,SAAAA;AACxC,QAAMH,MAAM,MAAMF,OAAAA;AAClB,QAAMM,WAAY,MAAMJ,IAAIG,IAAAA;AAC5B,QAAME,cAAcC,kBAAkBF,QAAAA;AACtC,QAAMG,mBAAmBF,YAAYG,IAAIC,gBAAAA;AACzC,SAAOF;AACT;AAEO,IAAMD,oBAAoB,CAACI,WAAAA;AAChC,QAAML,cAA6C,CAAA;AAEnD,QAAMM,gBAAgB,CAACC,WAAsCC,iBAAAA;AAC3D,UAAM,CAACC,cAAcC,aAAAA,IAAiBF,aAAaG,OAAOC,MAAM,GAAA;AAChE,UAAM,CAACC,WAAWC,UAAAA,IAAcP,UAAUI,OAAOC,MAAM,GAAA;AACvD,QAAIE,eAAeJ,eAAe;AAChC,aAAO;IACT;AACA,QAAIG,cAAc,KAAK;AACrB,aAAO;IACT;AACA,QAAIJ,iBAAiB,KAAK;AACxB,aAAO;IACT;AACA,SAAKI,cAAc,OAAOA,cAAc,QAAQJ,iBAAiB,KAAK;AACpE,aAAOD,aAAaO,KAAKC,WAAW,GAAA;IACtC;AACA,WAAO;EACT;AAEA,aAAWC,SAASZ,QAAQ;AAC1B,QAAIL,YAAYkB,WAAW,GAAG;AAC5BlB,kBAAYmB,KAAK;QAACF;OAAM;AACxB;IACF;AACA,UAAMG,iBAAiBpB,YAAYqB,GAAG,EAAC;AACvC,QAAIf,cAAcc,eAAeC,GAAG,EAAC,GAAKJ,KAAAA,GAAQ;AAChDG,qBAAeD,KAAKF,KAAAA;AACpB;IACF;AACAjB,gBAAYmB,KAAK;MAACF;KAAM;EAC1B;AAEA,SAAOjB;AACT;AAEO,IAAMI,mBAAmB,CAACkB,UAAAA;AAC/B,QAAMC,gBAA2C;IAC/CZ,QAAQW,MAAMD,GAAG,CAAA,EAAIV,OAAOC,MAAM,GAAA,EAAK,CAAA;IACvCY,OAAOF,MAAMG,OAAO,CAACC,KAAKT,UAAUS,MAAMT,MAAMO,OAAO,CAAA,IAAKF,MAAMJ;IAClES,OAAOL,MAAMD,GAAG,CAAA,EAAIM;IACpBZ,MAAMO,MAAMD,GAAG,CAAA,EAAIN;IACnBa,OAAON,MAAMD,GAAG,CAAA,EAAIO;IACpBC,KAAKP,MAAMD,GAAG,EAAC,EAAIQ;EACrB;AAEA,aAAWZ,SAASK,MAAMQ,MAAM,CAAA,GAAI;AAClC,QAAIb,MAAMF,KAAKC,WAAW,GAAA,GAAM;AAC9BO,oBAAcR,QAAQE,MAAMF,KAAKgB,QAAQ,OAAO,EAAA;IAClD,OAAO;AACLR,oBAAcR,QAAQ,MAAME,MAAMF;IACpC;EACF;AAEA,SAAOQ;AACT;",
+  "names": ["pipeline", "log", "_ner", "getNer", "then", "ner", "info", "extractFullEntities", "text", "entities", "tokenGroups", "createTokenGroups", "combinedEntities", "map", "combineNerTokens", "tokens", "canBeCombined", "prevToken", "currentToken", "currentState", "currentEntity", "entity", "split", "prevState", "prevEntity", "word", "startsWith", "token", "length", "push", "lastTokenGroup", "at", "group", "combinedToken", "score", "reduce", "acc", "index", "start", "end", "slice", "replace"]
+}

package/dist/lib/browser/chunk-SIXTNSGV.mjs

@@ -0,0 +1,250 @@
+// src/session/session.ts
+import { AiLanguageModel, AiToolkit } from "@effect/ai";
+import { Chunk, Context, Effect, Option, pipe, Stream } from "effect";
+import { Array, String } from "effect";
+import { AiParser, AiPreprocessor, getToolCalls, runTool, ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { Event } from "@dxos/async";
+import { todo } from "@dxos/debug";
+import { Obj } from "@dxos/echo";
+import { ObjectVersion } from "@dxos/echo-db";
+import { DatabaseService } from "@dxos/functions";
+import { log } from "@dxos/log";
+import { DataType } from "@dxos/schema";
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var AiAssistantError = class extends BaseError.extend("AI_ASSISTANT_ERROR") {
+};
+
+// src/session/session.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/session/session.ts";
+var AiSession = class {
+  constructor(_options = {}) {
+    this._options = _options;
+    this._semaphore = Effect.runSync(Effect.makeSemaphore(1));
+    this._pending = [];
+    this._history = [];
+    this.message = new Event();
+    this.block = new Event();
+    this.update = new Event();
+    this.streamEvent = new Event();
+    this.userMessage = new Event();
+    this.statusReport = new Event();
+    this.done = new Event();
+    this.run = (options) => Effect.gen(this, function* () {
+      this._history = [
+        ...options.history
+      ];
+      const promptMessages = yield* this._formatUserPrompt(options.prompt, options.history);
+      this._pending = [
+        promptMessages
+      ];
+      this.userMessage.emit(promptMessages);
+      do {
+        log("request", {
+          pending: this._pending.length,
+          history: this._history.length,
+          tools: Object.values(options.toolkit?.tools ?? {}).map((tool) => tool.name)
+        }, {
+          F: __dxlog_file,
+          L: 126,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const prompt = yield* AiPreprocessor.preprocessAiInput([
+          ...this._history,
+          ...this._pending
+        ]);
+        const blueprints = options.blueprints ?? [];
+        const systemPrompt = yield* pipe(blueprints, Effect.forEach((blueprint) => Effect.succeed(blueprint.instructions)), Effect.flatMap(Effect.forEach((template) => DatabaseService.loadRef(template.source))), Effect.map(Array.map((template) => `
+
+<blueprint>${template.content}</blueprint>`)), Effect.map(Array.reduce(options.systemPrompt ?? "", String.concat)));
+        const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap((bp) => bp.tools));
+        const blueprintToolkitHandler = yield* blueprintToolkit.toContext(yield* ToolExecutionService.handlersFor(blueprintToolkit));
+        const toolkit = options.toolkit != null ? AiToolkit.merge(options.toolkit, blueprintToolkit) : blueprintToolkit;
+        const toolkitWithBlueprintHandlers = yield* toolkit.pipe(Effect.provide(blueprintToolkitHandler));
+        log.info("run", {
+          systemPrompt: [
+            systemPrompt.slice(0, 32),
+            "...",
+            systemPrompt.slice(-32),
+            systemPrompt.length
+          ].join(" "),
+          tools: Object.keys(blueprintToolkit.tools)
+        }, {
+          F: __dxlog_file,
+          L: 155,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const blocks = yield* AiLanguageModel.streamText({
+          prompt,
+          system: systemPrompt,
+          toolkit: toolkitWithBlueprintHandlers,
+          disableToolCallResolution: true
+        }).pipe(AiParser.parseGptStream({
+          onBlock: (block) => Effect.gen(this, function* () {
+            if (block.pending) {
+              this.update.emit(block);
+            } else {
+              this.block.emit(block);
+            }
+          }),
+          onPart: (part) => Effect.gen(this, function* () {
+            this.streamEvent.emit(part);
+          })
+        }), Stream.runCollect, Effect.map(Chunk.toArray));
+        const response = Obj.make(DataType.Message, {
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "assistant"
+          },
+          blocks
+        });
+        this._pending.push(response);
+        this.message.emit(response);
+        const toolCalls = getToolCalls(response);
+        if (toolCalls.length === 0) {
+          break;
+        }
+        const toolResults = yield* runTools(toolCalls, toolkitWithBlueprintHandlers);
+        this._pending.push(Obj.make(DataType.Message, {
+          created: (/* @__PURE__ */ new Date()).toISOString(),
+          sender: {
+            role: "user"
+          },
+          blocks: toolResults
+        }));
+      } while (true);
+      return this._pending;
+    }).pipe(this._semaphore.withPermits(1), Effect.withSpan("AiSession.run"));
+    this._formatUserPrompt = (prompt, history) => Effect.gen(function* () {
+      const prelude = [];
+      const artifactDiffResolver = yield* Effect.serviceOption(ArtifactDiffResolver);
+      if (Option.isSome(artifactDiffResolver)) {
+        const versions = gatherObjectVersions(history);
+        const artifactDiff = yield* Effect.tryPromise({
+          try: () => artifactDiffResolver.value.resolve([
+            ...versions.entries()
+          ].map(([id, version]) => ({
+            id,
+            lastVersion: version
+          }))),
+          catch: AiAssistantError.wrap("Artifact diff resolution error")
+        });
+        log.info("vision", {
+          artifactDiff,
+          versions
+        }, {
+          F: __dxlog_file,
+          L: 240,
+          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({
+            _tag: "anchor",
+            objectId: id,
+            version
+          });
+        }
+        if (artifactDiff.size > 0) {
+          prelude.push(createArtifactUpdateBlock(artifactDiff));
+        }
+      }
+      return Obj.make(DataType.Message, {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        sender: {
+          role: "user"
+        },
+        blocks: [
+          ...prelude,
+          {
+            _tag: "text",
+            text: prompt
+          }
+        ]
+      });
+    });
+  }
+  async runStructured(schema, options) {
+    return todo();
+  }
+  abort() {
+    this._stream?.abort();
+  }
+};
+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: `
+      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")}
+    `
+  };
+};
+var ArtifactDiffResolver = class extends Context.Tag("@dxos/assistant/ArtifactDiffResolver")() {
+};
+var runTools = Effect.fn("runTools")(function* (toolCalls, toolkit) {
+  const toolkitWithHandlers = Effect.isEffect(toolkit) ? yield* toolkit : toolkit;
+  return yield* Effect.forEach(toolCalls, (toolCall) => runTool(toolkitWithHandlers, toolCall));
+});
+
+// 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 {
+      _tag: "json",
+      disposition: VersionPin.DISPOSITION,
+      data: JSON.stringify(pin)
+    };
+  }
+};
+
+export {
+  AiSession,
+  ArtifactDiffResolver,
+  VersionPin
+};
+//# sourceMappingURL=chunk-SIXTNSGV.mjs.map

package/dist/lib/browser/chunk-SIXTNSGV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/session/session.ts", "../../../src/errors.ts", "../../../src/session/version-pin.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { AiLanguageModel, AiToolkit, type AiError, type AiResponse, type AiTool } from '@effect/ai';\nimport { Chunk, Context, Effect, Option, pipe, Stream, type Schema } from 'effect';\nimport { Array, String } from 'effect';\n\nimport {\n  AiParser,\n  AiPreprocessor,\n  getToolCalls,\n  runTool,\n  ToolExecutionService,\n  ToolResolverService,\n  type AgentStatus,\n  type AiInputPreprocessingError,\n  type AiToolNotFoundError,\n  type GenerationStream,\n} from '@dxos/ai';\nimport { Event } from '@dxos/async';\nimport { type Blueprint } from '@dxos/blueprints';\nimport { todo } from '@dxos/debug';\nimport { Obj } from '@dxos/echo';\nimport { ObjectVersion } from '@dxos/echo-db';\nimport { type ObjectId } from '@dxos/echo-schema';\nimport { DatabaseService } from '@dxos/functions';\nimport { log } from '@dxos/log';\nimport { DataType, type ContentBlock } from '@dxos/schema';\n\nimport { AiAssistantError } from '../errors';\n\nexport type AiSessionOptions = {};\n\nexport type SessionRunOptions<Tools extends AiTool.Any> = {\n  prompt: string;\n  history: DataType.Message[];\n  systemPrompt?: string;\n  toolkit?: AiToolkit.AiToolkit<Tools>;\n  blueprints?: Blueprint.Blueprint[];\n};\n\n/**\n * Contains message history, tools, current context.\n * Current context means the state of the app, time of day, and other contextual information.\n * It makes requests to the model, its a state machine.\n * It keeps track of the current goal.\n * It manages the context window.\n * Tracks the success criteria of reaching the goal, exposing metrics (stretch).\n * Could be run locally in the app or remotely.\n * Could be personal or shared.\n */\nexport class AiSession {\n  // TODO(burdon): Move to conversation.\n  private readonly _semaphore = Effect.runSync(Effect.makeSemaphore(1));\n\n  /** Pending messages (incl. the current user request). */\n  private _pending: DataType.Message[] = [];\n\n  /** Current streaming response. */\n  private _stream: GenerationStream | undefined;\n\n  /** Prior history from queue. */\n  private _history: DataType.Message[] = [];\n\n  /**\n   * New message.\n   */\n  public readonly message = new Event<DataType.Message>();\n\n  /**\n   * Complete block added to Message.\n   */\n  public readonly block = new Event<ContentBlock.Any>();\n\n  /**\n   * Update partial block (while streaming).\n   */\n  public readonly update = new Event<ContentBlock.Any>();\n\n  /**\n   * Unparsed events from the underlying generation stream.\n   */\n  public readonly streamEvent = new Event<AiResponse.Part>();\n\n  /**\n   * User prompt or tool result.\n   */\n  public readonly userMessage = new Event<DataType.Message>();\n\n  /**\n   * Agent self-reporting its status.\n   * Triggered by the model.\n   */\n  public readonly statusReport = new Event<AgentStatus>();\n\n  /**\n   * Emits when the session is done.\n   */\n  public readonly done = new Event<void>();\n\n  constructor(private readonly _options: AiSessionOptions = {}) {}\n\n  /**\n   * Runs the AI model loop interacting with tools and artifacts.\n   * @param options - The session options.\n   * @returns The messages generated by the session, including the user's prompt.\n   */\n  // TODO(dmaretskyi): Toolkit context doesn't get added to the effect type.\n  run = <Tools extends AiTool.Any>(\n    options: SessionRunOptions<Tools>,\n  ): Effect.Effect<\n    DataType.Message[],\n    AiAssistantError | AiInputPreprocessingError | AiToolNotFoundError | AiError.AiError,\n    AiLanguageModel.AiLanguageModel | ToolResolverService | ToolExecutionService | AiTool.ToHandler<Tools>\n  > =>\n    Effect.gen(this, function* () {\n      this._history = [...options.history];\n\n      const promptMessages = yield* this._formatUserPrompt(options.prompt, options.history);\n      this._pending = [promptMessages];\n      this.userMessage.emit(promptMessages);\n\n      // Potential tool use loop.\n      do {\n        log('request', {\n          pending: this._pending.length,\n          history: this._history.length,\n          tools: (Object.values(options.toolkit?.tools ?? {}) as AiTool.Any[]).map((tool: AiTool.Any) => tool.name),\n        });\n\n        const prompt = yield* AiPreprocessor.preprocessAiInput([...this._history, ...this._pending]);\n\n        const blueprints = options.blueprints ?? [];\n\n        // Build system prompt from blueprint templates.\n        // TODO(dmaretskyi): Loading BP from the Database should be done at the higher level. We need a type for the resolved blueprint.\n        const systemPrompt = yield* pipe(\n          blueprints,\n          Effect.forEach((blueprint) => Effect.succeed(blueprint.instructions)),\n          Effect.flatMap(Effect.forEach((template) => DatabaseService.loadRef(template.source))),\n          Effect.map(Array.map((template) => `\\n\\n<blueprint>${template.content}</blueprint>`)),\n          Effect.map(Array.reduce(options.systemPrompt ?? '', String.concat)),\n        );\n\n        // Build a combined toolkit from the blueprint tools and the provided toolkit.\n        const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap((bp) => bp.tools));\n        const blueprintToolkitHandler: Context.Context<AiTool.ToHandler<AiTool.Any>> =\n          yield* blueprintToolkit.toContext(yield* ToolExecutionService.handlersFor(blueprintToolkit));\n        const toolkit = options.toolkit != null ? AiToolkit.merge(options.toolkit, blueprintToolkit) : blueprintToolkit;\n        const toolkitWithBlueprintHandlers = yield* toolkit.pipe(\n          Effect.provide(blueprintToolkitHandler) as any,\n        ) as Effect.Effect<AiToolkit.ToHandler<any>, never, AiTool.ToHandler<Tools>>;\n\n        log.info('run', {\n          systemPrompt: [systemPrompt.slice(0, 32), '...', systemPrompt.slice(-32), systemPrompt.length].join(' '),\n          tools: Object.keys(blueprintToolkit.tools),\n        });\n\n        const blocks = yield* AiLanguageModel.streamText({\n          prompt,\n          system: systemPrompt,\n          toolkit: toolkitWithBlueprintHandlers,\n          disableToolCallResolution: true,\n        }).pipe(\n          AiParser.parseGptStream({\n            onBlock: (block) =>\n              Effect.gen(this, function* () {\n                if (block.pending) {\n                  this.update.emit(block);\n                } else {\n                  this.block.emit(block);\n                }\n              }),\n            onPart: (part) =>\n              Effect.gen(this, function* () {\n                this.streamEvent.emit(part);\n              }),\n          }),\n          Stream.runCollect,\n          Effect.map(Chunk.toArray),\n        );\n\n        const response = Obj.make(DataType.Message, {\n          created: new Date().toISOString(),\n          sender: { role: 'assistant' },\n          blocks,\n        });\n        this._pending.push(response);\n        this.message.emit(response);\n\n        const toolCalls = getToolCalls(response);\n        if (toolCalls.length === 0) {\n          break;\n        }\n\n        const toolResults = yield* runTools(toolCalls, toolkitWithBlueprintHandlers as any);\n        this._pending.push(\n          Obj.make(DataType.Message, {\n            created: new Date().toISOString(),\n            sender: { role: 'user' },\n            blocks: toolResults,\n          }),\n        );\n      } while (true);\n\n      return this._pending;\n    }).pipe(this._semaphore.withPermits(1), Effect.withSpan('AiSession.run'));\n\n  async runStructured<S extends Schema.Schema.AnyNoContext>(\n    schema: S,\n    options: SessionRunOptions<AiTool.Any>,\n  ): Promise<Schema.Schema.Type<S>> {\n    return todo();\n    // const parser = structuredOutputParser(schema);\n    // const result = await this.run({\n    //   ...options,\n    //   executableTools: [...(options.executableTools ?? []), parser.tool],\n    // });\n    // return parser.getResult(result);\n  }\n\n  private _formatUserPrompt = (prompt: string, history: DataType.Message[]) =>\n    Effect.gen(function* () {\n      const prelude: ContentBlock.Any[] = [];\n\n      // TODO(dmaretskyi): Evaluate other approaches as `serviceOption` isn't represented in the type system.\n      const artifactDiffResolver = yield* Effect.serviceOption(ArtifactDiffResolver);\n      if (Option.isSome(artifactDiffResolver)) {\n        const versions = gatherObjectVersions(history);\n\n        const artifactDiff = yield* Effect.tryPromise({\n          try: () =>\n            artifactDiffResolver.value.resolve(\n              [...versions.entries()].map(([id, version]) => ({ id, lastVersion: version })),\n            ),\n          catch: AiAssistantError.wrap('Artifact diff resolution error'),\n        });\n\n        log.info('vision', {\n          artifactDiff,\n          versions,\n        });\n\n        for (const [id, { version }] of [...artifactDiff.entries()]) {\n          if (ObjectVersion.equals(version, versions.get(id)!)) {\n            artifactDiff.delete(id);\n            continue;\n          }\n\n          prelude.push({ _tag: 'anchor', objectId: id, version });\n        }\n        if (artifactDiff.size > 0) {\n          prelude.push(createArtifactUpdateBlock(artifactDiff));\n        }\n      }\n\n      return Obj.make(DataType.Message, {\n        created: new Date().toISOString(),\n        sender: { role: 'user' },\n        blocks: [...prelude, { _tag: 'text', text: prompt }],\n      });\n    });\n\n  abort(): void {\n    this._stream?.abort();\n  }\n}\n\nconst gatherObjectVersions = (messages: DataType.Message[]): Map<ObjectId, ObjectVersion> => {\n  const artifactIds = new Map<ObjectId, ObjectVersion>();\n  for (const message of messages) {\n    for (const block of message.blocks) {\n      if (block._tag === 'anchor') {\n        artifactIds.set(block.objectId, block.version as ObjectVersion);\n      }\n    }\n  }\n\n  return artifactIds;\n};\n\nconst createArtifactUpdateBlock = (\n  artifactDiff: Map<ObjectId, { version: ObjectVersion; diff?: string }>,\n): ContentBlock.Any => {\n  return {\n    _tag: 'text',\n    // TODO(dmaretskyi): Does this need to be a special content-block?\n    disposition: 'artifact-update',\n    text: `\n      The following artifacts have been updated since the last message:\n      ${[...artifactDiff.entries()]\n        .map(([id, { diff }]) => `<changed-artifact id=\"${id}\">${diff ? `\\n${diff}` : ''}</changed-artifact>`)\n        .join('\\n')}\n    `,\n  };\n};\n\n/**\n * Resolves artifact ids to their versions.\n * Used to give the model a sense of the changes to the artifacts made by users during the conversation.\n * The artifacts versions are pinned in the history, and whenever the artifact changes in-between assistant's steps,\n * a diff is inserted into the conversation.\n *\n * Can be optionally provided to the session run call.\n */\n// TODO(dmaretskyi): Convert to Context.Reference\nexport class ArtifactDiffResolver extends Context.Tag('@dxos/assistant/ArtifactDiffResolver')<\n  ArtifactDiffResolver,\n  ArtifactDiffResolver.Service\n>() {}\n\nexport namespace ArtifactDiffResolver {\n  export type Service = {\n    resolve: (artifacts: { id: ObjectId; lastVersion: ObjectVersion }[]) => Promise<\n      Map<\n        ObjectId,\n        {\n          version: ObjectVersion;\n          diff?: string;\n        }\n      >\n    >;\n  };\n}\n\nconst runTools: <Tools extends AiTool.Any>(\n  toolCalls: ContentBlock.ToolCall[],\n  toolkit: AiToolkit.AiToolkit<Tools>,\n) => Effect.Effect<ContentBlock.ToolResult[], AiError.AiError, AiTool.ToHandler<Tools>> = Effect.fn('runTools')(\n  function* (toolCalls, toolkit) {\n    const toolkitWithHandlers = Effect.isEffect(toolkit) ? yield* toolkit : toolkit;\n\n    return yield* Effect.forEach(toolCalls, (toolCall) => runTool(toolkitWithHandlers, toolCall));\n  },\n);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError } from '@dxos/errors';\n\n/**\n * Generic error for AI agent execution.\n */\nexport class AiAssistantError extends BaseError.extend('AI_ASSISTANT_ERROR') {}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { Schema } from 'effect';\n\nimport { type ObjectVersion } from '@dxos/echo-db';\nimport { getVersion } from '@dxos/echo-db';\nimport { ObjectId, type BaseEchoObject } from '@dxos/echo-schema';\nimport { type ContentBlock } from '@dxos/schema';\n\n// TODO(dmaretskyi): Extract.\nconst ObjectVersionSchema = Schema.Unknown as Schema.Schema<ObjectVersion>;\n\nconst VersionPinSchema = Schema.Struct({\n  // TODO(dmaretskyi): Use Ref when those support encoding.\n  objectId: ObjectId,\n  // TODO(dmaretskyi): Could be opaque\n  version: ObjectVersionSchema,\n});\n\n/**\n * Used to pin a specific version of an object during the course of a conversation.\n * This allows us to detect when the object changes during the course of the conversation.\n */\nexport interface VersionPin extends Schema.Schema.Type<typeof VersionPinSchema> {}\n\nexport const VersionPin: typeof VersionPinSchema & {\n  DISPOSITION: 'version-pin';\n  fromObject: (object: BaseEchoObject) => VersionPin;\n  createBlock: (pin: VersionPin) => ContentBlock.Any;\n} = class extends VersionPinSchema {\n  static readonly DISPOSITION = 'version-pin';\n  static fromObject(object: BaseEchoObject): VersionPin {\n    return VersionPin.make({\n      objectId: object.id,\n      version: getVersion(object),\n    });\n  }\n\n  static createBlock(pin: VersionPin): ContentBlock.Any {\n    return {\n      _tag: 'json',\n      disposition: VersionPin.DISPOSITION,\n      data: JSON.stringify(pin),\n    };\n  }\n};\n"],
+  "mappings": "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",
+  "names": ["AiLanguageModel", "AiToolkit", "Chunk", "Context", "Effect", "Option", "pipe", "Stream", "Array", "String", "AiParser", "AiPreprocessor", "getToolCalls", "runTool", "ToolExecutionService", "ToolResolverService", "Event", "todo", "Obj", "ObjectVersion", "DatabaseService", "log", "DataType", "BaseError", "AiAssistantError", "BaseError", "extend", "AiSession", "_options", "_semaphore", "Effect", "runSync", "makeSemaphore", "_pending", "_history", "message", "Event", "block", "update", "streamEvent", "userMessage", "statusReport", "done", "run", "options", "gen", "history", "promptMessages", "_formatUserPrompt", "prompt", "emit", "log", "pending", "length", "tools", "Object", "values", "toolkit", "map", "tool", "name", "AiPreprocessor", "preprocessAiInput", "blueprints", "systemPrompt", "pipe", "forEach", "blueprint", "succeed", "instructions", "flatMap", "template", "DatabaseService", "loadRef", "source", "Array", "content", "reduce", "String", "concat", "blueprintToolkit", "ToolResolverService", "resolveToolkit", "bp", "blueprintToolkitHandler", "toContext", "ToolExecutionService", "handlersFor", "AiToolkit", "merge", "toolkitWithBlueprintHandlers", "provide", "info", "slice", "join", "keys", "blocks", "AiLanguageModel", "streamText", "system", "disableToolCallResolution", "AiParser", "parseGptStream", "onBlock", "onPart", "part", "Stream", "runCollect", "Chunk", "toArray", "response", "Obj", "make", "DataType", "Message", "created", "Date", "toISOString", "sender", "role", "push", "toolCalls", "getToolCalls", "toolResults", "runTools", "withPermits", "withSpan", "prelude", "artifactDiffResolver", "serviceOption", "ArtifactDiffResolver", "Option", "isSome", "versions", "gatherObjectVersions", "artifactDiff", "tryPromise", "try", "value", "resolve", "entries", "id", "version", "lastVersion", "catch", "AiAssistantError", "wrap", "ObjectVersion", "equals", "get", "delete", "_tag", "objectId", "size", "createArtifactUpdateBlock", "text", "runStructured", "schema", "todo", "abort", "_stream", "messages", "artifactIds", "Map", "set", "disposition", "diff", "Context", "Tag", "fn", "toolkitWithHandlers", "isEffect", "toolCall", "runTool", "Schema", "getVersion", "ObjectId", "ObjectVersionSchema", "Schema", "Unknown", "VersionPinSchema", "Struct", "objectId", "ObjectId", "version", "VersionPin", "DISPOSITION", "fromObject", "object", "make", "id", "getVersion", "createBlock", "pin", "_tag", "disposition", "data", "JSON", "stringify"]
+}