veryfront 0.1.1122 → 0.1.1124

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

@@ -1,52 +1,14 @@
-import * as dntShim from "../../../_dnt.shims.js";
-import { existsSync, readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { createAgentServiceSandboxTools } from "../../sandbox/index.js";
-import { register, tryResolve } from "../../extensions/contracts.js";
-import { MISSING_EXTENSION_ERROR } from "../../extensions/errors.js";
-import { importFirstPartyExtensionModule, isMissingFirstPartyExtensionModule, } from "../../extensions/first-party-import.js";
-import { dirname, resolve } from "../../platform/compat/path/index.js";
-import { cwd, env, getEnv } from "../../platform/compat/process.js";
-import { defineSchema } from "../../schemas/index.js";
-import { NodeTelemetryProviderName, } from "../../extensions/observability/index.js";
-import { SandboxShellToolsProviderName, } from "../../extensions/sandbox/index.js";
-import { createRemoteMCPToolSource, createToolsFromRemoteDefinitions, isToolVisibleTo, sleepTool, toolRegistry, } from "../../tool/index.js";
-import { SKILL_TOOL_IDS } from "../../skill/types.js";
-import { parseProviderError } from "../../chat/provider-errors.js";
-import { DEFAULT_PROJECT_DISCOVERY_DIRS } from "../../discovery/index.js";
-import { nodeAdapter } from "../../platform/adapters/node.js";
-import { getVeryfrontCloudProviderFromModelId, resolveVeryfrontCloudModelId, resolveVeryfrontCloudModelThinking, resolveVeryfrontCloudReasoningOption, resolveVeryfrontCloudThinkingProviderOptions, } from "../../provider/veryfront-cloud/model-catalog.js";
-import { __registerTraceContextGetter } from "../../utils/logger/logger.js";
-import { AGENT_NOT_FOUND, CONFIG_INVALID, INITIALIZATION_ERROR } from "../../errors/index.js";
 import { agentLogger } from "../../utils/index.js";
-import { buildAgentRunTraceAttributes, buildExecuteToolTraceAttributes, buildProjectServiceTraceAttributes, buildScheduleTraceAttributes, filterAgentTraceAttributes, } from "./trace-attributes.js";
+import { __registerTraceContextGetter } from "../../utils/logger/logger.js";
 import { runAgentServiceMain, } from "../service/bootstrap.js";
 import { loadAgentServiceEnvFiles } from "../service/env-files.js";
-import { createHostedFormInputTool } from "./form-input-tool.js";
-import { createHostedWebFetchTool } from "./web-fetch-tool.js";
-import { createHostedAgentProjectSteering, } from "./agent-project-steering.js";
-import { createLiveStudioMcpTools } from "../project/live-studio-mcp-tools.js";
-import { createDefaultHostedChatRuntime, } from "./default-chat-runtime.js";
-import { createHostedRootLocalToolRuntime } from "./root-sandbox-tool-source.js";
-import { createVeryfrontCloudContextSummaryGenerator } from "./context-summary-generator.js";
-import { createDefaultHostedInvokeAgentTool } from "./default-invoke-agent-tool.js";
-import { createDefaultHostedProjectSteeringRefresh, fetchDefaultHostedProjectSteering, } from "./default-project-steering-refresh.js";
-import { defaultAgentServiceMcpServers, } from "../service/mcp-server-config.js";
-import { resolveRuntimeSkillsForAgent, } from "../runtime/skill-metadata.js";
-import { buildAgentDelegateTools } from "../runtime/agent-delegation.js";
-import { createRuntimeAgentDefinitionFromAgent, describeProjectAgentRuntimeAgentIdCandidates, discoverProjectAgentRuntime, doesProjectAgentRuntimeAgentMatchSource, getProjectAgentRuntimeAgentIdCandidates, resolveSingleProjectAgentRuntimeAgentId, runWithProjectAgentRuntime, } from "../project/agent-runtime.js";
-import { buildVeryfrontCloudRuntimeInstructions } from "./cloud-runtime-system-messages.js";
-import { flattenSystemInstructions } from "../runtime/tool-inventory.js";
-import { createNodeAgentServiceRuntimeInfrastructure, } from "../service/node-runtime-infrastructure.js";
 import { createAgentServiceRuntime, startAgentServiceRuntime, startNodeAgentService, } from "../service/runtime.js";
-import { createAgentServiceRegistrationLifecycle, resolveAgentServiceRegistrationInput, } from "../service/registration.js";
-import { createDetachedRunTracker } from "../service/detached-run-tracker.js";
-import { runPreparedHostedChatExecutionDetached, streamPreparedHostedChatExecutionToAgUiResponse, } from "./prepared-chat-execution.js";
-import { createVeryfrontCloudPreparedHostedChatExecutionRuntimeOptions, } from "./cloud-prepared-chat-execution-runtime.js";
-import { prepareVeryfrontCloudHostedChatExecution } from "./cloud-chat-execution-preparation.js";
-import { applyAgentProjectContextChange } from "../project/context.js";
-import { getRuntimeAgentSourceContextSchema } from "../runtime/agent-invocation-contract.js";
-import { snapshotHostedRuntimeSourceIdentity, } from "./runtime-source-binding.js";
+import { resolveDefaultProcessTarget } from "./cloud-agent-paths.js";
+import { resolveNodeVeryfrontCloudAgentServiceOptions } from "./cloud-agent-provider-bootstrap.js";
+import { createNodeVeryfrontCloudAgentServiceContext, initializeNodeVeryfrontCloudAgentServiceContext, } from "./cloud-agent-config.js";
+import { buildHostedChildToolContext, getDiscoveredHostTools, resolveHostedChildAgentExecutionConfig, resolveHostedChildToolNames, resolveHostedDelegationBinding, resolveMcpServers, } from "./cloud-agent-child-tools.js";
+import { createControlPlaneRegistrationLifecycle, createNodeVeryfrontCloudAgentServiceRuntimeOptions, } from "./cloud-agent-chat-execution.js";
+const DEFAULT_HARD_SHUTDOWN_TIMEOUT_MS = 20_000;
 /** Veryfront API MCP server helper. */
 export function veryfrontApiMcpServer() {
     return { kind: "veryfront-api" };
@@ -55,432 +17,7 @@ export function veryfrontApiMcpServer() {
 export function veryfrontStudioMcpServer() {
     return { kind: "veryfront-studio" };
 }
-const DEFAULT_FORWARDED_CONFIG_NAMESPACE = "veryfront";
-const DEFAULT_DRAIN_TIMEOUT_MS = 15_000;
-const DEFAULT_HARD_SHUTDOWN_TIMEOUT_MS = 20_000;
-const DEFAULT_AGENT_SERVICE_NAME = "veryfront-agent-service";
-const DEFAULT_PROJECT_NAVIGATION_TOOL_NAMES = ["studio_open_project"];
-const HOSTED_CHILD_LOCAL_SKILL_TOOL_NAMES = new Set([
-    "execute_skill_script",
-    "load_skill_reference",
-]);
-const PROJECT_CONFIG_FILES = [
-    "veryfront.config.js",
-    "veryfront.config.ts",
-    "veryfront.config.mjs",
-];
-function pathOptionToPath(pathOption) {
-    return pathOption instanceof URL ? fileURLToPath(pathOption) : pathOption;
-}
-function resolveBaseDir(options) {
-    if (options.baseDir !== undefined) {
-        return pathOptionToPath(options.baseDir);
-    }
-    if (options.entrypointUrl !== undefined) {
-        return dirname(pathOptionToPath(options.entrypointUrl));
-    }
-    return 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;
-}
-/**
- * Schema for the subset of a project manifest (package.json / deno.json) we
- * read. Only `name` is consumed; extra fields are tolerated via passthrough so
- * arbitrary manifests validate. Defined lazily via `defineSchema` so the zod
- * extension is resolved at call time — the cloud-agent options resolver calls
- * `ensureDefaultSchemaValidator()` before reaching service-name resolution, so
- * a validator is registered by the time this runs.
- */
-const getProjectManifestSchema = defineSchema((v) => v.object({
-    name: v.string().optional(),
-}).passthrough());
-function readProjectManifestName(projectDir) {
-    const manifestSchema = getProjectManifestSchema();
-    for (const fileName of ["package.json", "deno.json"]) {
-        const filePath = resolve(projectDir, fileName);
-        if (!existsSync(filePath)) {
-            continue;
-        }
-        try {
-            const result = manifestSchema.safeParse(JSON.parse(readFileSync(filePath, "utf8")));
-            if (!result.success)
-                continue;
-            const name = result.data.name;
-            if (typeof name !== "string")
-                continue;
-            const trimmedName = name.trim();
-            if (trimmedName)
-                return trimmedName;
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-function resolveServiceName(options) {
-    if (options.serviceName?.trim()) {
-        return options.serviceName.trim();
-    }
-    const env = resolveEnvironment(options);
-    const envServiceName = env.VERYFRONT_AGENT_SERVICE_NAME?.trim();
-    if (envServiceName) {
-        return envServiceName;
-    }
-    return readProjectManifestName(resolveProjectDir(options)) ?? DEFAULT_AGENT_SERVICE_NAME;
-}
-function resolveDefaultProcessTarget() {
-    if (typeof process === "undefined") {
-        return undefined;
-    }
-    return process;
-}
-function resolveMcpServers(options, agentConfig) {
-    if (options.mcpServers !== undefined) {
-        if (agentConfig?.mcpServers === undefined) {
-            return options.mcpServers;
-        }
-        return agentConfig.mcpServers.flatMap((agentServer) => {
-            const hostServer = options.mcpServers?.find((server) => server.kind === agentServer.kind && server.id === agentServer.id);
-            if (!hostServer) {
-                return [];
-            }
-            const toolPolicy = mergeMcpToolPolicies(hostServer.toolPolicy, agentServer.toolPolicy);
-            return [{
-                    ...hostServer,
-                    ...(toolPolicy === undefined ? {} : { toolPolicy }),
-                }];
-        });
-    }
-    if (agentConfig?.mcpServers !== undefined) {
-        return agentConfig.mcpServers;
-    }
-    return defaultAgentServiceMcpServers();
-}
-function mergeMcpToolPolicies(hostPolicy, agentPolicy) {
-    if (hostPolicy === undefined) {
-        return agentPolicy;
-    }
-    if (agentPolicy === undefined) {
-        return hostPolicy;
-    }
-    const allow = hostPolicy.allow === undefined
-        ? agentPolicy.allow
-        : agentPolicy.allow === undefined
-            ? hostPolicy.allow
-            : hostPolicy.allow.filter((toolName) => agentPolicy.allow?.includes(toolName));
-    const deny = [
-        ...new Set([
-            ...(hostPolicy.deny ?? []),
-            ...(agentPolicy.deny ?? []),
-        ]),
-    ];
-    const approval = hostPolicy.approval ?? agentPolicy.approval;
-    return {
-        ...(allow === undefined ? {} : { allow }),
-        ...(deny.length === 0 ? {} : { deny }),
-        ...(approval === undefined ? {} : { approval }),
-    };
-}
-async function loadDefaultCreateBashTool() {
-    const provider = tryResolve(SandboxShellToolsProviderName);
-    if (provider)
-        return provider;
-    try {
-        const { createBashSandboxShellToolsProvider } = await importFirstPartyExtensionModule("ext-sandbox-shell-tools", "@veryfront/ext-sandbox-shell-tools");
-        return createBashSandboxShellToolsProvider;
-    }
-    catch (error) {
-        throw MISSING_EXTENSION_ERROR.create({
-            message: 'Missing extension for contract "SandboxShellToolsProvider". Install @veryfront/ext-sandbox-shell-tools or pass createBashTool explicitly.',
-            detail: `Veryfront cloud agent sandbox shell tools require a SandboxShellToolsProvider implementation: ${error instanceof Error ? error.message : String(error)}`,
-        });
-    }
-}
-async function resolveNodeVeryfrontCloudAgentServiceOptions(options) {
-    await ensureDefaultSchemaValidator();
-    await ensureDefaultAuthProvider();
-    await ensureDefaultNodeTelemetryProvider();
-    return {
-        ...options,
-        runtimeSource: resolveHostedRuntimeSourceIdentity(options.runtimeSource),
-        serviceName: resolveServiceName(options),
-        createBashTool: options.createBashTool ?? await loadDefaultCreateBashTool(),
-    };
-}
-function resolveHostedRuntimeSourceIdentity(input) {
-    if (input === undefined)
-        return undefined;
-    const source = getRuntimeAgentSourceContextSchema().parse(input);
-    if (source.type === "branch") {
-        throw new Error("Agent service runtimeSource must identify an immutable release or environment source.");
-    }
-    return snapshotHostedRuntimeSourceIdentity(source);
-}
-async function ensureDefaultSchemaValidator() {
-    if (tryResolve("SchemaValidator"))
-        return;
-    const { createZodAdapter } = await import("../../../extensions/ext-schema-zod/src/adapter.js");
-    register("SchemaValidator", createZodAdapter());
-}
-async function ensureDefaultAuthProvider() {
-    if (tryResolve("AuthProvider"))
-        return;
-    const { createAuthProvider } = await importFirstPartyExtensionModule("ext-auth-jwt", "@veryfront/ext-auth-jwt");
-    register("AuthProvider", createAuthProvider({}));
-}
-async function ensureDefaultNodeTelemetryProvider() {
-    if (tryResolve(NodeTelemetryProviderName))
-        return;
-    const OpenTelemetryNodeTelemetryProvider = await importOpenTelemetryNodeTelemetryProvider();
-    if (!OpenTelemetryNodeTelemetryProvider)
-        return;
-    register(NodeTelemetryProviderName, new OpenTelemetryNodeTelemetryProvider());
-}
-async function importOpenTelemetryNodeTelemetryProvider() {
-    try {
-        const { OpenTelemetryNodeTelemetryProvider } = await importFirstPartyExtensionModule("ext-observability-opentelemetry", "@veryfront/ext-observability-opentelemetry");
-        return OpenTelemetryNodeTelemetryProvider;
-    }
-    catch (error) {
-        if (!isMissingOptionalPackageError(error) && !isMissingFirstPartyExtensionModule(error)) {
-            throw error;
-        }
-        return null;
-    }
-}
-// Runtime heuristic: detects a missing optional npm/Deno package by error message text.
-// These strings come from Node, Deno, and bundler runtimes and can vary by version.
-// If the wording changes, a missing optional package will throw instead of returning null,
-// turning an optional dependency into a hard startup failure — the safe fallback.
-function isMissingOptionalPackageError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("Cannot find package") ||
-        message.includes("Cannot find module") ||
-        message.includes("ERR_MODULE_NOT_FOUND") ||
-        message.includes("Module not found");
-}
-function resolveEnvironment(options) {
-    if (options.env) {
-        return options.env;
-    }
-    if (options.processTarget?.env) {
-        return options.processTarget.env;
-    }
-    return env();
-}
-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);
-    }
-    return {
-        options,
-        processTarget,
-        projectDir: resolveProjectDir(options),
-        infrastructure,
-        trace,
-        defaultAgentId: null,
-        projectSteeringByAgentId: new Map(),
-        tracker: createDetachedRunTracker(),
-        discoveryResult: null,
-        agentConfig: null,
-        agentConfigs: new Map(),
-    };
-}
-function getMarkdownAgentConfig(context, agentId) {
-    return getProjectSteering(context, agentId).getAgentConfig();
-}
-function loadMarkdownAgentConfig(context, agentId) {
-    return getMarkdownAgentConfig(context, agentId);
-}
-async function resolveAgentConfig(context, agentId) {
-    const cachedAgentConfig = context.agentConfigs.get(agentId);
-    if (cachedAgentConfig) {
-        return cachedAgentConfig;
-    }
-    const source = context.options.agentSource ?? "auto";
-    const codeAgent = getProjectAgentRuntime(context).agents.get(agentId);
-    if (codeAgent && doesProjectAgentRuntimeAgentMatchSource(codeAgent, source)) {
-        const agentConfig = await createRuntimeAgentDefinitionFromAgent(codeAgent);
-        context.agentConfigs.set(agentConfig.id, agentConfig);
-        return agentConfig;
-    }
-    if (source === "code") {
-        throw AGENT_NOT_FOUND.create({ detail: `Code agent "${agentId}" was not discovered.` });
-    }
-    const agentConfig = loadMarkdownAgentConfig(context, agentId);
-    context.agentConfigs.set(agentConfig.id, agentConfig);
-    return agentConfig;
-}
-function getResolvedAgentConfig(context) {
-    if (!context.agentConfig) {
-        throw INITIALIZATION_ERROR.create({
-            detail: "Agent service context has not been initialized.",
-        });
-    }
-    return context.agentConfig;
-}
-function getProjectAgentRuntime(context) {
-    if (!context.discoveryResult) {
-        throw new Error("Agent service context has not been initialized.");
-    }
-    return context.discoveryResult;
-}
-async function discoverProjectPrimitives(context) {
-    context.discoveryResult = await discoverProjectAgentRuntime({
-        projectDir: context.projectDir,
-        adapter: nodeAdapter,
-    });
-}
-function resolveDefaultAgentId(context) {
-    if (context.options.agentId) {
-        return context.options.agentId;
-    }
-    const source = context.options.agentSource ?? "auto";
-    const candidates = getProjectAgentRuntimeAgentIdCandidates(context.discoveryResult);
-    const agentId = resolveSingleProjectAgentRuntimeAgentId({ candidates, source });
-    if (agentId) {
-        return agentId;
-    }
-    throw CONFIG_INVALID.create({
-        detail: [
-            "agentId is required when agent discovery does not resolve to exactly one agent.",
-            `Discovered agents: ${describeProjectAgentRuntimeAgentIdCandidates(candidates)}.`,
-        ].join(" "),
-    });
-}
-async function initializeNodeVeryfrontCloudAgentServiceContext(context) {
-    await discoverProjectPrimitives(context);
-    context.defaultAgentId = resolveDefaultAgentId(context);
-    context.agentConfig = await resolveAgentConfig(context, context.defaultAgentId);
-}
-function getDefaultAgentId(context) {
-    if (!context.defaultAgentId) {
-        throw INITIALIZATION_ERROR.create({
-            detail: "Agent service context has not been initialized.",
-        });
-    }
-    return context.defaultAgentId;
-}
-function getProjectSteering(context, agentId = getDefaultAgentId(context)) {
-    const cachedProjectSteering = context.projectSteeringByAgentId.get(agentId);
-    if (cachedProjectSteering) {
-        return cachedProjectSteering;
-    }
-    const projectSteering = createHostedAgentProjectSteering({
-        baseDir: resolveBaseDir(context.options),
-        agentId,
-        getApiUrl: () => context.infrastructure.getConfig().VERYFRONT_API_URL,
-        logger: context.infrastructure.logger,
-        trace: context.trace,
-    });
-    context.projectSteeringByAgentId.set(agentId, projectSteering);
-    return projectSteering;
-}
-export function getDiscoveredHostTools(scope) {
-    // Without an agent identity, this remains the project-level host tool spread
-    // and matches MCP tools/list: project-level callers see only unowned tools.
-    // Hosted per-agent runs pass their task context identity so owned colocated
-    // tools are available to their owner and hidden from other agents.
-    // Shared skill tools use local registry and filesystem state. Hosted runs
-    // instead add the request-scoped load_skill tool below; its optional file
-    // input reads references with project, branch, auth, and owner context.
-    // Hosted runs do not execute skill scripts directly.
-    return Object.fromEntries([...toolRegistry.getAll()]
-        .filter(([toolId, registryTool]) => !SKILL_TOOL_IDS.has(toolId) && isToolVisibleTo(registryTool, scope))
-        .sort(([left], [right]) => left.localeCompare(right)));
-}
-function getProjectInstructions(context, lookup, agentId) {
-    return context.trace("chat.getProjectInstructions", async () => {
-        return await getProjectSteering(context, agentId).getProjectInstructions(lookup);
-    });
-}
-function getSkillsConfig(context, lookup, agentId) {
-    return context.trace("chat.getSkillsConfig", async () => {
-        return await getProjectSteering(context, agentId).getSkillsConfig(lookup);
-    });
-}
-function createLoadSkillTool(context, toolContext) {
-    return getProjectSteering(context, toolContext.agentId).createLoadSkillTool(toolContext);
-}
-async function refreshProjectSkillIds(context, skillContext) {
-    await getProjectSteering(context, skillContext.agentId).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,
-        mcpServers: resolveMcpServers(context.options),
-        enableDurableInvokeAgent: config.VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT,
-    };
-}
-function shouldRethrowInvokeAgentError(error) {
-    return parseProviderError(error).code === "INSUFFICIENT_CREDITS";
-}
-function resolveHostedChildToolNames(agentConfig) {
-    if (agentConfig.tools === true) {
-        return undefined;
-    }
-    return [
-        ...new Set([
-            ...(agentConfig.tools ?? []).filter((toolName) => !HOSTED_CHILD_LOCAL_SKILL_TOOL_NAMES.has(toolName)),
-            ...(agentConfig.providerTools ?? []),
-            ...(agentConfig.delegates ?? []).map((id) => `agent_${id}`),
-            "load_skill",
-        ]),
-    ];
-}
-function buildHostedChildToolContext(globalToolContext, childAgentId, childConfig, durableChildRun) {
-    return {
-        ...globalToolContext,
-        agentId: childAgentId,
-        ...(childConfig?.availableSkillIds ? { availableSkillIds: childConfig.availableSkillIds } : {}),
-        ...(childConfig?.skillSourcePaths ? { skillSourcePaths: childConfig.skillSourcePaths } : {}),
-        ...(childConfig?.toolNames ? { availableToolNames: childConfig.toolNames } : {}),
-        loadedSkillResponses: {},
-        loadedSkillReferenceResponses: {},
-        ...(durableChildRun
-            ? {
-                conversationId: durableChildRun.childConversationId,
-                parentRunId: durableChildRun.childRunId,
-                parentMessageId: durableChildRun.childMessageId,
-            }
-            : {}),
-    };
-}
+export { getDiscoveredHostTools };
 /** Internal test seams for hosted project-agent materialization. */
 export const veryfrontCloudAgentServiceInternals = {
     buildHostedChildToolContext,
@@ -489,436 +26,6 @@ export const veryfrontCloudAgentServiceInternals = {
     resolveHostedChildToolNames,
     resolveMcpServers,
 };
-async function resolveHostedChildAgentExecutionConfig(context, taskContext, childAgentId, projectId) {
-    if (!getProjectAgentRuntime(context).agents.has(childAgentId)) {
-        return undefined;
-    }
-    const agentConfig = await resolveAgentConfig(context, childAgentId);
-    const branchId = projectId === taskContext.projectId ? taskContext.branchId : null;
-    const steering = await fetchProjectSteering(context, {
-        projectId: projectId || null,
-        authToken: taskContext.authToken,
-        branchId,
-    }, childAgentId);
-    const advertisedSkills = resolveRuntimeSkillsForAgent({
-        skills: steering.skills,
-        agentId: childAgentId,
-        selector: agentConfig.skills,
-    });
-    const loadableSkills = resolveRuntimeSkillsForAgent({
-        skills: steering.skills,
-        agentId: childAgentId,
-        selector: true,
-    });
-    const skillSourcePaths = Object.fromEntries(loadableSkills
-        .filter((skill) => skill.sourcePath)
-        .map((skill) => [skill.id, skill.sourcePath]));
-    const toolNames = resolveHostedChildToolNames(agentConfig);
-    const thinking = agentConfig.thinking?.enabled === false ? 0 : agentConfig.thinking?.budgetTokens;
-    return {
-        system: flattenSystemInstructions(buildVeryfrontCloudRuntimeInstructions({
-            agentConfig,
-            projectId: projectId || null,
-            branchId,
-            instructions: steering.instructions,
-            skills: advertisedSkills,
-            availableToolNames: toolNames,
-        })),
-        ...(agentConfig.model ? { model: agentConfig.model } : {}),
-        ...(agentConfig.temperature === undefined ? {} : { temperature: agentConfig.temperature }),
-        ...(agentConfig.maxSteps === undefined ? {} : { maxSteps: agentConfig.maxSteps }),
-        ...(thinking === undefined ? {} : { thinking }),
-        ...(toolNames === undefined ? {} : { toolNames }),
-        mcpServers: resolveMcpServers(context.options, agentConfig),
-        availableSkillIds: loadableSkills.map((skill) => skill.id),
-        ...(Object.keys(skillSourcePaths).length > 0 ? { skillSourcePaths } : {}),
-        ...(agentConfig.delegates === undefined ? {} : { delegateIds: agentConfig.delegates }),
-    };
-}
-function createInvokeAgentTool(context, childContext, options) {
-    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,
-        resolveModelThinking: resolveVeryfrontCloudModelThinking,
-        resolveProviderOptions: resolveVeryfrontCloudThinkingProviderOptions,
-        resolveReasoning: resolveVeryfrontCloudReasoningOption,
-        shouldRethrowError: shouldRethrowInvokeAgentError,
-        buildGlobalTools: (globalToolContext, childAgentId, childConfig, durableChildRun) => {
-            const childToolContext = buildHostedChildToolContext(globalToolContext, childAgentId, childConfig, durableChildRun);
-            return {
-                ...(childConfig ? getDiscoveredHostTools({ agentId: childAgentId }) : {}),
-                load_skill: createLoadSkillTool(context, childToolContext),
-                ...(childConfig?.delegateIds?.length
-                    ? buildHostedDelegateTools(context, {
-                        delegates: childConfig.delegateIds,
-                        selfId: childAgentId,
-                        taskContext: childToolContext,
-                    })
-                    : {}),
-            };
-        },
-        resolveChildAgentExecutionConfig: (childAgentId, projectId) => resolveHostedChildAgentExecutionConfig(context, childContext, childAgentId, projectId),
-        refreshProjectSkillIds: (projectSkillContext) => refreshProjectSkillIds(context, projectSkillContext),
-        createAgentServiceSandboxTools,
-        createLiveStudioTools: createLiveStudioMcpTools,
-        createRemoteToolSource: createRemoteMCPToolSource,
-        createToolsFromRemoteDefinitions,
-        requireDurableInvokeAgent: options?.requireDurable,
-    });
-}
-function buildHostedDelegateTools(context, input) {
-    const invokeAgent = createInvokeAgentTool(context, input.taskContext, { requireDurable: true });
-    return buildAgentDelegateTools({
-        delegates: input.delegates,
-        selfId: input.selfId,
-        resolveAgent: (delegateId) => getProjectAgentRuntime(context).agents.get(delegateId),
-        executeDelegate: ({ delegateId, toolInput, context: executionContext }) => invokeAgent.execute({
-            agent_id: delegateId,
-            description: `Run ${delegateId} specialist task`,
-            prompt: toolInput.input,
-        }, executionContext),
-    });
-}
-function resolveHostedDelegationBinding(agentConfig) {
-    if (agentConfig?.delegates !== undefined) {
-        return { kind: "scoped", delegateIds: agentConfig.delegates };
-    }
-    return { kind: "legacy" };
-}
-function buildLocalTools(context, options, taskContext) {
-    const config = context.infrastructure.getConfig();
-    const tools = {
-        ...getDiscoveredHostTools({ agentId: taskContext.agentId }),
-        form_input: createHostedFormInputTool(taskContext, config.VERYFRONT_API_URL),
-        load_skill: createLoadSkillTool(context, taskContext),
-        sleep: sleepTool,
-        web_fetch: createHostedWebFetchTool(),
-    };
-    if (options.allowDelegation !== false) {
-        const agentConfig = options.liveProjectSteering?.agent;
-        const binding = resolveHostedDelegationBinding(agentConfig);
-        if (binding.kind === "scoped") {
-            Object.assign(tools, buildHostedDelegateTools(context, {
-                delegates: binding.delegateIds,
-                selfId: agentConfig?.id ?? taskContext.agentId ?? "veryfront",
-                taskContext,
-            }));
-        }
-        else {
-            // Agents authored before declarative delegates retain the legacy hosted
-            // child-fork tool. Explicit scoped delegate bindings opt out.
-            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 projectRuntime = getProjectAgentRuntime(context);
-    const refreshSystem = createProjectSteeringRefresh(context);
-    const localToolRuntime = createHostedRootLocalToolRuntime({
-        allowedToolNames: options.allowedTools,
-        apiUrl: config.VERYFRONT_API_URL,
-        authToken: options.authToken,
-        createBashTool: context.options.createBashTool,
-        buildBaseTools: (taskContext) => buildLocalTools(context, options, taskContext),
-    });
-    return createDefaultHostedChatRuntime({
-        options,
-        sourceIntegrationPolicy: projectRuntime.sourceIntegrationPolicy,
-        config: {
-            apiUrl: config.VERYFRONT_API_URL,
-            apiMcpUrl: config.VERYFRONT_MCP_URL,
-            studioMcpUrl: config.VERYFRONT_STUDIO_MCP_URL,
-            mcpServers: resolveMcpServers(context.options, options.liveProjectSteering?.agent),
-        },
-        buildLocalTools: localToolRuntime.buildLocalTools,
-        cleanup: localToolRuntime.cleanup,
-        refreshSystem,
-        onSteeringMutation: async ({ mutation, taskContext }) => {
-            if (mutation.skillsChanged) {
-                // Pass the live task context (not a spread copy) so the refreshed
-                // owner-scoped skill ids and source paths actually land on the run.
-                await refreshProjectSkillIds(context, taskContext);
-            }
-        },
-        onStudioProjectSwitch: async ({ projectId, taskContext }) => {
-            if (!applyAgentProjectContextChange(taskContext, projectId)) {
-                return false;
-            }
-            await refreshProjectSkillIds(context, taskContext);
-            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 scheduleTraceAttributes = buildScheduleTraceAttributes(input.forwardedProps);
-    const span = context.infrastructure.tracer.scope().active();
-    span?.setAttributes(buildAgentRunTraceAttributes({
-        operationName: "invoke_agent",
-        conversationId: input.conversationId,
-        projectId: input.projectId,
-        userId: input.userId,
-        agentId: input.agentId,
-        agentName: input.agentName,
-        modelId: input.modelId,
-        runId: input.runId,
-        parentConversationId: input.upstreamParentConversationId,
-        parentRunId: input.upstreamParentRunId,
-        toolCallId: input.spawnedFromToolCallId,
-        scheduleId: typeof scheduleTraceAttributes["schedule.id"] === "string"
-            ? scheduleTraceAttributes["schedule.id"]
-            : null,
-        scheduleName: typeof scheduleTraceAttributes["schedule.name"] === "string"
-            ? scheduleTraceAttributes["schedule.name"]
-            : null,
-    }));
-    span?.setAttributes({
-        "agent.runtime.kind": input.runtimeKind,
-        ...input.projectServiceTraceAttributes,
-        ...scheduleTraceAttributes,
-    });
-}
-function fetchProjectSteering(context, input, agentId) {
-    return fetchDefaultHostedProjectSteering({
-        ...input,
-        fetchProjectInstructions: (lookup) => getProjectInstructions(context, lookup, agentId),
-        fetchSkills: (lookup) => getSkillsConfig(context, lookup, agentId),
-        trace: context.trace,
-        traceOperationName: "chat.fetchSteering",
-    });
-}
-function createHostedChatContextBudgetOptions(context, req, agentConfig, abortSignal) {
-    const config = context.infrastructure.getConfig();
-    if (!config.VERYFRONT_CONTEXT_COMPACTION_ENABLED || !req.durableRootRun) {
-        return undefined;
-    }
-    return {
-        tokenBudget: config.VERYFRONT_CONTEXT_COMPACTION_TOKEN_BUDGET,
-        reserveTokens: config.VERYFRONT_CONTEXT_COMPACTION_RESERVE_TOKENS,
-        recentTailTokens: config.VERYFRONT_CONTEXT_COMPACTION_RECENT_TAIL_TOKENS,
-        minimumRecentTurns: config.VERYFRONT_CONTEXT_COMPACTION_MINIMUM_RECENT_TURNS,
-        maxSummaryTokens: config.VERYFRONT_CONTEXT_COMPACTION_MAX_SUMMARY_TOKENS,
-        summaryGenerator: createVeryfrontCloudContextSummaryGenerator({
-            apiUrl: config.VERYFRONT_API_URL,
-            authToken: req.authToken,
-            projectSlug: req.projectSlug,
-            model: config.VERYFRONT_CONTEXT_COMPACTION_SUMMARY_MODEL ?? agentConfig.model,
-            maxOutputTokens: config.VERYFRONT_CONTEXT_COMPACTION_MAX_SUMMARY_TOKENS,
-            maxInputTokens: config.VERYFRONT_CONTEXT_COMPACTION_SUMMARY_INPUT_TOKENS,
-            abortSignal,
-        }),
-        logger: {
-            debug: (message, metadata) => context.infrastructure.logger.debug(message, metadata),
-            error: (message, metadata) => context.infrastructure.logger.error(message, metadata),
-        },
-    };
-}
-async function prepareChatExecutionWithinProjectRuntime(context, req) {
-    const { userId, authToken, projectId, conversationId, upstreamParentConversationId, upstreamParentRunId, spawnedFromToolCallId, } = req;
-    const config = context.infrastructure.getConfig();
-    const projectServiceTraceAttributes = buildProjectServiceTraceAttributes({
-        projectSlug: req.projectSlug,
-        readEnv: getEnv,
-    });
-    setPrepareChatExecutionStartAttributes(context, { projectId, userId });
-    const requestedAgentId = req.agentId ?? getDefaultAgentId(context);
-    // veryfront-api is the trusted caller for request-scoped project-agent config.
-    const agentConfig = req.agentConfig ?? await resolveAgentConfig(context, requestedAgentId);
-    const abortController = new AbortController();
-    const { effectiveMessages, rootRunContext, runtime: { agent, runtimeKind, modelId, cleanup }, finalMessages, } = await prepareVeryfrontCloudHostedChatExecution({
-        request: req,
-        agentConfig,
-        apiUrl: config.VERYFRONT_API_URL,
-        abortSignal: 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,
-        contextBudget: createHostedChatContextBudgetOptions(context, req, agentConfig, abortController.signal),
-        createRuntime: (creationOptions) => context.trace("chat.createRuntime", () => createAgentRuntime(context, {
-            ...creationOptions,
-            userId: req.userId,
-        })),
-    });
-    setPrepareChatExecutionResultAttributes(context, {
-        conversationId,
-        projectId,
-        userId,
-        agentId: agentConfig.id,
-        agentName: agentConfig.name,
-        modelId,
-        runId: rootRunContext.durableRootRun?.runId,
-        upstreamParentConversationId,
-        upstreamParentRunId,
-        spawnedFromToolCallId,
-        runtimeKind,
-        forwardedProps: req.forwardedProps,
-        projectServiceTraceAttributes,
-    });
-    return {
-        config,
-        agent,
-        agentId: agentConfig.id,
-        runtimeKind,
-        modelId,
-        cleanup,
-        messages: effectiveMessages,
-        finalMessages,
-        conversationId,
-        authToken,
-        projectId,
-        userId,
-        rootRunContext,
-        upstreamParentConversationId,
-        upstreamParentRunId,
-        spawnedFromToolCallId,
-        traceAttributes: {
-            ...projectServiceTraceAttributes,
-            ...buildScheduleTraceAttributes(req.forwardedProps),
-        },
-    };
-}
-async function prepareChatExecution(context, req) {
-    return await runWithProjectAgentRuntime(getProjectAgentRuntime(context), () => prepareChatExecutionWithinProjectRuntime(context, req));
-}
-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 resolveAgentServiceRuntimeName() {
-    if (Reflect.get(dntShim.dntGlobalThis, "Bun")) {
-        return "bun";
-    }
-    if (Reflect.get(dntShim.dntGlobalThis, "Deno")) {
-        return "deno";
-    }
-    return "node";
-}
-function getAgentServiceVersion(context) {
-    return context.options.env?.npm_package_version;
-}
-async function createControlPlaneRegistrationLifecycle(context) {
-    const config = context.infrastructure.getConfig();
-    const registrationInput = await resolveAgentServiceRegistrationInput({
-        config,
-        serviceName: context.options.serviceName,
-        agentId: getDefaultAgentId(context),
-        version: getAgentServiceVersion(context),
-        runtime: resolveAgentServiceRuntimeName(),
-    });
-    if (!registrationInput) {
-        return undefined;
-    }
-    if (!context.options.runtimeSource) {
-        throw new Error("runtimeSource is required when agent service control-plane registration is enabled.");
-    }
-    try {
-        const lifecycle = await createAgentServiceRegistrationLifecycle({
-            ...registrationInput,
-            logger: context.infrastructure.logger,
-        });
-        return {
-            stop: () => lifecycle.stop(),
-        };
-    }
-    catch (error) {
-        if (config.VERYFRONT_AGENT_SERVICE_REGISTRATION === "enabled") {
-            throw error;
-        }
-        context.infrastructure.logger.warn("Agent service registration skipped", {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return undefined;
-    }
-}
-function createNodeVeryfrontCloudAgentServiceRuntimeOptions(context) {
-    return {
-        serviceName: context.options.serviceName,
-        runtimeSource: context.options.runtimeSource,
-        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,
-    };
-}
 /** Create node Veryfront Cloud agent service runtime. */
 export async function createNodeVeryfrontCloudAgentServiceRuntime(options = {}) {
     const resolvedOptions = await resolveNodeVeryfrontCloudAgentServiceOptions(options);