opencode-database-plugin 1.0.7 → 1.0.9

package/dist/db.d.ts

@@ -1,4 +1,7 @@
 import postgres from "postgres";
 export declare const sql: postgres.Sql<{}>;
+export declare function isDatabaseHealthy(): boolean;
 export declare function ensureConnection(): Promise<boolean>;
+export declare function safeQuery<T>(queryFn: () => Promise<T>, timeoutMs?: number): Promise<T | undefined>;
+export declare function fireAndForget(queryFn: () => Promise<unknown>, onError?: (error: unknown) => void): void;
 //# sourceMappingURL=db.d.ts.map

package/dist/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAMhC,eAAO,MAAM,GAAG,kBAKd,CAAC;AAEH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAQzD"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAWhC,eAAO,MAAM,GAAG,kBAMd,CAAC;AAOH,wBAAgB,iBAAiB,IAAI,OAAO,CAY3C;AAYD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAUzD;AAED,wBAAsB,SAAS,CAAC,CAAC,EAC/B,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,SAAS,GAAE,MAAsB,GAChC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CA2BxB;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC/B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,IAAI,CAMN"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AA8BlD,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC3C,CAAC;CACH;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE;QACN,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAChC,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE;YACL,KAAK,CAAC,EAAE,MAAM,CAAC;YACf,GAAG,CAAC,EAAE,MAAM,CAAC;SACd,CAAC;KACH,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC3C,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAslB5B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA0E/D,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC3C,CAAC;CACH;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE;QACN,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAChC,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE;YACL,KAAK,CAAC,EAAE,MAAM,CAAC;YACf,GAAG,CAAC,EAAE,MAAM,CAAC;SACd,CAAC;KACH,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC3C,CAAC;CACH;AAmBD,eAAO,MAAM,cAAc,EAAE,MAyoB5B,CAAC"}

package/dist/index.js

@@ -1947,30 +1947,125 @@ function osUsername() {
 
 // db.ts
 var DATABASE_URL = process.env.OPENCODE_DATABASE_URL || "postgres://opencode:opencode@postgres:5432/opencode";
+var QUERY_TIMEOUT = parseInt(process.env.OPENCODE_DB_QUERY_TIMEOUT || "10000", 10);
 var sql = src_default(DATABASE_URL, {
   max: 10,
-  idle_timeout: 0,
-  connect_timeout: 30,
+  idle_timeout: 30,
+  connect_timeout: 10,
+  max_lifetime: 60 * 30,
   onnotice: () => {}
 });
+var consecutiveFailures = 0;
+var lastFailureTime = 0;
+var MAX_BACKOFF_MS = 60000;
+var BASE_BACKOFF_MS = 1000;
+function isDatabaseHealthy() {
+  if (consecutiveFailures === 0) {
+    return true;
+  }
+  const backoffMs = Math.min(BASE_BACKOFF_MS * Math.pow(2, consecutiveFailures - 1), MAX_BACKOFF_MS);
+  const timeSinceFailure = Date.now() - lastFailureTime;
+  return timeSinceFailure >= backoffMs;
+}
+function markHealthy() {
+  consecutiveFailures = 0;
+  lastFailureTime = 0;
+}
+function markUnhealthy() {
+  consecutiveFailures++;
+  lastFailureTime = Date.now();
+}
 async function ensureConnection() {
   try {
     await sql`SELECT 1`;
+    markHealthy();
     return true;
   } catch (error) {
     console.error("[database] Database connection failed:", error);
+    markUnhealthy();
     return false;
   }
 }
+async function safeQuery(queryFn, timeoutMs = QUERY_TIMEOUT) {
+  if (!isDatabaseHealthy()) {
+    return;
+  }
+  try {
+    const result = await Promise.race([
+      queryFn(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("Query timeout")), timeoutMs))
+    ]);
+    markHealthy();
+    return result;
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("connection") || error.message.includes("timeout") || error.message.includes("ECONNREFUSED") || error.message.includes("ENOTFOUND") || error.message.includes("ETIMEDOUT"))) {
+      markUnhealthy();
+    }
+    throw error;
+  }
+}
+function fireAndForget(queryFn, onError) {
+  safeQuery(queryFn).catch((error) => {
+    if (onError) {
+      onError(error);
+    }
+  });
+}
 
 // index.ts
+var STALE_ENTRY_TIMEOUT_MS = 15 * 60 * 1000;
+var CLEANUP_INTERVAL_MS = 60 * 1000;
 var pendingExecutions = new Map;
 var callIdToPartId = new Map;
 var pendingUserMessages = new Map;
 var tokensCountedBySession = new Map;
+var callIdTimestamps = new Map;
+function cleanupStaleMaps() {
+  const now = Date.now();
+  for (const [key, value] of pendingExecutions) {
+    if (now - value.startedAt.getTime() > STALE_ENTRY_TIMEOUT_MS) {
+      pendingExecutions.delete(key);
+    }
+  }
+  for (const [key, value] of pendingUserMessages) {
+    if (now - value.timestamp > STALE_ENTRY_TIMEOUT_MS) {
+      pendingUserMessages.delete(key);
+    }
+  }
+  for (const [key, timestamp] of callIdTimestamps) {
+    if (now - timestamp > STALE_ENTRY_TIMEOUT_MS) {
+      callIdToPartId.delete(key);
+      callIdTimestamps.delete(key);
+    }
+  }
+  for (const [sessionId, messageTimestamps] of tokensCountedBySession) {
+    for (const [messageId, timestamp] of messageTimestamps) {
+      if (now - timestamp > STALE_ENTRY_TIMEOUT_MS) {
+        messageTimestamps.delete(messageId);
+      }
+    }
+    if (messageTimestamps.size === 0) {
+      tokensCountedBySession.delete(sessionId);
+    }
+  }
+}
+var cleanupInterval = setInterval(cleanupStaleMaps, CLEANUP_INTERVAL_MS);
+if (cleanupInterval.unref) {
+  cleanupInterval.unref();
+}
 function generateCorrelationId() {
   return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
+function logError(client, message, extra) {
+  Promise.resolve(client.app.log({
+    body: {
+      service: "database",
+      level: "error",
+      message,
+      extra
+    }
+  })).catch(() => {});
+}
 var DatabasePlugin = async ({ client }) => {
   const connected = await ensureConnection();
   if (!connected) {
@@ -1990,7 +2085,7 @@ var DatabasePlugin = async ({ client }) => {
         switch (event.type) {
           case "session.created": {
             const info = props.info;
-            await sql`
+            fireAndForget(() => sql`
               INSERT INTO sessions (id, title, parent_id, project_id, directory, status, created_at)
               VALUES (
                 ${info.id},
@@ -2006,43 +2101,52 @@ var DatabasePlugin = async ({ client }) => {
                 parent_id = COALESCE(${info.parentID || null}, sessions.parent_id),
                 project_id = COALESCE(${info.projectID || null}, sessions.project_id),
                 directory = COALESCE(${info.directory || null}, sessions.directory)
-            `;
+            `, (error) => logError(client, "Error in session.created", {
+              error: String(error)
+            }));
             break;
           }
           case "session.updated": {
             const info = props.info;
-            await sql`
+            fireAndForget(() => sql`
               UPDATE sessions
               SET title = COALESCE(${info.title || null}, title),
                   share_url = COALESCE(${info.share?.url || null}, share_url)
               WHERE id = ${info.id}
-            `;
+            `, (error) => logError(client, "Error in session.updated", {
+              error: String(error)
+            }));
             break;
           }
           case "session.deleted": {
             const info = props.info;
-            await sql`
+            fireAndForget(() => sql`
               UPDATE sessions
               SET deleted_at = NOW(), status = 'deleted'
               WHERE id = ${info.id}
-            `;
+            `, (error) => logError(client, "Error in session.deleted", {
+              error: String(error)
+            }));
             tokensCountedBySession.delete(info.id);
             break;
           }
           case "session.idle": {
             const sessionID = props.sessionID;
-            await sql`
+            fireAndForget(() => sql`
               UPDATE sessions
               SET status = 'idle', updated_at = NOW()
               WHERE id = ${sessionID}
-            `;
+            `, (error) => logError(client, "Error in session.idle", {
+              error: String(error)
+            }));
             break;
           }
           case "session.error": {
             const sessionID = props.sessionID;
             const error = props.error;
             if (sessionID) {
-              await sql`
+              fireAndForget(async () => {
+                await sql`
                 INSERT INTO session_errors (session_id, error_type, error_message, error_data)
                 VALUES (
                   ${sessionID},
@@ -2051,70 +2155,66 @@ var DatabasePlugin = async ({ client }) => {
                   ${error ? sql.json(error) : null}
                 )
               `;
-              await sql`
+                await sql`
                 UPDATE sessions SET status = 'error' WHERE id = ${sessionID}
               `;
-              await client.app.log({
-                body: {
-                  service: "database",
-                  level: "info",
-                  message: "Session error",
-                  extra: { sessionID, errorMessage: error?.data?.message }
-                }
               });
             }
             break;
           }
           case "session.compacted": {
             const sessionID = props.sessionID;
-            const [sessionState] = await sql`
-              SELECT context_tokens, input_tokens, output_tokens,
-                     cache_read_tokens, cache_write_tokens, reasoning_tokens, estimated_cost
-              FROM sessions WHERE id = ${sessionID}
-            `;
-            if (sessionState) {
-              await sql`
-                INSERT INTO compactions (
-                  session_id,
-                  context_tokens_before,
-                  cumulative_input_tokens,
-                  cumulative_output_tokens,
-                  cumulative_cache_read,
-                  cumulative_cache_write,
-                  cumulative_reasoning,
-                  cumulative_cost
-                )
-                VALUES (
-                  ${sessionID},
-                  ${sessionState.context_tokens || 0},
-                  ${sessionState.input_tokens || 0},
-                  ${sessionState.output_tokens || 0},
-                  ${sessionState.cache_read_tokens || 0},
-                  ${sessionState.cache_write_tokens || 0},
-                  ${sessionState.reasoning_tokens || 0},
-                  ${parseFloat(sessionState.estimated_cost || "0")}
-                )
-              `;
-            }
-            await sql`
-              UPDATE sessions
-              SET
-                status = 'compacted',
-                peak_context_tokens = GREATEST(peak_context_tokens, context_tokens),
-                context_tokens = 0,
-                compaction_count = compaction_count + 1
-              WHERE id = ${sessionID}
-            `;
+            try {
+              const result = await safeQuery(() => sql`
+                SELECT context_tokens, input_tokens, output_tokens,
+                       cache_read_tokens, cache_write_tokens, reasoning_tokens, estimated_cost
+                FROM sessions WHERE id = ${sessionID}
+              `);
+              const sessionState = result?.[0];
+              if (sessionState) {
+                fireAndForget(() => sql`
+                  INSERT INTO compactions (
+                    session_id,
+                    context_tokens_before,
+                    cumulative_input_tokens,
+                    cumulative_output_tokens,
+                    cumulative_cache_read,
+                    cumulative_cache_write,
+                    cumulative_reasoning,
+                    cumulative_cost
+                  )
+                  VALUES (
+                    ${sessionID},
+                    ${sessionState.context_tokens || 0},
+                    ${sessionState.input_tokens || 0},
+                    ${sessionState.output_tokens || 0},
+                    ${sessionState.cache_read_tokens || 0},
+                    ${sessionState.cache_write_tokens || 0},
+                    ${sessionState.reasoning_tokens || 0},
+                    ${parseFloat(sessionState.estimated_cost || "0")}
+                  )
+                `);
+              }
+              fireAndForget(() => sql`
+                UPDATE sessions
+                SET
+                  status = 'compacted',
+                  peak_context_tokens = GREATEST(peak_context_tokens, context_tokens),
+                  context_tokens = 0,
+                  compaction_count = compaction_count + 1
+                WHERE id = ${sessionID}
+              `);
+            } catch {}
             tokensCountedBySession.delete(sessionID);
             break;
           }
           case "message.updated": {
             const info = props.info;
-            await sql`
+            fireAndForget(() => sql`
               INSERT INTO sessions (id, status, created_at, updated_at)
               VALUES (${info.sessionID}, 'active', NOW(), NOW())
               ON CONFLICT (id) DO UPDATE SET updated_at = NOW()
-            `;
+            `);
             let messageContent = info.parts;
             let textContent = null;
             let systemPrompt = info.system || null;
@@ -2134,7 +2234,7 @@ var DatabasePlugin = async ({ client }) => {
             }
             const modelProvider = info.providerID || info.model?.providerID || null;
             const modelId = info.modelID || info.model?.modelID || null;
-            await sql`
+            fireAndForget(() => sql`
               INSERT INTO messages (id, session_id, role, model_provider, model_id, text, summary, content, system_prompt, created_at)
               VALUES (
                 ${info.id},
@@ -2156,8 +2256,10 @@ var DatabasePlugin = async ({ client }) => {
                 summary = COALESCE(${info.summary?.title || null}, messages.summary),
                 content = COALESCE(${messageContent ? sql.json(messageContent) : null}, messages.content),
                 system_prompt = COALESCE(${systemPrompt}, messages.system_prompt)
-            `;
-            const sessionTokens = tokensCountedBySession.get(info.sessionID) || new Set;
+            `, (error) => logError(client, "Error in message.updated", {
+              error: String(error)
+            }));
+            const sessionTokens = tokensCountedBySession.get(info.sessionID) || new Map;
             if (info.role === "assistant" && info.tokens && !sessionTokens.has(info.id)) {
               const inputTokens = info.tokens.input ?? 0;
               const outputTokens = info.tokens.output ?? 0;
@@ -2165,10 +2267,10 @@ var DatabasePlugin = async ({ client }) => {
               const cacheRead = info.tokens.cache?.read ?? 0;
               const cacheWrite = info.tokens.cache?.write ?? 0;
               if (inputTokens > 0 || outputTokens > 0) {
-                sessionTokens.add(info.id);
+                sessionTokens.set(info.id, Date.now());
                 tokensCountedBySession.set(info.sessionID, sessionTokens);
                 const contextSize = inputTokens + cacheRead;
-                await sql`
+                fireAndForget(() => sql`
                   UPDATE sessions
                   SET
                     input_tokens = input_tokens + ${inputTokens},
@@ -2181,16 +2283,18 @@ var DatabasePlugin = async ({ client }) => {
                     model_provider = COALESCE(${modelProvider}, model_provider),
                     model_id = COALESCE(${modelId}, model_id)
                   WHERE id = ${info.sessionID}
-                `;
+                `, (error) => logError(client, "Error updating session tokens", {
+                  error: String(error)
+                }));
               }
             }
             break;
           }
           case "message.removed": {
             const messageID = props.messageID;
-            await sql`
+            fireAndForget(() => sql`
               DELETE FROM messages WHERE id = ${messageID}
-            `;
+            `);
             break;
           }
           case "message.part.updated": {
@@ -2199,56 +2303,60 @@ var DatabasePlugin = async ({ client }) => {
             const textContent = part.text || null;
             if (part.type === "tool" && part.callID) {
               callIdToPartId.set(part.callID, part.id);
+              callIdTimestamps.set(part.callID, Date.now());
               const pending = pendingExecutions.get(part.callID);
               if (pending) {
                 pending.partId = part.id;
               }
             }
             if (part.type === "step-finish" && part.cost !== undefined) {
-              await sql`
+              const cost = part.cost;
+              fireAndForget(() => sql`
                 UPDATE sessions
-                SET estimated_cost = estimated_cost + ${part.cost}
+                SET estimated_cost = estimated_cost + ${cost}
                 WHERE id = ${part.sessionID}
-              `;
+              `);
             }
-            await sql`
+            fireAndForget(() => sql`
               INSERT INTO messages (id, session_id, role, created_at)
               VALUES (${part.messageID}, ${part.sessionID}, 'assistant', NOW())
               ON CONFLICT (id) DO UPDATE SET
                 role = COALESCE(messages.role, 'assistant')
-            `;
-            await sql`
+            `);
+            fireAndForget(() => sql`
               INSERT INTO sessions (id, status, created_at)
               VALUES (${part.sessionID}, 'active', NOW())
               ON CONFLICT (id) DO NOTHING
-            `;
+            `);
             const isStreamingTextPart = part.type === "text" || part.type === "reasoning";
             const partAsJson = { ...part };
             if (isStreamingTextPart) {
-              await sql`
-                INSERT INTO message_parts (id, message_id, part_type, tool_name, text, content, created_at)
-                VALUES (
-                  ${part.id},
-                  ${part.messageID},
-                  ${part.type},
-                  ${toolName},
-                  ${textContent},
-                  ${sql.json(partAsJson)},
-                  NOW()
-                )
-                ON CONFLICT (id) DO NOTHING
-              `;
-              if (textContent) {
+              fireAndForget(async () => {
                 await sql`
-                  UPDATE message_parts
-                  SET
-                    tool_name = COALESCE(${toolName}, tool_name),
-                    text = ${textContent},
-                    content = ${sql.json(partAsJson)}
-                  WHERE id = ${part.id}
-                    AND (text IS NULL OR LENGTH(text) < LENGTH(${textContent}))
+                  INSERT INTO message_parts (id, message_id, part_type, tool_name, text, content, created_at)
+                  VALUES (
+                    ${part.id},
+                    ${part.messageID},
+                    ${part.type},
+                    ${toolName},
+                    ${textContent},
+                    ${sql.json(partAsJson)},
+                    NOW()
+                  )
+                  ON CONFLICT (id) DO NOTHING
                 `;
-              }
+                if (textContent) {
+                  await sql`
+                    UPDATE message_parts
+                    SET
+                      tool_name = COALESCE(${toolName}, tool_name),
+                      text = ${textContent},
+                      content = ${sql.json(partAsJson)}
+                    WHERE id = ${part.id}
+                      AND (text IS NULL OR LENGTH(text) < LENGTH(${textContent}))
+                  `;
+                }
+              });
             } else {
               const statusPriority = {
                 pending: 1,
@@ -2258,59 +2366,61 @@ var DatabasePlugin = async ({ client }) => {
               };
               const currentStatus = part.state?.status || "pending";
               const currentPriority = statusPriority[currentStatus] || 0;
-              await sql`
-                INSERT INTO message_parts (id, message_id, part_type, tool_name, text, content, created_at)
-                VALUES (
-                  ${part.id},
-                  ${part.messageID},
-                  ${part.type},
-                  ${toolName},
-                  ${textContent},
-                  ${sql.json(partAsJson)},
-                  NOW()
-                )
-                ON CONFLICT (id) DO NOTHING
-              `;
-              await sql`
-                UPDATE message_parts
-                SET
-                  tool_name = COALESCE(${toolName}, tool_name),
-                  text = COALESCE(${textContent}, text),
-                  content = ${sql.json(partAsJson)}
-                WHERE id = ${part.id}
-                  AND ${currentPriority} >= COALESCE(
-                    CASE (content->'state'->>'status')
-                      WHEN 'pending' THEN 1
-                      WHEN 'running' THEN 2
-                      WHEN 'completed' THEN 3
-                      WHEN 'error' THEN 3
-                      ELSE 0
-                    END, 0
+              fireAndForget(async () => {
+                await sql`
+                  INSERT INTO message_parts (id, message_id, part_type, tool_name, text, content, created_at)
+                  VALUES (
+                    ${part.id},
+                    ${part.messageID},
+                    ${part.type},
+                    ${toolName},
+                    ${textContent},
+                    ${sql.json(partAsJson)},
+                    NOW()
                   )
-              `;
+                  ON CONFLICT (id) DO NOTHING
+                `;
+                await sql`
+                  UPDATE message_parts
+                  SET
+                    tool_name = COALESCE(${toolName}, tool_name),
+                    text = COALESCE(${textContent}, text),
+                    content = ${sql.json(partAsJson)}
+                  WHERE id = ${part.id}
+                    AND ${currentPriority} >= COALESCE(
+                      CASE (content->'state'->>'status')
+                        WHEN 'pending' THEN 1
+                        WHEN 'running' THEN 2
+                        WHEN 'completed' THEN 3
+                        WHEN 'error' THEN 3
+                        ELSE 0
+                      END, 0
+                    )
+                `;
+              });
             }
             if (part.type === "text" && textContent) {
-              await sql`
+              fireAndForget(() => sql`
                 UPDATE messages
                 SET text = ${textContent}
                 WHERE id = ${part.messageID}
                   AND (text IS NULL OR LENGTH(text) < LENGTH(${textContent}))
-              `;
+              `);
             }
             break;
           }
           case "message.part.removed": {
             const partID = props.partID;
-            await sql`
+            fireAndForget(() => sql`
               DELETE FROM message_parts WHERE id = ${partID}
-            `;
+            `);
             break;
           }
           case "command.executed": {
             const name = props.name;
             const sessionID = props.sessionID;
             const args = props.arguments;
-            await sql`
+            fireAndForget(() => sql`
               INSERT INTO commands (session_id, command_name, command_args, created_at)
               VALUES (
                 ${sessionID},
@@ -2318,27 +2428,23 @@ var DatabasePlugin = async ({ client }) => {
                 ${args || null},
                 NOW()
               )
-            `;
+            `);
             break;
           }
         }
       } catch (error) {
-        await client.app.log({
-          body: {
-            service: "database",
-            level: "error",
-            message: "Error recording event",
-            extra: { eventType: event.type, error: String(error) }
-          }
+        logError(client, "Error recording event", {
+          eventType: event.type,
+          error: String(error)
         });
       }
     },
     "chat.message": async (input, output) => {
       try {
-        await sql`
+        fireAndForget(() => sql`
           UPDATE sessions SET status = 'active', updated_at = NOW()
           WHERE id = ${input.sessionID}
-        `;
+        `);
         const systemPrompt = output.message?.system;
         if (output.parts && output.parts.length > 0) {
           pendingUserMessages.set(input.sessionID, {
@@ -2354,14 +2460,7 @@ var DatabasePlugin = async ({ client }) => {
           });
         }
       } catch (error) {
-        await client.app.log({
-          body: {
-            service: "database",
-            level: "error",
-            message: "Error in chat.message",
-            extra: { error: String(error) }
-          }
-        });
+        logError(client, "Error in chat.message", { error: String(error) });
       }
     },
     "tool.execute.before": async (input, output) => {
@@ -2375,7 +2474,7 @@ var DatabasePlugin = async ({ client }) => {
           args: output.args || {},
           startedAt
         });
-        await sql`
+        fireAndForget(() => sql`
           INSERT INTO tool_executions (
             correlation_id,
             session_id,
@@ -2392,15 +2491,12 @@ var DatabasePlugin = async ({ client }) => {
             ${startedAt},
             NOW()
           )
-        `;
+        `, (error) => logError(client, "Error recording tool start", {
+          error: String(error)
+        }));
       } catch (error) {
-        await client.app.log({
-          body: {
-            service: "database",
-            level: "error",
-            message: "Error recording tool start",
-            extra: { error: String(error) }
-          }
+        logError(client, "Error in tool.execute.before", {
+          error: String(error)
         });
       }
     },
@@ -2408,79 +2504,81 @@ var DatabasePlugin = async ({ client }) => {
       try {
         const completedAt = new Date;
         const pending = pendingExecutions.get(input.callID);
+        const partId = pending?.partId || callIdToPartId.get(input.callID) || null;
         if (pending) {
           const durationMs = completedAt.getTime() - pending.startedAt.getTime();
-          await sql`
-            UPDATE tool_executions
-            SET
-              result = ${output.output ?? null},
-              completed_at = ${completedAt},
-              duration_ms = ${durationMs},
-              success = true
-            WHERE correlation_id = ${pending.correlationId}
-          `;
-          const partId = pending.partId || callIdToPartId.get(input.callID);
-          if (partId && output.output) {
-            const outputJson = JSON.stringify(output.output);
+          fireAndForget(async () => {
             await sql`
-              UPDATE message_parts
-              SET content = jsonb_set(
-                COALESCE(content, '{"state":{}}'::jsonb),
-                '{state,output}',
-                ${outputJson}::jsonb
-              )
-              WHERE id = ${partId}
-                AND (content->'state'->>'output') IS NULL
+              UPDATE tool_executions
+              SET
+                result = ${output.output ?? null},
+                completed_at = ${completedAt},
+                duration_ms = ${durationMs},
+                success = true
+              WHERE correlation_id = ${pending.correlationId}
             `;
-          }
+            if (partId && output.output) {
+              const outputJson = JSON.stringify(output.output);
+              await sql`
+                UPDATE message_parts
+                SET content = jsonb_set(
+                  COALESCE(content, '{"state":{}}'::jsonb),
+                  '{state,output}',
+                  ${outputJson}::jsonb
+                )
+                WHERE id = ${partId}
+                  AND (content->'state'->>'output') IS NULL
+              `;
+            }
+          });
           pendingExecutions.delete(input.callID);
         } else {
-          await sql`
-            INSERT INTO tool_executions (
-              correlation_id,
-              session_id,
-              tool_name,
-              args,
-              result,
-              completed_at,
-              success,
-              created_at
-            )
-            VALUES (
-              ${generateCorrelationId()},
-              ${input.sessionID},
-              ${input.tool},
-              ${output.metadata ?? null},
-              ${output.output ?? null},
-              ${completedAt},
-              true,
-              NOW()
-            )
-          `;
-          const partId = callIdToPartId.get(input.callID);
-          if (partId && output.output) {
-            const outputJson = JSON.stringify(output.output);
+          fireAndForget(async () => {
             await sql`
-              UPDATE message_parts
-              SET content = jsonb_set(
-                COALESCE(content, '{"state":{}}'::jsonb),
-                '{state,output}',
-                ${outputJson}::jsonb
+              INSERT INTO tool_executions (
+                correlation_id,
+                session_id,
+                tool_name,
+                args,
+                result,
+                completed_at,
+                success,
+                created_at
+              )
+              VALUES (
+                ${generateCorrelationId()},
+                ${input.sessionID},
+                ${input.tool},
+                ${output.metadata ?? null},
+                ${output.output ?? null},
+                ${completedAt},
+                true,
+                NOW()
               )
-              WHERE id = ${partId}
-                AND (content->'state'->>'output') IS NULL
             `;
-          }
+            if (partId && output.output) {
+              const outputJson = JSON.stringify(output.output);
+              await sql`
+                UPDATE message_parts
+                SET content = jsonb_set(
+                  COALESCE(content, '{"state":{}}'::jsonb),
+                  '{state,output}',
+                  ${outputJson}::jsonb
+                )
+                WHERE id = ${partId}
+                  AND (content->'state'->>'output') IS NULL
+              `;
+            }
+          });
         }
         callIdToPartId.delete(input.callID);
+        callIdTimestamps.delete(input.callID);
       } catch (error) {
-        await client.app.log({
-          body: {
-            service: "database",
-            level: "error",
-            message: "Error recording tool completion",
-            extra: { error: String(error) }
-          }
+        pendingExecutions.delete(input.callID);
+        callIdToPartId.delete(input.callID);
+        callIdTimestamps.delete(input.callID);
+        logError(client, "Error recording tool completion", {
+          error: String(error)
         });
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-database-plugin",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "OpenCode plugin that logs sessions, messages, tool executions, and token usage to PostgreSQL",
   "type": "module",
   "main": "./dist/index.js",