@pikku/kysely 0.13.16 → 0.13.18

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

@@ -1,530 +0,0 @@
-import { parseJson } from './kysely-json.js';
-import { getRunScores, saveRunScore } from './kysely-ai-run-scores.js';
-import { ensurePikkuSchema } from './schema/index.js';
-import { aiSchema } from './schema/ai.schema.js';
-export class KyselyAIStorageService {
-    db;
-    initialized = false;
-    constructor(db) {
-        this.db = db;
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        await ensurePikkuSchema(this.db, aiSchema);
-        this.initialized = true;
-    }
-    async createThread(resourceId, options) {
-        const id = options?.threadId ?? crypto.randomUUID();
-        const now = new Date();
-        await this.db
-            .insertInto('aiThreads')
-            .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('aiThreads')
-            .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('aiThreads')
-            .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('aiThreads').where('id', '=', threadId).execute();
-    }
-    async getMessages(threadId, options) {
-        let msgQuery = this.db
-            .selectFrom('aiMessage')
-            .select(['id', 'role', 'content', 'createdAt'])
-            .where('threadId', '=', threadId);
-        if (options?.cursor) {
-            const cursorRow = await this.db
-                .selectFrom('aiMessage')
-                .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('aiToolCall')
-            .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('aiMessage')
-                .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('aiToolCall')
-                .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('aiToolCall')
-                    .set({ result: tr.result })
-                    .where('id', '=', tr.id)
-                    .execute();
-            }
-        }
-        await this.db
-            .updateTable('aiThreads')
-            .set({ updatedAt: new Date() })
-            .where('id', '=', threadId)
-            .execute();
-    }
-    async getWorkingMemory(id, scope) {
-        const row = await this.db
-            .selectFrom('aiWorkingMemory')
-            .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('aiWorkingMemory')
-            .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('aiRun')
-            .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('aiRun')
-            .set(setValues)
-            .where('runId', '=', runId)
-            .execute();
-        if (updates.pendingApprovals !== undefined) {
-            await this.db
-                .updateTable('aiToolCall')
-                .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('aiRun')
-            .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('aiToolCall')
-            .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('aiRun')
-            .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('aiToolCall')
-                .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('aiToolCall')
-                    .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('aiToolCall')
-                    .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('aiToolCall')
-            .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('aiToolCall')
-            .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/schema/ai.schema.d.ts

@@ -1,12 +0,0 @@
-import type { PikkuSchema } from './pikku-schema.types.js';
-/**
- * Threads, messages, tool calls, working memory and agent runs.
- *
- * `aiRun` carries `pendingApprovals` even though the two services that used to
- * create this table disagreed about it: `KyselyAIStorageService` omitted the
- * column while `KyselyAIRunStateService` declared it and read it back through
- * casts. Whichever service happened to run first decided the shape, and on a
- * database where the storage service won, resolving an approval failed. One
- * declaration ends that — the column is here because live code reads it.
- */
-export declare const aiSchema: PikkuSchema;

package/dist/src/schema/ai.schema.js

@@ -1,102 +0,0 @@
-import { sql } from 'kysely';
-/**
- * Threads, messages, tool calls, working memory and agent runs.
- *
- * `aiRun` carries `pendingApprovals` even though the two services that used to
- * create this table disagreed about it: `KyselyAIStorageService` omitted the
- * column while `KyselyAIRunStateService` declared it and read it back through
- * casts. Whichever service happened to run first decided the shape, and on a
- * database where the storage service won, resolving an approval failed. One
- * declaration ends that — the column is here because live code reads it.
- */
-export const aiSchema = {
-    name: 'ai',
-    statements: [
-        (db) => db.schema
-            .createTable('aiThreads')
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
-            .addColumn('title', 'text')
-            .addColumn('metadata', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
-            .createIndex('idx_ai_threads_resource')
-            .on('aiThreads')
-            .column('resourceId'),
-        (db) => db.schema
-            .createTable('aiMessage')
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
-            .addColumn('role', 'varchar(50)', (col) => col.notNull())
-            .addColumn('content', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
-            .createIndex('idx_ai_message_thread')
-            .on('aiMessage')
-            .columns(['threadId', 'createdAt']),
-        (db) => db.schema
-            .createTable('aiToolCall')
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
-            .addColumn('messageId', 'varchar(36)', (col) => col.notNull().references('aiMessage.id').onDelete('cascade'))
-            .addColumn('runId', 'varchar(36)')
-            .addColumn('toolName', 'varchar(255)', (col) => col.notNull())
-            .addColumn('args', 'text', (col) => col.notNull())
-            .addColumn('result', 'text')
-            .addColumn('approvalStatus', 'varchar(50)')
-            .addColumn('approvalType', 'varchar(50)')
-            .addColumn('agentRunId', 'varchar(36)')
-            .addColumn('displayToolName', 'varchar(255)')
-            .addColumn('displayArgs', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
-            .createIndex('idx_ai_tool_call_thread')
-            .on('aiToolCall')
-            .column('threadId'),
-        (db) => db.schema
-            .createIndex('idx_ai_tool_call_message')
-            .on('aiToolCall')
-            .column('messageId'),
-        (db) => db.schema
-            .createTable('aiWorkingMemory')
-            .addColumn('id', 'varchar(255)', (col) => col.notNull())
-            .addColumn('scope', 'varchar(50)', (col) => col.notNull())
-            .addColumn('data', 'text', (col) => col.notNull())
-            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('ai_working_memory_pk', ['id', 'scope']),
-        (db) => db.schema
-            .createTable('aiRun')
-            .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('agentName', 'varchar(255)', (col) => col.notNull())
-            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
-            .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
-            .addColumn('status', 'varchar(50)', (col) => col.notNull().defaultTo('running'))
-            .addColumn('errorMessage', 'text')
-            .addColumn('suspendReason', 'text')
-            .addColumn('missingRpcs', 'text')
-            .addColumn('pendingApprovals', 'text')
-            .addColumn('usageInputTokens', 'integer', (col) => col.notNull().defaultTo(0))
-            .addColumn('usageOutputTokens', 'integer', (col) => col.notNull().defaultTo(0))
-            .addColumn('usageModel', 'varchar(255)', (col) => col.notNull().defaultTo(''))
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
-            .createIndex('idx_ai_run_thread')
-            .on('aiRun')
-            .columns(['threadId', 'createdAt']),
-        (db) => db.schema
-            .createTable('aiRunScore')
-            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
-            .addColumn('runId', 'varchar(36)', (col) => col.notNull().references('aiRun.runId').onDelete('cascade'))
-            .addColumn('scorerName', 'varchar(255)', (col) => col.notNull())
-            .addColumn('score', 'real', (col) => col.notNull())
-            .addColumn('reason', 'text')
-            .addColumn('metadata', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
-            .createIndex('idx_ai_run_score_run')
-            .on('aiRunScore')
-            .columns(['runId', 'createdAt']),
-    ],
-};