@tuturuuu/ai 0.6.0 → 0.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuturuuu/ai",
   "license": "MIT",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/tutur3u/platform",
@@ -22,53 +22,53 @@
     "type-check": "tsc --project tsconfig.typecheck.json"
   },
   "dependencies": {
-    "@ai-sdk/amazon-bedrock": "^5.0.29",
-    "@ai-sdk/anthropic": "^4.0.18",
-    "@ai-sdk/azure": "^4.0.20",
-    "@ai-sdk/cerebras": "^3.0.14",
-    "@ai-sdk/cohere": "^4.0.12",
-    "@ai-sdk/deepgram": "^3.0.12",
-    "@ai-sdk/deepinfra": "^3.0.14",
-    "@ai-sdk/deepseek": "^3.0.13",
-    "@ai-sdk/elevenlabs": "^3.0.13",
-    "@ai-sdk/fal": "^3.0.13",
-    "@ai-sdk/fireworks": "^3.0.15",
-    "@ai-sdk/gateway": "^4.0.27",
-    "@ai-sdk/gladia": "^3.0.12",
-    "@ai-sdk/google": "^4.0.23",
-    "@ai-sdk/google-vertex": "^5.0.27",
-    "@ai-sdk/groq": "^4.0.13",
-    "@ai-sdk/hume": "^3.0.12",
-    "@ai-sdk/lmnt": "^3.0.12",
-    "@ai-sdk/luma": "^3.0.13",
-    "@ai-sdk/mistral": "^4.0.14",
-    "@ai-sdk/openai": "^4.0.19",
-    "@ai-sdk/openai-compatible": "^3.0.14",
-    "@ai-sdk/perplexity": "^4.0.13",
-    "@ai-sdk/react": "^4.0.39",
-    "@ai-sdk/replicate": "^3.0.13",
-    "@ai-sdk/revai": "^3.0.12",
-    "@ai-sdk/togetherai": "^3.0.15",
-    "@ai-sdk/xai": "^4.0.18",
+    "@ai-sdk/amazon-bedrock": "^5.0.42",
+    "@ai-sdk/anthropic": "^4.0.29",
+    "@ai-sdk/azure": "^4.0.30",
+    "@ai-sdk/cerebras": "^3.0.22",
+    "@ai-sdk/cohere": "^4.0.20",
+    "@ai-sdk/deepgram": "^3.0.20",
+    "@ai-sdk/deepinfra": "^3.0.22",
+    "@ai-sdk/deepseek": "^3.0.21",
+    "@ai-sdk/elevenlabs": "^3.0.21",
+    "@ai-sdk/fal": "^3.0.21",
+    "@ai-sdk/fireworks": "^3.0.24",
+    "@ai-sdk/gateway": "^4.0.40",
+    "@ai-sdk/gladia": "^3.0.20",
+    "@ai-sdk/google": "^4.0.33",
+    "@ai-sdk/google-vertex": "^5.0.40",
+    "@ai-sdk/groq": "^4.0.21",
+    "@ai-sdk/hume": "^3.0.20",
+    "@ai-sdk/lmnt": "^3.0.20",
+    "@ai-sdk/luma": "^3.0.21",
+    "@ai-sdk/mistral": "^4.0.22",
+    "@ai-sdk/openai": "^4.0.29",
+    "@ai-sdk/openai-compatible": "^3.0.22",
+    "@ai-sdk/perplexity": "^4.0.22",
+    "@ai-sdk/react": "^4.0.54",
+    "@ai-sdk/replicate": "^3.0.21",
+    "@ai-sdk/revai": "^3.0.20",
+    "@ai-sdk/togetherai": "^3.0.23",
+    "@ai-sdk/xai": "^4.0.27",
     "@beeper/chat-adapter-matrix": "^0.2.0",
     "@bitbasti/chat-adapter-webex": "^0.1.0",
-    "@chat-adapter/discord": "^4.34.0",
-    "@chat-adapter/gchat": "^4.34.0",
-    "@chat-adapter/github": "^4.34.0",
-    "@chat-adapter/linear": "^4.34.0",
-    "@chat-adapter/messenger": "^4.34.0",
-    "@chat-adapter/slack": "^4.34.0",
-    "@chat-adapter/state-ioredis": "^4.34.0",
-    "@chat-adapter/state-memory": "^4.34.0",
-    "@chat-adapter/state-pg": "^4.34.0",
-    "@chat-adapter/state-redis": "^4.34.0",
-    "@chat-adapter/teams": "^4.34.0",
-    "@chat-adapter/telegram": "^4.34.0",
-    "@chat-adapter/web": "^4.34.0",
-    "@chat-adapter/whatsapp": "^4.34.0",
+    "@chat-adapter/discord": "^4.36.0",
+    "@chat-adapter/gchat": "^4.36.0",
+    "@chat-adapter/github": "^4.36.0",
+    "@chat-adapter/linear": "^4.36.0",
+    "@chat-adapter/messenger": "^4.36.0",
+    "@chat-adapter/slack": "^4.36.0",
+    "@chat-adapter/state-ioredis": "^4.36.0",
+    "@chat-adapter/state-memory": "^4.36.0",
+    "@chat-adapter/state-pg": "^4.36.0",
+    "@chat-adapter/state-redis": "^4.36.0",
+    "@chat-adapter/teams": "^4.36.0",
+    "@chat-adapter/telegram": "^4.36.0",
+    "@chat-adapter/web": "^4.36.0",
+    "@chat-adapter/whatsapp": "^4.36.0",
     "@json-render/core": "^0.19.0",
     "@json-render/react": "^0.19.0",
-    "@liveblocks/chat-sdk-adapter": "^3.22.0",
+    "@liveblocks/chat-sdk-adapter": "^3.23.0",
     "@octokit/rest": "^22.0.1",
     "@resend/chat-sdk-adapter": "^0.2.2",
     "@streamdown/cjk": "^1.0.3",
@@ -76,14 +76,14 @@
     "@streamdown/math": "^1.0.2",
     "@streamdown/mermaid": "^1.0.2",
     "@tuturuuu/google": "0.1.0",
-    "@tuturuuu/internal-api": "0.24.0",
+    "@tuturuuu/internal-api": "0.28.0",
     "@tuturuuu/supabase": "0.5.0",
-    "@tuturuuu/utils": "0.20.0",
-    "@vercel/sandbox": "^2.8.0",
-    "@zernio/chat-sdk-adapter": "^0.4.0",
-    "ai": "^7.0.36",
+    "@tuturuuu/utils": "0.22.0",
+    "@vercel/sandbox": "^2.9.2",
+    "@zernio/chat-sdk-adapter": "^0.5.0",
+    "ai": "^7.0.51",
     "bash-tool": "^1.3.18",
-    "chat": "^4.34.0",
+    "chat": "^4.36.0",
     "chat-adapter-baileys": "^2.1.0",
     "chat-adapter-blooio": "^0.1.0",
     "chat-adapter-imessage": "^1.1.0",
@@ -93,7 +93,7 @@
     "chat-state-cloudflare-do": "^0.2.0",
     "chat-state-mysql": "^0.1.0",
     "dayjs": "^1.11.21",
-    "next": "^16.3.0-preview.9",
+    "next": "^16.3.0",
     "qrcode": "^1.5.4",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
@@ -103,11 +103,11 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@tuturuuu/types": "0.23.0",
+    "@tuturuuu/types": "0.27.0",
     "@tuturuuu/typescript-config": "0.1.1",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.1.2",
     "@types/qrcode": "^1.5.6",
-    "@types/react": "^19.2.17",
+    "@types/react": "^19.2.18",
     "typescript": "7.0.2"
   },
   "exports": {

package/src/chat/google/chat-request-schema.ts

@@ -56,6 +56,7 @@ export const ChatRequestBodySchema = z.object({
   creditSource: z.enum(['personal', 'workspace']).optional(),
   creditWsId: z.string().trim().min(1).max(MAX_ID_LENGTH).optional(),
   observabilityContext: z.array(z.record(z.string(), z.unknown())).optional(),
+  persistenceRequestId: z.string().trim().uuid().optional(),
   taskBoardContext: TaskBoardContextSchema.optional(),
 });
 

package/src/chat/google/request-persistence-lease.ts

@@ -0,0 +1,218 @@
+import { NextResponse } from 'next/server';
+
+type RpcError = { message: string };
+
+type PrivateRpcClient = {
+  schema: (schema: 'private') => {
+    rpc: (
+      name: string,
+      args: Record<string, unknown>
+    ) => PromiseLike<{ data: unknown; error: RpcError | null }>;
+  };
+};
+
+type PersistenceSource = 'Mira' | 'Rewise';
+
+export type PersistenceLease = {
+  leaseToken: string;
+  retryAfterSeconds: number;
+  state: 'active' | 'claimed' | 'completed';
+};
+
+export type ClaimedPersistenceLease = Pick<PersistenceLease, 'leaseToken'> & {
+  chatId: string;
+  requestId: string;
+};
+
+function parseClaimResult(data: unknown, leaseToken: string): PersistenceLease {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error('Invalid AI persistence lease response');
+  }
+
+  const record = data as Record<string, unknown>;
+  if (!['active', 'claimed', 'completed'].includes(String(record.state))) {
+    throw new Error('Invalid AI persistence lease state');
+  }
+
+  const retryAfterSeconds = Number(record.retryAfterSeconds);
+  return {
+    leaseToken,
+    retryAfterSeconds:
+      Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
+        ? Math.ceil(retryAfterSeconds)
+        : 0,
+    state: record.state as PersistenceLease['state'],
+  };
+}
+
+export async function claimAiPersistenceRequest({
+  chatId,
+  client,
+  content,
+  creatorId,
+  requestId,
+  source,
+}: {
+  chatId: string;
+  client: unknown;
+  content: string;
+  creatorId: string;
+  requestId: string;
+  source: PersistenceSource;
+}): Promise<PersistenceLease> {
+  const leaseToken = crypto.randomUUID();
+  const { data, error } = await (client as PrivateRpcClient)
+    .schema('private')
+    .rpc('ai_chat_claim_persistence_request', {
+      p_chat_id: chatId,
+      p_content: content,
+      p_creator_id: creatorId,
+      p_lease_token: leaseToken,
+      p_request_id: requestId,
+      p_source: source,
+    });
+
+  if (error) throw new Error(error.message);
+  return parseClaimResult(data, leaseToken);
+}
+
+export async function beginAiPersistenceRequest({
+  chatId,
+  client,
+  content,
+  creatorId,
+  requestId,
+  source,
+}: {
+  chatId: string;
+  client: unknown;
+  content: string;
+  creatorId: string;
+  requestId?: string;
+  source: PersistenceSource;
+}): Promise<
+  | { lease: ClaimedPersistenceLease; response: null }
+  | { lease: null; response: Response | null }
+> {
+  if (!requestId) return { lease: null, response: null };
+
+  const result = await claimAiPersistenceRequest({
+    chatId,
+    client,
+    content,
+    creatorId,
+    requestId,
+    source,
+  });
+  if (result.state === 'active') {
+    return {
+      lease: null,
+      response: NextResponse.json(
+        {
+          code: 'ai_request_in_progress',
+          message: 'This AI request is already in progress.',
+        },
+        {
+          headers: {
+            'Retry-After': String(Math.max(1, result.retryAfterSeconds)),
+          },
+          status: 409,
+        }
+      ),
+    };
+  }
+  if (result.state === 'completed') {
+    return {
+      lease: null,
+      response: NextResponse.json(
+        {
+          code: 'ai_request_completed',
+          message: 'This AI request has already completed.',
+        },
+        { status: 409 }
+      ),
+    };
+  }
+
+  return {
+    lease: { chatId, leaseToken: result.leaseToken, requestId },
+    response: null,
+  };
+}
+
+async function updateAiPersistenceRequest(
+  client: unknown,
+  rpcName:
+    | 'ai_chat_complete_persistence_request'
+    | 'ai_chat_release_persistence_request',
+  lease: ClaimedPersistenceLease
+): Promise<boolean> {
+  const { data, error } = await (client as PrivateRpcClient)
+    .schema('private')
+    .rpc(rpcName, {
+      p_chat_id: lease.chatId,
+      p_lease_token: lease.leaseToken,
+      p_request_id: lease.requestId,
+    });
+
+  if (error) throw new Error(error.message);
+  return data === true;
+}
+
+export function completeAiPersistenceRequest(
+  client: unknown,
+  lease: ClaimedPersistenceLease
+) {
+  return updateAiPersistenceRequest(
+    client,
+    'ai_chat_complete_persistence_request',
+    lease
+  );
+}
+
+export function releaseAiPersistenceRequest(
+  client: unknown,
+  lease: ClaimedPersistenceLease
+) {
+  return updateAiPersistenceRequest(
+    client,
+    'ai_chat_release_persistence_request',
+    lease
+  );
+}
+
+export function createAiPersistenceFinisher<Response>({
+  client,
+  lease,
+  onSettled,
+  persist,
+}: {
+  client: unknown;
+  lease: ClaimedPersistenceLease | null;
+  onSettled: () => void;
+  persist: (response: Response) => Promise<boolean>;
+}) {
+  let handled = false;
+
+  return async (response: Response): Promise<void> => {
+    if (handled) return;
+    handled = true;
+
+    try {
+      const persisted = await persist(response);
+      if (lease && persisted) {
+        const completed = await completeAiPersistenceRequest(client, lease);
+        if (!completed) {
+          throw new Error('Failed to complete AI persistence request lease');
+        }
+      } else if (lease) {
+        await releaseAiPersistenceRequest(client, lease);
+      }
+      onSettled();
+    } catch (error) {
+      if (lease) await releaseAiPersistenceRequest(client, lease);
+      onSettled();
+      throw error;
+    }
+  };
+}

package/src/chat/google/route-message-preparation.ts

@@ -252,7 +252,7 @@ export async function prepareProcessedMessages(
   };
 }
 
-function extractLatestUserMessageContent(
+export function extractLatestUserMessageContent(
   processedMessages: ModelMessage[]
 ): string {
   const userMessages = processedMessages.filter(
@@ -298,6 +298,54 @@ type PersistLatestUserMessageParams = {
   source: 'Mira' | 'Rewise';
 };
 
+type RequestScopedPersistenceError = {
+  code?: string;
+  message: string;
+};
+
+export async function persistRequestScopedUserMessage({
+  chatId,
+  content,
+  creatorId,
+  findExistingMessage,
+  insertMessage,
+  requestId,
+  source,
+}: {
+  chatId: string;
+  content: string;
+  creatorId: string;
+  findExistingMessage: () => PromiseLike<{
+    data: { content: string | null; creator_id: string | null } | null;
+    error: RequestScopedPersistenceError | null;
+  }>;
+  insertMessage: () => PromiseLike<{
+    error: RequestScopedPersistenceError | null;
+  }>;
+  requestId: string;
+  source: 'Mira' | 'Rewise';
+}): Promise<{ error: RequestScopedPersistenceError | null }> {
+  const inserted = await insertMessage();
+  if (!inserted.error) return inserted;
+  if (inserted.error.code !== '23505') return inserted;
+
+  const existing = await findExistingMessage();
+  if (existing.error) return { error: existing.error };
+  if (
+    existing.data?.content === content &&
+    existing.data.creator_id === creatorId
+  ) {
+    return { error: null };
+  }
+
+  return {
+    error: {
+      code: '23505',
+      message: `Persistence request ${requestId} already belongs to another ${source} message in chat ${chatId}`,
+    },
+  };
+}
+
 export async function persistLatestUserMessage({
   processedMessages,
   chatId,

package/src/chat/google/route.ts

@@ -32,6 +32,11 @@ import { ChatRequestBodySchema, mapToUIMessages } from './chat-request-schema';
 import { systemInstruction } from './default-system-instruction';
 import { prepareMiraToolStep } from './mira-step-preparation';
 import { resolveChatReasoningSettings } from './reasoning-settings';
+import {
+  beginAiPersistenceRequest,
+  createAiPersistenceFinisher,
+  releaseAiPersistenceRequest,
+} from './request-persistence-lease';
 import {
   type AiRouteAuthResult,
   isInternalTuturuuuAiUser,
@@ -43,7 +48,9 @@ import {
 } from './route-chat-resolution';
 import { performCreditPreflight } from './route-credits';
 import {
+  extractLatestUserMessageContent,
   persistLatestUserMessage,
+  persistRequestScopedUserMessage,
   prepareProcessedMessages,
 } from './route-message-preparation';
 import { prepareMiraRuntime } from './route-mira-runtime';
@@ -102,6 +109,7 @@ export function createPOST(
 
   // Higher-order function that returns the actual request handler
   return async function handler(req: NextRequest): Promise<Response> {
+    let releaseClaimedPersistenceLease: (() => Promise<void>) | null = null;
     try {
       const sbAdmin = await createAdminClient();
       let requestBody: unknown;
@@ -141,6 +149,7 @@ export function createPOST(
         creditSource: requestedCreditSourceRaw,
         creditWsId: rawCreditWsId,
         observabilityContext,
+        persistenceRequestId,
         taskBoardContext,
       } = parsedBody.data;
       const thinkingMode = rawThinkingMode === 'thinking' ? 'thinking' : 'fast';
@@ -404,6 +413,43 @@ export function createPOST(
         processedMessages,
         chatId,
         insertChatMessage: async (args) => {
+          if (persistenceRequestId) {
+            return persistRequestScopedUserMessage({
+              chatId,
+              content: args.message,
+              creatorId: user.id,
+              findExistingMessage: async () => {
+                const { data, error } = await sbAdmin
+                  .from('ai_chat_messages')
+                  .select('content,creator_id')
+                  .eq('chat_id', chatId)
+                  .eq('role', 'USER')
+                  .contains('metadata', {
+                    requestId: persistenceRequestId,
+                    source: args.source,
+                  })
+                  .maybeSingle();
+                return { data, error };
+              },
+              insertMessage: async () => {
+                const { error } = await sbAdmin
+                  .from('ai_chat_messages')
+                  .insert({
+                    chat_id: chatId,
+                    content: args.message,
+                    creator_id: user.id,
+                    metadata: {
+                      requestId: persistenceRequestId,
+                      source: args.source,
+                    },
+                    role: 'USER',
+                  });
+                return { error };
+              },
+              requestId: persistenceRequestId,
+              source: args.source,
+            });
+          }
           const { error } = await supabase.rpc(
             'insert_ai_chat_message' as never,
             args as never
@@ -427,8 +473,6 @@ export function createPOST(
       }
       const { cappedMaxOutput } = creditPreflight;
 
-      // Mutable ref so the render_ui preprocessor can read current steps
-      // at Zod-validation time (before the execute handler runs).
       const stepsRef: { current: unknown[] } = { current: [] };
 
       const { miraSystemPrompt, miraTools } = await prepareMiraRuntime({
@@ -480,15 +524,12 @@ export function createPOST(
         promptMessages.messages
       );
 
-      // Provider-native Google Search tool for non-Mira mode.
       const googleSearchTool = createGoogleSearchToolSet();
 
       type PrepareStep = NonNullable<
         NonNullable<Parameters<typeof streamText>[0]>['prepareStep']
       >;
       const prepareStep: PrepareStep = ({ steps }) => {
-        // Keep the mutable ref in sync so the render_ui preprocessor can
-        // read current steps during Zod validation.
         stepsRef.current = steps;
         return prepareMiraToolStep({
           steps,
@@ -501,23 +542,43 @@ export function createPOST(
         });
       };
 
-      let assistantResponsePersisted = false;
-      const persistChatAssistantResponse = async (
-        response: Parameters<typeof persistAssistantResponse>[0]['response']
-      ) => {
-        if (assistantResponsePersisted) return;
-        assistantResponsePersisted = true;
-        await persistAssistantResponse({
-          response,
-          sbAdmin,
+      const { lease: claimedLease, response: leaseResponse } =
+        await beginAiPersistenceRequest({
           chatId,
-          userId: user.id,
-          model: resolvedModelId,
-          effectiveSource,
-          wsId: billingWsId ?? normalizedWsId ?? undefined,
-          observabilityContext,
+          client: sbAdmin,
+          content: extractLatestUserMessageContent(processedMessages),
+          creatorId: user.id,
+          requestId: persistenceRequestId,
+          source: effectiveSource,
         });
-      };
+      if (leaseResponse) return leaseResponse;
+      if (claimedLease) {
+        releaseClaimedPersistenceLease = async () => {
+          await releaseAiPersistenceRequest(sbAdmin, claimedLease);
+        };
+      }
+
+      const persistChatAssistantResponse = createAiPersistenceFinisher<
+        Parameters<typeof persistAssistantResponse>[0]['response']
+      >({
+        client: sbAdmin,
+        lease: claimedLease,
+        onSettled: () => {
+          releaseClaimedPersistenceLease = null;
+        },
+        persist: (response) =>
+          persistAssistantResponse({
+            response,
+            sbAdmin,
+            chatId,
+            userId: user.id,
+            model: resolvedModelId,
+            effectiveSource,
+            wsId: billingWsId ?? normalizedWsId ?? undefined,
+            observabilityContext,
+            persistenceRequestId,
+          }),
+      });
 
       const result = streamText({
         abortSignal: req.signal,
@@ -612,6 +673,15 @@ export function createPOST(
         sendSources: true,
       });
     } catch (error) {
+      if (releaseClaimedPersistenceLease) {
+        try {
+          await releaseClaimedPersistenceLease();
+        } catch (releaseError) {
+          console.error('Failed to release AI persistence request lease.', {
+            error: releaseError,
+          });
+        }
+      }
       if (error instanceof Error) {
         console.log(error.message);
         return NextResponse.json(

package/src/chat/google/stream-finish-persistence.ts

@@ -106,6 +106,7 @@ type PersistAssistantResponseParams = {
   model: string;
   effectiveSource: 'Mira' | 'Rewise';
   observabilityContext?: unknown;
+  persistenceRequestId?: string;
   wsId?: string;
 };
 
@@ -470,6 +471,7 @@ function buildAssistantMessageMetadata({
   inputTokens,
   model,
   observabilityContext,
+  persistenceRequestId,
   outputTokens,
   parts,
   reasoningText,
@@ -485,6 +487,7 @@ function buildAssistantMessageMetadata({
   inputTokens: number;
   model: string;
   observabilityContext?: unknown;
+  persistenceRequestId?: string;
   outputTokens: number;
   parts: Record<string, unknown>[];
   reasoningText: string;
@@ -494,6 +497,7 @@ function buildAssistantMessageMetadata({
 }) {
   return {
     source: effectiveSource,
+    ...(persistenceRequestId ? { requestId: persistenceRequestId } : {}),
     ai: {
       finishReason: response.finishReason,
       model,
@@ -526,6 +530,7 @@ function compactAssistantMessageMetadata(
   const ai = metadata.ai;
   return {
     source: metadata.source,
+    ...(metadata.requestId ? { requestId: metadata.requestId } : {}),
     ai: {
       finishReason: ai.finishReason,
       metadataCompacted: true,
@@ -568,8 +573,9 @@ export async function persistAssistantResponse({
   model,
   effectiveSource,
   observabilityContext,
+  persistenceRequestId,
   wsId,
-}: PersistAssistantResponseParams): Promise<void> {
+}: PersistAssistantResponseParams): Promise<boolean> {
   const steps = response.steps ?? [];
   const { allToolCalls, allToolResults } = collectToolData(steps);
 
@@ -579,7 +585,7 @@ export async function persistAssistantResponse({
     allToolResults.length === 0
   ) {
     console.warn('onFinish: no text and no tool calls — skipping DB save');
-    return;
+    return false;
   }
 
   const reasoningText = collectReasoningText(response);
@@ -608,6 +614,7 @@ export async function persistAssistantResponse({
     inputTokens,
     model,
     observabilityContext,
+    persistenceRequestId,
     outputTokens,
     parts,
     reasoningText,
@@ -695,7 +702,7 @@ export async function persistAssistantResponse({
         ...(searchCount > 0 ? { searchCount } : {}),
         error,
       });
-      return;
+      return true;
     }
 
     if (!deductionResult.success) {
@@ -707,7 +714,7 @@ export async function persistAssistantResponse({
         ...(searchCount > 0 ? { searchCount } : {}),
         deductionResult,
       });
-      return;
+      return true;
     }
 
     console.info('AI credits deducted for assistant response.', {
@@ -719,4 +726,6 @@ export async function persistAssistantResponse({
       deductionResult,
     });
   }
+
+  return true;
 }

package/src/core.ts

@@ -1,3 +1 @@
 export * from 'ai';
-export * as ChatSDK from 'chat';
-export * as ChatSDKAI from 'chat/ai';

package/src/credits/constants.ts

@@ -9,6 +9,7 @@ export const AI_FEATURES = [
   'email_draft',
   'image_generation',
   'embeddings',
+  'voice_live',
 ] as const;
 
 export type AiFeature = (typeof AI_FEATURES)[number];

package/src/live/usage.ts

@@ -0,0 +1,59 @@
+import { CREDIT_UNIT_USD } from '../credits/constants';
+
+export interface GeminiLiveUsageSnapshot {
+  inputAudioTokens: number;
+  inputImageTokens: number;
+  inputTextTokens: number;
+  inputVideoTokens: number;
+  outputAudioTokens: number;
+  outputTextTokens: number;
+  searchQueries: number;
+  thinkingTokens: number;
+}
+
+export interface GeminiLivePrice {
+  inputAudioPerMillion: number;
+  inputImageVideoPerMillion: number;
+  inputTextPerMillion: number;
+  outputAudioPerMillion: number;
+  outputTextPerMillion: number;
+  searchPerQuery: number;
+}
+
+export const GEMINI_3_1_FLASH_LIVE_PRICE: GeminiLivePrice = {
+  inputAudioPerMillion: 3,
+  inputImageVideoPerMillion: 1,
+  inputTextPerMillion: 0.75,
+  outputAudioPerMillion: 12,
+  outputTextPerMillion: 4.5,
+  searchPerQuery: 0.014,
+};
+
+export function calculateGeminiLiveCost(
+  usage: GeminiLiveUsageSnapshot,
+  price: GeminiLivePrice = GEMINI_3_1_FLASH_LIVE_PRICE
+) {
+  return (
+    (usage.inputTextTokens * price.inputTextPerMillion) / 1_000_000 +
+    (usage.inputAudioTokens * price.inputAudioPerMillion) / 1_000_000 +
+    ((usage.inputImageTokens + usage.inputVideoTokens) *
+      price.inputImageVideoPerMillion) /
+      1_000_000 +
+    ((usage.outputTextTokens + usage.thinkingTokens) *
+      price.outputTextPerMillion) /
+      1_000_000 +
+    (usage.outputAudioTokens * price.outputAudioPerMillion) / 1_000_000 +
+    usage.searchQueries * price.searchPerQuery
+  );
+}
+
+export function calculateGeminiLiveCredits(
+  usage: GeminiLiveUsageSnapshot,
+  markupMultiplier = 1,
+  price: GeminiLivePrice = GEMINI_3_1_FLASH_LIVE_PRICE
+) {
+  const costUsd = calculateGeminiLiveCost(usage, price);
+  return costUsd === 0
+    ? 0
+    : Math.max(1, (costUsd / CREDIT_UNIT_USD) * markupMultiplier);
+}

package/src/studio/metering.ts

@@ -16,6 +16,63 @@ export type AiStudioUsageCost = {
   providerCostUsd: number;
 };
 
+export type AiStudioRunStepKind = 'grader' | 'model' | 'system' | 'tool';
+
+export type RecordAiStudioRunStepInput = {
+  billedCredits?: number;
+  completedAt?: string | null;
+  errorClass?: string | null;
+  inputTokens?: number;
+  kind: AiStudioRunStepKind;
+  latencyMs?: number | null;
+  metadata?: Json;
+  modelId?: string | null;
+  name: string;
+  outputTokens?: number;
+  providerCostUsd?: number;
+  runId: string;
+  sequence: number;
+  startedAt?: string;
+  status: 'aborted' | 'failed' | 'running' | 'succeeded';
+};
+
+export async function recordAiStudioRunStep(
+  input: RecordAiStudioRunStepInput
+): Promise<void> {
+  const sbAdmin = await createAdminClient({ noCookie: true });
+  const { error } = await sbAdmin
+    .schema('private')
+    .from('ai_studio_run_steps')
+    .upsert(
+      {
+        billed_credits: input.billedCredits ?? 0,
+        completed_at: input.completedAt ?? new Date().toISOString(),
+        error_class: input.errorClass ?? null,
+        input_tokens: input.inputTokens ?? 0,
+        kind: input.kind,
+        latency_ms: input.latencyMs ?? null,
+        metadata: input.metadata ?? {},
+        model_id: input.modelId ?? null,
+        name: input.name,
+        output_tokens: input.outputTokens ?? 0,
+        provider_cost_usd: input.providerCostUsd ?? 0,
+        run_id: input.runId,
+        sequence: input.sequence,
+        started_at: input.startedAt ?? new Date().toISOString(),
+        status: input.status,
+      },
+      { onConflict: 'run_id,sequence' }
+    );
+
+  if (error) {
+    console.warn('Failed to record AI Studio run step', {
+      code: error.code,
+      runId: input.runId,
+      sequence: input.sequence,
+    });
+  }
+}
+
 export type CalculateAiStudioUsageCostInput = {
   imageCount?: number;
   inputTokens?: number;
@@ -131,7 +188,10 @@ export async function beginAiStudioRun(
 }
 
 export type BeginExternalAiStudioRunInput = {
-  actorId: string;
+  /** Null for machine credentials, which run without a user. */
+  actorId: string | null;
+  /** Set when a bound API key authenticated the request, for rotation traceability. */
+  apiKeyId?: string | null;
   externalAppId: string;
   feature: string;
   idempotencyKey?: string | null;
@@ -148,13 +208,18 @@ export async function beginExternalAiStudioRun(
   const { data, error } = await sbAdmin
     .schema('private')
     .rpc('begin_external_ai_studio_run', {
+      p_api_key_id: input.apiKeyId ?? undefined,
       p_external_app_id: input.externalAppId,
       p_feature: input.feature,
       p_idempotency_key: input.idempotencyKey ?? undefined,
       p_metadata: input.metadata,
       p_model_id: input.modelId,
       p_request_id: input.requestId,
-      p_user_id: input.actorId,
+      // Explicit null, never undefined: p_user_id has no default, so omitting it
+      // makes PostgREST fail to resolve the function. A machine credential
+      // genuinely has no user, and the column accepts NULL — the generated RPC
+      // types just cannot express a nullable argument.
+      p_user_id: input.actorId as unknown as string,
       p_ws_id: input.workspaceId,
     });
 
@@ -207,6 +272,11 @@ export async function settleAiStudioRun(
     });
 
   if (error || !data?.[0]?.success) {
+    console.error('AI Studio settlement RPC failed', {
+      code: error?.code ?? null,
+      errorCode: data?.[0]?.error_code ?? null,
+      runId: input.runId,
+    });
     throw new AiStudioError('AI usage could not be settled.', {
       code: 'server_error',
       status: 500,
@@ -215,8 +285,20 @@ export async function settleAiStudioRun(
   }
 }
 
+export type SettleExternalAiStudioRunInput = Omit<
+  SettleAiStudioRunInput,
+  'actualCredits'
+> & {
+  /**
+   * What this run would have billed had it been metered. Recorded, not charged,
+   * so an app's consumption of its unmetered allocation is a reportable number
+   * rather than an invisible zero.
+   */
+  unmeteredCredits?: number;
+};
+
 export async function settleExternalAiStudioRun(
-  input: Omit<SettleAiStudioRunInput, 'actualCredits'>
+  input: SettleExternalAiStudioRunInput
 ): Promise<void> {
   const sbAdmin = await createAdminClient({ noCookie: true });
   const { data, error } = await sbAdmin
@@ -235,9 +317,15 @@ export async function settleExternalAiStudioRun(
       p_reasoning_tokens: input.reasoningTokens ?? 0,
       p_run_id: input.runId,
       p_status: input.status,
+      p_unmetered_credits: Math.max(0, input.unmeteredCredits ?? 0),
     });
 
   if (error || !data?.[0]?.success) {
+    console.error('External-app AI Studio settlement RPC failed', {
+      code: error?.code ?? null,
+      errorCode: data?.[0]?.error_code ?? null,
+      runId: input.runId,
+    });
     throw new AiStudioError('External-app AI usage could not be settled.', {
       code: 'server_error',
       status: 500,