@dxos/assistant 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/README.md

@@ -1,4 +1,5 @@
 # @dxos/assistant
+
 Natural language interface to DXOS.
 
 Communicate with your DXOS applications through conversations using advanced LLM capabilities. This package provides a flexible system for building AI assistants that can help users interact with and control DXOS apps.

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

@@ -0,0 +1,193 @@
+// src/types/artifact.ts
+import * as Schema from "effect/Schema";
+import { Obj, Ref } from "@dxos/echo";
+import { Database } from "@dxos/echo";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
+import { trim } from "@dxos/util";
+var createArtifactElement = (id) => `<artifact id=${id} />`;
+var ArtifactId = class extends Schema.String.annotations({
+  // TODO(dmaretskyi): This section gets overriden.
+  description: trim`
+    The ID of the referenced object. Formats accepted:
+    - DXN (dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4). 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 (01KG7R1ZXWFMWQ4DA1Q6TN1DG4)
+  `,
+  examples: [
+    "dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+    "@dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+    "BM3FSHFOMJCHCG5QW7JTVKGYABD2GAA7G:01KG7R1ZXWFMWQ4DA1Q6TN1DG4",
+    "01KG7R1ZXWFMWQ4DA1Q6TN1DG4"
+  ]
+}) {
+  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.resolve(dxn, schema);
+  }
+};
+var RefFromLLM = Schema.transform(ArtifactId, Ref.Ref(Obj.Unknown), {
+  decode: (fromA, fromI) => EncodedReference.fromDXN(ArtifactId.toDXN(fromA)),
+  encode: (toI, toA) => EncodedReference.toDXN(toI).toString(),
+  strict: false
+}).annotations({
+  description: ArtifactId.ast.annotations.description
+});
+
+// src/functions/services.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Record from "effect/Record";
+import * as Schema2 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from "@dxos/ai";
+import { GenericToolkit } from "@dxos/ai";
+import { todo } from "@dxos/debug";
+import { Ref as Ref2 } from "@dxos/echo";
+import { FunctionInvocationService } from "@dxos/functions";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/functions/services.ts";
+var makeToolResolverFromFunctions = () => {
+  return Layer.effect(ToolResolverService, Effect.gen(function* () {
+    const toolkitProvider = yield* GenericToolkit.Provider;
+    const functionInvocationService = yield* FunctionInvocationService;
+    return {
+      resolve: (id) => Effect.gen(function* () {
+        const toolkit = toolkitProvider.getToolkit();
+        const tool = toolkit.toolkit.tools[id];
+        if (tool) {
+          return tool;
+        }
+        return yield* functionInvocationService.resolveFunction(id).pipe(Effect.map(projectFunctionToTool), Effect.catchTag("FunctionNotFound", () => Effect.fail(new AiToolNotFoundError(id))));
+      })
+    };
+  }));
+};
+var makeToolExecutionServiceFromFunctions = () => {
+  return Layer.effect(ToolExecutionService, Effect.gen(function* () {
+    const toolkitProvider = yield* GenericToolkit.Provider;
+    const toolkit = toolkitProvider.getToolkit();
+    const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));
+    invariant(isHandlerLike(toolkitHandler), void 0, {
+      F: __dxlog_file,
+      L: 76,
+      S: this,
+      A: [
+        "isHandlerLike(toolkitHandler)",
+        ""
+      ]
+    });
+    const functionInvocationService = yield* FunctionInvocationService;
+    return {
+      handlersFor: (toolkit2) => {
+        const makeHandler = (tool) => {
+          return Effect.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 } = Context.get(FunctionToolAnnotation)(tool.annotations);
+            return yield* functionInvocationService.invokeFunction(functionDef, input).pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
+          });
+        };
+        return toolkit2.of(Record.map(toolkit2.tools, (tool, _name) => Tool.isUserDefined(tool) ? makeHandler(tool) : null));
+      }
+    };
+  }));
+};
+var ToolExecutionServices = Layer.mergeAll(makeToolResolverFromFunctions(), makeToolExecutionServiceFromFunctions());
+var FunctionToolAnnotation = class extends Context.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: Schema2.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_file,
+    L: 152,
+    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,
+        Schema2.make(mapSchemaTypeForLLM(prop.type))
+      ]));
+    case "VoidKeyword":
+      return {};
+    default:
+      return todo(`Unsupported schema AST: ${schema.ast._tag}`);
+  }
+};
+var mapSchemaTypeForLLM = (ast) => {
+  if (Ref2.isRefType(ast)) {
+    const description = ast.annotations.description ? ast.annotations.description + "\n" + RefFromLLM.ast.annotations.description : RefFromLLM.ast.annotations.description;
+    return RefFromLLM.annotations({
+      description
+    }).ast;
+  } else if (SchemaAST.isTupleType(ast)) {
+    return new SchemaAST.TupleType(ast.elements.map((t) => new SchemaAST.OptionalType(mapSchemaTypeForLLM(t.type), t.isOptional, t.annotations)), ast.rest.map((t) => new SchemaAST.Type(mapSchemaTypeForLLM(t.type), t.annotations)), ast.isReadonly, ast.annotations);
+  } else if (SchemaAST.isTypeLiteral(ast)) {
+    return new SchemaAST.TypeLiteral(ast.propertySignatures.map((p) => new SchemaAST.PropertySignature(p.name, mapSchemaTypeForLLM(p.type), p.isOptional, p.isReadonly, p.annotations)), ast.indexSignatures, ast.annotations);
+  }
+  return ast;
+};
+var isHandlerLike = (value) => {
+  return typeof value.tools === "object" && typeof value.handle === "function";
+};
+
+export {
+  createArtifactElement,
+  ArtifactId,
+  RefFromLLM,
+  makeToolResolverFromFunctions,
+  makeToolExecutionServiceFromFunctions,
+  ToolExecutionServices
+};
+//# sourceMappingURL=chunk-BE6SRJ4N.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/artifact.ts", "../../../src/functions/services.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Effect from 'effect/Effect';\nimport * as Schema from 'effect/Schema';\n\nimport { type Err, Obj, Ref, type Type } from '@dxos/echo';\nimport { Database } from '@dxos/echo';\nimport { EncodedReference } from '@dxos/echo-protocol';\nimport { DXN, LOCAL_SPACE_TAG, type ObjectId, type SpaceId } from '@dxos/keys';\nimport { trim } from '@dxos/util';\n\n/**\n * @deprecated\n */\nexport const createArtifactElement = (id: ObjectId) => `<artifact id=${id} />`;\n\n// TODO(burdon): Rename RefFromLLM? -- yes -dm\n/**\n * A model-friendly way to reference an object.\n * Supports vairous formats that will be normalized to a DXN.\n *\n * @deprecated Use `Ref.Ref(XXX)` instead.\n */\nexport const ArtifactId: Schema.Schema<string> & {\n  toDXN: (reference: ArtifactId, owningSpaceId?: SpaceId) => DXN;\n  resolve: <S extends Type.AnyEntity>(\n    schema: S,\n    ref: ArtifactId,\n  ) => Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Database.Service>;\n} = class extends Schema.String.annotations({\n  // TODO(dmaretskyi): This section gets overriden.\n  description: trim`\n    The ID of the referenced object. Formats accepted:\n    - DXN (dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4). DXNs can be prepended with an @ symbol for compatibility with in-text references.\n    - space ID, object ID tuple (spaceID:objectID)\n    - Only object ID that is assumed to be in the current space (01KG7R1ZXWFMWQ4DA1Q6TN1DG4)\n  `,\n  examples: [\n    'dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',\n    '@dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',\n    'BM3FSHFOMJCHCG5QW7JTVKGYABD2GAA7G:01KG7R1ZXWFMWQ4DA1Q6TN1DG4',\n    '01KG7R1ZXWFMWQ4DA1Q6TN1DG4',\n  ],\n}) {\n  static toDXN(reference: ArtifactId, owningSpaceId?: SpaceId): DXN {\n    // Allow @dxn: prefix for compatibility with in-text references.\n    if (reference.startsWith('@dxn:')) {\n      return DXN.parse(reference.slice(1));\n    } else if (reference.startsWith('dxn:')) {\n      return DXN.parse(reference);\n    } else if (/^[A-Z0-9]+:[A-Z0-9]+$/.test(reference)) {\n      const [spaceId, objectId] = reference.split(':');\n      // This is a workaround because the current Filter API doesn't work with fully qualified Echo DXNs.\n      // We check if the space ID is the same as the owning space and then use LOCAL_SPACE_TAG for local references.\n      // TODO(dmaretskyi): Fix this in the Echo and Filter API to properly handle fully qualified DXNs.\n      return new DXN(DXN.kind.ECHO, [spaceId === owningSpaceId ? LOCAL_SPACE_TAG : spaceId, objectId]);\n    } else if (/^[A-Z0-9]+$/.test(reference)) {\n      return DXN.fromLocalObjectId(reference);\n    } else {\n      throw new Error(`Unable to parse object reference: ${reference}`);\n    }\n  }\n\n  /**\n   * Resolves an artifact ID to an object.\n   */\n  static resolve<S extends Type.AnyEntity>(\n    schema: S,\n    ref: ArtifactId,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Database.Service> {\n    const dxn = ArtifactId.toDXN(ref);\n    return Database.resolve(dxn, schema);\n  }\n};\n\nexport type ArtifactId = Schema.Schema.Type<typeof ArtifactId>;\n\n/**\n * Schema that decodes ECHO reference object from an LLM-friendly input.\n */\nexport const RefFromLLM = Schema.transform(ArtifactId, Ref.Ref(Obj.Unknown), {\n  decode: (fromA, fromI) => EncodedReference.fromDXN(ArtifactId.toDXN(fromA)),\n  encode: (toI, toA) => EncodedReference.toDXN(toI).toString(),\n  strict: false,\n}).annotations({\n  description: ArtifactId.ast.annotations.description as string,\n});\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Tool from '@effect/ai/Tool';\nimport type * as Toolkit from '@effect/ai/Toolkit';\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Record from 'effect/Record';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';\nimport { GenericToolkit } from '@dxos/ai';\nimport { todo } from '@dxos/debug';\nimport { Ref } from '@dxos/echo';\nimport { type FunctionDefinition, FunctionInvocationService } from '@dxos/functions';\nimport { invariant } from '@dxos/invariant';\n\nimport { RefFromLLM } from '../types';\n\n/**\n * Constructs a `ToolResolverService` whose `resolve(id)` looks up tools in the following order:\n *  1. Toolkit: return an existing tool from the provided `toolkit` if one is present under `id`.\n *  2. Functions in DB: query `FunctionType` by `key=id`; if found, deserialize and project to a tool\n *     (propagating any `deployedFunctionId` discovered in the object's metadata).\n *  3. Functions passed in: fall back to a matching `FunctionDefinition` from the `functions` array.\n *\n * If none of the above yield a match, the effect fails with `AiToolNotFoundError`.\n *\n * Requires `Database.Service` in the environment.\n */\nexport const makeToolResolverFromFunctions = (): Layer.Layer<\n  ToolResolverService,\n  never,\n  GenericToolkit.Provider | FunctionInvocationService\n> => {\n  return Layer.effect(\n    ToolResolverService,\n    Effect.gen(function* () {\n      const toolkitProvider = yield* GenericToolkit.Provider;\n      const functionInvocationService = yield* FunctionInvocationService;\n      return {\n        resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>\n          Effect.gen(function* () {\n            const toolkit = toolkitProvider.getToolkit();\n\n            const tool = toolkit.toolkit.tools[id];\n            if (tool) {\n              return tool;\n            }\n\n            return yield* functionInvocationService.resolveFunction(id).pipe(\n              Effect.map(projectFunctionToTool),\n              Effect.catchTag('FunctionNotFound', () => Effect.fail(new AiToolNotFoundError(id))),\n            );\n          }),\n      } satisfies Context.Tag.Service<ToolResolverService>;\n    }),\n  );\n};\n\nexport const makeToolExecutionServiceFromFunctions = (): Layer.Layer<\n  ToolExecutionService,\n  never,\n  FunctionInvocationService | GenericToolkit.Provider\n> => {\n  return Layer.effect(\n    ToolExecutionService,\n    Effect.gen(function* () {\n      const toolkitProvider = yield* GenericToolkit.Provider;\n      const toolkit = toolkitProvider.getToolkit();\n\n      const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));\n      invariant(isHandlerLike(toolkitHandler));\n      const functionInvocationService = yield* FunctionInvocationService;\n\n      return {\n        handlersFor: (toolkit) => {\n          const makeHandler = (tool: Tool.Any): ((params: unknown) => Effect.Effect<unknown, any, any>) => {\n            return Effect.fn(`toolFunctionHandler ${tool.name}`)(function* (input: any) {\n              if (toolkitHandler.tools[tool.name]) {\n                if (Tool.isProviderDefined(tool)) {\n                  throw new Error('Attempted to call a provider-defined tool');\n                }\n\n                // TODO(wittjosiah): Everything is `never` here.\n                const { result } = yield* (toolkitHandler.handle as any)(tool.name, input);\n                return result;\n              }\n\n              const { definition: functionDef } = Context.get(FunctionToolAnnotation)(tool.annotations as any);\n\n              return yield* functionInvocationService\n                .invokeFunction(functionDef, input as any)\n                .pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));\n            });\n          };\n\n          return toolkit.of(\n            Record.map(toolkit.tools, (tool, _name) => (Tool.isUserDefined(tool) ? makeHandler(tool) : null)) as any,\n          ) as any;\n        },\n      };\n    }),\n  );\n};\n\nexport const ToolExecutionServices = Layer.mergeAll(\n  makeToolResolverFromFunctions(),\n  makeToolExecutionServiceFromFunctions(),\n);\n\nclass FunctionToolAnnotation extends Context.Tag('@dxos/assistant/FunctionToolAnnotation')<\n  FunctionToolAnnotation,\n  { definition: FunctionDefinition.Any }\n>() {}\n\nconst toolCache = new WeakMap<FunctionDefinition.Any, Tool.Any>();\n\n/**\n * Projects a `FunctionDefinition` into an `AiTool`.\n *\n * @param fn The function definition to project into a tool.\n * @param meta Optional projection metadata.\n * @param meta.deployedFunctionId Backend deployment ID used for remote invocation when present.\n *    This is the EDGE service's function deployment identifier (not the ECHO object ID/DXN and not `FunctionDefinition.key`).\n */\nconst projectFunctionToTool = (fn: FunctionDefinition.Any): Tool.Any => {\n  if (toolCache.has(fn)) {\n    return toolCache.get(fn)!;\n  }\n\n  // TODO(burdon): Use and map function.key?\n  // TODO(dmaretskyi): Use function key instead.\n  const tool = Tool.make(makeToolName(fn.name), {\n    description: fn.description,\n    parameters: createStructFieldsFromSchema(fn.inputSchema),\n    // TODO(dmaretskyi): Include output schema.\n    failure: Schema.Any, // TODO(dmaretskyi): Better type for the failure?\n  }).annotate(FunctionToolAnnotation, { definition: fn });\n  toolCache.set(fn, tool);\n  return tool;\n};\n\n/**\n * @returns Tool name produced from function name by escaping invalid characters.\n */\nconst makeToolName = (name: string) => {\n  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, '-');\n  invariant(toolName.match(/^[a-z_][a-z0-9-_]*$/));\n  return toolName;\n};\n\n// TODO(dmaretskyi): Factor out.\nconst createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<string, Schema.Schema<any, any>> => {\n  switch (schema.ast._tag) {\n    case 'TypeLiteral':\n      return Object.fromEntries(\n        schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(mapSchemaTypeForLLM(prop.type))]),\n      );\n    case 'VoidKeyword':\n      return {};\n    default:\n      return todo(`Unsupported schema AST: ${schema.ast._tag}`);\n  }\n};\n\n/**\n * Picks an LLM-friendly schema type for the given schema AST.\n * The picked schema type decodes to the original schema type.\n */\nconst mapSchemaTypeForLLM = (ast: SchemaAST.AST): SchemaAST.AST => {\n  if (Ref.isRefType(ast)) {\n    const description = ast.annotations.description\n      ? ast.annotations.description + '\\n' + RefFromLLM.ast.annotations.description\n      : (RefFromLLM.ast.annotations.description as string);\n    return RefFromLLM.annotations({ description }).ast;\n  } else if (SchemaAST.isTupleType(ast)) {\n    return new SchemaAST.TupleType(\n      ast.elements.map((t) => new SchemaAST.OptionalType(mapSchemaTypeForLLM(t.type), t.isOptional, t.annotations)),\n      ast.rest.map((t) => new SchemaAST.Type(mapSchemaTypeForLLM(t.type), t.annotations)),\n      ast.isReadonly,\n      ast.annotations,\n    );\n  } else if (SchemaAST.isTypeLiteral(ast)) {\n    return new SchemaAST.TypeLiteral(\n      ast.propertySignatures.map(\n        (p) =>\n          new SchemaAST.PropertySignature(\n            p.name,\n            mapSchemaTypeForLLM(p.type),\n            p.isOptional,\n            p.isReadonly,\n            p.annotations,\n          ),\n      ),\n      ast.indexSignatures,\n      ast.annotations,\n    );\n  }\n\n  return ast;\n};\n\nconst isHandlerLike = (value: unknown): value is Toolkit.WithHandler<Record<string, Tool.Any>> => {\n  return typeof (value as any).tools === 'object' && typeof (value as any).handle === 'function';\n};\n"],
+  "mappings": ";AAKA,YAAYA,YAAY;AAExB,SAAmBC,KAAKC,WAAsB;AAC9C,SAASC,gBAAgB;AACzB,SAASC,wBAAwB;AACjC,SAASC,KAAKC,uBAAoD;AAClE,SAASC,YAAY;AAKd,IAAMC,wBAAwB,CAACC,OAAiB,gBAAgBA,EAAAA;AAShE,IAAMC,aAMT,cAAqBC,cAAOC,YAAY;;EAE1CC,aAAaC;;;;;;EAMbC,UAAU;IACR;IACA;IACA;IACA;;AAEJ,CAAA,EAAA;EACE,OAAOC,MAAMC,WAAuBC,eAA8B;AAEhE,QAAID,UAAUE,WAAW,OAAA,GAAU;AACjC,aAAOC,IAAIC,MAAMJ,UAAUK,MAAM,CAAA,CAAA;IACnC,WAAWL,UAAUE,WAAW,MAAA,GAAS;AACvC,aAAOC,IAAIC,MAAMJ,SAAAA;IACnB,WAAW,wBAAwBM,KAAKN,SAAAA,GAAY;AAClD,YAAM,CAACO,SAASC,QAAAA,IAAYR,UAAUS,MAAM,GAAA;AAI5C,aAAO,IAAIN,IAAIA,IAAIO,KAAKC,MAAM;QAACJ,YAAYN,gBAAgBW,kBAAkBL;QAASC;OAAS;IACjG,WAAW,cAAcF,KAAKN,SAAAA,GAAY;AACxC,aAAOG,IAAIU,kBAAkBb,SAAAA;IAC/B,OAAO;AACL,YAAM,IAAIc,MAAM,qCAAqCd,SAAAA,EAAW;IAClE;EACF;;;;EAKA,OAAOe,QACLC,QACAC,KACiF;AACjF,UAAMC,MAAMzB,WAAWM,MAAMkB,GAAAA;AAC7B,WAAOE,SAASJ,QAAQG,KAAKF,MAAAA;EAC/B;AACF;AAOO,IAAMI,aAAoBC,iBAAU5B,YAAY6B,IAAIA,IAAIC,IAAIC,OAAO,GAAG;EAC3EC,QAAQ,CAACC,OAAOC,UAAUC,iBAAiBC,QAAQpC,WAAWM,MAAM2B,KAAAA,CAAAA;EACpEI,QAAQ,CAACC,KAAKC,QAAQJ,iBAAiB7B,MAAMgC,GAAAA,EAAKE,SAAQ;EAC1DC,QAAQ;AACV,CAAA,EAAGvC,YAAY;EACbC,aAAaH,WAAW0C,IAAIxC,YAAYC;AAC1C,CAAA;;;ACpFA,YAAYwC,UAAU;AAEtB,YAAYC,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,aAAY;AACxB,YAAYC,eAAe;AAE3B,SAASC,qBAAqBC,sBAAsBC,2BAA2B;AAC/E,SAASC,sBAAsB;AAC/B,SAASC,YAAY;AACrB,SAASC,OAAAA,YAAW;AACpB,SAAkCC,iCAAiC;AACnE,SAASC,iBAAiB;;AAenB,IAAMC,gCAAgC,MAAA;AAK3C,SAAaC,aACXC,qBACOC,WAAI,aAAA;AACT,UAAMC,kBAAkB,OAAOC,eAAeC;AAC9C,UAAMC,4BAA4B,OAAOC;AACzC,WAAO;MACLC,SAAS,CAACC,OACDP,WAAI,aAAA;AACT,cAAMQ,UAAUP,gBAAgBQ,WAAU;AAE1C,cAAMC,OAAOF,QAAQA,QAAQG,MAAMJ,EAAAA;AACnC,YAAIG,MAAM;AACR,iBAAOA;QACT;AAEA,eAAO,OAAON,0BAA0BQ,gBAAgBL,EAAAA,EAAIM,KACnDC,WAAIC,qBAAAA,GACJC,gBAAS,oBAAoB,MAAaC,YAAK,IAAIC,oBAAoBX,EAAAA,CAAAA,CAAAA,CAAAA;MAElF,CAAA;IACJ;EACF,CAAA,CAAA;AAEJ;AAEO,IAAMY,wCAAwC,MAAA;AAKnD,SAAarB,aACXsB,sBACOpB,WAAI,aAAA;AACT,UAAMC,kBAAkB,OAAOC,eAAeC;AAC9C,UAAMK,UAAUP,gBAAgBQ,WAAU;AAE1C,UAAMY,iBAAiB,OAAOb,QAAQA,QAAQK,KAAYS,eAAQd,QAAQe,KAAK,CAAA;AAC/EC,cAAUC,cAAcJ,cAAAA,GAAAA,QAAAA;;;;;;;;;AACxB,UAAMjB,4BAA4B,OAAOC;AAEzC,WAAO;MACLqB,aAAa,CAAClB,aAAAA;AACZ,cAAMmB,cAAc,CAACjB,SAAAA;AACnB,iBAAckB,UAAG,uBAAuBlB,KAAKmB,IAAI,EAAE,EAAE,WAAWC,OAAU;AACxE,gBAAIT,eAAeV,MAAMD,KAAKmB,IAAI,GAAG;AACnC,kBAASE,uBAAkBrB,IAAAA,GAAO;AAChC,sBAAM,IAAIsB,MAAM,2CAAA;cAClB;AAGA,oBAAM,EAAEC,OAAM,IAAK,OAAQZ,eAAea,OAAexB,KAAKmB,MAAMC,KAAAA;AACpE,qBAAOG;YACT;AAEA,kBAAM,EAAEE,YAAYC,YAAW,IAAaC,YAAIC,sBAAAA,EAAwB5B,KAAK6B,WAAW;AAExF,mBAAO,OAAOnC,0BACXoC,eAAeJ,aAAaN,KAAAA,EAC5BjB,KAAY4B,sBAAe,CAACC,WAAkBzB,YAAKyB,MAAAA,CAAAA,CAAAA;UACxD,CAAA;QACF;AAEA,eAAOlC,SAAQmC,GACN7B,WAAIN,SAAQG,OAAO,CAACD,MAAMkC,UAAgBC,mBAAcnC,IAAAA,IAAQiB,YAAYjB,IAAAA,IAAQ,IAAA,CAAA;MAE/F;IACF;EACF,CAAA,CAAA;AAEJ;AAEO,IAAMoC,wBAA8BC,eACzClD,8BAAAA,GACAsB,sCAAAA,CAAAA;AAGF,IAAMmB,yBAAN,cAA6CU,YAAI,wCAAA,EAAA,EAAA;AAG5C;AAEL,IAAMC,YAAY,oBAAIC,QAAAA;AAUtB,IAAMnC,wBAAwB,CAACa,QAAAA;AAC7B,MAAIqB,UAAUE,IAAIvB,GAAAA,GAAK;AACrB,WAAOqB,UAAUZ,IAAIT,GAAAA;EACvB;AAIA,QAAMlB,OAAY0C,UAAKC,aAAazB,IAAGC,IAAI,GAAG;IAC5CyB,aAAa1B,IAAG0B;IAChBC,YAAYC,6BAA6B5B,IAAG6B,WAAW;;IAEvDC,SAAgBC;EAClB,CAAA,EAAGC,SAAStB,wBAAwB;IAAEH,YAAYP;EAAG,CAAA;AACrDqB,YAAUY,IAAIjC,KAAIlB,IAAAA;AAClB,SAAOA;AACT;AAKA,IAAM2C,eAAe,CAACxB,SAAAA;AACpB,QAAMiC,WAAWjC,KAAKkC,YAAW,EAAGC,QAAQ,iBAAiB,GAAA;AAC7DxC,YAAUsC,SAASG,MAAM,qBAAA,GAAA,QAAA;;;;;;;;;AACzB,SAAOH;AACT;AAGA,IAAMN,+BAA+B,CAACU,WAAAA;AACpC,UAAQA,OAAOC,IAAIC,MAAI;IACrB,KAAK;AACH,aAAOC,OAAOC,YACZJ,OAAOC,IAAII,mBAAmBzD,IAAI,CAAC0D,SAAS;QAACA,KAAK3C;QAAauB,aAAKqB,oBAAoBD,KAAKE,IAAI,CAAA;OAAG,CAAA;IAExG,KAAK;AACH,aAAO,CAAC;IACV;AACE,aAAOC,KAAK,2BAA2BT,OAAOC,IAAIC,IAAI,EAAE;EAC5D;AACF;AAMA,IAAMK,sBAAsB,CAACN,QAAAA;AAC3B,MAAIS,KAAIC,UAAUV,GAAAA,GAAM;AACtB,UAAMb,cAAca,IAAI5B,YAAYe,cAChCa,IAAI5B,YAAYe,cAAc,OAAOwB,WAAWX,IAAI5B,YAAYe,cAC/DwB,WAAWX,IAAI5B,YAAYe;AAChC,WAAOwB,WAAWvC,YAAY;MAAEe;IAAY,CAAA,EAAGa;EACjD,WAAqBY,sBAAYZ,GAAAA,GAAM;AACrC,WAAO,IAAca,oBACnBb,IAAIc,SAASnE,IAAI,CAACoE,MAAM,IAAcC,uBAAaV,oBAAoBS,EAAER,IAAI,GAAGQ,EAAEE,YAAYF,EAAE3C,WAAW,CAAA,GAC3G4B,IAAIkB,KAAKvE,IAAI,CAACoE,MAAM,IAAcI,eAAKb,oBAAoBS,EAAER,IAAI,GAAGQ,EAAE3C,WAAW,CAAA,GACjF4B,IAAIoB,YACJpB,IAAI5B,WAAW;EAEnB,WAAqBiD,wBAAcrB,GAAAA,GAAM;AACvC,WAAO,IAAcsB,sBACnBtB,IAAII,mBAAmBzD,IACrB,CAAC4E,MACC,IAAcC,4BACZD,EAAE7D,MACF4C,oBAAoBiB,EAAEhB,IAAI,GAC1BgB,EAAEN,YACFM,EAAEH,YACFG,EAAEnD,WAAW,CAAA,GAGnB4B,IAAIyB,iBACJzB,IAAI5B,WAAW;EAEnB;AAEA,SAAO4B;AACT;AAEA,IAAM1C,gBAAgB,CAACoE,UAAAA;AACrB,SAAO,OAAQA,MAAclF,UAAU,YAAY,OAAQkF,MAAc3D,WAAW;AACtF;",
+  "names": ["Schema", "Obj", "Ref", "Database", "EncodedReference", "DXN", "LOCAL_SPACE_TAG", "trim", "createArtifactElement", "id", "ArtifactId", "String", "annotations", "description", "trim", "examples", "toDXN", "reference", "owningSpaceId", "startsWith", "DXN", "parse", "slice", "test", "spaceId", "objectId", "split", "kind", "ECHO", "LOCAL_SPACE_TAG", "fromLocalObjectId", "Error", "resolve", "schema", "ref", "dxn", "Database", "RefFromLLM", "transform", "Ref", "Obj", "Unknown", "decode", "fromA", "fromI", "EncodedReference", "fromDXN", "encode", "toI", "toA", "toString", "strict", "ast", "Tool", "Context", "Effect", "Layer", "Record", "Schema", "SchemaAST", "AiToolNotFoundError", "ToolExecutionService", "ToolResolverService", "GenericToolkit", "todo", "Ref", "FunctionInvocationService", "invariant", "makeToolResolverFromFunctions", "effect", "ToolResolverService", "gen", "toolkitProvider", "GenericToolkit", "Provider", "functionInvocationService", "FunctionInvocationService", "resolve", "id", "toolkit", "getToolkit", "tool", "tools", "resolveFunction", "pipe", "map", "projectFunctionToTool", "catchTag", "fail", "AiToolNotFoundError", "makeToolExecutionServiceFromFunctions", "ToolExecutionService", "toolkitHandler", "provide", "layer", "invariant", "isHandlerLike", "handlersFor", "makeHandler", "fn", "name", "input", "isProviderDefined", "Error", "result", "handle", "definition", "functionDef", "get", "FunctionToolAnnotation", "annotations", "invokeFunction", "catchAllDefect", "defect", "of", "_name", "isUserDefined", "ToolExecutionServices", "mergeAll", "Tag", "toolCache", "WeakMap", "has", "make", "makeToolName", "description", "parameters", "createStructFieldsFromSchema", "inputSchema", "failure", "Any", "annotate", "set", "toolName", "toLowerCase", "replace", "match", "schema", "ast", "_tag", "Object", "fromEntries", "propertySignatures", "prop", "mapSchemaTypeForLLM", "type", "todo", "Ref", "isRefType", "RefFromLLM", "isTupleType", "TupleType", "elements", "t", "OptionalType", "isOptional", "rest", "Type", "isReadonly", "isTypeLiteral", "TypeLiteral", "p", "PropertySignature", "indexSignatures", "value"]
+}

package/dist/lib/{browser → neutral}/extraction/index.mjs

@@ -1,15 +1,13 @@
-import "../chunk-J5LGTIGS.mjs";
-
 // src/extraction/extraction.ts
 import * as Schema from "effect/Schema";
 import { asyncTimeout } from "@dxos/async";
-import { Type } from "@dxos/echo";
+import { Obj } from "@dxos/echo";
 import { log } from "@dxos/log";
 import { Message } from "@dxos/types";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant/src/extraction/extraction.ts";
 var ExtractionInput = Schema.Struct({
   message: Message.Message,
-  objects: Schema.optional(Schema.Array(Type.Obj)),
+  objects: Schema.optional(Schema.Array(Obj.Unknown)),
   options: Schema.optional(Schema.Struct({
     timeout: Schema.optional(Schema.Number),
     fallbackToRaw: Schema.optional(Schema.Boolean)
@@ -49,7 +47,7 @@ var processTranscriptMessage = async (params) => {
 // src/extraction/extraction-llm-function/extraction-llm-function.ts
 import { defineFunction } from "@dxos/functions";
 var extractionAnthropicFunction = defineFunction({
-  key: "dxos.org/function/extraction/extract-entities",
+  key: "org.dxos.function.extraction.extract-entities",
   name: "Extract Entities",
   description: "Extract entities from the transcript message and add them to the message.",
   inputSchema: ExtractionInput,
@@ -62,7 +60,7 @@ var extractionAnthropicFunction = defineFunction({
 // src/extraction/extraction-ner-function/extraction-ner-function.ts
 import { defineFunction as defineFunction2 } from "@dxos/functions";
 var extractionNerFunction = defineFunction2({
-  key: "dxos.org/function/extraction/extract-entities",
+  key: "org.dxos.function.extraction.extract-entities",
   name: "Extract Entities",
   description: "Extracts named entities from a text",
   inputSchema: ExtractionInput,

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/extraction/extraction.ts", "../../../../src/extraction/extraction-llm-function/extraction-llm-function.ts", "../../../../src/extraction/extraction-ner-function/extraction-ner-function.ts", "../../../../src/extraction/extraction-ner-function/named-entity-recognition.ts", "../../../../src/extraction/quotes.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { asyncTimeout } from '@dxos/async';\nimport { Obj } from '@dxos/echo';\nimport { type FunctionDefinition } from '@dxos/functions';\nimport { type FunctionExecutor } from '@dxos/functions-runtime';\nimport { log } from '@dxos/log';\nimport { Message } from '@dxos/types';\n\nexport const ExtractionInput = Schema.Struct({\n  message: Message.Message,\n  objects: Schema.optional(Schema.Array(Obj.Unknown)),\n  options: Schema.optional(\n    Schema.Struct({\n      timeout: Schema.optional(Schema.Number),\n      fallbackToRaw: Schema.optional(Schema.Boolean),\n    }),\n  ),\n});\nexport interface ExtractionInput extends Schema.Schema.Type<typeof ExtractionInput> {}\n\nexport const ExtractionOutput = Schema.Struct({\n  message: Message.Message,\n  timeElapsed: Schema.Number,\n});\nexport interface ExtractionOutput extends Schema.Schema.Type<typeof ExtractionOutput> {}\n\nexport type ProcessTranscriptMessageProps = {\n  input: ExtractionInput;\n  function: FunctionDefinition<ExtractionInput, ExtractionOutput>;\n  executor: FunctionExecutor;\n\n  options?: {\n    /**\n     * Timeout for the entity extraction.\n     */\n    timeout?: number;\n\n    /**\n     * Fallback to raw text if the entity extraction fails.\n     * Otherwise the function will throw an error.\n     * @default false\n     */\n    fallbackToRaw?: boolean;\n  };\n};\n\nexport type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionOutput>;\n\n/**\n * Extract entities from the transcript message and add them to the message.\n */\n// TODO(dmaretskyi): Move context to a vector search index.\nexport const processTranscriptMessage = async (params: ProcessTranscriptMessageProps): Promise<ExtractionOutput> => {\n  try {\n    if (params.options?.timeout && params.options.timeout > 0) {\n      return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);\n    } else {\n      return await params.executor.invoke(params.function, params.input);\n    }\n  } catch (error) {\n    if (params.options?.fallbackToRaw) {\n      log.warn('failed to process message, falling back to raw text', { error });\n      return {\n        message: params.input.message,\n        timeElapsed: 0,\n      };\n    } else {\n      throw error;\n    }\n  }\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type FunctionDefinition, defineFunction } from '@dxos/functions';\n\nimport { ExtractionInput, ExtractionOutput } from '../extraction';\n\nexport const extractionAnthropicFunction: FunctionDefinition<ExtractionInput, ExtractionOutput> = defineFunction({\n  key: 'org.dxos.function.extraction.extract-entities',\n  name: 'Extract Entities',\n  description: 'Extract entities from the transcript message and add them to the message.',\n  inputSchema: ExtractionInput,\n  outputSchema: ExtractionOutput,\n  handler: async ({ data: { message, objects }, context }) => {\n    throw new Error('not implemented');\n    // const startTime = performance.now();\n    // const ai = context.getService(AiService.AiService);\n    // const session = new AiSession({ operationModel: 'configured' });\n    // const result = await session.runStructured(ReferencedQuotes, {\n    //   generationOptions: {\n    //     model: '@anthropic/claude-3-5-haiku-20241022',\n    //   },\n    //   client: ai.client,\n    //   systemPrompt: PROMPT,\n    //   history: [\n    //     Obj.make(DataType.Message.Message, {\n    //       created: new Date().toISOString(),\n    //       sender: { role: 'user' },\n    //       blocks: [\n    //         {\n    //           _tag: 'text',\n    //           text: `<context>${JSON.stringify(objects)}</context>`,\n    //         } satisfies DataType.ContentBlock.Text,\n    //         {\n    //           _tag: 'text',\n    //           text: `<transcript>${JSON.stringify(message.blocks)}</transcript>`,\n    //         } satisfies DataType.ContentBlock.Text,\n    //       ],\n    //     }),\n    //   ],\n    //   artifacts: [],\n    //   prompt: '',\n    //   tools: [],\n    // } as any); // TODO(burdon): Rewrite test.\n\n    // return {\n    //   timeElapsed: performance.now() - startTime,\n    //   message: create(DataType.Message.Message, {\n    //     ...message,\n    //     blocks: message.blocks.map((block) =>\n    //       block._tag !== 'transcript'\n    //         ? block\n    //         : {\n    //             ...block,\n    //             text: insertReferences(block.text, result),\n    //           },\n    //     ),\n    //   }),\n    // };\n  },\n});\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { defineFunction } from '@dxos/functions';\n\nimport { ExtractionInput, ExtractionOutput } from '../extraction';\n\n/**\n * Named Entity Recognition model\n */\n// TODO(mykola): Make it use vector index to query objects and not pass objects as input.\nexport const extractionNerFunction = defineFunction({\n  key: 'org.dxos.function.extraction.extract-entities',\n  name: 'Extract Entities',\n  description: 'Extracts named entities from a text',\n  inputSchema: ExtractionInput,\n  outputSchema: ExtractionOutput,\n  handler: async ({ data: { message, options }, context }) => {\n    throw new Error('not implemented');\n    // log.info('input', { message, options });\n    // const startTime = performance.now();\n    // const { db } = context.getService(Database.Service);\n    // const { extractFullEntities } = await import('./named-entity-recognition');\n\n    // const entitiesPromise = Promise.all(\n    //   message.blocks.map(async (block) => {\n    //     invariant(block._tag === 'transcript' || block._tag === 'text');\n    //     return extractFullEntities(block.text);\n    //   }),\n    // ).then((entities) => entities.flat());\n    // const entities = options?.timeout ? await asyncTimeout(entitiesPromise, options.timeout) : await entitiesPromise;\n\n    // log.info('entities', { entities });\n    // const quoteReferences = await findQuotes(\n    //   entities.map((entity) => entity.word),\n    //   db,\n    // );\n\n    // const blocksWithReferences = message.blocks.map((block) => {\n    //   invariant(block._tag === 'transcript' || block._tag === 'text');\n    //   return { ...block, text: insertReferences(block._tag, quoteReferences) };\n    // });\n\n    // const messageWithReferences = create(Message.Message, {\n    //   ...message,\n    //   blocks: blocksWithReferences,\n    // });\n\n    // log.info('output', { messageWithReferences });\n    // return {\n    //   message: messageWithReferences,\n    //   timeElapsed: performance.now() - startTime,\n    // };\n  },\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", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { type Database, Filter, Query } from '@dxos/echo';\nimport { ObjectId } from '@dxos/keys';\nimport { DXN } from '@dxos/keys';\nimport { log } from '@dxos/log';\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 const findQuotes = async (quotes: string[], db: Database.Database): Promise<ReferencedQuotes> => {\n  const references = await Promise.all(\n    quotes.map(async (quote) => {\n      const objects = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();\n      log.info('found quotes in vector index', { objects, quote });\n      return objects.length > 0 ? [{ id: objects[0].id.toString(), quote }] : [];\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) => {\n  for (const quote of quotes.references) {\n    if (!ObjectId.isValid(quote.id)) {\n      continue;\n    }\n\n    // Use a case-insensitive regular expression to replace the quote.\n    const regex = new RegExp(quote.quote.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'), 'gi');\n    text = text.replace(regex, `[${quote.quote}](${DXN.fromLocalObjectId(quote.id).toString()})`);\n  }\n\n  return text;\n};\n"],
+  "mappings": "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",
+  "names": ["Schema", "asyncTimeout", "Obj", "log", "Message", "ExtractionInput", "Struct", "message", "objects", "optional", "Array", "Unknown", "options", "timeout", "Number", "fallbackToRaw", "Boolean", "ExtractionOutput", "timeElapsed", "processTranscriptMessage", "params", "executor", "invoke", "function", "input", "error", "warn", "defineFunction", "extractionAnthropicFunction", "defineFunction", "key", "name", "description", "inputSchema", "ExtractionInput", "outputSchema", "ExtractionOutput", "handler", "data", "message", "objects", "context", "Error", "defineFunction", "extractionNerFunction", "defineFunction", "key", "name", "description", "inputSchema", "ExtractionInput", "outputSchema", "ExtractionOutput", "handler", "data", "message", "options", "context", "Error", "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", "Schema", "Filter", "Query", "ObjectId", "DXN", "log", "ReferencedQuotes", "Struct", "references", "Array", "id", "String", "quote", "pipe", "mutable", "annotations", "description", "findQuotes", "quotes", "db", "Promise", "all", "map", "objects", "query", "select", "text", "type", "run", "info", "length", "toString", "flat", "insertReferences", "isValid", "regex", "RegExp", "replace", "fromLocalObjectId"]
+}