@agent-native/core 0.114.11 → 0.114.13

package/dist/observability/routes.d.ts

@@ -41,16 +41,16 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
@@ -59,10 +59,10 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

package/dist/progress/routes.d.ts

@@ -15,7 +15,7 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

package/dist/secrets/routes.d.ts

@@ -37,17 +37,17 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     status?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
     error: string;
     removed?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — re-run the validator against the
@@ -58,13 +58,13 @@ export declare function createTestSecretHandler(): import("h3").EventHandlerWith
     note?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,12 +95,12 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

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

@@ -27,11 +27,11 @@ 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 {};
 //# sourceMappingURL=agent-engine-api-key-route.d.ts.map

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

@@ -20,7 +20,7 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    error?: undefined;
     text: string;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=transcribe-voice.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.114.11",
+  "version": "0.114.13",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/src/application-state/index.ts

@@ -5,8 +5,10 @@ export {
   appStatePut,
   appStateDelete,
   appStateCompareAndSet,
+  appStateCompareAndSetMany,
   appStateList,
   appStateDeleteByPrefix,
+  type AppStateCompareAndSetOperation,
 } from "./store.js";
 
 // Emitter (for SSE wiring)
@@ -35,6 +37,7 @@ export {
   writeAppState,
   deleteAppState,
   compareAndSetAppState,
+  compareAndSetManyAppState,
   listAppState,
   deleteAppStateByPrefix,
   readAppStateForCurrentTab,

package/src/application-state/script-helpers.ts

@@ -18,8 +18,10 @@ import {
   appStatePut,
   appStateDelete,
   appStateCompareAndSet,
+  appStateCompareAndSetMany,
   appStateList,
   appStateDeleteByPrefix,
+  type AppStateCompareAndSetOperation,
 } from "./store.js";
 
 /**
@@ -74,7 +76,7 @@ export async function deleteAppState(key: string): Promise<boolean> {
 
 export async function compareAndSetAppState(
   key: string,
-  expectedValue: Record<string, unknown>,
+  expectedValue: Record<string, unknown> | null,
   nextValue: Record<string, unknown> | null,
 ): Promise<boolean> {
   const sessionId = await resolveSessionId();
@@ -83,6 +85,15 @@ export async function compareAndSetAppState(
   });
 }
 
+export async function compareAndSetManyAppState(
+  operations: readonly AppStateCompareAndSetOperation[],
+): Promise<boolean> {
+  const sessionId = await resolveSessionId();
+  return appStateCompareAndSetMany(sessionId, operations, {
+    requestSource: "agent",
+  });
+}
+
 export async function listAppState(
   prefix: string,
 ): Promise<Array<{ key: string; value: Record<string, unknown> }>> {

package/src/application-state/store.ts

@@ -1,9 +1,11 @@
 import {
   getDbExec,
+  getDialect,
   isLocalDatabase,
   isConnectionError,
   isPostgres,
   intType,
+  type DbExec,
 } from "../db/client.js";
 import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
@@ -194,39 +196,238 @@ export async function appStateDelete(
 export async function appStateCompareAndSet(
   sessionId: string,
   key: string,
-  expectedValue: Record<string, unknown>,
+  expectedValue: Record<string, unknown> | null,
   nextValue: Record<string, unknown> | null,
   options?: StoreWriteOptions,
 ): Promise<boolean> {
   await ensureTable();
   const client = getDbExec();
+  const changed = await executeAppStateCompareAndSet(
+    client,
+    sessionId,
+    key,
+    expectedValue,
+    nextValue,
+  );
+  if (changed) {
+    if (nextValue === null) {
+      emitAppStateDelete(key, options?.requestSource, sessionId);
+    } else {
+      emitAppStateChange(key, options?.requestSource, sessionId);
+    }
+  }
+  return changed;
+}
+
+export interface AppStateCompareAndSetOperation {
+  key: string;
+  expectedValue: Record<string, unknown> | null;
+  nextValue: Record<string, unknown> | null;
+}
+
+const APP_STATE_CAS_MISMATCH = Symbol("app-state-cas-mismatch");
+
+async function executeAppStateCompareAndSet(
+  client: DbExec,
+  sessionId: string,
+  key: string,
+  expectedValue: Record<string, unknown> | null,
+  nextValue: Record<string, unknown> | null,
+): Promise<boolean> {
+  const statement = buildAppStateCompareAndSetStatement(
+    sessionId,
+    key,
+    expectedValue,
+    nextValue,
+  );
+  const result = await client.execute(statement);
+  return result.rowsAffected > 0;
+}
+
+function buildAppStateCompareAndSetStatement(
+  sessionId: string,
+  key: string,
+  expectedValue: Record<string, unknown> | null,
+  nextValue: Record<string, unknown> | null,
+): { sql: string; args: unknown[] } {
+  if (expectedValue === null) {
+    if (nextValue === null) {
+      throw new Error(
+        "Application state CAS cannot replace absence with absence.",
+      );
+    }
+    const next = serializeAppStateValue(key, nextValue);
+    return {
+      sql: isPostgres()
+        ? `INSERT INTO application_state (session_id, key, value, updated_at) SELECT ?, ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM application_state WHERE session_id = ? AND key = ?) ON CONFLICT (session_id, key) DO NOTHING`
+        : `INSERT OR IGNORE INTO application_state (session_id, key, value, updated_at) SELECT ?, ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM application_state WHERE session_id = ? AND key = ?)`,
+      args: [sessionId, key, next, Date.now(), sessionId, key],
+    };
+  }
+
   const expected = JSON.stringify(expectedValue);
   if (nextValue === null) {
-    const result = await client.execute({
+    return {
       sql: `DELETE FROM application_state WHERE session_id = ? AND key = ? AND value = ?`,
       args: [sessionId, key, expected],
-    });
-    const changed = result.rowsAffected > 0;
-    if (changed) emitAppStateDelete(key, options?.requestSource, sessionId);
-    return changed;
+    };
   }
 
-  const next = JSON.stringify(nextValue);
+  const next = serializeAppStateValue(key, nextValue);
+  return {
+    sql: `UPDATE application_state SET value = ?, updated_at = ? WHERE session_id = ? AND key = ? AND value = ?`,
+    args: [next, Date.now(), sessionId, key, expected],
+  };
+}
+
+function buildD1CompareAndSetGuard(
+  sessionId: string,
+  guardKey: string,
+  operation: AppStateCompareAndSetOperation,
+): { sql: string; args: unknown[] } {
+  const expected = operation.expectedValue;
+  const condition =
+    expected === null
+      ? "NOT EXISTS (SELECT 1 FROM application_state WHERE session_id = ? AND key = ?)"
+      : "EXISTS (SELECT 1 FROM application_state WHERE session_id = ? AND key = ? AND value = ?)";
+  return {
+    sql: `INSERT INTO application_state (session_id, key, value, updated_at) SELECT ?, ?, '{}', ? WHERE NOT (${condition})`,
+    args:
+      expected === null
+        ? [sessionId, guardKey, Date.now(), sessionId, operation.key]
+        : [
+            sessionId,
+            guardKey,
+            Date.now(),
+            sessionId,
+            operation.key,
+            JSON.stringify(expected),
+          ],
+  };
+}
+
+function isD1CompareAndSetMismatch(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /unique constraint failed:\s*application_state\.session_id,\s*application_state\.key/i.test(
+    message,
+  );
+}
+
+function serializeAppStateValue(
+  key: string,
+  value: Record<string, unknown>,
+): string {
+  const serialized = JSON.stringify(value);
   if (
     !isLocalDatabase() &&
-    Buffer.byteLength(next, "utf8") > MAX_HOSTED_APP_STATE_VALUE_BYTES
+    Buffer.byteLength(serialized, "utf8") > MAX_HOSTED_APP_STATE_VALUE_BYTES
   ) {
     throw new Error(
       `application_state value "${key}" is too large for hosted SQL storage. Store large files, base64, or blobs in file storage and write only a URL or handle.`,
     );
   }
-  const result = await client.execute({
-    sql: `UPDATE application_state SET value = ?, updated_at = ? WHERE session_id = ? AND key = ? AND value = ?`,
-    args: [next, Date.now(), sessionId, key, expected],
-  });
-  const changed = result.rowsAffected > 0;
-  if (changed) emitAppStateChange(key, options?.requestSource, sessionId);
-  return changed;
+  return serialized;
+}
+
+export async function appStateCompareAndSetMany(
+  sessionId: string,
+  operations: readonly AppStateCompareAndSetOperation[],
+  options?: StoreWriteOptions,
+): Promise<boolean> {
+  if (operations.length === 0) return true;
+  const keys = new Set(operations.map(({ key }) => key));
+  if (keys.size !== operations.length) {
+    throw new Error("Application state multi-key CAS requires unique keys.");
+  }
+  for (const { key, nextValue } of operations) {
+    if (nextValue) serializeAppStateValue(key, nextValue);
+  }
+  const orderedOperations = [...operations].sort((a, b) =>
+    a.key.localeCompare(b.key),
+  );
+
+  await ensureTable();
+  const client = getDbExec();
+  if (getDialect() === "d1") {
+    if (!client.atomicBatch) {
+      throw new Error(
+        "D1 application-state CAS requires atomic batch support.",
+      );
+    }
+    const guardKey = `__agent_native_cas_guard__:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+    const guardInsert = {
+      sql: `INSERT INTO application_state (session_id, key, value, updated_at) VALUES (?, ?, '{}', ?)`,
+      args: [sessionId, guardKey, Date.now()],
+    };
+    const guards = orderedOperations.map((operation) =>
+      buildD1CompareAndSetGuard(sessionId, guardKey, operation),
+    );
+    const mutations = orderedOperations.map((operation) =>
+      buildAppStateCompareAndSetStatement(
+        sessionId,
+        operation.key,
+        operation.expectedValue,
+        operation.nextValue,
+      ),
+    );
+    let results;
+    try {
+      results = await client.atomicBatch([
+        guardInsert,
+        ...guards,
+        ...mutations,
+        {
+          sql: `DELETE FROM application_state WHERE session_id = ? AND key = ?`,
+          args: [sessionId, guardKey],
+        },
+      ]);
+    } catch (error) {
+      if (isD1CompareAndSetMismatch(error)) return false;
+      throw error;
+    }
+    const mutationResults = results.slice(
+      1 + guards.length,
+      1 + guards.length + mutations.length,
+    );
+    if (
+      mutationResults.length !== mutations.length ||
+      mutationResults.some((result) => result.rowsAffected !== 1)
+    ) {
+      throw new Error(
+        "D1 application-state CAS completed without applying every mutation.",
+      );
+    }
+  } else {
+    if (!client.transaction) {
+      throw new Error("Application state multi-key CAS requires transactions.");
+    }
+    try {
+      await client.transaction(async (tx) => {
+        for (const operation of orderedOperations) {
+          const changed = await executeAppStateCompareAndSet(
+            tx,
+            sessionId,
+            operation.key,
+            operation.expectedValue,
+            operation.nextValue,
+          );
+          if (!changed) throw APP_STATE_CAS_MISMATCH;
+        }
+      });
+    } catch (error) {
+      if (error === APP_STATE_CAS_MISMATCH) return false;
+      throw error;
+    }
+  }
+
+  for (const { key, nextValue } of operations) {
+    if (nextValue === null) {
+      emitAppStateDelete(key, options?.requestSource, sessionId);
+    } else {
+      emitAppStateChange(key, options?.requestSource, sessionId);
+    }
+  }
+  return true;
 }
 
 export async function appStateList(

package/src/client/extensions/EmbeddedExtension.tsx

@@ -177,6 +177,7 @@ export function EmbeddedExtension({
   // originates inside the same sandboxed realm as user code) and must be
   // ignored so a viewer cannot self-escalate to owner.
   const bindingLatchedRef = useRef(false);
+  const extensionRef = useRef(null as null | Extension);
 
   useEffect(() => {
     setIsDark(document.documentElement.classList.contains("dark"));
@@ -216,6 +217,7 @@ export function EmbeddedExtension({
     retry: shouldRetryExtensionLoad,
     retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 4000),
   });
+  extensionRef.current = extension ?? null;
 
   // Notify the host once when the extension can't be loaded for this viewer so
   // it can show a fallback instead of a blank panel.
@@ -338,6 +340,92 @@ export function EmbeddedExtension({
         return;
       }
 
+      if (message.type === "agent-native-extension-error-fix") {
+        const name = extensionRef.current?.name ?? extensionId;
+        const errors: string[] = Array.isArray((message as any).errors)
+          ? (message as any).errors
+          : [];
+        const errorDetails: Array<{ message: string; stack: string }> =
+          Array.isArray((message as any).errorDetails)
+            ? (message as any).errorDetails
+            : [];
+        const consoleLogs: Array<{ level: string; message: string }> =
+          Array.isArray((message as any).consoleLogs)
+            ? (message as any).consoleLogs
+            : [];
+        const networkLogs: Array<{
+          path: string;
+          method: string;
+          ok?: boolean;
+          status?: number;
+          error?: string;
+        }> = Array.isArray((message as any).networkLogs)
+          ? (message as any).networkLogs
+          : [];
+
+        const detailedTrace = errorDetails
+          .filter((e) => e && typeof e === "object")
+          .map((e) => {
+            const msg =
+              typeof e.message === "string" ? e.message : String(e.message);
+            return typeof e.stack === "string" ? `${msg}\n${e.stack}` : msg;
+          })
+          .join("\n\n");
+
+        // Force a fresh read from the server, same as ExtensionViewer's fix
+        // flow — the query cache may hold the agent's previous (broken) turn.
+        let freshContent: string | undefined;
+        try {
+          const res = await fetch(
+            agentNativePath(`/_agent-native/extensions/${extensionId}`),
+            { cache: "no-store" },
+          );
+          if (res.ok) {
+            const fresh = (await res.json()) as Extension;
+            freshContent =
+              typeof fresh?.content === "string" ? fresh.content : undefined;
+          }
+        } catch {
+          // Fall through with no snapshot — agent can still re-read via get-extension.
+        }
+
+        const contextParts = [
+          `The user is viewing a dashboard panel embedding extension "${name}" (id: ${extensionId}, slot: ${slotId}) and there are runtime errors that need fixing.`,
+          `\nFull error details:\n${detailedTrace}`,
+        ];
+
+        if (consoleLogs.length > 0) {
+          const consoleStr = consoleLogs
+            .map((l) => `[${l.level}] ${l.message}`)
+            .join("\n");
+          contextParts.push(`\nRecent console output:\n${consoleStr}`);
+        }
+
+        if (networkLogs.length > 0) {
+          const netStr = networkLogs
+            .map(
+              (l) =>
+                `${l.method} ${l.path} → ${l.ok ? l.status : "FAILED: " + (l.error || l.status)}`,
+            )
+            .join("\n");
+          contextParts.push(`\nRecent network requests:\n${netStr}`);
+        }
+
+        if (freshContent) {
+          contextParts.push(
+            `\nCurrent extension content (just re-read from the database — this is the authoritative source, not anything you may have written in a previous turn):\n\`\`\`html\n${freshContent}\n\`\`\``,
+          );
+        }
+
+        sendToAgentChat({
+          message: `Fix runtime errors in extension "${name}" (id: ${extensionId}), embedded as a dashboard panel. The content snapshot below was just re-read from the database — treat it as authoritative and ignore any prior version you may have generated in this chat. If in doubt, call get-extension first.\n\nErrors:\n${errors.join("\n")}`,
+          context: contextParts.join("\n"),
+          submit: true,
+          openSidebar: true,
+        });
+        return;
+      }
+
       if (message.type !== "agent-native-extension-request") return;
 
       const requestId = String(message.requestId ?? "");
@@ -410,7 +498,7 @@ export function EmbeddedExtension({
 
     window.addEventListener("message", handleMessage);
     return () => window.removeEventListener("message", handleMessage);
-  }, [extensionId]);
+  }, [extensionId, slotId]);
 
   if (!extension) {
     if (!isLoading && !isFetching) return null;

package/src/db/client.ts

@@ -29,6 +29,9 @@ export interface DbExec {
     sql: string | { sql: string; args?: unknown[] },
   ): Promise<{ rows: any[]; rowsAffected: number }>;
   transaction?<T>(fn: (tx: DbExec) => Promise<T>): Promise<T>;
+  atomicBatch?(
+    statements: readonly (string | { sql: string; args?: unknown[] })[],
+  ): Promise<Array<{ rows: any[]; rowsAffected: number }>>;
   /**
    * Release the underlying connection/pool held by this exec.
    * Only non-singleton execs created via `createDbExec()` (e.g. the migration
@@ -1100,7 +1103,17 @@ async function createDbExecInternal(
     };
     return {
       execute,
-      transaction: explicitTransaction(execute),
+      async atomicBatch(statements) {
+        const prepared = statements.map((statement) => {
+          if (typeof statement === "string") return d1.prepare(statement);
+          return d1.prepare(statement.sql).bind(...(statement.args ?? []));
+        });
+        const results = await d1.batch(prepared);
+        return results.map((result: any) => ({
+          rows: result.results || [],
+          rowsAffected: result.meta?.changes ?? 0,
+        }));
+      },
     };
   }
 
@@ -1558,6 +1571,10 @@ export function getDbExec(): DbExec {
       // After init, swap to a sanitizing wrapper around the real client
       const wrapper: DbExec = {
         execute: (s) => _exec!.execute(sanitize(s)),
+        atomicBatch: _exec!.atomicBatch
+          ? (statements) =>
+              _exec!.atomicBatch!(statements.map((s) => sanitize(s)))
+          : undefined,
         transaction: _exec!.transaction
           ? (fn) =>
               _exec!.transaction!((tx) =>
@@ -1582,6 +1599,10 @@ export function getDbExec(): DbExec {
       }
       const wrapper: DbExec = {
         execute: (s) => _exec!.execute(sanitize(s)),
+        atomicBatch: _exec!.atomicBatch
+          ? (statements) =>
+              _exec!.atomicBatch!(statements.map((s) => sanitize(s)))
+          : undefined,
         transaction: _exec!.transaction
           ? (innerFn) =>
               _exec!.transaction!((tx) =>
@@ -1601,8 +1622,30 @@ export function getDbExec(): DbExec {
           }),
         );
       }
+      if (_exec!.atomicBatch) {
+        throw new Error(
+          "This database supports atomic batches, not interactive transactions.",
+        );
+      }
       return explicitTransaction(wrapper.execute)(fn);
     },
+    async atomicBatch(statements) {
+      if (!_initPromise) _initPromise = initClient();
+      try {
+        await _initPromise;
+      } catch (err) {
+        _initPromise = undefined;
+        _exec = undefined;
+        throw err;
+      }
+      if (!_exec!.atomicBatch) {
+        throw new Error("This database does not support atomic batches.");
+      }
+      const batch = (items: typeof statements) =>
+        _exec!.atomicBatch!(items.map((item) => sanitize(item)));
+      Object.assign(proxy, { atomicBatch: batch });
+      return batch(statements);
+    },
   };
   return proxy;
 }