create-absolutejs 0.15.2 → 0.15.4

package/dist/commands/formatProject.js

@@ -2,13 +2,15 @@ import { exit } from 'process';
 import { spinner } from '@clack/prompts';
 import { $ } from 'bun';
 import { green, red } from 'picocolors';
-import { formatCommands, formatNoInstallCommands } from '../utils/commandMaps';
+import { formatCommands } from '../utils/commandMaps';
 export const formatProject = async ({ projectName, packageManager, installDependenciesNow }) => {
+    // A no-install scaffold must be fully offline and must not assume a global
+    // formatter. Templates are already formatted in the published package.
+    if (!installDependenciesNow)
+        return;
     const spin = spinner();
     try {
-        const fmt = installDependenciesNow
-            ? formatCommands[packageManager]
-            : formatNoInstallCommands[packageManager];
+        const fmt = formatCommands[packageManager];
         spin.start('Formatting files…');
         const [bin, ...args] = fmt.split(' ');
         await $ `${bin} ${args}`.cwd(projectName).quiet();

package/dist/data.js

@@ -7,7 +7,7 @@ export const absoluteAuthPlugin = {
                 providersConfiguration: {}
             },
             isPlugin: true,
-            packageName: 'absoluteAuth'
+            packageName: 'auth'
         }
     ],
     latestVersion: versions['@absolutejs/auth'],

package/dist/generators/configurations/generatePackageJson.d.ts

@@ -1,8 +1,8 @@
 import type { CreateConfiguration } from '../../types';
-type CreatePackageJsonProps = Pick<CreateConfiguration, 'authOption' | 'useTailwind' | 'databaseEngine' | 'databaseHost' | 'plugins' | 'orm' | 'frontendDirectories' | 'codeQualityTool'> & {
+type CreatePackageJsonProps = Pick<CreateConfiguration, 'authOption' | 'agentic' | 'useTailwind' | 'databaseEngine' | 'databaseHost' | 'plugins' | 'orm' | 'frontendDirectories' | 'codeQualityTool'> & {
     projectName: string;
     latest: boolean;
     repositoryUrl: string | undefined;
 };
-export declare const createPackageJson: ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }: CreatePackageJsonProps) => Promise<void>;
+export declare const createPackageJson: ({ agentic, projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }: CreatePackageJsonProps) => Promise<void>;
 export {};

package/dist/generators/configurations/generatePackageJson.js

@@ -16,7 +16,7 @@ const dbClientCommands = {
     postgresql: 'psql -h localhost -U user -d database',
     singlestore: 'singlestore -u root -ppassword -D database'
 };
-export const createPackageJson = async ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }) => {
+export const createPackageJson = async ({ agentic, projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }) => {
     const flags = computeFlags(frontendDirectories);
     const isLocal = !databaseHost || databaseHost === 'none';
     /* ── Collect all package names that need versions ─────────── */
@@ -28,6 +28,27 @@ export const createPackageJson = async ({ projectName, authOption, plugins, data
         packageNames.add(dep.value);
     if (authOption === 'abs')
         packageNames.add(absoluteAuthPlugin.value);
+    if (agentic) {
+        packageNames.add('@absolutejs/a2a');
+        packageNames.add('@absolutejs/agency');
+        packageNames.add('@absolutejs/agent-conformance');
+        packageNames.add('@absolutejs/agent-discovery');
+        packageNames.add('@absolutejs/agent-inbox');
+        packageNames.add('@absolutejs/agent-memory');
+        packageNames.add('@absolutejs/agent-runtime');
+        packageNames.add('@absolutejs/agent-sandbox');
+        packageNames.add('@absolutejs/agent-trust');
+        packageNames.add('@absolutejs/agent-control');
+        packageNames.add('@absolutejs/auth');
+        packageNames.add('@absolutejs/egress');
+        packageNames.add('@absolutejs/execution');
+        packageNames.add('@absolutejs/manifest');
+        packageNames.add('@absolutejs/mcp');
+        packageNames.add('@absolutejs/policy');
+        packageNames.add('@absolutejs/secrets');
+        packageNames.add('@absolutejs/sync-bus-pg');
+        packageNames.add('@absolutejs/wallet');
+    }
     for (const pluginValue of plugins) {
         const meta = availablePlugins.find((p) => p.value === pluginValue);
         if (meta)
@@ -113,6 +134,9 @@ export const createPackageJson = async ({ projectName, authOption, plugins, data
     const dependencies = {};
     const devDependencies = {};
     devDependencies['typescript'] = resolveVersion('typescript', versions['typescript']);
+    /* Every scaffolded project runs on Bun, and the local database drivers type
+       against its built-in modules (`bun:sqlite`, `SQL` from `bun`). */
+    devDependencies['@types/bun'] = resolveVersion('@types/bun', versions['@types/bun']);
     for (const p of defaultPlugins) {
         dependencies[p.value] = resolveVersion(p.value, p.latestVersion);
     }
@@ -122,6 +146,31 @@ export const createPackageJson = async ({ projectName, authOption, plugins, data
     if (authOption === 'abs') {
         dependencies[absoluteAuthPlugin.value] = resolveVersion(absoluteAuthPlugin.value, absoluteAuthPlugin.latestVersion);
     }
+    if (agentic) {
+        for (const name of [
+            '@absolutejs/a2a',
+            '@absolutejs/agency',
+            '@absolutejs/agent-discovery',
+            '@absolutejs/agent-inbox',
+            '@absolutejs/agent-memory',
+            '@absolutejs/agent-runtime',
+            '@absolutejs/agent-sandbox',
+            '@absolutejs/agent-trust',
+            '@absolutejs/agent-control',
+            '@absolutejs/auth',
+            '@absolutejs/egress',
+            '@absolutejs/execution',
+            '@absolutejs/manifest',
+            '@absolutejs/mcp',
+            '@absolutejs/policy',
+            '@absolutejs/secrets',
+            '@absolutejs/sync-bus-pg',
+            '@absolutejs/wallet'
+        ]) {
+            dependencies[name] = resolveVersion(name, versions[name]);
+        }
+        devDependencies['@absolutejs/agent-conformance'] = resolveVersion('@absolutejs/agent-conformance', versions['@absolutejs/agent-conformance']);
+    }
     for (const pluginValue of plugins) {
         const meta = availablePlugins.find((p) => p.value === pluginValue);
         if (!meta)
@@ -243,6 +292,8 @@ export const createPackageJson = async ({ projectName, authOption, plugins, data
     if (orm === 'drizzle') {
         scripts['db:studio'] = 'drizzle-kit studio';
         scripts['db:push'] = 'drizzle-kit push';
+        /* `drizzle.config.ts` imports it and the scripts above shell out to it. */
+        devDependencies['drizzle-kit'] = resolveVersion('drizzle-kit', versions['drizzle-kit']);
     }
     const packageJson = {
         dependencies,

package/dist/generators/db/generateDatabaseTypes.js

@@ -163,7 +163,7 @@ export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption
     }
     const schemaImport = authOption === 'abs'
         ? `import { users, schema } from '../../db/schema';`
-        : `import { countHistory } from '../../db/schema';`;
+        : `import { countHistory, schema } from '../../db/schema';`;
     const extraTypes = authOption === 'abs'
         ? `export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;`

package/dist/generators/db/handlerTemplates.d.ts

@@ -6,122 +6,98 @@ type QueryOperations = {
 };
 declare const driverConfigurations: {
     readonly 'cockroachdb:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'gel:drizzle:local': {
-        readonly dbType: "GelJsDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'\n";
         readonly queries: QueryOperations;
     };
     readonly 'gel:sql:local': {
-        readonly dbType: "Client";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mariadb:drizzle:local': {
-        readonly dbType: "MySql2Database<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mariadb:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mongodb:sql:local': {
-        readonly dbType: "Db";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mssql:drizzle:local': {
-        readonly dbType: "NodeMssqlDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mssql:sql:local': {
-        readonly dbType: "ConnectionPool";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:drizzle:local': {
-        readonly dbType: "MySql2Database<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:drizzle:planetscale': {
-        readonly dbType: "PlanetScaleDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:planetscale': {
-        readonly dbType: "Client";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:local': {
-        readonly dbType: "BunSQLDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:neon': {
-        readonly dbType: "NeonDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:planetscale': {
-        readonly dbType: "NodePgDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:neon': {
-        readonly dbType: "Pool";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:planetscale': {
-        readonly dbType: "Pool";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'singlestore:drizzle:local': {
-        readonly dbType: "SingleStoreDriverDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'singlestore:sql:local': {
-        readonly dbType: "Pool";
         readonly importLines: "import { RowDataPacket } from 'mysql2/promise'\n";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:drizzle:local': {
-        readonly dbType: "BunSQLiteDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:drizzle:turso': {
-        readonly dbType: "LibSQLDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:sql:local': {
-        readonly dbType: "Database";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:sql:turso': {
-        readonly dbType: "Client";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };

package/dist/generators/db/handlerTemplates.js

@@ -1,22 +1,38 @@
-const buildSqlAuthTemplate = ({ importLines, queries }) => `
-import { DatabaseType, NewUser } from '../../types/databaseTypes';
+const buildSqlAuthTemplate = ({ importLines, queries, rowsAreTyped }) => `
+import { DatabaseType, NewUser${rowsAreTyped ? '' : ', User'} } from '../../types/databaseTypes';
 ${importLines}
 
-export const getUser = async (db: DatabaseType, authSub: string) => {
+${rowsAreTyped
+    ? `export const getUser = async (db: DatabaseType, authSub: string) => {
+	${queries.selectUser}
+};`
+    : `const selectUserRow = async (db: DatabaseType, authSub: string) => {
 	${queries.selectUser}
 };
 
+/* The driver returns the row untyped, so it is asserted to the shape the query
+   above selects. */
+export const getUser = async (
+	db: DatabaseType,
+	authSub: string
+): Promise<User | null> =>
+	((await selectUserRow(db, authSub)) as User | null) ?? null;`}
+
 export const createUser = async (db: DatabaseType, newUserData: NewUser) => {
 	const { auth_sub: authSub, metadata: userIdentity } = newUserData;
 	${queries.insertUser}
 }`;
-const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `
+/* Takes `db` as the `DatabaseType` alias rather than naming the driver type
+   inline, matching the auth template — the driver type is only ever spelled out
+   in types/databaseTypes, so it does not need importing at every call site. */
+const buildSqlCountTemplate = ({ importLines, queries }) => `
+import { DatabaseType } from '../../types/databaseTypes';
 ${importLines}
-export const getCountHistory = async (db: ${dbType}, uid: number) => {
+export const getCountHistory = async (db: DatabaseType, uid: number) => {
   ${queries.selectHistory}
 }
 
-export const createCountHistory = async (db: ${dbType}, count: number) => {
+export const createCountHistory = async (db: DatabaseType, count: number) => {
   ${queries.insertHistory}
 }
 `;
@@ -322,135 +338,111 @@ const mysqlPlanetScaleQueryOperations = {
 };
 const driverConfigurations = {
     'cockroachdb:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: postgresSqlQueryOperations
     },
     'gel:drizzle:local': {
-        dbType: 'GelJsDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'
 `,
         queries: drizzleQueryOperations
     },
     'gel:sql:local': {
-        dbType: 'Client',
         importLines: ``,
         queries: gelClientQueryOperations
     },
     'mariadb:drizzle:local': {
-        dbType: 'MySql2Database<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mariadb:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: mysqlSqlQueryOperations
     },
     'mongodb:sql:local': {
-        dbType: 'Db',
         importLines: ``,
         queries: mongodbQueryOperations
     },
     'mssql:drizzle:local': {
-        dbType: 'NodeMssqlDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'mssql:sql:local': {
-        dbType: 'ConnectionPool',
         importLines: ``,
         queries: mssqlSqlQueryOperations
     },
     'mysql:drizzle:local': {
-        dbType: 'MySql2Database<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mysql:drizzle:planetscale': {
-        dbType: 'PlanetScaleDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mysql:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: mysqlSqlQueryOperations
     },
     'mysql:sql:planetscale': {
-        dbType: 'Client',
         importLines: ``,
         queries: mysqlPlanetScaleQueryOperations
     },
     'postgresql:drizzle:local': {
-        dbType: 'BunSQLDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:drizzle:neon': {
-        dbType: 'NeonDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:drizzle:planetscale': {
-        dbType: 'NodePgDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: postgresSqlQueryOperations
     },
     'postgresql:sql:neon': {
-        dbType: 'Pool',
         importLines: ``,
         queries: postgresQueryOperations
     },
     'postgresql:sql:planetscale': {
-        dbType: 'Pool',
         importLines: ``,
         queries: postgresQueryOperations
     },
     'singlestore:drizzle:local': {
-        dbType: 'SingleStoreDriverDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'singlestore:sql:local': {
-        dbType: 'Pool',
         importLines: `import { RowDataPacket } from 'mysql2/promise'
 `,
         queries: singlestoreSqlQueryOperations
     },
     'sqlite:drizzle:local': {
-        dbType: 'BunSQLiteDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'sqlite:drizzle:turso': {
-        dbType: 'LibSQLDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'sqlite:sql:local': {
-        dbType: 'Database',
         importLines: ``,
         queries: bunSqliteQueryOperations
     },
     'sqlite:sql:turso': {
-        dbType: 'Client',
         importLines: ``,
         queries: libsqlQueryOperations
     }
@@ -459,7 +451,10 @@ export const getAuthTemplate = (key) => {
     const configuration = driverConfigurations[key];
     if (!configuration)
         throw new Error(`Unsupported driver configuration: ${key}`);
-    return buildSqlAuthTemplate(configuration);
+    return buildSqlAuthTemplate({
+        ...configuration,
+        rowsAreTyped: key.includes(':drizzle:')
+    });
 };
 export const getCountTemplate = (key) => {
     const configuration = driverConfigurations[key];

package/dist/generators/db/scaffoldDatabase.js

@@ -26,12 +26,12 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         usesAuth
     });
     writeFileSync(join(handlerDirectory, handlerFileName), dbHandlers, 'utf-8');
-    // Raw-SQL (no-ORM) auth handlers import `DatabaseType`/`NewUser` from
-    // types/databaseTypes (so do the auth config and the example page), but
-    // the drizzle-backed type module below is only written on the drizzle
-    // path. Generate a self-contained, driver-typed version here so the
-    // non-drizzle auth scaffold actually type-checks and builds.
-    if (usesAuth && orm !== 'drizzle') {
+    // Raw-SQL (no-ORM) handlers import `DatabaseType` (and `NewUser` on the auth
+    // path) from types/databaseTypes (so do the auth config and the example
+    // page), but the drizzle-backed type module below is only written on the
+    // drizzle path. Generate a self-contained, driver-typed version here so the
+    // non-drizzle scaffold actually type-checks and builds.
+    if (orm !== 'drizzle') {
         mkdirSync(typesDirectory, { recursive: true });
         const sqlTypes = generateDatabaseTypes({
             authOption,

package/dist/generators/project/generateAbsoluteAuthConfig.d.ts

@@ -1,2 +1,3 @@
 import { ProviderOption } from '@absolutejs/auth';
+export declare const generateSessionUserType: () => string;
 export declare const generateAbsoluteAuthConfig: (absProviders: ProviderOption[] | undefined, hasDatabase: boolean) => string;

package/dist/generators/project/generateAbsoluteAuthConfig.js

@@ -12,6 +12,15 @@ const defaultProviderConfigurations = {
         searchParams: [['access_type', 'offline']]
     }
 };
+/* Mirrors the `User` shape the raw-SQL path writes into types/databaseTypes, so
+   an auth scaffold without a database resolves the same type from the same
+   module the example page already imports. */
+export const generateSessionUserType = () => `export type User = {
+	auth_sub: string;
+	created_at: Date;
+	metadata: Record<string, unknown>;
+};
+`;
 export const generateAbsoluteAuthConfig = (absProviders, hasDatabase) => {
     const providerConfigs = (absProviders ?? [])
         .map((provider) => {
@@ -45,38 +54,46 @@ ${credentialsLines}
     if (!hasDatabase) {
         return `import { getEnv } from '@absolutejs/absolute';
 import {
-	AbsoluteAuthProps,
-	createInMemoryAuthSessionStore
+	createInMemoryAuthSessionStore,
+	defineAuthConfig
 } from '@absolutejs/auth';
+import { User } from '../../types/databaseTypes';
 
-export const absoluteAuthConfig = (): AbsoluteAuthProps => ({
-	authSessionStore: createInMemoryAuthSessionStore(),
-	providersConfiguration: {
+export const absoluteAuthConfig = () =>
+	defineAuthConfig<User>({
+		authSessionStore: createInMemoryAuthSessionStore(),
+		/* Without a database there is nowhere to persist users, so no user is
+		   ever registered and this resolver has nothing to look a subject up in.
+		   Scaffold with a database to persist users and resolve them here. */
+		getUser: () => null,
+		providersConfiguration: {
 ${providerConfigs}
-	}
-});
+		}
+	});
 `;
     }
     return `import { getEnv } from '@absolutejs/absolute';
 import {
-	AbsoluteAuthProps,
 	createInMemoryAuthSessionStore,
+	defineAuthConfig,
 	extractPropFromIdentity,
-	instantiateUserSession,
-	providers
+	instantiateUserSession
 } from '@absolutejs/auth';
 import { DatabaseType, User } from '../../types/databaseTypes';
 import { createUser, getUser } from '../handlers/userHandlers';
 
-export const absoluteAuthConfig = (
-	db: DatabaseType
-): AbsoluteAuthProps<User> => ({
+export const absoluteAuthConfig = (db: DatabaseType) =>
+	defineAuthConfig<User>({
 	authSessionStore: createInMemoryAuthSessionStore(),
+	getUser: async (sub) => (await getUser(db, sub)) ?? null,
 	providersConfiguration: {
 ${providerConfigs}
 	},
+	/* \`providerConfiguration\` is handed to the callback rather than looked up by
+	   name, so identity extraction also works for custom providers. */
 	onCallbackSuccess: async ({
 		authProvider,
+		providerConfiguration,
 		providerInstance,
 		tokenResponse,
 		unregisteredSession,
@@ -86,6 +103,7 @@ ${providerConfigs}
 	}) =>
 		instantiateUserSession({
 			authProvider,
+			providerConfiguration,
 			providerInstance,
 			session,
 			tokenResponse,
@@ -93,7 +111,6 @@ ${providerConfigs}
 			user_session_id,
 			getUser: async (userIdentity) => {
 				const provider = authProvider.toUpperCase();
-				const providerConfiguration = providers[authProvider];
 
 				const subject = extractPropFromIdentity(
 					userIdentity,
@@ -116,7 +133,6 @@ ${providerConfigs}
 			},
 			onNewUser: async (userIdentity) => {
 				const provider = authProvider.toUpperCase();
-				const providerConfiguration = providers[authProvider];
 
 				const subject = extractPropFromIdentity(
 					userIdentity,

package/dist/generators/project/generateRoutesBlock.js

@@ -10,8 +10,9 @@ export const generateRoutesBlock = ({ databaseEngine, frontendDirectories, authO
       return status(error.code, error.message);
     }
 
-    const providerConfiguration =
-      auth_client.value && providers[auth_client.value as ProviderOption];
+    const providerConfiguration = auth_client.value
+      ? providers[auth_client.value as ProviderOption]
+      : undefined;
 
     return ${handlerCall};
   }`

package/dist/generators/project/generateServer.js

@@ -36,11 +36,8 @@ export const generateServerFile = ({ tailwind, authOption, plugins, buildDirecto
         .filter((pluginImport) => pluginImport.isPlugin &&
         pluginImport.packageName !== 'networking')
         .map((pluginImport) => {
-        if (pluginImport.packageName === 'absoluteAuth') {
-            const hasDatabase = databaseEngine !== undefined && databaseEngine !== 'none';
-            return hasDatabase
-                ? `.use(absoluteAuth(absoluteAuthConfig(db)))`
-                : `.use(absoluteAuth(absoluteAuthConfig()))`;
+        if (pluginImport.packageName === 'auth') {
+            return `.use(authPlugin)`;
         }
         if (pluginImport.config === undefined) {
             return `.use(${pluginImport.packageName})`;
@@ -63,10 +60,16 @@ export const generateServerFile = ({ tailwind, authOption, plugins, buildDirecto
         databaseEngine,
         frontendDirectories
     });
+    const hasDatabase = databaseEngine !== undefined && databaseEngine !== 'none';
+    /* `auth()` is async, so it is hoisted out of the `.use()` chain rather than
+       inlined — Elysia accepts the promise as a plugin. */
+    const authBlock = authOption === 'abs'
+        ? `const authPlugin = auth(absoluteAuthConfig(${hasDatabase ? 'db' : ''}))\n`
+        : '';
     const content = `${importsBlock}
 
 ${manifestBlock}
-${dbBlock ? `${dbBlock}\n` : ''}
+${dbBlock ? `${dbBlock}\n` : ''}${authBlock}
 const server = new Elysia()
 .use(absolutejs)
 ${useBlock}${authOption === 'abs' ? `\n${guardBlock}` : ''}

package/dist/generators/project/scaffoldAgentic.d.ts

@@ -0,0 +1,7 @@
+export declare const agentRuntimeSource = "import {\n\tcreateAgency,\n\tcreateAgentControlPlane,\n\tcreateMemoryAgencyStore,\n\tcreateMemoryAgentControlStore,\n\tdenyAllPolicy\n} from '@absolutejs/agency'\nimport {\n\tcreateAgentRuntime,\n\tcreateMemoryAgentRuntimeStore\n} from '@absolutejs/agent-runtime'\n\n// Memory stores are development defaults. Replace them with durable stores\n// before running more than one process or accepting production actions.\nexport const agentControl = createAgentControlPlane({\n\tsources: [],\n\tstore: createMemoryAgentControlStore()\n})\n\n// Intentionally deny-by-default. Replace denyAllPolicy() with your policy\n// decision point only after declaring each action's effects and scopes.\nexport const agency = createAgency({\n\tcontrol: agentControl,\n\tpolicy: denyAllPolicy(),\n\tstore: createMemoryAgencyStore()\n})\n\n// Durable run semantics are available from the first commit. The placeholder\n// driver fails closed until the application supplies its model/tool loop.\nexport const agentRuntime = createAgentRuntime({\n\tstore: createMemoryAgentRuntimeStore(),\n\tdriver: {\n\t\tnext: async () => ({\n\t\t\ttype: 'fail',\n\t\t\tcode: 'agent_not_configured',\n\t\t\tmessage: 'Configure the agent driver before accepting runs'\n\t\t})\n\t},\n\teffects: {\n\t\texecute: async () => {\n\t\t\tthrow new Error('Agent effects are not configured')\n\t\t}\n\t}\n})\n";
+export declare const agentDiscoverySource = "import {\n\tABSOLUTE_AGENT_SCHEMA,\n\tcreateAgentDiscoveryHandler,\n\tsignAgentDocument,\n\ttype AgentDiscoveryDocument,\n\ttype DiscoverySigner\n} from '@absolutejs/agent-discovery'\n\n// Keep this document specific and keyword-rich: registries rank declared\n// capabilities, effects, scopes, interfaces, examples, and publisher trust.\nexport const createAgentDocument = ({\n\torigin,\n\tpublishedAt,\n\tversion\n}: {\n\torigin: string\n\tpublishedAt: string\n\tversion: string\n}): AgentDiscoveryDocument => ({\n\t$schema: ABSOLUTE_AGENT_SCHEMA,\n\tid: `${origin}/agents/main`,\n\tname: 'Replace with your agent name',\n\tdescription: 'Replace with a precise description of the outcomes this agent delivers.',\n\tversion,\n\turl: origin,\n\tpublisher: {\n\t\tid: origin,\n\t\tname: 'Replace with your organization',\n\t\tjwksUri: `${origin}/.well-known/jwks.json`\n\t},\n\tcapabilities: [{\n\t\tid: 'status.read',\n\t\ttitle: 'Read service status',\n\t\tdescription: 'Returns the public health and readiness status of this agent.',\n\t\ttags: ['status', 'health', 'readiness'],\n\t\teffects: ['read'],\n\t\tapproval: 'never'\n\t}],\n\tinterfaces: [{\n\t\ttype: 'http',\n\t\turl: `${origin}/api/agents/main`,\n\t\tcontentTypes: ['application/json']\n\t}],\n\tcategories: ['replace-with-domain-category'],\n\ttags: ['replace-with-user-intent', 'replace-with-outcome'],\n\tlanguages: ['en'],\n\tdocumentationUrl: `${origin}/docs/agents/main`,\n\texamples: [{\n\t\ttitle: 'Check whether the agent is ready',\n\t\tprompt: 'Check the agent service status.',\n\t\tcapabilityId: 'status.read'\n\t}],\n\tcreatedAt: publishedAt,\n\tupdatedAt: publishedAt\n})\n\n// Use a KMS/HSM-backed signer in production. Mount the returned fetch handler\n// at the origin root so all well-known, A2A, JSON-LD, agents.txt, and sitemap\n// discovery surfaces are served from one signed descriptor.\nexport const createAgentDiscovery = async ({\n\tsigner,\n\torigin,\n\tpublishedAt,\n\tversion\n}: {\n\tsigner: DiscoverySigner\n\torigin: string\n\tpublishedAt: string\n\tversion: string\n}) =>\n\tcreateAgentDiscoveryHandler({\n\t\tdocuments: [await signAgentDocument(\n\t\t\tcreateAgentDocument({ origin, publishedAt, version }),\n\t\t\tsigner\n\t\t)]\n\t})\n";
+export declare const agentsGuide = "# Agent execution contract\n\nThis project uses the AbsoluteJS provider-neutral agent stack.\n\n- Authenticate agents and bind every delegation to a user with\n  `@absolutejs/auth`. Never treat model-provided identity as authenticated.\n- Route every effectful tool through `agency` in `src/backend/agent.ts`.\n  Approval is exact-input-bound; execution requires a fresh single-use lease.\n- Declare tool effects, scopes, approval policy, idempotency keys,\n  reversibility, destinations, and spend fields in manifest contract 2.\n- Keep raw credentials host-side with `@absolutejs/secrets` credential\n  operations. Agents receive operation results, never secret values.\n- Give agents bounded wallet allowances and signed mandates. The host resolves\n  ledger destinations; an agent never supplies the recipient account id.\n- Bind MCP task handles to the authenticated actor on get, update, and cancel.\n- Use `@absolutejs/execution` for idempotent effects and its transactional\n  PostgreSQL outbox before handing work to a durable queue.\n- Publish and consume remote agents with `@absolutejs/a2a` using A2A 1.0;\n  preserve the authenticated tenant and actor binding at every task boundary.\n- Route outbound HTTP through `@absolutejs/egress`. Authorize host, method,\n  resolved public IP, redirects, byte limits, and injected credentials host-side.\n- Store immutable, digest-addressed policy revisions with `@absolutejs/policy`\n  and atomically activate only reviewed versions.\n- Publish the signed descriptor in `src/backend/agent-discovery.ts` through\n  `@absolutejs/agent-discovery`. Keep capabilities, examples, tags, effects,\n  scopes, A2A/MCP interfaces, JSON-LD, agents.txt, and sitemap surfaces current.\n- Run long-lived work through `@absolutejs/agent-runtime`; use its leases,\n  checkpoints, timers, budgets, cancellation, and crash-safe effect recovery.\n- Authorize all HTTP/filesystem/process access with expiring\n  `@absolutejs/agent-sandbox` grants. There is no ambient agent authority.\n- Preserve instruction/data separation and provenance taints with\n  `@absolutejs/agent-trust`; external content never becomes an instruction.\n- Store scoped, expiring, provenance-bearing data with\n  `@absolutejs/agent-memory`, and validate writes against memory poisoning.\n- Receive only verified events through `@absolutejs/agent-inbox`; durable\n  leases, retries, dead letters, and schedules do not require Redis.\n- Use OpenID AuthZEN AARP for requestable approvals and COAZ mappings for\n  parameter-level MCP authorization. Approval always triggers re-evaluation.\n- Protect operator actions with `@absolutejs/agent-control` scopes, a\n  kill-switch-first check, and leased idempotency records.\n- Use `@absolutejs/sync-bus-pg` for durable framework channels. Redis is an\n  optional at-most-once fanout adapter, not a source of truth or work queue.\n- Run `@absolutejs/agent-conformance` suites for every new action, capability,\n  credential, wallet, egress, execution, control, and task adapter.\n- Use the control plane kill switch for incident response. It blocks new\n  requests, lease issuance, and execution before downstream revocation fans out.\n\nMemory stores are for local development only. Production stores must be\ndurable and enforce lease/capability consumption atomically. Apply each\npackage's exported PostgreSQL schema in a migration before enabling traffic.\n";
+export declare const scaffoldAgentic: ({ backendDirectory, projectName }: {
+    backendDirectory: string;
+    projectName: string;
+}) => void;