@semiont/make-meaning 0.3.3 → 0.3.5

package/dist/index.d.ts

@@ -1,22 +1,54 @@
 import { JobQueue, ReferenceAnnotationWorker, GenerationWorker, HighlightAnnotationWorker, AssessmentAnnotationWorker, CommentAnnotationWorker, TagAnnotationWorker } from '@semiont/jobs';
 import { EventStore, ViewStorage } from '@semiont/event-sourcing';
-import { FilesystemServiceConfig, GraphServiceConfig, InferenceServiceConfig, Logger, StoredEvent, ResourceId, EventBus, components, UserId, CreationMethod, AnnotationId, ResourceAnnotations, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
+import { SemiontProject } from '@semiont/core/node';
+import { GraphServiceConfig, Logger, StoredEvent, ResourceId, EventBus, components, UserId, CreationMethod, AnnotationId, ResourceAnnotations, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
 export { AssembledAnnotation, applyBodyOperations, assembleAnnotation } from '@semiont/core';
 import { InferenceClient } from '@semiont/inference';
 import { GraphDatabase } from '@semiont/graph';
 import { RepresentationStore } from '@semiont/content';
 import { Writable, Readable } from 'node:stream';
 
+/**
+ * Inference configuration for a single actor or worker.
+ */
+interface InferenceConfig {
+    type: 'anthropic' | 'ollama';
+    model: string;
+    maxTokens?: number;
+    apiKey?: string;
+    endpoint?: string;
+    baseURL?: string;
+}
+/**
+ * Per-actor inference overrides.
+ * Stower never calls an LLM, so it has no entry here.
+ */
+interface ActorInferenceConfig {
+    gatherer?: InferenceConfig;
+    matcher?: InferenceConfig;
+}
+/**
+ * Per-worker-type inference overrides.
+ * Falls back to `workers.default` if a specific worker is not listed.
+ */
+interface WorkerInferenceConfig {
+    default?: InferenceConfig;
+    'reference-annotation'?: InferenceConfig;
+    'highlight-annotation'?: InferenceConfig;
+    'assessment-annotation'?: InferenceConfig;
+    'comment-annotation'?: InferenceConfig;
+    'tag-annotation'?: InferenceConfig;
+    'generation'?: InferenceConfig;
+}
 /** Narrow config type — only the fields make-meaning actually reads */
 interface MakeMeaningConfig {
     services: {
-        filesystem?: FilesystemServiceConfig;
         graph?: GraphServiceConfig;
-        inference?: InferenceServiceConfig;
-    };
-    _metadata?: {
-        projectRoot: string;
     };
+    /** Per-actor inference config */
+    actors?: ActorInferenceConfig;
+    /** Per-worker-type inference config */
+    workers?: WorkerInferenceConfig;
 }
 
 /**
@@ -131,7 +163,7 @@ interface KnowledgeBase {
     content: RepresentationStore;
     graph: GraphDatabase;
 }
-declare function createKnowledgeBase(eventStore: EventStore, basePath: string, projectRoot: string | undefined, graphDb: GraphDatabase, logger: Logger): KnowledgeBase;
+declare function createKnowledgeBase(eventStore: EventStore, project: SemiontProject, graphDb: GraphDatabase, logger: Logger): KnowledgeBase;
 
 /**
  * Gatherer Actor
@@ -163,10 +195,10 @@ declare class Gatherer {
     private kb;
     private eventBus;
     private inferenceClient;
-    private config?;
+    private project?;
     private subscriptions;
     private readonly logger;
-    constructor(kb: KnowledgeBase, eventBus: EventBus, inferenceClient: InferenceClient, logger: Logger, config?: MakeMeaningConfig | undefined);
+    constructor(kb: KnowledgeBase, eventBus: EventBus, inferenceClient: InferenceClient, logger: Logger, project?: SemiontProject | undefined);
     initialize(): Promise<void>;
     private handleAnnotationGather;
     private handleResourceGather;
@@ -342,8 +374,9 @@ interface MakeMeaningService {
     kb: KnowledgeBase;
     jobQueue: JobQueue;
     eventStore: EventStore;
-    inferenceClient: InferenceClient;
     graphDb: GraphDatabase;
+    /** Inference client for the Gatherer actor — use for context-assembly operations */
+    gathererInferenceClient: InferenceClient;
     workers: {
         detection: ReferenceAnnotationWorker;
         generation: GenerationWorker;
@@ -359,7 +392,7 @@ interface MakeMeaningService {
     cloneTokenManager: CloneTokenManager;
     stop: () => Promise<void>;
 }
-declare function startMakeMeaning(config: MakeMeaningConfig, eventBus: EventBus, logger: Logger): Promise<MakeMeaningService>;
+declare function startMakeMeaning(project: SemiontProject, config: MakeMeaningConfig, eventBus: EventBus, logger: Logger): Promise<MakeMeaningService>;
 
 /**
  * Entity Types Bootstrap Service
@@ -373,7 +406,7 @@ declare function startMakeMeaning(config: MakeMeaningConfig, eventBus: EventBus,
  * Bootstrap entity types projection if it doesn't exist.
  * Uses a system user ID (00000000-0000-0000-0000-000000000000) for bootstrap events.
  */
-declare function bootstrapEntityTypes(eventBus: EventBus, config: MakeMeaningConfig, logger?: Logger): Promise<void>;
+declare function bootstrapEntityTypes(eventBus: EventBus, project: SemiontProject, logger?: Logger): Promise<void>;
 /**
  * Reset the bootstrap flag (used for testing)
  */
@@ -389,7 +422,7 @@ declare function resetBootstrap(): void;
 /**
  * Read entity types from view storage projection
  */
-declare function readEntityTypesProjection(config: MakeMeaningConfig): Promise<string[]>;
+declare function readEntityTypesProjection(project: SemiontProject): Promise<string[]>;
 
 /**
  * Exchange Format Manifest Types

package/dist/index.js

@@ -737,7 +737,7 @@ var require_Observable = __commonJS({
       Observable2.prototype.forEach = function(next, promiseCtor) {
         var _this = this;
         promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function(resolve4, reject) {
+        return new promiseCtor(function(resolve, reject) {
           var subscriber = new Subscriber_1.SafeSubscriber({
             next: function(value) {
               try {
@@ -748,7 +748,7 @@ var require_Observable = __commonJS({
               }
             },
             error: reject,
-            complete: resolve4
+            complete: resolve
           });
           _this.subscribe(subscriber);
         });
@@ -770,14 +770,14 @@ var require_Observable = __commonJS({
       Observable2.prototype.toPromise = function(promiseCtor) {
         var _this = this;
         promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function(resolve4, reject) {
+        return new promiseCtor(function(resolve, reject) {
           var value;
           _this.subscribe(function(x) {
             return value = x;
           }, function(err) {
             return reject(err);
           }, function() {
-            return resolve4(value);
+            return resolve(value);
           });
         });
       };
@@ -2873,11 +2873,11 @@ var require_innerFrom = __commonJS({
     "use strict";
     var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve4) {
-          resolve4(value);
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve4, reject) {
+      return new (P || (P = Promise))(function(resolve, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -2893,7 +2893,7 @@ var require_innerFrom = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve4(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -2975,14 +2975,14 @@ var require_innerFrom = __commonJS({
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve4, reject) {
-            v = o[n](v), settle(resolve4, reject, v.done, v.value);
+          return new Promise(function(resolve, reject) {
+            v = o[n](v), settle(resolve, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve4, reject, d, v) {
+      function settle(resolve, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve4({ value: v2, done: d });
+          resolve({ value: v2, done: d });
         }, reject);
       }
     };
@@ -3601,7 +3601,7 @@ var require_lastValueFrom = __commonJS({
     var EmptyError_1 = require_EmptyError();
     function lastValueFrom(source, config) {
       var hasConfig = typeof config === "object";
-      return new Promise(function(resolve4, reject) {
+      return new Promise(function(resolve, reject) {
         var _hasValue = false;
         var _value;
         source.subscribe({
@@ -3612,9 +3612,9 @@ var require_lastValueFrom = __commonJS({
           error: reject,
           complete: function() {
             if (_hasValue) {
-              resolve4(_value);
+              resolve(_value);
             } else if (hasConfig) {
-              resolve4(config.defaultValue);
+              resolve(config.defaultValue);
             } else {
               reject(new EmptyError_1.EmptyError());
             }
@@ -3636,16 +3636,16 @@ var require_firstValueFrom = __commonJS({
     var Subscriber_1 = require_Subscriber();
     function firstValueFrom5(source, config) {
       var hasConfig = typeof config === "object";
-      return new Promise(function(resolve4, reject) {
+      return new Promise(function(resolve, reject) {
         var subscriber = new Subscriber_1.SafeSubscriber({
           next: function(value) {
-            resolve4(value);
+            resolve(value);
             subscriber.unsubscribe();
           },
           error: reject,
           complete: function() {
             if (hasConfig) {
-              resolve4(config.defaultValue);
+              resolve(config.defaultValue);
             } else {
               reject(new EmptyError_1.EmptyError());
             }
@@ -9943,14 +9943,33 @@ var require_operators = __commonJS({
 });
 
 // src/service.ts
-var import_rxjs8 = __toESM(require_cjs(), 1);
-var import_operators8 = __toESM(require_operators(), 1);
-import * as path3 from "path";
 import { JobQueue } from "@semiont/jobs";
 import { createEventStore as createEventStoreCore } from "@semiont/event-sourcing";
 import { getPrimaryRepresentation as getPrimaryRepresentation4 } from "@semiont/api-client";
+
+// src/config.ts
+function resolveActorInference(config, actor) {
+  const specific = config.actors?.[actor];
+  if (specific) return specific;
+  throw new Error(
+    `No inference config found for actor '${actor}'. Set actors.${actor}.inference in your config.`
+  );
+}
+function resolveWorkerInference(config, workerType) {
+  const specific = config.workers?.[workerType];
+  if (specific) return specific;
+  const defaultWorker = config.workers?.default;
+  if (defaultWorker) return defaultWorker;
+  throw new Error(
+    `No inference config found for worker '${workerType}'. Set workers.${workerType}.inference or workers.default.inference in your config.`
+  );
+}
+
+// src/service.ts
+var import_rxjs8 = __toESM(require_cjs(), 1);
+var import_operators8 = __toESM(require_operators(), 1);
 import { Readable } from "stream";
-import { getInferenceClient } from "@semiont/inference";
+import { createInferenceClient } from "@semiont/inference";
 import { getGraphDatabase } from "@semiont/graph";
 import {
   ReferenceAnnotationWorker,
@@ -10378,26 +10397,13 @@ import * as path from "path";
 import { DEFAULT_ENTITY_TYPES } from "@semiont/ontology";
 import { userId } from "@semiont/core";
 var bootstrapCompleted = false;
-async function bootstrapEntityTypes(eventBus, config, logger) {
+async function bootstrapEntityTypes(eventBus, project, logger) {
   if (bootstrapCompleted) {
     logger?.debug("Entity types bootstrap already completed, skipping");
     return;
   }
-  const configuredPath = config.services.filesystem?.path;
-  if (!configuredPath) {
-    throw new Error("services.filesystem.path is required for entity types bootstrap");
-  }
-  const projectRoot = config._metadata?.projectRoot;
-  let basePath;
-  if (path.isAbsolute(configuredPath)) {
-    basePath = configuredPath;
-  } else if (projectRoot) {
-    basePath = path.resolve(projectRoot, configuredPath);
-  } else {
-    basePath = path.resolve(configuredPath);
-  }
   const projectionPath = path.join(
-    basePath,
+    project.stateDir,
     "projections",
     "__system__",
     "entitytypes.json"
@@ -10437,11 +10443,10 @@ function resetBootstrap() {
 // src/knowledge-base.ts
 import { FilesystemViewStorage } from "@semiont/event-sourcing";
 import { FilesystemRepresentationStore } from "@semiont/content";
-function createKnowledgeBase(eventStore, basePath, projectRoot, graphDb, logger) {
-  const views = new FilesystemViewStorage(basePath, projectRoot);
+function createKnowledgeBase(eventStore, project, graphDb, logger) {
+  const views = new FilesystemViewStorage(project);
   const content = new FilesystemRepresentationStore(
-    { basePath },
-    projectRoot,
+    project,
     logger.child({ component: "representation-store" })
   );
   return { eventStore, views, content, graph: graphDb };
@@ -11148,22 +11153,9 @@ var LLMContext = class {
 // src/views/entity-types-reader.ts
 import { promises as fs2 } from "fs";
 import * as path2 from "path";
-async function readEntityTypesProjection(config) {
-  const configuredPath = config.services.filesystem?.path;
-  if (!configuredPath) {
-    throw new Error("services.filesystem.path is required for entity types reader");
-  }
-  const projectRoot = config._metadata?.projectRoot;
-  let basePath;
-  if (path2.isAbsolute(configuredPath)) {
-    basePath = configuredPath;
-  } else if (projectRoot) {
-    basePath = path2.resolve(projectRoot, configuredPath);
-  } else {
-    basePath = path2.resolve(configuredPath);
-  }
+async function readEntityTypesProjection(project) {
   const entityTypesPath = path2.join(
-    basePath,
+    project.stateDir,
     "projections",
     "__system__",
     "entitytypes.json"
@@ -11182,11 +11174,11 @@ async function readEntityTypesProjection(config) {
 
 // src/gatherer.ts
 var Gatherer = class {
-  constructor(kb, eventBus, inferenceClient, logger, config) {
+  constructor(kb, eventBus, inferenceClient, logger, project) {
     this.kb = kb;
     this.eventBus = eventBus;
     this.inferenceClient = inferenceClient;
-    this.config = config;
+    this.project = project;
     this.logger = logger;
   }
   subscriptions = [];
@@ -11518,10 +11510,10 @@ var Gatherer = class {
   // ========================================================================
   async handleEntityTypes(event) {
     try {
-      if (!this.config) {
-        throw new Error("MakeMeaningConfig required for entity type reads");
+      if (!this.project) {
+        throw new Error("SemiontProject required for entity type reads");
       }
-      const entityTypes = await readEntityTypesProjection(this.config);
+      const entityTypes = await readEntityTypesProjection(this.project);
       this.eventBus.get("mark:entity-types-result").next({
         correlationId: event.correlationId,
         response: { entityTypes }
@@ -12395,27 +12387,13 @@ var CloneTokenManager = class {
 };
 
 // src/service.ts
-async function startMakeMeaning(config, eventBus, logger) {
-  const filesystemConfig = config.services?.filesystem;
-  if (!filesystemConfig?.path) {
-    throw new Error("services.filesystem.path is required for make-meaning service");
-  }
+async function startMakeMeaning(project, config, eventBus, logger) {
   const graphConfig = config.services?.graph;
   if (!graphConfig) {
     throw new Error("services.graph is required for make-meaning service");
   }
-  const configuredPath = filesystemConfig.path;
-  const projectRoot = config._metadata?.projectRoot;
-  let basePath;
-  if (path3.isAbsolute(configuredPath)) {
-    basePath = configuredPath;
-  } else if (projectRoot) {
-    basePath = path3.resolve(projectRoot, configuredPath);
-  } else {
-    basePath = path3.resolve(configuredPath);
-  }
   const jobQueueLogger = logger.child({ component: "job-queue" });
-  const jobQueue = new JobQueue({ dataDir: basePath }, jobQueueLogger, eventBus);
+  const jobQueue = new JobQueue(project, jobQueueLogger, eventBus);
   await jobQueue.initialize();
   const jobStatusSubscription = eventBus.get("job:status-requested").pipe(
     (0, import_operators8.mergeMap)((event) => (0, import_rxjs8.from)((async () => {
@@ -12454,15 +12432,41 @@ async function startMakeMeaning(config, eventBus, logger) {
     error: (err) => jobQueueLogger.error("Job status pipeline error", { error: err })
   });
   const eventStoreLogger = logger.child({ component: "event-store" });
-  const eventStore = createEventStoreCore(basePath, void 0, eventBus, eventStoreLogger);
-  const inferenceLogger = logger.child({ component: "inference-client" });
-  const inferenceConfig = config.services?.inference;
-  if (!inferenceConfig) {
-    throw new Error("services.inference is required for make-meaning service");
-  }
-  const inferenceClient = await getInferenceClient(inferenceConfig, inferenceLogger);
+  const eventStore = createEventStoreCore(project, void 0, eventBus, eventStoreLogger);
+  const gathererInferenceClient = createInferenceClient(
+    resolveActorInference(config, "gatherer"),
+    logger.child({ component: "inference-client-gatherer" })
+  );
+  const matcherInferenceClient = createInferenceClient(
+    resolveActorInference(config, "matcher"),
+    logger.child({ component: "inference-client-matcher" })
+  );
+  const detectionInferenceClient = createInferenceClient(
+    resolveWorkerInference(config, "reference-annotation"),
+    logger.child({ component: "inference-client-reference-annotation" })
+  );
+  const generationInferenceClient = createInferenceClient(
+    resolveWorkerInference(config, "generation"),
+    logger.child({ component: "inference-client-generation" })
+  );
+  const highlightInferenceClient = createInferenceClient(
+    resolveWorkerInference(config, "highlight-annotation"),
+    logger.child({ component: "inference-client-highlight-annotation" })
+  );
+  const assessmentInferenceClient = createInferenceClient(
+    resolveWorkerInference(config, "assessment-annotation"),
+    logger.child({ component: "inference-client-assessment-annotation" })
+  );
+  const commentInferenceClient = createInferenceClient(
+    resolveWorkerInference(config, "comment-annotation"),
+    logger.child({ component: "inference-client-comment-annotation" })
+  );
+  const tagInferenceClient = createInferenceClient(
+    resolveWorkerInference(config, "tag-annotation"),
+    logger.child({ component: "inference-client-tag-annotation" })
+  );
   const graphDb = await getGraphDatabase(graphConfig);
-  const kb = createKnowledgeBase(eventStore, basePath, projectRoot, graphDb, logger);
+  const kb = createKnowledgeBase(eventStore, project, graphDb, logger);
   const graphConsumerLogger = logger.child({ component: "graph-consumer" });
   const graphConsumer = new GraphDBConsumer(eventStore, graphDb, graphConsumerLogger);
   await graphConsumer.initialize();
@@ -12470,12 +12474,12 @@ async function startMakeMeaning(config, eventBus, logger) {
   const stower = new Stower(kb, eventBus, stowerLogger);
   await stower.initialize();
   const bootstrapLogger = logger.child({ component: "entity-types-bootstrap" });
-  await bootstrapEntityTypes(eventBus, config, bootstrapLogger);
+  await bootstrapEntityTypes(eventBus, project, bootstrapLogger);
   const gathererLogger = logger.child({ component: "gatherer" });
-  const gatherer = new Gatherer(kb, eventBus, inferenceClient, gathererLogger, config);
+  const gatherer = new Gatherer(kb, eventBus, gathererInferenceClient, gathererLogger, project);
   await gatherer.initialize();
   const matcherLogger = logger.child({ component: "matcher" });
-  const matcher = new Matcher(kb, eventBus, matcherLogger, inferenceClient);
+  const matcher = new Matcher(kb, eventBus, matcherLogger, matcherInferenceClient);
   await matcher.initialize();
   const cloneTokenLogger = logger.child({ component: "clone-token-manager" });
   const cloneTokenManager = new CloneTokenManager(kb, eventBus, cloneTokenLogger);
@@ -12496,12 +12500,12 @@ async function startMakeMeaning(config, eventBus, logger) {
   const commentLogger = logger.child({ component: "comment-detection-worker" });
   const tagLogger = logger.child({ component: "tag-detection-worker" });
   const workers = {
-    detection: new ReferenceAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, detectionLogger),
-    generation: new GenerationWorker(jobQueue, inferenceClient, eventBus, generationLogger),
-    highlight: new HighlightAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, highlightLogger),
-    assessment: new AssessmentAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, assessmentLogger),
-    comment: new CommentAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, commentLogger),
-    tag: new TagAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, tagLogger)
+    detection: new ReferenceAnnotationWorker(jobQueue, detectionInferenceClient, eventBus, contentFetcher, detectionLogger),
+    generation: new GenerationWorker(jobQueue, generationInferenceClient, eventBus, generationLogger),
+    highlight: new HighlightAnnotationWorker(jobQueue, highlightInferenceClient, eventBus, contentFetcher, highlightLogger),
+    assessment: new AssessmentAnnotationWorker(jobQueue, assessmentInferenceClient, eventBus, contentFetcher, assessmentLogger),
+    comment: new CommentAnnotationWorker(jobQueue, commentInferenceClient, eventBus, contentFetcher, commentLogger),
+    tag: new TagAnnotationWorker(jobQueue, tagInferenceClient, eventBus, contentFetcher, tagLogger)
   };
   workers.detection.start().catch((error) => {
     detectionLogger.error("Worker stopped unexpectedly", { error });
@@ -12525,8 +12529,8 @@ async function startMakeMeaning(config, eventBus, logger) {
     kb,
     jobQueue,
     eventStore,
-    inferenceClient,
     graphDb,
+    gathererInferenceClient,
     workers,
     graphConsumer,
     stower,
@@ -12609,9 +12613,9 @@ async function writeTarGz(entries, output) {
 async function decompressStream(input) {
   const gunzip = createGunzip();
   const chunks = [];
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve, reject) => {
     gunzip.on("data", (chunk) => chunks.push(chunk));
-    gunzip.on("end", () => resolve4(Buffer.concat(chunks)));
+    gunzip.on("end", () => resolve(Buffer.concat(chunks)));
     gunzip.on("error", reject);
     input.on("error", reject);
     input.pipe(gunzip);