@agentuity/cli 0.0.69 → 0.0.70

package/dist/cmd/build/ast.js

@@ -81,6 +81,13 @@ function generateStableAgentId(projectId, name) {
 function generateStableEvalId(projectId, agentId, name) {
     return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
 }
+/**
+ * Type guard to check if an AST node is an ObjectExpression
+ */
+function isObjectExpression(node) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return typeof node === 'object' && node !== null && node.type === 'ObjectExpression';
+}
 /**
  * Extract schema code from createAgent call arguments
  * Returns input and output schema code as strings
@@ -117,7 +124,7 @@ function extractSchemaCode(callargexp) {
     return { inputSchemaCode, outputSchemaCode };
 }
 const MetadataError = StructuredError('MetatadataNameMissingError')();
-function augmentAgentMetadataNode(projectId, id, identifier, rel, version, ast, propvalue, filename, inputSchemaCode, outputSchemaCode) {
+function augmentAgentMetadataNode(projectId, id, rel, version, ast, propvalue, filename, inputSchemaCode, outputSchemaCode) {
     const metadata = parseObjectExpressionToMap(propvalue);
     if (!metadata.has('name')) {
         const location = ast.loc?.start?.line ? ` on line ${ast.loc.start.line}` : '';
@@ -128,19 +135,10 @@ function augmentAgentMetadataNode(projectId, id, identifier, rel, version, ast,
         });
     }
     const name = metadata.get('name');
-    if (metadata.has('identifier') && identifier !== metadata.get('identifier')) {
-        const location = ast.loc?.start?.line ? ` on line ${ast.loc.start.line}` : '';
-        throw new MetadataError({
-            filename,
-            line: ast.loc?.start?.line,
-            message: `metadata.identifier (${metadata.get('identifier')}) in ${filename}${location} is mismatched (${name}). This is an internal error.`,
-        });
-    }
     const descriptionNode = propvalue.properties.find((x) => x.key.name === 'description')?.value;
     const description = descriptionNode ? descriptionNode.value : '';
     const agentId = generateStableAgentId(projectId, name);
     metadata.set('version', version);
-    metadata.set('identifier', identifier);
     metadata.set('filename', rel);
     metadata.set('id', id);
     metadata.set('agentId', agentId);
@@ -151,7 +149,7 @@ function augmentAgentMetadataNode(projectId, id, identifier, rel, version, ast,
     if (outputSchemaCode) {
         metadata.set('outputSchemaCode', outputSchemaCode);
     }
-    propvalue.properties.push(createObjectPropertyNode('id', id), createObjectPropertyNode('agentId', agentId), createObjectPropertyNode('version', version), createObjectPropertyNode('identifier', name), createObjectPropertyNode('filename', rel), createObjectPropertyNode('description', description));
+    propvalue.properties.push(createObjectPropertyNode('id', id), createObjectPropertyNode('agentId', agentId), createObjectPropertyNode('version', version), createObjectPropertyNode('filename', rel), createObjectPropertyNode('description', description));
     if (inputSchemaCode) {
         propvalue.properties.push(createObjectPropertyNode('inputSchemaCode', inputSchemaCode));
     }
@@ -162,14 +160,21 @@ function augmentAgentMetadataNode(projectId, id, identifier, rel, version, ast,
     // Evals imports are now handled in registry.generated.ts
     return [newsource, metadata];
 }
-function createAgentMetadataNode(id, name, rel, version, ast, callargexp, _filename) {
+function createAgentMetadataNode(id, name, rel, version, ast, callargexp, _filename, projectId, inputSchemaCode, outputSchemaCode) {
     const newmetadata = createNewMetadataNode();
+    const agentId = generateStableAgentId(projectId, name);
     const md = new Map();
     md.set('id', id);
+    md.set('agentId', agentId);
     md.set('version', version);
     md.set('name', name);
-    md.set('identifier', name);
     md.set('filename', rel);
+    if (inputSchemaCode) {
+        md.set('inputSchemaCode', inputSchemaCode);
+    }
+    if (outputSchemaCode) {
+        md.set('outputSchemaCode', outputSchemaCode);
+    }
     for (const [key, value] of md) {
         newmetadata.value.properties.push(createObjectPropertyNode(key, value));
     }
@@ -178,118 +183,6 @@ function createAgentMetadataNode(id, name, rel, version, ast, callargexp, _filen
     // Evals imports are now handled in registry.generated.ts
     return [newsource, md];
 }
-function camelToKebab(str) {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
-        .toLowerCase();
-}
-function setLiteralValue(literal, value) {
-    literal.value = value;
-    if (literal.raw !== undefined) {
-        literal.raw = JSON.stringify(value);
-    }
-}
-function augmentEvalMetadataNode(projectId, agentId, id, name, rel, version, _ast, metadataObj, _filename) {
-    const metadata = parseObjectExpressionToMap(metadataObj);
-    // Name can come from metadata.name or variable name (already resolved in caller)
-    // If metadata doesn't have name, we'll add it from the resolved name
-    if (!metadata.has('name')) {
-        metadataObj.properties.push(createObjectPropertyNode('name', name));
-    }
-    const descriptionNode = metadataObj.properties.find((x) => x.key.name === 'description')?.value;
-    const description = descriptionNode ? descriptionNode.value : '';
-    const effectiveAgentId = agentId || '';
-    const _evalId = getEvalId(projectId, effectiveAgentId, rel, name, version); // Deployment-specific ID (not used, kept for potential future use)
-    const stableEvalId = generateStableEvalId(projectId, effectiveAgentId, name);
-    // Check if id, version, identifier, filename, evalId already exist
-    const existingKeys = new Set();
-    for (const prop of metadataObj.properties) {
-        if (prop.key.type === 'Identifier') {
-            existingKeys.add(prop.key.name);
-        }
-    }
-    // Add or update metadata properties
-    if (!existingKeys.has('id')) {
-        metadataObj.properties.push(createObjectPropertyNode('id', id));
-    }
-    else {
-        // Update existing id
-        for (const prop of metadataObj.properties) {
-            if (prop.key.type === 'Identifier' && prop.key.name === 'id') {
-                if (prop.value.type === 'Literal') {
-                    setLiteralValue(prop.value, id);
-                }
-                break;
-            }
-        }
-    }
-    if (!existingKeys.has('version')) {
-        metadataObj.properties.push(createObjectPropertyNode('version', version));
-    }
-    else {
-        for (const prop of metadataObj.properties) {
-            if (prop.key.type === 'Identifier' && prop.key.name === 'version') {
-                if (prop.value.type === 'Literal') {
-                    setLiteralValue(prop.value, version);
-                }
-                break;
-            }
-        }
-    }
-    if (!existingKeys.has('identifier')) {
-        metadataObj.properties.push(createObjectPropertyNode('identifier', name));
-    }
-    else {
-        for (const prop of metadataObj.properties) {
-            if (prop.key.type === 'Identifier' && prop.key.name === 'identifier') {
-                if (prop.value.type === 'Literal') {
-                    setLiteralValue(prop.value, name);
-                }
-                break;
-            }
-        }
-    }
-    if (!existingKeys.has('filename')) {
-        metadataObj.properties.push(createObjectPropertyNode('filename', rel));
-    }
-    else {
-        for (const prop of metadataObj.properties) {
-            if (prop.key.type === 'Identifier' && prop.key.name === 'filename') {
-                if (prop.value.type === 'Literal') {
-                    setLiteralValue(prop.value, rel);
-                }
-                break;
-            }
-        }
-    }
-    if (!existingKeys.has('evalId')) {
-        metadataObj.properties.push(createObjectPropertyNode('evalId', stableEvalId));
-    }
-    else {
-        for (const prop of metadataObj.properties) {
-            if (prop.key.type === 'Identifier' && prop.key.name === 'evalId') {
-                if (prop.value.type === 'Literal') {
-                    setLiteralValue(prop.value, stableEvalId);
-                }
-                break;
-            }
-        }
-    }
-    if (!existingKeys.has('description')) {
-        metadataObj.properties.push(createObjectPropertyNode('description', description));
-    }
-    else {
-        for (const prop of metadataObj.properties) {
-            if (prop.key.type === 'Identifier' && prop.key.name === 'description') {
-                if (prop.value.type === 'Literal') {
-                    setLiteralValue(prop.value, description);
-                }
-                break;
-            }
-        }
-    }
-}
 const DuplicateNameError = StructuredError('DuplicateNameError')();
 export function parseEvalMetadata(rootDir, filename, contents, projectId, deploymentId, agentId) {
     const logLevel = (process.env.AGENTUITY_LOG_LEVEL || 'info');
@@ -326,81 +219,54 @@ export function parseEvalMetadata(rootDir, filename, contents, projectId, deploy
                             property.type === 'Identifier' &&
                             property.name === 'createEval') {
                             // Found agent.createEval() call
-                            if (call.arguments.length > 0) {
+                            // New signature: agent.createEval(name, { description?, handler })
+                            if (call.arguments.length >= 2) {
                                 const firstArg = call.arguments[0];
-                                if (firstArg.type === 'ObjectExpression') {
-                                    const evalConfig = firstArg;
-                                    let evalName;
-                                    let evalDescription;
-                                    let variableName;
-                                    let metadataObj;
-                                    // Capture variable name if available
-                                    if (vardecl.id.type === 'Identifier') {
-                                        variableName = vardecl.id.name;
-                                    }
-                                    // Extract metadata from the eval config
-                                    for (const prop of evalConfig.properties) {
-                                        if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
-                                            if (prop.value.type === 'ObjectExpression') {
-                                                metadataObj = prop.value;
-                                                for (const metaProp of metadataObj.properties) {
-                                                    if (metaProp.key.type === 'Identifier') {
-                                                        if (metaProp.key.name === 'name' &&
-                                                            metaProp.value.type === 'Literal') {
-                                                            evalName = metaProp.value.value;
-                                                        }
-                                                        else if (metaProp.key.name === 'description' &&
-                                                            metaProp.value.type === 'Literal') {
-                                                            evalDescription = metaProp.value.value;
-                                                        }
-                                                    }
-                                                }
+                                const secondArg = call.arguments[1];
+                                let evalName;
+                                let evalDescription;
+                                let configObj;
+                                // First argument should be a string literal (the name)
+                                if (firstArg.type === 'Literal' &&
+                                    typeof firstArg.value === 'string') {
+                                    evalName = firstArg.value;
+                                }
+                                else {
+                                    throw new MetadataError({
+                                        filename,
+                                        line: body.loc?.start?.line,
+                                        message: 'agent.createEval() first argument must be a string literal name.',
+                                    });
+                                }
+                                // Second argument should be the config object
+                                if (secondArg.type === 'ObjectExpression') {
+                                    configObj = secondArg;
+                                    // Extract description from config object
+                                    for (const prop of configObj.properties) {
+                                        if (prop.key.type === 'Identifier' &&
+                                            prop.key.name === 'description') {
+                                            if (prop.value.type === 'Literal') {
+                                                evalDescription = prop.value.value;
                                             }
                                         }
                                     }
-                                    // Use metadata.name if provided, otherwise use variable name
-                                    // Throw error if neither is available (should never happen)
-                                    let finalName;
-                                    if (evalName) {
-                                        finalName = evalName;
-                                    }
-                                    else if (variableName) {
-                                        finalName = camelToKebab(variableName);
-                                    }
-                                    else {
-                                        throw new MetadataError({
-                                            filename,
-                                            line: body.loc?.start?.line,
-                                            message: 'Eval is missing a name. Please provide metadata.name or use a named export.',
-                                        });
-                                    }
-                                    logger.trace(`Found eval: ${finalName}${evalDescription ? ` - ${evalDescription}` : ''}`);
-                                    const evalId = getEvalId(projectId, deploymentId, rel, finalName, version);
-                                    // Inject metadata into AST if metadata object exists
-                                    let stableEvalId;
-                                    const effectiveAgentId = agentId || '';
-                                    if (metadataObj) {
-                                        augmentEvalMetadataNode(projectId, effectiveAgentId, evalId, finalName, rel, version, ast, metadataObj, filename);
-                                        // Extract evalId from metadata after augmentation
-                                        const metadata = parseObjectExpressionToMap(metadataObj);
-                                        stableEvalId =
-                                            metadata.get('evalId') ||
-                                                generateStableEvalId(projectId, effectiveAgentId, finalName);
-                                    }
-                                    else {
-                                        // If no metadata object, generate stable evalId
-                                        stableEvalId = generateStableEvalId(projectId, effectiveAgentId, finalName);
-                                    }
-                                    evals.push({
-                                        filename: rel,
-                                        id: evalId,
-                                        version,
-                                        identifier: finalName,
-                                        name: finalName,
-                                        evalId: stableEvalId,
-                                        description: evalDescription,
-                                    });
                                 }
+                                const finalName = evalName;
+                                logger.trace(`Found eval: ${finalName}${evalDescription ? ` - ${evalDescription}` : ''}`);
+                                const evalId = getEvalId(projectId, deploymentId, rel, finalName, version);
+                                // Generate stable evalId
+                                const effectiveAgentId = agentId || '';
+                                const stableEvalId = generateStableEvalId(projectId, effectiveAgentId, finalName);
+                                // Note: We no longer inject metadata into the AST since there's no metadata object
+                                // The runtime will generate IDs from the name parameter
+                                evals.push({
+                                    filename: rel,
+                                    id: evalId,
+                                    version,
+                                    name: finalName,
+                                    evalId: stableEvalId,
+                                    description: evalDescription,
+                                });
                             }
                         }
                     }
@@ -433,8 +299,11 @@ export function parseEvalMetadata(rootDir, filename, contents, projectId, deploy
     return [newsource, evals];
 }
 const InvalidExportError = StructuredError('InvalidExportError')();
-const InvalidCreateAgentError = StructuredError('InvalidCreateAgentError')();
 export async function parseAgentMetadata(rootDir, filename, contents, projectId, deploymentId) {
+    // Quick string search optimization - skip AST parsing if no createAgent call
+    if (!contents.includes('createAgent')) {
+        return undefined;
+    }
     const ast = acornLoose.parse(contents, {
         locations: true,
         ecmaVersion: 'latest',
@@ -452,42 +321,54 @@ export async function parseAgentMetadata(rootDir, filename, contents, projectId,
             if (body.declaration?.type === 'CallExpression') {
                 const call = body.declaration;
                 if (call.callee.name === 'createAgent') {
-                    for (const callarg of call.arguments) {
-                        const callargexp = callarg;
-                        // Extract schema code before processing metadata
-                        let inputSchemaCode;
-                        let outputSchemaCode;
-                        if (!schemaCodeExtracted) {
-                            const schemaCode = extractSchemaCode(callargexp);
-                            inputSchemaCode = schemaCode.inputSchemaCode;
-                            outputSchemaCode = schemaCode.outputSchemaCode;
-                            schemaCodeExtracted = true;
-                        }
-                        for (const prop of callargexp.properties) {
-                            if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
-                                result = augmentAgentMetadataNode(projectId, id, name, rel, version, ast, prop.value, filename, inputSchemaCode, outputSchemaCode);
-                                break;
-                            }
-                        }
-                        if (!result) {
-                            result = createAgentMetadataNode(id, name, rel, version, ast, callargexp, filename);
+                    // Enforce new API: createAgent('name', {config})
+                    if (call.arguments.length < 2) {
+                        throw new Error(`createAgent requires 2 arguments: createAgent('name', config) in ${filename}`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const nameArg = call.arguments[0];
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const configArg = call.arguments[1];
+                    if (!nameArg || nameArg.type !== 'Literal' || typeof nameArg.value !== 'string') {
+                        throw new Error(`createAgent first argument must be a string literal in ${filename}`);
+                    }
+                    if (!isObjectExpression(configArg)) {
+                        throw new Error(`createAgent second argument must be a config object in ${filename}`);
+                    }
+                    const callargexp = configArg;
+                    // Extract schema code before processing metadata
+                    let inputSchemaCode;
+                    let outputSchemaCode;
+                    if (!schemaCodeExtracted) {
+                        const schemaCode = extractSchemaCode(callargexp);
+                        inputSchemaCode = schemaCode.inputSchemaCode;
+                        outputSchemaCode = schemaCode.outputSchemaCode;
+                        schemaCodeExtracted = true;
+                    }
+                    for (const prop of callargexp.properties) {
+                        if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
+                            result = augmentAgentMetadataNode(projectId, id, rel, version, ast, prop.value, filename, inputSchemaCode, outputSchemaCode);
+                            break;
                         }
-                        break;
                     }
+                    if (!result) {
+                        result = createAgentMetadataNode(id, name, rel, version, ast, callargexp, filename, projectId, inputSchemaCode, outputSchemaCode);
+                    }
+                    break;
                 }
             }
-            if (!result) {
-                const identifier = body.declaration;
-                exportName = identifier.name;
-                break;
-            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!result && body.declaration?.type === 'Identifier') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const identifier = body.declaration;
+            exportName = identifier.name;
+            break;
         }
     }
+    // If no default export or createAgent found, skip this file (it's not an agent)
     if (!result && !exportName) {
-        throw new InvalidExportError({
-            filename,
-            message: `could not find default export for ${filename} using ${rootDir}`,
-        });
+        return undefined;
     }
     if (!result) {
         for (const body of ast.body) {
@@ -499,29 +380,42 @@ export async function parseAgentMetadata(rootDir, filename, contents, projectId,
                             if (vardecl.init?.type === 'CallExpression') {
                                 const call = vardecl.init;
                                 if (call.callee.name === 'createAgent') {
-                                    for (const callarg of call.arguments) {
-                                        const callargexp = callarg;
-                                        // Extract schema code before processing metadata
-                                        let inputSchemaCode;
-                                        let outputSchemaCode;
-                                        if (!schemaCodeExtracted) {
-                                            const schemaCode = extractSchemaCode(callargexp);
-                                            inputSchemaCode = schemaCode.inputSchemaCode;
-                                            outputSchemaCode = schemaCode.outputSchemaCode;
-                                            schemaCodeExtracted = true;
-                                        }
-                                        for (const prop of callargexp.properties) {
-                                            if (prop.key.type === 'Identifier' &&
-                                                prop.key.name === 'metadata') {
-                                                result = augmentAgentMetadataNode(projectId, id, name, rel, version, ast, prop.value, filename, inputSchemaCode, outputSchemaCode);
-                                                break;
-                                            }
-                                        }
-                                        if (!result) {
-                                            result = createAgentMetadataNode(id, name, rel, version, ast, callargexp, filename);
+                                    // Enforce new API: createAgent('name', {config})
+                                    if (call.arguments.length < 2) {
+                                        throw new Error(`createAgent requires 2 arguments: createAgent('name', config) in ${filename}`);
+                                    }
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    const nameArg = call.arguments[0];
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    const configArg = call.arguments[1];
+                                    if (!nameArg ||
+                                        nameArg.type !== 'Literal' ||
+                                        typeof nameArg.value !== 'string') {
+                                        throw new Error(`createAgent first argument must be a string literal in ${filename}`);
+                                    }
+                                    if (!isObjectExpression(configArg)) {
+                                        throw new Error(`createAgent second argument must be a config object in ${filename}`);
+                                    }
+                                    const callargexp = configArg;
+                                    // Extract schema code before processing metadata
+                                    let inputSchemaCode;
+                                    let outputSchemaCode;
+                                    if (!schemaCodeExtracted) {
+                                        const schemaCode = extractSchemaCode(callargexp);
+                                        inputSchemaCode = schemaCode.inputSchemaCode;
+                                        outputSchemaCode = schemaCode.outputSchemaCode;
+                                        schemaCodeExtracted = true;
+                                    }
+                                    for (const prop of callargexp.properties) {
+                                        if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
+                                            result = augmentAgentMetadataNode(projectId, id, rel, version, ast, prop.value, filename, inputSchemaCode, outputSchemaCode);
+                                            break;
                                         }
-                                        break;
                                     }
+                                    if (!result) {
+                                        result = createAgentMetadataNode(id, name, rel, version, ast, callargexp, filename, projectId, inputSchemaCode, outputSchemaCode);
+                                    }
+                                    break;
                                 }
                             }
                         }
@@ -530,11 +424,9 @@ export async function parseAgentMetadata(rootDir, filename, contents, projectId,
             }
         }
     }
+    // If no createAgent found after checking all declarations, skip this file
     if (!result) {
-        throw new InvalidCreateAgentError({
-            filename,
-            message: `error parsing: ${filename}. could not find an proper createAgent defined in this file`,
-        });
+        return undefined;
     }
     // Parse evals from eval.ts file in the same directory
     const logLevel = (process.env.AGENTUITY_LOG_LEVEL || 'info');
@@ -565,6 +457,69 @@ export async function parseAgentMetadata(rootDir, filename, contents, projectId,
 }
 const InvalidCreateRouterError = StructuredError('InvalidCreateRouterError')();
 const InvalidRouterConfigError = StructuredError('InvalidRouterConfigError')();
+function hasValidatorCall(args) {
+    if (!args || args.length === 0)
+        return { hasValidator: false };
+    for (const arg of args) {
+        if (!arg || typeof arg !== 'object')
+            continue;
+        const node = arg;
+        // Check if this is a CallExpression with callee named 'validator'
+        if (node.type === 'CallExpression') {
+            const callExpr = node;
+            if (callExpr.callee.type === 'Identifier') {
+                const identifier = callExpr.callee;
+                if (identifier.name === 'validator') {
+                    // Try to extract schema variables from validator({ input, output })
+                    const schemas = extractValidatorSchemas(callExpr);
+                    return { hasValidator: true, ...schemas };
+                }
+            }
+            // Check for agent.validator()
+            if (callExpr.callee.type === 'MemberExpression') {
+                const member = callExpr.callee;
+                if (member.property && member.property.name === 'validator') {
+                    // Extract agent variable name (the object before .validator())
+                    const agentVariable = member.object.type === 'Identifier'
+                        ? member.object.name
+                        : undefined;
+                    return { hasValidator: true, agentVariable };
+                }
+            }
+        }
+    }
+    return { hasValidator: false };
+}
+/**
+ * Extract schema variable names from validator() call arguments
+ * Example: validator({ input: myInputSchema, output: myOutputSchema })
+ */
+function extractValidatorSchemas(callExpr) {
+    const result = {};
+    // Check if validator has arguments
+    if (!callExpr.arguments || callExpr.arguments.length === 0) {
+        return result;
+    }
+    // First argument should be an object expression
+    const firstArg = callExpr.arguments[0];
+    if (!firstArg || firstArg.type !== 'ObjectExpression') {
+        return result;
+    }
+    const objExpr = firstArg;
+    for (const prop of objExpr.properties) {
+        const keyName = prop.key.name;
+        if ((keyName === 'input' || keyName === 'output') && prop.value.type === 'Identifier') {
+            const valueName = prop.value.name;
+            if (keyName === 'input') {
+                result.inputSchemaVariable = valueName;
+            }
+            else {
+                result.outputSchemaVariable = valueName;
+            }
+        }
+    }
+    return result;
+}
 export async function parseRoute(rootDir, filename, projectId, deploymentId) {
     const contents = await Bun.file(filename).text();
     const version = hash(contents);
@@ -575,6 +530,26 @@ export async function parseRoute(rootDir, filename, projectId, deploymentId) {
     });
     let exportName;
     let variableName;
+    // Extract import statements to map variable names to their import sources
+    const importMap = new Map(); // Maps variable name to import path
+    for (const body of ast.body) {
+        if (body.type === 'ImportDeclaration') {
+            const importDecl = body;
+            const importPath = importDecl.source?.value;
+            if (importPath && importDecl.specifiers) {
+                for (const spec of importDecl.specifiers) {
+                    if (spec.type === 'ImportDefaultSpecifier' && spec.local?.name) {
+                        // import hello from '@agent/hello'
+                        importMap.set(spec.local.name, importPath);
+                    }
+                    else if (spec.type === 'ImportSpecifier' && spec.local?.name) {
+                        // import { hello } from './shared'
+                        importMap.set(spec.local.name, importPath);
+                    }
+                }
+            }
+        }
+    }
     for (const body of ast.body) {
         if (body.type === 'ExportDefaultDeclaration') {
             const identifier = body.declaration;
@@ -596,11 +571,20 @@ export async function parseRoute(rootDir, filename, projectId, deploymentId) {
                     if (identifier.name === exportName) {
                         if (vardecl.init?.type === 'CallExpression') {
                             const call = vardecl.init;
+                            // Support both createRouter() and new Hono()
                             if (call.callee.name === 'createRouter') {
                                 variableName = identifier.name;
                                 break;
                             }
                         }
+                        else if (vardecl.init?.type === 'NewExpression') {
+                            const newExpr = vardecl.init;
+                            // Support new Hono() pattern
+                            if (newExpr.callee.name === 'Hono') {
+                                variableName = identifier.name;
+                                break;
+                            }
+                        }
                     }
                 }
             }
@@ -609,21 +593,17 @@ export async function parseRoute(rootDir, filename, projectId, deploymentId) {
     if (!variableName) {
         throw new InvalidCreateRouterError({
             filename,
-            message: `error parsing: ${filename}. could not find an proper createRouter defined in this file`,
+            message: `error parsing: ${filename}. could not find an proper createRouter or new Hono() defined in this file`,
         });
     }
     const rel = relative(rootDir, filename);
     const dir = dirname(filename);
     const name = basename(dir);
-    // Detect if this is a subagent route and build proper path
-    const relativePath = relative(rootDir, dir)
-        .replace(/^src\/agent\//, '')
-        .replace(/^src\/web\//, '');
-    const pathParts = relativePath.split('/').filter(Boolean);
-    const isSubagent = pathParts.length === 2 && filename.includes('src/agent');
-    const routeName = isSubagent ? pathParts.join('/') : name;
+    // For src/api/index.ts, we don't want to add the folder name since it's the root API router
+    const isRootApi = filename.includes('src/api/index.ts');
+    const routeName = isRootApi ? '' : name;
     const routes = [];
-    const routePrefix = filename.includes('src/agent') ? '/agent' : '/api';
+    const routePrefix = '/api';
     try {
         for (const body of ast.body) {
             if (body.type === 'ExpressionStatement') {
@@ -744,6 +724,27 @@ export async function parseRoute(rootDir, filename, projectId, deploymentId) {
                             .replaceAll(/\/{2,}/g, '/')
                             .replaceAll(/\/$/g, '');
                         const id = generateRouteId(projectId, deploymentId, type, method, rel, thepath, version);
+                        // Check if this route uses validator middleware
+                        const validatorInfo = hasValidatorCall(statement.expression.arguments);
+                        // Store validator info in config if present
+                        const routeConfig = config ? { ...config } : {};
+                        if (validatorInfo.hasValidator) {
+                            routeConfig.hasValidator = true;
+                            if (validatorInfo.agentVariable) {
+                                routeConfig.agentVariable = validatorInfo.agentVariable;
+                                // Look up where this agent variable is imported from
+                                const agentImportPath = importMap.get(validatorInfo.agentVariable);
+                                if (agentImportPath) {
+                                    routeConfig.agentImportPath = agentImportPath;
+                                }
+                            }
+                            if (validatorInfo.inputSchemaVariable) {
+                                routeConfig.inputSchemaVariable = validatorInfo.inputSchemaVariable;
+                            }
+                            if (validatorInfo.outputSchemaVariable) {
+                                routeConfig.outputSchemaVariable = validatorInfo.outputSchemaVariable;
+                            }
+                        }
                         routes.push({
                             id,
                             method: method,
@@ -751,7 +752,7 @@ export async function parseRoute(rootDir, filename, projectId, deploymentId) {
                             filename: rel,
                             path: thepath,
                             version,
-                            config,
+                            config: Object.keys(routeConfig).length > 0 ? routeConfig : undefined,
                         });
                     }
                 }