@pikku/kysely 0.13.16 → 0.13.18

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

@@ -3,7 +3,7 @@ import type {
   StepState,
   WorkflowStatus,
   WorkflowRunService,
-} from '@pikku/core/ecosystem/workflow'
+} from '@pikku/core/workflow'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'

package/src/kysely-workflow-service.test.ts

@@ -428,4 +428,3 @@ describe('KyselyWorkflowService — a transition that addresses no history row',
     assert.equal(history[0]!.status, 'succeeded')
   })
 })
-

package/src/kysely-workflow-service.ts

@@ -1,6 +1,15 @@
-import type { SerializedError } from '@pikku/core/ecosystem/types'
+import type { SerializedError } from '@pikku/core/errors'
 import { PikkuWorkflowService } from '@pikku/core/workflow'
-import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/ecosystem/workflow'
+import type {
+  WorkflowPlannedStep,
+  WorkflowQueueOptions,
+  WorkflowRun,
+  WorkflowRunWire,
+  StepState,
+  StepStatus,
+  WorkflowStatus,
+  WorkflowVersionStatus,
+} from '@pikku/core/workflow'
 import { sql, type Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { KyselyWorkflowRunService } from './kysely-workflow-run-service.js'

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

@@ -1,22 +0,0 @@
-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 {
-    private db;
-    constructor(db: Kysely<KyselyPikkuDB>);
-    listThreads(options?: {
-        agentName?: string;
-        resourceId?: string;
-        owners?: 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/kysely-ai-agent-run-service.js

@@ -1,190 +0,0 @@
-import { sql } from 'kysely';
-import { parseJson } from './kysely-json.js';
-// Owner ids routinely contain `_` (e.g. `user_123`), which LIKE treats as a
-// single-character wildcard — so a raw prefix would match a foreign owner.
-const escapeLikePattern = (value) => value.replace(/[\\%_]/g, (char) => `\\${char}`);
-export class KyselyAgentRunService {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async listThreads(options) {
-        const { agentName, resourceId, owners, limit = 50, offset = 0, } = options ?? {};
-        // An owners constraint is an authorization boundary, so an empty list must
-        // match nothing rather than degrade to "no filter".
-        if (owners && owners.length === 0)
-            return [];
-        let query = this.db
-            .selectFrom('aiThreads as t')
-            .select([
-            't.id',
-            't.resourceId',
-            't.title',
-            't.metadata',
-            't.createdAt',
-            't.updatedAt',
-        ]);
-        if (agentName) {
-            query = query.where('t.id', 'in', this.db
-                .selectFrom('aiRun')
-                .select('threadId')
-                .where('agentName', '=', agentName)
-                .distinct());
-        }
-        if (resourceId) {
-            query = query.where('t.resourceId', '=', resourceId);
-        }
-        if (owners) {
-            query = query.where((eb) => eb.or(owners.flatMap((owner) => [
-                eb('t.resourceId', '=', owner),
-                eb('t.resourceId', 'like', sql `${`${escapeLikePattern(owner)}:%`} escape '\\'`),
-            ])));
-        }
-        const result = await query
-            .orderBy('t.updatedAt', 'desc')
-            .limit(limit)
-            .offset(offset)
-            .execute();
-        return result.map((row) => this.mapThreadRow(row));
-    }
-    async getThread(threadId) {
-        const row = await this.db
-            .selectFrom('aiThreads')
-            .select([
-            'id',
-            'resourceId',
-            'title',
-            'metadata',
-            'createdAt',
-            'updatedAt',
-        ])
-            .where('id', '=', threadId)
-            .executeTakeFirst();
-        if (!row)
-            return null;
-        return this.mapThreadRow(row);
-    }
-    async getThreadMessages(threadId) {
-        const [msgResult, tcResult] = await Promise.all([
-            this.db
-                .selectFrom('aiMessage')
-                .select(['id', 'role', 'content', 'createdAt'])
-                .where('threadId', '=', threadId)
-                .orderBy('createdAt', 'asc')
-                .execute(),
-            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 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: 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 getThreadRuns(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();
-        return result.map((row) => this.mapRunRow(row));
-    }
-    async deleteThread(threadId) {
-        const result = await this.db
-            .deleteFrom('aiThreads')
-            .where('id', '=', threadId)
-            .executeTakeFirst();
-        return BigInt(result.numDeletedRows) > 0n;
-    }
-    async getDistinctAgentNames() {
-        const result = await this.db
-            .selectFrom('aiRun')
-            .select('agentName')
-            .distinct()
-            .orderBy('agentName')
-            .execute();
-        return result.map((row) => row.agentName);
-    }
-    mapThreadRow(row) {
-        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),
-        };
-    }
-    mapRunRow(row) {
-        return {
-            runId: row.runId,
-            agentName: row.agentName,
-            threadId: row.threadId,
-            resourceId: row.resourceId,
-            status: row.status,
-            errorMessage: row.errorMessage ?? undefined,
-            suspendReason: row.suspendReason ?? undefined,
-            missingRpcs: parseJson(row.missingRpcs),
-            usageInputTokens: Number(row.usageInputTokens),
-            usageOutputTokens: Number(row.usageOutputTokens),
-            usageModel: row.usageModel,
-            createdAt: new Date(row.createdAt),
-            updatedAt: new Date(row.updatedAt),
-        };
-    }
-}

package/dist/src/kysely-ai-run-scores.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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,24 +0,0 @@
-import type { Kysely } from 'kysely';
-import type { KyselyPikkuDB } from './kysely-tables.js';
-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;
-    constructor(db: Kysely<KyselyPikkuDB>);
-    init(): 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[]>;
-    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<boolean>;
-    findRunByToolCallId(toolCallId: string): Promise<{
-        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,169 +0,0 @@
-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;
-    constructor(db) {
-        this.db = db;
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        await ensurePikkuSchema(this.db, aiSchema);
-        this.initialized = true;
-    }
-    async createRun(run) {
-        const runId = `run-${crypto.randomUUID()}`;
-        await this.db
-            .insertInto('aiRun')
-            .values({
-            runId,
-            agentName: run.agentName,
-            threadId: run.threadId,
-            resourceId: run.resourceId,
-            status: run.status ?? 'running',
-            errorMessage: run.errorMessage ?? null,
-            suspendReason: run.suspendReason ?? null,
-            missingRpcs: run.missingRpcs ? JSON.stringify(run.missingRpcs) : null,
-            usageInputTokens: run.usage?.inputTokens ?? 0,
-            usageOutputTokens: run.usage?.outputTokens ?? 0,
-            usageModel: run.usage?.model ?? '',
-        })
-            .execute();
-        return runId;
-    }
-    async updateRun(runId, updates) {
-        const values = {
-            updatedAt: sql `CURRENT_TIMESTAMP`,
-        };
-        if (updates.status !== undefined)
-            values.status = updates.status;
-        if (updates.errorMessage !== undefined)
-            values.errorMessage = updates.errorMessage;
-        if (updates.suspendReason !== undefined)
-            values.suspendReason = updates.suspendReason;
-        if (updates.missingRpcs !== undefined)
-            values.missingRpcs = JSON.stringify(updates.missingRpcs);
-        if (updates.pendingApprovals !== undefined)
-            values.pendingApprovals = JSON.stringify(updates.pendingApprovals);
-        if (updates.usage) {
-            values.usageInputTokens = updates.usage.inputTokens;
-            values.usageOutputTokens = updates.usage.outputTokens;
-            values.usageModel = updates.usage.model;
-        }
-        await this.db
-            .updateTable('aiRun')
-            .set(values)
-            .where('runId', '=', runId)
-            .execute();
-    }
-    async getRun(runId) {
-        const row = await this.db
-            .selectFrom('aiRun')
-            .selectAll()
-            .where('runId', '=', runId)
-            .executeTakeFirst();
-        return row ? this.toRunState(row) : null;
-    }
-    async getRunsByThread(threadId) {
-        const rows = await this.db
-            .selectFrom('aiRun')
-            .selectAll()
-            .where('threadId', '=', threadId)
-            .orderBy('createdAt', 'desc')
-            .execute();
-        return rows.map((r) => this.toRunState(r));
-    }
-    async resolveApproval(toolCallId, status) {
-        const rows = await this.db
-            .selectFrom('aiRun')
-            .select(['runId', 'pendingApprovals'])
-            .where('status', '=', 'suspended')
-            .execute();
-        for (const row of rows) {
-            let approvals = [];
-            if (row.pendingApprovals) {
-                try {
-                    approvals = JSON.parse(row.pendingApprovals);
-                }
-                catch {
-                    console.warn(`Failed to parse pendingApprovals for run ${row.runId}, treating as empty`);
-                }
-            }
-            const filtered = approvals.filter((a) => a.toolCallId !== toolCallId);
-            if (filtered.length !== approvals.length) {
-                const updates = {
-                    pendingApprovals: filtered.length > 0 ? JSON.stringify(filtered) : null,
-                    updatedAt: sql `CURRENT_TIMESTAMP`,
-                };
-                if (filtered.length === 0) {
-                    updates.status = status;
-                }
-                // Compare-and-swap on the list we read: a concurrent approver that got
-                // there first has already rewritten it, and this update matches no row.
-                const result = await this.db
-                    .updateTable('aiRun')
-                    .set(updates)
-                    .where('runId', '=', row.runId)
-                    .where('status', '=', 'suspended')
-                    .where('pendingApprovals', '=', row.pendingApprovals)
-                    .executeTakeFirst();
-                return Number(result?.numUpdatedRows ?? 0) > 0;
-            }
-        }
-        return false;
-    }
-    async findRunByToolCallId(toolCallId) {
-        const rows = await this.db
-            .selectFrom('aiRun')
-            .selectAll()
-            .where('status', '=', 'suspended')
-            .execute();
-        for (const row of rows) {
-            let approvals = [];
-            if (row.pendingApprovals) {
-                try {
-                    approvals = JSON.parse(row.pendingApprovals);
-                }
-                catch {
-                    console.warn(`Failed to parse pendingApprovals for run ${row.runId}, treating as empty`);
-                }
-            }
-            const approval = approvals.find((a) => a.toolCallId === toolCallId);
-            if (approval) {
-                return { run: this.toRunState(row), approval };
-            }
-        }
-        return null;
-    }
-    async saveScore(score) {
-        await saveRunScore(this.db, score);
-    }
-    async getScores(runId) {
-        return getRunScores(this.db, runId);
-    }
-    toRunState(row) {
-        return {
-            runId: row.runId,
-            agentName: row.agentName,
-            threadId: row.threadId,
-            resourceId: row.resourceId,
-            status: row.status,
-            errorMessage: row.errorMessage ?? undefined,
-            suspendReason: row.suspendReason ?? undefined,
-            missingRpcs: row.missingRpcs ? JSON.parse(row.missingRpcs) : undefined,
-            pendingApprovals: row.pendingApprovals
-                ? JSON.parse(row.pendingApprovals)
-                : undefined,
-            usage: {
-                inputTokens: row.usageInputTokens ?? 0,
-                outputTokens: row.usageOutputTokens ?? 0,
-                model: row.usageModel ?? '',
-            },
-            createdAt: new Date(row.createdAt),
-            updatedAt: new Date(row.updatedAt),
-        };
-    }
-}

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

@@ -1,40 +0,0 @@
-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 {
-    private db;
-    private initialized;
-    constructor(db: Kysely<KyselyPikkuDB>);
-    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<boolean>;
-    saveScore(score: SaveScoreInput): Promise<void>;
-    getScores(runId: string): Promise<AIRunScore[]>;
-    close(): Promise<void>;
-}