@tuturuuu/ai 0.13.0 → 0.15.0

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

@@ -1,6 +1,7 @@
-import { randomUUID } from 'node:crypto';
 import { deductAiCredits } from '@tuturuuu/ai/credits/check-credits';
 import type { CreditDeductionResult } from '../../credits/types';
+import { collectAssistantMessageParts } from './assistant-message-parts';
+import { countGoogleSearchQueries } from './google-search-usage';
 
 type UsageLike = {
   inputTokens?: number;
@@ -21,7 +22,6 @@ type UsageLike = {
   };
   reasoningTokens?: number;
 };
-
 type GroundingMetadataLike = {
   webSearchQueries?: string[];
 };
@@ -51,6 +51,7 @@ type SourceLike = {
 };
 
 type StepLike = {
+  content?: readonly unknown[];
   text?: string;
   toolCalls?: ReadonlyArray<ToolCallLike>;
   toolResults?: ReadonlyArray<ToolResultLike>;
@@ -248,105 +249,6 @@ function logGoogleSearchDebug(response: StreamFinishResponseLike): void {
   }
 }
 
-function countGoogleSearchQueries(
-  response: StreamFinishResponseLike,
-  allToolCalls: ToolCallLike[]
-): number {
-  const customGoogleSearchCalls = allToolCalls.filter(
-    (toolCall) => toolCall.toolName === 'google_search'
-  ).length;
-  if (customGoogleSearchCalls > 0) return customGoogleSearchCalls;
-
-  const topQueries =
-    response.providerMetadata?.google?.groundingMetadata?.webSearchQueries;
-  if (topQueries?.length) return topQueries.length;
-
-  let perStepQueriesCount = 0;
-  for (const step of response.steps ?? []) {
-    const stepQueries =
-      step.providerMetadata?.google?.groundingMetadata?.webSearchQueries;
-    if (stepQueries?.length) {
-      perStepQueriesCount += stepQueries.length;
-    }
-  }
-  if (perStepQueriesCount > 0) return perStepQueriesCount;
-
-  if (Array.isArray(response.sources) && response.sources.length > 0) {
-    return 1;
-  }
-
-  return 0;
-}
-
-function collectUiMessageParts({
-  allToolCalls,
-  allToolResults,
-  reasoningText,
-  response,
-  serializedSources,
-}: {
-  allToolCalls: ToolCallLike[];
-  allToolResults: ToolResultLike[];
-  reasoningText: string;
-  response: StreamFinishResponseLike;
-  serializedSources: ReturnType<typeof collectSerializableSources>;
-}) {
-  const parts: Record<string, unknown>[] = [];
-
-  if (response.text) {
-    parts.push({ type: 'text', text: response.text });
-  }
-
-  if (reasoningText) {
-    parts.push({ type: 'reasoning', text: reasoningText });
-  }
-
-  for (const toolCall of allToolCalls) {
-    const toolCallId =
-      toolCall.toolCallId ?? readString(toolCall.toolCallId) ?? undefined;
-    const matchingResult = allToolResults.find(
-      (result) => toolCallId && readString(result.toolCallId) === toolCallId
-    );
-    parts.push({
-      type: 'dynamic-tool',
-      toolName: toolCall.toolName ?? matchingResult?.toolName ?? 'tool',
-      toolCallId: toolCallId ?? randomUUID(),
-      state: 'output-available',
-      input: extractToolInput(toolCall),
-      output: matchingResult ? extractToolOutput(matchingResult) : null,
-    });
-  }
-
-  for (const toolResult of allToolResults) {
-    const hasCall = allToolCalls.some(
-      (toolCall) =>
-        readString(toolCall.toolCallId) &&
-        readString(toolCall.toolCallId) === readString(toolResult.toolCallId)
-    );
-    if (hasCall) continue;
-
-    parts.push({
-      type: 'dynamic-tool',
-      toolName: toolResult.toolName ?? 'tool',
-      toolCallId: toolResult.toolCallId ?? randomUUID(),
-      state: 'output-available',
-      output: extractToolOutput(toolResult),
-    });
-  }
-
-  for (const source of serializedSources) {
-    if (!source.url) continue;
-    parts.push({
-      type: 'source-url',
-      sourceId: source.sourceId ?? source.url,
-      title: source.title,
-      url: source.url,
-    });
-  }
-
-  return parts;
-}
-
 export function buildAbortedStreamFinishResponse(
   steps: ReadonlyArray<StepLike>
 ): StreamFinishResponseLike {
@@ -386,14 +288,6 @@ function sumStepUsage(steps: ReadonlyArray<StepLike>): UsageLike {
   );
 }
 
-function extractToolInput(toolCall: ToolCallLike) {
-  return toolCall.input ?? toolCall.args ?? toolCall.arguments ?? {};
-}
-
-function extractToolOutput(toolResult: ToolResultLike) {
-  return toolResult.output ?? toolResult.result ?? toolResult;
-}
-
 function readString(value: unknown) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -419,7 +313,7 @@ function compactJsonValue(value: unknown, maxLength = 400): unknown {
   }
 }
 
-function compactAiMessagePart(part: Record<string, unknown>) {
+function compactAiMessagePart(part: Record<string, unknown>, limit = 400) {
   const type = readString(part.type) ?? 'unknown';
 
   if (type === 'text' || type === 'reasoning') {
@@ -427,7 +321,7 @@ function compactAiMessagePart(part: Record<string, unknown>) {
       ...part,
       text:
         typeof part.text === 'string'
-          ? truncateString(part.text, 4000)
+          ? truncateString(part.text, limit)
           : part.text,
     };
   }
@@ -438,11 +332,11 @@ function compactAiMessagePart(part: Record<string, unknown>) {
       toolName: part.toolName,
       toolCallId: part.toolCallId,
       state: part.state,
-      input: compactJsonValue(part.input),
-      output: compactJsonValue(part.output),
+      input: compactJsonValue(part.input, limit),
+      output: compactJsonValue(part.output, limit),
       errorText:
         typeof part.errorText === 'string'
-          ? truncateString(part.errorText, 1200)
+          ? truncateString(part.errorText, limit)
           : part.errorText,
     };
   }
@@ -528,6 +422,22 @@ function compactAssistantMessageMetadata(
   metadata: ReturnType<typeof buildAssistantMessageMetadata>
 ) {
   const ai = metadata.ai;
+  let textOffset = 0;
+  const compactParts = ai.parts.map((part) => {
+    if (part.type === 'text' && typeof part.text === 'string') {
+      const result = {
+        type: 'text',
+        textStart: textOffset,
+        textLength: part.text.length,
+      };
+      textOffset += part.text.length + 2;
+      return result;
+    }
+    return compactAiMessagePart(
+      part,
+      Math.max(20, Math.min(400, Math.floor(1500 / ai.parts.length)))
+    );
+  });
   return {
     source: metadata.source,
     ...(metadata.requestId ? { requestId: metadata.requestId } : {}),
@@ -535,27 +445,11 @@ function compactAssistantMessageMetadata(
       finishReason: ai.finishReason,
       metadataCompacted: true,
       model: ai.model,
-      observability: {
-        contextBreakdown: Array.isArray(ai.observability.contextBreakdown)
-          ? ai.observability.contextBreakdown.slice(-20)
-          : [],
-      },
-      omittedPartCount: Math.max(0, ai.parts.length - 8),
-      parts: ai.parts
-        .slice(0, 8)
-        .map((part) =>
-          part && typeof part === 'object' && !Array.isArray(part)
-            ? compactAiMessagePart(part as Record<string, unknown>)
-            : part
-        ),
+      observability: { contextBreakdown: [] },
+      omittedPartCount: 0,
+      parts: compactParts,
       usage: ai.usage,
     },
-    ...(typeof metadata.reasoning === 'string'
-      ? { reasoning: truncateString(metadata.reasoning, 3000) }
-      : {}),
-    ...(Array.isArray(metadata.sources)
-      ? { sources: metadata.sources.slice(0, 20) }
-      : {}),
     toolCallCount: Array.isArray(metadata.toolCalls)
       ? metadata.toolCalls.length
       : 0,
@@ -579,15 +473,6 @@ export async function persistAssistantResponse({
   const steps = response.steps ?? [];
   const { allToolCalls, allToolResults } = collectToolData(steps);
 
-  if (
-    !response.text &&
-    allToolCalls.length === 0 &&
-    allToolResults.length === 0
-  ) {
-    console.warn('onFinish: no text and no tool calls — skipping DB save');
-    return false;
-  }
-
   const reasoningText = collectReasoningText(response);
   const {
     cachedInputTokens,
@@ -597,13 +482,14 @@ export async function persistAssistantResponse({
     reasoningTokens,
   } = collectUsageTotals(response);
   const serializedSources = collectSerializableSources(response);
-  const parts = collectUiMessageParts({
-    allToolCalls,
-    allToolResults,
-    reasoningText,
-    response,
-    serializedSources,
+  const parts = collectAssistantMessageParts({
+    ...response,
+    sources: serializedSources,
   });
+  if (!parts.some((part) => part.type !== 'step-start')) {
+    console.warn('onFinish: no message parts — skipping DB save');
+    return false;
+  }
 
   const metadata = buildAssistantMessageMetadata({
     allToolCalls,
@@ -626,7 +512,10 @@ export async function persistAssistantResponse({
   const insertPayload = {
     chat_id: chatId,
     creator_id: userId,
-    content: response.text || '',
+    content: parts
+      .filter((part) => part.type === 'text')
+      .map((part) => part.text)
+      .join('\n\n'),
     role: 'ASSISTANT',
     model: (model.includes('/')
       ? model.split('/').pop()!
@@ -666,7 +555,7 @@ export async function persistAssistantResponse({
   console.log('AI Response saved to database');
   logGoogleSearchDebug(response);
 
-  const searchCount = countGoogleSearchQueries(response, allToolCalls);
+  const searchCount = countGoogleSearchQueries(model, response, allToolCalls);
   if (searchCount > 0) {
     console.log(
       `Google Search grounding detected: ${searchCount} search quer${searchCount === 1 ? 'y' : 'ies'}`

package/src/chat/mira-artifact-intent.ts

@@ -0,0 +1,38 @@
+import type { ModelMessage } from 'ai';
+
+/** Route explicit product presentation to native panels, including follow-ups. */
+export function shouldPresentWorkspaceArtifact(
+  messages: ModelMessage[]
+): boolean {
+  const userTexts = messages
+    .filter((message) => message.role === 'user')
+    .map((message) =>
+      (typeof message.content === 'string'
+        ? message.content
+        : message.content
+            .filter((part) => part.type === 'text')
+            .map((part) => part.text)
+            .join(' ')
+      )
+        .normalize('NFD')
+        .replace(/\p{Diacritic}/gu, '')
+        .toLowerCase()
+    );
+  const latest = userTexts.at(-1) ?? '';
+  if (
+    /\b((?:don't|do not) (?:show|open|display|present|see|view)|(?:can't|cannot) (?:see|view)|without (?:(?:any|an?) )?(?:artifacts?|panels?)|(?:no|not)(?: (?:in|as))?(?: an?)? (?:artifacts?|panels?)|text[-\s]+only|chat[-\s]+only|how (do|can|to))\b|\bkhong (?:mo|hien thi|xem)\b/u.test(
+      latest
+    )
+  )
+    return false;
+  const product =
+    /\b(tasks?|to[-\s]?dos?|calendars?|schedules?|agendas?|finances?|wallets?|transactions?|meetings?|cong viec|lich|tai chinh|cuoc hop)\b/u;
+  const present =
+    /\b(show|display|present|open|view|see|hien thi|cho (toi|minh) xem|mo)\b/u;
+  if (present.test(latest) && product.test(latest)) return true;
+  return (
+    /\b(artifact|panel)\b/u.test(latest) &&
+    (present.test(latest) || /\b(should|instead)\b/u.test(latest)) &&
+    userTexts.slice(-4).some((text) => product.test(text))
+  );
+}

package/src/chat/mira-prompt.ts

@@ -0,0 +1,29 @@
+import { buildMiraContext } from '../tools/context-builder';
+import type { MiraWorkspaceContextState } from '../tools/workspace-context';
+import { buildMiraSystemInstruction } from './mira-system-instruction';
+
+/** The shared identity, memory, workspace and behavior prompt for Chat and Live. */
+export async function buildMiraPrompt({
+  workspaceContext,
+  taskBoardInstruction,
+  ...options
+}: Parameters<typeof buildMiraContext>[0] & {
+  workspaceContext: MiraWorkspaceContextState;
+  taskBoardInstruction?: string | null;
+}): Promise<string> {
+  const { contextString, soul, isFirstInteraction } =
+    await buildMiraContext(options);
+  const workspaceInstruction = `## Workspace Context\n\nCurrent task/calendar/finance workspace context: ${workspaceContext.name} (${workspaceContext.personal ? 'personal' : 'shared'} workspace).\nUse this workspace for "my tasks", "my calendar", and "my finance" requests. Only switch to another workspace when the user explicitly names a different workspace.`;
+  return [
+    contextString,
+    workspaceInstruction,
+    taskBoardInstruction,
+    buildMiraSystemInstruction({
+      soul,
+      isFirstInteraction,
+      withoutPermission: options.withoutPermission,
+    }),
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}

package/src/chat/mira-render-ui-policy.ts

@@ -1,4 +1,5 @@
 import type { ModelMessage } from 'ai';
+import { isGoogleSearchToolName } from '../tools/google-search-events';
 
 type ToolStepLike = {
   toolCalls?: Array<{
@@ -229,6 +230,15 @@ function hasExplicitWorkspaceQualifier(text: string): boolean {
 
   const normalizedCandidate = normalizeWorkspaceQualifierCandidate(candidate);
   if (!normalizedCandidate) return false;
+  // Explicit workspace naming wins over presentation-destination heuristics.
+  if (/\bworkspace\b/u.test(normalizedCandidate)) return true;
+  // A presentation destination is not a named workspace.
+  if (
+    /^(?:(?:the|an?|my)\s+)?(?:(?:tasks?|calendar|finance|meetings?)\s+)?(?:panels?|artifacts?|chat|sidebar|views?|screen)\b/u.test(
+      normalizedCandidate
+    )
+  )
+    return false;
   if (DISALLOWED_WORKSPACE_QUALIFIERS.has(normalizedCandidate)) return false;
 
   return true;
@@ -386,6 +396,20 @@ export function shouldForceWorkspaceMembersForLatestUserMessage(
   return false;
 }
 
+function selectedNames(output: Record<string, unknown> | undefined): string[] {
+  if (Array.isArray(output?.selectedTools)) {
+    return output.selectedTools.filter(
+      (name): name is string => typeof name === 'string'
+    );
+  }
+  if (Array.isArray(output?.tools)) {
+    return output.tools.flatMap((entry) =>
+      isRecord(entry) && typeof entry.name === 'string' ? [entry.name] : []
+    );
+  }
+  return [];
+}
+
 export function extractSelectedToolsFromSteps(steps: unknown[]): string[] {
   for (let i = steps.length - 1; i >= 0; i--) {
     const step = steps[i] as ToolStepLike | undefined;
@@ -397,15 +421,10 @@ export function extractSelectedToolsFromSteps(steps: unknown[]): string[] {
       return tools.filter((tool): tool is string => typeof tool === 'string');
     }
 
-    const selectResult = step?.toolResults?.find(
-      (toolResult) => toolResult.toolName === 'select_tools'
-    );
-    const selectedTools = selectResult?.output?.selectedTools;
-    if (Array.isArray(selectedTools)) {
-      return selectedTools.filter(
-        (tool): tool is string => typeof tool === 'string'
-      );
-    }
+    const selectResult =
+      step?.toolResults?.find((result) => result.toolName === 'select_tools') ??
+      step?.toolResults?.find((result) => result.toolName === 'search_tools');
+    if (selectResult) return selectedNames(selectResult.output);
   }
   return [];
 }
@@ -429,12 +448,12 @@ export function wasToolEverSelectedInSteps(
     if (fromCalls) return true;
 
     return (typedStep?.toolResults ?? []).some((toolResult) => {
-      if (toolResult.toolName !== 'select_tools') return false;
-      const selected = toolResult.output?.selectedTools;
-      return (
-        Array.isArray(selected) &&
-        selected.some((tool) => typeof tool === 'string' && tool === toolName)
-      );
+      if (
+        toolResult.toolName !== 'select_tools' &&
+        toolResult.toolName !== 'search_tools'
+      )
+        return false;
+      return selectedNames(toolResult.output).includes(toolName);
     });
   });
 }
@@ -443,13 +462,17 @@ export function hasToolCallInSteps(
   steps: unknown[],
   toolName: string
 ): boolean {
+  const matches = (name: string | undefined) =>
+    toolName === 'google_search'
+      ? isGoogleSearchToolName(name)
+      : name === toolName;
   return steps.some((step) => {
     const typedStep = step as ToolStepLike | undefined;
-    const called = (typedStep?.toolCalls ?? []).some(
-      (toolCall) => toolCall.toolName === toolName
+    const called = (typedStep?.toolCalls ?? []).some((toolCall) =>
+      matches(toolCall.toolName)
     );
-    const hasResult = (typedStep?.toolResults ?? []).some(
-      (toolResult) => toolResult.toolName === toolName
+    const hasResult = (typedStep?.toolResults ?? []).some((toolResult) =>
+      matches(toolResult.toolName)
     );
     return called || hasResult;
   });
@@ -516,7 +539,8 @@ export function countRenderUiAttemptsInSteps(steps: unknown[]): number {
 export function buildActiveToolsFromSelected(
   selectedTools: string[]
 ): string[] {
-  if (selectedTools.length === 0) return ['select_tools', 'no_action_needed'];
+  if (selectedTools.length === 0)
+    return ['search_tools', 'select_tools', 'no_action_needed'];
 
   const unique = Array.from(new Set(selectedTools));
   const includesNoAction = unique.includes('no_action_needed');
@@ -526,6 +550,7 @@ export function buildActiveToolsFromSelected(
       (toolName) =>
         toolName !== 'select_tools' && toolName !== 'no_action_needed'
     ),
+    'search_tools',
     'select_tools',
     ...(includesNoAction ? ['no_action_needed'] : []),
   ];
@@ -538,3 +563,23 @@ export function removeWorkspaceDiscoveryTools(selectedTools: string[]) {
     (toolName) => !WORKSPACE_DISCOVERY_TOOL_NAMES.has(toolName)
   );
 }
+
+/** A dispatched UI command is complete only after an acknowledged success. */
+export function getWorkspaceArtifactProgress(steps: unknown[]) {
+  let attempts = 0;
+  let completed = false;
+  for (const step of steps) {
+    const value = step as ToolStepLike | undefined;
+    const calls = (value?.toolCalls ?? []).filter(
+      (call) => call.toolName === 'show_workspace_artifact'
+    );
+    const results = (value?.toolResults ?? []).filter(
+      (result) => result.toolName === 'show_workspace_artifact'
+    );
+    attempts += Math.max(calls.length, results.length);
+    completed ||= results.some(
+      (result) => result.output?.success === true && !result.output.error
+    );
+  }
+  return { attempts, completed };
+}