@agent-native/core 0.210.0 → 0.210.1-nightly-20261020010058

package/dist/mcp/embed-app.js

@@ -1266,18 +1266,53 @@ export function embedApp(options = {}) {
 
     // Best-effort telemetry sink so inline-embed failures are visible in
     // Sentry (handshake timeout, transplant fetch status/CORS, auth, CSP).
-    // The shell is a sandboxed opaque-origin iframe, so it POSTs to the app
-    // origin's CORS-open /_agent-native/mcp/embed-error route, derived from the
-    // known app URLs. Deduped per stage+message so a retry loop can't spam.
+    // The shell is a sandboxed opaque-origin iframe, so it POSTs to the app's
+    // CORS-open /_agent-native/mcp/embed-error route. Deduped per stage+message
+    // so a retry loop can't spam.
     const reportedEmbedErrorKeys = new Set();
     let embedErrorReportCount = 0;
-    function embedReportOrigin() {
-      for (const value of [openStartUrl, openUrl, lastFrameSrc]) {
+    function embedReportUrls() {
+      const embedStartPath = "/_agent-native/embed/start";
+      const reportPath = "/_agent-native/mcp/embed-error";
+      const values = [openStartUrl, openUrl, lastFrameSrc];
+      for (const value of values) {
         if (typeof value === "string" && value) {
-          try { return new URL(value, window.location.href).origin; } catch {}
+          if (!URL.canParse(value, window.location.href)) continue;
+          const url = new URL(value, window.location.href);
+          url.username = "";
+          url.password = "";
+          if (!url.pathname.endsWith(embedStartPath)) continue;
+          const appBasePath = url.pathname.slice(0, -embedStartPath.length);
+          url.pathname = appBasePath + "/_agent-native/mcp/embed-error";
+          url.search = "";
+          url.hash = "";
+          return [url.href];
         }
       }
-      return "";
+
+      const value = [openUrl, lastFrameSrc, openStartUrl].find(
+        (candidate) =>
+          typeof candidate === "string" &&
+          candidate &&
+          URL.canParse(candidate, window.location.href),
+      );
+      if (!value) return [];
+
+      const url = new URL(value, window.location.href);
+      url.username = "";
+      url.password = "";
+      const routeMarker = url.pathname.indexOf("/_agent-native/");
+      if (routeMarker >= 0) {
+        url.pathname = url.pathname.slice(0, routeMarker) + reportPath;
+        url.search = "";
+        url.hash = "";
+        return [url.href];
+      }
+
+      url.pathname = reportPath;
+      url.search = "";
+      url.hash = "";
+      return [url.href];
     }
     function reportEmbedError(stage, message, detail, status) {
       try {
@@ -1285,28 +1320,60 @@ export function embedApp(options = {}) {
         if (reportedEmbedErrorKeys.has(key) || embedErrorReportCount >= 8) return;
         reportedEmbedErrorKeys.add(key);
         embedErrorReportCount += 1;
-        const origin = embedReportOrigin();
-        if (!origin) return;
+        const reportUrls = embedReportUrls();
+        if (!reportUrls.length) return;
+        const contextUrl = [openStartUrl, openUrl, lastFrameSrc].find(
+          (value) =>
+            typeof value === "string" &&
+            value &&
+            URL.canParse(value, window.location.href),
+        );
+        let embedUrl = "";
+        if (contextUrl) {
+          const url = new URL(contextUrl, window.location.href);
+          // Embed paths can contain private resource identifiers.
+          if (url.protocol === "http:" || url.protocol === "https:") {
+            embedUrl = url.origin;
+          }
+        }
         let renderMode = "";
         try { renderMode = renderModeSource().mode || ""; } catch {}
         const body = JSON.stringify({
           stage: String(stage || ""),
           message: String(message || "").slice(0, 500),
           detail: detail ? String(detail).slice(0, 1200) : undefined,
-          url: openStartUrl || openUrl || lastFrameSrc || "",
+          url: embedUrl,
           status: typeof status === "number" ? status : undefined,
           host: window.location.hostname || "",
           renderMode: renderMode,
           bridge: openAiBridge ? "openai" : app ? "native" : "none",
           userAgent: navigator.userAgent || ""
         });
-        fetch(origin + "/_agent-native/mcp/embed-error", {
-          method: "POST",
-          credentials: "omit",
-          keepalive: true,
-          headers: { "Content-Type": "application/json" },
-          body: body
-        }).catch(() => {});
+        void (async () => {
+          let lastFetchError;
+          let lastResponseStatus;
+          for (const reportUrl of reportUrls) {
+            try {
+              const response = await fetch(reportUrl, {
+                method: "POST",
+                credentials: "omit",
+                keepalive: true,
+                headers: { "Content-Type": "application/json" },
+                body: body
+              });
+              if (response.status === 204) return;
+              lastResponseStatus = response.status;
+            } catch (error) {
+              lastFetchError = error;
+            }
+          }
+          if (lastFetchError || lastResponseStatus !== undefined) {
+            console.warn("[agent-native] MCP embed error report was not accepted", {
+              status: lastResponseStatus,
+              error: lastFetchError
+            });
+          }
+        })();
       } catch {}
     }
 

package/dist/notifications/routes.d.ts

@@ -1,12 +1,12 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
-    error?: undefined;
     count: number;
     updated?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated: number;
+    error?: undefined;
     ok?: undefined;
 } | {
     count?: undefined;
@@ -14,8 +14,8 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -27,43 +27,43 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    ok?: undefined;
     error: string;
     message: string;
     summary?: undefined;
     spans?: undefined;
-} | {
-    error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/org/actions/invite-organization-member.js

@@ -4,6 +4,7 @@ import { orgAdminAudit } from "../../audit/org-admin.js";
 import { getDbExec } from "../../db/client.js";
 import { requireOrgMember } from "../actions.js";
 export default defineAction({
+    mcpTool: true,
     description: "Invite one person to the active organization as a member and email them the invitation. Every call needs the user's approval. Only organization owners and admins may invite. Admin invitations are sent from Settings > Members.",
     schema: z.object({ email: z.string().trim().email() }),
     // The invitation email reaches a real person, so a saved "always allow"

package/dist/org/actions/list-organization-members.js

@@ -4,6 +4,7 @@ import { getDbExec } from "../../db/client.js";
 import { requireOrgMember } from "../actions.js";
 const MAX_PENDING_INVITATIONS = 100;
 export default defineAction({
+    mcpTool: true,
     description: "List members of the active organization with their roles, sorted by email. Owners and admins also get pending invitations.",
     http: { method: "GET" },
     schema: z.object({

package/dist/org/index.d.ts

@@ -162,9 +162,9 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    name?: undefined;
     success: boolean;
     id?: undefined;
-    name?: undefined;
     role?: undefined;
 } | {
     success?: undefined;

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,10 +75,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    message?: undefined;
+    id?: undefined;
     deleted?: undefined;
     found?: undefined;
-    id?: undefined;
     providers: {
         id: string;
         label: string;
@@ -92,18 +91,18 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     provider?: undefined;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
-    deleted?: undefined;
+} | {
     id?: undefined;
+    deleted?: undefined;
     providers?: undefined;
     count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
+} | {
     deleted?: undefined;
     providers?: undefined;
     count?: undefined;
@@ -112,8 +111,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     id: string;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
+} | {
     found?: undefined;
     providers?: undefined;
     count?: undefined;
@@ -122,6 +121,7 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     id: string;
     registered?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
     deleted?: undefined;
     found?: undefined;

package/dist/provider-api/actions/provider-api.d.ts

@@ -316,10 +316,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        message?: undefined;
+        deleted?: undefined;
         id?: undefined;
         provider?: undefined;
-        deleted?: undefined;
-        message?: undefined;
         found?: undefined;
         providers: {
             id: string;
@@ -334,9 +334,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
-        id?: undefined;
-        deleted?: undefined;
         message?: undefined;
+        deleted?: undefined;
+        id?: undefined;
         providers?: undefined;
         count?: undefined;
         found: boolean;
@@ -344,9 +344,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
-        deleted?: undefined;
         message?: undefined;
+        deleted?: undefined;
+        provider?: undefined;
         providers?: undefined;
         count?: undefined;
         found: boolean;
@@ -354,8 +354,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         message?: undefined;
+        provider?: undefined;
         found?: undefined;
         providers?: undefined;
         count?: undefined;
@@ -364,8 +364,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         deleted?: undefined;
+        provider?: undefined;
         found?: undefined;
         providers?: undefined;
         count?: undefined;

package/dist/scripts/db/exec.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { getDatabaseUrl } from "../../db/client.js";
 import { parseArgs, fail } from "../utils.js";
-import { createPostgresScriptClient } from "./postgres-client.js";
+import { createPostgresScriptClient, withPostgresStatementDeadline, } from "./postgres-client.js";
 import { finalRawDbSql, rawDbInsertTarget, readRawDbWriteStatement, verifyRawDbStatement, } from "./safety.js";
 import { buildScopingPostgres } from "./scoping.js";
 function parseSqlArgs(raw, label = "--args") {
@@ -151,9 +151,11 @@ Options:
     try {
         const results = [];
         await client.begin(async (tx) => {
-            const scoping = await buildScopingPostgres(tx);
+            const timedTx = withPostgresStatementDeadline(tx);
+            const scoping = await buildScopingPostgres(timedTx);
             for (const statement of scoping.setup)
-                await tx.unsafe(statement);
+                await timedTx.unsafe(statement);
+            let operationFailed = false;
             try {
                 for (let index = 0; index < statements.length; index++) {
                     const statement = statements[index];
@@ -162,13 +164,13 @@ Options:
                     // final SQL and check it against this transaction's state right
                     // before it runs, after any earlier statement in the batch.
                     const executed = finalRawDbSql(injectOwnership(statement.statement, scoping), "write", label);
-                    await verifyRawDbStatement(tx, executed.statement, {
+                    await verifyRawDbStatement(timedTx, executed.statement, {
                         columnsByTable: scoping.columnsByTable,
                         label,
                     });
                     const sql = executed.sql;
                     try {
-                        const result = await tx.unsafe(sql, statement.args, {
+                        const result = await timedTx.unsafe(sql, statement.args, {
                             singleStatement: true,
                         });
                         results.push({
@@ -185,9 +187,19 @@ Options:
                     }
                 }
             }
+            catch (error) {
+                operationFailed = true;
+                throw error;
+            }
             finally {
                 for (const statement of scoping.teardown) {
-                    await tx.unsafe(statement).catch(() => { });
+                    try {
+                        await timedTx.unsafe(statement);
+                    }
+                    catch (error) {
+                        if (!operationFailed)
+                            throw error;
+                    }
                 }
             }
         });

package/dist/scripts/db/patch.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { getDatabaseUrl } from "../../db/client.js";
 import { parseArgs, fail } from "../utils.js";
-import { createPostgresScriptClient } from "./postgres-client.js";
+import { createPostgresScriptClient, withPostgresStatementDeadline, } from "./postgres-client.js";
 import { assertNoRawDbAccessControlPatchTarget, assertNoSensitiveFrameworkTables, finalRawDbSql, readRawDbPatchStatement, validateRawDbPatchWhere, verifyRawDbStatement, } from "./safety.js";
 import { buildScopingPostgres } from "./scoping.js";
 function isValidIdentifier(value) {
@@ -348,12 +348,14 @@ Options:
     try {
         let output;
         await client.begin(async (tx) => {
-            const scoping = await buildScopingPostgres(tx);
+            const timedTx = withPostgresStatementDeadline(tx);
+            const scoping = await buildScopingPostgres(timedTx);
             for (const statement of scoping.setup)
-                await tx.unsafe(statement);
+                await timedTx.unsafe(statement);
+            let operationFailed = false;
             try {
-                await verifyRawDbStatement(tx, select.statement);
-                const selected = await tx.unsafe(select.sql, [], {
+                await verifyRawDbStatement(timedTx, select.statement);
+                const selected = await timedTx.unsafe(select.sql, [], {
                     singleStatement: true,
                 });
                 if (selected.length === 0) {
@@ -369,8 +371,8 @@ Options:
                 }
                 const edited = applyEditsToValue(original, options);
                 if (edited.applied > 0) {
-                    await verifyRawDbStatement(tx, update.statement);
-                    await tx.unsafe(update.sql, [edited.content], {
+                    await verifyRawDbStatement(timedTx, update.statement);
+                    await timedTx.unsafe(update.sql, [edited.content], {
                         singleStatement: true,
                     });
                 }
@@ -384,9 +386,19 @@ Options:
                     results: edited.results,
                 };
             }
+            catch (error) {
+                operationFailed = true;
+                throw error;
+            }
             finally {
                 for (const statement of scoping.teardown) {
-                    await tx.unsafe(statement).catch(() => { });
+                    try {
+                        await timedTx.unsafe(statement);
+                    }
+                    catch (error) {
+                        if (!operationFailed)
+                            throw error;
+                    }
                 }
             }
         });

package/dist/scripts/db/postgres-client.d.ts

@@ -13,4 +13,6 @@ export interface PostgresScriptClient {
     begin<T>(fn: (tx: PostgresScriptClient) => Promise<T>): Promise<T>;
     end(): Promise<void>;
 }
+export declare function setRawDbStatementTimeout(client: Pick<PostgresScriptClient, "unsafe">): Promise<void>;
+export declare function withPostgresStatementDeadline(client: Pick<PostgresScriptClient, "unsafe">, timeoutMs?: number): Pick<PostgresScriptClient, "unsafe">;
 export declare function createPostgresScriptClient(url: string): Promise<PostgresScriptClient>;

package/dist/scripts/db/postgres-client.js

@@ -1,4 +1,20 @@
-import { getPgliteClient, isPgliteUrl, toPostgresParams, } from "../../db/client.js";
+import { dbOpTimeoutMs, getPgliteClient, isPgliteUrl, postgresStatementTimeoutMs, toPostgresParams, } from "../../db/client.js";
+export async function setRawDbStatementTimeout(client) {
+    await client.unsafe(`SET LOCAL statement_timeout = ${postgresStatementTimeoutMs(dbOpTimeoutMs())}`);
+}
+export function withPostgresStatementDeadline(client, timeoutMs = dbOpTimeoutMs()) {
+    const deadline = Date.now() + timeoutMs;
+    return {
+        async unsafe(sql, args, options) {
+            const remainingMs = Math.floor(deadline - Date.now());
+            if (remainingMs <= 0) {
+                throw new Error(`Database transaction timed out after ${timeoutMs}ms.`);
+            }
+            await client.unsafe(`SET LOCAL statement_timeout = ${postgresStatementTimeoutMs(remainingMs)}`);
+            return client.unsafe(sql, args, options);
+        },
+    };
+}
 function rowsResult(rows, affectedRows) {
     const records = (rows ?? []);
     const result = records;

package/dist/scripts/db/query.js

@@ -3,7 +3,7 @@ import { assertHostedRuntimeDatabase, getLocalDatabaseUrl, } from "../../db/clie
 import { getRequestOrgId, getRequestUserEmail, } from "../../server/request-context.js";
 import { parseArgs, fail } from "../utils.js";
 import { tryForwardDbQueryToDevServer } from "./dev-query-proxy.js";
-import { createPostgresScriptClient } from "./postgres-client.js";
+import { createPostgresScriptClient, withPostgresStatementDeadline, } from "./postgres-client.js";
 import { finalRawDbSql, readRawDbReadStatement, verifyRawDbStatement, } from "./safety.js";
 import { buildScopingPostgres } from "./scoping.js";
 function parseSqlArgs(raw) {
@@ -67,14 +67,15 @@ export async function runDbQuery(options) {
         let rows = [];
         try {
             await client.begin(async (tx) => {
-                const scoping = await buildScopingPostgres(tx);
+                const timedTx = withPostgresStatementDeadline(tx);
+                const scoping = await buildScopingPostgres(timedTx);
                 for (const setup of scoping.setup)
-                    await tx.unsafe(setup);
+                    await timedTx.unsafe(setup);
                 // From here on the transaction cannot write, so a data-modifying CTE,
                 // SELECT INTO, or EXPLAIN ANALYZE of a write fails instead of running.
-                await tx.unsafe("SET TRANSACTION READ ONLY");
-                await verifyRawDbStatement(tx, executed.statement);
-                const result = await tx.unsafe(executed.sql, sqlArgs, {
+                await timedTx.unsafe("SET TRANSACTION READ ONLY");
+                await verifyRawDbStatement(timedTx, executed.statement);
+                const result = await timedTx.unsafe(executed.sql, sqlArgs, {
                     singleStatement: true,
                 });
                 rows = Array.from(result);

package/dist/scripts/db/safety.js

@@ -50,6 +50,7 @@ const SENSITIVE_FRAMEWORK_TABLES = new Set([
     "users",
     "session",
     "sessions",
+    "chat_threads",
     "account",
     "accounts",
     "verification",
@@ -83,7 +84,7 @@ function assertNoSensitiveFrameworkTableTokens(tokens, operation) {
         const name = token.value.toLowerCase();
         if (!SENSITIVE_FRAMEWORK_TABLES.has(name))
             continue;
-        fail(`Sensitive framework table "${name}" is not ${sensitiveVerb(operation)} through raw DB tools. Use the framework auth, secrets, or OAuth APIs instead.`);
+        fail(`Sensitive framework table "${name}" is not ${sensitiveVerb(operation)} through raw DB tools. Use the appropriate framework API instead.`);
     }
 }
 export function assertNoSensitiveFrameworkTables(sql, operation) {

package/dist/secrets/routes.d.ts

@@ -57,39 +57,39 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
     errorCode?: undefined;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error: string;
     errorCode: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -117,11 +117,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/agent-chat-plugin.js

@@ -25,6 +25,7 @@ import { applyProviderModelSelection, providerForEngineName, resolveProviderMode
 import { startRun } from "../agent/run-manager.js";
 import { callerHasRunAccess, callerHasThreadAccess, } from "../agent/run-ownership.js";
 import { readBackgroundRunClaim } from "../agent/run-store.js";
+import { buildAssistantMessageFromRunJournal } from "../agent/run-thread-projector.js";
 import { buildCurrentTimeUserContext, buildRuntimeContextPrompt, } from "../agent/runtime-context.js";
 import { buildAssistantMessage, buildUserMessage, applySubmittedUserMessage, containsInlineAttachmentPayload, foldAgentChatRunCompletion, extractThreadMeta, foldUnstartedTurnFailure, mergeThreadDataForClientSave, } from "../agent/thread-data-builder.js";
 import { appendThreadDebugHistory } from "../agent/thread-debug-history.js";
@@ -2824,21 +2825,29 @@ export function createAgentChatPlugin(options) {
                 }
             }
             // Callback to persist agent response when run finishes (even if client disconnected).
-            // Reconstructs the assistant message from buffered events and appends to thread_data.
+            // Reconstructs the assistant message from the durable run journal.
             const onRunComplete = async (run, threadId, trackingSource) => {
                 const runThreadId = String(run?.threadId ?? threadId ?? "");
                 const chatScope = getRequestRunContext()?.chatScope;
-                const assistantMsg = buildAssistantMessage(run.events ?? [], run.runId, {
+                const assistantOptions = {
                     scope: chatScope,
                     suppressInternalContinuation: true,
-                    turnId: typeof run.turnId === "string" && run.turnId
-                        ? run.turnId
-                        : undefined,
-                    runDurationMs: typeof run.startedAt === "number" &&
-                        Number.isFinite(run.startedAt)
+                    runDurationMs: typeof run.startedAt === "number" && Number.isFinite(run.startedAt)
                         ? Math.max(0, Date.now() - run.startedAt)
                         : undefined,
-                });
+                };
+                const assistantMsg = runThreadId && run.turnId
+                    ? await buildAssistantMessageFromRunJournal({
+                        threadId: runThreadId,
+                        turnId: run.turnId,
+                        runId: run.runId,
+                        runEvents: run.events ?? [],
+                        options: assistantOptions,
+                    })
+                    : buildAssistantMessage(run.events ?? [], run.runId, {
+                        ...assistantOptions,
+                        turnId: run.turnId,
+                    });
                 const runContext = getRequestRunContext();
                 const failureCode = run.status === "errored"
                     ? [...(run.events ?? [])]