@pikku/kysely 0.12.6 → 0.12.8

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## 0.12.0
 
+## 0.12.8
+
+### Patch Changes
+
+- f85c234: Add unified credential system with per-user OAuth and AI agent pre-flight checks
+
+  - Unified CredentialService with lazy loading per user via pikkuUserId
+  - wire.getCredential() for typed single credential lookup
+  - MissingCredentialError with structured payload for client-side connect flows
+  - Console UI: Global/Users credential tabs, per-user OAuth connect/revoke
+  - AI agent pre-flight check: detects missing OAuth credentials from addon metadata, shows "Connect your accounts" prompt before chat
+  - CLI codegen: generates credentialsMeta per addon package for runtime lookup
+  - Vercel AI runner: catches MissingCredentialError as runtime fallback
+
+- Updated dependencies [f85c234]
+- Updated dependencies [88d3100]
+  - @pikku/core@0.12.14
+
+## 0.12.7
+
+### Patch Changes
+
+- c485aab: Fix CamelCasePlugin mismatch: convert all table types, query references, and result property accesses from snake_case to camelCase to match Kysely CamelCasePlugin runtime behavior
+
 ## 0.12.6
 
 ### Patch Changes

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

@@ -7,24 +7,24 @@ export class KyselyAgentRunService {
     async listThreads(options) {
         const { agentName, limit = 50, offset = 0 } = options ?? {};
         let query = this.db
-            .selectFrom('ai_threads as t')
+            .selectFrom('aiThreads as t')
             .select([
             't.id',
-            't.resource_id',
+            't.resourceId',
             't.title',
             't.metadata',
-            't.created_at',
-            't.updated_at',
+            't.createdAt',
+            't.updatedAt',
         ]);
         if (agentName) {
             query = query.where('t.id', 'in', this.db
-                .selectFrom('ai_run')
-                .select('thread_id')
-                .where('agent_name', '=', agentName)
+                .selectFrom('aiRun')
+                .select('threadId')
+                .where('agentName', '=', agentName)
                 .distinct());
         }
         const result = await query
-            .orderBy('t.updated_at', 'desc')
+            .orderBy('t.updatedAt', 'desc')
             .limit(limit)
             .offset(offset)
             .execute();
@@ -32,14 +32,14 @@ export class KyselyAgentRunService {
     }
     async getThread(threadId) {
         const row = await this.db
-            .selectFrom('ai_threads')
+            .selectFrom('aiThreads')
             .select([
             'id',
-            'resource_id',
+            'resourceId',
             'title',
             'metadata',
-            'created_at',
-            'updated_at',
+            'createdAt',
+            'updatedAt',
         ])
             .where('id', '=', threadId)
             .executeTakeFirst();
@@ -50,21 +50,21 @@ export class KyselyAgentRunService {
     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')
+                .selectFrom('aiMessage')
+                .select(['id', 'role', 'content', 'createdAt'])
+                .where('threadId', '=', threadId)
+                .orderBy('createdAt', 'asc')
                 .execute(),
             this.db
-                .selectFrom('ai_tool_call')
-                .select(['id', 'message_id', 'tool_name', 'args', 'result'])
-                .where('thread_id', '=', threadId)
-                .orderBy('created_at', 'asc')
+                .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.message_id;
+            const msgId = tc.messageId;
             if (!tcByMessage.has(msgId))
                 tcByMessage.set(msgId, []);
             tcByMessage.get(msgId).push(tc);
@@ -75,13 +75,13 @@ export class KyselyAgentRunService {
                 id: row.id,
                 role: row.role,
                 content: row.content ?? undefined,
-                createdAt: new Date(row.created_at),
+                createdAt: new Date(row.createdAt),
             };
             const tcs = tcByMessage.get(msg.id);
             if (tcs?.length) {
                 msg.toolCalls = tcs.map((tc) => ({
                     id: tc.id,
-                    name: tc.tool_name,
+                    name: tc.toolName,
                     args: parseJson(tc.args),
                 }));
                 const completed = tcs.filter((tc) => tc.result != null);
@@ -92,7 +92,7 @@ export class KyselyAgentRunService {
                         role: 'tool',
                         toolResults: completed.map((tc) => ({
                             id: tc.id,
-                            name: tc.tool_name,
+                            name: tc.toolName,
                             result: tc.result,
                         })),
                         createdAt: msg.createdAt,
@@ -106,68 +106,68 @@ export class KyselyAgentRunService {
     }
     async getThreadRuns(threadId) {
         const result = await this.db
-            .selectFrom('ai_run')
+            .selectFrom('aiRun')
             .select([
-            'run_id',
-            'agent_name',
-            'thread_id',
-            'resource_id',
+            'runId',
+            'agentName',
+            'threadId',
+            'resourceId',
             'status',
-            'error_message',
-            'suspend_reason',
-            'missing_rpcs',
-            'usage_input_tokens',
-            'usage_output_tokens',
-            'usage_model',
-            'created_at',
-            'updated_at',
+            'errorMessage',
+            'suspendReason',
+            'missingRpcs',
+            'usageInputTokens',
+            'usageOutputTokens',
+            'usageModel',
+            'createdAt',
+            'updatedAt',
         ])
-            .where('thread_id', '=', threadId)
-            .orderBy('created_at', 'desc')
+            .where('threadId', '=', threadId)
+            .orderBy('createdAt', 'desc')
             .execute();
         return result.map((row) => this.mapRunRow(row));
     }
     async deleteThread(threadId) {
         const result = await this.db
-            .deleteFrom('ai_threads')
+            .deleteFrom('aiThreads')
             .where('id', '=', threadId)
             .executeTakeFirst();
         return BigInt(result.numDeletedRows) > 0n;
     }
     async getDistinctAgentNames() {
         const result = await this.db
-            .selectFrom('ai_run')
-            .select('agent_name')
+            .selectFrom('aiRun')
+            .select('agentName')
             .distinct()
-            .orderBy('agent_name')
+            .orderBy('agentName')
             .execute();
-        return result.map((row) => row.agent_name);
+        return result.map((row) => row.agentName);
     }
     mapThreadRow(row) {
         return {
             id: row.id,
-            resourceId: row.resource_id,
+            resourceId: row.resourceId,
             title: row.title ?? undefined,
             metadata: parseJson(row.metadata),
-            createdAt: new Date(row.created_at),
-            updatedAt: new Date(row.updated_at),
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
         };
     }
     mapRunRow(row) {
         return {
-            runId: row.run_id,
-            agentName: row.agent_name,
-            threadId: row.thread_id,
-            resourceId: row.resource_id,
+            runId: row.runId,
+            agentName: row.agentName,
+            threadId: row.threadId,
+            resourceId: row.resourceId,
             status: row.status,
-            errorMessage: row.error_message ?? undefined,
-            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),
+            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),
         };
     }
 }