@agent-native/core 0.200.0 → 0.200.1-nightly-20261002183718

package/dist/agent/engine/ai-sdk-engine.js

@@ -279,8 +279,15 @@ class AISDKEngine {
         }
         const toolNameMap = createProviderToolNameMap(opts.tools, opts.messages);
         const providerTools = limitProviderTools(opts.tools);
+        // The Responses API treats an omitted `strict` as strict mode and rewrites
+        // every optional parameter as required, so the model must invent a value
+        // ("" or a guessed id) for each one. Action schemas use omission to mean
+        // "not this mode", so those fillers turn a valid call into a mixed one
+        // that validation rejects on every retry.
+        const usesResponsesApi = this.provider === "openai" &&
+            (this.forceResponses || !isCustomOpenAiBaseUrl(this.baseUrl));
         const aiSdkTools = providerTools.length > 0
-            ? engineToolsToAISDK(providerTools, jsonSchema, toolNameMap)
+            ? engineToolsToAISDK(providerTools, jsonSchema, toolNameMap, usesResponsesApi ? false : undefined)
             : undefined;
         const messages = engineMessagesToAISDK(opts.messages, {
             toolResultImages: this.capabilities.vision,

package/dist/agent/engine/translate-ai-sdk.d.ts

@@ -1,6 +1,6 @@
 import { type ProviderToolNameMap } from "./tool-name.js";
 import type { EngineTool, EngineMessage, EngineContentPart, EngineEvent } from "./types.js";
-export declare function engineToolsToAISDK(tools: EngineTool[], jsonSchema?: (schema: Record<string, unknown>) => unknown, toolNameMap?: ProviderToolNameMap): Record<string, any>;
+export declare function engineToolsToAISDK(tools: EngineTool[], jsonSchema?: (schema: Record<string, unknown>) => unknown, toolNameMap?: ProviderToolNameMap, strict?: boolean): Record<string, any>;
 export interface EngineToAISDKOptions {
     toolResultImages?: boolean;
     toolNameMap?: ProviderToolNameMap;

package/dist/agent/engine/translate-ai-sdk.js

@@ -2,7 +2,7 @@ import { classifyProviderError, describeErrorWithCauses, } from "./error-detail.
 import { flattenComposedRootSchema } from "./flatten-composed-root-schema.js";
 import { createProviderToolNameMap, toEngineToolName, toProviderToolName, } from "./tool-name.js";
 import { backfillEngineMessagesToolResults } from "./translate-anthropic.js";
-export function engineToolsToAISDK(tools, jsonSchema, toolNameMap = createProviderToolNameMap(tools)) {
+export function engineToolsToAISDK(tools, jsonSchema, toolNameMap = createProviderToolNameMap(tools), strict) {
     const result = {};
     for (const tool of tools) {
         const inputSchema = flattenComposedRootSchema(tool.inputSchema);
@@ -16,6 +16,7 @@ export function engineToolsToAISDK(tools, jsonSchema, toolNameMap = createProvid
         result[providerName] = {
             description: tool.description,
             inputSchema: jsonSchema ? jsonSchema(rawSchema) : rawSchema,
+            ...(strict === undefined ? {} : { strict }),
         };
     }
     return result;

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

@@ -112,6 +112,13 @@ export declare function getActiveRunForThreadAsync(threadId: string): Promise<{
     threadId: string;
     turnId: string;
     status: string;
+    /**
+     * The one answer to "is a run in flight on this thread". A terminal run is
+     * still returned inside `TERMINAL_RUN_RECONNECT_WINDOW_MS` so a reconnecting
+     * client can replay it, which is why `status` alone being present means
+     * nothing; `/runs/active` reports this as its `active` flag.
+     */
+    inFlight: boolean;
     heartbeatAt: number;
     lastProgressAt: number | null;
     dispatchMode?: string | null;

package/dist/agent/run-manager.js

@@ -1811,6 +1811,7 @@ export async function getActiveRunForThreadAsync(threadId) {
                     threadId: successor.threadId,
                     turnId: successor.turnId ?? successor.id,
                     status: successor.status,
+                    inFlight: true,
                     heartbeatAt: successor.heartbeatAt ?? successor.startedAt,
                     lastProgressAt: successor.lastProgressAt,
                     dispatchMode: successor.dispatchMode,
@@ -1833,6 +1834,7 @@ export async function getActiveRunForThreadAsync(threadId) {
             threadId: memRun.threadId,
             turnId: memRun.turnId,
             status,
+            inFlight: status === "running",
             heartbeatAt,
             lastProgressAt: sqlSnapshot?.lastProgressAt ?? null,
             dispatchMode: sqlSnapshot?.dispatchMode ?? null,
@@ -1896,6 +1898,7 @@ export async function getActiveRunForThreadAsync(threadId) {
                 threadId: sqlRun.threadId,
                 turnId: sqlRun.turnId ?? sqlRun.id,
                 status: sqlRun.status,
+                inFlight: true,
                 heartbeatAt: sqlRun.heartbeatAt ?? sqlRun.startedAt,
                 lastProgressAt: sqlRun.lastProgressAt,
                 dispatchMode: sqlRun.dispatchMode,
@@ -1917,6 +1920,7 @@ export async function getActiveRunForThreadAsync(threadId) {
                 threadId: sqlRun.threadId,
                 turnId: sqlRun.turnId ?? sqlRun.id,
                 status: legacyWireRunStatus(sqlRun.status),
+                inFlight: false,
                 heartbeatAt: sqlRun.heartbeatAt ?? sqlRun.startedAt,
                 lastProgressAt: sqlRun.lastProgressAt,
                 dispatchMode: sqlRun.dispatchMode,

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

@@ -423,12 +423,15 @@ function normalizeContentForFingerprint(content) {
         ? { ...part, toolCallId: undefined }
         : part);
 }
-function messageIdentityKeySet(message) {
+function messageIdentityKeySet(message, eventRunIds) {
     const strong = [];
     if (typeof message?.id === "string" && message.id) {
         strong.push(`id:${message.id}`);
     }
-    const runId = getMessageRunId(message);
+    const runId = getMessageRunId(message) ??
+        (typeof message?.id === "string"
+            ? eventRunIds?.get(message.id)
+            : undefined);
     if (runId)
         strong.push(`run:${runId}`);
     const turnId = turnIdOf(message);
@@ -1425,9 +1428,7 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
         existingNormalized &&
         typeof existingNormalized === "object") {
         for (const [key, value] of Object.entries(existingNormalized)) {
-            if (key === "messages" || key === "headId")
-                continue;
-            if (key === "queuedMessages" && !preserveExistingQueuedMessages) {
+            if (key === "messages" || key === "headId" || key === "queuedMessages") {
                 continue;
             }
             if (!(key in merged)) {
@@ -1435,11 +1436,11 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
             }
         }
     }
-    else if (preserveExistingQueuedMessages &&
-        existingNormalized &&
-        typeof existingNormalized === "object" &&
-        existingNormalized.queuedMessages !== undefined &&
-        merged.queuedMessages === undefined) {
+    // Queue mutations are the only writer of the queue and opt out here. Any
+    // other save carries a queue it read earlier, and letting that copy win drops
+    // a promotion claim or an append that landed in between.
+    if (preserveExistingQueuedMessages &&
+        existingNormalized?.queuedMessages !== undefined) {
         merged.queuedMessages = existingNormalized.queuedMessages;
     }
     if (merged.agentKit !== undefined) {
@@ -1454,10 +1455,30 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
     if (!existingMessages || !incomingMessages) {
         return pruneClaimedQueuedMessages(merged);
     }
-    const incomingKeySets = incomingMessages.map((entry) => messageIdentityKeySet(getStoredMessage(entry)));
+    // The chat UI saves its replies under AgentKit ids with no runId; only the
+    // AgentKit events tie them to the run the server folded under its own id.
+    const eventRunIds = snapshotMessageRunIds(merged.agentKit);
+    const incomingKeySets = incomingMessages.map((entry) => messageIdentityKeySet(getStoredMessage(entry), eventRunIds));
     const usedIncoming = new Set();
     const nextMessages = [];
     const idRewrites = new Map();
+    // A message that keeps its own id owns the incoming copy with that id; a
+    // run or turn match is weaker and must not take it from the message itself.
+    const incomingByOwnId = new Map();
+    existingMessages.forEach((entry, existingIndex) => {
+        const existingMessage = getStoredMessage(entry);
+        const id = messageId(existingMessage);
+        if (!id ||
+            (existingMessage?.role === "assistant" &&
+                messageContentIsEmpty(existingMessage.content))) {
+            return;
+        }
+        const incomingIndex = incomingKeySets.findIndex((keys, index) => !usedIncoming.has(index) && keys.strong.includes(`id:${id}`));
+        if (incomingIndex === -1)
+            return;
+        usedIncoming.add(incomingIndex);
+        incomingByOwnId.set(existingIndex, incomingIndex);
+    });
     for (let existingIndex = 0; existingIndex < existingMessages.length; existingIndex++) {
         const existingEntry = existingMessages[existingIndex];
         const existingMessage = getStoredMessage(existingEntry);
@@ -1465,8 +1486,9 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
             messageContentIsEmpty(existingMessage.content)) {
             continue;
         }
-        const existingKeys = messageIdentityKeySet(existingMessage);
-        const incomingIndex = findRankedIdentityMatch(existingKeys, incomingKeySets, usedIncoming, existingIndex);
+        const existingKeys = messageIdentityKeySet(existingMessage, eventRunIds);
+        const incomingIndex = incomingByOwnId.get(existingIndex) ??
+            findRankedIdentityMatch(existingKeys, incomingKeySets, usedIncoming, existingIndex);
         if (incomingIndex === -1) {
             nextMessages.push(existingEntry);
             continue;
@@ -1491,7 +1513,34 @@ export function mergeThreadDataForClientSave(existingRepo, incomingRepo, options
         }
         nextMessages.push(incomingMessages[index]);
     }
-    merged.messages = nextMessages.map((entry) => rewriteEntryParentId(entry, idRewrites));
+    // One reply per run: the server's folded reply carries the run in its
+    // metadata, and the chat UI's own copy of it (saved under an AgentKit id,
+    // tied to the run only by events) is dropped wherever both ended up stored.
+    const serverReplyRuns = new Set();
+    for (const entry of nextMessages) {
+        const message = getStoredMessage(entry);
+        const runId = message?.role === "assistant" ? getMessageRunId(message) : null;
+        if (runId)
+            serverReplyRuns.add(runId);
+    }
+    const keptMessages = nextMessages.filter((entry) => {
+        const message = getStoredMessage(entry);
+        if (message?.role !== "assistant" || getMessageRunId(message))
+            return true;
+        const runId = typeof message.id === "string" ? eventRunIds.get(message.id) : undefined;
+        if (!runId || !serverReplyRuns.has(runId))
+            return true;
+        const kept = nextMessages.find((candidate) => {
+            const other = getStoredMessage(candidate);
+            return other?.role === "assistant" && getMessageRunId(other) === runId;
+        });
+        const keptId = messageId(getStoredMessage(kept));
+        const droppedId = messageId(message);
+        if (keptId && droppedId)
+            idRewrites.set(droppedId, keptId);
+        return false;
+    });
+    merged.messages = keptMessages.map((entry) => rewriteEntryParentId(entry, idRewrites));
     const normalizedMerged = normalizeThreadRepository(pruneClaimedQueuedMessages(merged));
     normalizedMerged.headId = chooseMergedHeadId(existingNormalized, incomingNormalized, normalizedMerged);
     const previousUser = latestStoredUser(existingNormalized);

package/dist/client/chat/agentkit-agent-native.js

@@ -1324,10 +1324,13 @@ export function createAgentNativeAgentKitTransport(options = {}) {
     async function activeRunSnapshot(threadId) {
         const value = await activeRunStatus(threadId);
         const status = value.status;
-        if (value.active === false)
-            return null;
-        if (value.active !== true)
+        if (typeof value.active !== "boolean")
             return undefined;
+        // An idle thread has no run; a run that just finished keeps its id and
+        // status for replay even though it is no longer `active`.
+        if (value.active === false && (status === "idle" || !value.runId)) {
+            return null;
+        }
         if (typeof value.runId !== "string" || !value.runId) {
             throw new TypeError("Agent chat active-run response must include an active run ID.");
         }
@@ -1651,15 +1654,21 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             ...(claimedMessage ? { claimedMessage } : {}),
         };
     }
+    // A server that predates `active` meaning "in flight" reports a run inside
+    // its reconnect window as `active` with a terminal status.
+    function runIsInFlight(status) {
+        return (status.active === true &&
+            ![
+                "completed",
+                "complete",
+                "failed",
+                "cancelled",
+                "errored",
+                "aborted",
+            ].includes(String(status.status ?? "")));
+    }
     function runSlotIsClear(status) {
-        return (status.awaitingRedispatch !== true &&
-            (status.active !== true ||
-                status.status === "completed" ||
-                status.status === "complete" ||
-                status.status === "failed" ||
-                status.status === "cancelled" ||
-                status.status === "errored" ||
-                status.status === "aborted"));
+        return status.awaitingRedispatch !== true && !runIsInFlight(status);
     }
     async function waitForRunSlot(threadId, maxPolls = RUN_SLOT_STABLE_POLLS * 2) {
         let consecutiveClearPolls = 0;
@@ -1838,11 +1847,14 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                         throw new TypeError("Agent chat queue claim response is invalid.");
                     }
                     if (interruptActiveRun) {
-                        const activeRun = await activeRunSnapshot(threadId);
-                        if (activeRun) {
+                        const activeRun = await activeRunStatus(threadId);
+                        if (runIsInFlight(activeRun)) {
+                            if (typeof activeRun.runId !== "string" || !activeRun.runId) {
+                                throw new TypeError("Agent chat active-run response must include an active run ID.");
+                            }
                             await transport.cancelRun({
                                 threadId,
-                                runId: activeRun.id,
+                                runId: activeRun.runId,
                             });
                             await waitForRunSlot(threadId, RUN_SLOT_STABLE_POLLS * 4);
                         }

package/dist/client/use-chat-threads.js

@@ -81,6 +81,26 @@ export function appendChatThreadScopeParams(params, scope) {
     params.set("scopeType", scope.type);
     params.set("scopeId", scope.id);
 }
+/**
+ * The scope a thread save reports for the thread: a scope, `null` when the
+ * server holds the thread unscoped, `undefined` when the response says nothing
+ * (an older server or an unreadable body), so the local scope is left alone.
+ */
+function savedThreadScope(body) {
+    const record = body;
+    if (!record || typeof record !== "object" || !("scope" in record)) {
+        return undefined;
+    }
+    const scope = record.scope;
+    if (scope === null)
+        return null;
+    if (!scope || typeof scope !== "object")
+        return undefined;
+    const { type, id } = scope;
+    return typeof type === "string" && typeof id === "string"
+        ? scope
+        : undefined;
+}
 function withChatThreadScope(url, scope) {
     const params = new URLSearchParams();
     appendChatThreadScopeParams(params, scope);
@@ -239,6 +259,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         ? new Set([initialActiveThreadRef.current.id])
         : new Set());
     const explicitlyOpenedThreadIdsRef = useRef(new Set());
+    // Bumped when a thread's scope is changed on purpose (detach), so a save
+    // response that was in flight across the change cannot restore the old scope.
+    const scopeMutationsRef = useRef(new Map());
     const optimisticThreadScopesRef = useRef(new Map());
     const knownThreadScopesRef = useRef(new Map());
     const serverConfirmedThreadIdsRef = useRef(new Set());
@@ -728,6 +751,8 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         routeThreadId,
     ]);
     const detachThread = useCallback(async (threadId) => {
+        const bumpScopeMutation = () => scopeMutationsRef.current.set(threadId, (scopeMutationsRef.current.get(threadId) ?? 0) + 1);
+        bumpScopeMutation();
         try {
             const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}`, historyScope), {
                 method: "PUT",
@@ -738,6 +763,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 await fetchThreads();
                 return;
             }
+            bumpScopeMutation();
             knownThreadScopesRef.current.set(threadId, null);
             optimisticThreadScopesRef.current.set(threadId, null);
             const wasActive = activeThreadIdRef.current === threadId;
@@ -969,6 +995,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     // rides only on creation: a periodic save must never move an existing thread
     // between resources, however stale this client's guess is.
     const saveThreadData = useCallback(async (id, data) => {
+        const scopeEpoch = scopeMutationsRef.current.get(id) ?? 0;
         try {
             const { titleSource, ...threadDataPayload } = data;
             const localThread = threadsRef.current.find((t) => t.id === id);
@@ -1004,6 +1031,13 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             }
             if (!response.ok)
                 return;
+            const reportedScope = savedThreadScope(
+            // coercion-ok: a save response without a readable body carries no scope, and the local scope stays as it was.
+            await response.json().catch(() => null));
+            // A response that was in flight across a detach describes the thread
+            // as it was before it, so it must not put the old scope back.
+            const scopeChangedDuringSave = (scopeMutationsRef.current.get(id) ?? 0) !== scopeEpoch;
+            const savedScope = scopeChangedDuringSave ? undefined : reportedScope;
             serverConfirmedThreadIdsRef.current.add(id);
             clearClientDraftThreadMarker(id);
             newlyCreatedRef.current.delete(id);
@@ -1021,10 +1055,21 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                             ...(data.messageCount != null && {
                                 messageCount: data.messageCount,
                             }),
+                            // The run adopts the scope it was sent with, which the
+                            // visible page at save time may no longer be; take the
+                            // server's, or the active pointer stays under the
+                            // unscoped key and a reload here starts fresh.
+                            ...(savedScope !== undefined
+                                ? { scope: savedScope }
+                                : {}),
                             updatedAt: Date.now(),
                         }
                         : t));
                 }
+                // A thread the list no longer holds because it was detached while
+                // this save ran must not come back under the page's current scope.
+                if (scopeChangedDuringSave)
+                    return prev;
                 const now = Date.now();
                 return sortThreadSummaries([
                     {
@@ -1034,7 +1079,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                         messageCount: data.messageCount ?? 0,
                         createdAt: now,
                         updatedAt: now,
-                        scope: scopeRef.current ?? null,
+                        scope: savedScope !== undefined
+                            ? savedScope
+                            : (scopeRef.current ?? null),
                     },
                     ...prev,
                 ]);

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -8,8 +8,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     state: string;
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

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

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
     configured?: undefined;
+    error?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/notifications/routes.d.ts

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

package/dist/observability/routes.d.ts

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

package/dist/resources/handlers.d.ts

@@ -39,8 +39,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
     error: string;
 }>;
 export declare function handleDeleteResource(event: any): Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/server/agent-chat-plugin.js

@@ -5040,7 +5040,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         : null;
                     const { isBuilderGatewayDeployConfigured } = await import("./credential-provider.js");
                     return {
-                        active: true,
+                        active: run.inFlight,
                         runId: run.runId,
                         threadId: run.threadId,
                         turnId: run.turnId,
@@ -5383,7 +5383,11 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                                 const incomingScope = parseScopeFromBody(body.scope);
                                 await setThreadScope(threadId, owner, incomingScope);
                             }
-                            return { ok: true };
+                            // The scope the thread really has now (a detach can land
+                            // between the read above and this save), so the client records
+                            // what the server holds instead of guessing from the page.
+                            const saved = await resolveThreadAccess(owner, threadId, "editor", { orgId });
+                            return { ok: true, scope: saved?.scope ?? null };
                         });
                     }
                     // POST /threads/:id/queued — apply a single queue mutation against

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

@@ -66,12 +66,12 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     code: any;
 } | {
     errorCode?: undefined;
+    error?: undefined;
     code?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
-    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,17 +8,17 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     scope?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     error: any;
     scope?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     scope: "org" | "user";
+    error?: undefined;
 }>>;
 export interface DefaultModelSelectionRequest {
     engine: string;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,9 +1,9 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    models?: undefined;
     ok?: undefined;
+    models?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     models: string[];
-    error?: undefined;
 }>>;

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

@@ -626,8 +626,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/dist/server/realtime-token.d.ts

@@ -54,8 +54,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/triggers/actions/manage-automation.d.ts

@@ -14,6 +14,7 @@ declare const _default: import("../../action.js").ActionDefinition<{
     executionCwd?: string;
 }, {
     deleted?: undefined;
+    enabled?: undefined;
     created: boolean;
     name: string;
     scope: "organization" | "personal";
@@ -24,25 +25,24 @@ declare const _default: import("../../action.js").ActionDefinition<{
     reasoningEffort: "auto" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh";
     webhookPath: string;
     nextRun: string;
-    enabled?: undefined;
     executionHostId?: undefined;
     executionEngine?: undefined;
     executionCwd?: undefined;
 } | {
+    enabled?: undefined;
+    nextRun?: undefined;
     created?: undefined;
     scope?: undefined;
     triggerType?: undefined;
     event?: undefined;
     deleted: boolean;
     name: string;
-    enabled?: undefined;
     schedule?: undefined;
     timezone?: undefined;
     reasoningEffort?: undefined;
     executionHostId?: undefined;
     executionEngine?: undefined;
     executionCwd?: undefined;
-    nextRun?: undefined;
     webhookPath?: undefined;
 } | {
     deleted?: undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.200.0",
+  "version": "0.200.1-nightly-20261002183718",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -668,7 +668,7 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.200.0",
+    "@agent-native/agentkit": "^0.200.1-nightly-20261002183718",
     "@agent-native/recap-cli": "^0.5.60"
   },
   "devDependencies": {
@@ -739,7 +739,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": ">=0.196.0",
+    "@agent-native/core-corpus": "0.200.1-nightly-20261002183718",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",