@pikku/cli 0.12.76 → 0.12.77

package/dist/src/functions/commands/new-addon.d.ts

@@ -10,6 +10,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     credential?: string;
     test?: boolean;
     openapi?: string;
+    authConfig?: string;
     mcp?: boolean;
     camelCase?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
@@ -24,6 +25,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     credential?: string;
     test?: boolean;
     openapi?: string;
+    authConfig?: string;
     mcp?: boolean;
     camelCase?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
@@ -38,6 +40,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     credential?: string;
     test?: boolean;
     openapi?: string;
+    authConfig?: string;
     mcp?: boolean;
     camelCase?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-addon.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
 import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
 import { pikkuSessionlessFunc } from '#pikku';
-import { parseOpenAPISpec, computeContractHash, generateAddonFromOpenAPI, } from '@pikku/openapi-parser';
+import { parseOpenAPISpec, computeContractHash, generateAddonFromOpenAPI, loadAuthConfig, } from '@pikku/openapi-parser';
 function toCamelCase(str) {
     return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
 }
@@ -174,7 +174,34 @@ ${description}
 // export { ${camelName}Operation } from './functions/operation.function.js'
 `;
     // src/services.ts
-    if (flags.credential && flags.credential !== 'oauth2') {
+    if (flags.delegated) {
+        // Delegated login: the credential is the upstream token captured at
+        // sign-in; an expired token is the re-auth signal (UnauthorizedError).
+        files['src/services.ts'] =
+            `import { UnauthorizedError } from '@pikku/core/errors'
+import { ${pascalName}Service } from './${name}-api.service.js'
+import { pikkuAddonWireServices } from '#pikku'
+
+export const createWireServices = pikkuAddonWireServices(
+  async ({ variables }, wire) => {
+    if (!wire.getCredential) {
+      throw new Error('Credential resolution is not available in this runtime')
+    }
+    const cred = await wire.getCredential<{ token: string; expiresAt?: number }>('${camelName}')
+    if (!cred?.token) {
+      throw new UnauthorizedError('No ${displayName} session — sign in again')
+    }
+    if (cred.expiresAt && cred.expiresAt * 1000 < Date.now()) {
+      throw new UnauthorizedError('${displayName} session expired — sign in again')
+    }
+    const ${camelName} = new ${pascalName}Service(cred, variables)
+
+    return { ${camelName} }
+  }
+)
+`;
+    }
+    else if (flags.credential && flags.credential !== 'oauth2') {
         // Per-user credential: use createWireServices with wire.getCredential()
         const credField = flags.credential === 'bearer' ? 'token' : 'apiKey';
         files['src/services.ts'] =
@@ -508,11 +535,16 @@ wireCredential({
 `;
     }
     else if (flags.credential === 'bearer') {
+        const credentialFields = flags.delegated
+            ? `  token: z.string().describe('${displayName} session token captured at delegated sign-in'),
+  expiresAt: z.number().optional().describe('Token expiry (epoch seconds)'),
+  tenantId: z.string().optional().describe('Upstream tenant id'),`
+            : `  token: z.string().describe('${displayName} bearer token'),`;
         files[`src/${name}.credential.ts`] = `import { z } from 'zod'
 import { wireCredential } from '@pikku/core/credential'
 
 export const ${camelName}CredentialSchema = z.object({
-  token: z.string().describe('${displayName} bearer token'),
+${credentialFields}
 })
 
 wireCredential({
@@ -766,7 +798,7 @@ async function writeFiles(baseDir, files) {
     return written;
 }
 export const pikkuNewAddon = pikkuSessionlessFunc({
-    func: async ({ logger, config }, { name, displayName, description, category = 'General', dir, secret = false, variable = false, oauth = false, credential, test = true, openapi, mcp = false, camelCase = false, }) => {
+    func: async ({ logger, config }, { name, displayName, description, category = 'General', dir, secret = false, variable = false, oauth = false, credential, test = true, openapi, authConfig, mcp = false, camelCase = false, }) => {
         name = sanitizeAddonName(name);
         if (!/^[a-z][a-z0-9_-]*$/.test(name)) {
             logger.error(`Invalid addon name "${name}": must start with a lowercase letter and contain only lowercase alphanumerics, hyphens, and underscores`);
@@ -791,6 +823,20 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
             description: resolvedDescription,
             category,
         };
+        // Load the auth config (custom auth header / delegated login overrides)
+        let loadedAuthConfig;
+        if (authConfig) {
+            loadedAuthConfig = await loadAuthConfig(authConfig);
+            if (loadedAuthConfig.delegated) {
+                // Delegated login stores the upstream token per-user — bearer is the
+                // only coherent credential mode.
+                if (credential && credential !== 'bearer') {
+                    logger.error(`--auth-config with delegated login requires --credential bearer (got "${credential}")`);
+                    process.exit(1);
+                }
+                credential = 'bearer';
+            }
+        }
         // Validate credential type if provided
         const credentialType = credential;
         if (credentialType &&
@@ -805,6 +851,7 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
             variable,
             oauth: effectiveOAuth,
             credential: credentialType,
+            delegated: Boolean(loadedAuthConfig?.delegated),
         });
         // If openapi spec provided, generate typed files and merge over scaffold
         if (openapi) {
@@ -815,6 +862,7 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
                 credential: credentialType,
                 mcp,
                 camelCase,
+                authConfig: loadedAuthConfig,
             });
             Object.assign(addonFiles, openapiFiles);
             // Inject openapi metadata into pikku.config.json
@@ -826,6 +874,7 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
                 version: spec.info.version,
                 hash: computeContractHash(spec),
                 ...(camelCase ? { camelCase: true } : {}),
+                ...(loadedAuthConfig ? { authConfig: true } : {}),
             };
             addonFiles['pikku.config.json'] = JSON.stringify(config, null, 2);
         }

package/dist/src/functions/db/db-codegen.d.ts

@@ -1,5 +1,6 @@
 import type { DbIntrospector } from './db-introspector.js';
 import { type ZodFormat } from './zod-codegen.js';
+import { type CodedDiagnostic } from '@pikku/inspector';
 type Dialect = 'sqlite' | 'postgres';
 export interface CodegenOptions {
     outFile: string;
@@ -31,8 +32,12 @@ export interface CodegenResult {
     classificationMapWritten: boolean;
     enumsWritten: boolean;
     tables: string[];
-    /** Non-fatal codegen warnings (e.g. name looks like a date but unannotated). */
-    warnings: string[];
+    /**
+     * Non-fatal codegen diagnostics (e.g. name looks like a date but unannotated,
+     * or a JSON column with no concrete `tsType`). The caller surfaces these via
+     * `logger.diagnostic(...)`, so `pikku db --fail-on-warn` can gate on them.
+     */
+    warnings: CodedDiagnostic[];
     /**
      * Per-interface, per-field zod `format` overrides for the zod codegen. Keyed
      * by interface name (PascalCase) and field name (camelCase), matching the

package/dist/src/functions/db/db-codegen.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { loadAnnotations, nameSuggestsKind, } from './annotation-parser.js';
 import { ZOD_FORMATS } from './zod-codegen.js';
+import { ErrorCode } from '@pikku/inspector';
 /**
  * The column kind implied by the *real* DB type, dialect-aware. Postgres has
  * native temporal/boolean types so we can trust them; SQLite stores dates as
@@ -13,6 +14,9 @@ function realKind(dialect, sqlType) {
     if (dialect !== 'postgres')
         return null;
     const u = sqlType.toUpperCase();
+    // Array types carry no scalar kind — an array of timestamps is not a `date`.
+    if (u.endsWith('[]'))
+        return null;
     if (u.includes('TIMESTAMP') || u === 'DATE')
         return 'date';
     if (u === 'BOOLEAN' || u === 'BOOL')
@@ -44,6 +48,10 @@ function escapeTsString(value) {
 // ─── Type mapping ─────────────────────────────────────────────────────────────
 function mapType(sqlType) {
     const upper = sqlType.toUpperCase();
+    // Preserve array-ness — map the element type and re-apply the `[]` suffix
+    // rather than letting the element's substring match flatten it to a scalar.
+    if (upper.endsWith('[]'))
+        return `${mapType(sqlType.slice(0, -2))}[]`;
     if (upper.includes('INT'))
         return 'number';
     if (upper.includes('CHAR') ||
@@ -173,8 +181,12 @@ function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByNam
         if (!ann?.kind && !ann?.tsType) {
             const suggested = nameSuggestsKind(col.name);
             if (suggested && real && suggested !== real) {
-                warnings.push(`Column "${bare}.${col.name}" is named like a ${suggested} but its DB type ` +
-                    `is ${col.type} (${real}). If intentional, set its kind in db/annotations.ts.`);
+                warnings.push({
+                    severity: 'warn',
+                    code: ErrorCode.DB_COLUMN_NAME_TYPE_CONTRADICTION,
+                    message: `Column "${bare}.${col.name}" is named like a ${suggested} but its DB type ` +
+                        `is ${col.type} (${real}). If intentional, set its kind in db/annotations.ts.`,
+                });
             }
         }
         // Enum columns are typed as a union of string literals — only when no
@@ -201,9 +213,13 @@ function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByNam
         if (isJsonColumn) {
             const resolved = selectBase(typeAnn, col);
             if (resolved === 'unknown' || resolved === 'any') {
-                warnings.push(`Column "${bare}.${col.name}" is ${col.type} and will be typed as ` +
-                    `\`${resolved}\` — JSON/JSONB columns need a concrete TypeScript type. ` +
-                    `In db/annotations.ts add: "${col.name}": { kind: 'json', tsType: 'YourType' }.`);
+                warnings.push({
+                    severity: 'warn',
+                    code: ErrorCode.DB_JSON_COLUMN_UNTYPED,
+                    message: `Column "${bare}.${col.name}" is ${col.type} and will be typed as ` +
+                        `\`${resolved}\` — JSON/JSONB columns need a concrete TypeScript type. ` +
+                        `In db/annotations.ts add: "${col.name}": { kind: 'json', tsType: 'YourType' }.`,
+                });
             }
         }
         // A `format` validator refines the zod schema only and keeps the TS type
@@ -217,8 +233,12 @@ function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByNam
                 (formatHints[ifaceName] ??= {})[fieldName] = ann.format;
             }
             else {
-                warnings.push(`Column "${bare}.${col.name}": format '${ann.format}' ignored — its ` +
-                    `resolved type is ${base}, not string. Remove the conflicting kind/tsType.`);
+                warnings.push({
+                    severity: 'warn',
+                    code: ErrorCode.DB_FORMAT_ON_NON_STRING,
+                    message: `Column "${bare}.${col.name}": format '${ann.format}' ignored — its ` +
+                        `resolved type is ${base}, not string. Remove the conflicting kind/tsType.`,
+                });
             }
         }
         const classification = ann?.classification ?? 'private';
@@ -379,10 +399,11 @@ export async function generateSchemaTypes(introspector, options) {
     const camelCase = options.camelCase ?? true;
     const dialect = options.dialect ?? 'sqlite';
     const tableNames = await introspector.listTables();
-    const tables = await Promise.all(tableNames.map(async (name) => ({
+    const columnsByTable = await introspector.getAllColumns();
+    const tables = tableNames.map((name) => ({
         name,
-        columns: await introspector.getColumns(name),
-    })));
+        columns: columnsByTable.get(name) ?? [],
+    }));
     const explicitAnnotations = options.rootDir
         ? loadAnnotations(options.rootDir)
         : {};
@@ -401,8 +422,6 @@ export async function generateSchemaTypes(introspector, options) {
     const interfaces = tables
         .map((t) => emitInterface(t, camelCase, explicitAnnotations, dialect, enumByName, zodFormats, warnings))
         .join('\n\n');
-    for (const w of warnings)
-        console.warn(`[pikku db] ${w}`);
     const dbEntries = tables
         .map((t) => {
         const tableKey = camelCase ? snakeToCamel(t.name) : t.name;
@@ -484,8 +503,7 @@ export async function generateSchemaTypes(introspector, options) {
     // ── pikku-db-schema.gen.json ─────────────────────────────────────────────────
     let schemaJsonBody = null;
     if (options.schemaJsonFile) {
-        const fkResults = await Promise.all(tableNames.map((name) => introspector.getForeignKeys(name)));
-        const fkMap = new Map(tableNames.map((name, i) => [name, fkResults[i]]));
+        const fkMap = await introspector.getAllForeignKeys();
         const jsonTables = tables.map((t) => ({
             name: t.name,
             columns: t.columns.map((c) => {

package/dist/src/functions/db/db-introspector.d.ts

@@ -34,6 +34,19 @@ export interface DbIntrospector {
     listTables(): Promise<string[]>;
     getColumns(table: string): Promise<ColumnInfo[]>;
     getForeignKeys(table: string): Promise<ForeignKeyInfo[]>;
+    /**
+     * Columns for every table in one sweep, keyed by the same table name that
+     * {@link listTables} returns (schema-qualified for non-`public` tables). On
+     * Postgres this is a single set-based query — introspecting a large schema
+     * must not fan out one round-trip per table, which both scales O(tables) and
+     * overlaps queries on a single connection.
+     */
+    getAllColumns(): Promise<Map<string, ColumnInfo[]>>;
+    /**
+     * Foreign keys for every table in one sweep, keyed like {@link getAllColumns}.
+     * Tables with no foreign keys may be omitted from the map.
+     */
+    getAllForeignKeys(): Promise<Map<string, ForeignKeyInfo[]>>;
     listEnums(): Promise<EnumInfo[]>;
     close(): Promise<void>;
 }

package/dist/src/functions/db/local-db.js

@@ -435,8 +435,7 @@ export async function createKysely(resolved) {
 }
 async function introspectorToMap(intro) {
     const map = new Map();
-    for (const table of await intro.listTables()) {
-        const cols = await intro.getColumns(table);
+    for (const [table, cols] of await intro.getAllColumns()) {
         map.set(table, new Set(cols.map((c) => c.name)));
     }
     return map;

package/dist/src/functions/db/postgres/postgres-introspector.d.ts

@@ -1,5 +1,5 @@
 import type { DbIntrospector, ColumnInfo, ForeignKeyInfo, EnumInfo } from '../db-introspector.js';
-interface QueryClient {
+export interface QueryClient {
     query<T = unknown>(sql: string, params?: unknown[]): Promise<{
         rows: T[];
     }>;
@@ -13,7 +13,8 @@ export declare class PostgresIntrospector implements DbIntrospector {
     listTables(): Promise<string[]>;
     getColumns(table: string): Promise<ColumnInfo[]>;
     getForeignKeys(table: string): Promise<ForeignKeyInfo[]>;
+    getAllColumns(): Promise<Map<string, ColumnInfo[]>>;
+    getAllForeignKeys(): Promise<Map<string, ForeignKeyInfo[]>>;
     listEnums(): Promise<EnumInfo[]>;
     close(): Promise<void>;
 }
-export {};

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -1,4 +1,22 @@
 import { Pool } from 'pg';
+/** Table display name matching `listTables` (schema-qualified unless `public`). */
+function tableKey(schema, table) {
+    return schema === 'public' ? table : `${schema}.${table}`;
+}
+/**
+ * Resolve the SQL type string for a column, preserving array-ness. Postgres
+ * reports every array column with `data_type = 'ARRAY'`; the element type lives
+ * in `udt_name` as the internal array type name (`_text`, `_int4`, `_uuid`, …).
+ * We strip the leading underscore and re-form it as `<element>[]` so downstream
+ * type mapping keeps the array instead of flattening to the scalar element.
+ */
+function resolveColumnType(dataType, udtName) {
+    if (dataType === 'ARRAY') {
+        const element = udtName.startsWith('_') ? udtName.slice(1) : udtName;
+        return `${element}[]`;
+    }
+    return dataType;
+}
 export class PostgresIntrospector {
     client;
     ownsClient;
@@ -25,9 +43,7 @@ export class PostgresIntrospector {
          AND table_schema NOT LIKE 'pg_temp_%'
          AND table_type = 'BASE TABLE'
        ORDER BY table_schema, table_name`);
-        return result.rows.map((r) => r.table_schema === 'public'
-            ? r.table_name
-            : `${r.table_schema}.${r.table_name}`);
+        return result.rows.map((r) => tableKey(r.table_schema, r.table_name));
     }
     async getColumns(table) {
         const dotIdx = table.indexOf('.');
@@ -57,7 +73,7 @@ export class PostgresIntrospector {
        ORDER BY c.ordinal_position`, [tableName, schema]);
         return result.rows.map((r) => ({
             name: r.column_name,
-            type: r.data_type,
+            type: resolveColumnType(r.data_type, r.udt_name),
             udtName: r.udt_name,
             notNull: r.is_nullable === 'NO',
             pk: Boolean(r.is_pk),
@@ -87,12 +103,98 @@ export class PostgresIntrospector {
        ORDER BY kcu.ordinal_position`, [tableName, schema]);
         return result.rows.map((r) => ({
             column: r.column_name,
-            foreignTable: r.foreign_table_schema === 'public'
-                ? r.foreign_table_name
-                : `${r.foreign_table_schema}.${r.foreign_table_name}`,
+            foreignTable: tableKey(r.foreign_table_schema, r.foreign_table_name),
             foreignColumn: r.foreign_column_name,
         }));
     }
+    async getAllColumns() {
+        const result = await this.client.query(`WITH pk_cols AS (
+         SELECT tc.table_schema, tc.table_name, kcu.column_name
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+          AND tc.table_name = kcu.table_name
+         WHERE tc.constraint_type = 'PRIMARY KEY'
+       )
+       SELECT
+         c.table_schema,
+         c.table_name,
+         c.column_name,
+         c.data_type,
+         c.udt_name,
+         c.is_nullable,
+         c.column_default,
+         c.is_generated,
+         (pk.column_name IS NOT NULL) AS is_pk
+       FROM information_schema.columns c
+       JOIN information_schema.tables t
+         ON t.table_schema = c.table_schema
+        AND t.table_name = c.table_name
+        AND t.table_type = 'BASE TABLE'
+       LEFT JOIN pk_cols pk
+         ON pk.table_schema = c.table_schema
+        AND pk.table_name = c.table_name
+        AND pk.column_name = c.column_name
+       WHERE c.table_schema NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+         AND c.table_schema NOT LIKE 'pg_temp_%'
+       ORDER BY c.table_schema, c.table_name, c.ordinal_position`);
+        const byTable = new Map();
+        for (const r of result.rows) {
+            const key = tableKey(r.table_schema, r.table_name);
+            let cols = byTable.get(key);
+            if (!cols) {
+                cols = [];
+                byTable.set(key, cols);
+            }
+            cols.push({
+                name: r.column_name,
+                type: resolveColumnType(r.data_type, r.udt_name),
+                udtName: r.udt_name,
+                notNull: r.is_nullable === 'NO',
+                pk: Boolean(r.is_pk),
+                defaultValue: r.column_default,
+                generated: r.is_generated === 'ALWAYS',
+            });
+        }
+        return byTable;
+    }
+    async getAllForeignKeys() {
+        const result = await this.client.query(`SELECT kcu.table_schema  AS owner_schema,
+              kcu.table_name    AS owner_table,
+              kcu.column_name,
+              kcu2.table_schema AS foreign_table_schema,
+              kcu2.table_name   AS foreign_table_name,
+              kcu2.column_name  AS foreign_column_name
+       FROM information_schema.referential_constraints rc
+       JOIN information_schema.key_column_usage kcu
+         ON kcu.constraint_catalog = rc.constraint_catalog
+        AND kcu.constraint_schema  = rc.constraint_schema
+        AND kcu.constraint_name    = rc.constraint_name
+       JOIN information_schema.key_column_usage kcu2
+         ON kcu2.constraint_catalog = rc.unique_constraint_catalog
+        AND kcu2.constraint_schema  = rc.unique_constraint_schema
+        AND kcu2.constraint_name    = rc.unique_constraint_name
+        AND kcu2.ordinal_position   = kcu.ordinal_position
+       WHERE kcu.table_schema NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+         AND kcu.table_schema NOT LIKE 'pg_temp_%'
+       ORDER BY kcu.table_schema, kcu.table_name, kcu.ordinal_position`);
+        const byTable = new Map();
+        for (const r of result.rows) {
+            const key = tableKey(r.owner_schema, r.owner_table);
+            let fks = byTable.get(key);
+            if (!fks) {
+                fks = [];
+                byTable.set(key, fks);
+            }
+            fks.push({
+                column: r.column_name,
+                foreignTable: tableKey(r.foreign_table_schema, r.foreign_table_name),
+                foreignColumn: r.foreign_column_name,
+            });
+        }
+        return byTable;
+    }
     async listEnums() {
         const result = await this.client.query(`SELECT t.typname AS enum_name,
               t.typnamespace::regnamespace::text AS schema_name,

package/dist/src/functions/db/sqlite/sqlite-introspector.d.ts

@@ -14,6 +14,8 @@ export declare class SqliteIntrospector implements DbIntrospector {
      */
     private parseCheckEnums;
     getForeignKeys(table: string): Promise<ForeignKeyInfo[]>;
+    getAllColumns(): Promise<Map<string, ColumnInfo[]>>;
+    getAllForeignKeys(): Promise<Map<string, ForeignKeyInfo[]>>;
     listEnums(): Promise<EnumInfo[]>;
     close(): Promise<void>;
 }

package/dist/src/functions/db/sqlite/sqlite-introspector.js

@@ -67,6 +67,22 @@ export class SqliteIntrospector {
             foreignColumn: r.to,
         }));
     }
+    async getAllColumns() {
+        const byTable = new Map();
+        for (const table of await this.listTables()) {
+            byTable.set(table, await this.getColumns(table));
+        }
+        return byTable;
+    }
+    async getAllForeignKeys() {
+        const byTable = new Map();
+        for (const table of await this.listTables()) {
+            const fks = await this.getForeignKeys(table);
+            if (fks.length > 0)
+                byTable.set(table, fks);
+        }
+        return byTable;
+    }
     async listEnums() {
         return [];
     }

package/dist/src/functions/wirings/workflow/pikku-command-workflow.js

@@ -62,7 +62,8 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
+        const agentMapImportPath = getFileImportRelativePath(workflowTypesFile, config.agentMapDeclarationFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath, agentMapImportPath));
         const scenarioActors = config.scenarios?.actors;
         if (scenarioActors && Object.keys(scenarioActors).length > 0) {
             const agentMapImportPath = getFileImportRelativePath(config.scenarioActorsFile, config.agentMapDeclarationFile, packageMappings);

package/dist/src/functions/wirings/workflow/serialize-workflow-types.d.ts

@@ -1 +1 @@
-export declare const serializeWorkflowTypes: (functionTypesImportPath: string, rpcMapImportPath: string, workflowMapImportPath: string) => string;
+export declare const serializeWorkflowTypes: (functionTypesImportPath: string, rpcMapImportPath: string, workflowMapImportPath: string, agentMapImportPath: string) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-types.js

@@ -1,4 +1,4 @@
-export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath, workflowMapImportPath) => {
+export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath, workflowMapImportPath, agentMapImportPath) => {
     return `import { WorkflowCancelledException } from '@pikku/core/workflow'
 import { template } from '@pikku/core/workflow'
 import {
@@ -12,6 +12,7 @@ export { WorkflowCancelledException }
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
 import type { FlattenedRPCMap } from '${rpcMapImportPath}'
 import type { FlattenedWorkflowMap } from '${workflowMapImportPath}'
+import type { AgentMap as FlattenedAgentMap } from '${agentMapImportPath}'
 
 export { template }
 
@@ -144,13 +145,19 @@ type InputWithRefs<T> = {
 type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> =
   FuncMap[K] extends keyof FlattenedRPCMap
     ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']>
-    : Record<string, unknown>
+    : FuncMap[K] extends keyof FlattenedWorkflowMap
+      ? InputWithRefs<FlattenedWorkflowMap[FuncMap[K]]['input']>
+      : Record<string, unknown>
 
 type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> =
   N extends keyof FuncMap
     ? FuncMap[N] extends keyof FlattenedRPCMap
       ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string
-      : string
+      : FuncMap[N] extends keyof FlattenedWorkflowMap
+        ? keyof FlattenedWorkflowMap[FuncMap[N]]['output'] & string
+        : FuncMap[N] extends keyof FlattenedAgentMap
+          ? keyof FlattenedAgentMap[FuncMap[N]]['output'] & string
+          : string
     : string
 
 type RefFunction<FuncMap extends Record<string, string>> = {
@@ -177,7 +184,12 @@ type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
 type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | { if: string; then: NodeIds; else?: NodeIds }
 
 export function pikkuWorkflowGraph<
-  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
+  const FuncMap extends Record<
+    string,
+    | (keyof FlattenedRPCMap & string)
+    | (keyof FlattenedWorkflowMap & string)
+    | (keyof FlattenedAgentMap & string)
+  >
 >(
   config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
 ): PikkuWorkflowGraphResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.76",
+  "version": "0.12.77",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {
@@ -28,17 +28,17 @@
     "@electric-sql/pglite": "^0.5.1",
     "@jridgewell/trace-mapping": "^0.3.25",
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/better-auth": "^0.12.15",
+    "@pikku/better-auth": "^0.12.17",
     "@pikku/bun-server": "^0.12.4",
     "@pikku/deploy-cloudflare": "^0.12.8",
-    "@pikku/fetch": "^0.12.6",
-    "@pikku/inspector": "^0.12.38",
+    "@pikku/fetch": "^0.12.7",
+    "@pikku/inspector": "^0.12.39",
     "@pikku/kysely": "^0.13.0",
     "@pikku/kysely-node-sqlite": "^0.12.3",
-    "@pikku/node-http-server": "^0.12.5",
-    "@pikku/openapi-parser": "^0.12.11",
-    "@pikku/schedule": "^0.12.3",
-    "@pikku/ws": "^0.12.3",
+    "@pikku/node-http-server": "^0.12.6",
+    "@pikku/openapi-parser": "^0.12.13",
+    "@pikku/schedule": "^0.12.4",
+    "@pikku/ws": "^0.12.4",
     "@types/cookie": "^1.0.0",
     "@types/json-schema": "^7.0.15",
     "chalk": "^5.6.2",
@@ -59,10 +59,10 @@
     "zod-to-ts": "^2.1.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.57"
+    "@pikku/core": "^0.12.58"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.57",
+    "@pikku/core": "^0.12.58",
     "@types/istanbul-lib-instrument": "^1.7.7",
     "@types/node": "^24.11.0",
     "@types/pg": "^8.11.0",
@@ -75,7 +75,7 @@
     "cli.schema.json"
   ],
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "exports": {
     ".": "./dist/bin/pikku.js"