@meistrari/chat-nuxt 1.3.0 → 1.5.0

package/dist/runtime/server/utils/conversation-message-sync.js

@@ -0,0 +1,132 @@
+import { schema } from "#chat-runtime/server/db";
+import { extractContentFromSession } from "#chat-runtime/server/utils/agent-api";
+import { logger } from "#chat-runtime/server/utils/logger";
+function toMilliseconds(timestamp) {
+  if (typeof timestamp !== "number" || !Number.isFinite(timestamp))
+    return null;
+  return timestamp < 1e10 ? timestamp * 1e3 : timestamp;
+}
+export function mapAgentApiSessionToMessageUpdate(agentSession, options) {
+  const updateData = {};
+  const lastSyncedUuid = options.lastAssistantMessage?.externalUuid;
+  const lastSyncedIndex = lastSyncedUuid ? agentSession.reasoning?.findIndex((item) => item.uuid === lastSyncedUuid) ?? -1 : -1;
+  const newReasoning = agentSession.reasoning?.slice(lastSyncedIndex + 1);
+  const hasNewReasoning = newReasoning && newReasoning.length > 0;
+  const sessionUpdatedAtMs = toMilliseconds(agentSession.updatedAt);
+  const terminalSessionBelongsToPendingMessage = hasNewReasoning || !options.lastAssistantMessage || sessionUpdatedAtMs !== null && sessionUpdatedAtMs >= options.pendingMessage.createdAt.getTime();
+  if (hasNewReasoning) {
+    updateData.reasoningData = newReasoning;
+    const lastReasoningItem = newReasoning.at(-1);
+    if (lastReasoningItem?.uuid) {
+      updateData.externalUuid = lastReasoningItem.uuid;
+    }
+    if (!options.pendingMessage.ttft && options.userMessage) {
+      const now = options.now ?? /* @__PURE__ */ new Date();
+      updateData.ttft = String(now.getTime() - options.userMessage.createdAt.getTime());
+    }
+  }
+  if (agentSession.status === "completed" || agentSession.status === "waiting_messages") {
+    if (terminalSessionBelongsToPendingMessage) {
+      updateData.content = extractContentFromSession(agentSession);
+      updateData.status = "completed";
+      updateData.updatedAt = options.now ?? /* @__PURE__ */ new Date();
+    }
+  } else if (agentSession.status === "failed") {
+    const errorContent = agentSession.error || "Agent execution failed";
+    updateData.content = `Error: ${errorContent}`;
+    updateData.status = "failed";
+    updateData.updatedAt = options.now ?? /* @__PURE__ */ new Date();
+  }
+  return updateData;
+}
+export function hasMessageUpdate(updateData) {
+  return Object.keys(updateData).length > 0;
+}
+export function isTerminalMessageUpdate(updateData) {
+  return updateData.status === "completed" || updateData.status === "failed";
+}
+export function buildMessageUpdateResponse(messages, messageId, updateData) {
+  const updatedMessages = messages.map(
+    (message) => message.id === messageId ? { ...message, ...updateData } : message
+  );
+  if (updateData.files && updateData.files.length > 0) {
+    return {
+      messages: updatedMessages,
+      newFiles: updateData.files
+    };
+  }
+  return { messages: updatedMessages };
+}
+export function trackTelaAgentConversationUsage(db, context, conversationId, sessionId, usage) {
+  if (!usage)
+    return;
+  void db.insert(schema.conversationUsage).values({
+    workspaceId: context.workspaceId,
+    conversationId,
+    ...usage,
+    userId: context.user.id,
+    userEmail: context.user.email ?? null,
+    sessionId
+  }).onConflictDoUpdate({
+    target: schema.conversationUsage.conversationId,
+    set: {
+      ...usage,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  }).catch((error) => {
+    logger.warn({ conversationId, error }, "Failed to track conversation usage");
+  });
+}
+export function trackAgentApiConversationUsage(db, context, conversationId, sessionId, agentSession) {
+  const usage = agentSession.result?.usage;
+  if (!usage)
+    return;
+  const breakdown = agentSession.result?.usageBreakdown;
+  const serverToolUse = breakdown?.serverToolUse;
+  const webSearchRequests = typeof serverToolUse?.web_search_requests === "number" ? serverToolUse.web_search_requests : null;
+  const webFetchRequests = typeof serverToolUse?.web_fetch_requests === "number" ? serverToolUse.web_fetch_requests : null;
+  void db.insert(schema.conversationUsage).values({
+    workspaceId: context.workspaceId,
+    conversationId,
+    promptTokens: usage.promptTokens ?? 0,
+    completionTokens: usage.completionTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0,
+    promptCost: String(usage.promptCost ?? 0),
+    completionCost: String(usage.completionCost ?? 0),
+    totalCost: String(usage.totalCost ?? 0),
+    durationMs: usage.duration ?? null,
+    turns: usage.turns ?? null,
+    userId: context.user.id,
+    userEmail: context.user.email ?? null,
+    model: agentSession.model ?? null,
+    sessionId,
+    cacheReadInputTokens: breakdown?.cacheReadInputTokens ?? null,
+    cacheCreationInputTokens: breakdown?.cacheCreationInputTokens ?? null,
+    modelUsage: breakdown?.modelUsage ?? null,
+    durationApiMs: breakdown?.durationApiMs ?? null,
+    webSearchRequests,
+    webFetchRequests
+  }).onConflictDoUpdate({
+    target: schema.conversationUsage.conversationId,
+    set: {
+      promptTokens: usage.promptTokens ?? 0,
+      completionTokens: usage.completionTokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0,
+      promptCost: String(usage.promptCost ?? 0),
+      completionCost: String(usage.completionCost ?? 0),
+      totalCost: String(usage.totalCost ?? 0),
+      durationMs: usage.duration ?? null,
+      turns: usage.turns ?? null,
+      model: agentSession.model ?? null,
+      cacheReadInputTokens: breakdown?.cacheReadInputTokens ?? null,
+      cacheCreationInputTokens: breakdown?.cacheCreationInputTokens ?? null,
+      modelUsage: breakdown?.modelUsage ?? null,
+      durationApiMs: breakdown?.durationApiMs ?? null,
+      webSearchRequests,
+      webFetchRequests,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  }).catch((error) => {
+    logger.warn({ conversationId, error }, "Failed to track conversation usage");
+  });
+}

package/dist/runtime/server/utils/conversation-scope.d.ts

@@ -0,0 +1,2 @@
+import type { ChatRuntimeContext } from '#chat-runtime/server/utils/chat-context';
+export declare function conversationScopeConditions(context: ChatRuntimeContext, conversationId?: string): import("drizzle-orm").SQL<unknown> | undefined;

package/dist/runtime/server/utils/conversation-scope.js

@@ -0,0 +1,12 @@
+import { and, eq, isNull } from "drizzle-orm";
+import { schema } from "#chat-runtime/server/db";
+export function conversationScopeConditions(context, conversationId) {
+  const conditions = [
+    eq(schema.conversations.workspaceId, context.workspaceId),
+    context.telaAgentId ? eq(schema.conversations.telaAgentId, context.telaAgentId) : isNull(schema.conversations.telaAgentId)
+  ];
+  if (conversationId) {
+    conditions.unshift(eq(schema.conversations.id, conversationId));
+  }
+  return and(...conditions);
+}

package/dist/runtime/server/utils/tela-agent-api.d.ts

@@ -0,0 +1,29 @@
+import type { H3Event } from 'h3';
+import type { TelaAgent, TelaAgentRunPayload, TelaAgentSession } from '#chat-runtime/types/tela-agent';
+export declare function runTelaAgent(event: H3Event, agentId: string, payload: TelaAgentRunPayload): Promise<{
+    success: true;
+    sessionId: string;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function getTelaAgent(event: H3Event, agentId: string): Promise<{
+    success: true;
+    data: TelaAgent;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function getTelaAgentSession(event: H3Event, sessionId: string): Promise<{
+    success: true;
+    data: TelaAgentSession;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function endTelaAgentSession(event: H3Event, sessionId: string): Promise<{
+    success: true;
+} | {
+    success: false;
+    error: string;
+}>;

package/dist/runtime/server/utils/tela-agent-api.js

@@ -0,0 +1,107 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import {
+  telaAgentApiResponseSchema,
+  telaAgentEndSessionApiResponseSchema,
+  telaAgentRunApiResponseSchema,
+  telaAgentSessionApiResponseSchema
+} from "#chat-runtime/types/tela-agent";
+import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
+import { logger } from "#chat-runtime/server/utils/logger";
+function getTelaErrorMessage(body, fallback) {
+  if (body && typeof body === "object") {
+    const record = body;
+    if (typeof record.error === "string")
+      return record.error;
+    if (typeof record.message === "string")
+      return record.message;
+  }
+  return fallback;
+}
+async function readResponseBody(response) {
+  const text = await response.text();
+  if (!text)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function telaAgentFetch(event, path, init) {
+  const { telaApiUrl } = useRuntimeConfig();
+  const token = getAgentDataToken(event);
+  const url = `${telaApiUrl}${path}`;
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      "x-data-token": token,
+      "Authorization": `Bearer ${token}`,
+      ...init.headers
+    }
+  });
+  const body = await readResponseBody(response);
+  if (!response.ok) {
+    const error = getTelaErrorMessage(body, `Tela API error: ${response.status} - ${response.statusText}`);
+    logger.warn({ status: response.status, statusText: response.statusText, path }, "Tela agent API request failed");
+    return { success: false, error };
+  }
+  return { success: true, body };
+}
+export async function runTelaAgent(event, agentId, payload) {
+  const encodedAgentId = encodeURIComponent(agentId);
+  const result = await telaAgentFetch(event, `/agent/${encodedAgentId}/run`, {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  if (!result.success)
+    return result;
+  const parsed = telaAgentRunApiResponseSchema.safeParse(result.body);
+  if (!parsed.success) {
+    logger.warn({ issues: parsed.error.issues }, "Tela agent run response parse error");
+    return { success: false, error: "Invalid response from Tela API" };
+  }
+  return { success: true, sessionId: parsed.data.data.sessionId };
+}
+export async function getTelaAgent(event, agentId) {
+  const encodedAgentId = encodeURIComponent(agentId);
+  const result = await telaAgentFetch(event, `/agent/${encodedAgentId}`, {
+    method: "GET"
+  });
+  if (!result.success)
+    return result;
+  const parsed = telaAgentApiResponseSchema.safeParse(result.body);
+  if (!parsed.success) {
+    logger.warn({ issues: parsed.error.issues, agentId }, "Tela agent metadata response parse error");
+    return { success: false, error: "Invalid agent metadata response from Tela API" };
+  }
+  return { success: true, data: parsed.data.data };
+}
+export async function getTelaAgentSession(event, sessionId) {
+  const encodedSessionId = encodeURIComponent(sessionId);
+  const result = await telaAgentFetch(event, `/agent/sessions/${encodedSessionId}`, {
+    method: "GET"
+  });
+  if (!result.success)
+    return result;
+  const parsed = telaAgentSessionApiResponseSchema.safeParse(result.body);
+  if (!parsed.success) {
+    logger.warn({ issues: parsed.error.issues, sessionId }, "Tela agent session response parse error");
+    return { success: false, error: "Invalid session response from Tela API" };
+  }
+  return { success: true, data: parsed.data.data };
+}
+export async function endTelaAgentSession(event, sessionId) {
+  const encodedSessionId = encodeURIComponent(sessionId);
+  const result = await telaAgentFetch(event, `/agent/sessions/${encodedSessionId}`, {
+    method: "DELETE"
+  });
+  if (!result.success)
+    return result;
+  const parsed = telaAgentEndSessionApiResponseSchema.safeParse(result.body);
+  if (!parsed.success || !parsed.data.data.success) {
+    logger.warn({ sessionId }, "Tela agent end session response parse error");
+    return { success: false, error: "Invalid end-session response from Tela API" };
+  }
+  return { success: true };
+}

package/dist/runtime/server/utils/tela-agent-session.d.ts

@@ -0,0 +1,48 @@
+import type { MessageStatus, ReasoningItem } from '#chat-runtime/types/agent';
+import type { FileUploadInput, MessageFile } from '#chat-runtime/types/chat';
+import type { TelaAgentExecutionInput, TelaAgentInputVariable, TelaAgentSession, TelaAgentStep } from '#chat-runtime/types/tela-agent';
+export type TelaAgentMessageUpdate = {
+    reasoningData?: ReasoningItem[];
+    externalUuid?: string;
+    content?: string;
+    status?: MessageStatus;
+    ttft?: string;
+    updatedAt?: Date;
+    files?: MessageFile[];
+};
+export type TelaAgentUsageValues = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    promptCost: string;
+    completionCost: string;
+    totalCost: string;
+    durationMs: number | null;
+    turns: number | null;
+    model: string | null;
+    cacheReadInputTokens: number | null;
+    cacheCreationInputTokens: number | null;
+    modelUsage: null;
+    durationApiMs: null;
+    webSearchRequests: null;
+    webFetchRequests: null;
+};
+type TelaAgentFileInput = FileUploadInput | MessageFile;
+export declare function toTelaAgentInputSchema(files: TelaAgentFileInput[] | undefined, inputVariables: TelaAgentInputVariable[] | null | undefined): TelaAgentExecutionInput[];
+export declare function toTelaAgentAttachments(files: TelaAgentFileInput[] | undefined): {
+    vaultRef: string;
+    filename: any;
+}[];
+export declare function getTelaAgentStepSyncId(step: TelaAgentStep): string;
+export declare function normalizeTelaAgentReasoningStep(sessionId: string, step: TelaAgentStep): ReasoningItem | null;
+export declare function getNewTelaAgentSteps(session: TelaAgentSession, lastSyncedStepId: string | null | undefined): TelaAgentStep[];
+export declare function extractTelaAgentAssistantContent(session: TelaAgentSession, steps?: TelaAgentStep[]): string;
+export declare function mapTelaAgentSessionToMessageUpdate(session: TelaAgentSession, options?: {
+    lastSyncedStepId?: string | null;
+    existingReasoningData?: ReasoningItem[] | null;
+    pendingMessageTtft?: string | null;
+    userMessageCreatedAt?: Date | null;
+    now?: Date;
+}): TelaAgentMessageUpdate;
+export declare function mapTelaAgentUsage(session: TelaAgentSession): TelaAgentUsageValues | null;
+export {};

package/dist/runtime/server/utils/tela-agent-session.js

@@ -0,0 +1,350 @@
+import { createError } from "h3";
+import { jsonMarkdown } from "#chat-runtime/utils/markdown-nodes";
+const INTERRUPTED_GENERATION_TEXT = "_Gera\xE7\xE3o interrompida pelo usu\xE1rio_";
+const POSTGRES_NUL_BYTE = String.fromCharCode(0);
+const REASONING_TAG_PATTERN = /<reasoning>[\s\S]*?(?:<\/reasoning>|$)/g;
+const ANSWER_TAG_PATTERN = /<answer>([\s\S]*?)(?:<\/answer>|$)/;
+const MARKDOWN_HEADING_PATTERN = /(?:^|\r?\n)#{1,6}\s+\S.*$/gm;
+const BINARY_ARTIFACT_MARKERS = [
+  "%PDF-",
+  `PK${String.fromCharCode(3)}${String.fromCharCode(4)}`
+];
+function getVaultRef(file) {
+  return file.vaultReference?.trim() || (file.url.startsWith("vault://") ? file.url : null);
+}
+function requireVaultRef(file) {
+  const vaultRef = getVaultRef(file);
+  if (!vaultRef) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Tela agent attachments require vault-backed files"
+    });
+  }
+  return vaultRef;
+}
+export function toTelaAgentInputSchema(files, inputVariables) {
+  const fileInputVariables = (inputVariables ?? []).filter((input) => input.type === "file" && input.name.trim());
+  if (fileInputVariables.length !== 1)
+    return [];
+  const inputName = fileInputVariables[0].name;
+  return (files ?? []).map((file) => {
+    return {
+      type: "file",
+      name: inputName,
+      vaultRef: requireVaultRef(file),
+      filename: file.name.slice(0, 255)
+    };
+  });
+}
+export function toTelaAgentAttachments(files) {
+  return (files ?? []).map((file) => ({
+    vaultRef: requireVaultRef(file),
+    filename: file.name.slice(0, 255)
+  }));
+}
+export function getTelaAgentStepSyncId(step) {
+  return step.eventId ?? step.id;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function sanitizeText(value) {
+  return value.replaceAll(POSTGRES_NUL_BYTE, "");
+}
+function sanitizeUnknown(value) {
+  if (typeof value === "string")
+    return sanitizeText(value);
+  if (Array.isArray(value))
+    return value.map((item) => sanitizeUnknown(item));
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, sanitizeUnknown(item)])
+    );
+  }
+  return value;
+}
+function sanitizeRecord(value) {
+  return sanitizeUnknown(value);
+}
+function decodeUriSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function extractMissingVaultFileName(error) {
+  const messageMatch = /\bFile\s+(.+?)\s+not found in workspace\b/i.exec(error);
+  const messageFileName = messageMatch?.[1]?.trim();
+  if (messageFileName)
+    return sanitizeText(messageFileName);
+  const urlMatch = /\/files\/([^:\s?#]+).*?\b404\s+Not Found\b/is.exec(error);
+  const urlFileName = urlMatch?.[1]?.trim();
+  if (urlFileName)
+    return sanitizeText(decodeUriSegment(urlFileName));
+  return null;
+}
+function formatTelaAgentFailureMessage(error) {
+  const sanitizedError = sanitizeText(error ?? "Agent execution failed");
+  const missingVaultFileName = extractMissingVaultFileName(sanitizedError);
+  if (missingVaultFileName) {
+    return `Erro: O arquivo ${JSON.stringify(missingVaultFileName)} n\xE3o foi encontrado neste workspace. Envie o arquivo novamente ou confira se a refer\xEAncia do Vault pertence ao workspace atual.`;
+  }
+  return `Error: ${sanitizedError}`;
+}
+function extractTaggedAnswer(value) {
+  const match = value.match(ANSWER_TAG_PATTERN);
+  return match?.[1]?.trim() || null;
+}
+function stripTaggedReasoning(value) {
+  return value.replace(REASONING_TAG_PATTERN, "").trim();
+}
+function findBinaryArtifactStart(value) {
+  let index = -1;
+  for (const marker of BINARY_ARTIFACT_MARKERS) {
+    let searchStart = 0;
+    while (searchStart < value.length) {
+      const markerIndex = value.indexOf(marker, searchStart);
+      if (markerIndex === -1)
+        break;
+      if (markerIndex === 0 || value[markerIndex - 1] === "\n") {
+        index = index === -1 ? markerIndex : Math.min(index, markerIndex);
+        break;
+      }
+      searchStart = markerIndex + marker.length;
+    }
+  }
+  return index;
+}
+function stripBinaryArtifactContent(value) {
+  const index = findBinaryArtifactStart(value);
+  if (index === -1)
+    return value;
+  return value.slice(0, index).trimEnd();
+}
+function looksLikeGeneratedArtifactScript(value) {
+  const trimmed = value.trim();
+  if (!trimmed)
+    return false;
+  const hasScriptShape = /^#!\/usr\/bin\/env\s+\S+/m.test(trimmed) || /(?:^|\n)# -\*- coding:/.test(trimmed) || /(?:^|\n)from\s+\S+\s+import\s+\S+/.test(trimmed) || /(?:^|\n)import\s+\S+/.test(trimmed) || /(?:^|\n)(?:class|def)\s+\w+/.test(trimmed);
+  const hasGeneratedFileSignal = /vault:\/\/|\.output\s*\(|open\s*\([^)]*,\s*['"][wa]/.test(trimmed);
+  return hasScriptShape && hasGeneratedFileSignal;
+}
+function findGeneratedArtifactMarkdownStart(value) {
+  for (const match of value.matchAll(MARKDOWN_HEADING_PATTERN)) {
+    if (match.index === void 0)
+      continue;
+    const headingOffset = match[0].match(/^[\r\n]+/)?.[0].length ?? 0;
+    const markdownStart = match.index + headingOffset;
+    const heading = value.slice(markdownStart, match.index + match[0].length).trim();
+    if (/^#{1,6}\s+-\*-/.test(heading))
+      continue;
+    if (looksLikeGeneratedArtifactScript(value.slice(0, markdownStart)))
+      return markdownStart;
+  }
+  return -1;
+}
+function stripGeneratedArtifactScriptPrefix(value) {
+  const markdownStart = findGeneratedArtifactMarkdownStart(value);
+  if (markdownStart === -1)
+    return value;
+  return value.slice(markdownStart).trimStart();
+}
+function normalizeTelaAgentResultContent(value) {
+  const sanitized = sanitizeText(value);
+  const taggedAnswer = extractTaggedAnswer(sanitized);
+  let normalized = taggedAnswer ?? sanitized;
+  let changed = taggedAnswer !== null;
+  const withoutTaggedReasoning = stripTaggedReasoning(normalized);
+  changed ||= withoutTaggedReasoning !== normalized;
+  normalized = withoutTaggedReasoning;
+  const withoutBinaryArtifacts = stripBinaryArtifactContent(normalized);
+  changed ||= withoutBinaryArtifacts !== normalized;
+  normalized = withoutBinaryArtifacts;
+  const withoutGeneratedScript = stripGeneratedArtifactScriptPrefix(normalized);
+  changed ||= withoutGeneratedScript !== normalized;
+  normalized = withoutGeneratedScript;
+  const withoutTrailingBinaryArtifacts = stripBinaryArtifactContent(normalized);
+  changed ||= withoutTrailingBinaryArtifacts !== normalized;
+  normalized = withoutTrailingBinaryArtifacts;
+  return changed ? normalized.trim() : normalized;
+}
+function getStringProperty(record, key) {
+  const value = record[key];
+  if (typeof value !== "string")
+    return null;
+  const sanitized = sanitizeText(value);
+  return sanitized.trim() ? sanitized : null;
+}
+function getContentPartText(part) {
+  return getStringProperty(part, "text") ?? getStringProperty(part, "thinking");
+}
+function normalizeToolResultContent(content) {
+  if (typeof content === "string")
+    return sanitizeText(content);
+  if (Array.isArray(content))
+    return sanitizeUnknown(content);
+  return "";
+}
+function normalizeMessageContentPart(part) {
+  if (!isRecord(part))
+    return null;
+  const type = getStringProperty(part, "type");
+  if (!type)
+    return null;
+  if (type === "text" || type === "thinking" || type === "reasoning") {
+    const text2 = getContentPartText(part);
+    return text2 ? { type: "text", text: text2 } : null;
+  }
+  if (type === "tool_use") {
+    const id = getStringProperty(part, "id");
+    const name = getStringProperty(part, "name");
+    if (!id || !name)
+      return null;
+    return {
+      type: "tool_use",
+      id,
+      name,
+      input: isRecord(part.input) ? sanitizeRecord(part.input) : {}
+    };
+  }
+  if (type === "tool_result") {
+    const toolUseId = getStringProperty(part, "tool_use_id");
+    if (!toolUseId)
+      return null;
+    return {
+      type: "tool_result",
+      tool_use_id: toolUseId,
+      content: normalizeToolResultContent(part.content),
+      ...typeof part.is_error === "boolean" ? { is_error: part.is_error } : {}
+    };
+  }
+  const text = getContentPartText(part);
+  return text ? { type: "text", text } : null;
+}
+function normalizeStepMessageContent(step) {
+  const record = step;
+  const message = record.message;
+  if (isRecord(message) && Array.isArray(message.content)) {
+    return message.content.map((part) => normalizeMessageContentPart(part)).filter((part) => Boolean(part));
+  }
+  const text = getStepText(step);
+  return text ? [{ type: "text", text }] : [];
+}
+function getStepText(step) {
+  const record = step;
+  const directText = getStringProperty(record, "content") ?? getStringProperty(record, "text") ?? getStringProperty(record, "output");
+  if (directText)
+    return directText;
+  const message = record.message;
+  if (typeof message === "string" && message.trim())
+    return message;
+  if (isRecord(message) && Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (!isRecord(part))
+        continue;
+      const text = getContentPartText(part);
+      if (text)
+        return text;
+    }
+  }
+  return null;
+}
+export function normalizeTelaAgentReasoningStep(sessionId, step) {
+  const content = normalizeStepMessageContent(step);
+  if (content.length === 0)
+    return null;
+  const record = step;
+  const message = isRecord(record.message) ? record.message : null;
+  const sourceType = getStringProperty(record, "type");
+  const type = sourceType === "user" ? "user" : "assistant";
+  const role = message ? getStringProperty(message, "role") : null;
+  const timestamp = typeof record.timestamp === "number" ? record.timestamp : Date.now();
+  const timeElapsed = typeof record.timeElapsed === "number" ? record.timeElapsed : 0;
+  const parentToolUseId = getStringProperty(record, "parent_tool_use_id");
+  return {
+    type,
+    uuid: getTelaAgentStepSyncId(step),
+    message: {
+      role: role ?? (type === "user" ? "user" : "assistant"),
+      content
+    },
+    timestamp,
+    session_id: sessionId,
+    timeElapsed,
+    parent_tool_use_id: parentToolUseId
+  };
+}
+export function getNewTelaAgentSteps(session, lastSyncedStepId) {
+  if (!lastSyncedStepId)
+    return session.steps;
+  const lastSyncedIndex = session.steps.findIndex((step) => getTelaAgentStepSyncId(step) === lastSyncedStepId);
+  return session.steps.slice(lastSyncedIndex + 1);
+}
+export function extractTelaAgentAssistantContent(session, steps = session.steps) {
+  const structuredContent = session.result?.structuredContent;
+  if (structuredContent)
+    return sanitizeText(jsonMarkdown(structuredContent));
+  if (session.result?.content)
+    return normalizeTelaAgentResultContent(session.result.content);
+  for (let i = steps.length - 1; i >= 0; i--) {
+    const text = getStepText(steps[i]);
+    if (text)
+      return text;
+  }
+  return "";
+}
+export function mapTelaAgentSessionToMessageUpdate(session, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const newSteps = getNewTelaAgentSteps(session, options.lastSyncedStepId);
+  const reasoningData = newSteps.map((step) => normalizeTelaAgentReasoningStep(session.sessionId, step)).filter((step) => Boolean(step));
+  const accumulatedReasoningData = [
+    ...options.existingReasoningData ?? [],
+    ...reasoningData
+  ];
+  const lastStep = newSteps.at(-1);
+  const update = {};
+  if (reasoningData.length > 0)
+    update.reasoningData = accumulatedReasoningData;
+  if (reasoningData.length > 0 && lastStep)
+    update.externalUuid = getTelaAgentStepSyncId(lastStep);
+  if (!options.pendingMessageTtft && options.userMessageCreatedAt && reasoningData.length > 0) {
+    update.ttft = String(now.getTime() - options.userMessageCreatedAt.getTime());
+  }
+  if (session.status === "completed" || session.status === "waiting_messages") {
+    update.content = extractTelaAgentAssistantContent(session);
+    update.status = "completed";
+    update.updatedAt = now;
+  } else if (session.status === "failed") {
+    update.content = formatTelaAgentFailureMessage(session.error);
+    update.status = "failed";
+    update.updatedAt = now;
+  } else if (session.status === "cancelled") {
+    update.content = INTERRUPTED_GENERATION_TEXT;
+    update.status = "completed";
+    update.updatedAt = now;
+  }
+  return update;
+}
+export function mapTelaAgentUsage(session) {
+  const usage = session.result?.usage;
+  if (!usage)
+    return null;
+  return {
+    promptTokens: usage.promptTokens ?? 0,
+    completionTokens: usage.completionTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0,
+    promptCost: String(usage.promptCost ?? 0),
+    completionCost: String(usage.completionCost ?? 0),
+    totalCost: String(usage.totalCost ?? 0),
+    durationMs: usage.duration ?? null,
+    turns: usage.turns ?? null,
+    model: null,
+    cacheReadInputTokens: null,
+    cacheCreationInputTokens: null,
+    modelUsage: null,
+    durationApiMs: null,
+    webSearchRequests: null,
+    webFetchRequests: null
+  };
+}