agent-manifest 3.3.0 → 4.0.0

package/dist/cli.js

@@ -43,7 +43,7 @@ const program = new commander_1.Command();
 program
     .name('agentjson')
     .description('Universal agent manifest compiler — generates agent.json for any web app')
-    .version('3.1.0')
+    .version('4.0.0')
     .option('-p, --path <path>', 'path to the project root', '.')
     .option('-o, --output <output>', 'output path for agent.json', './public/agent.json')
     .option('--author <author>', 'author name or organization')
@@ -51,6 +51,7 @@ program
     .option('--auth-type <type>', 'override detected auth type: none | bearer | api-key | oauth2 | basic | farcaster-frame | cookie')
     .option('--auth-header <header>', 'auth header name (default: Authorization)')
     .option('--auth-docs <url>', 'URL where agents can obtain credentials')
+    .option('--base-url <url>', 'canonical base URL for the app (e.g. https://myapp.com)')
     .action(async (options) => {
     const projectPath = path.resolve(options.path);
     const outputPath = path.resolve(options.output);
@@ -69,6 +70,7 @@ program
     const openApiParser = new index_1.OpenAPIParser();
     const prismaParser = new index_1.PrismaParser();
     const actions = [];
+    const dataModel = {};
     // Determine which files are OpenAPI / Prisma by extension/name
     const openApiExts = new Set(['.json', '.yaml', '.yml']);
     const prismaExt = '.prisma';
@@ -90,7 +92,8 @@ program
         // ── Prisma schema ─────────────────────────────────────────────────────
         if (ext === prismaExt || base === 'schema.prisma') {
             try {
-                actions.push(...prismaParser.parseFile(file));
+                const prismaResult = prismaParser.parseFile(file);
+                Object.assign(dataModel, prismaResult.dataModel);
             }
             catch { /* ignore */ }
             continue;
@@ -131,7 +134,7 @@ program
     const uniqueActions = new Map();
     for (const action of actions) {
         const existing = uniqueActions.get(action.name);
-        if (!existing || Object.keys(action.inputs).length > Object.keys(existing.inputs).length) {
+        if (!existing || Object.keys(action.parameters?.properties ?? {}).length > Object.keys(existing.parameters?.properties ?? {}).length) {
             uniqueActions.set(action.name, action);
         }
     }
@@ -148,11 +151,18 @@ program
         ...(options.authDocs && { docsUrl: options.authDocs }),
     };
     const generator = new index_1.ManifestGenerator();
-    const manifest = generator.generate(Array.from(uniqueActions.values()), appMetadata, tsParser.getCapabilities(), auth);
+    const manifest = generator.generate(Array.from(uniqueActions.values()), appMetadata, tsParser.getCapabilities(), auth, '1.0.0', {
+        baseUrl: options.baseUrl ?? appMetadata.url,
+        dataModel,
+    });
     fs.mkdirSync(path.dirname(outputPath), { recursive: true });
     fs.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
+    const uiCount = Array.from(uniqueActions.values()).filter(a => a.type === 'ui').length;
+    const modelCount = Object.keys(dataModel).length;
     console.log(`✅ agent.json generated at: ${outputPath}`);
-    console.log(`   ${uniqueActions.size} actions · ${manifest.capabilities.length} capabilities · auth: ${auth.type}`);
+    console.log(`   ${uniqueActions.size} actions${uiCount ? ` · ${uiCount} ui-interactions` : ''} · ${manifest.capabilities.length} capabilities · auth: ${auth.type}`);
+    if (modelCount > 0)
+        console.log(`   dataModel: ${modelCount} models`);
 });
 // ─── validate ────────────────────────────────────────────────────────────────
 program
@@ -186,8 +196,12 @@ program
 });
 // ─── Structural validator ────────────────────────────────────────────────────
 const SAFETY_LEVELS = new Set(['read', 'write', 'financial', 'destructive', 'confidential']);
-const ACTION_TYPES = new Set(['api', 'contract', 'function', 'socket']);
-const AUTH_TYPES = new Set(['none', 'bearer', 'api-key', 'oauth2', 'basic', 'farcaster-frame', 'cookie']);
+const ACTION_TYPES = new Set(['api', 'contract', 'function', 'socket', 'ui']);
+const AUTH_TYPES = new Set([
+    'none', 'bearer', 'api-key', 'oauth2', 'basic', 'cookie',
+    'siwe', 'farcaster-siwf', 'farcaster-frame',
+    'clerk', 'privy', 'dynamic', 'magic', 'passkey', 'saml', 'supabase',
+]);
 const INTENT_RE = /^[a-z][a-z0-9]*\.[a-z][a-z0-9]*$/;
 function validateManifest(m) {
     const errors = [];
@@ -211,13 +225,19 @@ function validateManifest(m) {
             else if (!INTENT_RE.test(action.intent))
                 errors.push(`${prefix}: \`intent\` must match domain.verb format`);
             if (!ACTION_TYPES.has(action.type))
-                errors.push(`${prefix}: \`type\` must be one of api|contract|function`);
+                errors.push(`${prefix}: \`type\` must be one of api|contract|function|socket|ui`);
             if (!SAFETY_LEVELS.has(action.safety))
                 errors.push(`${prefix}: \`safety\` must be one of read|write|financial|destructive|confidential`);
             if (typeof action.agentSafe !== 'boolean')
                 errors.push(`${prefix}: \`agentSafe\` must be a boolean`);
             if (!action.requiredAuth)
                 errors.push(`${prefix}: \`requiredAuth\` is missing`);
+            else if (!['public', 'required', 'farcaster-signed'].includes(action.requiredAuth.required))
+                errors.push(`${prefix}: \`requiredAuth.required\` must be "public", "required", or "farcaster-signed"`);
+            if (!action.parameters || typeof action.parameters.properties !== 'object')
+                errors.push(`${prefix}: \`parameters.properties\` must be an object`);
+            if (!action.returns || typeof action.returns.type !== 'string')
+                errors.push(`${prefix}: \`returns.type\` must be a string`);
         });
     }
     return errors;

package/dist/discovery/service.js

@@ -72,6 +72,15 @@ const ALWAYS_EXCLUDE = [
     '!**/secrets/**',
     '!**/credentials/**',
 ];
+/**
+ * Checks if a path is strictly within the project directory.
+ * Prevents path traversal via symbolic links or malformed paths.
+ */
+function isPathWithinProject(filePath, projectPath) {
+    const resolved = path.resolve(filePath);
+    const root = path.resolve(projectPath);
+    return resolved.startsWith(root);
+}
 class DiscoveryService {
     projectPath;
     cache = {};
@@ -150,6 +159,8 @@ class DiscoveryService {
             ...ALWAYS_EXCLUDE,
         ], { cwd: this.projectPath, absolute: true });
         for (const file of allTsFiles) {
+            if (!isPathWithinProject(file, this.projectPath))
+                continue;
             if (relevantFiles.includes(file))
                 continue;
             const hash = fileHash(file);

package/dist/generator/json.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManifestGenerator = void 0;
 class ManifestGenerator {
-    generate(actions, metadata = {}, capabilities = [], auth = { type: 'none' }, version = '1.0.0') {
+    generate(actions, metadata = {}, capabilities = [], auth = { type: 'none' }, version = '1.0.0', options = {}) {
         return {
             name: metadata.name ?? 'Web App',
             description: metadata.description ?? 'Auto-generated agent manifest',
             version,
             ...(metadata.author && { author: metadata.author }),
             ...(metadata.url && { url: metadata.url }),
+            ...(options.baseUrl && { baseUrl: options.baseUrl }),
             auth,
             metadata: {
                 ...(metadata.iconUrl && { iconUrl: metadata.iconUrl }),
@@ -19,6 +20,7 @@ class ManifestGenerator {
             },
             capabilities,
             actions,
+            ...(options.dataModel && Object.keys(options.dataModel).length > 0 && { dataModel: options.dataModel }),
         };
     }
 }

package/dist/parser/auth-detector.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthDetector = void 0;
+exports.AuthFlowInferrer = exports.AuthDetector = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const AUTH_SIGNALS = [
@@ -42,6 +42,15 @@ const AUTH_SIGNALS = [
     { pattern: '@farcaster/frame-node', type: 'farcaster-frame', priority: 100 },
     { pattern: 'validateFrameMessage', type: 'farcaster-frame', priority: 100 },
     { pattern: 'frameActionPayload', type: 'farcaster-frame', priority: 100 },
+    // Farcaster SIWF — must be before SIWE (higher priority)
+    { pattern: '@farcaster/auth-kit', type: 'farcaster-siwf', priority: 98 },
+    { pattern: 'verifySignInMessage', type: 'farcaster-siwf', priority: 98 },
+    { pattern: 'useSignIn', type: 'farcaster-siwf', priority: 95 },
+    // SIWE
+    { pattern: 'SiweMessage', type: 'siwe', priority: 95 },
+    { pattern: "from 'siwe'", type: 'siwe', priority: 95 },
+    { pattern: 'verifySiweMessage', type: 'siwe', priority: 95 },
+    { pattern: 'generateNonce', type: 'siwe', priority: 90 },
     // OAuth2 / NextAuth / Auth.js
     { pattern: 'NextAuth', type: 'oauth2', priority: 90 },
     { pattern: 'next-auth', type: 'oauth2', priority: 90 },
@@ -51,8 +60,14 @@ const AUTH_SIGNALS = [
     { pattern: 'oauth2', type: 'oauth2', priority: 80 },
     { pattern: 'access_token', type: 'oauth2', priority: 75 },
     { pattern: 'refresh_token', type: 'oauth2', priority: 75 },
-    { pattern: 'clerkMiddleware', type: 'bearer', scheme: 'Bearer', priority: 88 },
-    { pattern: 'currentUser', type: 'bearer', scheme: 'Bearer', priority: 70 },
+    // SAML
+    { pattern: 'samlify', type: 'saml', priority: 92 },
+    { pattern: 'passport-saml', type: 'saml', priority: 92 },
+    { pattern: '@node-saml', type: 'saml', priority: 92 },
+    { pattern: 'SAMLResponse', type: 'saml', priority: 88 },
+    // Clerk
+    { pattern: 'clerkMiddleware', type: 'clerk', priority: 88 },
+    { pattern: 'currentUser', type: 'clerk', priority: 70 },
     // JWT / Bearer
     { pattern: 'jwt.verify', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
     { pattern: 'jsonwebtoken', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
@@ -61,6 +76,25 @@ const AUTH_SIGNALS = [
     { pattern: 'authorization.split', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 },
     { pattern: "headers.get('authorization')", type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 65 },
     { pattern: "req.headers.authorization", type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 65 },
+    // Privy
+    { pattern: '@privy-io/react-auth', type: 'privy', priority: 85 },
+    { pattern: 'usePrivy', type: 'privy', priority: 85 },
+    { pattern: 'PrivyProvider', type: 'privy', priority: 85 },
+    // Dynamic
+    { pattern: '@dynamic-labs/sdk-react-core', type: 'dynamic', priority: 85 },
+    { pattern: 'DynamicContextProvider', type: 'dynamic', priority: 85 },
+    { pattern: 'useDynamicContext', type: 'dynamic', priority: 80 },
+    // Magic
+    { pattern: 'magic-sdk', type: 'magic', priority: 80 },
+    { pattern: '@magic-sdk', type: 'magic', priority: 80 },
+    { pattern: 'new Magic(', type: 'magic', priority: 80 },
+    // Passkey / WebAuthn
+    { pattern: '@simplewebauthn/browser', type: 'passkey', priority: 78 },
+    { pattern: 'startAuthentication', type: 'passkey', priority: 78 },
+    { pattern: 'startRegistration', type: 'passkey', priority: 78 },
+    { pattern: 'navigator.credentials.create', type: 'passkey', priority: 75 },
+    // Supabase
+    { pattern: 'supabase.auth', type: 'supabase', priority: 75 },
     // API key
     { pattern: "'x-api-key'", type: 'api-key', header: 'X-API-Key', priority: 60 },
     { pattern: '"x-api-key"', type: 'api-key', header: 'X-API-Key', priority: 60 },
@@ -80,6 +114,7 @@ const AUTH_SIGNALS = [
 ];
 class AuthDetector {
     best = null;
+    _flowInferrer = new AuthFlowInferrer();
     scanContent(content) {
         for (const signal of AUTH_SIGNALS) {
             if (content.includes(signal.pattern)) {
@@ -88,6 +123,7 @@ class AuthDetector {
                 }
             }
         }
+        this._flowInferrer.addContent(content);
     }
     /** Read package.json to detect auth libraries in dependencies */
     readPackageJson(projectPath) {
@@ -99,8 +135,24 @@ class AuthDetector {
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (deps['next-auth'] || deps['@auth/core'])
                 this.applySignal({ pattern: 'next-auth', type: 'oauth2', priority: 90 });
+            if (deps['@farcaster/auth-kit'])
+                this.applySignal({ pattern: 'farcaster-siwf', type: 'farcaster-siwf', priority: 98 });
+            if (deps['siwe'])
+                this.applySignal({ pattern: 'siwe', type: 'siwe', priority: 95 });
+            if (deps['samlify'] || deps['passport-saml'])
+                this.applySignal({ pattern: 'saml', type: 'saml', priority: 92 });
             if (deps['@clerk/nextjs'] || deps['@clerk/clerk-sdk-node'])
-                this.applySignal({ pattern: 'clerk', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 88 });
+                this.applySignal({ pattern: 'clerk', type: 'clerk', priority: 88 });
+            if (deps['@privy-io/react-auth'])
+                this.applySignal({ pattern: 'privy', type: 'privy', priority: 85 });
+            if (deps['@dynamic-labs/sdk-react-core'])
+                this.applySignal({ pattern: 'dynamic', type: 'dynamic', priority: 85 });
+            if (deps['magic-sdk'] || deps['@magic-sdk/admin'])
+                this.applySignal({ pattern: 'magic', type: 'magic', priority: 80 });
+            if (deps['@simplewebauthn/browser'])
+                this.applySignal({ pattern: 'passkey', type: 'passkey', priority: 78 });
+            if (deps['@supabase/supabase-js'])
+                this.applySignal({ pattern: 'supabase', type: 'supabase', priority: 75 });
             if (deps['jsonwebtoken'] || deps['jose'])
                 this.applySignal({ pattern: 'jwt', type: 'bearer', header: 'Authorization', scheme: 'Bearer', priority: 70 });
             if (deps['iron-session'])
@@ -118,14 +170,44 @@ class AuthDetector {
     getAuth() {
         if (!this.best)
             return { type: 'none' };
-        const config = { type: this.best.type };
+        const type = this.best.type;
+        const config = { type };
         if (this.best.header)
             config.header = this.best.header;
         if (this.best.scheme)
             config.scheme = this.best.scheme;
         if (this.best.queryParam)
             config.queryParam = this.best.queryParam;
-        return config;
+        const flowFields = this._flowInferrer.infer(type);
+        return { ...config, ...flowFields };
     }
 }
 exports.AuthDetector = AuthDetector;
+class AuthFlowInferrer {
+    scannedContents = [];
+    addContent(content) {
+        this.scannedContents.push(content);
+    }
+    infer(authType) {
+        const result = {};
+        for (const content of this.scannedContents) {
+            if (!result.nonceUrl && (authType === 'siwe' || authType === 'farcaster-siwf')) {
+                const m = content.match(/['"`](\/api\/auth\/nonce[^'"`\s]*)['"`]/);
+                if (m)
+                    result.nonceUrl = m[1];
+            }
+            if (!result.callbackUrl && authType === 'oauth2') {
+                const m = content.match(/['"`](\/api\/auth\/callback[^'"`\s]*)['"`]/);
+                if (m)
+                    result.callbackUrl = m[1];
+            }
+            if (!result.loginUrl) {
+                const m = content.match(/['"`](\/sign-in|\/login|\/auth\/login)['"`]/);
+                if (m)
+                    result.loginUrl = m[1];
+            }
+        }
+        return result;
+    }
+}
+exports.AuthFlowInferrer = AuthFlowInferrer;

package/dist/parser/contract-parser.js

@@ -93,10 +93,10 @@ class ContractParser {
                     abiFunction: item.name,
                     isReadOnly,
                     safety,
-                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, item.name),
                     requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, isReadOnly, type: 'contract' }),
-                    inputs: this.mapAbiInputs(item.inputs ?? []),
-                    outputs: {
+                    parameters: { properties: this.mapAbiInputs(item.inputs ?? []) },
+                    returns: {
                         type: this.mapAbiOutputs(item.outputs ?? []),
                         description: '',
                     },
@@ -172,10 +172,10 @@ class ContractParser {
                 ...(chainId !== undefined ? { chainId } : {}),
                 ...(contractAddress !== undefined ? { contractAddress } : {}),
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, functionName),
                 requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, isReadOnly: false, type: 'contract' }),
-                inputs: parameters,
-                outputs: { type: 'any' },
+                parameters: { properties: parameters },
+                returns: { type: 'any' },
             });
         });
         return actions;

package/dist/parser/express-parser.js

@@ -113,10 +113,10 @@ class ExpressParser {
                 location: routePath,
                 method: httpMethod,
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, actionName),
                 requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, httpMethod, type: 'api' }),
-                inputs: this.extractRouteParams(routePath),
-                outputs: { type: 'any' },
+                parameters: { properties: this.extractRouteParams(routePath) },
+                returns: { type: 'any' },
             });
         });
         return actions;

package/dist/parser/intent-classifier.js

@@ -25,16 +25,16 @@ const INTENT_RULES = [
     { pattern: /\b(listNFT|sellNFT|listFor(?:Sale)?)/i, intent: 'nft.list' },
     { pattern: /\b(buyNFT|purchaseNFT)/i, intent: 'nft.buy' },
     { pattern: /\b(burnNFT|burn)/i, intent: 'nft.burn' },
+    // Governance (must come BEFORE Social so castVote → governance.vote, not social.cast)
+    { pattern: /\b(vote|castVote|submitVote)/i, intent: 'governance.vote' },
+    { pattern: /\b(propose|createProposal|submitProposal)/i, intent: 'governance.propose' },
+    { pattern: /\b(delegate|undelegate)/i, intent: 'governance.delegate' },
     // Social (Farcaster-native)
-    { pattern: /\b(cast|compose(?:Cast)?|post(?:Cast)?)/i, intent: 'social.cast' },
+    { pattern: /\b(cast(?!Vote)|compose(?:Cast)?|post(?:Cast)?)/i, intent: 'social.cast' },
     { pattern: /\b(follow|unfollow|subscribe)/i, intent: 'social.follow' },
     { pattern: /\b(like|react|upvote|downvote)/i, intent: 'social.react' },
     { pattern: /\b(comment|reply)/i, intent: 'social.reply' },
     { pattern: /\b(share|recast|repost)/i, intent: 'social.share' },
-    // Governance
-    { pattern: /\b(vote|castVote|submitVote)/i, intent: 'governance.vote' },
-    { pattern: /\b(propose|createProposal|submitProposal)/i, intent: 'governance.propose' },
-    { pattern: /\b(delegate|undelegate)/i, intent: 'governance.delegate' },
     // Auth
     { pattern: /\b(login|logout|signIn|signOut|connect|disconnect)/i, intent: 'auth.session' },
     { pattern: /\b(register|signup|createAccount)/i, intent: 'auth.register' },
@@ -73,7 +73,9 @@ const DESTRUCTIVE_VERBS = /\b(delete|remove|destroy|burn|archive|purge|wipe|clea
  *           updateSsn, exportPrivateKey, getMedicalRecord.
  */
 // No \b — these nouns appear anywhere in camelCase (resetPassword, submitKyc, getSsn)
-const CONFIDENTIAL_NOUNS = /(password|credential|privateKey|secretKey|biometric|ssn|taxId|pii|kyc|medicalRecord|healthRecord|passport|driverLicense|creditCard|cvv|encryptedData|identityVerif)/i;
+const CONFIDENTIAL_NOUNS = /(password|credential|privateKey|secretKey|biometric|ssn|taxId|tax_id|pii|kyc|medical|health|passport|license|creditCard|cvv|encrypted|identity|dob|birthDate|address|phone|mobile|email)/i;
+/** Verbs that imply high-privilege administrative or sensitive state changes. */
+const SENSITIVE_WRITE_VERBS = /\b(admin|role|permission|password|owner|ban|block|lock|unlock|grant|revoke|delegate|sudo|root|secret)/i;
 /**
  * Classify the safety level of an action.
  *
@@ -97,19 +99,40 @@ function classifySafety(opts) {
             return 'confidential';
         return 'write';
     }
+    // Financial and confidential always win regardless of type
     if (FINANCIAL_VERBS.test(name))
         return 'financial';
     if (CONFIDENTIAL_NOUNS.test(name))
         return 'confidential';
+    if (type === 'function' || type === 'ui') {
+        if (DESTRUCTIVE_VERBS.test(name))
+            return 'destructive';
+        // Auth functions are confidential (handle credentials)
+        if (/\b(login|logout|signIn|signOut|register|signup|createAccount)/i.test(name))
+            return 'confidential';
+        // Social/game → write
+        return 'write';
+    }
     if (httpMethod === 'GET')
         return 'read';
+    if (isReadOnly)
+        return 'read';
     if (DESTRUCTIVE_VERBS.test(name))
         return 'destructive';
     return 'write';
 }
-/** Derive agentSafe from safety level. Non-read/write levels require human confirmation. */
-function deriveAgentSafe(safety) {
-    return safety === 'read' || safety === 'write';
+/**
+ * Derive agentSafe from safety level.
+ * Only 'read' and non-sensitive 'write' actions are safe for autonomous execution.
+ */
+function deriveAgentSafe(safety, name) {
+    if (safety === 'read')
+        return true;
+    if (safety === 'write') {
+        // Narrowing: check if the write action name contains high-privilege keywords
+        return !SENSITIVE_WRITE_VERBS.test(name);
+    }
+    return false;
 }
 /**
  * Infer per-action auth requirement.
@@ -149,8 +172,10 @@ function inferActionAuth(opts) {
     if (safety === 'destructive') {
         return { required: 'required' };
     }
-    // Read-only GET on a public (no-auth) app → public
-    if (httpMethod === 'GET' && safety === 'read' && (appAuthType === 'none' || !appAuthType)) {
+    // No-auth app → read and write actions are public (non-contract only).
+    // Financial/confidential/destructive retain their required auth even on no-auth apps
+    // (those actions handle money or PII and should always require confirmation).
+    if (type !== 'contract' && (appAuthType === 'none' || !appAuthType) && (safety === 'read' || safety === 'write')) {
         return { required: 'public' };
     }
     return { required: 'required' };

package/dist/parser/openapi-parser.js

@@ -63,9 +63,9 @@ class OpenAPIParser {
                 const httpMethod = method.toUpperCase();
                 const safety = (0, intent_classifier_1.classifySafety)({ name: operationId, httpMethod, type: 'api' });
                 // Extract parameters (path + query + header)
-                const inputs = {};
+                const props = {};
                 for (const param of operation.parameters ?? []) {
-                    inputs[param.name] = {
+                    props[param.name] = {
                         type: param.schema?.type ?? 'string',
                         description: param.description,
                         required: param.required ?? false,
@@ -76,7 +76,7 @@ class OpenAPIParser {
                 if (bodySchema?.properties) {
                     const required = bodySchema.required ?? [];
                     for (const [field, schema] of Object.entries(bodySchema.properties)) {
-                        inputs[field] = {
+                        props[field] = {
                             type: schema.type ?? 'any',
                             description: schema.description,
                             required: required.includes(field),
@@ -94,12 +94,12 @@ class OpenAPIParser {
                     location: routePath,
                     method: httpMethod,
                     safety,
-                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, operationId),
                     requiredAuth: hasSecurity
                         ? { required: 'required' }
                         : (0, intent_classifier_1.inferActionAuth)({ safety, httpMethod, type: 'api' }),
-                    inputs,
-                    outputs: this.extractOutputSchema(operation),
+                    parameters: { properties: props },
+                    returns: this.extractOutputSchema(operation),
                 });
             }
         }

package/dist/parser/prisma-parser.js

@@ -35,159 +35,55 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRISMA_PATTERNS = exports.PrismaParser = void 0;
 const fs = __importStar(require("fs"));
-const intent_classifier_1 = require("./intent-classifier");
 /**
- * Reads a Prisma schema file and infers CRUD agent actions for every model.
+ * Reads a Prisma schema file and extracts the data model as a structured
+ * `dataModel` map. Each Prisma model becomes an entry with its writeable
+ * fields (auto-managed fields like @id, @default(now()), @updatedAt are excluded).
  *
- * For a model named `User` it emits:
- *   listUsers    → data.read    (GET-like)
- *   getUser      → data.read    (GET-like, by id)
- *   createUser   → data.create  (POST-like)
- *   updateUser   → data.update  (PATCH-like)
- *   deleteUser   → data.delete  (DELETE-like)
- *
- * Fields declared on the model are mapped to action inputs where relevant.
+ * Returns `{ actions: [], dataModel }` — no CRUD actions are generated.
+ * Prisma models are data schema, not API endpoints.
  */
 class PrismaParser {
     parseFile(filePath) {
         const content = fs.readFileSync(filePath, 'utf8');
-        const models = this.extractModels(content);
-        const actions = [];
-        for (const model of models) {
-            const name = model.name;
-            const lower = name.charAt(0).toLowerCase() + name.slice(1);
-            const location = filePath;
-            // Writeable fields (non-id, non-auto) used as create/update inputs
-            const writeableFields = model.fields.filter(f => !f.isId && !f.isAuto && !f.isList);
-            const idField = model.fields.find(f => f.isId) ?? { name: 'id', type: 'String' };
-            const idInput = {
-                [idField.name]: { type: this.prismaTypeToJson(idField.type), required: true },
-            };
-            const writeInputs = {};
-            for (const f of writeableFields) {
-                writeInputs[f.name] = {
-                    type: this.prismaTypeToJson(f.type),
-                    required: !f.isOptional,
+        const dataModel = {};
+        const modelRegex = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+        let match;
+        while ((match = modelRegex.exec(content)) !== null) {
+            const modelName = match[1];
+            const body = match[2];
+            const fields = {};
+            for (const line of body.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@'))
+                    continue;
+                const fieldMatch = /^(\w+)\s+(\w+)(\[\])?([\?])?(.*)?$/.exec(trimmed);
+                if (!fieldMatch)
+                    continue;
+                const [, fieldName, fieldType, isList, isOptional, attrs] = fieldMatch;
+                // Skip auto-managed fields (any @default(...) variant, not just @default(now()))
+                if (attrs?.includes('@id') || attrs?.includes('@default(') || attrs?.includes('@updatedAt'))
+                    continue;
+                fields[fieldName] = {
+                    type: this.mapFieldType(fieldType, !!isList),
+                    required: !isOptional,
                 };
             }
-            // list
-            actions.push({
-                name: `list${name}s`,
-                description: `List all ${name} records`,
-                intent: 'data.read',
-                type: 'function',
-                location,
-                safety: 'read',
-                agentSafe: true,
-                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'read', httpMethod: 'GET', type: 'function' }),
-                inputs: {},
-                outputs: { type: 'array', description: `Array of ${name}` },
-            });
-            // get
-            actions.push({
-                name: `get${name}`,
-                description: `Get a single ${name} by ${idField.name}`,
-                intent: 'data.read',
-                type: 'function',
-                location,
-                safety: 'read',
-                agentSafe: true,
-                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'read', httpMethod: 'GET', type: 'function' }),
-                inputs: idInput,
-                outputs: { type: 'object', description: name },
-            });
-            // create
-            actions.push({
-                name: `create${name}`,
-                description: `Create a new ${name} record`,
-                intent: 'data.create',
-                type: 'function',
-                location,
-                safety: 'write',
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)('write'),
-                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'write', type: 'function' }),
-                inputs: writeInputs,
-                outputs: { type: 'object', description: `Created ${name}` },
-            });
-            // update
-            actions.push({
-                name: `update${name}`,
-                description: `Update an existing ${name} record`,
-                intent: 'data.update',
-                type: 'function',
-                location,
-                safety: 'write',
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)('write'),
-                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'write', type: 'function' }),
-                inputs: { ...idInput, ...writeInputs },
-                outputs: { type: 'object', description: `Updated ${name}` },
-            });
-            // delete
-            actions.push({
-                name: `delete${name}`,
-                description: `Delete a ${name} record`,
-                intent: 'data.delete',
-                type: 'function',
-                location,
-                safety: 'destructive',
-                agentSafe: false,
-                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'destructive', type: 'function' }),
-                inputs: idInput,
-                outputs: { type: 'object', description: `Deleted ${name}` },
-            });
-            void lower; // suppress unused-variable warning
-        }
-        return actions;
-    }
-    // ─── Schema parsing helpers ───────────────────────────────────────────────
-    extractModels(content) {
-        const models = [];
-        // Match: model ModelName { ... }
-        const modelRe = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
-        let modelMatch;
-        while ((modelMatch = modelRe.exec(content)) !== null) {
-            const modelName = modelMatch[1];
-            const body = modelMatch[2];
-            const fields = this.parseFields(body);
-            models.push({ name: modelName, fields });
-        }
-        return models;
-    }
-    parseFields(body) {
-        const fields = [];
-        const lines = body.split('\n');
-        for (const raw of lines) {
-            const line = raw.trim();
-            if (!line || line.startsWith('//') || line.startsWith('@@'))
-                continue;
-            // field   Type   @attr @attr
-            const match = line.match(/^(\w+)\s+(\w+)(\[\])?(\?)?(.*)$/);
-            if (!match)
-                continue;
-            const [, name, type, isList, isOptional, attrs] = match;
-            fields.push({
-                name,
-                type,
-                isList: !!isList,
-                isOptional: !!isOptional,
-                isId: attrs.includes('@id'),
-                isAuto: attrs.includes('@default(autoincrement())') || attrs.includes('@default(uuid())') || attrs.includes('@default(cuid())') || attrs.includes('@updatedAt'),
-            });
+            dataModel[modelName] = {
+                description: `Prisma model: ${modelName}`,
+                fields,
+            };
         }
-        return fields;
+        return { actions: [], dataModel };
     }
-    prismaTypeToJson(prismaType) {
-        switch (prismaType) {
-            case 'String': return 'string';
-            case 'Int':
-            case 'Float':
-            case 'Decimal': return 'number';
-            case 'Boolean': return 'boolean';
-            case 'DateTime': return 'string';
-            case 'Json': return 'object';
-            case 'Bytes': return 'string';
-            default: return 'object'; // relations / enums
-        }
+    mapFieldType(prismaType, isList) {
+        if (isList)
+            return 'array';
+        const map = {
+            String: 'string', Int: 'number', Float: 'number', Decimal: 'number',
+            Boolean: 'boolean', DateTime: 'string', Json: 'object', Bytes: 'string',
+        };
+        return map[prismaType] ?? 'object';
     }
 }
 exports.PrismaParser = PrismaParser;

package/dist/parser/remix-parser.js

@@ -78,10 +78,10 @@ class RemixParser {
                 location: routePath,
                 method: httpMethod,
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, actionName),
                 requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, httpMethod, type: 'api' }),
-                inputs: this.extractRouteParams(routePath),
-                outputs: { type: 'object' },
+                parameters: { properties: this.extractRouteParams(routePath) },
+                returns: { type: 'object' },
             });
         }
         return actions;

package/dist/parser/socketio-parser.js

@@ -108,10 +108,10 @@ class SocketIOParser {
                 location: relativePath,
                 socketEvent: eventName,
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, camelName),
                 requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, type: 'socket' }),
-                inputs,
-                outputs: { type: 'object' },
+                parameters: { properties: inputs },
+                returns: { type: 'object' },
             });
         });
         return actions;

package/dist/parser/sse-parser.js

@@ -92,10 +92,10 @@ class SSEParser {
                 location: relativePath,
                 method: 'GET',
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, name),
                 requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, httpMethod: 'GET', type: 'api' }),
-                inputs: {},
-                outputs: { type: 'stream', description: 'Server-Sent Events stream' },
+                parameters: { properties: {} },
+                returns: { type: 'stream', description: 'Server-Sent Events stream' },
             });
         }
         return actions;

package/dist/parser/trpc-parser.js

@@ -101,15 +101,15 @@ class TRPCParser {
                 location: relativePath,
                 method: methodName,
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, procedureName),
                 requiredAuth: (0, intent_classifier_1.inferActionAuth)({
                     safety,
                     httpMethod: httpLike,
                     appAuthType: isProtected ? 'bearer' : undefined,
                     type: 'function',
                 }),
-                inputs,
-                outputs: { type: 'object' },
+                parameters: { properties: inputs },
+                returns: { type: 'object' },
             });
         });
         return actions;

package/dist/parser/ts-parser.js

@@ -151,10 +151,10 @@ class TSParser {
                     location,
                     method: methodName,
                     safety,
-                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, actionName),
                     requiredAuth: this.actionAuth(safety, methodName),
-                    inputs: zodInputs,
-                    outputs: { type: 'any' },
+                    parameters: { properties: zodInputs },
+                    returns: { type: 'any' },
                 });
             }
             // export const POST = async (request: Request) => { ... }
@@ -177,10 +177,10 @@ class TSParser {
                     location,
                     method: methodName,
                     safety,
-                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, actionName),
                     requiredAuth: this.actionAuth(safety, methodName),
-                    inputs: zodInputs,
-                    outputs: { type: 'any' },
+                    parameters: { properties: zodInputs },
+                    returns: { type: 'any' },
                 });
             }
         }
@@ -201,10 +201,10 @@ class TSParser {
                 location,
                 method,
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, actionName),
                 requiredAuth: this.actionAuth(safety, method),
-                inputs: zodShape ?? {},
-                outputs: { type: 'any' },
+                parameters: { properties: zodShape ?? {} },
+                returns: { type: 'any' },
             });
         }
         // 3d. Generic non-Next.js API routes: api/**
@@ -224,10 +224,10 @@ class TSParser {
                 location,
                 method,
                 safety,
-                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, actionName),
                 requiredAuth: this.actionAuth(safety, method),
-                inputs: zodShape ?? {},
-                outputs: { type: 'any' },
+                parameters: { properties: zodShape ?? {} },
+                returns: { type: 'any' },
             });
         }
         // 3e. Server Actions: files with 'use server' directive
@@ -261,10 +261,10 @@ class TSParser {
                     type: 'function',
                     location: `./${relativePath}`,
                     safety,
-                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                    agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, name),
                     requiredAuth: this.actionAuth(safety, undefined, undefined, 'function'),
-                    inputs: this.extractFunctionParams(init),
-                    outputs: { type: 'any' },
+                    parameters: { properties: this.extractFunctionParams(init) },
+                    returns: { type: 'any' },
                 });
             }
         }
@@ -357,14 +357,14 @@ class TSParser {
             ?.getComment()
             ?.toString()
             .match(/safety=(read|write|financial|destructive)/)?.[1];
-        const inputs = {};
+        const properties = {};
         if ('getParameters' in declaration) {
             for (const param of declaration.getParameters()) {
                 const paramName = param.getName();
                 const paramDoc = jsDoc
                     ?.getTags()
                     .find(t => t.getTagName() === 'param' && t.getName() === paramName);
-                inputs[paramName] = {
+                properties[paramName] = {
                     type: this.mapType(param.getType()),
                     description: paramDoc?.getComment()?.toString().trim() || '',
                     required: !param.isOptional(),
@@ -380,10 +380,10 @@ class TSParser {
             type: 'function',
             location: `./${relativePath}`,
             safety,
-            agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+            agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, name),
             requiredAuth: this.actionAuth(safety, undefined, undefined, 'function'),
-            inputs,
-            outputs: {
+            parameters: { properties },
+            returns: {
                 type: returnType ? this.mapType(returnType) : 'any',
                 description: jsDoc?.getTags().find(t => t.getTagName() === 'returns')?.getComment()?.toString().trim() || '',
             },

package/dist/parser/websocket-parser.js

@@ -104,10 +104,10 @@ class WebSocketParser {
                         location: relativePath,
                         socketEvent: msgType,
                         safety,
-                        agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                        agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety, msgType),
                         requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, type: 'socket' }),
-                        inputs: { type: { type: 'string', required: true }, payload: { type: 'object', required: false } },
-                        outputs: { type: 'object' },
+                        parameters: { properties: { type: { type: 'string', required: true }, payload: { type: 'object', required: false } } },
+                        returns: { type: 'object' },
                     });
                 }
             }
@@ -124,10 +124,10 @@ class WebSocketParser {
                         location: relativePath,
                         socketEvent: 'message',
                         safety: 'write',
-                        agentSafe: true,
+                        agentSafe: (0, intent_classifier_1.deriveAgentSafe)('write', name),
                         requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety: 'write', type: 'socket' }),
-                        inputs: { data: { type: 'string', required: true } },
-                        outputs: { type: 'object' },
+                        parameters: { properties: { data: { type: 'string', required: true } } },
+                        returns: { type: 'object' },
                     });
                 }
             }

package/dist/parser/zod-extractor.js

@@ -319,8 +319,15 @@ class ZodExtractor {
         const envMatch = text.match(/process\.env\.([A-Z0-9_]+)/);
         if (envMatch)
             return { $env: envMatch[1] };
-        if (ts_morph_1.Node.isStringLiteral(node))
-            return node.getLiteralValue();
+        if (ts_morph_1.Node.isStringLiteral(node)) {
+            const val = node.getLiteralValue();
+            // SECURITY: Redact high-entropy strings or common secret prefixes
+            if (/^(sk_|pk_|api_key|token|secret|key-|passwd|auth_|ghp_)/i.test(val) ||
+                (val.length > 20 && /[a-z]/i.test(val) && /[0-9]/.test(val) && /[A-Z]/.test(val))) {
+                return '[REDACTED_SECRET]';
+            }
+            return val;
+        }
         if (ts_morph_1.Node.isNumericLiteral(node))
             return Number(node.getLiteralValue());
         if (text === 'true')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-manifest",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "description": "Universal agent manifest compiler — generates agent.json for any web app so AI agents can discover and interact with it",
   "main": "dist/index.js",
   "bin": {

package/schema/agent.schema.json

@@ -37,7 +37,7 @@
       "properties": {
         "type": {
           "type": "string",
-          "enum": ["none", "bearer", "api-key", "oauth2", "basic", "farcaster-frame", "cookie"],
+          "enum": ["none", "bearer", "api-key", "oauth2", "basic", "cookie", "siwe", "farcaster-siwf", "farcaster-frame", "clerk", "privy", "dynamic", "magic", "passkey", "saml", "supabase"],
           "description": "Authentication scheme"
         },
         "header":     { "type": "string", "description": "Header name, e.g. Authorization or X-API-Key" },
@@ -65,6 +65,14 @@
     "actions": {
       "type": "array",
       "items": { "$ref": "#/definitions/AgentAction" }
+    },
+    "baseUrl": {
+      "type": "string",
+      "format": "uri"
+    },
+    "dataModel": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#/definitions/DataModelEntry" }
     }
   },
   "definitions": {
@@ -88,7 +96,7 @@
     },
     "AgentAction": {
       "type": "object",
-      "required": ["name", "description", "intent", "type", "location", "safety", "agentSafe", "inputs", "outputs"],
+      "required": ["name", "description", "intent", "type", "location", "safety", "agentSafe", "parameters", "returns"],
       "additionalProperties": false,
       "properties": {
         "name":        { "type": "string", "description": "Unique action identifier" },
@@ -100,7 +108,7 @@
         },
         "type": {
           "type": "string",
-          "enum": ["api", "contract", "function", "socket"]
+          "enum": ["api", "contract", "function", "socket", "ui"]
         },
         "location": { "type": "string" },
         "method": {
@@ -149,11 +157,14 @@
             }
           }
         },
-        "inputs": {
+        "parameters": {
           "type": "object",
-          "additionalProperties": { "$ref": "#/definitions/ParameterProperty" }
+          "properties": {
+            "properties": { "type": "object" }
+          },
+          "required": ["properties"]
         },
-        "outputs": {
+        "returns": {
           "type": "object",
           "required": ["type"],
           "additionalProperties": false,
@@ -163,6 +174,25 @@
           }
         }
       }
+    },
+    "DataModelEntry": {
+      "type": "object",
+      "properties": {
+        "description": { "type": "string" },
+        "fields": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "type": { "type": "string" },
+              "required": { "type": "boolean" },
+              "description": { "type": "string" }
+            },
+            "required": ["type"]
+          }
+        }
+      },
+      "required": ["fields"]
     }
   }
 }