@meistrari/chat-nuxt 1.11.0 → 1.13.0

package/dist/runtime/server/db/schema/index.d.ts

@@ -1,4 +1,5 @@
 export { CHAT_SCHEMA_NAME, chatSchema } from './_schema.js';
+export { conversationGroups } from './conversation-groups.js';
 export { conversationUsage, type ConversationUsageMetadata, type ModelUsageEntry } from './conversation-usage.js';
 export { conversations } from './conversations.js';
 export { type ExternalSkillInsert, type ExternalSkillRow, externalSkills, externalSkillsRelations } from './external-skills.js';

package/dist/runtime/server/db/schema/index.js

@@ -1,4 +1,5 @@
 export { CHAT_SCHEMA_NAME, chatSchema } from "./_schema.js";
+export { conversationGroups } from "./conversation-groups.js";
 export { conversationUsage } from "./conversation-usage.js";
 export { conversations } from "./conversations.js";
 export { externalSkills, externalSkillsRelations } from "./external-skills.js";

package/dist/runtime/server/db/schema/messages.d.ts

@@ -148,6 +148,40 @@ export declare const messages: import("drizzle-orm/pg-core").PgTableWithColumns<
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        agentSessionCursor: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_session_cursor";
+            tableName: "messages";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        agentSessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_session_id";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         ttft: import("drizzle-orm/pg-core").PgColumn<{
             name: "ttft";
             tableName: "messages";

package/dist/runtime/server/db/schema/messages.js

@@ -1,4 +1,4 @@
-import { uuid, text, timestamp, index, jsonb } from "drizzle-orm/pg-core";
+import { uuid, text, timestamp, index, integer, jsonb } from "drizzle-orm/pg-core";
 import { chatSchema } from "./_schema.js";
 import { conversations } from "./conversations.js";
 export const messages = chatSchema.table("messages", {
@@ -10,6 +10,8 @@ export const messages = chatSchema.table("messages", {
   reasoningData: jsonb("reasoning_data"),
   files: jsonb("files").$type(),
   externalUuid: text("external_uuid"),
+  agentSessionCursor: integer("agent_session_cursor"),
+  agentSessionId: text("agent_session_id"),
   ttft: text("ttft"),
   createdBy: text("created_by"),
   createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),

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

@@ -0,0 +1,4 @@
+import type { ChatRuntimeContext } from '#chat-runtime/server/utils/chat-context';
+export declare function conversationGroupScopeConditions(context: ChatRuntimeContext, groupId?: string): import("drizzle-orm").SQL<unknown> | undefined;
+export declare function resolveConversationGroupName(name: unknown): string;
+export declare function resolveOptionalConversationGroupId(groupId: unknown): string | null;

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

@@ -0,0 +1,48 @@
+import { and, eq, isNull } from "drizzle-orm";
+import { createError } from "h3";
+import { schema } from "#chat-runtime/server/db";
+const MAX_GROUP_NAME_LENGTH = 80;
+export function conversationGroupScopeConditions(context, groupId) {
+  const conditions = [
+    eq(schema.conversationGroups.workspaceId, context.workspaceId),
+    context.telaAgentId ? eq(schema.conversationGroups.telaAgentId, context.telaAgentId) : isNull(schema.conversationGroups.telaAgentId),
+    context.conversationScope ? eq(schema.conversationGroups.conversationScope, context.conversationScope) : isNull(schema.conversationGroups.conversationScope)
+  ];
+  if (groupId) {
+    conditions.unshift(eq(schema.conversationGroups.id, groupId));
+  }
+  return and(...conditions);
+}
+export function resolveConversationGroupName(name) {
+  if (typeof name !== "string") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group name is required"
+    });
+  }
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group name cannot be empty"
+    });
+  }
+  if (trimmedName.length > MAX_GROUP_NAME_LENGTH) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group name is too long"
+    });
+  }
+  return trimmedName;
+}
+export function resolveOptionalConversationGroupId(groupId) {
+  if (groupId === null)
+    return null;
+  if (typeof groupId !== "string" || !groupId.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid group ID"
+    });
+  }
+  return groupId.trim();
+}

package/dist/runtime/server/utils/conversation-message-sync.d.ts

@@ -20,7 +20,7 @@ type MessageUpdateResponse = {
 export declare const PENDING_RESPONSE_GRACE_MS = 30000;
 export declare const THREAD_SESSION_START_ERROR = "Erro: N\u00E3o foi poss\u00EDvel iniciar a sess\u00E3o de resposta. Tente enviar a mensagem novamente.";
 export declare const SESSION_STATUS_CHECK_ERROR = "Erro: N\u00E3o foi poss\u00EDvel verificar o andamento da resposta. Tente enviar a mensagem novamente.";
-export declare function hasPendingMessageExceededGraceWindow(pendingMessage: Pick<Message, 'createdAt'>, now?: Date): boolean;
+export declare function hasPendingMessageExceededGraceWindow(pendingMessage: Pick<Message, 'createdAt'>, now?: Date, graceMs?: number): boolean;
 export declare function buildFailedPendingMessageUpdate(content: string, now?: Date): MessageUpdate;
 export declare function mapAgentApiSessionToMessageUpdate(agentSession: AgentApiSession, options: {
     pendingMessage: Pick<Message, 'ttft' | 'createdAt' | 'updatedAt'>;

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

@@ -24,8 +24,8 @@ function resolveTerminalContentForPendingMessage(agentSession, newReasoning, las
     return null;
   return sessionContent || reasoningContent;
 }
-export function hasPendingMessageExceededGraceWindow(pendingMessage, now = /* @__PURE__ */ new Date()) {
-  return now.getTime() - pendingMessage.createdAt.getTime() >= PENDING_RESPONSE_GRACE_MS;
+export function hasPendingMessageExceededGraceWindow(pendingMessage, now = /* @__PURE__ */ new Date(), graceMs = PENDING_RESPONSE_GRACE_MS) {
+  return now.getTime() - pendingMessage.createdAt.getTime() >= graceMs;
 }
 export function buildFailedPendingMessageUpdate(content, now = /* @__PURE__ */ new Date()) {
   return {

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

@@ -14,7 +14,9 @@ export declare function getTelaAgent(event: H3Event, agentId: string): Promise<{
     success: false;
     error: string;
 }>;
-export declare function getTelaAgentSession(event: H3Event, sessionId: string): Promise<{
+export declare function getTelaAgentSession(event: H3Event, sessionId: string, options?: {
+    cursor?: number | null;
+}): Promise<{
     success: true;
     data: TelaAgentSession;
 } | {

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

@@ -3,10 +3,14 @@ import {
   telaAgentApiResponseSchema,
   telaAgentEndSessionApiResponseSchema,
   telaAgentRunApiResponseSchema,
-  telaAgentSessionApiResponseSchema
+  telaAgentV4SessionStreamEventSchema
 } from "#chat-runtime/types/tela-agent";
 import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
 import { logger } from "#chat-runtime/server/utils/logger";
+const TELA_SESSION_STREAM_FIRST_EVENT_TIMEOUT_MS = 3e3;
+const TELA_SESSION_STREAM_IDLE_TIMEOUT_MS = 250;
+const TELA_AGENT_V4_SESSION_EVENT_KINDS = /* @__PURE__ */ new Set(["status", "steps", "result", "error"]);
+const TELA_AGENT_METADATA_MAX_ATTEMPTS = 3;
 function getTelaErrorMessage(body, fallback) {
   if (body && typeof body === "object") {
     const record = body;
@@ -27,26 +31,105 @@ async function readResponseBody(response) {
     return text;
   }
 }
-async function telaAgentFetch(event, path, init) {
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+async function telaAgentFetch(event, path, init, options = {}) {
   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 maxAttempts = options.maxAttempts ?? 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    let response;
+    let body;
+    try {
+      response = await fetch(url, {
+        ...init,
+        headers: {
+          "Content-Type": "application/json",
+          "x-data-token": token,
+          "Authorization": `Bearer ${token}`,
+          ...init.headers
+        }
+      });
+      body = await readResponseBody(response);
+    } catch (error) {
+      const message = getErrorMessage(error);
+      logger.warn({ error: message, path }, "Tela agent API request threw");
+      return { success: false, error: `Tela API request failed: ${message}` };
     }
-  });
-  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 };
+    if (!response.ok) {
+      const error = getTelaErrorMessage(body, `Tela API error: ${response.status} - ${response.statusText}`);
+      if (attempt < maxAttempts && options.retryStatusCodes?.includes(response.status)) {
+        logger.warn({ status: response.status, statusText: response.statusText, path, attempt }, "Tela agent API request failed, retrying");
+        continue;
+      }
+      logger.warn({ status: response.status, statusText: response.statusText, path }, "Tela agent API request failed");
+      return { success: false, error };
+    }
+    return { success: true, body };
+  }
+  return { success: false, error: "Tela API request failed" };
+}
+function getTelaAgentV4SessionEventKind(event) {
+  if (!event || typeof event !== "object" || !("kind" in event))
+    return null;
+  const kind = event.kind;
+  return typeof kind === "string" ? kind : null;
+}
+function parseTelaAgentV4SessionSseFrame(frame) {
+  let data = "";
+  let hasData = false;
+  let lineStart = 0;
+  while (lineStart <= frame.length) {
+    const lineEnd = frame.indexOf("\n", lineStart);
+    const line = lineEnd === -1 ? frame.slice(lineStart) : frame.slice(lineStart, lineEnd);
+    lineStart = lineEnd === -1 ? frame.length + 1 : lineEnd + 1;
+    if (!line || line.startsWith(":"))
+      continue;
+    const separatorIndex = line.indexOf(":");
+    const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+    let value = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
+    if (value.startsWith(" "))
+      value = value.slice(1);
+    if (field === "data") {
+      data = hasData ? `${data}
+${value}` : value;
+      hasData = true;
+    }
+  }
+  if (!hasData || !data || data === "[DONE]" || data === "Stream complete")
+    return void 0;
+  let rawEvent;
+  try {
+    rawEvent = JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+  const eventKind = getTelaAgentV4SessionEventKind(rawEvent);
+  if (!eventKind || !TELA_AGENT_V4_SESSION_EVENT_KINDS.has(eventKind))
+    return void 0;
+  const parsed = telaAgentV4SessionStreamEventSchema.safeParse(rawEvent);
+  if (!parsed.success)
+    return void 0;
+  return parsed.data;
+}
+async function readTelaSessionStreamChunk(reader, timeoutMs) {
+  let timeout;
+  try {
+    return await Promise.race([
+      reader.read().then(
+        (result) => ({ type: "read", result }),
+        (error) => ({ type: "error", error })
+      ),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => resolve({ type: "timeout" }), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
   }
-  return { success: true, body };
 }
 export async function runTelaAgent(event, agentId, payload) {
   const encodedAgentId = encodeURIComponent(agentId);
@@ -67,6 +150,9 @@ export async function getTelaAgent(event, agentId) {
   const encodedAgentId = encodeURIComponent(agentId);
   const result = await telaAgentFetch(event, `/agent/${encodedAgentId}`, {
     method: "GET"
+  }, {
+    maxAttempts: TELA_AGENT_METADATA_MAX_ATTEMPTS,
+    retryStatusCodes: [502]
   });
   if (!result.success)
     return result;
@@ -77,19 +163,192 @@ export async function getTelaAgent(event, agentId) {
   }
   return { success: true, data: parsed.data.data };
 }
-export async function getTelaAgentSession(event, sessionId) {
+export async function getTelaAgentSession(event, sessionId, options = {}) {
+  const { telaApiUrl } = useRuntimeConfig();
+  const token = getAgentDataToken(event);
   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");
+  const params = new URLSearchParams();
+  if (typeof options.cursor === "number")
+    params.set("cursor", String(options.cursor));
+  const queryString = params.toString();
+  const path = `/agent/sessions/${encodedSessionId}${queryString ? `?${queryString}` : ""}`;
+  const url = `${telaApiUrl}${path}`;
+  const abortController = new AbortController();
+  let completed = false;
+  let response = null;
+  let reader = null;
+  const abortOnResponseClose = () => {
+    if (!completed)
+      abortController.abort();
+  };
+  event.node?.res?.once?.("close", abortOnResponseClose);
+  try {
+    let buildSnapshot = function() {
+      if (!status)
+        return null;
+      return {
+        sessionId,
+        status,
+        steps,
+        ...nextCursor !== void 0 ? { nextCursor } : {},
+        ...result ? { result } : {},
+        ...error ? { error } : {},
+        ...createdAt !== void 0 ? { createdAt } : {},
+        ...updatedAt !== void 0 ? { updatedAt } : {}
+      };
+    }, applyStreamEvent = function(streamEvent) {
+      if (streamEvent.kind === "error") {
+        status = "failed";
+        error = streamEvent.error;
+        return buildSnapshot();
+      }
+      status = streamEvent.status;
+      if (streamEvent.kind === "status") {
+        error = streamEvent.error;
+        createdAt = streamEvent.createdAt;
+        updatedAt = streamEvent.updatedAt;
+        if (status === "failed" || status === "cancelled")
+          return buildSnapshot();
+        return null;
+      }
+      createdAt = streamEvent.createdAt;
+      updatedAt = streamEvent.updatedAt;
+      nextCursor = streamEvent.nextCursor;
+      if (streamEvent.kind === "steps") {
+        for (const step of streamEvent.steps) {
+          const key = step.eventId ?? step.id;
+          if (!key)
+            continue;
+          const existingIndex = stepIndexByKey.get(key);
+          if (existingIndex === void 0) {
+            stepIndexByKey.set(key, steps.length);
+            steps.push(step);
+            continue;
+          }
+          steps[existingIndex] = {
+            ...steps[existingIndex],
+            ...step
+          };
+        }
+        if (status === "failed" || status === "cancelled")
+          return buildSnapshot();
+        return null;
+      }
+      result = streamEvent.result;
+      error = void 0;
+      return buildSnapshot();
+    }, drainBuffer = function() {
+      while (true) {
+        const frameBoundary = buffer.indexOf("\n\n");
+        if (frameBoundary === -1)
+          return null;
+        const frame = buffer.slice(0, frameBoundary);
+        buffer = buffer.slice(frameBoundary + 2);
+        const streamEvent = parseTelaAgentV4SessionSseFrame(frame);
+        if (!streamEvent)
+          continue;
+        const terminalSnapshot = applyStreamEvent(streamEvent);
+        if (terminalSnapshot)
+          return terminalSnapshot;
+      }
+    };
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        signal: abortController.signal,
+        headers: {
+          "Accept": "text/event-stream",
+          "x-data-token": token,
+          "Authorization": `Bearer ${token}`
+        }
+      });
+    } catch (error2) {
+      const message = getErrorMessage(error2);
+      logger.warn({ error: message, path }, "Tela agent API request threw");
+      return { success: false, error: `Tela API request failed: ${message}` };
+    }
+    if (!response.ok) {
+      let body;
+      try {
+        body = await readResponseBody(response);
+      } catch (error3) {
+        const message = getErrorMessage(error3);
+        logger.warn({ error: message, path }, "Tela agent API error response read failed");
+        return { success: false, error: `Tela API request failed: ${message}` };
+      }
+      const error2 = 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: error2 };
+    }
+    if (!response.body)
+      return { success: false, error: "Tela session stream response body is missing" };
+    reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const steps = [];
+    const stepIndexByKey = /* @__PURE__ */ new Map();
+    let status = null;
+    let nextCursor;
+    let result;
+    let error;
+    let createdAt;
+    let updatedAt;
+    let buffer = "";
+    while (true) {
+      const snapshot = buildSnapshot();
+      const readResult = await readTelaSessionStreamChunk(
+        reader,
+        snapshot ? TELA_SESSION_STREAM_IDLE_TIMEOUT_MS : TELA_SESSION_STREAM_FIRST_EVENT_TIMEOUT_MS
+      );
+      if (readResult.type === "timeout") {
+        if (snapshot)
+          return { success: true, data: snapshot };
+        return { success: false, error: "Tela session stream timed out before a session event" };
+      }
+      if (readResult.type === "error") {
+        const message = getErrorMessage(readResult.error);
+        const activeSnapshot = buildSnapshot();
+        if (activeSnapshot) {
+          logger.warn({ error: message, path, sessionId }, "Tela agent session stream failed after active snapshot");
+          return { success: true, data: activeSnapshot };
+        }
+        logger.warn({ error: message, path }, "Tela agent API request threw");
+        return { success: false, error: `Tela API request failed: ${message}` };
+      }
+      const { done, value } = readResult.result;
+      if (done) {
+        buffer += decoder.decode().replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        if (buffer.trim()) {
+          const streamEvent = parseTelaAgentV4SessionSseFrame(buffer);
+          if (streamEvent) {
+            const terminalSnapshot2 = applyStreamEvent(streamEvent);
+            if (terminalSnapshot2)
+              return { success: true, data: terminalSnapshot2 };
+          }
+        }
+        const snapshot2 = buildSnapshot();
+        if (snapshot2)
+          return { success: true, data: snapshot2 };
+        return { success: false, error: "Tela session stream ended without a session event" };
+      }
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const terminalSnapshot = drainBuffer();
+      if (terminalSnapshot)
+        return { success: true, data: terminalSnapshot };
+    }
+  } catch (error) {
+    const message = getErrorMessage(error);
+    logger.warn({ error: message, sessionId }, "Tela agent session response parse error");
     return { success: false, error: "Invalid session response from Tela API" };
+  } finally {
+    completed = true;
+    event.node?.res?.off?.("close", abortOnResponseClose);
+    abortController.abort();
+    await reader?.cancel().catch(() => void 0);
+    try {
+      reader?.releaseLock();
+    } catch {
+    }
   }
-  return { success: true, data: parsed.data.data };
 }
 export async function endTelaAgentSession(event, sessionId) {
   const encodedSessionId = encodeURIComponent(sessionId);

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

@@ -4,6 +4,8 @@ import type { TelaAgentExecutionInput, TelaAgentInputVariable, TelaAgentSession,
 export type TelaAgentMessageUpdate = {
     reasoningData?: ReasoningItem[];
     externalUuid?: string;
+    agentSessionCursor?: number;
+    agentSessionId?: string;
     content?: string;
     status?: MessageStatus;
     ttft?: string;
@@ -33,12 +35,20 @@ export declare function toTelaAgentAttachments(files: TelaAgentFileInput[] | und
     vaultRef: string;
     filename: any;
 }[];
-export declare function getTelaAgentStepSyncId(step: TelaAgentStep): string;
+export declare function getTelaAgentStepSyncId(step: TelaAgentStep): string | null;
 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 extractTelaAgentAssistantContent(session: TelaAgentSession): string;
+export declare function resolveTelaAgentRequestCursor(options: {
+    pendingMessage: {
+        agentSessionCursor?: number | null;
+    };
+    lastTerminalMessage?: {
+        agentSessionCursor?: number | null;
+        agentSessionId?: string | null;
+    } | null;
+    threadSessionId: string;
+}): number | undefined;
 export declare function mapTelaAgentSessionToMessageUpdate(session: TelaAgentSession, options?: {
-    lastSyncedStepId?: string | null;
     existingReasoningData?: ReasoningItem[] | null;
     pendingMessageTtft?: string | null;
     userMessageCreatedAt?: Date | null;

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

@@ -43,7 +43,7 @@ export function toTelaAgentAttachments(files) {
   }));
 }
 export function getTelaAgentStepSyncId(step) {
-  return step.eventId ?? step.id;
+  return step.eventId ?? step.id ?? null;
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -251,6 +251,9 @@ function getStepText(step) {
   return null;
 }
 export function normalizeTelaAgentReasoningStep(sessionId, step) {
+  const syncId = getTelaAgentStepSyncId(step);
+  if (!syncId)
+    return null;
   const content = normalizeStepMessageContent(step);
   if (content.length === 0)
     return null;
@@ -264,7 +267,7 @@ export function normalizeTelaAgentReasoningStep(sessionId, step) {
   const parentToolUseId = getStringProperty(record, "parent_tool_use_id");
   return {
     type,
-    uuid: getTelaAgentStepSyncId(step),
+    uuid: syncId,
     message: {
       role: role ?? (type === "user" ? "user" : "assistant"),
       content
@@ -275,40 +278,70 @@ export function normalizeTelaAgentReasoningStep(sessionId, step) {
     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) {
+export function extractTelaAgentAssistantContent(session) {
   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]);
+  for (let i = session.steps.length - 1; i >= 0; i--) {
+    const text = getStepText(session.steps[i]);
     if (text)
       return text;
   }
   return "";
 }
+export function resolveTelaAgentRequestCursor(options) {
+  if (typeof options.pendingMessage.agentSessionCursor === "number")
+    return options.pendingMessage.agentSessionCursor;
+  const lastTerminalMessage = options.lastTerminalMessage;
+  if (lastTerminalMessage && lastTerminalMessage.agentSessionId === options.threadSessionId && typeof lastTerminalMessage.agentSessionCursor === "number") {
+    return lastTerminalMessage.agentSessionCursor;
+  }
+  return void 0;
+}
 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 reasoningData = session.steps.map((step) => normalizeTelaAgentReasoningStep(session.sessionId, step)).filter((step) => Boolean(step));
+  const accumulatedReasoningData = [...options.existingReasoningData ?? []];
+  const reasoningIndexes = new Map(accumulatedReasoningData.map((item, index) => [item.uuid, index]));
+  const changedReasoningData = [];
+  for (const item of reasoningData) {
+    const existingIndex = reasoningIndexes.get(item.uuid);
+    if (existingIndex === void 0) {
+      reasoningIndexes.set(item.uuid, accumulatedReasoningData.length);
+      accumulatedReasoningData.push(item);
+      changedReasoningData.push(item);
+      continue;
+    }
+    const existingItem = accumulatedReasoningData[existingIndex];
+    const existingContent = JSON.stringify({
+      type: existingItem.type,
+      message: existingItem.message,
+      parent_tool_use_id: existingItem.parent_tool_use_id
+    });
+    const nextContent = JSON.stringify({
+      type: item.type,
+      message: item.message,
+      parent_tool_use_id: item.parent_tool_use_id
+    });
+    if (existingContent !== nextContent) {
+      accumulatedReasoningData[existingIndex] = item;
+      changedReasoningData.push(item);
+    }
+  }
+  const lastChangedReasoning = changedReasoningData.at(-1);
   const update = {};
-  if (reasoningData.length > 0)
+  const nextCursor = typeof session.nextCursor === "number" ? session.nextCursor : void 0;
+  if (nextCursor !== void 0) {
+    update.agentSessionCursor = nextCursor;
+    update.agentSessionId = session.sessionId;
+  }
+  if (changedReasoningData.length > 0)
     update.reasoningData = accumulatedReasoningData;
-  if (reasoningData.length > 0 && lastStep)
-    update.externalUuid = getTelaAgentStepSyncId(lastStep);
-  if (!options.pendingMessageTtft && options.userMessageCreatedAt && reasoningData.length > 0) {
+  if (lastChangedReasoning)
+    update.externalUuid = lastChangedReasoning.uuid;
+  if (!options.pendingMessageTtft && options.userMessageCreatedAt && changedReasoningData.length > 0) {
     update.ttft = String(now.getTime() - options.userMessageCreatedAt.getTime());
   }
   if (session.status === "completed" || session.status === "waiting_messages") {
@@ -323,6 +356,8 @@ export function mapTelaAgentSessionToMessageUpdate(session, options = {}) {
     update.content = INTERRUPTED_GENERATION_TEXT;
     update.status = "completed";
     update.updatedAt = now;
+  } else if (changedReasoningData.length > 0 || nextCursor !== void 0) {
+    update.updatedAt = now;
   }
   return update;
 }