@meistrari/chat-nuxt 1.12.0 → 1.13.0

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/chat/reasoning-message.vue

@@ -19,7 +19,7 @@ const props = defineProps({
   isPreviewMode: { type: Boolean, required: false },
   completed: { type: Boolean, required: false }
 });
-const { conjugateText } = useVerbConjugation();
+const { conjugateText, resolveReadFileStepTitle } = useVerbConjugation();
 const { settings: workspaceSettings } = useWorkspaceSettings();
 const canvasToolNames = computed(() => {
   const names = /* @__PURE__ */ new Set();
@@ -193,6 +193,9 @@ const stepTitle = computed(() => {
     const verb = stepWasExecuted.value ? "Leu" : "Lendo";
     if (typeof filePath === "string") {
       const fileName = filePath.split("/").pop() || "arquivo";
+      const readTitle = resolveReadFileStepTitle(fileName, stepWasExecuted.value);
+      if (readTitle)
+        return readTitle;
       title = `${verb}: ${fileName.length > 40 ? `${fileName.slice(0, 40)}...` : fileName}`;
     } else {
       title = `${verb} arquivo`;

package/dist/runtime/composables/useVerbConjugation.d.ts

@@ -3,4 +3,5 @@ export declare function useVerbConjugation(): {
     isEnglish: (text: string) => boolean;
     translateEnglishText: (text: string, toPast: boolean) => string;
     conjugatePortugueseVerb: (text: string) => string;
+    resolveReadFileStepTitle: (fileName: string, wasExecuted: boolean) => string | null;
 };

package/dist/runtime/composables/useVerbConjugation.js

@@ -186,6 +186,12 @@ const gerundToPast = new Map(
 const infinitiveToPast = new Map(
   ptValues.map((v) => [v.infinitive, v.past])
 );
+const readFileStepLabels = {
+  "instructions.md": "instru\xE7\xF5es",
+  "output-format.json": "estrutura de sa\xEDda esperada",
+  "input-list.json": "lista de arquivos de entrada",
+  "result.json": "resultado"
+};
 export function useVerbConjugation() {
   function isEnglish(text) {
     const firstWord = text.trim().split(/\s+/)[0]?.toLowerCase() || "";
@@ -247,10 +253,17 @@ export function useVerbConjugation() {
     }
     return conjugatePortugueseVerb(text);
   }
+  function resolveReadFileStepTitle(fileName, wasExecuted) {
+    const label = readFileStepLabels[fileName];
+    if (!label)
+      return null;
+    return conjugateText(`Lendo ${label}`, wasExecuted);
+  }
   return {
     conjugateText,
     isEnglish,
     translateEnglishText,
-    conjugatePortugueseVerb
+    conjugatePortugueseVerb,
+    resolveReadFileStepTitle
   };
 }

package/dist/runtime/server/api/conversations/[id]/messages/[messageId]/retry.post.js

@@ -64,6 +64,8 @@ export default defineEventHandler(async (event) => {
     reasoningData: null,
     files: null,
     ttft: null,
+    agentSessionCursor: null,
+    agentSessionId: null,
     updatedAt: null
   }).where(eq(schema.messages.id, messageId));
   logger.info({ conversationId, messageId }, "Message retry initiated");

package/dist/runtime/server/api/conversations/[id]/messages/index.get.js

@@ -11,6 +11,7 @@ import {
   hasPendingMessageExceededGraceWindow,
   isTerminalMessageUpdate,
   mapAgentApiSessionToMessageUpdate,
+  PENDING_RESPONSE_GRACE_MS,
   SESSION_STATUS_CHECK_ERROR,
   THREAD_SESSION_START_ERROR,
   trackAgentApiConversationUsage,
@@ -18,8 +19,9 @@ import {
 } from "#chat-runtime/server/utils/conversation-message-sync";
 import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
 import { getTelaAgentSession } from "#chat-runtime/server/utils/tela-agent-api";
-import { mapTelaAgentSessionToMessageUpdate, mapTelaAgentUsage } from "#chat-runtime/server/utils/tela-agent-session";
+import { mapTelaAgentSessionToMessageUpdate, mapTelaAgentUsage, resolveTelaAgentRequestCursor } from "#chat-runtime/server/utils/tela-agent-session";
 import { logger } from "#chat-runtime/server/utils/logger";
+const TELA_AGENT_PROGRESS_RECOVERY_MS = 5 * 6e4;
 export default defineEventHandler(async (event) => {
   const context = resolveChatRuntimeContext(event);
   const token = getAgentDataToken(event);
@@ -70,18 +72,38 @@ export default defineEventHandler(async (event) => {
   }
   logger.debug({ conversationId, messageId: pendingMessage.id, sessionId: conversation.threadSessionId }, "Polling pending message");
   if (conversation.telaAgentId) {
-    const sessionResult2 = await getTelaAgentSession(event, conversation.threadSessionId);
+    const agentSessionCursor = resolveTelaAgentRequestCursor({
+      pendingMessage,
+      lastTerminalMessage: lastTerminalAssistantMessage,
+      threadSessionId: conversation.threadSessionId
+    });
+    const sessionResult2 = await getTelaAgentSession(event, conversation.threadSessionId, {
+      cursor: agentSessionCursor
+    });
     if (!sessionResult2.success) {
-      return { messages };
+      const lastProgressAt = pendingMessage.updatedAt ?? pendingMessage.createdAt;
+      const hasTelaAgentProgress = typeof pendingMessage.agentSessionCursor === "number" || !!pendingMessage.externalUuid || Array.isArray(pendingMessage.reasoningData) && pendingMessage.reasoningData.length > 0;
+      const recoveryMs = hasTelaAgentProgress ? TELA_AGENT_PROGRESS_RECOVERY_MS : PENDING_RESPONSE_GRACE_MS;
+      if (!hasPendingMessageExceededGraceWindow({ createdAt: lastProgressAt }, /* @__PURE__ */ new Date(), recoveryMs)) {
+        logger.debug({ conversationId, messageId: pendingMessage.id, sessionId: conversation.threadSessionId, error: sessionResult2.error }, "Tela agent session status check failed within grace window");
+        return { messages };
+      }
+      const updateData3 = buildFailedPendingMessageUpdate(SESSION_STATUS_CHECK_ERROR);
+      logger.warn({ conversationId, messageId: pendingMessage.id, sessionId: conversation.threadSessionId, error: sessionResult2.error }, "Pending message failed because Tela agent session status check did not recover");
+      await db.update(schema.messages).set(updateData3).where(eq(schema.messages.id, pendingMessage.id));
+      return buildMessageUpdateResponse(messages, pendingMessage.id, updateData3);
     }
     const agentSession2 = sessionResult2.data;
     const userMessage2 = messages.findLast((message) => message.role === "user");
     const updateData2 = mapTelaAgentSessionToMessageUpdate(agentSession2, {
-      lastSyncedStepId: pendingMessage.externalUuid ?? lastTerminalAssistantMessage?.externalUuid,
       existingReasoningData: Array.isArray(pendingMessage.reasoningData) ? pendingMessage.reasoningData : null,
       pendingMessageTtft: pendingMessage.ttft,
       userMessageCreatedAt: userMessage2?.createdAt ?? null
     });
+    if (typeof agentSessionCursor === "number" && pendingMessage.agentSessionCursor !== agentSessionCursor && updateData2.agentSessionCursor === void 0) {
+      updateData2.agentSessionCursor = agentSessionCursor;
+      updateData2.agentSessionId = conversation.threadSessionId;
+    }
     await attachNewAssistantFilesToMessageUpdate(db, conversationId, updateData2, token);
     if (!hasMessageUpdate(updateData2)) {
       return { messages };

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-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;