@pikku/kysely 0.13.15 → 0.13.16

package/dist/src/kysely-agent-storage-service.js

@@ -0,0 +1,533 @@
+import { parseJson } from './kysely-json.js';
+import { getRunScores, saveRunScore } from './kysely-agent-run-scores.js';
+import { ensurePikkuSchema } from './schema/index.js';
+import { agentSchema } from './schema/agent.schema.js';
+export class KyselyAgentStorageService {
+    db;
+    initialized = false;
+    constructor(db) {
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        await ensurePikkuSchema(this.db, agentSchema);
+        this.initialized = true;
+    }
+    async createThread(resourceId, options) {
+        const id = options?.threadId ?? crypto.randomUUID();
+        const now = new Date();
+        await this.db
+            .insertInto('agentThreads')
+            .values({
+            id,
+            resourceId: resourceId,
+            title: options?.title ?? null,
+            metadata: JSON.stringify(options?.metadata ?? null),
+            createdAt: now,
+            updatedAt: now,
+        })
+            .execute();
+        return {
+            id,
+            resourceId,
+            title: options?.title,
+            metadata: options?.metadata,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    async getThread(threadId) {
+        const row = await this.db
+            .selectFrom('agentThreads')
+            .select([
+            'id',
+            'resourceId',
+            'title',
+            'metadata',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('id', '=', threadId)
+            .executeTakeFirst();
+        if (!row) {
+            throw new Error(`Thread not found: ${threadId}`);
+        }
+        return {
+            id: row.id,
+            resourceId: row.resourceId,
+            title: row.title ?? undefined,
+            metadata: parseJson(row.metadata),
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+    async getThreads(resourceId) {
+        const result = await this.db
+            .selectFrom('agentThreads')
+            .select([
+            'id',
+            'resourceId',
+            'title',
+            'metadata',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('resourceId', '=', resourceId)
+            .orderBy('updatedAt', 'desc')
+            .execute();
+        return result.map((row) => ({
+            id: row.id,
+            resourceId: row.resourceId,
+            title: row.title ?? undefined,
+            metadata: parseJson(row.metadata),
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        }));
+    }
+    async deleteThread(threadId) {
+        await this.db
+            .deleteFrom('agentThreads')
+            .where('id', '=', threadId)
+            .execute();
+    }
+    async getMessages(threadId, options) {
+        let msgQuery = this.db
+            .selectFrom('agentMessage')
+            .select(['id', 'role', 'content', 'createdAt'])
+            .where('threadId', '=', threadId);
+        if (options?.cursor) {
+            const cursorRow = await this.db
+                .selectFrom('agentMessage')
+                .select('createdAt')
+                .where('id', '=', options.cursor)
+                .executeTakeFirst();
+            if (cursorRow) {
+                msgQuery = msgQuery.where('createdAt', '<', cursorRow.createdAt);
+            }
+        }
+        let msgResult;
+        if (options?.cursor || options?.lastN) {
+            const innerResult = await msgQuery
+                .orderBy('createdAt', 'desc')
+                .limit(options?.lastN ?? 50)
+                .execute();
+            innerResult.reverse();
+            msgResult = innerResult;
+        }
+        else {
+            msgResult = await msgQuery.orderBy('createdAt', 'asc').execute();
+        }
+        const tcResult = await this.db
+            .selectFrom('agentToolCall')
+            .select(['id', 'messageId', 'toolName', 'args', 'result'])
+            .where('threadId', '=', threadId)
+            .orderBy('createdAt', 'asc')
+            .execute();
+        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 rawContent = row.content;
+            let parsedContent = rawContent ?? undefined;
+            if (rawContent) {
+                try {
+                    const parsed = JSON.parse(rawContent);
+                    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: parseJson(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.db
+                .insertInto('agentMessage')
+                .values(nonToolMessages.map((msg) => ({
+                id: msg.id,
+                threadId: threadId,
+                role: msg.role,
+                content: msg.content != null ? JSON.stringify(msg.content) : null,
+                createdAt: msg.createdAt ?? new Date(),
+            })))
+                .execute();
+        }
+        const toolCalls = nonToolMessages.flatMap((msg) => msg.toolCalls?.map((tc) => ({ ...tc, messageId: msg.id })) ?? []);
+        if (toolCalls.length > 0) {
+            await this.db
+                .insertInto('agentToolCall')
+                .values(toolCalls.map((tc) => ({
+                id: tc.id,
+                threadId: threadId,
+                messageId: tc.messageId,
+                toolName: tc.name,
+                args: JSON.stringify(tc.args),
+            })))
+                .execute();
+        }
+        for (const toolMsg of toolMessages) {
+            if (!toolMsg.toolResults)
+                continue;
+            for (const tr of toolMsg.toolResults) {
+                await this.db
+                    .updateTable('agentToolCall')
+                    .set({ result: tr.result })
+                    .where('id', '=', tr.id)
+                    .execute();
+            }
+        }
+        await this.db
+            .updateTable('agentThreads')
+            .set({ updatedAt: new Date() })
+            .where('id', '=', threadId)
+            .execute();
+    }
+    async getWorkingMemory(id, scope) {
+        const row = await this.db
+            .selectFrom('agentWorkingMemory')
+            .select('data')
+            .where('id', '=', id)
+            .where('scope', '=', scope)
+            .executeTakeFirst();
+        if (!row)
+            return null;
+        return parseJson(row.data);
+    }
+    async saveWorkingMemory(id, scope, data) {
+        await this.db
+            .insertInto('agentWorkingMemory')
+            .values({
+            id,
+            scope,
+            data: JSON.stringify(data),
+            updatedAt: new Date(),
+        })
+            .onConflict((oc) => oc.columns(['id', 'scope']).doUpdateSet({
+            data: JSON.stringify(data),
+            updatedAt: new Date(),
+        }))
+            .execute();
+    }
+    async createRun(run) {
+        const runId = crypto.randomUUID();
+        await this.db
+            .insertInto('agentRun')
+            .values({
+            runId: runId,
+            agentName: run.agentName,
+            threadId: run.threadId,
+            resourceId: run.resourceId,
+            status: run.status,
+            errorMessage: run.errorMessage ?? null,
+            suspendReason: run.suspendReason ?? null,
+            missingRpcs: run.missingRpcs ? JSON.stringify(run.missingRpcs) : null,
+            usageInputTokens: run.usage.inputTokens,
+            usageOutputTokens: run.usage.outputTokens,
+            usageModel: run.usage.model,
+            createdAt: run.createdAt,
+            updatedAt: run.updatedAt,
+        })
+            .execute();
+        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 = JSON.stringify(updates.missingRpcs);
+        }
+        if (updates.usage !== undefined) {
+            setValues.usageInputTokens = updates.usage.inputTokens;
+            setValues.usageOutputTokens = updates.usage.outputTokens;
+            setValues.usageModel = updates.usage.model;
+        }
+        await this.db
+            .updateTable('agentRun')
+            .set(setValues)
+            .where('runId', '=', runId)
+            .execute();
+        if (updates.pendingApprovals !== undefined) {
+            await this.db
+                .updateTable('agentToolCall')
+                .set({
+                approvalStatus: null,
+                runId: null,
+                approvalType: null,
+                agentRunId: null,
+                displayToolName: null,
+                displayArgs: null,
+            })
+                .where('runId', '=', runId)
+                .where('approvalStatus', 'is not', null)
+                .execute();
+            if (updates.pendingApprovals.length) {
+                await this.setApprovals(runId, updates.pendingApprovals);
+            }
+        }
+    }
+    async getRun(runId) {
+        const row = await this.db
+            .selectFrom('agentRun')
+            .select([
+            'runId',
+            'agentName',
+            'threadId',
+            'resourceId',
+            'status',
+            'errorMessage',
+            'suspendReason',
+            'missingRpcs',
+            'usageInputTokens',
+            'usageOutputTokens',
+            'usageModel',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('runId', '=', runId)
+            .executeTakeFirst();
+        if (!row)
+            return null;
+        const approvals = await this.db
+            .selectFrom('agentToolCall')
+            .select([
+            'id',
+            'toolName',
+            'args',
+            'approvalType',
+            'agentRunId',
+            'displayToolName',
+            'displayArgs',
+        ])
+            .where('runId', '=', runId)
+            .where('approvalStatus', '=', 'pending')
+            .execute();
+        return this.mapRunRow(row, approvals);
+    }
+    async getRunsByThread(threadId) {
+        const result = await this.db
+            .selectFrom('agentRun')
+            .select([
+            'runId',
+            'agentName',
+            'threadId',
+            'resourceId',
+            'status',
+            'errorMessage',
+            'suspendReason',
+            'missingRpcs',
+            'usageInputTokens',
+            'usageOutputTokens',
+            'usageModel',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('threadId', '=', threadId)
+            .orderBy('createdAt', 'desc')
+            .execute();
+        const runs = [];
+        for (const row of result) {
+            const approvals = await this.db
+                .selectFrom('agentToolCall')
+                .select([
+                'id',
+                'toolName',
+                'args',
+                'approvalType',
+                'agentRunId',
+                'displayToolName',
+                'displayArgs',
+            ])
+                .where('runId', '=', row.runId)
+                .where('approvalStatus', '=', 'pending')
+                .execute();
+            runs.push(this.mapRunRow(row, approvals));
+        }
+        return runs;
+    }
+    async setApprovals(runId, approvals) {
+        for (const a of approvals) {
+            if (a.type === 'agent-call') {
+                await this.db
+                    .updateTable('agentToolCall')
+                    .set({
+                    approvalStatus: 'pending',
+                    runId: runId,
+                    approvalType: 'agent-call',
+                    agentRunId: a.agentRunId,
+                    displayToolName: a.displayToolName,
+                    displayArgs: JSON.stringify(a.displayArgs),
+                })
+                    .where('id', '=', a.toolCallId)
+                    .execute();
+            }
+            else {
+                await this.db
+                    .updateTable('agentToolCall')
+                    .set({
+                    approvalStatus: 'pending',
+                    runId: runId,
+                    approvalType: 'tool-call',
+                })
+                    .where('id', '=', a.toolCallId)
+                    .execute();
+            }
+        }
+    }
+    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: parseJson(a.displayArgs),
+                    };
+                }
+                return {
+                    type: 'tool-call',
+                    toolCallId: a.id,
+                    toolName: a.toolName,
+                    args: parseJson(a.args),
+                };
+            })
+            : undefined;
+        return {
+            runId: row.runId,
+            agentName: row.agentName,
+            threadId: row.threadId,
+            resourceId: row.resourceId,
+            status: row.status,
+            errorMessage: row.errorMessage ?? undefined,
+            suspendReason: row.suspendReason,
+            missingRpcs: parseJson(row.missingRpcs),
+            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.db
+            .selectFrom('agentToolCall')
+            .select([
+            'id',
+            'toolName',
+            'args',
+            'runId',
+            'approvalType',
+            'agentRunId',
+            'displayToolName',
+            'displayArgs',
+        ])
+            .where('id', '=', toolCallId)
+            .where('approvalStatus', '=', 'pending')
+            .executeTakeFirst();
+        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: parseJson(tc.displayArgs),
+            };
+        }
+        else {
+            approval = {
+                type: 'tool-call',
+                toolCallId: tc.id,
+                toolName: tc.toolName,
+                args: parseJson(tc.args),
+            };
+        }
+        return { run, approval };
+    }
+    async resolveApproval(toolCallId, status) {
+        // Only the caller that moves the tool call off 'pending' has claimed it.
+        const result = await this.db
+            .updateTable('agentToolCall')
+            .set({ approvalStatus: status })
+            .where('id', '=', toolCallId)
+            .where('approvalStatus', '=', 'pending')
+            .executeTakeFirst();
+        return Number(result?.numUpdatedRows ?? 0) > 0;
+    }
+    async saveScore(score) {
+        await saveRunScore(this.db, score);
+    }
+    async getScores(runId) {
+        return getRunScores(this.db, runId);
+    }
+    async close() { }
+}

package/dist/src/kysely-ai-agent-run-service.d.ts

@@ -1,4 +1,5 @@
-import type { AIThread, AIMessage, AgentRunRow, AgentRunService } from '@pikku/core/ai-agent';
+import type { AIThread, AIMessage } from '@pikku/core/ai-agent';
+import type { AgentRunRow, AgentRunService } from '@pikku/core/ecosystem/ai-agent';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyAgentRunService implements AgentRunService {

package/dist/src/kysely-ai-run-state-service.d.ts

@@ -1,7 +1,8 @@
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 import type { AIRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
-import type { AgentRunState, PendingApproval } from '@pikku/core/ai-agent';
+import type { AgentRunState } from '@pikku/core/ai-agent';
+import type { PendingApproval } from '@pikku/core/ecosystem/ai-agent';
 import type { AIRunScore } from '@pikku/core/ai-scorer';
 export declare class KyselyAIRunStateService implements AIRunStateService {
     private db;

package/dist/src/kysely-audit-service.d.ts

@@ -1,4 +1,6 @@
-import type { AuditEvent, AuditEventBatch, AuditFacets, AuditQuery, AuditQueryResult, AuditService } from '@pikku/core';
+import type { AuditService } from '@pikku/core';
+import type { AuditEvent, AuditEventBatch } from '@pikku/core/ecosystem/services';
+import type { AuditFacets, AuditQuery, AuditQueryResult } from '@pikku/core/ecosystem/types';
 import type { Kysely } from 'kysely';
 /**
  * Durable {@link AuditService} that persists AuditEvents to an `audit` table

package/dist/src/kysely-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 { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';

package/dist/src/kysely-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';
 import { ensurePikkuSchema } from './schema/index.js';
 import { deploymentSchema } from './schema/deployment.schema.js';
 export class KyselyDeploymentService {

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

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/channel';
+import { EventHubStore } from '@pikku/core/ecosystem/channel';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyEventHubStore extends EventHubStore {

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

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

package/dist/src/kysely-scope-service.d.ts

@@ -1,6 +1,7 @@
-import type { Role, ScopeService } from '@pikku/core/services';
-import type { FlatScope } from '@pikku/core/scope';
-import type { SystemRole } from '@pikku/core/role';
+import type { ScopeService } from '@pikku/core/services';
+import type { Role } from '@pikku/core/ecosystem/services';
+import type { FlatScope } from '@pikku/core/ecosystem/scope';
+import type { SystemRole } from '@pikku/core/ecosystem/role';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 /**

package/dist/src/kysely-tables.d.ts

@@ -1,5 +1,5 @@
 import type { Generated } from 'kysely';
-import type { WorkflowStatus, StepStatus, WorkflowVersionStatus } from '@pikku/core/workflow';
+import type { WorkflowStatus, StepStatus, WorkflowVersionStatus } from '@pikku/core/ecosystem/workflow';
 export interface ChannelsTable {
     channelId: string;
     channelName: string;
@@ -75,7 +75,7 @@ export interface WorkflowVersionsTable {
     status: Generated<WorkflowVersionStatus>;
     createdAt: Generated<Date>;
 }
-export interface AIThreadsTable {
+export interface AgentThreadsTable {
     id: string;
     resourceId: string;
     title: string | null;
@@ -83,14 +83,14 @@ export interface AIThreadsTable {
     createdAt: Generated<Date>;
     updatedAt: Generated<Date>;
 }
-export interface AIMessageTable {
+export interface AgentMessageTable {
     id: string;
     threadId: string;
     role: 'system' | 'user' | 'assistant' | 'tool';
     content: string | null;
     createdAt: Generated<Date>;
 }
-export interface AIToolCallTable {
+export interface AgentToolCallTable {
     id: string;
     threadId: string;
     messageId: string;
@@ -105,13 +105,13 @@ export interface AIToolCallTable {
     displayArgs: string | null;
     createdAt: Generated<Date>;
 }
-export interface AIWorkingMemoryTable {
+export interface AgentWorkingMemoryTable {
     id: string;
     scope: string;
     data: string;
     updatedAt: Generated<Date>;
 }
-export interface AIRunTable {
+export interface AgentRunTable {
     runId: Generated<string>;
     agentName: string;
     threadId: string;
@@ -133,7 +133,7 @@ export interface AIRunTable {
     createdAt: Generated<Date>;
     updatedAt: Generated<Date>;
 }
-export interface AIRunScoreTable {
+export interface AgentRunScoreTable {
     id: string;
     runId: string;
     scorerName: string;
@@ -301,12 +301,12 @@ export interface KyselyPikkuDB {
     workflowStep: WorkflowStepTable;
     workflowStepHistory: WorkflowStepHistoryTable;
     workflowVersions: WorkflowVersionsTable;
-    aiThreads: AIThreadsTable;
-    aiMessage: AIMessageTable;
-    aiToolCall: AIToolCallTable;
-    aiWorkingMemory: AIWorkingMemoryTable;
-    aiRun: AIRunTable;
-    aiRunScore: AIRunScoreTable;
+    agentThreads: AgentThreadsTable;
+    agentMessage: AgentMessageTable;
+    agentToolCall: AgentToolCallTable;
+    agentWorkingMemory: AgentWorkingMemoryTable;
+    agentRun: AgentRunTable;
+    agentRunScore: AgentRunScoreTable;
     pikkuDeployments: PikkuDeploymentsTable;
     pikkuDeploymentFunctions: PikkuDeploymentFunctionsTable;
     secrets: SecretsTable;

package/dist/src/kysely-virtual-user-run-store.d.ts

@@ -1,5 +1,5 @@
 import type { Kysely } from 'kysely';
-import type { VirtualUserRunOutcome, VirtualUserRunRecord, VirtualUserRunStart, VirtualUserRunStore } from '@pikku/core/virtual-user';
+import type { VirtualUserRunOutcome, VirtualUserRunRecord, VirtualUserRunStart, VirtualUserRunStore } from '@pikku/core/ecosystem/virtual-user';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 /**
  * Records virtual-user runs in a `virtualUserRun` table.