@agent-native/core 0.228.1 → 0.228.2-nightly-20261113152307

package/dist/application-state/handlers.d.ts

@@ -36,18 +36,18 @@ export declare const listComposeDrafts: import("h3").EventHandlerWithFetch<impor
 export declare const getComposeDraft: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<Record<string, unknown> | null>>;
 export declare const putComposeDraft: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<any>>;
 export declare const saveComposeDraft: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    errorCode?: undefined;
     value?: undefined;
     error: string;
     revision?: undefined;
-    errorCode?: undefined;
     details?: undefined;
 } | {
+    errorCode?: undefined;
     error?: undefined;
     value: {
         id: string;
     };
     revision: string;
-    errorCode?: undefined;
     details?: undefined;
 } | {
     value?: undefined;

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

@@ -13,9 +13,9 @@ export declare const postCollabPatch: import("h3").EventHandlerWithFetch<import(
     ok: boolean;
 }>>;
 export declare const getCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    data?: undefined;
     error: string;
     docId?: undefined;
-    data?: undefined;
 } | {
     error?: undefined;
     docId: string;

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

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

package/dist/file-upload/builder-gateway.d.ts

@@ -0,0 +1,42 @@
+export type BuilderGatewayStep = "signed_url" | "session_start" | "complete";
+export interface BuilderGatewayErrorDetails {
+    step: BuilderGatewayStep;
+    /** HTTP status of the last attempt; 0 when no response arrived. */
+    status: number;
+    attempts: number;
+    /** The last response was an HTML error page, not the gateway's JSON. */
+    isHtml: boolean;
+    /** One id per attempt sent to Builder; search the upload function's logs by it. */
+    traceIds: string[];
+    /** Allow-listed response headers of the last failed attempt. */
+    headers: Record<string, string>;
+    cause?: unknown;
+}
+export declare class BuilderGatewayError extends Error {
+    readonly provider = "builder";
+    readonly step: BuilderGatewayStep;
+    readonly status: number;
+    readonly attempts: number;
+    readonly isHtml: boolean;
+    readonly traceIds: string[];
+    readonly headers: Record<string, string>;
+    constructor(message: string, details: BuilderGatewayErrorDetails);
+}
+/** Summarize a failed response without keeping a whole HTML error page. */
+export declare function describeErrorBody(res: Response): Promise<{
+    detail: string;
+    isHtml: boolean;
+}>;
+export interface GatewayRequestInit {
+    method: string;
+    headers: Record<string, string>;
+    body?: BodyInit;
+}
+/**
+ * One bounded, observable call to the Builder upload gateway or the storage
+ * session it hands out. Retries only failures that say "try again": no
+ * response, a gateway 5xx, and the step's own extra statuses. Resolves with
+ * the OK response; rejects with `BuilderGatewayError` once the attempts run
+ * out or the failure is not retryable.
+ */
+export declare function builderGatewayRequest(step: BuilderGatewayStep, url: string, init: GatewayRequestInit): Promise<Response>;

package/dist/file-upload/builder-gateway.js

@@ -0,0 +1,185 @@
+import { randomUUID } from "node:crypto";
+export class BuilderGatewayError extends Error {
+    provider = "builder";
+    step;
+    status;
+    attempts;
+    isHtml;
+    traceIds;
+    headers;
+    constructor(message, details) {
+        super(message, details.cause === undefined ? undefined : { cause: details.cause });
+        this.name = "BuilderGatewayError";
+        this.step = details.step;
+        this.status = details.status;
+        this.attempts = details.attempts;
+        this.isHtml = details.isHtml;
+        this.traceIds = details.traceIds;
+        this.headers = details.headers;
+    }
+}
+const BACKOFF_FACTOR = 3;
+// The signed-URL and session-start requests are tiny and answer in well under
+// a second, so their 15 s cap lets every attempt fit inside one serverless
+// request; a slow answer is retried instead of waited on.
+const GATEWAY_POLICIES = {
+    signed_url: {
+        label: "Builder.io signed-URL request failed",
+        attempts: 3,
+        baseDelayMs: 500,
+        timeoutMs: 15_000,
+        retryStatuses: new Set([502, 503, 504]),
+        retryOnTimeout: true,
+        traced: true,
+    },
+    session_start: {
+        label: "GCS resumable session initiation failed",
+        attempts: 3,
+        baseDelayMs: 500,
+        timeoutMs: 15_000,
+        retryStatuses: new Set([408, 429, 500, 502, 503, 504]),
+        retryOnTimeout: true,
+        traced: false,
+    },
+    // Completing a stable video can include server-side compression, so this
+    // keeps the long timeout and never retries after our own timeout: that retry
+    // would race the first attempt. A 409 is that race from elsewhere (a
+    // duplicate in flight); the next call returns the registered asset.
+    complete: {
+        label: "Builder.io upload complete failed",
+        attempts: 4,
+        baseDelayMs: 500,
+        timeoutMs: 120_000,
+        retryStatuses: new Set([409, 502, 503, 504]),
+        retryOnTimeout: false,
+        traced: true,
+    },
+};
+// Response headers that say which layer answered; never request headers,
+// which carry the Authorization token.
+const DIAGNOSTIC_RESPONSE_HEADERS = [
+    "server",
+    "via",
+    "x-served-by",
+    "x-cache",
+    "x-cloud-trace-context",
+    "x-amz-cf-id",
+    "x-amz-cf-pop",
+    "cf-ray",
+    "retry-after",
+    "content-type",
+    "date",
+];
+function snapshotResponseHeaders(headers) {
+    const snapshot = {};
+    for (const name of DIAGNOSTIC_RESPONSE_HEADERS) {
+        const value = headers.get(name);
+        if (value)
+            snapshot[name] = value;
+    }
+    return snapshot;
+}
+/** Summarize a failed response without keeping a whole HTML error page. */
+export async function describeErrorBody(res) {
+    let raw;
+    try {
+        raw = await res.text();
+    }
+    catch {
+        return {
+            detail: `${res.statusText || "no status text"} (response body unreadable)`,
+            isHtml: false,
+        };
+    }
+    const isHtml = /text\/html/i.test(res.headers.get("content-type") ?? "") ||
+        /^\s*<(?:!doctype\s+html|html)\b/i.test(raw);
+    if (isHtml) {
+        return { detail: "HTML error page returned instead of JSON", isHtml: true };
+    }
+    const text = raw.trim();
+    return { detail: text ? text.slice(0, 500) : res.statusText, isHtml: false };
+}
+async function sendOnce(url, init, policy, traceId) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, policy.timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...init,
+            headers: traceId
+                ? { ...init.headers, "X-Cloud-Trace-Context": `${traceId}/1;o=1` }
+                : init.headers,
+            signal: controller.signal,
+        });
+        return { kind: "response", response };
+    }
+    catch (error) {
+        return { kind: "network", error, timedOut };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * One bounded, observable call to the Builder upload gateway or the storage
+ * session it hands out. Retries only failures that say "try again": no
+ * response, a gateway 5xx, and the step's own extra statuses. Resolves with
+ * the OK response; rejects with `BuilderGatewayError` once the attempts run
+ * out or the failure is not retryable.
+ */
+export async function builderGatewayRequest(step, url, init) {
+    const policy = GATEWAY_POLICIES[step];
+    const traceIds = [];
+    for (let attempt = 1;; attempt++) {
+        const startedAt = Date.now();
+        const traceId = policy.traced ? randomUUID().replaceAll("-", "") : null;
+        if (traceId)
+            traceIds.push(traceId);
+        const result = await sendOnce(url, init, policy, traceId);
+        const elapsedMs = Date.now() - startedAt;
+        if (result.kind === "response" && result.response.ok) {
+            if (attempt > 1) {
+                console.log(`[builder-upload] ${step} recovered on attempt ${attempt}/${policy.attempts}`, { elapsedMs, traceId });
+            }
+            return result.response;
+        }
+        let status = 0;
+        let isHtml = false;
+        let detail;
+        let headers = {};
+        let retryable;
+        if (result.kind === "response") {
+            status = result.response.status;
+            headers = snapshotResponseHeaders(result.response.headers);
+            ({ detail, isHtml } = await describeErrorBody(result.response));
+            retryable = policy.retryStatuses.has(status);
+        }
+        else {
+            detail = result.timedOut
+                ? `timed out after ${policy.timeoutMs} ms`
+                : result.error instanceof Error
+                    ? result.error.message
+                    : String(result.error);
+            retryable = result.timedOut ? policy.retryOnTimeout : true;
+        }
+        const willRetry = retryable && attempt < policy.attempts;
+        console.warn(`[builder-upload] ${step} attempt ${attempt}/${policy.attempts} failed${willRetry ? ", retrying" : ""}`, { status: status || "no response", elapsedMs, traceId, headers });
+        if (!willRetry) {
+            throw new BuilderGatewayError(`${policy.label} (${status || "no response"}): ${detail}`, {
+                step,
+                status,
+                attempts: attempt,
+                isHtml,
+                traceIds,
+                headers,
+                cause: result.kind === "network" ? result.error : undefined,
+            });
+        }
+        // Jitter keeps a burst of retrying recordings from landing together.
+        const delayMs = policy.baseDelayMs * BACKOFF_FACTOR ** (attempt - 1);
+        await new Promise((resolve) => setTimeout(resolve, Math.round(delayMs * (0.75 + Math.random() * 0.5))));
+    }
+}

package/dist/file-upload/builder.js

@@ -1,3 +1,4 @@
+import { builderGatewayRequest, describeErrorBody } from "./builder-gateway.js";
 const DEFAULT_BUILDER_APP_HOST = "https://builder.io";
 const LARGE_FILE_THRESHOLD_BYTES = 30 * 1024 * 1024;
 const UPLOAD_TIMEOUT_MS = 120_000;
@@ -44,8 +45,10 @@ function setRecordAssetQueryParam(url, recordAsset) {
 }
 async function assertOk(res, label) {
     if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        throw Object.assign(new Error(`${label} (${res.status}): ${body || res.statusText}`), { status: res.status });
+        const { detail } = await describeErrorBody(res);
+        throw Object.assign(new Error(`${label} (${res.status}): ${detail}`), {
+            status: res.status,
+        });
     }
 }
 function confirmedBuilderAuthorizationFailure(error) {
@@ -116,7 +119,7 @@ async function requestBuilderSignedUrl(authorization, apiKey, filename, mimeType
     const url = new URL("/api/v1/upload/signed-url", host);
     if (apiKey)
         url.searchParams.set("apiKey", apiKey);
-    const res = await fetchWithTimeout(url.toString(), {
+    const res = await builderGatewayRequest("signed_url", url.toString(), {
         method: "POST",
         headers: {
             Authorization: authorization,
@@ -129,7 +132,6 @@ async function requestBuilderSignedUrl(authorization, apiKey, filename, mimeType
             resumable,
         }),
     });
-    await assertOk(res, "Builder.io signed-URL request failed");
     const json = (await res.json());
     if (!json.uploadUrl || !json.assetId || !json.requiredHeaders) {
         throw new Error(`Builder.io signed-URL response missing required fields: ${JSON.stringify(Object.keys(json))}`);
@@ -149,7 +151,7 @@ async function completeBuilderUpload(authorization, apiKey, assetId, filename, o
         setStableUrlQueryParam(url);
     }
     setRecordAssetQueryParam(url, options?.recordAsset);
-    const res = await fetchWithTimeout(url.toString(), {
+    const res = await builderGatewayRequest("complete", url.toString(), {
         method: "POST",
         headers: {
             Authorization: authorization,
@@ -161,7 +163,6 @@ async function completeBuilderUpload(authorization, apiKey, assetId, filename, o
             ...(options?.recordAsset === false ? { record: false } : {}),
         }),
     });
-    await assertOk(res, "Builder.io upload complete failed");
     const json = (await res.json());
     if (!json.url)
         throw new Error("Builder.io upload/complete returned no URL");
@@ -315,15 +316,11 @@ export const builderFileUploadProvider = {
             if (contentLengthRange)
                 initHeaders["x-goog-content-length-range"] = contentLengthRange;
             console.log(`[builder-resumable] session step 2: initiating GCS session`);
-            const initRes = await fetchWithTimeout(uploadUrl, {
+            const initRes = await builderGatewayRequest("session_start", uploadUrl, {
                 method: "POST",
                 headers: initHeaders,
                 body: new Uint8Array(0),
             });
-            if (!initRes.ok) {
-                const body = await initRes.text().catch(() => "");
-                throw new Error(`GCS resumable session initiation failed (${initRes.status}): ${body}`);
-            }
             const sessionUri = initRes.headers.get("location");
             if (!sessionUri)
                 throw new Error("GCS did not return a Location header for the resumable session");

package/dist/file-upload/index.d.ts

@@ -1,6 +1,7 @@
 export type { FileUploadDeleteInput, FileUploadInput, FileUploadProvider, FileUploadResult, ResumableUploadSession, ResumableChunkResult, } from "./types.js";
 export { registerFileUploadProvider, unregisterFileUploadProvider, listFileUploadProviders, getActiveFileUploadProvider, getActiveFileUploadProviderForRequest, deleteUploadedFile, uploadFile, } from "./registry.js";
 export { builderFileUploadProvider } from "./builder.js";
+export { BuilderGatewayError, type BuilderGatewayErrorDetails, type BuilderGatewayStep, } from "./builder-gateway.js";
 export { getBuilderUploadCredentialStatus } from "./status.js";
 export { ensureS3FileUploadProvider, S3RequestError, s3FileUploadProvider, } from "./s3.js";
 export { cancelS3ResponseBody, fetchS3WithTimeout, presignS3GetUrl, readS3ErrorText, rfc3986, s3ObjectUri, sha256Hex, signS3Request, signedS3Request, trustedDeploymentS3Origin, type PresignS3GetOptions, type S3ClientConfig, type S3Method, type SignedS3RequestOptions, } from "./s3-client.js";

package/dist/file-upload/index.js

@@ -1,5 +1,6 @@
 export { registerFileUploadProvider, unregisterFileUploadProvider, listFileUploadProviders, getActiveFileUploadProvider, getActiveFileUploadProviderForRequest, deleteUploadedFile, uploadFile, } from "./registry.js";
 export { builderFileUploadProvider } from "./builder.js";
+export { BuilderGatewayError, } from "./builder-gateway.js";
 export { getBuilderUploadCredentialStatus } from "./status.js";
 export { ensureS3FileUploadProvider, S3RequestError, s3FileUploadProvider, } from "./s3.js";
 export { cancelS3ResponseBody, fetchS3WithTimeout, presignS3GetUrl, readS3ErrorText, rfc3986, s3ObjectUri, sha256Hex, signS3Request, signedS3Request, trustedDeploymentS3Origin, } from "./s3-client.js";

package/dist/framework-package-versions.json

@@ -1,10 +1,10 @@
 {
-  "@agent-native/agentkit": "0.228.1",
+  "@agent-native/agentkit": "0.228.2-nightly-20261113152307",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.228.1",
-  "@agent-native/core-corpus": "0.228.1",
+  "@agent-native/core": "0.228.2-nightly-20261113152307",
+  "@agent-native/core-corpus": "0.228.2-nightly-20261113152307",
   "@agent-native/creative-context": "0.8.71",
-  "@agent-native/dispatch": "0.42.6",
+  "@agent-native/dispatch": "0.42.7-nightly-20261113152307",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
   "@agent-native/otel": "0.1.38",
@@ -12,6 +12,6 @@
   "@agent-native/recap-cli": "0.5.102",
   "@agent-native/scheduling": "0.2.58",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.6",
-  "@agent-native/toolkit": "0.228.1"
+  "@agent-native/skills": "0.4.7-nightly-20261113152307",
+  "@agent-native/toolkit": "0.228.2-nightly-20261113152307"
 }

package/dist/mcp/screen-memory-stdio.d.ts

@@ -283,20 +283,20 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 type: string;
             };
             startAt: {
-                description?: undefined;
                 type: string;
+                description?: undefined;
             };
             endAt: {
-                description?: undefined;
                 type: string;
+                description?: undefined;
             };
             count: {
                 type: string;
                 description: string;
             };
             reason: {
-                description?: undefined;
                 type: string;
+                description?: undefined;
             };
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;

package/dist/org/index.d.ts

@@ -180,9 +180,9 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean | undefined;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    success: boolean;
     id?: undefined;
     name?: undefined;
+    success: boolean;
     role?: undefined;
 } | {
     success?: undefined;

package/dist/secrets/routes.d.ts

@@ -65,8 +65,8 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     ok?: undefined;
     status?: undefined;
 } | {
-    error?: undefined;
     errorCode?: undefined;
+    error?: undefined;
     ok: boolean;
     status: string;
 } | {

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

@@ -66,8 +66,8 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     error: string;
     code: ProviderKeyCheckCode;
 } | {
-    errorCode?: undefined;
     error?: undefined;
+    errorCode?: undefined;
     code?: undefined;
     ok: boolean;
     key: string;

package/dist/server/better-auth-instance.d.ts

@@ -1,4 +1,4 @@
-import { type BetterAuthOptions } from "better-auth";
+import { type BetterAuthOptions, type BetterAuthPlugin } from "better-auth";
 import type { H3Event } from "h3";
 import { type SignupOrigin } from "./attribution.js";
 import { type EmailReadiness } from "./email.js";
@@ -330,5 +330,16 @@ export interface GoogleAuthIdentity {
 }
 export declare function ensureGoogleAuthIdentity(identity: GoogleAuthIdentity): Promise<boolean>;
 export declare function ensureGoogleAuthIdentityWithAdapter(adapter: BetterAuthInternalAdapter, identity: GoogleAuthIdentity): Promise<boolean>;
+type BetterAuthInitContext = Parameters<NonNullable<BetterAuthPlugin["init"]>>[0];
+/**
+ * Better Auth runs mail callbacks through `runInBackgroundOrAwait`, which logs
+ * and swallows their errors. Track the delivery promises so the runner can hand
+ * them back and a failed send fails the request.
+ */
+export declare function trackAuthEmailDeliveries(ctx: BetterAuthInitContext): {
+    context: {
+        runInBackgroundOrAwait(task: Parameters<BetterAuthInitContext["runInBackgroundOrAwait"]>[0]): unknown;
+    };
+} | undefined;
 export declare function resetBetterAuth(): Promise<void>;
 export declare function buildDatabaseConfig(): Promise<BetterAuthOptions["database"]>;

package/dist/server/better-auth-instance.js

@@ -1403,6 +1403,58 @@ export async function ensureGoogleAuthIdentityWithAdapter(adapter, identity) {
     await syncGoogleProfile(adapter, existing, email, identity);
     return false;
 }
+/**
+ * Better Auth runs mail callbacks through `runInBackgroundOrAwait`, which logs
+ * and swallows their errors. Track the delivery promises so the runner can hand
+ * them back and a failed send fails the request.
+ */
+export function trackAuthEmailDeliveries(ctx) {
+    const deliveries = new WeakSet();
+    const emailVerification = ctx.options.emailVerification;
+    const sendVerificationEmail = emailVerification?.sendVerificationEmail;
+    if (emailVerification && sendVerificationEmail) {
+        emailVerification.sendVerificationEmail = (...args) => {
+            const delivery = sendVerificationEmail(...args);
+            if (delivery instanceof Promise)
+                deliveries.add(delivery);
+            return delivery;
+        };
+    }
+    const changeEmail = ctx.options.user?.changeEmail;
+    const sendChangeEmailConfirmation = changeEmail?.sendChangeEmailConfirmation;
+    if (changeEmail && sendChangeEmailConfirmation) {
+        changeEmail.sendChangeEmailConfirmation = (...args) => {
+            const delivery = sendChangeEmailConfirmation(...args);
+            if (delivery instanceof Promise)
+                deliveries.add(delivery);
+            return delivery;
+        };
+    }
+    if (!sendVerificationEmail && !sendChangeEmailConfirmation)
+        return;
+    const passwordOptions = ctx.options.emailAndPassword;
+    const onExistingUserSignUp = passwordOptions?.onExistingUserSignUp;
+    if (passwordOptions && onExistingUserSignUp) {
+        passwordOptions.onExistingUserSignUp = (...args) => {
+            const delivery = onExistingUserSignUp(...args);
+            deliveries.add(delivery);
+            return delivery;
+        };
+    }
+    const runInBackgroundOrAwait = ctx.runInBackgroundOrAwait.bind(ctx);
+    return {
+        context: {
+            runInBackgroundOrAwait(task) {
+                // Better Auth swallows even awaited task errors; verification and
+                // email-change mail must fail the request before the UI can claim
+                // mail was sent.
+                if (task instanceof Promise && deliveries.has(task))
+                    return task;
+                return runInBackgroundOrAwait(task);
+            },
+        },
+    };
+}
 export async function resetBetterAuth() {
     _authInitGeneration++;
     _auth = undefined;
@@ -2021,40 +2073,7 @@ async function createBetterAuthInstance(config) {
                         },
                     ],
                 },
-                init(ctx) {
-                    const emailVerification = ctx.options.emailVerification;
-                    if (!emailVerification?.sendVerificationEmail)
-                        return;
-                    const sendVerificationEmail = emailVerification.sendVerificationEmail;
-                    const deliveries = new WeakSet();
-                    emailVerification.sendVerificationEmail = (...args) => {
-                        const delivery = sendVerificationEmail(...args);
-                        if (delivery instanceof Promise)
-                            deliveries.add(delivery);
-                        return delivery;
-                    };
-                    const passwordOptions = ctx.options.emailAndPassword;
-                    const onExistingUserSignUp = passwordOptions?.onExistingUserSignUp;
-                    if (passwordOptions && onExistingUserSignUp) {
-                        passwordOptions.onExistingUserSignUp = (...args) => {
-                            const delivery = onExistingUserSignUp(...args);
-                            deliveries.add(delivery);
-                            return delivery;
-                        };
-                    }
-                    const runInBackgroundOrAwait = ctx.runInBackgroundOrAwait.bind(ctx);
-                    return {
-                        context: {
-                            runInBackgroundOrAwait(task) {
-                                // Better Auth swallows even awaited task errors; verification
-                                // must fail the request before the UI can claim mail was sent.
-                                if (task instanceof Promise && deliveries.has(task))
-                                    return task;
-                                return runInBackgroundOrAwait(task);
-                            },
-                        },
-                    };
-                },
+                init: trackAuthEmailDeliveries,
             },
         ],
     });

package/package.json

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