@agent-native/core 0.198.3-nightly-20260930124743 → 0.198.3

package/dist/db/create-get-db.js

@@ -1,4 +1,6 @@
-import { getActivePgliteTransactionClient, getRuntimeDatabaseUrl, isPgliteUrl, isConnectionError, getPgliteClient, loadPgliteDrizzle, pgliteDrizzleClient, pgPoolOptions, neonPoolOptions, guardNeonPool, withDbTimeout, retryOnConnectionError, dbOpTimeoutMs, sharedDbPool, onSharedDbPoolsClosed, onSharedDbPoolReplaced, assertHostedRuntimeDatabase, } from "./client.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { sql } from "drizzle-orm";
+import { annotateMissingTable, dbExecQueryBudget, getActivePgliteTransactionClient, getRuntimeDatabaseUrl, hasExplicitDbTimeout, isPgliteUrl, isConnectionError, getPgliteClient, loadPgliteDrizzle, pgliteDrizzleClient, pgPoolOptions, neonPoolOptions, guardNeonPool, withDbTimeout, retryOnConnectionError, dbOpTimeoutMs, sharedDbPool, toPostgresParams, withDbExec, onSharedDbPoolsClosed, onSharedDbPoolReplaced, postgresStatementTimeoutMs, assertHostedRuntimeDatabase, } from "./client.js";
 let _pgDrizzle;
 function getPgDrizzle() {
     if (!_pgDrizzle) {
@@ -25,6 +27,479 @@ function getNeonServerlessDrizzle() {
     }
     return _neonServerlessDrizzle;
 }
+function drizzleRawQuery(text, params = []) {
+    const query = sql.raw(text);
+    query.toQuery = () => ({ sql: text, params });
+    return query;
+}
+function terminateNeonTransactionConnection(transaction) {
+    const client = transaction.session?.client;
+    const stream = client?.connection?.stream;
+    if (typeof client?.release === "function" &&
+        typeof stream?.destroy === "function") {
+        stream.destroy();
+    }
+}
+async function withTransactionStatementTimeout(transaction, run) {
+    const timeoutMs = dbOpTimeoutMs();
+    const statementTimeoutMs = postgresStatementTimeoutMs(timeoutMs);
+    const timeoutSql = `SELECT set_config('statement_timeout', CASE WHEN current_setting('statement_timeout')::interval <= interval '0' OR current_setting('statement_timeout')::interval > interval '${statementTimeoutMs}ms' THEN '${statementTimeoutMs}ms' ELSE current_setting('statement_timeout') END, true)`;
+    let timedOut = false;
+    let setupQuery;
+    try {
+        await withDbTimeout("query", () => (setupQuery = Promise.resolve(transaction.execute(drizzleRawQuery(timeoutSql)))), timeoutMs, () => {
+            timedOut = true;
+            terminateNeonTransactionConnection(transaction);
+        }, { sql: timeoutSql });
+    }
+    catch (err) {
+        if (timedOut && setupQuery)
+            await setupQuery.catch(() => { });
+        throw err;
+    }
+    return await run();
+}
+const activeDrizzleTransactionScope = new AsyncLocalStorage();
+function createDrizzleTransactionQueryQueue(parent) {
+    return {
+        pending: Promise.resolve(),
+        parent,
+        active: true,
+        nestedTransactionActive: false,
+    };
+}
+function assertDrizzleTransactionQueryQueueActive(queue) {
+    for (let current = queue; current; current = current.parent) {
+        if (!current.active) {
+            throw new Error("Cannot use a database handle after its transaction has completed");
+        }
+    }
+}
+async function closeDrizzleTransactionQueryQueue(queue) {
+    queue.active = false;
+    await queue.pending;
+}
+function activeDrizzleTransactionScopeForQueue(queue) {
+    const activeScope = activeDrizzleTransactionScope.getStore();
+    if (!queue) {
+        if (activeScope)
+            assertDrizzleTransactionQueryQueueActive(activeScope.queue);
+        return activeScope;
+    }
+    assertDrizzleTransactionQueryQueueActive(queue);
+    for (let scope = activeScope; scope; scope = scope.parent) {
+        assertDrizzleTransactionQueryQueueActive(scope.queue);
+        for (let current = scope.queue; current; current = current.parent) {
+            if (current !== queue)
+                continue;
+            if (scope !== activeScope) {
+                throw new Error("Cannot use a database handle from an enclosing transaction while an independent transaction is active");
+            }
+            return scope;
+        }
+    }
+    return undefined;
+}
+function runInActiveDrizzleTransactionScope(scope, run) {
+    return activeDrizzleTransactionScope.run({ ...scope, parent: activeDrizzleTransactionScope.getStore() }, run);
+}
+function acquireDrizzleTransactionQuery(queue) {
+    const previous = queue.pending;
+    let release;
+    queue.pending = new Promise((resolve) => {
+        release = resolve;
+    });
+    return previous.then(() => release);
+}
+async function withDrizzleTransactionQuery(queue, run) {
+    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+    const activeQueue = activeScope?.queue ?? queue;
+    if (!activeQueue)
+        return await run();
+    if (activeQueue.nestedTransactionActive) {
+        throw new Error("Cannot use a transaction handle while its nested transaction is active");
+    }
+    const release = await acquireDrizzleTransactionQuery(activeQueue);
+    try {
+        const currentQueue = activeDrizzleTransactionScopeForQueue(queue)?.queue ?? queue;
+        if (currentQueue?.nestedTransactionActive) {
+            throw new Error("Cannot use a transaction handle while its nested transaction is active");
+        }
+        return await run();
+    }
+    finally {
+        release();
+    }
+}
+function scopeDrizzlePreparedQuery(prepared, queue, sourceSession, prepareArgs) {
+    let hasToken = false;
+    let token;
+    const resolvePrepared = (target) => {
+        const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+        const session = activeScope?.transaction.session;
+        if (!session || session === sourceSession)
+            return target;
+        const rebound = session.prepareQuery(...prepareArgs);
+        if (hasToken)
+            rebound.setToken?.(token);
+        return rebound;
+    };
+    const scoped = new Proxy(prepared, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "setToken" && typeof value === "function") {
+                return (nextToken) => {
+                    hasToken = true;
+                    token = nextToken;
+                    value.call(target, nextToken);
+                    return scoped;
+                };
+            }
+            if ((prop === "execute" || prop === "all" || prop === "values") &&
+                typeof value === "function") {
+                return (...args) => withDrizzleTransactionQuery(queue, () => {
+                    const current = resolvePrepared(target);
+                    return current[prop].apply(current, args);
+                });
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return scoped;
+}
+function scopeDrizzleSessionQueries(session, queue) {
+    return new Proxy(session, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "prepareQuery" && typeof value === "function") {
+                return (...args) => {
+                    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                    const queryQueue = queue ?? activeScope?.queue;
+                    const querySession = activeScope?.transaction.session ?? target;
+                    const prepared = querySession.prepareQuery(...args);
+                    return scopeDrizzlePreparedQuery(prepared, queryQueue, querySession, args);
+                };
+            }
+            if ((prop === "query" || prop === "queryObjects") &&
+                typeof value === "function") {
+                return (...args) => withDrizzleTransactionQuery(queue, () => {
+                    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                    const querySession = activeScope?.transaction.session ?? target;
+                    return querySession[prop].apply(querySession, args);
+                });
+            }
+            return typeof value === "function" ? value.bind(receiver) : value;
+        },
+    });
+}
+function scopeDrizzleRelationalPreparedQuery(prepared, getQuery, queue, prepareArgs, initialToken) {
+    let hasToken = initialToken !== undefined;
+    let token = initialToken?.value;
+    const scoped = new Proxy(prepared, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "setToken" && typeof value === "function") {
+                return (nextToken) => {
+                    hasToken = true;
+                    token = nextToken;
+                    value.call(target, nextToken);
+                    return scoped;
+                };
+            }
+            if ((prop === "execute" || prop === "all" || prop === "values") &&
+                typeof value === "function") {
+                return (...args) => withDrizzleTransactionQuery(queue, () => {
+                    const current = getQuery().prepare(...prepareArgs);
+                    if (hasToken)
+                        current.setToken?.(token);
+                    return current[prop].apply(current, args);
+                });
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return scoped;
+}
+function scopeDrizzleRelationalQuery(query, getQuery, queue, transactionSession) {
+    let hasToken = false;
+    let token;
+    const getScopedQuery = () => {
+        const current = getQuery();
+        const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+        if (transactionSession || activeScope) {
+            current.session =
+                activeScope?.transaction.session ??
+                    transactionSession ??
+                    current.session;
+        }
+        return current;
+    };
+    const execute = (...args) => withDrizzleTransactionQuery(queue, () => {
+        const current = getScopedQuery();
+        if (hasToken)
+            current.setToken?.(token);
+        return current.execute(...args);
+    });
+    const scoped = new Proxy(query, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "setToken" && typeof value === "function") {
+                return (nextToken) => {
+                    hasToken = true;
+                    token = nextToken;
+                    value.call(target, nextToken);
+                    return scoped;
+                };
+            }
+            if (prop === "execute" && typeof value === "function")
+                return execute;
+            if (prop === "then" && typeof value === "function") {
+                return (onFulfilled, onRejected) => execute().then(onFulfilled, onRejected);
+            }
+            if (prop === "catch" && typeof value === "function") {
+                return (onRejected) => execute().catch(onRejected);
+            }
+            if (prop === "finally" && typeof value === "function") {
+                return (onFinally) => execute().finally(onFinally);
+            }
+            if (prop === "prepare" && typeof value === "function") {
+                return (...args) => {
+                    const current = getScopedQuery();
+                    return scopeDrizzleRelationalPreparedQuery(current.prepare(...args), getScopedQuery, queue, args, hasToken ? { value: token } : undefined);
+                };
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return scoped;
+}
+function scopeDrizzleRelationalQueries(queries, transaction, queue) {
+    return new Proxy(queries, {
+        get(target, tableName) {
+            const builder = Reflect.get(target, tableName, target);
+            if (!builder || typeof builder !== "object")
+                return builder;
+            return new Proxy(builder, {
+                get(builderTarget, method) {
+                    const value = Reflect.get(builderTarget, method, builderTarget);
+                    if ((method !== "findFirst" && method !== "findMany") ||
+                        typeof value !== "function") {
+                        return typeof value === "function"
+                            ? value.bind(builderTarget)
+                            : value;
+                    }
+                    return (...args) => {
+                        const getQuery = () => {
+                            const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                            const activeTransaction = activeScope?.transaction ?? transaction;
+                            return activeTransaction.query[tableName][method](...args);
+                        };
+                        return scopeDrizzleRelationalQuery(getQuery(), getQuery, queue);
+                    };
+                },
+            });
+        },
+    });
+}
+function scopeDrizzleRootRelationalQueries(queries, queue, transactionSession) {
+    return new Proxy(queries, {
+        get(target, tableName) {
+            const builder = Reflect.get(target, tableName, target);
+            if (!builder || typeof builder !== "object")
+                return builder;
+            return new Proxy(builder, {
+                get(builderTarget, method) {
+                    const value = Reflect.get(builderTarget, method, builderTarget);
+                    if ((method !== "findFirst" && method !== "findMany") ||
+                        typeof value !== "function") {
+                        return typeof value === "function"
+                            ? value.bind(builderTarget)
+                            : value;
+                    }
+                    return (...args) => {
+                        const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                        const queryQueue = queue ?? activeScope?.queue;
+                        const querySession = activeScope?.transaction.session ?? transactionSession;
+                        const getQuery = () => value.apply(builderTarget, args);
+                        return scopeDrizzleRelationalQuery(getQuery(), getQuery, queryQueue, querySession);
+                    };
+                },
+            });
+        },
+    });
+}
+async function withNestedDrizzleTransaction(transaction, queue, run) {
+    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+    const activeQueue = activeScope?.queue ?? queue;
+    const activeTransaction = activeScope?.transaction ?? transaction;
+    return await withDrizzleTransactionQuery(activeQueue, async () => {
+        activeQueue.nestedTransactionActive = true;
+        try {
+            return await activeTransaction.transaction(async (nested) => {
+                const nestedQueue = createDrizzleTransactionQueryQueue(activeQueue);
+                try {
+                    await withTransactionStatementTimeout(nested, () => undefined);
+                    return await runInActiveDrizzleTransactionScope({ queue: nestedQueue, transaction: nested }, () => run(nested, nestedQueue));
+                }
+                finally {
+                    await closeDrizzleTransactionQueryQueue(nestedQueue);
+                }
+            });
+        }
+        finally {
+            activeQueue.nestedTransactionActive = false;
+        }
+    });
+}
+function drizzleTransactionExec(transaction, queryQueue = createDrizzleTransactionQueryQueue()) {
+    const executeStatement = async (statement, remainingMs, timedOut) => {
+        const query = typeof statement === "string" ? { sql: statement, args: [] } : statement;
+        const postgresSql = toPostgresParams(query.sql);
+        const args = (query.args ?? []).map((arg) => arg ?? null);
+        const prepared = drizzleRawQuery(postgresSql, args);
+        if (!hasExplicitDbTimeout(statement)) {
+            return await transaction.execute(prepared);
+        }
+        const currentTimeout = await transaction.execute(drizzleRawQuery("SELECT current_setting('statement_timeout') AS statement_timeout"));
+        const currentRows = Array.isArray(currentTimeout)
+            ? currentTimeout
+            : currentTimeout?.rows;
+        const previousTimeout = currentRows?.[0]?.statement_timeout;
+        if (typeof previousTimeout !== "string") {
+            throw new Error("Could not read the active statement timeout");
+        }
+        if (timedOut())
+            return undefined;
+        await transaction.execute(drizzleRawQuery(`SET LOCAL statement_timeout = ${postgresStatementTimeoutMs(remainingMs())}`));
+        const restoreTimeout = () => transaction.execute(drizzleRawQuery("SELECT set_config('statement_timeout', $1, true)", [
+            previousTimeout,
+        ]));
+        if (timedOut()) {
+            // Keep the transaction open until this reset finishes or rollback releases the local setting.
+            await restoreTimeout().catch(() => { });
+            return undefined;
+        }
+        let queryResult;
+        let queryError;
+        let queryFailed = false;
+        try {
+            queryResult = await transaction.execute(prepared);
+        }
+        catch (err) {
+            queryFailed = true;
+            queryError = err;
+        }
+        try {
+            await restoreTimeout();
+        }
+        catch (err) {
+            if (!queryFailed)
+                throw err;
+        }
+        if (queryFailed)
+            throw queryError;
+        return queryResult;
+    };
+    const execute = async (statement) => {
+        const query = typeof statement === "string" ? statement : statement.sql;
+        const { timeoutMs } = dbExecQueryBudget(statement);
+        const startedAt = Date.now();
+        const remainingMs = () => Math.max(1, timeoutMs - (Date.now() - startedAt));
+        let timedOut = false;
+        let started = false;
+        let inFlight;
+        let result;
+        try {
+            result = await withDbTimeout("query", () => {
+                inFlight = withDrizzleTransactionQuery(queryQueue, () => {
+                    if (timedOut)
+                        return Promise.resolve(undefined);
+                    started = true;
+                    return executeStatement(statement, remainingMs, () => timedOut);
+                });
+                return inFlight;
+            }, timeoutMs, () => {
+                timedOut = true;
+                if (started)
+                    terminateNeonTransactionConnection(transaction);
+            }, { sql: query });
+        }
+        catch (err) {
+            // A caller can catch the timeout and continue, so drain any query already sent.
+            if (timedOut && started && inFlight)
+                await inFlight.catch(() => { });
+            throw annotateMissingTable(err, statement);
+        }
+        const rows = Array.isArray(result) ? result : result?.rows;
+        if (!Array.isArray(rows)) {
+            throw new Error("Drizzle transaction query returned no row array");
+        }
+        return {
+            rows,
+            rowsAffected: result.rowCount ?? result.count ?? result.affectedRows ?? rows.length,
+        };
+    };
+    const exec = {
+        execute,
+    };
+    exec.atomicBatch = async (statements) => {
+        const results = [];
+        for (const statement of statements)
+            results.push(await exec.execute(statement));
+        return results;
+    };
+    if (typeof transaction.transaction === "function") {
+        exec.transaction = (run) => withNestedDrizzleTransaction(transaction, queryQueue, (nested, queue) => {
+            const nestedExec = drizzleTransactionExec(nested, queue);
+            return withDbExec(nestedExec, () => run(nestedExec));
+        });
+    }
+    return exec;
+}
+function scopeDbExecToDrizzleTransactions(db, queryQueue) {
+    return new Proxy(db, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "transaction" && typeof value === "function") {
+                return (run, ...args) => {
+                    if (typeof run !== "function") {
+                        return value.apply(target, [run, ...args]);
+                    }
+                    if (!queryQueue) {
+                        if (activeDrizzleTransactionScopeForQueue()) {
+                            throw new Error("Cannot start a root transaction while another transaction is active; use the transaction handle to create a savepoint");
+                        }
+                        const transactionQueue = createDrizzleTransactionQueryQueue();
+                        return value.apply(target, [
+                            async (transaction) => {
+                                try {
+                                    return await withTransactionStatementTimeout(transaction, () => withDbExec(drizzleTransactionExec(transaction, transactionQueue), () => runInActiveDrizzleTransactionScope({ queue: transactionQueue, transaction }, () => run(scopeDbExecToDrizzleTransactions(transaction, transactionQueue)))));
+                                }
+                                finally {
+                                    await closeDrizzleTransactionQueryQueue(transactionQueue);
+                                }
+                            },
+                            ...args,
+                        ]);
+                    }
+                    return withNestedDrizzleTransaction(target, queryQueue, (transaction, nestedQueue) => withDbExec(drizzleTransactionExec(transaction, nestedQueue), () => run(scopeDbExecToDrizzleTransactions(transaction, nestedQueue))));
+                };
+            }
+            if (prop === "session" && value) {
+                const activeScope = activeDrizzleTransactionScopeForQueue(queryQueue);
+                return scopeDrizzleSessionQueries(value, queryQueue ?? activeScope?.queue);
+            }
+            if (prop === "query" && queryQueue && value) {
+                return scopeDrizzleRelationalQueries(value, target, queryQueue);
+            }
+            if (prop === "query" && value) {
+                const activeScope = activeDrizzleTransactionScopeForQueue();
+                return scopeDrizzleRootRelationalQueries(value, activeScope?.queue, activeScope?.transaction.session);
+            }
+            return typeof value === "function" ? value.bind(receiver) : value;
+        },
+    });
+}
 /**
  * Returns true when a SQL string starts with a SELECT-class verb.
  * Used by the Neon resilience wrapper to decide retry safety:
@@ -235,7 +710,7 @@ export function createGetDb(schema) {
                 const rawPool = sharedDbPool("neon", url, () => new Pool({ connectionString: url, ...neonPoolOptions() }));
                 guardNeonPool(rawPool, url);
                 const pool = buildResilientNeonPool(rawPool);
-                _db = drizzle(pool, { schema });
+                _db = scopeDbExecToDrizzleTransactions(drizzle(pool, { schema }));
                 return _db;
             });
         }
@@ -243,7 +718,7 @@ export function createGetDb(schema) {
             _dbReady = getPgDrizzle().then(({ drizzle, postgres }) => {
                 resetOnPoolClose("postgres-js", url);
                 const client = sharedDbPool("postgres-js", url, () => postgres(url, pgPoolOptions(url)));
-                _db = drizzle(buildResilientPostgresJsClient(client), { schema });
+                _db = scopeDbExecToDrizzleTransactions(drizzle(buildResilientPostgresJsClient(client), { schema }));
                 return _db;
             });
         }

package/dist/deploy/workspace-deploy.js

@@ -18,6 +18,12 @@ import { collectImmutableAssetPaths, IMMUTABLE_ASSET_CACHE_HEADERS, } from "./im
 function workspaceFrameworkRoutePrefixEnv() {
     return (process.env.AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX?.trim() || "");
 }
+function workspaceFrameworkRoutePrefixEnvSnippet() {
+    const frameworkRoutePrefix = workspaceFrameworkRoutePrefixEnv();
+    return frameworkRoutePrefix
+        ? `  processRef.env.AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX = ${JSON.stringify(frameworkRoutePrefix)};\n`
+        : "  delete processRef.env.AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX;\n";
+}
 function workspaceFrameworkRoutePrefix() {
     return normalizeFrameworkRoutePrefix(workspaceFrameworkRoutePrefixEnv() || undefined, "AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX");
 }
@@ -167,6 +173,7 @@ function buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApp
             ? workspaceGatewayUrl
             : null);
     const workspaceOAuthUrl = workspaceOAuthOrigin(workspaceGatewayUrl);
+    const frameworkRoutePrefix = workspaceFrameworkRoutePrefixEnv();
     const env = {
         ...process.env,
         NITRO_PRESET: preset,
@@ -184,7 +191,6 @@ function buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApp
             : {}),
         APP_BASE_PATH: `/${app}`,
         VITE_APP_BASE_PATH: `/${app}`,
-        AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX: workspaceFrameworkRoutePrefixEnv(),
         AGENT_NATIVE_WORKSPACE_APP_AUDIENCE: workspaceAppAudience,
         AGENT_NATIVE_WORKSPACE_APP_PUBLIC_PATHS: JSON.stringify(workspaceAppRouteAccess.publicPaths),
         AGENT_NATIVE_WORKSPACE_APP_PROTECTED_PATHS: JSON.stringify(workspaceAppRouteAccess.protectedPaths),
@@ -206,6 +212,13 @@ function buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApp
             : {}),
         [WORKSPACE_APPS_ENV_KEY]: JSON.stringify(workspaceApps),
     };
+    if (frameworkRoutePrefix) {
+        env.AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX =
+            frameworkRoutePrefix;
+    }
+    else {
+        delete env.AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX;
+    }
     if (preset === "netlify" && appUsesNetlifyUnpooledDatabaseUrl(appDir)) {
         env.DATABASE_URL =
             process.env.NETLIFY_DATABASE_URL_UNPOOLED ??
@@ -641,13 +654,13 @@ ${workspaceDirectoryEnvSnippet(workspaceApps)}
     VITE_AGENT_NATIVE_WORKSPACE_AUTH_MODE: ${JSON.stringify(workspaceAuthMode)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_ID: ${JSON.stringify(app)},
     VITE_APP_BASE_PATH: basePath,
-    AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX: ${JSON.stringify(workspaceFrameworkRoutePrefixEnv())},
     VITE_AGENT_NATIVE_WORKSPACE_APP_AUDIENCE: ${JSON.stringify(workspaceAppAudience)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PUBLIC_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.publicPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PROTECTED_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.protectedPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APPS_JSON: ${JSON.stringify(JSON.stringify(workspaceApps))},
     ${JSON.stringify(WORKSPACE_APPS_ENV_KEY)}: ${JSON.stringify(JSON.stringify(workspaceApps))},
   });
+${workspaceFrameworkRoutePrefixEnvSnippet()}
 }
 
 setBasePathEnv();
@@ -734,13 +747,13 @@ ${workspaceDirectoryEnvSnippet(workspaceApps)}
     VITE_AGENT_NATIVE_WORKSPACE_AUTH_MODE: ${JSON.stringify(workspaceAuthMode)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_ID: ${JSON.stringify(app)},
     VITE_APP_BASE_PATH: basePath,
-    AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX: ${JSON.stringify(workspaceFrameworkRoutePrefixEnv())},
     VITE_AGENT_NATIVE_WORKSPACE_APP_AUDIENCE: ${JSON.stringify(workspaceAppAudience)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PUBLIC_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.publicPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PROTECTED_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.protectedPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APPS_JSON: ${JSON.stringify(JSON.stringify(workspaceApps))},
     ${JSON.stringify(WORKSPACE_APPS_ENV_KEY)}: ${JSON.stringify(JSON.stringify(workspaceApps))},
   });
+${workspaceFrameworkRoutePrefixEnvSnippet()}
 }
 
 function enabled() {
@@ -865,13 +878,13 @@ ${workspaceDirectoryEnvSnippet(workspaceApps)}
     VITE_AGENT_NATIVE_WORKSPACE_AUTH_MODE: ${JSON.stringify(workspaceAuthMode)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_ID: ${JSON.stringify(app)},
     VITE_APP_BASE_PATH: basePath,
-    AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX: ${JSON.stringify(workspaceFrameworkRoutePrefixEnv())},
     VITE_AGENT_NATIVE_WORKSPACE_APP_AUDIENCE: ${JSON.stringify(workspaceAppAudience)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PUBLIC_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.publicPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PROTECTED_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.protectedPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APPS_JSON: ${JSON.stringify(JSON.stringify(workspaceApps))},
     ${JSON.stringify(WORKSPACE_APPS_ENV_KEY)}: ${JSON.stringify(JSON.stringify(workspaceApps))},
   });
+${workspaceFrameworkRoutePrefixEnvSnippet()}
 }
 
 setBasePathEnv();
@@ -928,13 +941,13 @@ ${workspaceDirectoryEnvSnippet(workspaceApps)}
     VITE_AGENT_NATIVE_WORKSPACE_AUTH_MODE: ${JSON.stringify(workspaceAuthMode)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_ID: ${JSON.stringify(app)},
     VITE_APP_BASE_PATH: basePath,
-    AGENT_NATIVE_CONFIG_RUNTIME_FRAMEWORK_ROUTE_PREFIX: ${JSON.stringify(workspaceFrameworkRoutePrefixEnv())},
     VITE_AGENT_NATIVE_WORKSPACE_APP_AUDIENCE: ${JSON.stringify(workspaceAppAudience)},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PUBLIC_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.publicPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APP_PROTECTED_PATHS: ${JSON.stringify(JSON.stringify(workspaceAppRouteAccess.protectedPaths))},
     VITE_AGENT_NATIVE_WORKSPACE_APPS_JSON: ${JSON.stringify(JSON.stringify(workspaceApps))},
     ${JSON.stringify(WORKSPACE_APPS_ENV_KEY)}: ${JSON.stringify(JSON.stringify(workspaceApps))},
   });
+${workspaceFrameworkRoutePrefixEnvSnippet()}
 }
 
 function normalizeBasePathArgs(args) {

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<{
     configured?: undefined;
     error?: undefined;
 } | {
-    url?: undefined;
     id?: undefined;
+    url?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

package/dist/localization/core-messages/supplemental/ar-SA.js

@@ -37,6 +37,8 @@ export const mcpConnectMessages = {
     revoke: "إلغاء",
     couldNotRevoke: "تعذر إلغاء الرمز.",
     authorizeDevice: "تخويل الجهاز",
+    organization: "المؤسسة",
+    invalidOrganization: "اختر مؤسسة أنت عضو فيها.",
     fullCatalogRequested: "يطلب هذا الجهاز الوصول إلى كتالوج الإجراءات الكامل.",
     createToken: "إنشاء رمز اتصال",
     authorizingDevice: "جارٍ تخويل الجهاز...",

package/dist/localization/core-messages/supplemental/de-DE.js

@@ -37,6 +37,8 @@ export const mcpConnectMessages = {
     revoke: "Widerrufen",
     couldNotRevoke: "Token konnte nicht widerrufen werden.",
     authorizeDevice: "Gerät autorisieren",
+    organization: "Organisation",
+    invalidOrganization: "Wähle eine Organisation, der du angehörst.",
     fullCatalogRequested: "Dieses Gerät fordert Zugriff auf den vollständigen Aktionskatalog an.",
     createToken: "Verbindungstoken erstellen",
     authorizingDevice: "Gerät wird autorisiert...",

package/dist/localization/core-messages/supplemental/en-US.js

@@ -37,6 +37,8 @@ export const mcpConnectMessages = {
     revoke: "Revoke",
     couldNotRevoke: "Could not revoke token.",
     authorizeDevice: "Authorize device",
+    organization: "Organization",
+    invalidOrganization: "Choose an organization you belong to.",
     fullCatalogRequested: "This device is requesting access to the full action catalog.",
     createToken: "Create connection token",
     authorizingDevice: "Authorizing device...",

package/dist/localization/core-messages/supplemental/es-ES.js

@@ -37,6 +37,8 @@ export const mcpConnectMessages = {
     revoke: "Revocar",
     couldNotRevoke: "No se pudo revocar el token.",
     authorizeDevice: "Autorizar dispositivo",
+    organization: "Organización",
+    invalidOrganization: "Elige una organización a la que pertenezcas.",
     fullCatalogRequested: "Este dispositivo solicita acceso al catálogo completo de acciones.",
     createToken: "Crear token de conexión",
     authorizingDevice: "Autorizando dispositivo...",