@agent-native/core 0.196.0 → 0.196.1-nightly-20260928204657

package/corpus/templates/clips/server/routes/api/thumbnail/[recordingId].get.ts

@@ -10,6 +10,7 @@ import {
   signShortLivedToken,
   verifyShortLivedToken,
 } from "@agent-native/core/server";
+import { AGENT_NATIVE_DEFAULT_SOCIAL_IMAGE } from "@agent-native/core/shared";
 import { resolveAccess } from "@agent-native/core/sharing";
 import { eq } from "drizzle-orm";
 import {
@@ -159,6 +160,18 @@ function imageResponse(
   return new Response(body, { status, headers });
 }
 
+function defaultSocialImageResponse(): Response {
+  return new Response(null, {
+    status: 302,
+    headers: {
+      Location: AGENT_NATIVE_DEFAULT_SOCIAL_IMAGE,
+      "Cache-Control": "private, max-age=0, no-store",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff",
+    },
+  });
+}
+
 async function fetchThumbnail(sourceUrl: string): Promise<Response> {
   let currentUrl = sourceUrl;
   const dispatcher = (await createSsrfSafeDispatcher()) ?? undefined;
@@ -325,20 +338,13 @@ export default defineEventHandler(async (event: H3Event) => {
         query.animated === "1"
           ? recording.animatedThumbnailUrl || recording.thumbnailUrl
           : recording.thumbnailUrl || recording.animatedThumbnailUrl;
-      if (!sourceUrl) {
-        setResponseStatus(event, 404);
-        return { error: "Thumbnail not found" };
-      }
+      if (!sourceUrl) return defaultSocialImageResponse();
 
       if (sourceUrl.startsWith("data:")) {
-        return (
-          dataUrlResponse(sourceUrl) ??
-          imageResponse(null, "text/plain; charset=utf-8", 415)
-        );
+        return dataUrlResponse(sourceUrl) ?? defaultSocialImageResponse();
       }
       if (isRecursiveThumbnailUrl(sourceUrl, recordingId)) {
-        setResponseStatus(event, 404);
-        return { error: "Thumbnail not found" };
+        return defaultSocialImageResponse();
       }
 
       let resolvedSourceUrl = sourceUrl;
@@ -360,17 +366,23 @@ export default defineEventHandler(async (event: H3Event) => {
               extra: { recordingId },
             },
           );
-          setResponseStatus(event, 502);
-          return { error: "The recording thumbnail could not be loaded." };
         }
-        return response;
+        const contentType = response.headers
+          .get("content-type")
+          ?.split(";", 1)[0]
+          ?.trim()
+          .toLowerCase();
+        return response.ok &&
+          contentType &&
+          SAFE_RASTER_IMAGE_TYPES.has(contentType)
+          ? response
+          : defaultSocialImageResponse();
       } catch (error) {
         captureRouteError(error, {
           route: "api/thumbnail",
           extra: { recordingId },
         });
-        setResponseStatus(event, 502);
-        return { error: "The recording thumbnail could not be loaded." };
+        return defaultSocialImageResponse();
       }
     },
   );

package/corpus/templates/clips/shared/ai-request-status.ts

@@ -48,3 +48,9 @@ export interface ClipsAiRequestStatus {
   requestedAt?: string;
   updatedAt?: string;
 }
+
+/** A recording the browser bridge may auto-title once it is old enough. */
+export interface AutoTitleCandidate {
+  id: string;
+  createdAt: string;
+}

package/corpus/templates/clips/shared/share-meta.ts

@@ -10,9 +10,6 @@ import {
   type SocialMetaDescriptor,
 } from "@agent-native/core/shared";
 
-import { buildAgentApiUrls } from "./agent-context";
-import { isLoomEmbedBackedRecording } from "./loom";
-
 export const CLIPS_DEFAULT_TITLE = "Untitled recording";
 
 export type ClipsShareMetaRecording = {
@@ -32,8 +29,6 @@ export type ClipsShareMetaRecording = {
   isLoomEmbedBacked?: boolean;
 };
 
-const SOCIAL_FRAME_AT_MS = 350;
-
 export type PreferredThumbnailVariant = "still" | "animated";
 
 export function preferredThumbnailVariant(
@@ -146,31 +141,11 @@ export function resolveClipsSocialImageUrl(options: {
   }
 
   if (!canUseSocialImage(recording)) return undefined;
-  if (
-    !origin ||
-    recording.isLoomEmbedBacked === true ||
-    isLoomEmbedBackedRecording(recording)
-  ) {
-    console.warn("clips.thumbnail.publish_fallback", {
-      recordingId: recording.id,
-      fallback: "default-image",
-    });
-    return AGENT_NATIVE_DEFAULT_SOCIAL_IMAGE;
-  }
-
   console.warn("clips.thumbnail.publish_fallback", {
     recordingId: recording.id,
-    fallback: "live-frame",
+    fallback: "default-image",
   });
-  const frameUrl = new URL(
-    buildAgentApiUrls(recording.id, {
-      origin,
-      basePath,
-    }).frameUrl(SOCIAL_FRAME_AT_MS),
-  );
-  const version = recording.updatedAt?.trim();
-  if (version) frameUrl.searchParams.set("v", version);
-  return frameUrl.toString();
+  return AGENT_NATIVE_DEFAULT_SOCIAL_IMAGE;
 }
 
 export function buildClipsShareMeta(options: {

package/corpus/templates/clips/{actions/lib → shared}/title-source.ts

@@ -15,13 +15,20 @@ export function isDefaultTitle(title: string | null | undefined): boolean {
   return !trimmed || trimmed === DEFAULT_RECORDING_TITLE;
 }
 
+/** Title sources an auto-generated title may overwrite. */
+export const AUTO_REPLACEABLE_TITLE_SOURCES = [
+  "default",
+  "context",
+] as const satisfies readonly RecordingTitleSource[];
+
 export function isAutoTitleReplaceable(
   title: string | null | undefined,
   titleSource: string | null | undefined,
 ): boolean {
   return (
     isDefaultTitle(title) ||
-    titleSource === "default" ||
-    titleSource === "context"
+    (AUTO_REPLACEABLE_TITLE_SOURCES as readonly string[]).includes(
+      titleSource ?? "",
+    )
   );
 }

package/corpus/templates/slides/changelog/2026-09-28-typing-in-slides-agent-chat-keeps-every-character-in-order.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-28
+---
+
+Typing in Slides agent chat keeps every character in order

package/corpus/templates/slides/scripts/edit-fidelity/README.md

@@ -15,6 +15,13 @@ Run the script from `templates/slides`:
 pnpm exec tsx scripts/edit-fidelity/run.ts [case-filter] [options]
 ```
 
+Run the focused chat caret regression while a synthetic slide text edit session
+is open in Chromium:
+
+```bash
+pnpm exec tsx scripts/edit-fidelity/run.ts --typing-chat
+```
+
 By default the harness starts its own scratch dev server with this command,
 run from the repo root:
 
@@ -47,6 +54,7 @@ because it creates and rewrites decks.
 | `--resume <run>`               | Reuse `<run>`'s output and keep every result that did not error                            |
 | `--cpu-throttle N`             | Slow each editor page's CPU N times, to reproduce timing-dependent saves                   |
 | `--headed`                     | Show the browser                                                                           |
+| `--typing-chat`                | Run only the Agent chat typing regression with a slide text edit session open              |
 
 Exit codes:
 
@@ -136,8 +144,9 @@ them per slide. For each target and scenario:
    stylesheet per slide font, so `fonts.ready` alone can resolve before the
    slide's font is requested. Scenarios never contaminate each other: a
    `pagehide` keepalive write from the previous page that carries other
-   content for this slide could land after the restore, so it errors the
-   scenario.
+   content for this slide could land after the restore. The harness retains
+   those request bodies, waits for the restored content to settle when one
+   could overwrite it, and errors if the fixture did not survive.
 2. **View.** Capture `view.png` and a style snapshot of the slide.
 3. **Enter edit.** Try click, then a second click, then double-click. The
    gesture that worked is recorded. A click must leave a caret within one

package/corpus/templates/slides/scripts/edit-fidelity/run.ts

@@ -134,6 +134,7 @@ const cpuThrottle = numOpt("--cpu-throttle", 1);
 const update = argv.includes("--update");
 const acceptFailing = argv.includes("--accept-failing");
 const headed = argv.includes("--headed");
+const typingChatOnly = argv.includes("--typing-chat");
 for (const s of scenarios) {
   if (!SCENARIOS.includes(s))
     fatal(`unknown scenario ${s}; expected ${SCENARIOS.join(",")}`);
@@ -532,6 +533,101 @@ async function exitEdit(
   return waitFor(async () => !(await editorState(page, slideId)).editing, 5000);
 }
 
+async function runChatTypingRegression(page: Page, base: string) {
+  await page.route("**/_agent-native/agent-engine/status", (route: any) =>
+    route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ configured: true, chatEligible: true }),
+    }),
+  );
+  await page.goto(`${base}/home`, { waitUntil: "domcontentloaded" });
+  await ensureSignedIn(page);
+  const created = await action(page, "create-deck", {
+    title: "[edit-fidelity] chat typing regression",
+    slides: [
+      {
+        id: "chat-typing-slide",
+        content:
+          '<div class="fmd-slide"><p>Slide text edit stays open</p></div>',
+      },
+    ],
+  });
+  const deckId = String(created.id ?? created.deckId);
+  await openSlide(page, base, deckId, 0, "chat-typing-slide");
+  const [target] = await listTargets(page, "chat-typing-slide");
+  if (!target) throw new Error("synthetic slide has no editable text target");
+  if (!(await enterEdit(page, "chat-typing-slide", target.point, []))) {
+    throw new Error("could not open the synthetic slide text edit session");
+  }
+
+  await page.evaluate(() =>
+    window.dispatchEvent(
+      new CustomEvent("agent-panel:open", { detail: { focus: true } }),
+    ),
+  );
+  const selector =
+    '.agent-sidebar-panel[data-agent-sidebar-state="open"] [data-agent-composer-slot="editor-input"]';
+  const composer = page.locator(selector);
+  await composer.waitFor({ state: "visible", timeout: 45_000 });
+  if (!(await editorState(page, "chat-typing-slide")).editing) {
+    throw new Error(
+      "opening the Agent sidebar ended the slide text edit session",
+    );
+  }
+  await page.waitForFunction(
+    (inputSelector: string) =>
+      document
+        .querySelector<HTMLElement>(inputSelector)
+        ?.getAttribute("contenteditable") === "true",
+    selector,
+    { timeout: 20_000 },
+  );
+  await composer.focus();
+
+  await composer.evaluate((element: HTMLElement) => {
+    (window as any).__typingRegressionComposer = element;
+  });
+
+  const first = "Fast typing should keep every character in order.";
+  const second = " A pause must not reset the caret either.";
+  await composer.pressSequentially(first);
+  await sleep(400);
+  await composer.pressSequentially(second);
+
+  const expected = first + second;
+  const result = await page.evaluate((selector: string) => {
+    const editor = document.querySelector<HTMLElement>(selector);
+    const selection = window.getSelection();
+    const focusNode = selection?.focusNode;
+    return {
+      text: editor?.innerText ?? null,
+      sameNode: editor === (window as any).__typingRegressionComposer,
+      focused: document.activeElement === editor,
+      caretOffset:
+        editor && focusNode && editor.contains(focusNode)
+          ? (selection?.focusOffset ?? null)
+          : null,
+    };
+  }, selector);
+  const editAfterTyping = await editorState(page, "chat-typing-slide");
+  const problems: string[] = [];
+  if (result.text !== expected) {
+    problems.push(`text mismatch: ${JSON.stringify(result.text)}`);
+  }
+  if (!result.sameNode) problems.push("composer remounted while typing");
+  if (!result.focused) problems.push("composer lost focus while typing");
+  if (result.caretOffset !== expected.length) {
+    problems.push(
+      `caret ended at ${result.caretOffset}, expected ${expected.length}`,
+    );
+  }
+  if (!editAfterTyping.editing) {
+    problems.push("slide text edit session ended while typing in chat");
+  }
+  return problems;
+}
+
 /**
  * Polls the stored slide until it stops changing and no write the page sent
  * is still in flight. Saves are debounced, so "no change yet" is only trusted
@@ -897,11 +993,30 @@ async function runScenario(
   page.on("requestfailed", onWriteDone);
 
   try {
+    await page.goto(`${ctx.base}/home`, { waitUntil: "domcontentloaded" });
+    const priorPagehideWrites = await takeKeepaliveWrites(page);
+    const priorPagehideMismatches = keepaliveMismatches(
+      priorPagehideWrites,
+      slideId,
+      ctx.stored,
+    );
     await restoreSlide(page, deckId, slideId, ctx.stored);
+    if (priorPagehideMismatches.length) {
+      const restored = await settleSaved(
+        page,
+        deckId,
+        slideId,
+        () => inFlight.size,
+        15_000,
+      );
+      if (restored !== ctx.stored) {
+        throw new Error(
+          `${priorPagehideMismatches.length} prior pagehide write(s) overwrote the restored slide`,
+        );
+      }
+    }
     await openSlide(page, ctx.base, deckId, ctx.slideIndex, slideId);
-    // Leaving the previous page fires pagehide after restoreSlide, so a
-    // keepalive flush it sent can land after the restore and change the
-    // slide this scenario starts from.
+    // Earlier writes were checked after settling; only new writes can still overwrite the fixture.
     const leftBehind = keepaliveMismatches(
       await takeKeepaliveWrites(page),
       slideId,
@@ -909,7 +1024,7 @@ async function runScenario(
     );
     if (leftBehind.length) {
       throw new Error(
-        `leaving the previous page sent ${leftBehind.length} keepalive write(s) that can overwrite the restored slide`,
+        `${leftBehind.length} pagehide keepalive write(s) can overwrite the restored slide`,
       );
     }
     const current = (await listTargets(page, slideId))[target.index];
@@ -1815,6 +1930,22 @@ async function main() {
     await warmUp(warm, base);
     await warm.close();
 
+    if (typingChatOnly) {
+      const page = await context.newPage();
+      const problems = await runChatTypingRegression(page, base);
+      await page.close();
+      if (problems.length) {
+        console.error(
+          `[edit-fidelity] chat typing regression: ${problems.join("; ")}`,
+        );
+        return 1;
+      }
+      console.log(
+        "[edit-fidelity] chat typing regression passed with a slide edit session open",
+      );
+      return 0;
+    }
+
     console.log(
       `[edit-fidelity] ${base} · ${cases.length} case(s) · scenarios ${scenarios.join(",")} · out ${outRoot}`,
     );

package/dist/agent/production-agent.js

@@ -7657,6 +7657,8 @@ export function createProductionAgentHandler(options) {
             backgroundFunction: runsInBackgroundFunction,
             noProgressTimeoutMs: options.runNoProgressTimeoutMs,
             turnId: effectiveTurnId,
+            agentKitApprovalContinuation: internalContinuation &&
+                Boolean(approvedToolCallsForExecution?.length),
             turnInitiator,
             parentId: requestParentId,
             waitUntil: getRequestRunContext()?.waitUntil,

package/dist/agent/run-manager.d.ts

@@ -6,6 +6,7 @@ export interface ActiveRun {
     threadId: string;
     parentId?: string | null;
     turnId: string;
+    agentKitApprovalContinuation?: boolean;
     events: RunEvent[];
     status: RunStatus;
     subscribers: Set<(event: RunEvent) => void>;
@@ -54,6 +55,7 @@ export interface StartRunOptions {
     softTimeoutMs?: number;
     useHostedSoftTimeoutDefault?: boolean;
     turnId?: string;
+    agentKitApprovalContinuation?: boolean;
     parentId?: string | null;
     backgroundFunction?: boolean;
     noProgressTimeoutMs?: number;

package/dist/agent/run-manager.js

@@ -486,6 +486,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         threadId,
         ...(options?.parentId !== undefined ? { parentId: options.parentId } : {}),
         turnId: options?.turnId ?? runId,
+        ...(options?.agentKitApprovalContinuation
+            ? { agentKitApprovalContinuation: true }
+            : {}),
         events: [],
         status: "running",
         subscribers: new Set(),
@@ -1795,7 +1798,8 @@ export async function getActiveRunForThreadAsync(threadId) {
     const memRun = getActiveRunForThread(threadId);
     if (memRun && (memRun.status === "running" || memRun.events.length > 0)) {
         const sqlSnapshot = await fetchRunThreadSnapshot(memRun.runId, threadId);
-        if (!sqlSnapshot && memRun.status !== "running") {
+        if (memRun.status !== "running" &&
+            (!sqlSnapshot || sqlSnapshot.status === "running")) {
             const successor = await fetchNewerNonTerminalRunForSameTurn(threadId, memRun);
             if (successor) {
                 return {
@@ -1813,7 +1817,10 @@ export async function getActiveRunForThreadAsync(threadId) {
                 };
             }
         }
-        const status = legacyWireRunStatus(sqlSnapshot?.status ?? memRun.status);
+        const sqlStatus = sqlSnapshot?.status === "running" && memRun.status !== "running"
+            ? memRun.status
+            : (sqlSnapshot?.status ?? memRun.status);
+        const status = legacyWireRunStatus(sqlStatus);
         const heartbeatAt = status === "running"
             ? Date.now()
             : (sqlSnapshot?.heartbeatAt ?? memRun.startedAt);

package/dist/agent/thread-data-builder.d.ts

@@ -107,6 +107,7 @@ export declare function foldAssistantTurn(repo: any, assistantMsg: AssistantMess
     turnId?: string;
     runId?: string;
     parentId?: string | null;
+    agentKitOwnsContinuation?: boolean;
 }): any;
 export declare function normalizeThreadTitle(value: unknown): string;
 export declare function extractThreadMeta(repo: any): {

package/dist/agent/thread-data-builder.js

@@ -1039,6 +1039,149 @@ export function claimQueuedMessage(repo, messageId) {
     normalized[CLAIMED_QUEUED_MESSAGE_IDS_KEY] = [...claimed, messageId].slice(-MAX_CLAIMED_QUEUED_MESSAGE_IDS);
     return pruneClaimedQueuedMessages(normalized);
 }
+function snapshotEntryId(entry, kind) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    if (kind === "widget") {
+        const messageId = entry.messageId;
+        const widgetId = entry.widget?.id;
+        return typeof messageId === "string" && typeof widgetId === "string"
+            ? JSON.stringify([messageId, widgetId])
+            : undefined;
+    }
+    return typeof entry.id === "string" ? entry.id : undefined;
+}
+function snapshotMessageRunIds(agentKit) {
+    const runIds = new Map();
+    for (const event of Array.isArray(agentKit?.events) ? agentKit.events : []) {
+        if ((event?.type === "message.created" ||
+            event?.type === "message.completed") &&
+            event.message?.role === "assistant" &&
+            typeof event.message.id === "string" &&
+            typeof event.runId === "string") {
+            runIds.set(event.message.id, event.runId);
+        }
+    }
+    for (const run of Array.isArray(agentKit?.runs) ? agentKit.runs : []) {
+        if (typeof run?.activeMessageId === "string" &&
+            typeof run.id === "string") {
+            runIds.set(run.activeMessageId, run.id);
+        }
+    }
+    return runIds;
+}
+function snapshotAssistantTextKey(message, runIds) {
+    const runId = (typeof message?.id === "string" ? runIds.get(message.id) : undefined) ??
+        message?.metadata?.runId ??
+        message?.metadata?.custom?.runId;
+    if (message?.role !== "assistant" ||
+        typeof runId !== "string" ||
+        !Array.isArray(message.parts) ||
+        message.parts.length === 0 ||
+        !message.parts.every((part) => part?.type === "text" && typeof part.text === "string")) {
+        return undefined;
+    }
+    return JSON.stringify([
+        runId,
+        message.parts.map((part) => [part.text, part.format ?? null]),
+    ]);
+}
+function preferIncomingSnapshotEntry(kind, existing, incoming) {
+    if (kind === "message") {
+        const rank = (message) => message.status === "complete" ? 2 : message.status === "error" ? 1 : 0;
+        if (rank(existing) !== rank(incoming))
+            return rank(incoming) > rank(existing);
+        const partCount = (message) => Array.isArray(message.parts) ? message.parts.length : 0;
+        if (partCount(existing) !== partCount(incoming)) {
+            return partCount(incoming) > partCount(existing);
+        }
+        const textLength = (message) => (Array.isArray(message.parts) ? message.parts : []).reduce((total, part) => total + (typeof part?.text === "string" ? part.text.length : 0), 0);
+        return textLength(incoming) > textLength(existing);
+    }
+    if (kind === "toolCall") {
+        return existing.status === "running" && incoming.status !== "running";
+    }
+    return (existing.widget?.state === "active" && incoming.widget?.state !== "active");
+}
+function mergeAgentKitHistoryArray(existing, incoming, kind, existingMessageRunIds, incomingMessageRunIds) {
+    if (!Array.isArray(existing) && !Array.isArray(incoming))
+        return undefined;
+    const merged = Array.isArray(existing) ? [...existing] : [];
+    const positions = new Map();
+    const assistantTextPositions = new Map();
+    merged.forEach((entry, index) => {
+        const id = snapshotEntryId(entry, kind);
+        if (id && !positions.has(id))
+            positions.set(id, index);
+        if (kind === "message") {
+            const key = snapshotAssistantTextKey(entry, existingMessageRunIds);
+            if (key) {
+                assistantTextPositions.set(key, [
+                    ...(assistantTextPositions.get(key) ?? []),
+                    index,
+                ]);
+            }
+        }
+    });
+    const matchedAssistantTextPositions = new Set();
+    for (const entry of Array.isArray(incoming) ? incoming : []) {
+        const id = snapshotEntryId(entry, kind);
+        const idIndex = id ? positions.get(id) : undefined;
+        const textKey = kind === "message"
+            ? snapshotAssistantTextKey(entry, incomingMessageRunIds)
+            : undefined;
+        const textIndex = idIndex === undefined && textKey
+            ? assistantTextPositions
+                .get(textKey)
+                ?.find((candidate) => !matchedAssistantTextPositions.has(candidate))
+            : undefined;
+        const index = idIndex ?? textIndex;
+        if (index === undefined) {
+            if (id)
+                positions.set(id, merged.length);
+            merged.push(entry);
+        }
+        else {
+            if (kind === "message")
+                matchedAssistantTextPositions.add(index);
+            if (id && idIndex === undefined)
+                positions.set(id, index);
+            const preferIncoming = preferIncomingSnapshotEntry(kind, merged[index], entry);
+            const preferCurrentMessageId = kind === "message" &&
+                textIndex !== undefined &&
+                !preferIncomingSnapshotEntry(kind, entry, merged[index]);
+            if (preferIncoming || preferCurrentMessageId) {
+                merged[index] = entry;
+            }
+        }
+    }
+    return merged;
+}
+function mergeAgentKitHistory(existing, incoming) {
+    if (!existing ||
+        typeof existing !== "object" ||
+        Array.isArray(existing) ||
+        !incoming ||
+        typeof incoming !== "object" ||
+        Array.isArray(incoming)) {
+        return incoming ?? existing;
+    }
+    const previous = existing;
+    const next = incoming;
+    const merged = { ...previous, ...next };
+    const existingMessageRunIds = snapshotMessageRunIds(previous);
+    const incomingMessageRunIds = snapshotMessageRunIds(next);
+    for (const [key, kind] of [
+        ["messages", "message"],
+        ["toolCalls", "toolCall"],
+        ["widgets", "widget"],
+    ]) {
+        const entries = mergeAgentKitHistoryArray(previous[key], next[key], kind, existingMessageRunIds, incomingMessageRunIds);
+        if (entries)
+            merged[key] = entries;
+    }
+    return merged;
+}
 function pruneClaimedQueuedMessages(repo) {
     if (!Array.isArray(repo?.queuedMessages))
         return repo;
@@ -1079,6 +1222,9 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
         merged.queuedMessages === undefined) {
         merged.queuedMessages = existingNormalized.queuedMessages;
     }
+    if (merged.agentKit !== undefined) {
+        merged.agentKit = mergeAgentKitHistory(existingNormalized?.agentKit, merged.agentKit);
+    }
     const existingMessages = Array.isArray(existingNormalized?.messages)
         ? existingNormalized.messages
         : null;
@@ -1509,6 +1655,8 @@ function appendFoldedContent(existing, incoming) {
     }).content;
 }
 export function foldAssistantTurn(repo, assistantMsg, options) {
+    if (options.agentKitOwnsContinuation)
+        return repo;
     const turnId = options.turnId;
     const runId = options.runId;
     if (!turnId)

package/dist/chat-threads/store.d.ts

@@ -73,6 +73,7 @@ export interface ForkThreadSourceSnapshot {
     title?: string;
     preview?: string;
     messageCount?: number;
+    fromMessageId?: string;
     scope?: ChatThreadScope | null;
 }
 export declare function createThread(ownerEmail: string, opts?: {