@agent-native/toolkit 0.20.2 → 0.20.3-nightly-20260916144018

package/src/composer/TiptapComposer.spec.ts

@@ -124,13 +124,14 @@ describe("createTiptapComposerExtensions", () => {
     );
   });
 
-  it("uses compact GPT-5.6 model and effort names in the collapsed trigger", () => {
-    expect(compactComposerModelName("gpt-5.6-sol")).toBe("GPT-5.6 Sol");
-    expect(compactComposerModelName("gpt-5-6-terra")).toBe("GPT-5.6 Terra");
-    expect(compactComposerModelName("openai/gpt-5.6-luna")).toBe(
-      "GPT-5.6 Luna",
+  it("uses concise OpenAI variant names in the trigger and picker", () => {
+    expect(compactComposerModelName("gpt-5.6-sol")).toBe("Sol");
+    expect(compactComposerModelName("gpt-5-6-terra")).toBe("Terra");
+    expect(compactComposerModelName("openai/gpt-5.6-luna")).toBe("Luna");
+    expect(compactComposerModelName("openai/gpt-6-astra")).toBe("Astra");
+    expect(compactComposerModelName("openai/gpt-6-astra-pro")).toBe(
+      "Astra Pro",
     );
-    expect(compactComposerModelName("openai/gpt-6-astra")).toBe("GPT-6 Astra");
     expect(compactComposerModelName("google/gemini-3.8-flash")).toBe(
       "Gemini 3.8 Flash",
     );
@@ -1267,12 +1268,26 @@ describe("createTiptapComposerExtensions", () => {
       (tab) => tab.textContent?.includes("Connect keys"),
     );
     expect(modelTab?.textContent).toContain("Connect keys");
+    act(() => modelButton?.click());
 
     act(() => root.render(React.createElement(Harness, { configured: true })));
     expect(
       container.querySelector('[data-agent-composer-slot="model-button"]')
         ?.textContent,
-    ).toContain("GPT-5.6 Luna");
+    ).toContain("Luna");
+
+    act(() =>
+      container
+        .querySelector<HTMLButtonElement>(
+          '[data-agent-composer-slot="model-button"]',
+        )
+        ?.click(),
+    );
+    const picker = document.querySelector(
+      '[data-agent-native-composer-popover="true"]',
+    );
+    expect(picker?.textContent).toContain("Luna");
+    expect(picker?.textContent).not.toContain("GPT-5.6 Luna");
   });
 
   it("resets a hidden model when switching to Claude Code", async () => {

package/src/composer/TiptapComposer.tsx

@@ -1094,8 +1094,8 @@ const FRIENDLY_MODEL_NAMES: Record<string, string> = {
   "kimi-k2-5": "Kimi K2.5",
   "deepseek-v3-1": "DeepSeek v3.1",
   "z-ai/glm-5.2": "GLM 5.2",
-  "openai/gpt-6-astra": "GPT-6 Astra",
-  "openai/gpt-6-astra-pro": "GPT-6 Astra Pro",
+  "openai/gpt-6-astra": "Astra",
+  "openai/gpt-6-astra-pro": "Astra Pro",
   "anthropic/claude-fable-5.1": "Fable 5.1",
   "google/gemini-3.8-flash": "Gemini 3.8 Flash",
   "qwen/qwen3.8-max-0902": "Qwen 3.8 Max",
@@ -1210,18 +1210,18 @@ function friendlyModelName(model: string, t?: ComposerTranslate): string {
     return `${tier} ${claude[2]}${claude[3] ? `.${claude[3]}` : ""}`;
   }
   // GPT: gpt-{major}-{minor}[-suffix] or gpt-{major}.{minor}[-suffix]
-  if (model.startsWith("gpt-")) {
-    const rest = model.slice(4);
+  if (isOpenAiModelId(model)) {
+    const normalizedModel = model.replace(/^openai\//i, "");
+    const rest = normalizedModel.slice(4);
     const gpt = rest.match(/^(\d+)[.-](\d+)(?:[.-](.+))?$/);
+    if (gpt?.[3]) {
+      return gpt[3]
+        .split("-")
+        .map((s) => s[0].toUpperCase() + s.slice(1))
+        .join(" ");
+    }
     if (gpt) {
-      const suffix = gpt[3]
-        ? " " +
-          gpt[3]
-            .split("-")
-            .map((s) => s[0].toUpperCase() + s.slice(1))
-            .join(" ")
-        : "";
-      return `GPT-${gpt[1]}.${gpt[2]}${suffix}`;
+      return `GPT-${gpt[1]}.${gpt[2]}`;
     }
     return `GPT-${rest}`;
   }
@@ -1253,14 +1253,6 @@ export function compactComposerModelName(
   model: string,
   t?: ComposerTranslate,
 ): string {
-  const gpt56Variant = model.match(
-    /^(?:openai\/)?gpt-5[.-]6[.-](sol|terra|luna)$/i,
-  )?.[1];
-  if (gpt56Variant) {
-    const variant =
-      gpt56Variant[0].toUpperCase() + gpt56Variant.slice(1).toLowerCase();
-    return `GPT-5.6 ${variant}`;
-  }
   return friendlyModelName(model, t);
 }
 

package/src/editor/useCollabReconcile.concurrent.spec.ts

@@ -49,6 +49,12 @@ interface HarnessProps {
   value: string;
   contentUpdatedAt: string;
   contentRevision?: string;
+  acknowledgedLocalSnapshot?: {
+    value: string;
+    revision: string;
+    updatedAt: string;
+    sequence: number;
+  } | null;
   editorOwnedFocus?: boolean;
   isEditorFocused?: () => boolean;
 }
@@ -80,6 +86,7 @@ function makeHarness() {
     value,
     contentUpdatedAt,
     contentRevision,
+    acknowledgedLocalSnapshot,
     editorOwnedFocus = false,
     isEditorFocused,
   }: HarnessProps) {
@@ -105,6 +112,7 @@ function makeHarness() {
       value,
       contentUpdatedAt,
       contentRevision,
+      acknowledgedLocalSnapshot,
       onBaseAwareReconcile: (result) => {
         (captured.reconciled ??= []).push({
           status: result.status,
@@ -997,6 +1005,225 @@ describe("useCollabReconcile — concurrent edit / lost-update guards", () => {
     ]);
   });
 
+  it("adopts an idle successful local-save echo as a base without replaying it", async () => {
+    vi.useFakeTimers();
+    const { captured, Harness } = makeHarness();
+    render(root, Harness, {
+      value: "Alpha",
+      contentUpdatedAt: "2024-01-01T00:00:01.000Z",
+      contentRevision: "revision-1",
+      editorOwnedFocus: true,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    act(() => captured.editor!.commands.setContent("Alpha partial"));
+    act(() => captured.editor!.commands.setContent("Alpha latest"));
+    await act(async () => vi.advanceTimersByTimeAsync(1600));
+
+    render(root, Harness, {
+      value: "Alpha partial",
+      contentUpdatedAt: "2024-01-01T00:00:02.000Z",
+      contentRevision: "revision-2",
+      acknowledgedLocalSnapshot: {
+        value: "Alpha partial",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+      editorOwnedFocus: true,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    expect(getEditorMarkdown(captured.editor!)).toBe("Alpha latest");
+    expect(captured.reconciled).toBeUndefined();
+  });
+
+  it("reconciles an external revert with distinct revision even when its content matches a prior local emission", async () => {
+    vi.useFakeTimers();
+    const { captured, Harness } = makeHarness();
+    render(root, Harness, {
+      value: "Base",
+      contentUpdatedAt: "2024-01-01T00:00:01.000Z",
+      contentRevision: "revision-1",
+      editorOwnedFocus: true,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    act(() => captured.editor!.commands.setContent("Earlier local value"));
+    act(() => captured.editor!.commands.setContent("Saved local base"));
+    render(root, Harness, {
+      value: "Saved local base",
+      contentUpdatedAt: "2024-01-01T00:00:02.000Z",
+      contentRevision: "revision-2",
+      acknowledgedLocalSnapshot: {
+        value: "Saved local base",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+      editorOwnedFocus: true,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    render(root, Harness, {
+      value: "Earlier local value",
+      contentUpdatedAt: "2024-01-01T00:00:03.000Z",
+      contentRevision: "revision-3",
+      acknowledgedLocalSnapshot: {
+        value: "Saved local base",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+      editorOwnedFocus: true,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+    expect(getEditorMarkdown(captured.editor!)).toBe("Saved local base");
+    await act(async () => vi.advanceTimersByTimeAsync(2200));
+
+    expect(getEditorMarkdown(captured.editor!)).toBe("Earlier local value");
+  });
+
+  it("merges a genuine remote change against the acknowledged local-save base", async () => {
+    vi.useFakeTimers();
+    const { captured, Harness } = makeHarness();
+    render(root, Harness, {
+      value: "Alpha\n\nBravo\n\nCharlie",
+      contentUpdatedAt: "2024-01-01T00:00:01.000Z",
+      contentRevision: "revision-1",
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    act(() =>
+      captured.editor!.commands.setContent(
+        "Alpha saved\n\nBravo\n\nCharlie local",
+      ),
+    );
+    render(root, Harness, {
+      value: "Alpha saved\n\nBravo\n\nCharlie",
+      contentUpdatedAt: "2024-01-01T00:00:02.000Z",
+      contentRevision: "revision-2",
+      acknowledgedLocalSnapshot: {
+        value: "Alpha saved\n\nBravo\n\nCharlie",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+    expect(getEditorMarkdown(captured.editor!)).toBe(
+      "Alpha saved\n\nBravo\n\nCharlie local",
+    );
+
+    render(root, Harness, {
+      value: "Alpha saved\n\nBravo server\n\nCharlie",
+      contentUpdatedAt: "2024-01-01T00:00:03.000Z",
+      contentRevision: "revision-3",
+      acknowledgedLocalSnapshot: {
+        value: "Alpha saved\n\nBravo\n\nCharlie",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    expect(getEditorMarkdown(captured.editor!)).toBe(
+      "Alpha saved\n\nBravo server\n\nCharlie local",
+    );
+    expect(captured.reconciled).toEqual([
+      {
+        status: "merged",
+        content: "Alpha saved\n\nBravo server\n\nCharlie local",
+      },
+    ]);
+
+    render(root, Harness, {
+      value: "Alpha saved\n\nBravo\n\nCharlie",
+      contentUpdatedAt: "2024-01-01T00:00:02.000Z",
+      contentRevision: "revision-2",
+      acknowledgedLocalSnapshot: {
+        value: "Alpha saved\n\nBravo\n\nCharlie",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+    expect(getEditorMarkdown(captured.editor!)).toBe(
+      "Alpha saved\n\nBravo server\n\nCharlie local",
+    );
+
+    render(root, Harness, {
+      value: "Alpha remote\n\nBravo server\n\nCharlie",
+      contentUpdatedAt: "2024-01-01T00:00:04.000Z",
+      contentRevision: "revision-4",
+      acknowledgedLocalSnapshot: {
+        value: "Alpha saved\n\nBravo\n\nCharlie",
+        revision: "revision-2",
+        updatedAt: "2024-01-01T00:00:02.000Z",
+        sequence: 1,
+      },
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+    expect(getEditorMarkdown(captured.editor!)).toBe(
+      "Alpha remote\n\nBravo server\n\nCharlie local",
+    );
+  });
+
+  it("does not clear a fresh conflict latch when an older acknowledged revision reappears", async () => {
+    vi.useFakeTimers();
+    const { captured, Harness } = makeHarness();
+    render(root, Harness, {
+      value: "Alpha",
+      contentUpdatedAt: "2024-01-01T00:00:01.000Z",
+      contentRevision: "revision-1",
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    act(() => captured.editor!.commands.setContent("Alpha latest"));
+    const acknowledgedLocalSnapshot = {
+      value: "Alpha saved",
+      revision: "revision-2",
+      updatedAt: "2024-01-01T00:00:02.000Z",
+      sequence: 1,
+    };
+    render(root, Harness, {
+      value: acknowledgedLocalSnapshot.value,
+      contentUpdatedAt: acknowledgedLocalSnapshot.updatedAt,
+      contentRevision: acknowledgedLocalSnapshot.revision,
+      acknowledgedLocalSnapshot,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    const conflictingRemote = {
+      value: "Alpha remote",
+      contentUpdatedAt: "2024-01-01T00:00:03.000Z",
+      contentRevision: "revision-3",
+      acknowledgedLocalSnapshot,
+    };
+    render(root, Harness, conflictingRemote);
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+    expect(captured.reconciled).toEqual([
+      { status: "conflict", content: "Alpha latest" },
+    ]);
+
+    render(root, Harness, {
+      value: acknowledgedLocalSnapshot.value,
+      contentUpdatedAt: acknowledgedLocalSnapshot.updatedAt,
+      contentRevision: acknowledgedLocalSnapshot.revision,
+      acknowledgedLocalSnapshot,
+    });
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+    render(root, Harness, conflictingRemote);
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    expect(getEditorMarkdown(captured.editor!)).toBe("Alpha latest");
+    expect(captured.reconciled).toEqual([
+      { status: "conflict", content: "Alpha latest" },
+    ]);
+  });
+
   it("persists the first local edit after a synced empty collaborative document", async () => {
     const captured: Captured = {
       editor: null,

package/src/editor/useCollabReconcile.ts

@@ -63,6 +63,17 @@ export interface UseCollabReconcileOptions {
   contentUpdatedAt?: string | null;
   /** Opaque authoritative body revision. Enables base-aware reconciliation. */
   contentRevision?: string | null;
+  /**
+   * A server-confirmed snapshot written by this editor. This is deliberately
+   * separate from `registerEmitted`: an emitted value may still fail to save,
+   * while an acknowledged revision is safe to adopt as the next merge base.
+   */
+  acknowledgedLocalSnapshot?: {
+    value: string;
+    revision: string;
+    updatedAt: string;
+    sequence: number;
+  } | null;
   /** This exact body revision is already represented in durable Yjs state. */
   collabContentRevision?: string | null;
   /** Resolves as synced only after a fresh provider response is applied. */
@@ -252,6 +263,7 @@ export function useCollabReconcile({
   value,
   contentUpdatedAt,
   contentRevision,
+  acknowledgedLocalSnapshot,
   collabContentRevision,
   requestCollabSync,
   onBaseAwareReconcile,
@@ -302,6 +314,15 @@ export function useCollabReconcile({
     revision: string;
   } | null>(contentRevision ? { value, revision: contentRevision } : null);
   const reportedConflictRevisionRef = useRef<string | null>(null);
+  const acknowledgedLocalSnapshotRef = useRef<{
+    value: string;
+    revision: string;
+    updatedAt: string;
+    sequence: number;
+  } | null>(null);
+  const latestObservedUpdatedAtRef = useRef<string | null>(
+    contentUpdatedAt ?? null,
+  );
   const acknowledgedCollabRef = useRef<{ ydoc: YDoc; revision: string } | null>(
     null,
   );
@@ -595,6 +616,69 @@ export function useCollabReconcile({
     // change isn't inserted twice (Yjs + setContent → duplicated region).
     const apply = (deferred = false) => {
       if (cancelled || editor.isDestroyed) return;
+      if (
+        contentUpdatedAt &&
+        (!latestObservedUpdatedAtRef.current ||
+          contentUpdatedAt > latestObservedUpdatedAtRef.current)
+      ) {
+        latestObservedUpdatedAtRef.current = contentUpdatedAt;
+      }
+      if (acknowledgedLocalSnapshot) {
+        const acceptedAcknowledgement = acknowledgedLocalSnapshotRef.current;
+        const acknowledgementIsNewestAccepted =
+          !acceptedAcknowledgement ||
+          acknowledgedLocalSnapshot.sequence > acceptedAcknowledgement.sequence;
+        const acknowledgementIsNotSuperseded =
+          !latestObservedUpdatedAtRef.current ||
+          acknowledgedLocalSnapshot.updatedAt >=
+            latestObservedUpdatedAtRef.current;
+        if (acknowledgementIsNewestAccepted && acknowledgementIsNotSuperseded) {
+          acknowledgedLocalSnapshotRef.current = acknowledgedLocalSnapshot;
+          authoritativeBaseRef.current = {
+            value: acknowledgedLocalSnapshot.value,
+            revision: acknowledgedLocalSnapshot.revision,
+          };
+          if (
+            !lastAppliedUpdatedAtRef.current ||
+            acknowledgedLocalSnapshot.updatedAt >
+              lastAppliedUpdatedAtRef.current
+          ) {
+            lastAppliedUpdatedAtRef.current =
+              acknowledgedLocalSnapshot.updatedAt;
+          }
+        }
+      }
+      const acknowledged = acknowledgedLocalSnapshotRef.current;
+      if (
+        acknowledged &&
+        contentRevision === acknowledged.revision &&
+        value === acknowledged.value
+      ) {
+        const acknowledgementWasSuperseded =
+          latestObservedUpdatedAtRef.current !== null &&
+          acknowledged.updatedAt < latestObservedUpdatedAtRef.current;
+        if (!acknowledgementWasSuperseded) {
+          authoritativeBaseRef.current = {
+            value: acknowledged.value,
+            revision: acknowledged.revision,
+          };
+          if (
+            !lastAppliedUpdatedAtRef.current ||
+            acknowledged.updatedAt > lastAppliedUpdatedAtRef.current
+          ) {
+            lastAppliedUpdatedAtRef.current = acknowledged.updatedAt;
+          }
+          reportedConflictRevisionRef.current = null;
+        }
+        return;
+      }
+      if (
+        acknowledged &&
+        contentUpdatedAt &&
+        contentUpdatedAt < acknowledged.updatedAt
+      ) {
+        return;
+      }
       // In collab mode, defer all reconcile until the shared doc is seeded so we
       // never setContent over an unseeded fragment.
       if (collab && !collabSynced) {
@@ -661,6 +745,7 @@ export function useCollabReconcile({
       if (
         currentMarkdown === normalizedValue ||
         (typingRecently &&
+          !contentRevision &&
           // A stale echo of our own (possibly partial) save while the user is
           // actively typing would clobber the fresh tail. Outside active
           // typing, the same bytes can be a deliberate newer external revert
@@ -905,6 +990,7 @@ export function useCollabReconcile({
   }, [
     contentUpdatedAt,
     contentRevision,
+    acknowledgedLocalSnapshot,
     editor,
     ydoc,
     editable,