@pikku/kysely 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.12.0
+
+- Updated dependencies
+
 ## 0.11.0
 
 ### Minor Changes
@@ -5,7 +9,6 @@
 - Remove Kysely-based channel and eventhub stores (use @pikku/pg instead)
 - Update to support shared connection instances
 
-
 # @pikku/kysely
 
 ## 0.10.0

package/dist/src/index.d.ts

@@ -1 +1,11 @@
 export { PikkuKysely } from './pikku-kysely.js';
+export { KyselyChannelStore } from './kysely-channel-store.js';
+export { KyselyEventHubStore } from './kysely-eventhub-store.js';
+export { KyselyWorkflowService } from './kysely-workflow-service.js';
+export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
+export { KyselyDeploymentService } from './kysely-deployment-service.js';
+export { KyselyAIStorageService } from './kysely-ai-storage-service.js';
+export { KyselyAgentRunService } from './kysely-agent-run-service.js';
+export type { KyselyPikkuDB } from './kysely-tables.js';
+export type { WorkflowRunService } from '@pikku/core/workflow';
+export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent';

package/dist/src/index.js

@@ -1 +1,8 @@
 export { PikkuKysely } from './pikku-kysely.js';
+export { KyselyChannelStore } from './kysely-channel-store.js';
+export { KyselyEventHubStore } from './kysely-eventhub-store.js';
+export { KyselyWorkflowService } from './kysely-workflow-service.js';
+export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
+export { KyselyDeploymentService } from './kysely-deployment-service.js';
+export { KyselyAIStorageService } from './kysely-ai-storage-service.js';
+export { KyselyAgentRunService } from './kysely-agent-run-service.js';

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

@@ -0,0 +1,19 @@
+import type { AIThread, AIMessage, AgentRunRow, AgentRunService } from '@pikku/core/ai-agent';
+import { 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;
+        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-agent-run-service.js

@@ -0,0 +1,171 @@
+import { parseJson } from './kysely-json.js';
+export class KyselyAgentRunService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listThreads(options) {
+        const { agentName, limit = 50, offset = 0 } = options ?? {};
+        let query = this.db
+            .selectFrom('ai_threads as t')
+            .select([
+            't.id',
+            't.resource_id',
+            't.title',
+            't.metadata',
+            't.created_at',
+            't.updated_at',
+        ]);
+        if (agentName) {
+            query = query.where('t.id', 'in', this.db
+                .selectFrom('ai_run')
+                .select('thread_id')
+                .where('agent_name', '=', agentName)
+                .distinct());
+        }
+        const result = await query
+            .orderBy('t.updated_at', 'desc')
+            .limit(limit)
+            .offset(offset)
+            .execute();
+        return result.map((row) => this.mapThreadRow(row));
+    }
+    async getThread(threadId) {
+        const row = await this.db
+            .selectFrom('ai_threads')
+            .select([
+            'id',
+            'resource_id',
+            'title',
+            'metadata',
+            'created_at',
+            'updated_at',
+        ])
+            .where('id', '=', threadId)
+            .executeTakeFirst();
+        if (!row)
+            return null;
+        return this.mapThreadRow(row);
+    }
+    async getThreadMessages(threadId) {
+        const [msgResult, tcResult] = await Promise.all([
+            this.db
+                .selectFrom('ai_message')
+                .select(['id', 'role', 'content', 'created_at'])
+                .where('thread_id', '=', threadId)
+                .orderBy('created_at', 'asc')
+                .execute(),
+            this.db
+                .selectFrom('ai_tool_call')
+                .select(['id', 'message_id', 'tool_name', 'args', 'result'])
+                .where('thread_id', '=', threadId)
+                .orderBy('created_at', 'asc')
+                .execute(),
+        ]);
+        const tcByMessage = new Map();
+        for (const tc of tcResult) {
+            const msgId = tc.message_id;
+            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.created_at),
+            };
+            const tcs = tcByMessage.get(msg.id);
+            if (tcs?.length) {
+                msg.toolCalls = tcs.map((tc) => ({
+                    id: tc.id,
+                    name: tc.tool_name,
+                    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.tool_name,
+                            result: tc.result,
+                        })),
+                        createdAt: msg.createdAt,
+                    });
+                    continue;
+                }
+            }
+            messages.push(msg);
+        }
+        return messages;
+    }
+    async getThreadRuns(threadId) {
+        const result = await this.db
+            .selectFrom('ai_run')
+            .select([
+            'run_id',
+            'agent_name',
+            'thread_id',
+            'resource_id',
+            'status',
+            'suspend_reason',
+            'missing_rpcs',
+            'usage_input_tokens',
+            'usage_output_tokens',
+            'usage_model',
+            'created_at',
+            'updated_at',
+        ])
+            .where('thread_id', '=', threadId)
+            .orderBy('created_at', 'desc')
+            .execute();
+        return result.map((row) => this.mapRunRow(row));
+    }
+    async deleteThread(threadId) {
+        const result = await this.db
+            .deleteFrom('ai_threads')
+            .where('id', '=', threadId)
+            .executeTakeFirst();
+        return BigInt(result.numDeletedRows) > 0n;
+    }
+    async getDistinctAgentNames() {
+        const result = await this.db
+            .selectFrom('ai_run')
+            .select('agent_name')
+            .distinct()
+            .orderBy('agent_name')
+            .execute();
+        return result.map((row) => row.agent_name);
+    }
+    mapThreadRow(row) {
+        return {
+            id: row.id,
+            resourceId: row.resource_id,
+            title: row.title ?? undefined,
+            metadata: parseJson(row.metadata),
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+        };
+    }
+    mapRunRow(row) {
+        return {
+            runId: row.run_id,
+            agentName: row.agent_name,
+            threadId: row.thread_id,
+            resourceId: row.resource_id,
+            status: row.status,
+            suspendReason: row.suspend_reason ?? undefined,
+            missingRpcs: parseJson(row.missing_rpcs),
+            usageInputTokens: Number(row.usage_input_tokens),
+            usageOutputTokens: Number(row.usage_output_tokens),
+            usageModel: row.usage_model,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { AIStorageService, AIRunStateService, CreateRunInput } from '@pikku/core/services';
+import type { AIThread, AIMessage, AgentRunState } from '@pikku/core/ai-agent';
+import { 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<void>;
+    close(): Promise<void>;
+}