@pikku/kysely 0.13.13 → 0.13.16

package/dist/src/kysely-agent-storage-service.d.ts

@@ -0,0 +1,40 @@
+import type { AgentStorageService, AgentRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
+import type { AgentThread, AgentMessage, AgentRunState } from '@pikku/core/agent';
+import type { AgentRunScore } from '@pikku/core/agent-scorer';
+import type { Kysely } from 'kysely';
+import type { KyselyPikkuDB } from './kysely-tables.js';
+export declare class KyselyAgentStorageService implements AgentStorageService, AgentRunStateService {
+    private db;
+    private initialized;
+    constructor(db: Kysely<KyselyPikkuDB>);
+    init(): Promise<void>;
+    createThread(resourceId: string, options?: {
+        threadId?: string;
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AgentThread>;
+    getThread(threadId: string): Promise<AgentThread>;
+    getThreads(resourceId: string): Promise<AgentThread[]>;
+    deleteThread(threadId: string): Promise<void>;
+    getMessages(threadId: string, options?: {
+        lastN?: number;
+        cursor?: string;
+    }): Promise<AgentMessage[]>;
+    saveMessages(threadId: string, messages: AgentMessage[]): 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<boolean>;
+    saveScore(score: SaveScoreInput): Promise<void>;
+    getScores(runId: string): Promise<AgentRunScore[]>;
+    close(): Promise<void>;
+}

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-scores.d.ts

@@ -0,0 +1,10 @@
+import type { Kysely } from 'kysely';
+import type { KyselyPikkuDB } from './kysely-tables.js';
+import type { SaveScoreInput } from '@pikku/core/services';
+import type { AIRunScore } from '@pikku/core/ai-scorer';
+/**
+ * Shared by the two Kysely services that implement `AIRunStateService` — they
+ * differ in how they store approvals, not in how they store grades.
+ */
+export declare const saveRunScore: (db: Kysely<KyselyPikkuDB>, score: SaveScoreInput) => Promise<void>;
+export declare const getRunScores: (db: Kysely<KyselyPikkuDB>, runId: string) => Promise<AIRunScore[]>;

package/dist/src/kysely-ai-run-scores.js

@@ -0,0 +1,34 @@
+import { parseJson } from './kysely-json.js';
+/**
+ * Shared by the two Kysely services that implement `AIRunStateService` — they
+ * differ in how they store approvals, not in how they store grades.
+ */
+export const saveRunScore = async (db, score) => {
+    await db
+        .insertInto('aiRunScore')
+        .values({
+        id: crypto.randomUUID(),
+        runId: score.runId,
+        scorerName: score.scorerName,
+        score: score.score,
+        reason: score.reason ?? null,
+        metadata: score.metadata ? JSON.stringify(score.metadata) : null,
+    })
+        .execute();
+};
+export const getRunScores = async (db, runId) => {
+    const rows = await db
+        .selectFrom('aiRunScore')
+        .selectAll()
+        .where('runId', '=', runId)
+        .orderBy('createdAt', 'asc')
+        .execute();
+    return rows.map((row) => ({
+        runId: row.runId,
+        scorerName: row.scorerName,
+        score: Number(row.score),
+        reason: row.reason ?? undefined,
+        metadata: parseJson(row.metadata),
+        createdAt: new Date(row.createdAt),
+    }));
+};

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

@@ -1,7 +1,9 @@
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
-import type { AIRunStateService, CreateRunInput } from '@pikku/core/services';
-import type { AgentRunState, PendingApproval } from '@pikku/core/ai-agent';
+import type { AIRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
+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;
     private initialized;
@@ -16,5 +18,7 @@ export declare class KyselyAIRunStateService implements AIRunStateService {
         run: AgentRunState;
         approval: PendingApproval;
     } | null>;
+    saveScore(score: SaveScoreInput): Promise<void>;
+    getScores(runId: string): Promise<AIRunScore[]>;
     private toRunState;
 }

package/dist/src/kysely-ai-run-state-service.js

@@ -1,6 +1,7 @@
 import { sql } from 'kysely';
 import { ensurePikkuSchema } from './schema/index.js';
 import { aiSchema } from './schema/ai.schema.js';
+import { getRunScores, saveRunScore } from './kysely-ai-run-scores.js';
 export class KyselyAIRunStateService {
     db;
     initialized = false;
@@ -137,6 +138,12 @@ export class KyselyAIRunStateService {
         }
         return null;
     }
+    async saveScore(score) {
+        await saveRunScore(this.db, score);
+    }
+    async getScores(runId) {
+        return getRunScores(this.db, runId);
+    }
     toRunState(row) {
         return {
             runId: row.runId,

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

@@ -1,5 +1,6 @@
-import type { AIStorageService, AIRunStateService, CreateRunInput } from '@pikku/core/services';
+import type { AIStorageService, AIRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
 import type { AIThread, AIMessage, AgentRunState } from '@pikku/core/ai-agent';
+import type { AIRunScore } from '@pikku/core/ai-scorer';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyAIStorageService implements AIStorageService, AIRunStateService {
@@ -33,5 +34,7 @@ export declare class KyselyAIStorageService implements AIStorageService, AIRunSt
         approval: NonNullable<AgentRunState['pendingApprovals']>[number];
     } | null>;
     resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<boolean>;
+    saveScore(score: SaveScoreInput): Promise<void>;
+    getScores(runId: string): Promise<AIRunScore[]>;
     close(): Promise<void>;
 }