veryfront 0.1.498 → 0.1.499

package/esm/src/agent/veryfront-cloud-agent-service.js

@@ -0,0 +1,482 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHostedSandboxTools } from "../sandbox/index.js";
+import { createRemoteMCPToolSource, createToolsFromRemoteDefinitions, sleepTool, toolRegistry, } from "../tool/index.js";
+import { parseProviderError } from "../chat/provider-errors.js";
+import { getConfig } from "../config/index.js";
+import { clearTrackedAgents, clearTranspileCache, createProjectDiscoveryConfig, DEFAULT_PROJECT_DISCOVERY_DIRS, discoverAll, } from "../discovery/index.js";
+import { nodeAdapter } from "../platform/adapters/node.js";
+import { getVeryfrontCloudProviderFromModelId, resolveVeryfrontCloudModelId, resolveVeryfrontCloudThinkingProviderOptions, } from "../provider/index.js";
+import { __registerTraceContextGetter } from "../utils/logger/logger.js";
+import { buildAgentRunTraceAttributes, buildExecuteToolTraceAttributes, filterAgentTraceAttributes, } from "./agent-trace-attributes.js";
+import { runAgentServiceMain, } from "./agent-service-bootstrap.js";
+import { loadAgentServiceEnvFiles } from "./hosted-agent-service-env-files.js";
+import { createHostedFormInputTool } from "./hosted-form-input-tool.js";
+import { createHostedAgentProjectSteering } from "./hosted-agent-project-steering.js";
+import { createLiveStudioMcpTools } from "./live-studio-mcp-tools.js";
+import { createDefaultHostedChatRuntime, } from "./default-hosted-chat-runtime.js";
+import { createDefaultHostedInvokeAgentTool } from "./default-hosted-invoke-agent-tool.js";
+import { createDefaultHostedProjectSteeringRefresh, fetchDefaultHostedProjectSteering, } from "./default-hosted-project-steering-refresh.js";
+import { buildVeryfrontCloudRuntimeInstructions, } from "./veryfront-cloud-runtime-system-messages.js";
+import { createNodeAgentServiceRuntimeInfrastructure, } from "./node-hosted-agent-service-runtime-infrastructure.js";
+import { createAgentServiceRuntime, startNodeAgentService, } from "./hosted-agent-service-runtime.js";
+import { createDetachedRunTracker } from "./detached-run-tracker.js";
+import { runPreparedHostedChatExecutionDetached, streamPreparedHostedChatExecutionToAgUiResponse, } from "./prepared-hosted-chat-execution.js";
+import { createVeryfrontCloudPreparedHostedChatExecutionRuntimeOptions, } from "./veryfront-cloud-prepared-hosted-chat-execution-runtime.js";
+import { prepareVeryfrontCloudHostedChatExecution, } from "./veryfront-cloud-hosted-chat-execution-preparation.js";
+import { applyAgentProjectContextChange } from "./project-context.js";
+import { agentRegistry, getAgent } from "./composition/index.js";
+const DEFAULT_FORWARDED_CONFIG_NAMESPACE = "veryfront";
+const DEFAULT_DRAIN_TIMEOUT_MS = 15_000;
+const DEFAULT_HARD_SHUTDOWN_TIMEOUT_MS = 20_000;
+const DEFAULT_PROJECT_NAVIGATION_TOOL_NAMES = ["studio_open_project"];
+const PROJECT_CONFIG_FILES = [
+    "veryfront.config.js",
+    "veryfront.config.ts",
+    "veryfront.config.mjs",
+];
+function resolveBaseDir(options) {
+    if (options.baseDir) {
+        return options.baseDir;
+    }
+    if (options.entryUrl) {
+        return dirname(fileURLToPath(options.entryUrl));
+    }
+    if (typeof process !== "undefined") {
+        return process.cwd();
+    }
+    return dntShim.Deno.cwd();
+}
+function hasDiscoveryRoot(baseDir) {
+    const discoveryDirs = [
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.agentDirs,
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.toolDirs,
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.skillDirs,
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.resourceDirs,
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.promptDirs,
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.workflowDirs,
+        ...DEFAULT_PROJECT_DISCOVERY_DIRS.taskDirs,
+    ];
+    return discoveryDirs.some((dir) => existsSync(resolve(baseDir, dir))) ||
+        PROJECT_CONFIG_FILES.some((file) => existsSync(resolve(baseDir, file)));
+}
+function uniquePaths(paths) {
+    return [...new Set(paths.map((path) => resolve(path)))];
+}
+function resolveProjectDir(options) {
+    if (options.projectDir) {
+        return options.projectDir;
+    }
+    const baseDir = resolveBaseDir(options);
+    const candidates = uniquePaths([baseDir, dirname(baseDir), dirname(dirname(baseDir))]);
+    return candidates.find(hasDiscoveryRoot) ?? baseDir;
+}
+function resolveDefaultProcessTarget() {
+    if (typeof process === "undefined") {
+        return undefined;
+    }
+    return process;
+}
+function resolveEnvironment(options) {
+    if (options.env) {
+        return options.env;
+    }
+    if (options.processTarget?.env) {
+        return options.processTarget.env;
+    }
+    if (typeof process !== "undefined") {
+        return process.env;
+    }
+    return {};
+}
+function createNodeVeryfrontCloudAgentServiceContext(options) {
+    const processTarget = options.processTarget ?? resolveDefaultProcessTarget();
+    const infrastructure = createNodeAgentServiceRuntimeInfrastructure({
+        serviceName: options.serviceName,
+        env: resolveEnvironment({ env: options.env, processTarget }),
+        processTarget,
+    });
+    function trace(operationName, operation) {
+        return infrastructure.tracer.trace(operationName, operation);
+    }
+    const projectSteering = createHostedAgentProjectSteering({
+        baseDir: resolveBaseDir(options),
+        agentId: options.agentId,
+        getApiUrl: () => infrastructure.getConfig().VERYFRONT_API_URL,
+        logger: infrastructure.logger,
+        trace,
+    });
+    return {
+        options,
+        processTarget,
+        projectDir: resolveProjectDir(options),
+        infrastructure,
+        trace,
+        projectSteering,
+        tracker: createDetachedRunTracker(),
+        discoveryResult: null,
+        agentConfig: null,
+    };
+}
+function resolveAgentSystem(system) {
+    return typeof system === "function" ? system() : system;
+}
+async function createRuntimeAgentDefinitionFromCodeAgent(codeAgent) {
+    return {
+        id: codeAgent.id,
+        name: codeAgent.id,
+        description: "",
+        instructions: await resolveAgentSystem(codeAgent.config.system),
+        model: codeAgent.config.model,
+        maxSteps: codeAgent.config.maxSteps,
+    };
+}
+function getMarkdownAgentConfig(context) {
+    return context.projectSteering.getAgentConfig();
+}
+async function resolveAgentConfig(context) {
+    const source = context.options.agentSource ?? "auto";
+    const codeAgent = getAgent(context.options.agentId);
+    if (source !== "markdown" && codeAgent) {
+        return await createRuntimeAgentDefinitionFromCodeAgent(codeAgent);
+    }
+    if (source === "code") {
+        throw new Error(`Code agent "${context.options.agentId}" was not discovered.`);
+    }
+    return getMarkdownAgentConfig(context);
+}
+function getResolvedAgentConfig(context) {
+    if (!context.agentConfig) {
+        throw new Error("Agent service context has not been initialized.");
+    }
+    return context.agentConfig;
+}
+async function discoverProjectPrimitives(context) {
+    clearTrackedAgents();
+    clearTranspileCache();
+    agentRegistry.clear();
+    toolRegistry.clear();
+    const config = await getConfig(context.projectDir, nodeAdapter);
+    const discoveryOptions = createProjectDiscoveryConfig({
+        projectDir: context.projectDir,
+        config,
+    });
+    context.discoveryResult = await discoverAll(discoveryOptions);
+}
+async function initializeNodeVeryfrontCloudAgentServiceContext(context) {
+    await discoverProjectPrimitives(context);
+    context.agentConfig = await resolveAgentConfig(context);
+}
+function getDiscoveredHostTools() {
+    return Object.fromEntries([...toolRegistry.getAll()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function getProjectInstructions(context, lookup) {
+    return context.trace("chat.getProjectInstructions", async () => {
+        return await context.projectSteering.getProjectInstructions(lookup);
+    });
+}
+function getSkillsConfig(context, lookup) {
+    return context.trace("chat.getSkillsConfig", async () => {
+        return await context.projectSteering.getSkillsConfig(lookup);
+    });
+}
+function createLoadSkillTool(context, toolContext) {
+    return context.projectSteering.createLoadSkillTool(toolContext);
+}
+async function refreshProjectSkillIds(context, skillContext) {
+    await context.projectSteering.refreshProjectSkillIds(skillContext);
+}
+function setFilteredTraceAttributes(context, attributes) {
+    context.infrastructure.setActiveSpanAttributes(filterAgentTraceAttributes(attributes));
+}
+function getInvokeAgentConfig(context) {
+    const config = context.infrastructure.getConfig();
+    return {
+        apiUrl: config.VERYFRONT_API_URL,
+        apiMcpUrl: config.VERYFRONT_MCP_URL,
+        studioMcpUrl: config.VERYFRONT_STUDIO_MCP_URL,
+        enableDurableInvokeAgent: config.VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT,
+    };
+}
+function shouldRethrowInvokeAgentError(error) {
+    return parseProviderError(error).code === "INSUFFICIENT_CREDITS";
+}
+function createInvokeAgentTool(context, childContext) {
+    return createDefaultHostedInvokeAgentTool({
+        context: childContext,
+        getConfig: () => getInvokeAgentConfig(context),
+        logger: context.infrastructure.logger,
+        trace: context.trace,
+        setTraceAttributes: context.infrastructure.setActiveSpanAttributes,
+        createBashTool: context.options.createBashTool,
+        resolveModelId: resolveVeryfrontCloudModelId,
+        resolveProvider: getVeryfrontCloudProviderFromModelId,
+        resolveProviderOptions: resolveVeryfrontCloudThinkingProviderOptions,
+        shouldRethrowError: shouldRethrowInvokeAgentError,
+        buildGlobalTools: (globalToolContext) => ({
+            load_skill: createLoadSkillTool(context, globalToolContext),
+        }),
+        refreshProjectSkillIds: (projectSkillContext) => refreshProjectSkillIds(context, projectSkillContext),
+        createHostedSandboxTools,
+        createLiveStudioTools: createLiveStudioMcpTools,
+        createRemoteToolSource: createRemoteMCPToolSource,
+        createToolsFromRemoteDefinitions,
+    });
+}
+function buildLocalTools(context, options, taskContext) {
+    const config = context.infrastructure.getConfig();
+    const tools = {
+        ...getDiscoveredHostTools(),
+        form_input: createHostedFormInputTool(taskContext, config.VERYFRONT_API_URL),
+        load_skill: createLoadSkillTool(context, taskContext),
+        sleep: sleepTool,
+    };
+    if (options.allowDelegation !== false) {
+        tools.invoke_agent = createInvokeAgentTool(context, taskContext);
+    }
+    return tools;
+}
+function createProjectSteeringRefresh(context) {
+    return createDefaultHostedProjectSteeringRefresh({
+        fetchProjectInstructions: (lookup) => getProjectInstructions(context, lookup),
+        fetchSkills: (lookup) => getSkillsConfig(context, lookup),
+        buildInstructions: buildVeryfrontCloudRuntimeInstructions,
+        projectScopedRemoteToolOptions: {
+            projectNavigationToolNames: DEFAULT_PROJECT_NAVIGATION_TOOL_NAMES,
+        },
+        logger: context.infrastructure.logger,
+    });
+}
+function createAgentRuntime(context, options) {
+    const config = context.infrastructure.getConfig();
+    const refreshSystem = createProjectSteeringRefresh(context);
+    return createDefaultHostedChatRuntime({
+        options,
+        config: {
+            apiUrl: config.VERYFRONT_API_URL,
+            apiMcpUrl: config.VERYFRONT_MCP_URL,
+            studioMcpUrl: config.VERYFRONT_STUDIO_MCP_URL,
+        },
+        buildLocalTools: (taskContext) => buildLocalTools(context, options, taskContext),
+        refreshSystem,
+        onSteeringMutation: async ({ mutation, taskContext }) => {
+            if (mutation.skillsChanged) {
+                await refreshProjectSkillIds(context, {
+                    ...taskContext,
+                    authToken: taskContext.authToken,
+                });
+            }
+        },
+        onStudioProjectSwitch: async ({ projectId, taskContext }) => {
+            if (!applyAgentProjectContextChange(taskContext, projectId)) {
+                return false;
+            }
+            await refreshProjectSkillIds(context, {
+                ...taskContext,
+                authToken: taskContext.authToken,
+            });
+            return true;
+        },
+        projectScopedRemoteToolOptions: {
+            projectNavigationToolNames: DEFAULT_PROJECT_NAVIGATION_TOOL_NAMES,
+        },
+        createRemoteToolSource: createRemoteMCPToolSource,
+        traceLocalTools: {
+            trace: (spanName, operation) => context.infrastructure.tracer.trace(spanName, operation),
+            buildAttributes: ({ toolName, toolCallId }) => buildExecuteToolTraceAttributes({
+                toolName,
+                toolCallId,
+            }),
+            setAttributes: (attributes) => setFilteredTraceAttributes(context, attributes),
+        },
+        logger: context.infrastructure.logger,
+    });
+}
+function setPrepareChatExecutionStartAttributes(context, input) {
+    const span = context.infrastructure.tracer.scope().active();
+    span?.setAttributes({
+        "chat.projectId": input.projectId ?? "none",
+        "chat.userId": input.userId,
+    });
+}
+function setPrepareChatExecutionResultAttributes(context, input) {
+    const span = context.infrastructure.tracer.scope().active();
+    span?.setAttributes(buildAgentRunTraceAttributes({
+        operationName: "chat",
+        conversationId: input.conversationId,
+        projectId: input.projectId,
+        userId: input.userId,
+        agentId: input.agentId,
+        runId: input.runId,
+        parentConversationId: input.upstreamParentConversationId,
+        parentRunId: input.upstreamParentRunId,
+        toolCallId: input.spawnedFromToolCallId,
+    }));
+    span?.setAttributes({
+        "agent.runtime.kind": input.runtimeKind,
+    });
+}
+function fetchProjectSteering(context, input) {
+    return fetchDefaultHostedProjectSteering({
+        ...input,
+        fetchProjectInstructions: (lookup) => getProjectInstructions(context, lookup),
+        fetchSkills: (lookup) => getSkillsConfig(context, lookup),
+        trace: context.trace,
+        traceOperationName: "chat.fetchSteering",
+    });
+}
+async function prepareChatExecution(context, req) {
+    const { userId, authToken, projectId, conversationId, upstreamParentConversationId, upstreamParentRunId, spawnedFromToolCallId, } = req;
+    const config = context.infrastructure.getConfig();
+    setPrepareChatExecutionStartAttributes(context, { projectId, userId });
+    const agentConfig = getResolvedAgentConfig(context);
+    const { effectiveMessages, rootRunContext, runtime: { agent, runtimeKind, modelId, cleanup }, finalMessages, } = await prepareVeryfrontCloudHostedChatExecution({
+        request: req,
+        agentConfig,
+        apiUrl: config.VERYFRONT_API_URL,
+        abortSignal: new AbortController().signal,
+        logger: context.infrastructure.logger,
+        rootRun: {
+            instrumentation: {
+                trace: context.trace,
+                setTraceAttributes: context.infrastructure.setActiveSpanAttributes,
+                debug: (message, metadata) => context.infrastructure.logger.debug(message, metadata),
+                warn: (message, metadata) => context.infrastructure.logger.warn(message, metadata),
+                error: (message, metadata) => context.infrastructure.logger.error(message, metadata),
+            },
+        },
+        fetchSteering: (steeringInput) => fetchProjectSteering(context, steeringInput),
+        buildInstructions: buildVeryfrontCloudRuntimeInstructions,
+        createRuntime: (creationOptions) => context.trace("chat.createRuntime", () => createAgentRuntime(context, {
+            ...creationOptions,
+            userId: req.userId,
+        })),
+    });
+    setPrepareChatExecutionResultAttributes(context, {
+        conversationId,
+        projectId,
+        userId,
+        agentId: agentConfig.id,
+        runId: rootRunContext.durableRootRun?.runId,
+        upstreamParentConversationId,
+        upstreamParentRunId,
+        spawnedFromToolCallId,
+        runtimeKind,
+    });
+    return {
+        config,
+        agent,
+        agentId: agentConfig.id,
+        runtimeKind,
+        modelId,
+        cleanup,
+        messages: effectiveMessages,
+        finalMessages,
+        conversationId,
+        authToken,
+        projectId,
+        userId,
+        rootRunContext,
+        upstreamParentConversationId,
+        upstreamParentRunId,
+        spawnedFromToolCallId,
+    };
+}
+function createPreparedExecutionRuntimeOptions(context, config) {
+    return createVeryfrontCloudPreparedHostedChatExecutionRuntimeOptions({
+        apiUrl: config.VERYFRONT_API_URL,
+        tracer: context.infrastructure.tracer,
+        trace: context.trace,
+        traceStream: (operation) => context.infrastructure.tracer.trace("chat.stream", operation),
+        logger: context.infrastructure.logger,
+        setActiveSpanAttributes: context.infrastructure.setActiveSpanAttributes,
+    });
+}
+function createNodeVeryfrontCloudAgentServiceRuntimeOptions(context) {
+    return {
+        serviceName: context.options.serviceName,
+        forwardedConfigNamespace: context.options.forwardedConfigNamespace ??
+            DEFAULT_FORWARDED_CONFIG_NAMESPACE,
+        getConfig: context.infrastructure.getConfig,
+        getAgentConfig: () => getResolvedAgentConfig(context),
+        tracker: context.tracker,
+        prepareExecution: (request) => prepareChatExecution(context, request),
+        streamExecutionToAgUiResponse: (execution) => streamPreparedHostedChatExecutionToAgUiResponse({
+            execution,
+            runtime: createPreparedExecutionRuntimeOptions(context, execution.config),
+        }),
+        startDetachedExecution: ({ execution, abortSignal }) => runPreparedHostedChatExecutionDetached({
+            execution: {
+                ...execution,
+                abortSignal,
+            },
+            runtime: createPreparedExecutionRuntimeOptions(context, execution.config),
+        }),
+        cleanupExecution: async ({ execution, runId, conversationId }) => {
+            await execution.cleanup().catch((error) => {
+                context.infrastructure.logger.error("Detached durable run cleanup failed after duplicate start", {
+                    runId,
+                    conversationId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        },
+        setActiveSpanAttributes: context.infrastructure.setActiveSpanAttributes,
+        trace: context.trace,
+        logger: context.infrastructure.logger,
+        drainTimeoutMs: context.options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS,
+    };
+}
+export async function createNodeVeryfrontCloudAgentServiceRuntime(options) {
+    const context = createNodeVeryfrontCloudAgentServiceContext(options);
+    await initializeNodeVeryfrontCloudAgentServiceContext(context);
+    return createAgentServiceRuntime(createNodeVeryfrontCloudAgentServiceRuntimeOptions(context));
+}
+export async function startNodeVeryfrontCloudAgentService(options) {
+    const context = createNodeVeryfrontCloudAgentServiceContext(options);
+    await initializeNodeVeryfrontCloudAgentServiceContext(context);
+    return await startNodeAgentService({
+        ...createNodeVeryfrontCloudAgentServiceRuntimeOptions(context),
+        hardShutdownTimeoutMs: options.hardShutdownTimeoutMs ?? DEFAULT_HARD_SHUTDOWN_TIMEOUT_MS,
+    });
+}
+export async function runNodeVeryfrontCloudAgentServiceMain(options) {
+    const processTarget = options.processTarget ?? resolveDefaultProcessTarget();
+    let getRuntimeTraceContext = () => ({});
+    await loadAgentServiceEnvFiles();
+    const context = createNodeVeryfrontCloudAgentServiceContext({
+        ...options,
+        processTarget,
+    });
+    getRuntimeTraceContext = context.infrastructure.getTraceContext;
+    await initializeNodeVeryfrontCloudAgentServiceContext(context);
+    await runAgentServiceMain({
+        loadLogger: () => context.infrastructure.logger,
+        initializeTelemetry: async () => {
+            return await context.infrastructure.initializeOpenTelemetry().catch((error) => {
+                console.error("Failed to initialize OpenTelemetry:", error);
+                return false;
+            });
+        },
+        onTelemetryInitialized: () => {
+            console.log("OpenTelemetry initialized successfully");
+        },
+        getTraceContext: () => getRuntimeTraceContext(),
+        registerTraceContextGetter: (getter) => {
+            __registerTraceContextGetter(getter);
+        },
+        start: async () => {
+            await startNodeAgentService({
+                ...createNodeVeryfrontCloudAgentServiceRuntimeOptions(context),
+                hardShutdownTimeoutMs: options.hardShutdownTimeoutMs ?? DEFAULT_HARD_SHUTDOWN_TIMEOUT_MS,
+            });
+        },
+        onStartupError: (error) => {
+            console.error("Error in server startup:", error);
+        },
+        exit: processTarget?.exit,
+        processTarget,
+    });
+}

package/esm/src/config/schemas/config.schema.d.ts

@@ -297,6 +297,30 @@ export declare const veryfrontConfigSchema: z.ZodObject<{
                 paths: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>>;
+        resources: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            discovery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                paths: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        prompts: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            discovery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                paths: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        workflows: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            discovery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                paths: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        tasks: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            discovery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                paths: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
         mcp: z.ZodOptional<z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
             port: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;

package/esm/src/config/schemas/config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../../../src/src/config/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyBxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwhBtB,CAAC;AAGb,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGzE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAyBvE;AAQD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAEhF"}
+{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../../../src/src/config/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyBxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwkBtB,CAAC;AAGb,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGzE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAyBvE;AAQD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAEhF"}

package/esm/src/config/schemas/config.schema.js

@@ -418,6 +418,54 @@ export const veryfrontConfigSchema = z
         })
             .partial()
             .optional(),
+        resources: z
+            .object({
+            discovery: z
+                .object({
+                enabled: z.boolean().optional(),
+                paths: z.array(z.string()).optional(),
+            })
+                .partial()
+                .optional(),
+        })
+            .partial()
+            .optional(),
+        prompts: z
+            .object({
+            discovery: z
+                .object({
+                enabled: z.boolean().optional(),
+                paths: z.array(z.string()).optional(),
+            })
+                .partial()
+                .optional(),
+        })
+            .partial()
+            .optional(),
+        workflows: z
+            .object({
+            discovery: z
+                .object({
+                enabled: z.boolean().optional(),
+                paths: z.array(z.string()).optional(),
+            })
+                .partial()
+                .optional(),
+        })
+            .partial()
+            .optional(),
+        tasks: z
+            .object({
+            discovery: z
+                .object({
+                enabled: z.boolean().optional(),
+                paths: z.array(z.string()).optional(),
+            })
+                .partial()
+                .optional(),
+        })
+            .partial()
+            .optional(),
         mcp: z
             .object({
             enabled: z.boolean().optional(),

package/esm/src/discovery/index.d.ts

@@ -10,6 +10,7 @@
  */
 export type { DiscoveryConfig, DiscoveryHandler, DiscoveryResult, FileDiscoveryContext, } from "./types.js";
 export { discoverAll } from "./discovery-engine.js";
+export { createProjectDiscoveryConfig, DEFAULT_PROJECT_DISCOVERY_DIRS, } from "./project-discovery-config.js";
 export { clearTrackedAgents, filenameToId, filePathToPattern } from "./discovery-utils.js";
 export { clearTranspileCache } from "./transpiler.js";
 export { validateProviderConfig, type ValidationResult } from "./provider-config-validator.js";

package/esm/src/discovery/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}

package/esm/src/discovery/index.js

@@ -10,6 +10,7 @@
  */
 // Re-export main discovery function
 export { discoverAll } from "./discovery-engine.js";
+export { createProjectDiscoveryConfig, DEFAULT_PROJECT_DISCOVERY_DIRS, } from "./project-discovery-config.js";
 // Re-export utilities
 export { clearTrackedAgents, filenameToId, filePathToPattern } from "./discovery-utils.js";
 // Re-export transpiler utilities

package/esm/src/discovery/project-discovery-config.d.ts

@@ -0,0 +1,30 @@
+import type { VeryfrontConfig } from "../config/index.js";
+import type { FileSystemAdapter } from "../platform/adapters/base.js";
+import type { DiscoveryConfig } from "./types.js";
+export declare const DEFAULT_PROJECT_DISCOVERY_DIRS: {
+    toolDirs: string[];
+    agentDirs: string[];
+    skillDirs: string[];
+    resourceDirs: string[];
+    promptDirs: string[];
+    workflowDirs: string[];
+    taskDirs: string[];
+};
+type ProjectDiscoveryConfigInput = {
+    projectDir: string;
+    config?: VeryfrontConfig | null;
+    fsAdapter?: FileSystemAdapter;
+    verbose?: boolean;
+};
+export type ProjectDiscoveryConfig = DiscoveryConfig & {
+    toolDirs: string[];
+    agentDirs: string[];
+    skillDirs: string[];
+    resourceDirs: string[];
+    promptDirs: string[];
+    workflowDirs: string[];
+    taskDirs: string[];
+};
+export declare function createProjectDiscoveryConfig(input: ProjectDiscoveryConfigInput): ProjectDiscoveryConfig;
+export {};
+//# sourceMappingURL=project-discovery-config.d.ts.map

package/esm/src/discovery/project-discovery-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-discovery-config.d.ts","sourceRoot":"","sources":["../../../src/src/discovery/project-discovery-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,8BAA8B;;;;;;;;CAQ1C,CAAC;AAOF,KAAK,2BAA2B,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAChC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG;IACrD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAgBF,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,2BAA2B,GACjC,sBAAsB,CAoCxB"}

package/esm/src/discovery/project-discovery-config.js

@@ -0,0 +1,33 @@
+export const DEFAULT_PROJECT_DISCOVERY_DIRS = {
+    toolDirs: ["tools"],
+    agentDirs: ["agents"],
+    skillDirs: ["skills"],
+    resourceDirs: ["resources"],
+    promptDirs: ["prompts"],
+    workflowDirs: ["workflows"],
+    taskDirs: ["tasks"],
+};
+function isDiscoveryEnabled(discovery) {
+    return discovery?.enabled ?? true;
+}
+function resolveDiscoveryPaths(discovery, defaultPaths) {
+    if (!isDiscoveryEnabled(discovery)) {
+        return [];
+    }
+    return discovery?.paths ?? defaultPaths;
+}
+export function createProjectDiscoveryConfig(input) {
+    const aiConfig = input.config?.ai;
+    return {
+        baseDir: input.projectDir,
+        toolDirs: resolveDiscoveryPaths(aiConfig?.tools?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.toolDirs),
+        agentDirs: resolveDiscoveryPaths(aiConfig?.agents?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.agentDirs),
+        skillDirs: resolveDiscoveryPaths(aiConfig?.skills?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.skillDirs),
+        resourceDirs: resolveDiscoveryPaths(aiConfig?.resources?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.resourceDirs),
+        promptDirs: resolveDiscoveryPaths(aiConfig?.prompts?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.promptDirs),
+        workflowDirs: resolveDiscoveryPaths(aiConfig?.workflows?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.workflowDirs),
+        taskDirs: resolveDiscoveryPaths(aiConfig?.tasks?.discovery, DEFAULT_PROJECT_DISCOVERY_DIRS.taskDirs),
+        fsAdapter: input.fsAdapter,
+        verbose: input.verbose ?? false,
+    };
+}

package/esm/src/server/handlers/request/api/project-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-discovery.d.ts","sourceRoot":"","sources":["../../../../../../src/src/server/handlers/request/api/project-discovery.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAuErD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAmE/E"}
+{"version":3,"file":"project-discovery.d.ts","sourceRoot":"","sources":["../../../../../../src/src/server/handlers/request/api/project-discovery.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AA8CrD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAuE/E"}