@dxos/assistant 0.10.0 → 0.11.1

package/src/session/AiSession.ts

@@ -4,22 +4,24 @@
 
 // @import-as-namespace
 
-import { type Registry as AtomRegistry } from '@effect-atom/atom-react';
+import { type Registry as AtomRegistry } from '@effect-atom/atom';
 import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
 import * as Either from 'effect/Either';
 import { pipe } from 'effect/Function';
 import * as Layer from 'effect/Layer';
+import * as Order from 'effect/Order';
 import * as Record from 'effect/Record';
 import * as Runtime from 'effect/Runtime';
 
 import { type OpaqueToolkit, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
-import { McpServer, Operation, type Skill, Trace } from '@dxos/compute';
+import { type Instructions, McpServer, Operation, type Skill, Trace } from '@dxos/compute';
 import { Resource } from '@dxos/context';
 import { Database, Feed, Filter, Obj, Registry } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { McpToolkit } from '@dxos/mcp-client';
+import { FeedProtocol } from '@dxos/protocols';
 import { type ContentBlock, Message } from '@dxos/types';
 
 import { AiRequest, type GenerationObserver, formatSystemPrompt } from '../request';
@@ -55,6 +57,11 @@ export type Options = {
   runtime: Runtime.Runtime<Database.Service>;
   /** @effect-atom/atom-react Registry for reactive state. */
   registry?: AtomRegistry.Registry;
+  /**
+   * Instructions steering the conversation (typically the owning `Chat`'s), rendered into the system
+   * prompt on every turn. The session is feed-centric and cannot reach its chat, so these are passed in.
+   */
+  instructions?: readonly Instructions.Instructions[];
 };
 
 /**
@@ -68,18 +75,22 @@ const SUMMARY_THRESHOLD = 80_000;
  * Executes tools based on AI responses and supports cancellation of in-progress requests.
  */
 export class Session extends Resource {
+  private readonly _feed: Feed.Feed;
+  private readonly _runtime: Runtime.Runtime<Database.Service>;
+  readonly #instructions: readonly Instructions.Instructions[];
+
   /**
    * Skills and objects bound to the session.
    */
   private readonly _binder: AiContext.Binder;
-  private readonly _feed: Feed.Feed;
-  private readonly _runtime: Runtime.Runtime<Database.Service>;
+
   private readonly _sessionLoader = new SessionLoader();
 
   public constructor(options: Options) {
     super();
     this._feed = options.feed;
     this._runtime = options.runtime;
+    this.#instructions = options.instructions ?? [];
     invariant(this._feed);
     invariant(this._runtime);
     this._binder = new AiContext.Binder({
@@ -101,11 +112,23 @@ export class Session extends Resource {
     return this._binder;
   }
 
+  /**
+   * The conversation as the model should see it: only the messages reachable from the feed's current
+   * head, so a soft fork's abandoned turns are excluded.
+   */
   public async getHistory(): Promise<Message.Message[]> {
+    const { items: reachable } = Feed.history(await this.#messagesInAppendOrder());
+    return Runtime.runPromise(this._runtime)(this._sessionLoader.reifyHistory(this._feed, reachable));
+  }
+
+  /**
+   * Every message in the feed, in append order — what `Feed.history` needs, since it walks lineage
+   * positionally rather than by `created`, a wall clock peers do not agree on.
+   */
+  async #messagesInAppendOrder(): Promise<Message.Message[]> {
     const queryResult = await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Filter.type(Message.Message)));
     const items = await queryResult.run();
-    const messages = items.filter(Obj.instanceOf(Message.Message));
-    return Runtime.runPromise(this._runtime)(this._sessionLoader.reifyHistory(this._feed, messages));
+    return Array.sort(items.filter(Obj.instanceOf(Message.Message)), byFeedPosition);
   }
 
   getTools(): Effect.Effect<
@@ -132,6 +155,39 @@ export class Session extends Resource {
     );
   }
 
+  /**
+   * Appends one of this turn's messages to the feed, consuming a pending rewind if there is one.
+   *
+   * The rewind decision is made in the UI, but the continuation is appended by the agent's process,
+   * which resolves the feed and never sees the chat — so the feed carries the intent and this is where
+   * it becomes lineage. `rewindFrom` names the earliest discarded message, so the new parent is whatever
+   * precedes it; nothing preceding means the continuation starts a fresh line. Only the first message of
+   * a turn finds it set, since the append clears it, so the rest of the turn chains implicitly. Clearing
+   * after the append (rather than before) leaves the rewind pending if the turn fails.
+   */
+  public async appendTurnMessage(message: Message.Message): Promise<void> {
+    const rewindFrom = this._feed.rewindFrom;
+    const parent = rewindFrom !== undefined ? await this.#parentForRewind(rewindFrom) : undefined;
+
+    return Runtime.runPromise(this._runtime)(
+      Effect.gen(this, function* () {
+        yield* Feed.append(this._feed, [message], parent !== undefined ? { parent } : undefined);
+        if (rewindFrom !== undefined) {
+          Obj.update(this._feed, (feed) => {
+            feed.rewindFrom = undefined;
+          });
+        }
+      }),
+    );
+  }
+
+  /** The message preceding `rewindFrom` in append order, which the continuation parents to. */
+  async #parentForRewind(rewindFrom: string): Promise<string | undefined> {
+    const messages = await this.#messagesInAppendOrder();
+    const index = messages.findIndex((message) => message.id === rewindFrom);
+    return index > 0 ? messages[index - 1].id : undefined;
+  }
+
   /**
    * Creates a new cancelable request effect.
    */
@@ -153,14 +209,14 @@ export class Session extends Resource {
         summarizationThreshold: SUMMARY_THRESHOLD,
         observer: params.observer,
         persist: params.persist,
-        onOutput: (message) =>
-          Effect.promise(() => Runtime.runPromise(this._runtime)(Feed.append(this._feed, [message]))),
+        onOutput: (message) => Effect.promise(() => this.appendTurnMessage(message)),
       });
 
       yield* request.begin({
         history,
         skills,
         objects,
+        instructions: this.#instructions,
         prompt: params.prompt,
         system: params.system,
       });
@@ -189,6 +245,7 @@ export class Session extends Resource {
           system: params.system,
           skills: currentSkills,
           objects: this.context.getObjects(),
+          instructions: this.#instructions,
         }).pipe(Effect.orDie);
 
         const { done, finishReason } = yield* request.runAgentTurn({ system, toolkit });
@@ -294,3 +351,19 @@ const connectMcpServers = (
     Effect.map(Array.filterMap((_) => Either.getRight(_))),
   );
 };
+
+/**
+ * Orders feed items by the position the server assigned them. Unpositioned blocks (written locally and
+ * not yet acknowledged) sort last, which is what we want: a message just written is the newest.
+ */
+const byFeedPosition = Order.make<Message.Message>((a, b) => {
+  const positionA = feedPosition(a);
+  const positionB = feedPosition(b);
+  return positionA === positionB ? 0 : positionA < positionB ? -1 : 1;
+});
+
+const feedPosition = (message: Message.Message): number => {
+  const key = Obj.getKeys(message, FeedProtocol.KEY_QUEUE_POSITION).at(0)?.id;
+  const position = key !== undefined ? Number(key) : Number.NaN;
+  return Number.isNaN(position) ? Number.POSITIVE_INFINITY : position;
+};

package/src/tool-runtime/services.test.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { Obj, Ref } from '@dxos/echo';
+import { EID, EntityId, SpaceId } from '@dxos/keys';
+
+import { createStructFieldsFromSchema } from './services';
+
+describe('createStructFieldsFromSchema', () => {
+  const SPACE = SpaceId.random();
+  const OBJECT = EntityId.random();
+
+  // Projects a tool input schema for the LLM and decodes the given `in` value the way a tool call would.
+  const decodeIn = (schema: Schema.Schema<any, any>, value: unknown): any[] => {
+    const fields = createStructFieldsFromSchema(schema);
+    const decoded: any = Schema.decodeUnknownSync(Schema.Struct(fields))({ in: value });
+    return decoded.in;
+  };
+
+  // An LLM-supplied ref URI string must coerce to a valid local EID. Refs nested inside an optional
+  // field surface as a `T | undefined` union; the projection must still route them through the
+  // LLM-friendly coercion so a qualified URI does not become a malformed `echo:////…`.
+  test('coerces refs passed as qualified URI strings inside an optional array', ({ expect }) => {
+    const refs = decodeIn(Schema.Struct({ in: Schema.optional(Schema.Array(Ref.Ref(Obj.Unknown))) }), [
+      `echo://${SPACE}/${OBJECT}`,
+    ]);
+    expect(refs).toHaveLength(1);
+    expect(() => EID.parse(refs[0].uri)).not.toThrow();
+    expect(refs[0].uri).toBe(`echo:///${OBJECT}`);
+  });
+
+  test('coerces refs passed as qualified URI strings inside a required array', ({ expect }) => {
+    const refs = decodeIn(Schema.Struct({ in: Schema.Array(Ref.Ref(Obj.Unknown)) }), [`echo://${SPACE}/${OBJECT}`]);
+    expect(refs).toHaveLength(1);
+    expect(refs[0].uri).toBe(`echo:///${OBJECT}`);
+  });
+});

package/src/tool-runtime/services.ts

@@ -173,7 +173,14 @@ const makeToolName = (name: string) => {
 };
 
 // TODO(dmaretskyi): Factor out.
-const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<string, Schema.Schema<any, any>> => {
+/**
+ * Projects an operation input struct into the LLM-facing tool parameter fields, mapping each
+ * property through {@link mapSchemaTypeForLLM} (so refs become the model-friendly `RefFromLLM`).
+ * Exported for testing.
+ */
+export const createStructFieldsFromSchema = (
+  schema: Schema.Schema<any, any>,
+): Record<string, Schema.Schema<any, any>> => {
   switch (schema.ast._tag) {
     case 'TypeLiteral':
       return Object.fromEntries(
@@ -218,6 +225,14 @@ const mapSchemaTypeForLLM = (ast: SchemaAST.AST): SchemaAST.AST => {
       ast.indexSignatures,
       ast.annotations,
     );
+  } else if (SchemaAST.isUnion(ast)) {
+    // `Schema.optional(Schema.Array(Ref(...)))` surfaces the value as a `T | undefined` union, so a
+    // ref nested inside an optional/union field must be mapped through each member — otherwise it
+    // keeps the raw `Ref` encoding and an LLM-supplied URI string is never coerced via `RefFromLLM`.
+    return SchemaAST.Union.make(
+      ast.types.map((member) => mapSchemaTypeForLLM(member)),
+      ast.annotations,
+    );
   }
 
   return ast;

package/src/util/execution-graph.ts

@@ -3,8 +3,8 @@
 //
 
 import { AgentStatus } from '@dxos/ai';
+import { MESSAGE_PROPERTY_TOOL_CALL_ID } from '@dxos/compute-runtime';
 import { type Entity, Obj, type Ref } from '@dxos/echo';
-import { MESSAGE_PROPERTY_TOOL_CALL_ID } from '@dxos/functions';
 import { EID, type EntityId } from '@dxos/keys';
 import { LogLevel } from '@dxos/log';
 import { ContentBlock, Message } from '@dxos/types';

package/dist/lib/neutral/chunk-J5LGTIGS.mjs

@@ -1,10 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-export {
-  __export
-};
-//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/neutral/chunk-J5LGTIGS.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}

package/dist/lib/neutral/extraction/index.mjs

@@ -1,197 +0,0 @@
-import "../chunk-J5LGTIGS.mjs";
-
-// src/extraction/extraction-llm-function/proper-noun-extraction.ts
-import * as LanguageModel from "@effect/ai/LanguageModel";
-import * as Effect from "effect/Effect";
-import * as Schema2 from "effect/Schema";
-import { AiService } from "@dxos/ai";
-import { Obj } from "@dxos/echo";
-import { Message } from "@dxos/types";
-
-// src/extraction/quotes.ts
-import * as Schema from "effect/Schema";
-import { Filter, Query } from "@dxos/echo";
-import { EID, EntityId } from "@dxos/keys";
-var ReferencedQuotes = Schema.Struct({
-  references: Schema.Array(Schema.Struct({
-    id: Schema.String,
-    quote: Schema.String
-  })).pipe(Schema.mutable).annotations({
-    // TODO(burdon): Does this description make sense?
-    description: `
-      The references to the context objects that are mentioned in the transcript. 
-      Quote should match the original transcript text exactly, while id is the id of the context object.
-    `
-  })
-});
-var findReferences = async (nouns, db, { searchKind = "full-text" } = {}) => {
-  const normalizedNouns = Array.from(new Set(nouns.map((noun) => noun.trim()).filter((noun) => noun.length > 0))).sort((leftNoun, rightNoun) => rightNoun.length - leftNoun.length);
-  const references = await Promise.all(normalizedNouns.map(async (noun) => {
-    const objects = await db.query(Query.select(Filter.text(noun, {
-      type: searchKind
-    }))).run();
-    return objects.length > 0 ? [
-      {
-        id: objects[0].id.toString(),
-        quote: noun
-      }
-    ] : [];
-  }));
-  return {
-    references: references.flat()
-  };
-};
-var insertReferences = (text, quotes) => {
-  const references = quotes.references.filter((quote) => EntityId.isValid(quote.id)).sort((left, right) => right.quote.length - left.quote.length);
-  for (const quote of references) {
-    const regex = new RegExp(quote.quote.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
-    text = replaceOutsideLinks(text, regex, `[${quote.quote}](${EID.make({
-      entityId: quote.id
-    })})`);
-  }
-  return text;
-};
-var MARKDOWN_LINK = /\[[^\]]*\]\([^)]*\)/g;
-var replaceOutsideLinks = (text, regex, replacement) => {
-  let result = "";
-  let plainStart = 0;
-  for (const link of text.matchAll(MARKDOWN_LINK)) {
-    const index = link.index ?? 0;
-    result += text.slice(plainStart, index).replace(regex, replacement) + link[0];
-    plainStart = index + link[0].length;
-  }
-  return result + text.slice(plainStart).replace(regex, replacement);
-};
-
-// src/extraction/extraction-llm-function/proper-noun-extraction.ts
-var EXTRACTION_MODEL = "com.anthropic.model.claude-haiku-4-5.default";
-var ProperNouns = Schema2.Struct({
-  properNouns: Schema2.Array(Schema2.String).annotations({
-    description: "Proper nouns (names of people, organizations, places, products) mentioned in the text."
-  })
-});
-var extractProperNouns = (text) => Effect.gen(function* () {
-  const { value } = yield* Effect.scoped(LanguageModel.generateObject({
-    schema: ProperNouns,
-    prompt: [
-      "Extract every proper noun (people, organizations, places, products) mentioned in the transcript text below.",
-      "Return only the surface strings exactly as they appear. Exclude common nouns and pronouns.",
-      "",
-      "Transcript:",
-      text
-    ].join("\n")
-  }));
-  return value.properNouns.map((noun) => noun.trim()).filter((noun) => noun.length >= 3);
-}).pipe(Effect.provide(AiService.model(EXTRACTION_MODEL)));
-var enrichTranscriptMessage = (message, { db }) => Effect.gen(function* () {
-  const blocks = yield* Effect.forEach(message.blocks, (block) => Effect.gen(function* () {
-    if (block._tag !== "transcript") {
-      return block;
-    }
-    const nouns = yield* extractProperNouns(block.text);
-    const references = yield* Effect.promise(() => findReferences([
-      ...nouns
-    ], db));
-    return {
-      ...block,
-      text: insertReferences(block.text, references)
-    };
-  }));
-  return Obj.make(Message.Message, {
-    id: message.id,
-    sender: message.sender,
-    created: message.created,
-    properties: message.properties,
-    blocks
-  });
-});
-
-// 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/compute/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, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 14, S: void 0 });
-      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 {
-  ProperNouns,
-  ReferencedQuotes,
-  combineNerTokens,
-  createTokenGroups,
-  enrichTranscriptMessage,
-  extractFullEntities,
-  extractProperNouns,
-  findReferences,
-  getNer,
-  insertReferences
-};
-//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/extraction/index.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/extraction/extraction-llm-function/proper-noun-extraction.ts", "../../../../src/extraction/quotes.ts", "../../../../src/extraction/extraction-ner-function/named-entity-recognition.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as LanguageModel from '@effect/ai/LanguageModel';\nimport * as Effect from 'effect/Effect';\nimport * as Schema from 'effect/Schema';\n\nimport { AiService } from '@dxos/ai';\nimport { type Database, Obj } from '@dxos/echo';\nimport { Message } from '@dxos/types';\n\nimport { findReferences, insertReferences } from '../quotes';\n\nconst EXTRACTION_MODEL = 'com.anthropic.model.claude-haiku-4-5.default';\n\n/**\n * Proper nouns extracted from transcript text.\n */\nexport const ProperNouns = Schema.Struct({\n  properNouns: Schema.Array(Schema.String).annotations({\n    description: 'Proper nouns (names of people, organizations, places, products) mentioned in the text.',\n  }),\n});\nexport type ProperNouns = Schema.Schema.Type<typeof ProperNouns>;\n\n/**\n * Extracts proper nouns from transcript text using a small LLM (Haiku). Provides the LanguageModel\n * internally so the residual requirement is just {@link AiService.AiService}.\n */\nexport const extractProperNouns = (text: string) =>\n  Effect.gen(function* () {\n    const { value } = yield* Effect.scoped(\n      LanguageModel.generateObject({\n        schema: ProperNouns,\n        prompt: [\n          'Extract every proper noun (people, organizations, places, products) mentioned in the transcript text below.',\n          'Return only the surface strings exactly as they appear. Exclude common nouns and pronouns.',\n          '',\n          'Transcript:',\n          text,\n        ].join('\\n'),\n      }),\n    );\n\n    // Drop short tokens (e.g. \"IT\"): insertReferences replaces case-insensitive substrings, so a\n    // short noun would match inside unrelated words (\"secur[IT]y\") and corrupt neighbouring links.\n    return value.properNouns.map((noun) => noun.trim()).filter((noun) => noun.length >= 3);\n  }).pipe(Effect.provide(AiService.model(EXTRACTION_MODEL)));\n\n/**\n * Enriches a transcript message: for each transcript block, extracts proper nouns, links them to\n * objects in the space via full-text search, and rewrites the text with `[noun](dxn)` references.\n * Requires {@link AiService.AiService}; takes the space database handle.\n */\nexport const enrichTranscriptMessage = (message: Message.Message, { db }: { db: Database.Database }) =>\n  Effect.gen(function* () {\n    const blocks = yield* Effect.forEach(message.blocks, (block) =>\n      Effect.gen(function* () {\n        if (block._tag !== 'transcript') {\n          return block;\n        }\n\n        const nouns = yield* extractProperNouns(block.text);\n        const references = yield* Effect.promise(() => findReferences([...nouns], db));\n        return { ...block, text: insertReferences(block.text, references) };\n      }),\n    );\n\n    // Preserve the message identity and metadata; enrichment only rewrites transcript block text.\n    return Obj.make(Message.Message, {\n      id: message.id,\n      sender: message.sender,\n      created: message.created,\n      properties: message.properties,\n      blocks,\n    });\n  });\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { type Database, Filter, Query } from '@dxos/echo';\nimport { EID, EntityId } from '@dxos/keys';\n\nexport const ReferencedQuotes = Schema.Struct({\n  references: Schema.Array(\n    Schema.Struct({\n      id: Schema.String,\n      quote: Schema.String, // TODO(burdon): Quote?\n    }),\n  )\n    .pipe(Schema.mutable)\n    .annotations({\n      // TODO(burdon): Does this description make sense?\n      description: `\n      The references to the context objects that are mentioned in the transcript. \n      Quote should match the original transcript text exactly, while id is the id of the context object.\n    `,\n    }),\n});\nexport type ReferencedQuotes = Schema.Schema.Type<typeof ReferencedQuotes>;\n\nexport type FindReferencesOptions = {\n  /** Search backend. Full-text matches proper nouns precisely; vector matches semantically. */\n  searchKind?: 'full-text' | 'vector';\n};\n\n/**\n * Finds the best-matching context object for each noun and returns it as a reference.\n */\nexport const findReferences = async (\n  nouns: string[],\n  db: Database.Database,\n  { searchKind = 'full-text' }: FindReferencesOptions = {},\n): Promise<ReferencedQuotes> => {\n  // Deduplicate and process longer nouns first: `insertReferences` rewrites case-insensitive\n  // substrings, so a repeated or shorter overlapping noun would re-replace already-linked text and\n  // produce nested/broken markdown links.\n  const normalizedNouns = Array.from(new Set(nouns.map((noun) => noun.trim()).filter((noun) => noun.length > 0))).sort(\n    (leftNoun, rightNoun) => rightNoun.length - leftNoun.length,\n  );\n\n  const references = await Promise.all(\n    normalizedNouns.map(async (noun) => {\n      const objects = await db.query(Query.select(Filter.text(noun, { type: searchKind }))).run();\n      return objects.length > 0 ? [{ id: objects[0].id.toString(), quote: noun }] : [];\n    }),\n  );\n  return { references: references.flat() };\n};\n\n/**\n * Finds and replaces all quotes with DXNs references.\n */\n// TODO(dmaretskyi): Lookup and verifiy ids from provided context.\nexport const insertReferences = (text: string, quotes: ReferencedQuotes): string => {\n  // Process longer quotes first so e.g. \"Sarah Johnson\" is linked before \"Sarah\". Combined with the\n  // link-aware replacement below this stops a shorter or overlapping quote from rewriting text that\n  // is already part of an inserted link (which would produce nested `[[..](..)](..)` markdown).\n  const references = quotes.references\n    .filter((quote) => EntityId.isValid(quote.id))\n    .sort((left, right) => right.quote.length - left.quote.length);\n\n  for (const quote of references) {\n    // Case-insensitive match of the (regex-escaped) quote.\n    const regex = new RegExp(quote.quote.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'), 'gi');\n    text = replaceOutsideLinks(text, regex, `[${quote.quote}](${EID.make({ entityId: quote.id })})`);\n  }\n\n  return text;\n};\n\nconst MARKDOWN_LINK = /\\[[^\\]]*\\]\\([^)]*\\)/g;\n\n/** Applies a replacement to every span of `text` that is not already inside a `[label](url)` link. */\nconst replaceOutsideLinks = (text: string, regex: RegExp, replacement: string): string => {\n  let result = '';\n  let plainStart = 0;\n  for (const link of text.matchAll(MARKDOWN_LINK)) {\n    const index = link.index ?? 0;\n    result += text.slice(plainStart, index).replace(regex, replacement) + link[0];\n    plainStart = index + link[0].length;\n  }\n  return result + text.slice(plainStart).replace(regex, replacement);\n};\n", "//\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/**\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\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": "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",
-  "names": ["LanguageModel", "Effect", "Schema", "AiService", "Obj", "Message", "Schema", "Filter", "Query", "EID", "EntityId", "ReferencedQuotes", "Struct", "references", "Array", "id", "String", "quote", "pipe", "mutable", "annotations", "description", "findReferences", "nouns", "db", "searchKind", "normalizedNouns", "from", "Set", "map", "noun", "trim", "filter", "length", "sort", "leftNoun", "rightNoun", "Promise", "all", "objects", "query", "select", "text", "type", "run", "toString", "flat", "insertReferences", "quotes", "isValid", "left", "right", "regex", "RegExp", "replace", "replaceOutsideLinks", "make", "entityId", "MARKDOWN_LINK", "replacement", "result", "plainStart", "link", "matchAll", "index", "slice", "EXTRACTION_MODEL", "ProperNouns", "Struct", "properNouns", "Array", "String", "annotations", "description", "extractProperNouns", "text", "gen", "value", "scoped", "generateObject", "schema", "prompt", "join", "map", "noun", "trim", "filter", "length", "pipe", "provide", "AiService", "model", "enrichTranscriptMessage", "message", "db", "blocks", "forEach", "block", "_tag", "nouns", "references", "promise", "findReferences", "insertReferences", "Obj", "make", "Message", "id", "sender", "created", "properties", "pipeline", "log", "_ner", "ner", "entities", "text", "tokenGroups", "createTokenGroups", "combinedEntities", "canBeCombined", "prevToken", "currentToken", "currentState", "prevEntity", "entity", "currentEntity", "prevState", "token", "push", "lastTokenGroup", "score", "reduce", "index", "group", "at", "word", "start", "end", "combinedToken"]
-}