@pikku/mongodb 0.12.15 → 0.12.18

package/dist/src/mongodb-ai-storage-service.js

@@ -6,6 +6,7 @@ export class MongoDBAIStorageService {
     toolCalls;
     workingMemory;
     aiRuns;
+    aiRunScores;
     constructor(db) {
         this.db = db;
     }
@@ -18,12 +19,14 @@ export class MongoDBAIStorageService {
         this.workingMemory =
             this.db.collection('ai_working_memory');
         this.aiRuns = this.db.collection('ai_run');
+        this.aiRunScores = this.db.collection('ai_run_score');
         await this.threads.createIndex({ resourceId: 1 });
         await this.aiMessages.createIndex({ threadId: 1, createdAt: 1 });
         await this.toolCalls.createIndex({ threadId: 1 });
         await this.toolCalls.createIndex({ messageId: 1 });
         await this.workingMemory.createIndex({ id: 1, scope: 1 }, { unique: true });
         await this.aiRuns.createIndex({ threadId: 1, createdAt: 1 });
+        await this.aiRunScores.createIndex({ runId: 1, createdAt: 1 });
         this.initialized = true;
     }
     async createThread(resourceId, options) {
@@ -406,5 +409,30 @@ export class MongoDBAIStorageService {
         const result = await this.toolCalls.updateOne({ _id: toolCallId, approvalStatus: 'pending' }, { $set: { approvalStatus: status } });
         return result.modifiedCount > 0;
     }
+    async saveScore(score) {
+        await this.aiRunScores.insertOne({
+            _id: crypto.randomUUID(),
+            runId: score.runId,
+            scorerName: score.scorerName,
+            score: score.score,
+            reason: score.reason ?? null,
+            metadata: score.metadata ?? null,
+            createdAt: new Date(),
+        });
+    }
+    async getScores(runId) {
+        const rows = await this.aiRunScores
+            .find({ runId })
+            .sort({ createdAt: 1 })
+            .toArray();
+        return rows.map((row) => ({
+            runId: row.runId,
+            scorerName: row.scorerName,
+            score: row.score,
+            reason: row.reason ?? undefined,
+            metadata: row.metadata ?? undefined,
+            createdAt: row.createdAt,
+        }));
+    }
     async close() { }
 }

package/dist/src/mongodb-deployment-service.d.ts

@@ -1,4 +1,4 @@
-import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig } from '@pikku/core/services';
+import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig } from '@pikku/core/ecosystem/services';
 import type { JWTService, SecretService } from '@pikku/core/services';
 import type { Db } from 'mongodb';
 export declare class MongoDBDeploymentService implements DeploymentService {

package/dist/src/mongodb-deployment-service.js

@@ -1,5 +1,5 @@
-import { buildRemoteHeaders } from '@pikku/core/remote';
-import { getAllFunctionNames } from '@pikku/core/function';
+import { buildRemoteHeaders } from '@pikku/core/ecosystem/remote';
+import { getAllFunctionNames } from '@pikku/core/ecosystem/function';
 export class MongoDBDeploymentService {
     db;
     jwt;

package/dist/src/mongodb-eventhub-store.d.ts

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/channel';
+import { EventHubStore } from '@pikku/core/ecosystem/channel';
 import type { Db } from 'mongodb';
 export declare class MongoDBEventHubStore extends EventHubStore {
     private db;

package/dist/src/mongodb-eventhub-store.js

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/channel';
+import { EventHubStore } from '@pikku/core/ecosystem/channel';
 export class MongoDBEventHubStore extends EventHubStore {
     db;
     initialized = false;

package/dist/src/mongodb-workflow-run-service.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowRun, StepState, WorkflowRunService } from '@pikku/core/workflow';
+import type { WorkflowRun, StepState, WorkflowRunService } from '@pikku/core/ecosystem/workflow';
 import type { Db } from 'mongodb';
 export declare class MongoDBWorkflowRunService implements WorkflowRunService {
     private runs;

package/dist/src/mongodb-workflow-service.d.ts

@@ -1,5 +1,6 @@
-import type { SerializedError } from '@pikku/core';
-import { PikkuWorkflowService, type WorkflowPlannedStep, type WorkflowQueueOptions, type WorkflowRun, type WorkflowRunWire, type StepState, type StepStatus, type WorkflowStatus, type WorkflowVersionStatus } from '@pikku/core/workflow';
+import type { SerializedError } from '@pikku/core/ecosystem/types';
+import { PikkuWorkflowService } from '@pikku/core/workflow';
+import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/ecosystem/workflow';
 import type { Db } from 'mongodb';
 export declare class MongoDBWorkflowService extends PikkuWorkflowService {
     private initialized;

package/dist/src/mongodb-workflow-service.js

@@ -1,4 +1,4 @@
-import { PikkuWorkflowService, } from '@pikku/core/workflow';
+import { PikkuWorkflowService } from '@pikku/core/workflow';
 import { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js';
 export class MongoDBWorkflowService extends PikkuWorkflowService {
     initialized = false;

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/mongodb-agent-run-service.ts","../src/mongodb-ai-storage-service.ts","../src/mongodb-channel-store.ts","../src/mongodb-deployment-service.ts","../src/mongodb-eventhub-store.ts","../src/mongodb-secret-service.ts","../src/mongodb-session-store.ts","../src/mongodb-workflow-run-service.ts","../src/mongodb-workflow-service.ts","../src/pikku-mongodb.ts"],"version":"6.0.3"}
+{"root":["../src/index.ts","../src/mongodb-agent-run-service.ts","../src/mongodb-agent-storage-service.ts","../src/mongodb-channel-store.ts","../src/mongodb-deployment-service.ts","../src/mongodb-eventhub-store.ts","../src/mongodb-secret-service.ts","../src/mongodb-session-store.ts","../src/mongodb-workflow-run-service.ts","../src/mongodb-workflow-service.ts","../src/pikku-mongodb.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/mongodb",
-  "version": "0.12.15",
+  "version": "0.12.18",
   "description": "MongoDB services for Pikku — workflow state, agent runs, secrets and channel stores",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "prepublishOnly": "yarn build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.80"
+    "@pikku/core": "^0.12.84"
   },
   "dependencies": {
     "mongodb": "^6.12.0"

package/src/index.ts

@@ -5,11 +5,13 @@ export { MongoDBEventHubStore } from './mongodb-eventhub-store.js'
 export { MongoDBWorkflowService } from './mongodb-workflow-service.js'
 export { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'
 export { MongoDBDeploymentService } from './mongodb-deployment-service.js'
-export { MongoDBAIStorageService } from './mongodb-ai-storage-service.js'
+export { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js'
 export { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
 export { MongoDBSecretService } from './mongodb-secret-service.js'
-export type { MongoDBSecretServiceConfig } from './mongodb-secret-service.js'
 
-export type { WorkflowRunService } from '@pikku/core/workflow'
-export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent'
+export type { WorkflowRunService } from '@pikku/core/ecosystem/workflow'
+export type {
+  AgentRunService,
+  AgentRunRow,
+} from '@pikku/core/ecosystem/agent'
 export { MongoDBSessionStore } from './mongodb-session-store.js'

package/src/mongodb-agent-run-service.ts

@@ -1,9 +1,8 @@
+import type { AgentThread, AgentMessage } from '@pikku/core/agent'
 import type {
-  AIThread,
-  AIMessage,
   AgentRunRow,
   AgentRunService,
-} from '@pikku/core/ai-agent'
+} from '@pikku/core/ecosystem/agent'
 import type { Db, Collection } from 'mongodb'
 
 // Owner ids are untrusted input to the regex, so metacharacters must not be
@@ -11,7 +10,7 @@ import type { Db, Collection } from 'mongodb'
 const escapeRegExp = (value: string) =>
   value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
-interface AIThreadDoc {
+interface AgentThreadDoc {
   _id: string
   resourceId: string
   title: string | null
@@ -20,7 +19,7 @@ interface AIThreadDoc {
   updatedAt: Date
 }
 
-interface AIMessageDoc {
+interface AgentMessageDoc {
   _id: string
   threadId: string
   role: string
@@ -28,7 +27,7 @@ interface AIMessageDoc {
   createdAt: Date
 }
 
-interface AIToolCallDoc {
+interface AgentToolCallDoc {
   _id: string
   threadId: string
   messageId: string
@@ -44,7 +43,7 @@ interface AIToolCallDoc {
   createdAt: Date
 }
 
-interface AIRunDoc {
+interface AgentRunDoc {
   _id: string
   agentName: string
   threadId: string
@@ -61,16 +60,16 @@ interface AIRunDoc {
 }
 
 export class MongoDBAgentRunService implements AgentRunService {
-  private threads: Collection<AIThreadDoc>
-  private messages: Collection<AIMessageDoc>
-  private toolCalls: Collection<AIToolCallDoc>
-  private runs: Collection<AIRunDoc>
+  private threads: Collection<AgentThreadDoc>
+  private messages: Collection<AgentMessageDoc>
+  private toolCalls: Collection<AgentToolCallDoc>
+  private runs: Collection<AgentRunDoc>
 
   constructor(db: Db) {
-    this.threads = db.collection<AIThreadDoc>('ai_threads')
-    this.messages = db.collection<AIMessageDoc>('ai_message')
-    this.toolCalls = db.collection<AIToolCallDoc>('ai_tool_call')
-    this.runs = db.collection<AIRunDoc>('ai_run')
+    this.threads = db.collection<AgentThreadDoc>('agent_threads')
+    this.messages = db.collection<AgentMessageDoc>('agent_message')
+    this.toolCalls = db.collection<AgentToolCallDoc>('agent_tool_call')
+    this.runs = db.collection<AgentRunDoc>('agent_run')
   }
 
   async listThreads(options?: {
@@ -79,7 +78,7 @@ export class MongoDBAgentRunService implements AgentRunService {
     owners?: string[]
     limit?: number
     offset?: number
-  }): Promise<AIThread[]> {
+  }): Promise<AgentThread[]> {
     const {
       agentName,
       resourceId,
@@ -122,13 +121,13 @@ export class MongoDBAgentRunService implements AgentRunService {
     return result.map((row) => this.mapThreadRow(row))
   }
 
-  async getThread(threadId: string): Promise<AIThread | null> {
+  async getThread(threadId: string): Promise<AgentThread | null> {
     const row = await this.threads.findOne({ _id: threadId })
     if (!row) return null
     return this.mapThreadRow(row)
   }
 
-  async getThreadMessages(threadId: string): Promise<AIMessage[]> {
+  async getThreadMessages(threadId: string): Promise<AgentMessage[]> {
     const [msgResult, tcResult] = await Promise.all([
       this.messages.find({ threadId }).sort({ createdAt: 1 }).toArray(),
       this.toolCalls.find({ threadId }).sort({ createdAt: 1 }).toArray(),
@@ -141,11 +140,11 @@ export class MongoDBAgentRunService implements AgentRunService {
       tcByMessage.get(msgId)!.push(tc)
     }
 
-    const messages: AIMessage[] = []
+    const messages: AgentMessage[] = []
     for (const row of msgResult) {
-      const msg: AIMessage = {
+      const msg: AgentMessage = {
         id: row._id,
-        role: row.role as AIMessage['role'],
+        role: row.role as AgentMessage['role'],
         content: row.content ?? undefined,
         createdAt: new Date(row.createdAt),
       }
@@ -203,7 +202,7 @@ export class MongoDBAgentRunService implements AgentRunService {
     return result.sort()
   }
 
-  private mapThreadRow(row: AIThreadDoc): AIThread {
+  private mapThreadRow(row: AgentThreadDoc): AgentThread {
     return {
       id: row._id,
       resourceId: row.resourceId,
@@ -214,7 +213,7 @@ export class MongoDBAgentRunService implements AgentRunService {
     }
   }
 
-  private mapRunRow(row: AIRunDoc): AgentRunRow {
+  private mapRunRow(row: AgentRunDoc): AgentRunRow {
     return {
       runId: row._id,
       agentName: row.agentName,

package/src/{mongodb-ai-storage-service.ts → mongodb-agent-storage-service.ts}

@@ -1,12 +1,18 @@
 import type {
-  AIStorageService,
-  AIRunStateService,
+  AgentStorageService,
+  AgentRunStateService,
   CreateRunInput,
+  SaveScoreInput,
 } from '@pikku/core/services'
-import type { AIThread, AIMessage, AgentRunState } from '@pikku/core/ai-agent'
+import type {
+  AgentThread,
+  AgentMessage,
+  AgentRunState,
+} from '@pikku/core/agent'
+import type { AgentRunScore } from '@pikku/core/agent-scorer'
 import type { Db, Collection } from 'mongodb'
 
-interface AIThreadDoc {
+interface AgentThreadDoc {
   _id: string
   resourceId: string
   title: string | null
@@ -15,7 +21,7 @@ interface AIThreadDoc {
   updatedAt: Date
 }
 
-interface AIMessageDoc {
+interface AgentMessageDoc {
   _id: string
   threadId: string
   role: string
@@ -23,7 +29,7 @@ interface AIMessageDoc {
   createdAt: Date
 }
 
-interface AIToolCallDoc {
+interface AgentToolCallDoc {
   _id: string
   threadId: string
   messageId: string
@@ -39,14 +45,24 @@ interface AIToolCallDoc {
   createdAt: Date
 }
 
-interface AIWorkingMemoryDoc {
+interface AgentWorkingMemoryDoc {
   id: string
   scope: string
   data: any
   updatedAt: Date
 }
 
-interface AIRunDoc {
+interface AgentRunScoreDoc {
+  _id: string
+  runId: string
+  scorerName: string
+  score: number
+  reason: string | null
+  metadata: any | null
+  createdAt: Date
+}
+
+interface AgentRunDoc {
   _id: string
   agentName: string
   threadId: string
@@ -62,38 +78,44 @@ interface AIRunDoc {
   updatedAt: Date
 }
 
-export class MongoDBAIStorageService
-  implements AIStorageService, AIRunStateService
+export class MongoDBAgentStorageService
+  implements AgentStorageService, AgentRunStateService
 {
   private initialized = false
-  private threads!: Collection<AIThreadDoc>
-  private aiMessages!: Collection<AIMessageDoc>
-  private toolCalls!: Collection<AIToolCallDoc>
-  private workingMemory!: Collection<AIWorkingMemoryDoc>
-  private aiRuns!: Collection<AIRunDoc>
+  private threads!: Collection<AgentThreadDoc>
+  private agentMessages!: Collection<AgentMessageDoc>
+  private toolCalls!: Collection<AgentToolCallDoc>
+  private workingMemory!: Collection<AgentWorkingMemoryDoc>
+  private agentRuns!: Collection<AgentRunDoc>
+  private agentRunScores!: Collection<AgentRunScoreDoc>
 
   constructor(private db: Db) {}
 
   public async init(): Promise<void> {
     if (this.initialized) return
 
-    this.threads = this.db.collection<AIThreadDoc>('ai_threads')
-    this.aiMessages = this.db.collection<AIMessageDoc>('ai_message')
-    this.toolCalls = this.db.collection<AIToolCallDoc>('ai_tool_call')
-    this.workingMemory =
-      this.db.collection<AIWorkingMemoryDoc>('ai_working_memory')
-    this.aiRuns = this.db.collection<AIRunDoc>('ai_run')
+    this.threads = this.db.collection<AgentThreadDoc>('agent_threads')
+    this.agentMessages = this.db.collection<AgentMessageDoc>('agent_message')
+    this.toolCalls = this.db.collection<AgentToolCallDoc>('agent_tool_call')
+    this.workingMemory = this.db.collection<AgentWorkingMemoryDoc>(
+      'agent_working_memory'
+    )
+    this.agentRuns = this.db.collection<AgentRunDoc>('agent_run')
+    this.agentRunScores =
+      this.db.collection<AgentRunScoreDoc>('agent_run_score')
 
     await this.threads.createIndex({ resourceId: 1 })
 
-    await this.aiMessages.createIndex({ threadId: 1, createdAt: 1 })
+    await this.agentMessages.createIndex({ threadId: 1, createdAt: 1 })
 
     await this.toolCalls.createIndex({ threadId: 1 })
     await this.toolCalls.createIndex({ messageId: 1 })
 
     await this.workingMemory.createIndex({ id: 1, scope: 1 }, { unique: true })
 
-    await this.aiRuns.createIndex({ threadId: 1, createdAt: 1 })
+    await this.agentRuns.createIndex({ threadId: 1, createdAt: 1 })
+
+    await this.agentRunScores.createIndex({ runId: 1, createdAt: 1 })
 
     this.initialized = true
   }
@@ -105,7 +127,7 @@ export class MongoDBAIStorageService
       title?: string
       metadata?: Record<string, unknown>
     }
-  ): Promise<AIThread> {
+  ): Promise<AgentThread> {
     const id = options?.threadId ?? crypto.randomUUID()
     const now = new Date()
 
@@ -128,7 +150,7 @@ export class MongoDBAIStorageService
     }
   }
 
-  async getThread(threadId: string): Promise<AIThread> {
+  async getThread(threadId: string): Promise<AgentThread> {
     const row = await this.threads.findOne({ _id: threadId })
 
     if (!row) {
@@ -145,7 +167,7 @@ export class MongoDBAIStorageService
     }
   }
 
-  async getThreads(resourceId: string): Promise<AIThread[]> {
+  async getThreads(resourceId: string): Promise<AgentThread[]> {
     const result = await this.threads
       .find({ resourceId })
       .sort({ updatedAt: -1 })
@@ -163,19 +185,21 @@ export class MongoDBAIStorageService
 
   async deleteThread(threadId: string): Promise<void> {
     await this.toolCalls.deleteMany({ threadId })
-    await this.aiMessages.deleteMany({ threadId })
-    await this.aiRuns.deleteMany({ threadId })
+    await this.agentMessages.deleteMany({ threadId })
+    await this.agentRuns.deleteMany({ threadId })
     await this.threads.deleteOne({ _id: threadId })
   }
 
   async getMessages(
     threadId: string,
     options?: { lastN?: number; cursor?: string }
-  ): Promise<AIMessage[]> {
+  ): Promise<AgentMessage[]> {
     let filter: Record<string, any> = { threadId }
 
     if (options?.cursor) {
-      const cursorRow = await this.aiMessages.findOne({ _id: options.cursor })
+      const cursorRow = await this.agentMessages.findOne({
+        _id: options.cursor,
+      })
       if (cursorRow) {
         filter.createdAt = { $lt: cursorRow.createdAt }
       }
@@ -183,7 +207,7 @@ export class MongoDBAIStorageService
 
     let msgResult
     if (options?.cursor || options?.lastN) {
-      const innerResult = await this.aiMessages
+      const innerResult = await this.agentMessages
         .find(filter)
         .sort({ createdAt: -1 })
         .limit(options?.lastN ?? 50)
@@ -191,7 +215,7 @@ export class MongoDBAIStorageService
       innerResult.reverse()
       msgResult = innerResult
     } else {
-      msgResult = await this.aiMessages
+      msgResult = await this.agentMessages
         .find(filter)
         .sort({ createdAt: 1 })
         .toArray()
@@ -209,9 +233,9 @@ export class MongoDBAIStorageService
       tcByMessage.get(msgId)!.push(tc)
     }
 
-    const messages: AIMessage[] = []
+    const messages: AgentMessage[] = []
     for (const row of msgResult) {
-      let parsedContent: AIMessage['content'] = row.content ?? undefined
+      let parsedContent: AgentMessage['content'] = row.content ?? undefined
       if (typeof row.content === 'string') {
         try {
           const parsed = JSON.parse(row.content)
@@ -225,9 +249,9 @@ export class MongoDBAIStorageService
         }
       }
 
-      const msg: AIMessage = {
+      const msg: AgentMessage = {
         id: row._id,
-        role: row.role as AIMessage['role'],
+        role: row.role as AgentMessage['role'],
         content: parsedContent,
         createdAt: new Date(row.createdAt),
       }
@@ -263,14 +287,17 @@ export class MongoDBAIStorageService
     return messages
   }
 
-  async saveMessages(threadId: string, messages: AIMessage[]): Promise<void> {
+  async saveMessages(
+    threadId: string,
+    messages: AgentMessage[]
+  ): Promise<void> {
     if (messages.length === 0) return
 
     const toolMessages = messages.filter((m) => m.role === 'tool')
     const nonToolMessages = messages.filter((m) => m.role !== 'tool')
 
     if (nonToolMessages.length > 0) {
-      await this.aiMessages.insertMany(
+      await this.agentMessages.insertMany(
         nonToolMessages.map((msg) => ({
           _id: msg.id,
           threadId,
@@ -353,7 +380,7 @@ export class MongoDBAIStorageService
   async createRun(run: CreateRunInput): Promise<string> {
     const runId = crypto.randomUUID()
 
-    await this.aiRuns.insertOne({
+    await this.agentRuns.insertOne({
       _id: runId,
       agentName: run.agentName,
       threadId: run.threadId,
@@ -400,7 +427,7 @@ export class MongoDBAIStorageService
       setValues.usageModel = updates.usage.model
     }
 
-    await this.aiRuns.updateOne({ _id: runId }, { $set: setValues })
+    await this.agentRuns.updateOne({ _id: runId }, { $set: setValues })
 
     if (updates.pendingApprovals !== undefined) {
       await this.toolCalls.updateMany(
@@ -424,7 +451,7 @@ export class MongoDBAIStorageService
   }
 
   async getRun(runId: string): Promise<AgentRunState | null> {
-    const row = await this.aiRuns.findOne({ _id: runId })
+    const row = await this.agentRuns.findOne({ _id: runId })
     if (!row) return null
 
     const approvals = await this.toolCalls
@@ -435,7 +462,7 @@ export class MongoDBAIStorageService
   }
 
   async getRunsByThread(threadId: string): Promise<AgentRunState[]> {
-    const result = await this.aiRuns
+    const result = await this.agentRuns
       .find({ threadId })
       .sort({ createdAt: -1 })
       .toArray()
@@ -574,5 +601,32 @@ export class MongoDBAIStorageService
     return result.modifiedCount > 0
   }
 
+  async saveScore(score: SaveScoreInput): Promise<void> {
+    await this.agentRunScores.insertOne({
+      _id: crypto.randomUUID(),
+      runId: score.runId,
+      scorerName: score.scorerName,
+      score: score.score,
+      reason: score.reason ?? null,
+      metadata: score.metadata ?? null,
+      createdAt: new Date(),
+    })
+  }
+
+  async getScores(runId: string): Promise<AgentRunScore[]> {
+    const rows = await this.agentRunScores
+      .find({ runId })
+      .sort({ createdAt: 1 })
+      .toArray()
+    return rows.map((row) => ({
+      runId: row.runId,
+      scorerName: row.scorerName,
+      score: row.score,
+      reason: row.reason ?? undefined,
+      metadata: row.metadata ?? undefined,
+      createdAt: row.createdAt,
+    }))
+  }
+
   public async close(): Promise<void> {}
 }

package/src/mongodb-deployment-service.ts

@@ -1,11 +1,11 @@
-import { buildRemoteHeaders } from '@pikku/core/remote'
+import { buildRemoteHeaders } from '@pikku/core/ecosystem/remote'
 import type {
   DeploymentService,
   DeploymentServiceConfig,
   DeploymentConfig,
-} from '@pikku/core/services'
+} from '@pikku/core/ecosystem/services'
 import type { JWTService, SecretService } from '@pikku/core/services'
-import { getAllFunctionNames } from '@pikku/core/function'
+import { getAllFunctionNames } from '@pikku/core/ecosystem/function'
 import type { Db, Collection } from 'mongodb'
 
 interface DeploymentDoc {

package/src/mongodb-eventhub-store.ts

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/channel'
+import { EventHubStore } from '@pikku/core/ecosystem/channel'
 import type { Db, Collection } from 'mongodb'
 
 interface ChannelSubscriptionDoc {

package/src/mongodb-services.test.ts

@@ -2,14 +2,14 @@ import { describe, test, before, after } from 'node:test'
 import assert from 'node:assert/strict'
 import { MongoClient, type Db } from 'mongodb'
 import { MongoMemoryServer } from 'mongodb-memory-server'
-import { defineServiceTests } from '@pikku/core/testing'
+import { defineServiceTests } from '@pikku/core/ecosystem/testing'
 
 import { MongoDBChannelStore } from './mongodb-channel-store.js'
 import { MongoDBEventHubStore } from './mongodb-eventhub-store.js'
 import { MongoDBWorkflowService } from './mongodb-workflow-service.js'
 import { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'
 import { MongoDBDeploymentService } from './mongodb-deployment-service.js'
-import { MongoDBAIStorageService } from './mongodb-ai-storage-service.js'
+import { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js'
 import { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
 import { MongoDBSecretService } from './mongodb-secret-service.js'
 import { MongoDBSessionStore } from './mongodb-session-store.js'
@@ -42,8 +42,8 @@ function registerTests(name: string, getDb: () => Db) {
         await s.init()
         return s
       },
-      aiStorageService: async () => {
-        const s = new MongoDBAIStorageService(getDb())
+      agentStorageService: async () => {
+        const s = new MongoDBAgentStorageService(getDb())
         await s.init()
         return s
       },

package/src/mongodb-workflow-run-service.ts

@@ -4,7 +4,7 @@ import type {
   StepState,
   WorkflowStatus,
   WorkflowRunService,
-} from '@pikku/core/workflow'
+} from '@pikku/core/ecosystem/workflow'
 import type { Db, Collection } from 'mongodb'
 
 interface WorkflowRunDoc {

package/src/mongodb-workflow-service.ts

@@ -1,15 +1,6 @@
-import type { SerializedError } from '@pikku/core'
-import {
-  PikkuWorkflowService,
-  type WorkflowPlannedStep,
-  type WorkflowQueueOptions,
-  type WorkflowRun,
-  type WorkflowRunWire,
-  type StepState,
-  type StepStatus,
-  type WorkflowStatus,
-  type WorkflowVersionStatus,
-} from '@pikku/core/workflow'
+import type { SerializedError } from '@pikku/core/ecosystem/types'
+import { PikkuWorkflowService } from '@pikku/core/workflow'
+import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/ecosystem/workflow'
 import type { Db, Collection } from 'mongodb'
 import { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'