@agent-native/core 0.165.1 → 0.165.3

package/dist/mcp-client/remote-store.js

@@ -21,8 +21,8 @@
  */
 import { createHash } from "node:crypto";
 import { writeAppSecret, readAppSecret, deleteAppSecret, } from "../secrets/storage.js";
-import { getOrgSetting, putOrgSetting, deleteOrgSetting, } from "../settings/org-settings.js";
-import { getUserSetting, putUserSetting, deleteUserSetting, } from "../settings/user-settings.js";
+import { getOrgSetting, mutateOrgSetting } from "../settings/org-settings.js";
+import { getUserSetting, mutateUserSetting, } from "../settings/user-settings.js";
 import { getMcpOAuthAccessToken, revokeMcpOAuthCredentials, saveMcpOAuthCredentials, } from "./oauth-client.js";
 import { validateRemoteUrl } from "./remote-url.js";
 export { validateRemoteUrl } from "./remote-url.js";
@@ -107,20 +107,21 @@ function sanitiseOrgId(orgId) {
     return orgId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
 }
 async function readList(scope, scopeId) {
-    const raw = scope === "user"
+    return parseServerList(scope === "user"
         ? await getUserSetting(scopeId, SETTINGS_KEY)
-        : await getOrgSetting(scopeId, SETTINGS_KEY);
+        : await getOrgSetting(scopeId, SETTINGS_KEY));
+}
+function parseServerList(raw) {
     if (!raw || !Array.isArray(raw.servers))
         return [];
     return raw.servers.filter((s) => s && typeof s.id === "string" && typeof s.url === "string");
 }
-async function writeList(scope, scopeId, servers) {
-    if (scope === "user") {
-        await putUserSetting(scopeId, SETTINGS_KEY, { servers });
-    }
-    else {
-        await putOrgSetting(scopeId, SETTINGS_KEY, { servers });
-    }
+async function mutateServerList(scope, scopeId, updater) {
+    const mutate = scope === "user" ? mutateUserSetting : mutateOrgSetting;
+    const next = await mutate(scopeId, SETTINGS_KEY, async (raw) => ({
+        servers: await updater(parseServerList(raw)),
+    }));
+    return parseServerList(next);
 }
 export async function listRemoteServers(scope, scopeId) {
     return readList(scope, scopeId);
@@ -228,6 +229,7 @@ export async function replaceOAuthRemoteServer(scope, scopeId, serverId, credent
         ...credentials,
         serverUrl: credentialResource.url.toString(),
     };
+    let updated;
     try {
         await saveMcpOAuthCredentials({
             key: nextSecretKey,
@@ -235,21 +237,22 @@ export async function replaceOAuthRemoteServer(scope, scopeId, serverId, credent
             scopeId,
             credentials: nextCredentials,
         });
-        const server = {
-            ...current,
-            url: nextCredentials.serverUrl,
-            oauthSecretKey: nextSecretKey,
-        };
-        const next = [...existing];
-        next[index] = server;
-        await writeList(scope, scopeId, next);
-        await revokeMcpOAuthCredentials({
-            key: current.oauthSecretKey,
-            scope,
-            scopeId,
-            serverUrl: current.url,
-        }).catch(() => undefined);
-        return { ok: true, server };
+        updated = await mutateServerList(scope, scopeId, (servers) => {
+            const latestIndex = servers.findIndex((server) => server.id === serverId);
+            const latest = latestIndex >= 0 ? servers[latestIndex] : undefined;
+            if (!latest ||
+                latest.oauthSecretKey !== current.oauthSecretKey ||
+                latest.url !== current.url) {
+                throw new Error("MCP server changed while reconnecting");
+            }
+            const next = [...servers];
+            next[latestIndex] = {
+                ...latest,
+                url: nextCredentials.serverUrl,
+                oauthSecretKey: nextSecretKey,
+            };
+            return next;
+        });
     }
     catch (err) {
         await revokeMcpOAuthCredentials({
@@ -263,6 +266,18 @@ export async function replaceOAuthRemoteServer(scope, scopeId, serverId, credent
             error: `Failed to replace MCP OAuth credentials: ${err?.message ?? err}`,
         };
     }
+    // The settings row now points at the replacement grant. Old-grant cleanup
+    // is best effort and must not roll back or invalidate the committed row.
+    await revokeMcpOAuthCredentials({
+        key: current.oauthSecretKey,
+        scope,
+        scopeId,
+        serverUrl: current.url,
+    }).catch(() => undefined);
+    const server = updated.find((candidate) => candidate.id === serverId);
+    return server
+        ? { ok: true, server }
+        : { ok: false, error: "MCP server was not found" };
 }
 export async function addFirstPartyRemoteServer(orgId, input) {
     const trust = await isFirstPartyRemoteEndpointTrusted(orgId, input.appId, input.url);
@@ -327,7 +342,24 @@ async function addRemoteServerInternal(scope, scopeId, input) {
         description: input.description?.trim() || undefined,
         createdAt: Date.now(),
     };
-    await writeList(scope, scopeId, [...existing, server]);
+    try {
+        await mutateServerList(scope, scopeId, (servers) => {
+            if (servers.some((candidate) => candidate.name === name)) {
+                throw new Error(`A server named "${name}" already exists`);
+            }
+            return [...servers, server];
+        });
+    }
+    catch (err) {
+        if (headerSecretKey) {
+            await deleteAppSecret({
+                key: headerSecretKey,
+                scope: toSecretScope(scope),
+                scopeId,
+            }).catch(() => undefined);
+        }
+        return { ok: false, error: err?.message ?? String(err) };
+    }
     return { ok: true, server };
 }
 function normalizeEndpointPath(pathname) {
@@ -396,9 +428,29 @@ export async function isFirstPartyRemoteEndpointTrusted(orgId, appId, endpoint)
 }
 export async function removeRemoteServer(scope, scopeId, id) {
     const existing = await readList(scope, scopeId);
-    const removed = existing.find((s) => s.id === id);
-    const next = existing.filter((s) => s.id !== id);
-    if (next.length === existing.length)
+    const expected = existing.find((s) => s.id === id);
+    if (!expected)
+        return false;
+    let removed;
+    try {
+        await mutateServerList(scope, scopeId, (servers) => {
+            removed = undefined;
+            const latest = servers.find((server) => server.id === id);
+            if (!latest)
+                return servers;
+            if (latest.oauthSecretKey !== expected.oauthSecretKey) {
+                throw new Error(`MCP OAuth credentials changed while removing ${expected.name}`);
+            }
+            removed = latest;
+            return servers.filter((server) => server.id !== id);
+        });
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.warn(`[mcp-client] Failed to remove MCP server ${expected.name}: ${err?.message ?? err}`);
+        return false;
+    }
+    if (!removed)
         return false;
     if (removed?.oauthSecretKey) {
         try {
@@ -409,8 +461,7 @@ export async function removeRemoteServer(scope, scopeId, id) {
                 serverUrl: removed.url,
             });
             if (result.local === "replaced") {
-                console.warn(`[mcp-client] MCP OAuth credentials changed while removing ${removed.name}; the server was kept so the newer connection remains manageable.`);
-                return false;
+                console.warn(`[mcp-client] MCP OAuth credentials changed while removing ${removed.name}; the server row was already removed.`);
             }
             if (result.remote === "failed") {
                 console.warn(`[mcp-client] MCP OAuth revocation failed for ${removed.name}; local credentials were removed.`);
@@ -421,17 +472,6 @@ export async function removeRemoteServer(scope, scopeId, id) {
             console.warn(`[mcp-client] Failed to delete MCP OAuth credentials ${removed.oauthSecretKey}: ${err?.message ?? err}`);
         }
     }
-    if (next.length === 0) {
-        if (scope === "user") {
-            await deleteUserSetting(scopeId, SETTINGS_KEY);
-        }
-        else {
-            await deleteOrgSetting(scopeId, SETTINGS_KEY);
-        }
-    }
-    else {
-        await writeList(scope, scopeId, next);
-    }
     // Best-effort: drop the encrypted-headers secret too. Errors are logged
     // but don't fail the deletion — the settings row is already gone, so a
     // dangling secret is harmless (it just can't be read back).

package/dist/notifications/routes.d.ts

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

package/dist/observability/routes.d.ts

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

package/dist/progress/routes.d.ts

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

package/dist/provider-api/actions/provider-api.js

@@ -193,6 +193,13 @@ export function createProviderApiDocsSchema(providerSchema = z.string().min(1))
         search: WebContentSearchSchema.optional().describe("Optional post-fetch search over extracted content by default. Supports query, queries, terms, regex, source, maxMatches, and contextChars."),
     });
 }
+const STAGED_DATASET_CAP_ERROR = /Staged dataset (?:byte )?cap exceeded/i;
+function rethrowStagingError(error) {
+    if (error instanceof Error && STAGED_DATASET_CAP_ERROR.test(error.message)) {
+        throw new Error(`${error.message} Recover by deleting older staged datasets with list-staged-datasets/delete-staged-dataset, or switch this request to saveToFile / a smaller staged result before trying again.`, { cause: error });
+    }
+    throw error;
+}
 export function createProviderApiRequestAction(runtime, options = {}) {
     const schema = options.schema ?? createProviderApiRequestSchema();
     return defineAction({
@@ -244,10 +251,15 @@ export function createProviderApiRequestAction(runtime, options = {}) {
                 if (!ownerEmail) {
                     throw new Error("No authenticated context for provider API staging.");
                 }
-                return stagingExecuteRequest(args, runtime.executeRequest, {
-                    appId: options.appId,
-                    ownerEmail,
-                });
+                try {
+                    return await stagingExecuteRequest(args, runtime.executeRequest, {
+                        appId: options.appId,
+                        ownerEmail,
+                    });
+                }
+                catch (error) {
+                    rethrowStagingError(error);
+                }
             }
             return runtime.executeRequest(args);
         },

package/dist/resources/handlers.d.ts

@@ -51,8 +51,8 @@ export declare function handleDeleteResource(event: any): Promise<{
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>;
 /** POST /_agent-native/resources/upload — upload a file as a resource */
 export declare function handleUploadResource(event: any): Promise<import("./store.js").Resource | {
@@ -73,10 +73,10 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
-    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;
+    error?: undefined;
 } | {
     error: string;
     storageSetupRequired: boolean;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
-    error?: undefined;
 }>>;
 export {};

package/dist/server/google-oauth-credentials.js

@@ -57,7 +57,20 @@ export async function resolveGoogleProviderCredentialCandidatesWithReader(option
  * remain the backwards-compatible provider OAuth credentials.
  */
 export function resolveGoogleSignInCredentials() {
-    return (readCredentialPair("GOOGLE_SIGN_IN_CLIENT_ID", "GOOGLE_SIGN_IN_CLIENT_SECRET") ?? readCredentialPair("GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"));
+    const signIn = readCredentialPair("GOOGLE_SIGN_IN_CLIENT_ID", "GOOGLE_SIGN_IN_CLIENT_SECRET");
+    const provider = readCredentialPair("GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET");
+    // Both pairs configured for different clients means one of them is dead
+    // config that nothing will ever read. Silence here cost a fleet-wide beta
+    // sign-in outage: GOOGLE_CLIENT_SECRET was repaired and verified while the
+    // callback kept using a stale GOOGLE_SIGN_IN_CLIENT_SECRET, so the repaired
+    // variable looked correct and changed nothing. Name the loser explicitly.
+    if (signIn && provider && signIn.clientId !== provider.clientId) {
+        console.warn("[agent-native][google-oauth] GOOGLE_SIGN_IN_CLIENT_ID and GOOGLE_CLIENT_ID " +
+            "are set to different Google clients. Sign-in uses GOOGLE_SIGN_IN_CLIENT_ID; " +
+            "GOOGLE_CLIENT_ID/SECRET are ignored for sign-in. Editing them will not " +
+            "change sign-in behaviour.");
+    }
+    return signIn ?? provider;
 }
 export function hasGoogleSignInCredentials() {
     return resolveGoogleSignInCredentials() !== null;

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
-    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
+    error?: undefined;
 }>>;

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    error?: undefined;
     text: string;
+    error?: undefined;
 }>>;

package/dist/settings/index.d.ts

@@ -1,4 +1,4 @@
-export { getSetting, mutateSetting, putSetting, deleteSetting, getAllSettings, getSettingsEmitter, type StoreWriteOptions, } from "./store.js";
+export { getSetting, mutateSetting, putSetting, deleteSetting, deleteSettingIfValue, getAllSettings, getSettingsEmitter, type StoreWriteOptions, } from "./store.js";
 export { getSettingHandler, putSettingHandler, deleteSettingHandler, } from "./handlers.js";
 export { readSetting, writeSetting, removeSetting } from "./script-helpers.js";
 export { getUserSetting, putUserSetting, deleteUserSetting, } from "./user-settings.js";

package/dist/settings/index.js

@@ -1,5 +1,5 @@
 // Store
-export { getSetting, mutateSetting, putSetting, deleteSetting, getAllSettings, getSettingsEmitter, } from "./store.js";
+export { getSetting, mutateSetting, putSetting, deleteSetting, deleteSettingIfValue, getAllSettings, getSettingsEmitter, } from "./store.js";
 // H3 route handlers
 export { getSettingHandler, putSettingHandler, deleteSettingHandler, } from "./handlers.js";
 // Script helpers

package/dist/settings/store.d.ts

@@ -1,7 +1,11 @@
 import type { EventEmitter } from "node:events";
 export declare function getSettingsEmitter(): EventEmitter;
 export declare function ensureTable(): Promise<void>;
-export declare function getSetting(key: string): Promise<Record<string, unknown> | null>;
+export interface StoreReadOptions {
+    /** Skip the per-request snapshot when a cross-request race must be checked. */
+    bypassCache?: boolean;
+}
+export declare function getSetting(key: string, options?: StoreReadOptions): Promise<Record<string, unknown> | null>;
 export interface StoreWriteOptions {
     /** Tag identifying who initiated this write (e.g. a tab ID). */
     requestSource?: string;
@@ -16,6 +20,8 @@ export interface StoreWriteOptions {
 export declare function mutateSetting(key: string, updater: (current: Record<string, unknown> | null) => Record<string, unknown> | Promise<Record<string, unknown>>, options?: StoreWriteOptions): Promise<Record<string, unknown>>;
 export declare function putSetting(key: string, value: Record<string, unknown>, options?: StoreWriteOptions): Promise<void>;
 export declare function deleteSetting(key: string, options?: StoreWriteOptions): Promise<boolean>;
+/** Delete a setting only when its stored value still matches the inspected value. */
+export declare function deleteSettingIfValue(key: string, expected: Record<string, unknown>, options?: StoreWriteOptions): Promise<boolean>;
 /**
  * Delete every setting whose key starts with `prefix`. Returns the number of
  * rows removed. Used when an owning entity is deleted (e.g. an organization

package/dist/settings/store.js

@@ -115,9 +115,9 @@ export async function ensureTable() {
     }
     return _initPromise;
 }
-export async function getSetting(key) {
+export async function getSetting(key, options) {
     const cache = requestSettingsCache();
-    if (cache?.has(key)) {
+    if (!options?.bypassCache && cache?.has(key)) {
         const cached = cache.get(key);
         return cached == null ? null : JSON.parse(cached);
     }
@@ -129,7 +129,8 @@ export async function getSetting(key) {
         args: [key],
     });
     const raw = rows.length === 0 ? null : rows[0].value;
-    cache?.set(key, raw);
+    if (!options?.bypassCache)
+        cache?.set(key, raw);
     return raw == null ? null : JSON.parse(raw);
 }
 const SETTINGS_MUTATION_ATTEMPTS = 25;
@@ -221,6 +222,27 @@ export async function deleteSetting(key, options) {
     }
     return false;
 }
+/** Delete a setting only when its stored value still matches the inspected value. */
+export async function deleteSettingIfValue(key, expected, options) {
+    await ensureTable();
+    const client = getDbExec();
+    const table = settingsTable();
+    const result = await client.execute({
+        sql: `DELETE FROM ${table} WHERE key = ? AND value = ?`,
+        args: [key, JSON.stringify(expected)],
+    });
+    if (result.rowsAffected === 0)
+        return false;
+    requestSettingsCache()?.set(key, null);
+    invalidateRequestAllSettings();
+    settingsEmitter().emit("settings", {
+        source: "settings",
+        type: "delete",
+        key,
+        ...(options?.requestSource && { requestSource: options.requestSource }),
+    });
+    return true;
+}
 /**
  * Delete every setting whose key starts with `prefix`. Returns the number of
  * rows removed. Used when an owning entity is deleted (e.g. an organization

package/dist/settings/user-settings.d.ts

@@ -12,5 +12,7 @@ import { type StoreWriteOptions } from "./store.js";
 export declare function getUserSetting(email: string, key: string): Promise<Record<string, unknown> | null>;
 /** Write a user-scoped setting. Always writes to the prefixed key. */
 export declare function putUserSetting(email: string, key: string, value: Record<string, unknown>, options?: StoreWriteOptions): Promise<void>;
+/** Atomically derive and persist one user-scoped setting. */
+export declare function mutateUserSetting(email: string, key: string, updater: (current: Record<string, unknown> | null) => Record<string, unknown> | Promise<Record<string, unknown>>, options?: StoreWriteOptions): Promise<Record<string, unknown>>;
 /** Delete a user-scoped setting. */
 export declare function deleteUserSetting(email: string, key: string, options?: StoreWriteOptions): Promise<boolean>;

package/dist/settings/user-settings.js

@@ -7,7 +7,7 @@
  * No global fallback — each user starts with a clean slate. This
  * prevents one user's private data from leaking to other users.
  */
-import { getSetting, putSetting, deleteSetting, } from "./store.js";
+import { getSetting, mutateSetting, putSetting, deleteSettingIfValue, } from "./store.js";
 function userKey(email, key) {
     return `u:${email.trim().toLowerCase()}:${key}`;
 }
@@ -31,7 +31,70 @@ export async function getUserSetting(email, key) {
 export async function putUserSetting(email, key, value, options) {
     return putSetting(userKey(email, key), value, options);
 }
+/** Atomically derive and persist one user-scoped setting. */
+export async function mutateUserSetting(email, key, updater, options) {
+    const normalized = userKey(email, key);
+    const legacy = legacyUserKey(email, key);
+    let migratedLegacy = false;
+    let migratedLegacyValue = null;
+    const result = await mutateSetting(normalized, async (current) => {
+        if (current !== null) {
+            migratedLegacy = false;
+            migratedLegacyValue = null;
+            return updater(current);
+        }
+        const legacyCurrent = legacy === normalized
+            ? null
+            : await getSetting(legacy, { bypassCache: true });
+        migratedLegacy = legacyCurrent !== null;
+        migratedLegacyValue = legacyCurrent;
+        return updater(legacyCurrent);
+    }, options);
+    if (!migratedLegacy)
+        return result;
+    // If the legacy row disappeared after the updater read it, a concurrent
+    // delete won the race. Remove only our exact canonical write; never delete
+    // a newer canonical value from another writer.
+    if (!migratedLegacyValue ||
+        !(await deleteSettingIfValue(legacy, migratedLegacyValue, options))) {
+        if (await getSetting(legacy, { bypassCache: true }))
+            return result;
+        const removed = await deleteSettingIfValue(normalized, result, options);
+        if (!removed) {
+            // The canonical write committed successfully. A concurrent canonical
+            // writer may have replaced it after the legacy row disappeared; keep
+            // the committed value visible instead of making callers revoke side
+            // effects for a write that is already persisted.
+            return result;
+        }
+        throw new Error("User setting was deleted while migrating its legacy key");
+    }
+    return result;
+}
 /** Delete a user-scoped setting. */
 export async function deleteUserSetting(email, key, options) {
-    return deleteSetting(userKey(email, key), options);
+    const normalized = userKey(email, key);
+    const legacy = legacyUserKey(email, key);
+    const normalizedCurrent = await getSetting(normalized, {
+        bypassCache: true,
+    });
+    if (legacy === normalized) {
+        return normalizedCurrent === null
+            ? false
+            : deleteSettingIfValue(normalized, normalizedCurrent, options);
+    }
+    const legacyCurrent = await getSetting(legacy, { bypassCache: true });
+    // Retire the fallback row first. If the canonical delete fails, the
+    // remaining canonical value still wins reads instead of resurrecting legacy
+    // data after a partial delete; a retry can safely finish the operation.
+    const deletedLegacy = legacyCurrent === null
+        ? false
+        : await deleteSettingIfValue(legacy, legacyCurrent, options);
+    const normalizedAfterLegacyCleanup = normalizedCurrent === null && deletedLegacy
+        ? await getSetting(normalized, { bypassCache: true })
+        : normalizedCurrent;
+    const deletedNormalized = normalizedAfterLegacyCleanup === null
+        ? false
+        : await deleteSettingIfValue(normalized, normalizedAfterLegacyCleanup, options);
+    return deletedNormalized || deletedLegacy;
 }

package/dist/templates/chat/CHANGELOG.md

@@ -3,8 +3,34 @@
 All notable user-facing changes to Chat are documented here. Open it any
 time from the command menu (Cmd+K → "What's new").
 
-## 2026-06-23
+Older updates live in [the changelog folder](./changelog/) and are included in the in-app "What's new" view.
 
-### Added
+## 2026-08-11
 
-- See what's new right inside Chat — a changelog now lives in the command menu (Cmd+K).
+### Fixed
+
+- Chrome no longer offers to install Chat as a desktop app.
+
+## 2026-08-10
+
+### Improved
+
+- Full-page chat now uses the available width up to 1000px for more comfortable prompts and responses.
+
+## 2026-07-31
+
+### Improved
+
+- Clicking the Agent Native logo now toggles the app sidebar.
+
+## 2026-07-29
+
+### Improved
+
+- Sidebar footers now keep Feedback, Search, and Collapse together without a separate language shortcut.
+
+## 2026-07-25
+
+### Improved
+
+- Settings navigation now keeps Manage agent as a dedicated linked destination at the bottom.