@agent-native/core 0.182.1 → 0.182.2-nightly-20260917210345

package/corpus/templates/design/shared/component-library.ts

@@ -22,7 +22,11 @@ import {
   buildCodeLayerProjection,
   type CodeLayerSource,
 } from "./code-layer.js";
-import { componentNameFor, isComponentInstance } from "./component-model.js";
+import {
+  COMPONENT_ID_ATTR,
+  COMPONENT_REF_ATTR,
+  componentNameFor,
+} from "./component-model.js";
 
 export interface ComponentLibraryFile {
   id: string;
@@ -34,6 +38,10 @@ export interface ComponentLibraryFile {
 export interface ComponentLibraryEntry {
   /** Component name from `data-agent-native-component`. */
   name: string;
+  /** Opaque id on a canonical component root, when present. */
+  componentId?: string;
+  /** Opaque id referenced by a linked component instance, when present. */
+  componentRef?: string;
   fileId: string;
   filename: string;
   /** `data-agent-native-node-id` (or fallback) of the instance root. */
@@ -50,7 +58,12 @@ export interface ComponentLibraryEntry {
 export function scanComponentLibrary(
   files: ComponentLibraryFile[],
 ): ComponentLibraryEntry[] {
-  const entries: ComponentLibraryEntry[] = [];
+  const entries: Array<
+    Omit<ComponentLibraryEntry, "name"> & {
+      name?: string;
+    }
+  > = [];
+  const namesByIdentity = new Map<string, string>();
 
   for (const file of files) {
     const html = file.content ?? "";
@@ -68,9 +81,15 @@ export function scanComponentLibrary(
     });
 
     for (const node of projection.nodes) {
-      if (!isComponentInstance(node)) continue;
-      const name = componentNameFor(node);
-      if (!name) continue;
+      const name = componentNameFor(node) ?? undefined;
+      const componentId =
+        node.dataAttributes[COMPONENT_ID_ATTR]?.trim() || undefined;
+      const componentRef =
+        node.dataAttributes[COMPONENT_REF_ATTR]?.trim() || undefined;
+      if (!name && !componentId && !componentRef) continue;
+
+      if (name && componentId) namesByIdentity.set(componentId, name);
+      if (name && componentRef) namesByIdentity.set(componentRef, name);
 
       // `node.id` is an ephemeral id scoped to this one projection call — it
       // is NOT the same as the durable `data-agent-native-node-id` attribute
@@ -85,6 +104,8 @@ export function scanComponentLibrary(
 
       entries.push({
         name,
+        componentId,
+        componentRef,
         fileId: file.id,
         filename: file.filename,
         nodeId,
@@ -93,7 +114,16 @@ export function scanComponentLibrary(
     }
   }
 
-  return entries;
+  return entries.flatMap((entry) => {
+    const name =
+      entry.name ??
+      (entry.componentRef
+        ? namesByIdentity.get(entry.componentRef)
+        : entry.componentId
+          ? namesByIdentity.get(entry.componentId)
+          : undefined);
+    return name ? [{ ...entry, name }] : [];
+  });
 }
 
 /**

package/corpus/templates/design/shared/component-model.ts

@@ -44,6 +44,10 @@ export const COMPONENT_OVERRIDES_ATTR = "data-agent-native-component-overrides";
 /** Prefix for simple prop attributes stamped next to the component root. */
 export const COMPONENT_PROP_PREFIX = "data-agent-native-prop-";
 
+export function componentIndexId(designId: string, name: string): string {
+  return `ci_${designId}_${name.toLowerCase().replace(/[^a-z0-9]/g, "_")}`;
+}
+
 // ─── Extracted prop value ─────────────────────────────────────────────────────
 
 export interface ComponentPropValue {
@@ -228,14 +232,16 @@ export function instanceFromNode(
   const alpineDataRaw = node.attributes["x-data"];
   const alpineData =
     typeof alpineDataRaw === "string" ? alpineDataRaw : undefined;
+  const stableNodeId =
+    node.dataAttributes["data-agent-native-node-id"]?.trim() || node.id;
 
   return {
-    instanceId: node.id,
+    instanceId: stableNodeId,
     name,
     props: extractProps(node),
     alpineData,
     selector: node.selector,
-    nodeId: node.id,
+    nodeId: stableNodeId,
     componentIndexId,
     componentId: node.dataAttributes[COMPONENT_ID_ATTR]?.trim() || undefined,
     componentRef: node.dataAttributes[COMPONENT_REF_ATTR]?.trim() || undefined,

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/client/chat/agentkit-protocol.js

@@ -1,4 +1,7 @@
 import { AGENTKIT_PROTOCOL_VERSION, AgentProtocolValidationError, approvalResponseFromResume, createCapabilityUnavailableError, createCapabilityUnsupportedError, inferAgentActivityKind, negotiateAgentKitProtocolVersion, resumeEntryFromApproval, resumeOptionId, } from "@agent-native/agentkit/protocol";
+function isTerminalRunStatus(status) {
+    return (status === "completed" || status === "failed" || status === "cancelled");
+}
 const TOOL_RESULT_MEDIA_TYPE = "application/x-agent-native-tool-result";
 const TOOL_CALL_MEDIA_TYPE = "application/x-agent-native-tool-call";
 const RUNTIME_PART_MEDIA_TYPE = "application/x-agent-native-runtime-part";
@@ -905,12 +908,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
     }
     function append(run, event) {
         const lastType = run.events.at(-1)?.type;
-        if (lastType === "run.completed" ||
-            lastType === "run.failed" ||
-            lastType === "run.cancelled") {
-            return;
-        }
-        const terminalActivityStatus = event.type === "run.completed" ||
+        const terminalStatus = event.type === "run.completed" ||
             (event.type === "run.status" && event.status === "completed")
             ? "completed"
             : event.type === "run.failed" ||
@@ -920,20 +918,32 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     (event.type === "run.status" && event.status === "cancelled")
                     ? "cancelled"
                     : undefined;
-        if (terminalActivityStatus && run.activeActivities.size > 0) {
-            const completedAt = event.occurredAt ?? now();
-            for (const activity of [...run.activeActivities.values()]) {
-                append(run, {
-                    type: "activity.completed",
-                    occurredAt: completedAt,
-                    metadata: event.metadata,
-                    activity: {
-                        ...activity,
-                        status: terminalActivityStatus,
-                        completedAt,
-                    },
-                });
+        const terminalFollowup = run.terminal &&
+            lastType === "run.status" &&
+            ((run.status === "completed" && event.type === "run.completed") ||
+                (run.status === "failed" && event.type === "run.failed") ||
+                (run.status === "cancelled" && event.type === "run.cancelled"));
+        if (lastType === "run.completed" ||
+            lastType === "run.failed" ||
+            lastType === "run.cancelled") {
+            return;
+        }
+        if (run.terminal &&
+            run.terminalAppendDepth === 0 &&
+            !terminalFollowup &&
+            !(terminalStatus && !isTerminalRunStatus(run.status))) {
+            return;
+        }
+        if (terminalStatus && run.terminalAppendDepth === 0) {
+            run.terminalAppendDepth = 1;
+            try {
+                appendTerminalFollowups(run, event, terminalStatus);
+                append(run, event);
             }
+            finally {
+                run.terminalAppendDepth = 0;
+            }
+            return;
         }
         const { occurredAt: eventTime, ...payload } = event;
         const sequence = run.sequence + 1;
@@ -948,6 +958,10 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             metadata: mergeProtocolMetadata(run.metadata, event.metadata),
         };
         run.events.push(protocolEvent);
+        if (protocolEvent.type === "message.completed" &&
+            protocolEvent.message.id === run.activeMessageId) {
+            run.activeMessageCompleted = true;
+        }
         if (protocolEvent.type === "activity.started" ||
             protocolEvent.type === "activity.updated" ||
             protocolEvent.type === "activity.completed") {
@@ -958,6 +972,17 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 run.activeActivities.delete(protocolEvent.activity.id);
             }
         }
+        if (protocolEvent.type === "tool.started") {
+            run.activeTools.set(protocolEvent.toolCall.id, protocolEvent.toolCall);
+        }
+        else if (protocolEvent.type === "tool.updated") {
+            if (protocolEvent.toolCall.status === "running") {
+                run.activeTools.set(protocolEvent.toolCall.id, protocolEvent.toolCall);
+            }
+            else {
+                run.activeTools.delete(protocolEvent.toolCall.id);
+            }
+        }
         if (run.events.length > maxRetainedEvents) {
             run.events.splice(0, run.events.length - maxRetainedEvents);
             run.firstRetainedSequence = run.events[0]?.sequence ?? run.sequence + 1;
@@ -965,6 +990,15 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         let becameTerminal = false;
         if (protocolEvent.type === "run.status") {
             run.status = protocolEvent.status;
+            if (protocolEvent.status === "completed" ||
+                protocolEvent.status === "failed" ||
+                protocolEvent.status === "cancelled") {
+                run.completedAt = protocolEvent.occurredAt;
+                run.terminalAtMs = timeMs(protocolEvent.occurredAt);
+                run.actions.clear();
+                run.terminal = true;
+                becameTerminal = true;
+            }
         }
         else if (protocolEvent.type === "run.started") {
             run.startedAt = protocolEvent.occurredAt;
@@ -973,7 +1007,11 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             run.status = "completed";
             run.completedAt = protocolEvent.occurredAt;
             run.terminalAtMs = timeMs(protocolEvent.occurredAt);
+            if (protocolEvent.usage !== undefined) {
+                run.usage = protocolEvent.usage;
+            }
             run.actions.clear();
+            run.terminal = true;
             becameTerminal = true;
         }
         else if (protocolEvent.type === "run.cancelled") {
@@ -981,6 +1019,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             run.completedAt = protocolEvent.occurredAt;
             run.terminalAtMs = timeMs(protocolEvent.occurredAt);
             run.actions.clear();
+            run.terminal = true;
             becameTerminal = true;
         }
         else if (protocolEvent.type === "run.failed") {
@@ -989,6 +1028,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             run.terminalAtMs = timeMs(protocolEvent.occurredAt);
             run.error = protocolEvent.error;
             run.actions.clear();
+            run.terminal = true;
             becameTerminal = true;
         }
         for (const listener of run.listeners)
@@ -996,6 +1036,82 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         if (becameTerminal)
             pruneRetainedRuns(run.terminalAtMs);
     }
+    function appendTerminalFollowups(run, event, terminalStatus) {
+        if (run.activeMessageId && !run.activeMessageCompleted) {
+            append(run, {
+                type: "message.completed",
+                occurredAt: event.occurredAt ?? now(),
+                metadata: event.metadata,
+                message: {
+                    id: run.activeMessageId,
+                    role: "assistant",
+                    status: terminalStatus === "completed" ? "complete" : "error",
+                    parts: [],
+                },
+            });
+        }
+        const terminalActivityStatus = terminalStatus;
+        const terminalToolStatus = terminalActivityStatus;
+        if (terminalToolStatus && run.activeTools.size > 0) {
+            const terminalError = terminalToolStatus === "failed" &&
+                event.error &&
+                typeof event.error === "object"
+                ? event.error
+                : undefined;
+            for (const tool of [...run.activeTools.values()]) {
+                append(run, {
+                    type: "tool.updated",
+                    occurredAt: event.occurredAt ?? now(),
+                    metadata: event.metadata,
+                    toolCall: {
+                        ...tool,
+                        status: terminalToolStatus,
+                        ...(terminalError ? { error: terminalError } : {}),
+                    },
+                });
+            }
+        }
+        if (terminalToolStatus && run.actions.size > 0) {
+            const actionStatus = terminalToolStatus === "completed"
+                ? "completed"
+                : terminalToolStatus === "cancelled"
+                    ? "cancelled"
+                    : "failed";
+            const actionError = actionStatus === "failed"
+                ? {
+                    code: "run_terminated",
+                    message: "The run ended before the action reported a result.",
+                }
+                : undefined;
+            for (const invocation of [...run.actions.values()]) {
+                append(run, {
+                    type: actionStatus === "completed" ? "action.completed" : "action.failed",
+                    occurredAt: event.occurredAt ?? now(),
+                    metadata: event.metadata,
+                    result: {
+                        invocationId: invocation.id,
+                        status: actionStatus,
+                        ...(actionError ? { error: actionError } : {}),
+                    },
+                });
+            }
+        }
+        if (terminalActivityStatus && run.activeActivities.size > 0) {
+            const completedAt = event.occurredAt ?? now();
+            for (const activity of [...run.activeActivities.values()]) {
+                append(run, {
+                    type: "activity.completed",
+                    occurredAt: completedAt,
+                    metadata: event.metadata,
+                    activity: {
+                        ...activity,
+                        status: terminalActivityStatus,
+                        completedAt,
+                    },
+                });
+            }
+        }
+    }
     function runtimeEventToProtocolEvents(run, event) {
         const base = {
             occurredAt: event.timestamp,
@@ -1004,6 +1120,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         switch (event.type) {
             case "message-start":
                 run.activeMessageId = event.message.id;
+                run.activeMessageCompleted = false;
                 return [
                     {
                         type: "message.created",
@@ -1012,6 +1129,8 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     },
                 ];
             case "message-delta":
+                run.activeMessageId = event.messageId;
+                run.activeMessageCompleted = false;
                 if (event.delta.type === "text") {
                     return [
                         {
@@ -1047,6 +1166,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 ];
             case "message-done":
                 run.activeMessageId = event.message.id;
+                run.activeMessageCompleted = true;
                 return [
                     {
                         type: "message.completed",
@@ -1767,8 +1887,11 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 lastAccessedAtMs: timeMs(),
                 activeReaders: 0,
                 metadata: runMetadata,
+                activeMessageCompleted: false,
                 actions: new Map(),
+                activeTools: new Map(),
                 activeActivities: new Map(),
+                terminalAppendDepth: 0,
                 pumpPromise: null,
                 continuationPromise: null,
                 streamClosed: false,
@@ -1818,6 +1941,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 usage: run.usage,
                 error: run.error,
                 metadata: run.metadata,
+                activeMessageId: run.activeMessageId,
             };
         },
         async cancelRun(input) {
@@ -1851,19 +1975,8 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             }
             run.waitingForContinuation = false;
             run.pendingApprovalId = undefined;
-            if (streamWasClosed) {
-                const completedAt = now();
-                run.status = "cancelled";
-                run.completedAt = completedAt;
-                run.terminalAtMs = timeMs(completedAt);
-                run.actions.clear();
-                run.activeActivities.clear();
-                pruneRetainedRuns(run.terminalAtMs);
-            }
-            else {
-                append(run, { type: "run.status", status: "cancelled" });
-                append(run, { type: "run.cancelled" });
-            }
+            append(run, { type: "run.status", status: "cancelled" });
+            append(run, { type: "run.cancelled" });
         },
         async dispose() {
             if (disposed)
@@ -2076,8 +2189,11 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     activeReaders: 0,
                     metadata: replacementMetadata,
                     activeMessageId: run.activeMessageId,
+                    activeMessageCompleted: run.activeMessageCompleted,
                     actions: new Map(run.actions),
+                    activeTools: new Map(run.activeTools),
                     activeActivities: new Map(run.activeActivities),
+                    terminalAppendDepth: 0,
                     pumpPromise: null,
                     continuationPromise: null,
                     streamClosed: false,
@@ -2160,8 +2276,6 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 run.waitingForContinuation = false;
                 run.pendingConnectionRequestId = undefined;
                 run.streamClosed = true;
-                run.terminal = true;
-                run.terminalAtMs = timeMs();
                 append(run, { type: "run.status", status: "failed" });
                 append(run, {
                     type: "run.failed",

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     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;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/server/core-routes-plugin.d.ts

@@ -408,8 +408,8 @@ export declare function createPublicRemoteAgentsHandler(discover?: PublicAgentDi
     error: string;
     agents?: undefined;
 } | {
-    agents: Omit<import("./agent-discovery.js").DiscoveredAgent, "auth" | "kind">[];
     error?: undefined;
+    agents: Omit<import("./agent-discovery.js").DiscoveredAgent, "auth" | "kind">[];
 }>>;
 export declare function getBuilderConnectErrorDisposition(error: unknown, connectAttemptId: string | null): "correlated" | "legacy" | null;
 export declare function getBuilderConnectErrorKey(ownerEmail: string, connectAttemptId?: string | null): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.182.1",
+  "version": "0.182.2-nightly-20260917210345",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -486,9 +486,9 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.32",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.2.4",
-    "@agent-native/recap-cli": "0.5.34",
-    "@agent-native/toolkit": "^0.20.4"
+    "@agent-native/agentkit": "^0.2.5-nightly-20260917210345",
+    "@agent-native/toolkit": "^0.20.5-nightly-20260917210345",
+    "@agent-native/recap-cli": "0.5.34"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",

package/corpus/templates/design/app/components/design/editor/PendingScreenDeletionDialog.tsx

@@ -1,66 +0,0 @@
-import { useT } from "@agent-native/core/client/i18n";
-
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from "@/components/ui/alert-dialog";
-import type { DesignFile } from "@/pages/design-editor/types";
-
-export function PendingScreenDeletionDialog({
-  pendingScreenDeletion,
-  onCancel,
-  onConfirm,
-  confirming = false,
-}: {
-  pendingScreenDeletion: { files: DesignFile[] } | null;
-  onCancel: () => void;
-  onConfirm: () => void;
-  confirming?: boolean;
-}) {
-  const t = useT();
-  return (
-    <AlertDialog open={pendingScreenDeletion !== null}>
-      <AlertDialogContent>
-        <AlertDialogHeader>
-          <AlertDialogTitle>
-            {pendingScreenDeletion?.files.length === 1
-              ? t("designEditor.screenDeletion.titleOne")
-              : t("designEditor.screenDeletion.titleMany", {
-                  count: pendingScreenDeletion?.files.length ?? 0,
-                })}
-          </AlertDialogTitle>
-          <AlertDialogDescription>
-            {pendingScreenDeletion?.files.length === 1
-              ? t("designEditor.screenDeletion.descriptionOne", {
-                  filename: pendingScreenDeletion.files[0]?.filename ?? "",
-                })
-              : t("designEditor.screenDeletion.descriptionMany")}
-          </AlertDialogDescription>
-        </AlertDialogHeader>
-        <AlertDialogFooter>
-          <AlertDialogCancel onClick={onCancel} disabled={confirming}>
-            {t("designEditor.screenDeletion.cancel")}
-          </AlertDialogCancel>
-          <AlertDialogAction
-            className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
-            disabled={confirming}
-            onClick={(event) => {
-              event.preventDefault();
-              onConfirm();
-            }}
-          >
-            {confirming
-              ? "Removing…" /* i18n-ignore */
-              : t("designEditor.screenDeletion.confirm")}
-          </AlertDialogAction>
-        </AlertDialogFooter>
-      </AlertDialogContent>
-    </AlertDialog>
-  );
-}