@ariaflowagents/config 0.2.0

package/dist/loader.js

@@ -0,0 +1,1109 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { pathToFileURL } from 'url';
+import fg from 'fast-glob';
+import matter from 'gray-matter';
+import { parse as parseJsonc } from 'jsonc-parser';
+import { minimatch } from 'minimatch';
+import { tool as aiTool } from 'ai';
+import { z } from 'zod';
+import { createRuntime, } from '@ariaflowagents/core';
+let _warnings = [];
+let _logger = null;
+let _silent = false;
+function initObservability(options) {
+    _warnings = [];
+    _logger = options.logger ?? null;
+    _silent = options.silent ?? false;
+}
+function warn(type, file, message, severity = 'warn') {
+    const warning = { type, file, message, severity };
+    _warnings.push(warning);
+    if (_logger) {
+        _logger(severity, message, { type, file });
+    }
+    else if (!_silent) {
+        const prefix = severity === 'error' ? '❌' : '⚠️';
+        console[severity === 'error' ? 'error' : 'warn'](`${prefix} ${message} (${file})`);
+    }
+}
+function getWarnings() {
+    return [..._warnings];
+}
+function clearWarnings() {
+    _warnings = [];
+}
+// ============================================
+const toolJsonSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    type: z.enum(['builtin', 'module', 'skill']),
+    entry: z.string().optional(),
+    inputSchema: z.record(z.unknown()).optional(),
+    outputSchema: z.record(z.unknown()).optional(),
+    timeoutMs: z.number().optional(),
+    metadata: z.record(z.string()).optional(),
+});
+const skillFrontmatterSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    license: z.string().optional(),
+    metadata: z.record(z.string()).optional(),
+});
+const triagePromptTemplate = (basePrompt, routes, defaultAgent) => {
+    const routeDescriptions = routes
+        .map(route => `- **${route.agentId}**: ${route.description}`)
+        .join('\n');
+    const defaultNote = defaultAgent
+        ? `\n- Use "${defaultAgent}" when no specialist applies.`
+        : '';
+    return `${basePrompt}\n\n## Available Specialists\n${routeDescriptions}\n\n## Instructions\n- For general questions, answer directly\n- When the customer needs specialized help, use the handoff tool\n- Always provide a brief reason for the handoff${defaultNote}`;
+};
+function log(logger, level, message, meta) {
+    logger?.(level, message, meta);
+}
+function parseJsoncContent(content, sourcePath) {
+    const errors = [];
+    const parsed = parseJsonc(content, errors);
+    if (errors.length > 0) {
+        const message = errors.map(err => `Offset ${err.offset}: ${err.error}`).join(', ');
+        throw new Error(`Failed to parse JSONC (${sourcePath}): ${message}`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Config file ${sourcePath} must be a JSON object`);
+    }
+    return parsed;
+}
+async function readJsoncFile(filePath) {
+    const content = await readFile(filePath, 'utf8');
+    return parseJsoncContent(content, filePath);
+}
+function toArray(value) {
+    if (!value) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function deepMerge(base, override) {
+    if (!override || typeof override !== 'object' || Array.isArray(override)) {
+        return override ?? base;
+    }
+    if (!base || typeof base !== 'object' || Array.isArray(base)) {
+        return override;
+    }
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const baseValue = base[key];
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = deepMerge(baseValue, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function resolveConfigFile(target, baseDir) {
+    const resolved = path.isAbsolute(target) ? target : path.resolve(baseDir, target);
+    if (existsSync(resolved) && !resolved.endsWith('.json') && !resolved.endsWith('.jsonc')) {
+        const jsonc = path.join(resolved, 'ariaflow.jsonc');
+        const json = path.join(resolved, 'ariaflow.json');
+        if (existsSync(jsonc)) {
+            return jsonc;
+        }
+        if (existsSync(json)) {
+            return json;
+        }
+    }
+    return resolved;
+}
+async function loadConfigFile(configPath, visited = new Set()) {
+    const resolvedPath = path.resolve(configPath);
+    if (visited.has(resolvedPath)) {
+        throw new Error(`Detected circular config extends reference at ${resolvedPath}`);
+    }
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`Config file not found: ${resolvedPath}`);
+    }
+    visited.add(resolvedPath);
+    const config = await readJsoncFile(resolvedPath);
+    const layers = [];
+    const extendsList = toArray(config.extends);
+    const baseDir = path.dirname(resolvedPath);
+    for (const extendTarget of extendsList) {
+        const extendPath = resolveConfigFile(extendTarget, baseDir);
+        const nestedLayers = await loadConfigFile(extendPath, visited);
+        layers.push(...nestedLayers);
+    }
+    const { extends: _ignored, ...rest } = config;
+    layers.push({ config: rest, dir: baseDir, path: resolvedPath });
+    return layers;
+}
+function findProjectRoot(start) {
+    let current = path.resolve(start);
+    while (true) {
+        const gitDir = path.join(current, '.git');
+        if (existsSync(gitDir)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return start;
+        }
+        current = parent;
+    }
+}
+function findProjectConfig(projectRoot) {
+    const jsonc = path.join(projectRoot, 'ariaflow.jsonc');
+    const json = path.join(projectRoot, 'ariaflow.json');
+    if (existsSync(jsonc)) {
+        return jsonc;
+    }
+    if (existsSync(json)) {
+        return json;
+    }
+    return null;
+}
+function findGlobalConfig() {
+    const configDir = path.join(os.homedir(), '.config', 'ariaflow');
+    const jsonc = path.join(configDir, 'ariaflow.jsonc');
+    const json = path.join(configDir, 'ariaflow.json');
+    if (existsSync(jsonc)) {
+        return jsonc;
+    }
+    if (existsSync(json)) {
+        return json;
+    }
+    return null;
+}
+function findAriaflowDirs(cwd, projectRoot) {
+    const dirs = [];
+    let current = path.resolve(cwd);
+    const root = path.resolve(projectRoot);
+    while (true) {
+        const candidate = path.join(current, '.ariaflow');
+        if (existsSync(candidate)) {
+            dirs.push(candidate);
+        }
+        if (current === root) {
+            break;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return dirs.reverse();
+}
+async function loadMarkdownAgents(root, sources) {
+    const pattern = path.join(root, 'agent', '*.md');
+    const files = await fg(pattern, { onlyFiles: true, unique: true });
+    const agents = {};
+    for (const file of files) {
+        const content = await readFile(file, 'utf8');
+        const parsed = matter(content);
+        const id = path.basename(file, path.extname(file));
+        const data = parsed.data;
+        const type = data.type ?? 'llm';
+        const description = typeof data.description === 'string' ? data.description : undefined;
+        const name = typeof data.name === 'string' ? data.name : id;
+        const modelId = typeof data.model === 'string' ? data.model : undefined;
+        const tools = normalizeToolSelection(data.tools);
+        const mode = data.mode === 'hybrid'
+            ? 'hybrid'
+            : data.mode === 'strict'
+                ? 'strict'
+                : undefined;
+        const prompt = await resolvePrompt(data.prompt ?? data.systemPrompt ?? parsed.content, path.dirname(file));
+        if (!prompt) {
+            throw new Error(`Agent ${id} is missing a prompt (${file})`);
+        }
+        const baseAgent = {
+            id,
+            name,
+            description,
+            systemPrompt: prompt,
+            modelId,
+            toolNames: tools,
+            maxTurns: typeof data.maxTurns === 'number' ? data.maxTurns : undefined,
+            maxSteps: typeof data.maxSteps === 'number' ? data.maxSteps : undefined,
+        };
+        if (type === 'triage') {
+            const routes = Array.isArray(data.routes) ? data.routes : [];
+            const defaultAgent = typeof data.defaultAgent === 'string' ? data.defaultAgent : undefined;
+            const basePrompt = typeof data.systemPrompt === 'string' ? data.systemPrompt : prompt;
+            baseAgent.systemPrompt = basePrompt;
+            agents[id] = {
+                ...baseAgent,
+                type: 'triage',
+                routes,
+                defaultAgent,
+            };
+        }
+        else if (type === 'flow') {
+            if (!data.flow) {
+                throw new Error(`Flow agent ${id} is missing flow definition (${file})`);
+            }
+            const initialNode = typeof data.initialNode === 'string' ? data.initialNode : '';
+            if (!initialNode) {
+                throw new Error(`Flow agent ${id} is missing initialNode (${file})`);
+            }
+            agents[id] = {
+                ...baseAgent,
+                type: 'flow',
+                flow: data.flow,
+                initialNode,
+                mode,
+            };
+        }
+        else {
+            agents[id] = {
+                ...baseAgent,
+                type: 'llm',
+            };
+        }
+        sources.agentFiles.push(file);
+    }
+    return agents;
+}
+function normalizeToolSelection(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.filter(item => typeof item === 'string');
+    }
+    if (typeof value === 'object') {
+        return Object.entries(value)
+            .filter(([, enabled]) => Boolean(enabled))
+            .map(([name]) => name);
+    }
+    return undefined;
+}
+async function resolvePrompt(value, baseDir) {
+    if (!value) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0 ? value : null;
+    }
+    if (typeof value === 'object' && value !== null && 'file' in value) {
+        const fileValue = value.file;
+        if (!fileValue) {
+            return null;
+        }
+        const resolvedPath = path.isAbsolute(fileValue)
+            ? fileValue
+            : path.resolve(baseDir, fileValue);
+        if (!existsSync(resolvedPath)) {
+            warn('missing_prompt', resolvedPath, `Prompt file not found`);
+            return null;
+        }
+        return readFile(resolvedPath, 'utf8');
+    }
+    return null;
+}
+async function loadFlowFiles(root, sources) {
+    const pattern = path.join(root, 'flow', '*.json');
+    const files = await fg(pattern, { onlyFiles: true, unique: true });
+    const flows = {};
+    const meta = {};
+    for (const file of files) {
+        const content = await readFile(file, 'utf8');
+        const data = parseJsoncContent(content, file);
+        const id = data.id ?? path.basename(file, path.extname(file));
+        const { id: _id, entry, initialNode, ...rest } = data;
+        const flowConfig = {
+            nodes: rest.nodes,
+            transitions: rest.transitions,
+            defaultRolePrompt: rest.defaultRolePrompt,
+            contextStrategy: rest.contextStrategy,
+        };
+        flows[id] = flowConfig;
+        meta[id] = {
+            id,
+            initialNode: initialNode ?? entry,
+            path: file,
+        };
+        sources.flowFiles.push(file);
+    }
+    return { flows, meta };
+}
+async function loadToolFiles(root, sources) {
+    const pattern = path.join(root, 'tools', '*', 'tool.json');
+    const files = await fg(pattern, { onlyFiles: true, unique: true });
+    const tools = {};
+    for (const file of files) {
+        const raw = await readJsoncFile(file);
+        const parsed = toolJsonSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new Error(`Invalid tool.json at ${file}: ${parsed.error.message}`);
+        }
+        const toolConfig = parsed.data;
+        const toolDir = path.dirname(file);
+        const toolName = toolConfig.name;
+        if (path.basename(toolDir) !== toolName) {
+            throw new Error(`Tool name mismatch at ${file}: expected ${path.basename(toolDir)} got ${toolName}`);
+        }
+        if (toolConfig.type !== 'module') {
+            continue;
+        }
+        if (!toolConfig.entry) {
+            throw new Error(`Tool ${toolName} is missing entry path (${file})`);
+        }
+        const entryPath = path.isAbsolute(toolConfig.entry)
+            ? toolConfig.entry
+            : path.resolve(toolDir, toolConfig.entry);
+        const toolExport = await import(pathToFileURL(entryPath).toString());
+        const toolInstance = normalizeToolExport(toolExport, toolName);
+        tools[toolName] = toolInstance;
+        sources.toolFiles.push(file);
+    }
+    return tools;
+}
+function normalizeToolExport(module, name) {
+    const candidate = (module.tool ?? module.default ?? module);
+    if (!candidate || typeof candidate !== 'object') {
+        throw new Error(`Tool module for ${name} did not export a tool`);
+    }
+    if ('execute' in candidate && 'inputSchema' in candidate) {
+        const execute = candidate.execute;
+        const inputSchema = candidate.inputSchema;
+        const description = candidate.description ?? `Tool ${name}`;
+        return aiTool({ description, inputSchema, execute });
+    }
+    if ('execute' in candidate && 'parameters' in candidate) {
+        return candidate;
+    }
+    throw new Error(`Tool module for ${name} is missing execute/inputSchema or parameters`);
+}
+async function parseSkillFile(file, sources) {
+    const content = await readFile(file, 'utf8');
+    const parsed = matter(content);
+    const frontmatter = skillFrontmatterSchema.safeParse(parsed.data ?? {});
+    if (!frontmatter.success) {
+        warn('invalid_frontmatter', file, `Invalid SKILL.md frontmatter: ${frontmatter.error.message}`);
+    }
+    const data = frontmatter.data ?? { name: 'unknown', description: 'Unknown skill' };
+    const name = data.name ?? path.basename(path.dirname(file));
+    const dirName = path.basename(path.dirname(file));
+    if (name !== dirName) {
+        warn('name_mismatch', file, `Skill name mismatch: expected "${dirName}" got "${name}"`);
+    }
+    sources.skillFiles.push(file);
+    return {
+        name,
+        description: data.description ?? 'No description',
+        license: data.license,
+        metadata: data.metadata,
+        content: parsed.content.trim(),
+        path: file,
+    };
+}
+async function loadSkills(root, sources) {
+    const pattern = path.join(root, 'skill', '*', 'SKILL.md');
+    const files = await fg(pattern, { onlyFiles: true, unique: true });
+    const skills = [];
+    for (const file of files) {
+        skills.push(await parseSkillFile(file, sources));
+    }
+    return skills;
+}
+async function loadSkillsFromPaths(pathsList, baseDir, sources) {
+    const skills = [];
+    for (const target of pathsList) {
+        const resolved = path.isAbsolute(target) ? target : path.resolve(baseDir, target);
+        const statPath = resolved.endsWith('SKILL.md') ? resolved : path.join(resolved, '*', 'SKILL.md');
+        const files = await fg(statPath, { onlyFiles: true, unique: true });
+        for (const file of files) {
+            skills.push(await parseSkillFile(file, sources));
+        }
+    }
+    return skills;
+}
+function applyPermissions(skills, permissions) {
+    const rule = permissions?.skill;
+    if (!rule) {
+        return [];
+    }
+    if (typeof rule === 'string') {
+        return rule === 'allow' ? skills : [];
+    }
+    return skills.filter(skill => {
+        const result = evaluatePermission(skill.name, rule);
+        return result === 'allow' || result === 'ask';
+    });
+}
+function evaluatePermission(name, rules) {
+    if (rules[name]) {
+        return rules[name];
+    }
+    for (const [pattern, value] of Object.entries(rules)) {
+        if (pattern === name) {
+            return value;
+        }
+        if (pattern.includes('*') && minimatch(name, pattern)) {
+            return value;
+        }
+    }
+    return 'deny';
+}
+function createSkillTool(skills) {
+    if (skills.length === 0) {
+        return aiTool({
+            description: 'No skills available.',
+            inputSchema: z.object({}),
+            execute: async () => ({ error: 'No skills available' }),
+        });
+    }
+    const names = skills.map(skill => skill.name);
+    const descriptions = skills
+        .map(skill => `- **${skill.name}**: ${skill.description}`)
+        .join('\n');
+    return aiTool({
+        description: `Load a reusable skill by name.\n\nAvailable skills:\n${descriptions}`,
+        inputSchema: z.object({
+            name: z.enum(names),
+        }),
+        execute: async ({ name }) => {
+            const skill = skills.find(item => item.name === name);
+            if (!skill) {
+                return { error: `Skill not found: ${name}` };
+            }
+            return {
+                name: skill.name,
+                description: skill.description,
+                license: skill.license,
+                metadata: skill.metadata,
+                content: skill.content,
+            };
+        },
+    });
+}
+function resolveModel(modelId, aliasMap, registry, defaultModel) {
+    if (!modelId) {
+        return defaultModel ?? registry?.default;
+    }
+    const alias = aliasMap?.[modelId] ?? modelId;
+    return registry?.[alias] ?? registry?.[modelId];
+}
+function buildToolSet(toolRegistry, selection) {
+    if (!selection || selection.length === 0) {
+        return undefined;
+    }
+    const tools = {};
+    const missing = [];
+    for (const name of selection) {
+        const toolInstance = toolRegistry[name];
+        if (toolInstance) {
+            tools[name] = toolInstance;
+        }
+        else {
+            missing.push(name);
+        }
+    }
+    if (missing.length > 0) {
+        warn('tool_not_found', missing.join(', '), `Tool(s) not found: ${missing.join(', ')}`);
+    }
+    return Object.keys(tools).length > 0 ? tools : undefined;
+}
+function resolveFlowNodeTools(value, toolRegistry) {
+    if (!value) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        const names = value.filter(item => typeof item === 'string');
+        return buildToolSet(toolRegistry, names);
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        const hasToolShape = entries.some(([, toolValue]) => {
+            if (!toolValue || typeof toolValue !== 'object') {
+                return false;
+            }
+            return 'execute' in toolValue || 'parameters' in toolValue;
+        });
+        if (hasToolShape) {
+            return value;
+        }
+        const enabledNames = entries
+            .filter(([, enabled]) => Boolean(enabled))
+            .map(([name]) => name);
+        return buildToolSet(toolRegistry, enabledNames);
+    }
+    return undefined;
+}
+function hydrateFlowTools(flow, toolRegistry) {
+    return {
+        ...flow,
+        nodes: flow.nodes.map(node => ({
+            ...node,
+            tools: resolveFlowNodeTools(node.tools, toolRegistry),
+        })),
+    };
+}
+async function loadToolConfigEntries(toolsConfig, baseDir, registry, builtinTools, skills, permissions, sources) {
+    if (!toolsConfig) {
+        return;
+    }
+    for (const [name, value] of Object.entries(toolsConfig)) {
+        if (value === false) {
+            delete registry[name];
+            continue;
+        }
+        if (value === true) {
+            continue;
+        }
+        const config = value;
+        if (config.type === 'builtin') {
+            const builtin = builtinTools?.[name];
+            if (!builtin) {
+                throw new Error(`Builtin tool "${name}" not found in registry`);
+            }
+            registry[name] = builtin;
+            continue;
+        }
+        if (config.type === 'module') {
+            if (!config.entry) {
+                throw new Error(`Tool "${name}" is missing entry path`);
+            }
+            const entryPath = path.isAbsolute(config.entry)
+                ? config.entry
+                : path.resolve(baseDir, config.entry);
+            const module = await import(pathToFileURL(entryPath).toString());
+            registry[name] = normalizeToolExport(module, name);
+            continue;
+        }
+        if (config.type === 'skill-loader') {
+            const skillSources = config.paths?.length
+                ? await loadSkillsFromPaths(config.paths, baseDir, sources)
+                : skills;
+            const allowedSkills = applyPermissions(skillSources, permissions);
+            registry[name] = createSkillTool(allowedSkills);
+            continue;
+        }
+    }
+}
+export async function loadAriaflowConfig(options = {}) {
+    const startTime = Date.now();
+    initObservability(options);
+    const cwd = options.cwd ?? process.cwd();
+    const configFiles = [];
+    const sources = {
+        configFiles,
+        agentFiles: [],
+        flowFiles: [],
+        toolFiles: [],
+        skillFiles: [],
+    };
+    const baseLayers = [];
+    const globalConfig = findGlobalConfig();
+    if (globalConfig) {
+        const layers = await loadConfigFile(globalConfig);
+        baseLayers.push(...layers);
+        configFiles.push(...layers.map(layer => layer.path));
+    }
+    const customPath = options.configPath ?? process.env.ARIAFLOW_CONFIG;
+    if (customPath) {
+        const layers = await loadConfigFile(customPath);
+        baseLayers.push(...layers);
+        configFiles.push(...layers.map(layer => layer.path));
+    }
+    const projectRoot = findProjectRoot(cwd);
+    const projectConfig = findProjectConfig(projectRoot);
+    if (projectConfig) {
+        const layers = await loadConfigFile(projectConfig);
+        baseLayers.push(...layers);
+        configFiles.push(...layers.map(layer => layer.path));
+    }
+    const inlineContent = options.configContent ?? process.env.ARIAFLOW_CONFIG_CONTENT;
+    const inlineLayer = inlineContent
+        ? { config: parseJsoncContent(inlineContent, 'inline'), dir: cwd, path: 'inline' }
+        : null;
+    let mergedConfig = {};
+    for (const layer of baseLayers) {
+        mergedConfig = deepMerge(mergedConfig, layer.config);
+    }
+    if (inlineLayer) {
+        mergedConfig = deepMerge(mergedConfig, inlineLayer.config);
+    }
+    const roots = [];
+    for (const layer of baseLayers) {
+        const root = path.join(layer.dir, '.ariaflow');
+        if (existsSync(root)) {
+            roots.push(root);
+        }
+    }
+    const ariaflowDirs = findAriaflowDirs(cwd, projectRoot);
+    for (const dir of ariaflowDirs) {
+        if (!roots.includes(dir)) {
+            roots.push(dir);
+        }
+    }
+    const flows = {};
+    const flowMeta = {};
+    for (const layer of baseLayers) {
+        if (!layer.config.flows) {
+            continue;
+        }
+        for (const [id, flowInput] of Object.entries(layer.config.flows)) {
+            flows[id] = {
+                nodes: flowInput.nodes,
+                transitions: flowInput.transitions,
+                defaultRolePrompt: flowInput.defaultRolePrompt,
+                contextStrategy: flowInput.contextStrategy,
+            };
+            flowMeta[id] = { id, initialNode: flowInput.initialNode ?? flowInput.entry, path: layer.path };
+        }
+    }
+    for (const root of roots) {
+        const loaded = await loadFlowFiles(root, sources);
+        Object.assign(flows, loaded.flows);
+        Object.assign(flowMeta, loaded.meta);
+    }
+    if (inlineLayer?.config.flows) {
+        for (const [id, flowInput] of Object.entries(inlineLayer.config.flows)) {
+            flows[id] = {
+                nodes: flowInput.nodes,
+                transitions: flowInput.transitions,
+                defaultRolePrompt: flowInput.defaultRolePrompt,
+                contextStrategy: flowInput.contextStrategy,
+            };
+            flowMeta[id] = { id, initialNode: flowInput.initialNode ?? flowInput.entry, path: inlineLayer.path };
+        }
+    }
+    const agentDefs = {};
+    for (const layer of baseLayers) {
+        const agentInputs = layer.config.agents ?? {};
+        for (const [id, input] of Object.entries(agentInputs)) {
+            const normalized = await normalizeAgentInput(id, input, layer.dir, flows, flowMeta);
+            agentDefs[id] = normalized;
+        }
+    }
+    for (const root of roots) {
+        const markdownAgents = await loadMarkdownAgents(root, sources);
+        Object.assign(agentDefs, markdownAgents);
+    }
+    if (inlineLayer?.config.agents) {
+        for (const [id, input] of Object.entries(inlineLayer.config.agents)) {
+            const normalized = await normalizeAgentInput(id, input, inlineLayer.dir, flows, flowMeta);
+            agentDefs[id] = normalized;
+        }
+    }
+    const toolsRegistry = { ...(options.builtinTools ?? {}) };
+    for (const root of roots) {
+        const loadedTools = await loadToolFiles(root, sources);
+        Object.assign(toolsRegistry, loadedTools);
+    }
+    const skills = [];
+    for (const root of roots) {
+        skills.push(...(await loadSkills(root, sources)));
+    }
+    const mergedPermissions = mergedConfig.permissions;
+    for (const layer of baseLayers) {
+        await loadToolConfigEntries(layer.config.tools, layer.dir, toolsRegistry, options.builtinTools, skills, mergedPermissions, sources);
+    }
+    if (inlineLayer) {
+        await loadToolConfigEntries(inlineLayer.config.tools, inlineLayer.dir, toolsRegistry, options.builtinTools, skills, mergedPermissions, sources);
+    }
+    const agents = [];
+    const aliasMap = mergedConfig.models ?? {};
+    const defaultModel = resolveModel(mergedConfig.runtime?.defaultModel, aliasMap, options.modelRegistry, options.defaultModel);
+    for (const agent of Object.values(agentDefs)) {
+        const model = resolveModel(agent.modelId, aliasMap, options.modelRegistry, defaultModel);
+        if (!model) {
+            throw new Error(`Agent "${agent.id}" is missing a model (resolved from config)`);
+        }
+        const tools = buildToolSet(toolsRegistry, agent.toolNames);
+        if (agent.type === 'triage') {
+            agents.push({
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                systemPrompt: triagePromptTemplate(agent.systemPrompt, agent.routes, agent.defaultAgent),
+                model: model,
+                tools: tools,
+                maxTurns: agent.maxTurns,
+                maxSteps: agent.maxSteps,
+                type: 'triage',
+                routes: agent.routes.map(route => ({
+                    agentId: route.agentId,
+                    description: route.description,
+                })),
+                defaultAgent: agent.defaultAgent,
+            });
+            continue;
+        }
+        if (agent.type === 'flow') {
+            const flowWithTools = hydrateFlowTools(agent.flow, toolsRegistry);
+            agents.push({
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                systemPrompt: agent.systemPrompt,
+                model: model,
+                tools: tools,
+                maxTurns: agent.maxTurns,
+                maxSteps: agent.maxSteps,
+                type: 'flow',
+                flow: flowWithTools,
+                initialNode: agent.initialNode,
+                mode: agent.mode,
+            });
+            continue;
+        }
+        agents.push({
+            id: agent.id,
+            name: agent.name,
+            description: agent.description,
+            systemPrompt: agent.systemPrompt,
+            model: model,
+            tools: tools,
+            maxTurns: agent.maxTurns,
+            maxSteps: agent.maxSteps,
+            type: 'llm',
+        });
+    }
+    const runtimeConfig = mergedConfig.runtime;
+    const defaultAgentId = runtimeConfig?.defaultAgent ?? agents[0]?.id;
+    if (!defaultAgentId) {
+        throw new Error('No default agent configured');
+    }
+    if (!agents.find(agent => agent.id === defaultAgentId)) {
+        throw new Error(`Default agent "${defaultAgentId}" not found in loaded agents`);
+    }
+    return {
+        runtime: {
+            defaultAgentId,
+            defaultModel: defaultModel,
+            maxSteps: runtimeConfig?.maxSteps,
+            maxTurns: runtimeConfig?.maxTurns,
+            maxHandoffs: runtimeConfig?.maxHandoffs,
+        },
+        agents,
+        flows,
+        tools: toolsRegistry,
+        sources,
+    };
+}
+export async function loadAriaflowConfigWithResult(options = {}) {
+    const startTime = Date.now();
+    initObservability(options);
+    const cwd = options.cwd ?? process.cwd();
+    const configFiles = [];
+    const sources = {
+        configFiles,
+        agentFiles: [],
+        flowFiles: [],
+        toolFiles: [],
+        skillFiles: [],
+    };
+    const baseLayers = [];
+    const globalConfig = findGlobalConfig();
+    if (globalConfig) {
+        const layers = await loadConfigFile(globalConfig);
+        baseLayers.push(...layers);
+        configFiles.push(...layers.map(layer => layer.path));
+    }
+    const customPath = options.configPath ?? process.env.ARIAFLOW_CONFIG;
+    if (customPath) {
+        const layers = await loadConfigFile(customPath);
+        baseLayers.push(...layers);
+        configFiles.push(...layers.map(layer => layer.path));
+    }
+    const projectRoot = findProjectRoot(cwd);
+    const projectConfig = findProjectConfig(projectRoot);
+    if (projectConfig) {
+        const layers = await loadConfigFile(projectConfig);
+        baseLayers.push(...layers);
+        configFiles.push(...layers.map(layer => layer.path));
+    }
+    const inlineContent = options.configContent ?? process.env.ARIAFLOW_CONFIG_CONTENT;
+    const inlineLayer = inlineContent
+        ? { config: parseJsoncContent(inlineContent, 'inline'), dir: cwd, path: 'inline' }
+        : null;
+    let mergedConfig = {};
+    for (const layer of baseLayers) {
+        mergedConfig = deepMerge(mergedConfig, layer.config);
+    }
+    if (inlineLayer) {
+        mergedConfig = deepMerge(mergedConfig, inlineLayer.config);
+    }
+    const roots = [];
+    for (const layer of baseLayers) {
+        const root = path.join(layer.dir, '.ariaflow');
+        if (existsSync(root)) {
+            roots.push(root);
+        }
+    }
+    const ariaflowDirs = findAriaflowDirs(cwd, projectRoot);
+    for (const dir of ariaflowDirs) {
+        if (!roots.includes(dir)) {
+            roots.push(dir);
+        }
+    }
+    const flows = {};
+    const flowMeta = {};
+    for (const layer of baseLayers) {
+        if (!layer.config.flows)
+            continue;
+        for (const [id, flowInput] of Object.entries(layer.config.flows)) {
+            flows[id] = {
+                nodes: flowInput.nodes,
+                transitions: flowInput.transitions,
+                defaultRolePrompt: flowInput.defaultRolePrompt,
+                contextStrategy: flowInput.contextStrategy,
+            };
+            flowMeta[id] = { id, initialNode: flowInput.initialNode ?? flowInput.entry, path: layer.path };
+        }
+    }
+    for (const root of roots) {
+        const loaded = await loadFlowFiles(root, sources);
+        Object.assign(flows, loaded.flows);
+        Object.assign(flowMeta, loaded.meta);
+    }
+    if (inlineLayer?.config.flows) {
+        for (const [id, flowInput] of Object.entries(inlineLayer.config.flows)) {
+            flows[id] = {
+                nodes: flowInput.nodes,
+                transitions: flowInput.transitions,
+                defaultRolePrompt: flowInput.defaultRolePrompt,
+                contextStrategy: flowInput.contextStrategy,
+            };
+            flowMeta[id] = { id, initialNode: flowInput.initialNode ?? flowInput.entry, path: inlineLayer.path };
+        }
+    }
+    const agentDefs = {};
+    for (const layer of baseLayers) {
+        const agentInputs = layer.config.agents ?? {};
+        for (const [id, input] of Object.entries(agentInputs)) {
+            const normalized = await normalizeAgentInput(id, input, layer.dir, flows, flowMeta);
+            agentDefs[id] = normalized;
+        }
+    }
+    for (const root of roots) {
+        const markdownAgents = await loadMarkdownAgents(root, sources);
+        Object.assign(agentDefs, markdownAgents);
+    }
+    if (inlineLayer?.config.agents) {
+        for (const [id, input] of Object.entries(inlineLayer.config.agents)) {
+            const normalized = await normalizeAgentInput(id, input, inlineLayer.dir, flows, flowMeta);
+            agentDefs[id] = normalized;
+        }
+    }
+    const toolsRegistry = { ...(options.builtinTools ?? {}) };
+    for (const root of roots) {
+        const loadedTools = await loadToolFiles(root, sources);
+        Object.assign(toolsRegistry, loadedTools);
+    }
+    const skills = [];
+    for (const root of roots) {
+        skills.push(...(await loadSkills(root, sources)));
+    }
+    const mergedPermissions = mergedConfig.permissions;
+    for (const layer of baseLayers) {
+        await loadToolConfigEntries(layer.config.tools, layer.dir, toolsRegistry, options.builtinTools, skills, mergedPermissions, sources);
+    }
+    if (inlineLayer) {
+        await loadToolConfigEntries(inlineLayer.config.tools, inlineLayer.dir, toolsRegistry, options.builtinTools, skills, mergedPermissions, sources);
+    }
+    const agents = [];
+    const aliasMap = mergedConfig.models ?? {};
+    const defaultModel = resolveModel(mergedConfig.runtime?.defaultModel, aliasMap, options.modelRegistry, options.defaultModel);
+    for (const agent of Object.values(agentDefs)) {
+        const model = resolveModel(agent.modelId, aliasMap, options.modelRegistry, defaultModel);
+        if (!model) {
+            throw new Error(`Agent "${agent.id}" is missing a model (resolved from config)`);
+        }
+        const tools = buildToolSet(toolsRegistry, agent.toolNames);
+        if (agent.type === 'triage') {
+            agents.push({
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                systemPrompt: triagePromptTemplate(agent.systemPrompt, agent.routes, agent.defaultAgent),
+                model: model,
+                tools: tools,
+                maxTurns: agent.maxTurns,
+                maxSteps: agent.maxSteps,
+                type: 'triage',
+                routes: agent.routes.map(route => ({
+                    agentId: route.agentId,
+                    description: route.description,
+                })),
+                defaultAgent: agent.defaultAgent,
+            });
+            continue;
+        }
+        if (agent.type === 'flow') {
+            const flowWithTools = hydrateFlowTools(agent.flow, toolsRegistry);
+            agents.push({
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                systemPrompt: agent.systemPrompt,
+                model: model,
+                tools: tools,
+                maxTurns: agent.maxTurns,
+                maxSteps: agent.maxSteps,
+                type: 'flow',
+                flow: flowWithTools,
+                initialNode: agent.initialNode,
+                mode: agent.mode,
+            });
+            continue;
+        }
+        agents.push({
+            id: agent.id,
+            name: agent.name,
+            description: agent.description,
+            systemPrompt: agent.systemPrompt,
+            model: model,
+            tools: tools,
+            maxTurns: agent.maxTurns,
+            maxSteps: agent.maxSteps,
+            type: 'llm',
+        });
+    }
+    const runtimeConfig = mergedConfig.runtime;
+    const defaultAgentId = runtimeConfig?.defaultAgent ?? agents[0]?.id;
+    if (!defaultAgentId) {
+        throw new Error('No default agent configured');
+    }
+    if (!agents.find(agent => agent.id === defaultAgentId)) {
+        throw new Error(`Default agent "${defaultAgentId}" not found in loaded agents`);
+    }
+    const warnings = getWarnings();
+    const errorCount = warnings.filter(w => w.severity === 'error').length;
+    const durationMs = Date.now() - startTime;
+    if (!options.silent && warnings.length > 0) {
+        console.log(`\n⚠️  Loaded with ${errorCount} error(s) and ${warnings.length - errorCount} warning(s)`);
+    }
+    return {
+        config: {
+            runtime: {
+                defaultAgentId,
+                defaultModel: defaultModel,
+                maxSteps: runtimeConfig?.maxSteps,
+                maxTurns: runtimeConfig?.maxTurns,
+                maxHandoffs: runtimeConfig?.maxHandoffs,
+            },
+            agents,
+            flows,
+            tools: toolsRegistry,
+            sources,
+        },
+        summary: {
+            agents: agents.length,
+            flows: Object.keys(flows).length,
+            tools: Object.keys(toolsRegistry).length,
+            skills: skills.length,
+            layers: configFiles,
+            durationMs,
+            warningCount: warnings.length - errorCount,
+            errorCount,
+        },
+        warnings,
+    };
+}
+export function printLoadSummary(summary) {
+    console.log('\n✅ Config loaded successfully');
+    console.log(`   • ${summary.agents} agent(s)`);
+    console.log(`   • ${summary.flows} flow(s)`);
+    console.log(`   • ${summary.tools} tool(s)`);
+    console.log(`   • ${summary.skills} skill(s)`);
+    if (summary.layers.length > 0) {
+        console.log(`   • Layers: ${summary.layers.map(l => path.basename(l)).join(', ')}`);
+    }
+    if (summary.warningCount > 0 || summary.errorCount > 0) {
+        console.log(`   • ${summary.warningCount} warning(s), ${summary.errorCount} error(s)`);
+    }
+    console.log(`   • ${summary.durationMs}ms`);
+}
+async function normalizeAgentInput(id, input, baseDir, flows, flowMeta) {
+    const type = (input.type ?? 'llm');
+    const name = input.name ?? id;
+    const description = input.description;
+    const modelId = input.model;
+    const promptValue = await resolvePrompt(input.prompt ?? input.systemPrompt, baseDir);
+    if (!promptValue) {
+        warn('missing_prompt', id, `Agent "${id}" is missing a prompt`);
+    }
+    const baseAgent = {
+        id,
+        name,
+        description,
+        systemPrompt: promptValue ?? `[Missing prompt for agent: ${id}]`,
+        modelId,
+        toolNames: normalizeToolSelection(input.tools),
+        maxTurns: input.maxTurns,
+        maxSteps: input.maxSteps,
+    };
+    if (type === 'triage') {
+        const triage = input;
+        const routes = triage.routes ?? [];
+        const basePrompt = input.systemPrompt ? (await resolvePrompt(input.systemPrompt, baseDir)) : promptValue;
+        return {
+            ...baseAgent,
+            type: 'triage',
+            routes,
+            defaultAgent: triage.defaultAgent,
+            systemPrompt: basePrompt ?? promptValue ?? `[Missing prompt for agent: ${id}]`,
+        };
+    }
+    if (type === 'flow') {
+        const flowInput = input;
+        const mode = flowInput.mode === 'hybrid' || flowInput.mode === 'strict'
+            ? flowInput.mode
+            : undefined;
+        const flowId = flowInput.flowRef ?? flowInput.flow?.id;
+        const flowConfig = flowInput.flow
+            ? {
+                nodes: flowInput.flow.nodes,
+                transitions: flowInput.flow.transitions,
+                defaultRolePrompt: flowInput.flow.defaultRolePrompt,
+                contextStrategy: flowInput.flow.contextStrategy,
+            }
+            : flowId
+                ? flows[flowId]
+                : undefined;
+        if (!flowConfig) {
+            throw new Error(`Flow agent "${id}" references missing flow`);
+        }
+        const initialNode = flowInput.initialNode ??
+            flowInput.flow?.entry ??
+            flowMeta[flowId ?? '']?.initialNode ??
+            flowConfig.nodes?.[0]?.id;
+        if (!initialNode) {
+            throw new Error(`Flow agent "${id}" is missing initialNode`);
+        }
+        return {
+            ...baseAgent,
+            type: 'flow',
+            flow: flowConfig,
+            initialNode,
+            mode,
+        };
+    }
+    return {
+        ...baseAgent,
+        type: 'llm',
+    };
+}
+export function createRuntimeFromConfig(config, overrides = {}) {
+    return createRuntime({
+        agents: config.agents,
+        defaultAgentId: config.runtime.defaultAgentId,
+        defaultModel: config.runtime.defaultModel,
+        maxSteps: config.runtime.maxSteps,
+        maxHandoffs: config.runtime.maxHandoffs,
+        ...overrides,
+    });
+}
+//# sourceMappingURL=loader.js.map