@pikku/mongodb 0.12.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @pikku/mongodb
+
+## 0.12.1
+
+### Patch Changes
+
+- 97bab28: Initial release of @pikku/mongodb — MongoDB-backed service implementations for Pikku, including SecretService, ChannelStore, EventHubStore, DeploymentService, WorkflowService, WorkflowRunService, AIStorageService, AIRunStateService, and AgentRunService.
+- c7ff141: Add WorkflowVersionStatus type with draft→active lifecycle for AI-generated workflows, type all DB status fields with proper unions instead of plain strings
+- Updated dependencies [387b2ee]
+- Updated dependencies [32ed003]
+- Updated dependencies [7d369f3]
+- Updated dependencies [508a796]
+- Updated dependencies [ffe83af]
+- Updated dependencies [c7ff141]
+  - @pikku/core@0.12.3

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+export { PikkuMongoDB } from './pikku-mongodb.js';
+export { MongoDBChannelStore } from './mongodb-channel-store.js';
+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 { 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';

package/dist/src/index.js

@@ -0,0 +1,9 @@
+export { PikkuMongoDB } from './pikku-mongodb.js';
+export { MongoDBChannelStore } from './mongodb-channel-store.js';
+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 { MongoDBAgentRunService } from './mongodb-agent-run-service.js';
+export { MongoDBSecretService } from './mongodb-secret-service.js';

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

@@ -0,0 +1,21 @@
+import type { AIThread, AIMessage, AgentRunRow, AgentRunService } from '@pikku/core/ai-agent';
+import type { Db } from 'mongodb';
+export declare class MongoDBAgentRunService implements AgentRunService {
+    private threads;
+    private messages;
+    private toolCalls;
+    private runs;
+    constructor(db: Db);
+    listThreads(options?: {
+        agentName?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<AIThread[]>;
+    getThread(threadId: string): Promise<AIThread | null>;
+    getThreadMessages(threadId: string): Promise<AIMessage[]>;
+    getThreadRuns(threadId: string): Promise<AgentRunRow[]>;
+    deleteThread(threadId: string): Promise<boolean>;
+    getDistinctAgentNames(): Promise<string[]>;
+    private mapThreadRow;
+    private mapRunRow;
+}

package/dist/src/mongodb-agent-run-service.js

@@ -0,0 +1,127 @@
+export class MongoDBAgentRunService {
+    threads;
+    messages;
+    toolCalls;
+    runs;
+    constructor(db) {
+        this.threads = db.collection('ai_threads');
+        this.messages = db.collection('ai_message');
+        this.toolCalls = db.collection('ai_tool_call');
+        this.runs = db.collection('ai_run');
+    }
+    async listThreads(options) {
+        const { agentName, limit = 50, offset = 0 } = options ?? {};
+        let filter = {};
+        if (agentName) {
+            const threadIds = await this.runs.distinct('threadId', {
+                agentName,
+            });
+            filter._id = { $in: threadIds };
+        }
+        const result = await this.threads
+            .find(filter)
+            .sort({ updatedAt: -1 })
+            .skip(offset)
+            .limit(limit)
+            .toArray();
+        return result.map((row) => this.mapThreadRow(row));
+    }
+    async getThread(threadId) {
+        const row = await this.threads.findOne({ _id: threadId });
+        if (!row)
+            return null;
+        return this.mapThreadRow(row);
+    }
+    async getThreadMessages(threadId) {
+        const [msgResult, tcResult] = await Promise.all([
+            this.messages.find({ threadId }).sort({ createdAt: 1 }).toArray(),
+            this.toolCalls.find({ threadId }).sort({ createdAt: 1 }).toArray(),
+        ]);
+        const tcByMessage = new Map();
+        for (const tc of tcResult) {
+            const msgId = tc.messageId;
+            if (!tcByMessage.has(msgId))
+                tcByMessage.set(msgId, []);
+            tcByMessage.get(msgId).push(tc);
+        }
+        const messages = [];
+        for (const row of msgResult) {
+            const msg = {
+                id: row._id,
+                role: row.role,
+                content: row.content ?? undefined,
+                createdAt: new Date(row.createdAt),
+            };
+            const tcs = tcByMessage.get(msg.id);
+            if (tcs?.length) {
+                msg.toolCalls = tcs.map((tc) => ({
+                    id: tc._id,
+                    name: tc.toolName,
+                    args: tc.args,
+                }));
+                const completed = tcs.filter((tc) => tc.result != null);
+                if (completed.length) {
+                    messages.push(msg);
+                    messages.push({
+                        id: `tool-results-${msg.id}`,
+                        role: 'tool',
+                        toolResults: completed.map((tc) => ({
+                            id: tc._id,
+                            name: tc.toolName,
+                            result: tc.result,
+                        })),
+                        createdAt: msg.createdAt,
+                    });
+                    continue;
+                }
+            }
+            messages.push(msg);
+        }
+        return messages;
+    }
+    async getThreadRuns(threadId) {
+        const result = await this.runs
+            .find({ threadId })
+            .sort({ createdAt: -1 })
+            .toArray();
+        return result.map((row) => this.mapRunRow(row));
+    }
+    async deleteThread(threadId) {
+        await this.toolCalls.deleteMany({ threadId });
+        await this.messages.deleteMany({ threadId });
+        await this.runs.deleteMany({ threadId });
+        const result = await this.threads.deleteOne({ _id: threadId });
+        return result.deletedCount > 0;
+    }
+    async getDistinctAgentNames() {
+        const result = await this.runs.distinct('agentName');
+        return result.sort();
+    }
+    mapThreadRow(row) {
+        return {
+            id: row._id,
+            resourceId: row.resourceId,
+            title: row.title ?? undefined,
+            metadata: row.metadata ?? undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+    mapRunRow(row) {
+        return {
+            runId: row._id,
+            agentName: row.agentName,
+            threadId: row.threadId,
+            resourceId: row.resourceId,
+            status: row.status,
+            errorMessage: row.errorMessage ?? undefined,
+            suspendReason: row.suspendReason ?? undefined,
+            missingRpcs: row.missingRpcs ?? undefined,
+            usageInputTokens: Number(row.usageInputTokens),
+            usageOutputTokens: Number(row.usageOutputTokens),
+            usageModel: row.usageModel,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+}

package/dist/src/mongodb-ai-storage-service.d.ts

@@ -0,0 +1,41 @@
+import type { AIStorageService, AIRunStateService, CreateRunInput } from '@pikku/core/services';
+import type { AIThread, AIMessage, AgentRunState } from '@pikku/core/ai-agent';
+import type { Db } from 'mongodb';
+export declare class MongoDBAIStorageService implements AIStorageService, AIRunStateService {
+    private db;
+    private initialized;
+    private threads;
+    private aiMessages;
+    private toolCalls;
+    private workingMemory;
+    private aiRuns;
+    constructor(db: Db);
+    init(): Promise<void>;
+    createThread(resourceId: string, options?: {
+        threadId?: string;
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AIThread>;
+    getThread(threadId: string): Promise<AIThread>;
+    getThreads(resourceId: string): Promise<AIThread[]>;
+    deleteThread(threadId: string): Promise<void>;
+    getMessages(threadId: string, options?: {
+        lastN?: number;
+        cursor?: string;
+    }): Promise<AIMessage[]>;
+    saveMessages(threadId: string, messages: AIMessage[]): Promise<void>;
+    getWorkingMemory(id: string, scope: 'resource' | 'thread'): Promise<Record<string, unknown> | null>;
+    saveWorkingMemory(id: string, scope: 'resource' | 'thread', data: Record<string, unknown>): Promise<void>;
+    createRun(run: CreateRunInput): Promise<string>;
+    updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>;
+    getRun(runId: string): Promise<AgentRunState | null>;
+    getRunsByThread(threadId: string): Promise<AgentRunState[]>;
+    private setApprovals;
+    private mapRunRow;
+    findRunByToolCallId(toolCallId: string): Promise<{
+        run: AgentRunState;
+        approval: NonNullable<AgentRunState['pendingApprovals']>[number];
+    } | null>;
+    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,408 @@
+export class MongoDBAIStorageService {
+    db;
+    initialized = false;
+    threads;
+    aiMessages;
+    toolCalls;
+    workingMemory;
+    aiRuns;
+    constructor(db) {
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.threads = this.db.collection('ai_threads');
+        this.aiMessages = this.db.collection('ai_message');
+        this.toolCalls = this.db.collection('ai_tool_call');
+        this.workingMemory =
+            this.db.collection('ai_working_memory');
+        this.aiRuns = this.db.collection('ai_run');
+        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 });
+        this.initialized = true;
+    }
+    async createThread(resourceId, options) {
+        const id = options?.threadId ?? crypto.randomUUID();
+        const now = new Date();
+        await this.threads.insertOne({
+            _id: id,
+            resourceId,
+            title: options?.title ?? null,
+            metadata: options?.metadata ?? null,
+            createdAt: now,
+            updatedAt: now,
+        });
+        return {
+            id,
+            resourceId,
+            title: options?.title,
+            metadata: options?.metadata,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    async getThread(threadId) {
+        const row = await this.threads.findOne({ _id: threadId });
+        if (!row) {
+            throw new Error(`Thread not found: ${threadId}`);
+        }
+        return {
+            id: row._id,
+            resourceId: row.resourceId,
+            title: row.title ?? undefined,
+            metadata: row.metadata ?? undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+    async getThreads(resourceId) {
+        const result = await this.threads
+            .find({ resourceId })
+            .sort({ updatedAt: -1 })
+            .toArray();
+        return result.map((row) => ({
+            id: row._id,
+            resourceId: row.resourceId,
+            title: row.title ?? undefined,
+            metadata: row.metadata ?? undefined,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        }));
+    }
+    async deleteThread(threadId) {
+        await this.toolCalls.deleteMany({ threadId });
+        await this.aiMessages.deleteMany({ threadId });
+        await this.aiRuns.deleteMany({ threadId });
+        await this.threads.deleteOne({ _id: threadId });
+    }
+    async getMessages(threadId, options) {
+        let filter = { threadId };
+        if (options?.cursor) {
+            const cursorRow = await this.aiMessages.findOne({ _id: options.cursor });
+            if (cursorRow) {
+                filter.createdAt = { $lt: cursorRow.createdAt };
+            }
+        }
+        let msgResult;
+        if (options?.cursor || options?.lastN) {
+            const innerResult = await this.aiMessages
+                .find(filter)
+                .sort({ createdAt: -1 })
+                .limit(options?.lastN ?? 50)
+                .toArray();
+            innerResult.reverse();
+            msgResult = innerResult;
+        }
+        else {
+            msgResult = await this.aiMessages
+                .find(filter)
+                .sort({ createdAt: 1 })
+                .toArray();
+        }
+        const tcResult = await this.toolCalls
+            .find({ threadId })
+            .sort({ createdAt: 1 })
+            .toArray();
+        const tcByMessage = new Map();
+        for (const tc of tcResult) {
+            const msgId = tc.messageId;
+            if (!tcByMessage.has(msgId))
+                tcByMessage.set(msgId, []);
+            tcByMessage.get(msgId).push(tc);
+        }
+        const messages = [];
+        for (const row of msgResult) {
+            let parsedContent = row.content ?? undefined;
+            if (typeof row.content === 'string') {
+                try {
+                    const parsed = JSON.parse(row.content);
+                    if (Array.isArray(parsed)) {
+                        parsedContent = parsed;
+                    }
+                    else if (typeof parsed === 'string') {
+                        parsedContent = parsed;
+                    }
+                }
+                catch {
+                    // Not JSON, use raw string
+                }
+            }
+            const msg = {
+                id: row._id,
+                role: row.role,
+                content: parsedContent,
+                createdAt: new Date(row.createdAt),
+            };
+            const tcs = tcByMessage.get(msg.id);
+            if (tcs?.length) {
+                msg.toolCalls = tcs.map((tc) => ({
+                    id: tc._id,
+                    name: tc.toolName,
+                    args: tc.args,
+                }));
+                const completed = tcs.filter((tc) => tc.result != null);
+                if (completed.length) {
+                    messages.push(msg);
+                    messages.push({
+                        id: `tool-results-${msg.id}`,
+                        role: 'tool',
+                        toolResults: completed.map((tc) => ({
+                            id: tc._id,
+                            name: tc.toolName,
+                            result: tc.result,
+                        })),
+                        createdAt: msg.createdAt,
+                    });
+                    continue;
+                }
+            }
+            messages.push(msg);
+        }
+        return messages;
+    }
+    async saveMessages(threadId, messages) {
+        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(nonToolMessages.map((msg) => ({
+                _id: msg.id,
+                threadId,
+                role: msg.role,
+                content: msg.content != null ? JSON.stringify(msg.content) : null,
+                createdAt: msg.createdAt ?? new Date(),
+            })));
+        }
+        const toolCallDocs = nonToolMessages.flatMap((msg) => msg.toolCalls?.map((tc) => ({ ...tc, messageId: msg.id })) ?? []);
+        if (toolCallDocs.length > 0) {
+            await this.toolCalls.insertMany(toolCallDocs.map((tc) => ({
+                _id: tc.id,
+                threadId,
+                messageId: tc.messageId,
+                runId: null,
+                toolName: tc.name,
+                args: tc.args,
+                result: null,
+                approvalStatus: null,
+                approvalType: null,
+                agentRunId: null,
+                displayToolName: null,
+                displayArgs: null,
+                createdAt: new Date(),
+            })));
+        }
+        for (const toolMsg of toolMessages) {
+            if (!toolMsg.toolResults)
+                continue;
+            for (const tr of toolMsg.toolResults) {
+                await this.toolCalls.updateOne({ _id: tr.id }, { $set: { result: tr.result } });
+            }
+        }
+        await this.threads.updateOne({ _id: threadId }, { $set: { updatedAt: new Date() } });
+    }
+    async getWorkingMemory(id, scope) {
+        const row = await this.workingMemory.findOne({ id, scope });
+        if (!row)
+            return null;
+        return row.data;
+    }
+    async saveWorkingMemory(id, scope, data) {
+        await this.workingMemory.updateOne({ id, scope }, {
+            $set: {
+                data,
+                updatedAt: new Date(),
+            },
+            $setOnInsert: {
+                id,
+                scope,
+            },
+        }, { upsert: true });
+    }
+    async createRun(run) {
+        const runId = crypto.randomUUID();
+        await this.aiRuns.insertOne({
+            _id: runId,
+            agentName: run.agentName,
+            threadId: run.threadId,
+            resourceId: run.resourceId,
+            status: run.status,
+            errorMessage: run.errorMessage ?? null,
+            suspendReason: run.suspendReason ?? null,
+            missingRpcs: run.missingRpcs ?? null,
+            usageInputTokens: run.usage.inputTokens,
+            usageOutputTokens: run.usage.outputTokens,
+            usageModel: run.usage.model,
+            createdAt: run.createdAt,
+            updatedAt: run.updatedAt,
+        });
+        if (run.pendingApprovals?.length) {
+            await this.setApprovals(runId, run.pendingApprovals);
+        }
+        return runId;
+    }
+    async updateRun(runId, updates) {
+        const setValues = { updatedAt: new Date() };
+        if (updates.status !== undefined) {
+            setValues.status = updates.status;
+        }
+        if (updates.errorMessage !== undefined) {
+            setValues.errorMessage = updates.errorMessage;
+        }
+        if (updates.suspendReason !== undefined) {
+            setValues.suspendReason = updates.suspendReason;
+        }
+        if (updates.missingRpcs !== undefined) {
+            setValues.missingRpcs = updates.missingRpcs;
+        }
+        if (updates.usage !== undefined) {
+            setValues.usageInputTokens = updates.usage.inputTokens;
+            setValues.usageOutputTokens = updates.usage.outputTokens;
+            setValues.usageModel = updates.usage.model;
+        }
+        await this.aiRuns.updateOne({ _id: runId }, { $set: setValues });
+        if (updates.pendingApprovals !== undefined) {
+            await this.toolCalls.updateMany({ runId, approvalStatus: { $ne: null } }, {
+                $set: {
+                    approvalStatus: null,
+                    runId: null,
+                    approvalType: null,
+                    agentRunId: null,
+                    displayToolName: null,
+                    displayArgs: null,
+                },
+            });
+            if (updates.pendingApprovals.length) {
+                await this.setApprovals(runId, updates.pendingApprovals);
+            }
+        }
+    }
+    async getRun(runId) {
+        const row = await this.aiRuns.findOne({ _id: runId });
+        if (!row)
+            return null;
+        const approvals = await this.toolCalls
+            .find({ runId, approvalStatus: 'pending' })
+            .toArray();
+        return this.mapRunRow(row, approvals);
+    }
+    async getRunsByThread(threadId) {
+        const result = await this.aiRuns
+            .find({ threadId })
+            .sort({ createdAt: -1 })
+            .toArray();
+        const runs = [];
+        for (const row of result) {
+            const approvals = await this.toolCalls
+                .find({ runId: row._id, approvalStatus: 'pending' })
+                .toArray();
+            runs.push(this.mapRunRow(row, approvals));
+        }
+        return runs;
+    }
+    async setApprovals(runId, approvals) {
+        for (const a of approvals) {
+            if (a.type === 'agent-call') {
+                await this.toolCalls.updateOne({ _id: a.toolCallId }, {
+                    $set: {
+                        approvalStatus: 'pending',
+                        runId,
+                        approvalType: 'agent-call',
+                        agentRunId: a.agentRunId,
+                        displayToolName: a.displayToolName,
+                        displayArgs: a.displayArgs,
+                    },
+                });
+            }
+            else {
+                await this.toolCalls.updateOne({ _id: a.toolCallId }, {
+                    $set: {
+                        approvalStatus: 'pending',
+                        runId,
+                        approvalType: 'tool-call',
+                    },
+                });
+            }
+        }
+    }
+    mapRunRow(row, approvalRows) {
+        const pendingApprovals = approvalRows?.length
+            ? approvalRows.map((a) => {
+                if (a.approvalType === 'agent-call') {
+                    return {
+                        type: 'agent-call',
+                        toolCallId: a._id,
+                        agentName: a.toolName,
+                        agentRunId: a.agentRunId,
+                        displayToolName: a.displayToolName,
+                        displayArgs: a.displayArgs,
+                    };
+                }
+                return {
+                    type: 'tool-call',
+                    toolCallId: a._id,
+                    toolName: a.toolName,
+                    args: a.args,
+                };
+            })
+            : undefined;
+        return {
+            runId: row._id,
+            agentName: row.agentName,
+            threadId: row.threadId,
+            resourceId: row.resourceId,
+            status: row.status,
+            errorMessage: row.errorMessage ?? undefined,
+            suspendReason: row.suspendReason,
+            missingRpcs: row.missingRpcs ?? undefined,
+            pendingApprovals,
+            usage: {
+                inputTokens: Number(row.usageInputTokens),
+                outputTokens: Number(row.usageOutputTokens),
+                model: row.usageModel,
+            },
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+    async findRunByToolCallId(toolCallId) {
+        const tc = await this.toolCalls.findOne({
+            _id: toolCallId,
+            approvalStatus: 'pending',
+        });
+        if (!tc || !tc.runId)
+            return null;
+        const run = await this.getRun(tc.runId);
+        if (!run)
+            return null;
+        let approval;
+        if (tc.approvalType === 'agent-call') {
+            approval = {
+                type: 'agent-call',
+                toolCallId: tc._id,
+                agentName: tc.toolName,
+                agentRunId: tc.agentRunId,
+                displayToolName: tc.displayToolName,
+                displayArgs: tc.displayArgs,
+            };
+        }
+        else {
+            approval = {
+                type: 'tool-call',
+                toolCallId: tc._id,
+                toolName: tc.toolName,
+                args: tc.args,
+            };
+        }
+        return { run, approval };
+    }
+    async resolveApproval(toolCallId, status) {
+        await this.toolCalls.updateOne({ _id: toolCallId }, { $set: { approvalStatus: status } });
+    }
+    async close() { }
+}

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

@@ -0,0 +1,19 @@
+import type { CoreUserSession } from '@pikku/core';
+import type { Channel } from '@pikku/core/channel';
+import { ChannelStore } from '@pikku/core/channel';
+import type { Db } from 'mongodb';
+export declare class MongoDBChannelStore extends ChannelStore {
+    private db;
+    private initialized;
+    private channels;
+    private subscriptions;
+    constructor(db: Db);
+    init(): Promise<void>;
+    addChannel({ channelId, channelName, openingData, }: Channel): Promise<void>;
+    removeChannels(channelIds: string[]): Promise<void>;
+    setUserSession(channelId: string, session: CoreUserSession | null): Promise<void>;
+    getChannelAndSession(channelId: string): Promise<Channel & {
+        session: CoreUserSession;
+    }>;
+    close(): Promise<void>;
+}