veryfront 0.1.508 → 0.1.510

package/src/src/agent/{hosted-agent-service-runtime.ts → agent-service-runtime.ts}

@@ -11,18 +11,18 @@ import {
   type DetachedRunTracker,
 } from "./detached-run-tracker.js";
 import {
-  createHostedAgentServiceRouteSet,
-  type HostedAgentServiceActiveSpanAttributes,
-  type HostedAgentServiceDetachedCleanupInput,
-  type HostedAgentServiceDetachedExecutionInput,
-  type HostedAgentServiceRouteSet,
-  type HostedAgentServiceStreamExecutionInput,
-} from "./hosted-agent-service-routes.js";
+  type AgentServiceActiveSpanAttributes,
+  type AgentServiceDetachedCleanupInput,
+  type AgentServiceDetachedExecutionInput,
+  type AgentServiceRouteSet,
+  type AgentServiceStreamExecutionInput,
+  createAgentServiceRouteSet,
+} from "./agent-service-routes.js";
 import {
-  createHostedServiceAuth,
-  type HostedServiceAuth,
-  type HostedServiceAuthConfig,
-} from "./hosted-service-auth.js";
+  type AgentServiceAuth,
+  type AgentServiceAuthConfig,
+  createAgentServiceAuth,
+} from "./agent-service-auth.js";
 import type { ParsedHostedChatRequest } from "./hosted-chat-request-parser.js";
 import type { AgUiResumeValue } from "./ag-ui-tool-shared.js";
 import type { RuntimeAgentMarkdownDefinition } from "./runtime-agent-definition.js";
@@ -34,7 +34,7 @@ import {
 } from "./agent-service-server.js";
 import type { VeryfrontServiceServerLogger } from "../server/service-server.js";
 
-export type HostedAgentServiceRuntimeConfig = HostedServiceAuthConfig & {
+export type HostedAgentServiceRuntimeConfig = AgentServiceAuthConfig & {
   PORT: number;
   ALLOWED_ORIGINS: string[];
 };
@@ -65,16 +65,16 @@ export type CreateHostedAgentServiceRuntimeOptions<
   forwardedConfigNamespace?: string;
   logger: HostedAgentServiceRuntimeLogger;
   trace?: HostedAgentServiceRuntimeTrace;
-  setActiveSpanAttributes?: (attributes: HostedAgentServiceActiveSpanAttributes) => void;
+  setActiveSpanAttributes?: (attributes: AgentServiceActiveSpanAttributes) => void;
   prepareExecution: (req: ParsedHostedChatRequest) => Promise<TExecution>;
   streamExecutionToAgUiResponse: (
-    input: HostedAgentServiceStreamExecutionInput<TExecution>,
+    input: AgentServiceStreamExecutionInput<TExecution>,
   ) => Promise<Response> | Response;
   startDetachedExecution: (
-    input: HostedAgentServiceDetachedExecutionInput<TExecution>,
+    input: AgentServiceDetachedExecutionInput<TExecution>,
   ) => Promise<void>;
   cleanupExecution?: (
-    input: HostedAgentServiceDetachedCleanupInput<TExecution>,
+    input: AgentServiceDetachedCleanupInput<TExecution>,
   ) => Promise<void>;
   tracker?: DetachedRunTracker<AgUiResumeValue>;
   drainTimeoutMs?: number;
@@ -91,8 +91,8 @@ export type HostedAgentServiceRuntimeBundle<
 > = {
   config: TConfig;
   tracker: DetachedRunTracker<AgUiResumeValue>;
-  auth: HostedServiceAuth;
-  routeSet: HostedAgentServiceRouteSet<TExecution>;
+  auth: AgentServiceAuth;
+  routeSet: AgentServiceRouteSet<TExecution>;
   routes: AgentServiceRoute[];
   lifecycle: DetachedRunShutdownLifecycle;
   runtime: AgentServiceRuntime;
@@ -152,21 +152,21 @@ function defaultTrace<TResult>(
   return operation();
 }
 
-export function createHostedAgentServiceRuntime<
+export function createAgentServiceRuntime<
   TExecution extends object,
-  TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig,
+  TConfig extends AgentServiceRuntimeConfig = AgentServiceRuntimeConfig,
 >(
-  options: CreateHostedAgentServiceRuntimeOptions<TExecution, TConfig>,
-): HostedAgentServiceRuntimeBundle<TExecution, TConfig> {
+  options: CreateAgentServiceRuntimeOptions<TExecution, TConfig>,
+): AgentServiceRuntimeBundle<TExecution, TConfig> {
   const config = options.getConfig();
   const tracker = options.tracker ?? createDetachedRunTracker<AgUiResumeValue>();
   const trace = options.trace ?? defaultTrace;
-  const auth = createHostedServiceAuth({
+  const auth = createAgentServiceAuth({
     getConfig: options.getConfig,
     logger: options.logger,
     trace,
   });
-  const routeSet = createHostedAgentServiceRouteSet({
+  const routeSet = createAgentServiceRouteSet({
     forwardedConfigNamespace: options.forwardedConfigNamespace,
     authenticateRequest: auth.authenticateRequest,
     verifyProjectAccess: (projectId, authToken) => auth.verifyProjectAccess(projectId, authToken),
@@ -213,22 +213,22 @@ export function createHostedAgentServiceRuntime<
   };
 }
 
-export function createAgentServiceRuntime<
+export function createHostedAgentServiceRuntime<
   TExecution extends object,
-  TConfig extends AgentServiceRuntimeConfig = AgentServiceRuntimeConfig,
+  TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig,
 >(
-  options: CreateAgentServiceRuntimeOptions<TExecution, TConfig>,
-): AgentServiceRuntimeBundle<TExecution, TConfig> {
-  return createHostedAgentServiceRuntime(options);
+  options: CreateHostedAgentServiceRuntimeOptions<TExecution, TConfig>,
+): HostedAgentServiceRuntimeBundle<TExecution, TConfig> {
+  return createAgentServiceRuntime(options);
 }
 
-export async function startNodeHostedAgentService<
+export async function startNodeAgentService<
   TExecution extends object,
-  TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig,
+  TConfig extends AgentServiceRuntimeConfig = AgentServiceRuntimeConfig,
 >(
-  options: StartNodeHostedAgentServiceOptions<TExecution, TConfig>,
-): Promise<StartNodeHostedAgentServiceResult<TExecution, TConfig>> {
-  const bundle = createHostedAgentServiceRuntime(options);
+  options: StartNodeAgentServiceOptions<TExecution, TConfig>,
+): Promise<StartNodeAgentServiceResult<TExecution, TConfig>> {
+  const bundle = createAgentServiceRuntime(options);
   const nodeServer = await startNodeAgentServiceServer({
     runtime: bundle.runtime,
     serviceName: options.serviceName,
@@ -246,13 +246,13 @@ export async function startNodeHostedAgentService<
   };
 }
 
-export async function startNodeAgentService<
+export async function startNodeHostedAgentService<
   TExecution extends object,
-  TConfig extends AgentServiceRuntimeConfig = AgentServiceRuntimeConfig,
+  TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig,
 >(
-  options: StartNodeAgentServiceOptions<TExecution, TConfig>,
-): Promise<StartNodeAgentServiceResult<TExecution, TConfig>> {
-  return startNodeHostedAgentService(options);
+  options: StartNodeHostedAgentServiceOptions<TExecution, TConfig>,
+): Promise<StartNodeHostedAgentServiceResult<TExecution, TConfig>> {
+  return startNodeAgentService(options);
 }
 
 export async function startAgentServiceRuntime<

package/src/src/agent/default-hosted-chat-runtime.ts

@@ -30,6 +30,7 @@ import {
   prepareHostedChatRuntimeToolAssembly,
   type PrepareHostedChatRuntimeToolAssemblyInput,
 } from "./hosted-chat-runtime-tool-assembly.js";
+import type { HostedProjectMcpServerConfig } from "./hosted-project-remote-tool-source.js";
 import {
   createHostedRuntimeStateResolver,
   type HostedRuntimeStateResolverContext,
@@ -45,7 +46,7 @@ export type DefaultHostedChatRuntimeConfig = {
   apiUrl: string;
   apiMcpUrl: string;
   studioMcpUrl?: string | null;
-  studioMcpEnabled?: boolean;
+  mcpServers?: readonly HostedProjectMcpServerConfig[];
 };
 
 export type DefaultHostedChatRuntimeLogger = {
@@ -155,7 +156,7 @@ async function buildToolAssembly(
     apiUrl: input.config.apiUrl,
     apiMcpUrl: input.config.apiMcpUrl,
     studioMcpUrl: input.config.studioMcpUrl,
-    studioMcpEnabled: input.config.studioMcpEnabled,
+    mcpServers: input.config.mcpServers,
     conversationId: input.options.conversationId,
     allowedToolNames: input.options.allowedTools ?? null,
     projectScopedRemoteToolOptions: input.projectScopedRemoteToolOptions,

package/src/src/agent/default-hosted-invoke-agent-tool.ts

@@ -29,6 +29,7 @@ import { startHostedChildForkRuntimeWithHostTools } from "./hosted-child-fork-ru
 import {
   prepareDefaultHostedChildForkSandboxToolSources,
 } from "./hosted-child-fork-tool-sources.js";
+import type { HostedProjectMcpServerConfig } from "./hosted-project-remote-tool-source.js";
 import { executeHostedChildForkToolInput } from "./hosted-child-fork-execution-runner.js";
 import { createHostedChildInvokeTool } from "./hosted-child-invoke-tool.js";
 import {
@@ -79,6 +80,7 @@ export type DefaultHostedInvokeAgentConfig = {
   apiUrl: string;
   apiMcpUrl: string;
   studioMcpUrl?: string | null;
+  mcpServers?: readonly HostedProjectMcpServerConfig[];
   enableDurableInvokeAgent?: boolean;
 };
 
@@ -220,6 +222,7 @@ async function prepareForkToolSources<TContext extends DefaultHostedInvokeAgentC
     apiUrl: config.apiUrl,
     apiMcpUrl: config.apiMcpUrl,
     studioMcpUrl: config.studioMcpUrl,
+    mcpServers: config.mcpServers,
     clientProfile: options.context.clientProfile,
     getProjectId: () => options.context.projectId || null,
     conversationId: options.context.conversationId,

package/src/src/agent/hosted-chat-runtime-tool-assembly.ts

@@ -19,6 +19,7 @@ import {
 } from "./default-research-artifact-support.js";
 import {
   createHostedProjectRemoteToolSources,
+  type HostedProjectMcpServerConfig,
   type HostedProjectRemoteToolSourceMutationHandler,
   type HostedProjectRemoteToolSourcePrepareToolInput,
   type HostedProjectRemoteToolSourceProjectSwitchHandler,
@@ -58,7 +59,7 @@ export type PrepareHostedChatRuntimeToolAssemblyInput<
   apiUrl: string;
   apiMcpUrl: string;
   studioMcpUrl?: string | null;
-  studioMcpEnabled?: boolean;
+  mcpServers?: readonly HostedProjectMcpServerConfig[];
   conversationId?: string;
   allowedToolNames?: HostedChatRuntimeAllowedToolNames;
   projectScopedRemoteToolOptions?: ProjectScopedRemoteToolOptions;
@@ -121,7 +122,7 @@ export async function prepareHostedChatRuntimeToolAssembly<
     authToken: input.taskContext.authToken,
     apiMcpUrl: input.apiMcpUrl,
     studioMcpUrl: input.studioMcpUrl,
-    studioMcpEnabled: input.studioMcpEnabled,
+    mcpServers: input.mcpServers,
     clientProfile: input.taskContext.clientProfile,
     createRemoteToolSource: input.createRemoteToolSource ?? createRemoteMCPToolSource,
     defaultProjectId: () => activeProjectId(input.taskContext),

package/src/src/agent/hosted-child-fork-tool-sources.ts

@@ -14,6 +14,11 @@ import {
   createLiveStudioMcpTools,
   type LiveStudioMcpToolsOptions,
 } from "./live-studio-mcp-tools.js";
+import type { HostedProjectMcpServerConfig } from "./hosted-project-remote-tool-source.js";
+import {
+  createHostedProjectGenericRemoteMcpConfig,
+  createHostedProjectVeryfrontApiRemoteMcpConfig,
+} from "./hosted-project-remote-tool-source.js";
 import type { RuntimeClientProfile } from "./runtime-client-profile.js";
 import {
   type HostedChildProjectSwitchHandler,
@@ -31,13 +36,13 @@ export type HostedChildForkToolSourcesLogger = {
 export type PrepareDefaultHostedChildForkToolSourcesInput = {
   authToken: string;
   apiMcpUrl: string;
+  mcpServers?: readonly HostedProjectMcpServerConfig[];
   getProjectId: () => string | null | undefined;
   studioMcpUrl?: string | null;
   clientProfile?: RuntimeClientProfile | null;
   conversationId?: string;
   globalTools?: HostToolSet;
   abortSignal?: AbortSignal;
-  apiSourceId?: string;
   onConfirmedStudioProjectSwitch?: HostedChildProjectSwitchHandler;
   createRemoteToolSource?: (config: RemoteMCPToolSourceConfig) => RemoteToolSource;
   createToolsFromRemoteDefinitions?: typeof createToolsFromRemoteDefinitions;
@@ -70,26 +75,59 @@ export type PrepareDefaultHostedChildForkSandboxToolSourcesInput =
     ) => Promise<AgentServiceSandboxToolsResult>;
   };
 
+function defaultChildForkMcpServers(): HostedProjectMcpServerConfig[] {
+  return [{ kind: "veryfront-api" }];
+}
+
 export async function prepareDefaultHostedChildForkToolSources(
   input: PrepareDefaultHostedChildForkToolSourcesInput,
 ): Promise<DefaultHostedChildForkToolSourcesResult> {
+  throwIfAborted(input.abortSignal);
+
   let closeStudioMcpTools: (() => Promise<void>) | undefined;
   let studioMcpTools: HostToolSet = {};
+  let remoteMcpTools: HostToolSet = {};
   const createLiveStudioTools = input.createLiveStudioTools ?? createLiveStudioMcpTools;
+  const createRemoteToolSource = input.createRemoteToolSource ?? createRemoteMCPToolSource;
+  const materializeRemoteTools = input.createToolsFromRemoteDefinitions ??
+    createToolsFromRemoteDefinitions;
 
   try {
-    const studioTools = await createLiveStudioTools({
-      authToken: input.authToken,
-      clientProfile: input.clientProfile,
-      getProjectId: input.getProjectId,
-      studioMcpUrl: input.studioMcpUrl,
-      ...(input.conversationId ? { conversationId: input.conversationId } : {}),
-      ...(input.createRemoteToolSource
-        ? { createRemoteToolSource: input.createRemoteToolSource }
-        : {}),
-    });
-    studioMcpTools = studioTools.tools;
-    closeStudioMcpTools = studioTools.close;
+    const mcpServers = input.mcpServers ?? defaultChildForkMcpServers();
+    for (const server of mcpServers) {
+      if (server.kind === "veryfront-studio") {
+        const studioTools = await createLiveStudioTools({
+          authToken: input.authToken,
+          clientProfile: input.clientProfile,
+          getProjectId: input.getProjectId,
+          studioMcpUrl: input.studioMcpUrl,
+          ...(input.conversationId ? { conversationId: input.conversationId } : {}),
+          ...(input.createRemoteToolSource
+            ? { createRemoteToolSource: input.createRemoteToolSource }
+            : {}),
+        });
+        studioMcpTools = {
+          ...studioMcpTools,
+          ...studioTools.tools,
+        };
+        closeStudioMcpTools = studioTools.close;
+        continue;
+      }
+
+      const remoteConfig = server.kind === "veryfront-api"
+        ? createHostedProjectVeryfrontApiRemoteMcpConfig({
+          authToken: input.authToken,
+          apiMcpUrl: input.apiMcpUrl,
+          defaultSourceId: "veryfront-mcp-fork",
+        }, server)
+        : createHostedProjectGenericRemoteMcpConfig(server);
+      const remoteSource = createRemoteToolSource(remoteConfig);
+      const definitions = await remoteSource.listTools();
+      remoteMcpTools = {
+        ...remoteMcpTools,
+        ...materializeRemoteTools(remoteSource, definitions),
+      };
+    }
   } catch (error) {
     if (input.abortSignal?.aborted || input.isAbortError?.(error)) {
       throw error;
@@ -108,19 +146,6 @@ export async function prepareDefaultHostedChildForkToolSources(
 
   throwIfAborted(input.abortSignal);
 
-  const createRemoteToolSource = input.createRemoteToolSource ?? createRemoteMCPToolSource;
-  const materializeRemoteTools = input.createToolsFromRemoteDefinitions ??
-    createToolsFromRemoteDefinitions;
-  const apiMcpSource = createRemoteToolSource({
-    id: input.apiSourceId ?? "veryfront-mcp-fork",
-    endpoint: input.apiMcpUrl,
-    headers: {
-      Authorization: `Bearer ${input.authToken}`,
-    },
-  });
-  const apiMcpDefinitions = await apiMcpSource.listTools();
-  const apiMcpTools = materializeRemoteTools(apiMcpSource, apiMcpDefinitions);
-
   if (input.onConfirmedStudioProjectSwitch) {
     wrapHostedChildProjectSwitchTool({
       tools: studioMcpTools,
@@ -133,7 +158,7 @@ export async function prepareDefaultHostedChildForkToolSources(
   return {
     ok: true,
     forkTools: buildDefaultHostedChildForkToolSet(
-      apiMcpTools,
+      remoteMcpTools,
       studioMcpTools,
       input.globalTools ?? {},
     ),

package/src/src/agent/hosted-project-remote-tool-source.ts

@@ -27,6 +27,31 @@ export type HostedProjectRemoteToolSourceProjectSwitchHandler = (
   projectId: string,
 ) => Promise<void> | void;
 
+export type HostedProjectVeryfrontApiMcpServerConfig = {
+  kind: "veryfront-api";
+  id?: string;
+};
+
+export type HostedProjectVeryfrontStudioMcpServerConfig = {
+  kind: "veryfront-studio";
+  id?: string;
+};
+
+export type HostedProjectGenericMcpServerConfig = {
+  kind?: "generic";
+  id?: string;
+  endpoint: RemoteMCPToolSourceConfig["endpoint"];
+  headers?: RemoteMCPToolSourceConfig["headers"];
+  fetch?: RemoteMCPToolSourceConfig["fetch"];
+  listMethod?: RemoteMCPToolSourceConfig["listMethod"];
+  callMethod?: RemoteMCPToolSourceConfig["callMethod"];
+};
+
+export type HostedProjectMcpServerConfig =
+  | HostedProjectVeryfrontApiMcpServerConfig
+  | HostedProjectVeryfrontStudioMcpServerConfig
+  | HostedProjectGenericMcpServerConfig;
+
 export type HostedProjectRemoteToolSourcePrepareToolInput = (input: {
   toolName: string;
   toolInput: Record<string, unknown>;
@@ -188,16 +213,87 @@ export type CreateHostedProjectRemoteToolSourcesInput =
     authToken: string;
     apiMcpUrl: string;
     studioMcpUrl?: string | null;
-    studioMcpEnabled?: boolean;
+    mcpServers?: readonly HostedProjectMcpServerConfig[];
     clientProfile?: RuntimeClientProfile | null;
     getProjectId: () => string | null | undefined;
     conversationId?: string;
-    apiSourceId?: string;
-    studioSourceId?: string;
     createRemoteToolSource?: (config: RemoteMCPToolSourceConfig) => RemoteToolSource;
     onStudioProjectSwitch?: HostedProjectRemoteToolSourceProjectSwitchHandler;
   };
 
+function defaultHostedProjectMcpServers(): HostedProjectMcpServerConfig[] {
+  return [{ kind: "veryfront-api" }];
+}
+
+export function createHostedProjectGenericRemoteMcpConfig(
+  server: HostedProjectGenericMcpServerConfig,
+): RemoteMCPToolSourceConfig {
+  const config: RemoteMCPToolSourceConfig = {
+    endpoint: server.endpoint,
+  };
+
+  if (server.id !== undefined) config.id = server.id;
+  if (server.headers !== undefined) config.headers = server.headers;
+  if (server.fetch !== undefined) config.fetch = server.fetch;
+  if (server.listMethod !== undefined) config.listMethod = server.listMethod;
+  if (server.callMethod !== undefined) config.callMethod = server.callMethod;
+
+  return config;
+}
+
+export function createHostedProjectVeryfrontApiRemoteMcpConfig(
+  input: Pick<CreateHostedProjectRemoteToolSourcesInput, "apiMcpUrl" | "authToken"> & {
+    defaultSourceId?: string;
+  },
+  server: HostedProjectVeryfrontApiMcpServerConfig,
+): RemoteMCPToolSourceConfig {
+  return {
+    id: server.id ?? input.defaultSourceId ?? "veryfront-mcp",
+    endpoint: input.apiMcpUrl,
+    headers: {
+      Authorization: `Bearer ${input.authToken}`,
+    },
+  };
+}
+
+function createVeryfrontStudioRemoteMcpConfig(
+  input: Pick<
+    CreateHostedProjectRemoteToolSourcesInput,
+    "authToken" | "clientProfile" | "conversationId" | "getProjectId" | "studioMcpUrl"
+  >,
+  server: HostedProjectVeryfrontStudioMcpServerConfig,
+): RemoteMCPToolSourceConfig | null {
+  if (!input.studioMcpUrl || !clientAllowsStudioMcp(input.clientProfile)) {
+    return null;
+  }
+
+  return {
+    id: server.id ?? "studio-mcp",
+    endpoint: input.studioMcpUrl,
+    headers: () =>
+      buildStudioMcpHeaders(
+        input.authToken,
+        input.getProjectId() ?? null,
+        input.conversationId,
+      ),
+  };
+}
+
+function createRemoteMcpConfig(
+  input: CreateHostedProjectRemoteToolSourcesInput,
+  server: HostedProjectMcpServerConfig,
+): RemoteMCPToolSourceConfig | null {
+  if (server.kind === "veryfront-api") {
+    return createHostedProjectVeryfrontApiRemoteMcpConfig(input, server);
+  }
+
+  if (server.kind === "veryfront-studio") {
+    return createVeryfrontStudioRemoteMcpConfig(input, server);
+  }
+
+  return createHostedProjectGenericRemoteMcpConfig(server);
+}
+
 function createHostedProjectRemoteToolSourceFromConfig(
   input: CreateHostedProjectRemoteToolSourcesInput,
   source: RemoteToolSource,
@@ -230,41 +326,23 @@ export function createHostedProjectRemoteToolSources(
   input: CreateHostedProjectRemoteToolSourcesInput,
 ): RemoteToolSource[] {
   const createRemoteToolSource = input.createRemoteToolSource ?? createRemoteMCPToolSource;
-  const sources = [
-    createHostedProjectRemoteToolSourceFromConfig(
-      input,
-      createRemoteToolSource({
-        id: input.apiSourceId ?? "veryfront-mcp",
-        endpoint: input.apiMcpUrl,
-        headers: {
-          Authorization: `Bearer ${input.authToken}`,
-        },
-      }),
-    ),
-  ];
-
-  if (
-    !input.studioMcpEnabled || !input.studioMcpUrl || !clientAllowsStudioMcp(input.clientProfile)
-  ) {
-    return sources;
-  }
+  const sources: RemoteToolSource[] = [];
+  const mcpServers = input.mcpServers ?? defaultHostedProjectMcpServers();
+
+  for (const server of mcpServers) {
+    const remoteConfig = createRemoteMcpConfig(input, server);
+    if (!remoteConfig) {
+      continue;
+    }
 
-  sources.push(
-    createHostedProjectRemoteToolSourceFromConfig(
-      input,
-      createRemoteToolSource({
-        id: input.studioSourceId ?? "studio-mcp",
-        endpoint: input.studioMcpUrl,
-        headers: () =>
-          buildStudioMcpHeaders(
-            input.authToken,
-            input.getProjectId() ?? null,
-            input.conversationId,
-          ),
-      }),
-      input.onStudioProjectSwitch,
-    ),
-  );
+    sources.push(
+      createHostedProjectRemoteToolSourceFromConfig(
+        input,
+        createRemoteToolSource(remoteConfig),
+        server.kind === "veryfront-studio" ? input.onStudioProjectSwitch : undefined,
+      ),
+    );
+  }
 
   return sources;
 }

package/src/src/agent/hosted-project-steering-adapter.ts

@@ -1,5 +1,5 @@
 import type { Tool } from "../tool/index.js";
-import { HostedServiceAuthError, isHostedServiceAuthError } from "./hosted-service-auth.js";
+import { HostedServiceAuthError, isHostedServiceAuthError } from "./agent-service-auth.js";
 import {
   listRuntimeBuiltinSkillReferences,
   readRuntimeBuiltinSkill,

package/src/src/agent/index.ts

@@ -334,16 +334,18 @@ export {
   startNodeHostedAgentService,
   type StartNodeHostedAgentServiceOptions,
   type StartNodeHostedAgentServiceResult,
-} from "./hosted-agent-service-runtime.js";
+} from "./agent-service-runtime.js";
 export {
   createNodeVeryfrontCloudAgentServiceRuntime,
-  type NodeVeryfrontCloudAgentServiceMcpOptions,
+  type NodeVeryfrontCloudAgentServiceMcpServer,
   type NodeVeryfrontCloudAgentServiceOptions,
   type NodeVeryfrontCloudAgentServicePreparedExecution,
   type NodeVeryfrontCloudAgentServiceProcessTarget,
   startAgentService,
   startNodeVeryfrontCloudAgentService,
   type VeryfrontCloudAgentServiceOptions,
+  veryfrontMcpServer,
+  type VeryfrontMcpServerKind,
 } from "./veryfront-cloud-agent-service.js";
 export {
   type AgentServiceConfig,
@@ -354,7 +356,7 @@ export {
   hostedAgentServiceConfigSchema,
   parseAgentServiceConfig,
   parseHostedAgentServiceConfig,
-} from "./hosted-agent-service-config.js";
+} from "./agent-service-config.js";
 export {
   type AgentServiceEnvFileLoadOptions,
   type AgentServiceEnvFileLoadResult,
@@ -362,7 +364,7 @@ export {
   type HostedAgentServiceEnvFileLoadResult,
   loadAgentServiceEnvFiles,
   loadHostedAgentServiceEnvFiles,
-} from "./hosted-agent-service-env-files.js";
+} from "./agent-service-env-files.js";
 export {
   initializeNodeAgentServiceOpenTelemetry,
   type InitializeNodeAgentServiceTelemetryOptions,
@@ -382,7 +384,7 @@ export {
   type ResolveNodeAgentServiceTelemetryConfigOptions,
   resolveNodeHostedAgentServiceTelemetryConfig,
   type ResolveNodeHostedAgentServiceTelemetryConfigOptions,
-} from "./node-hosted-agent-service-telemetry.js";
+} from "./node-agent-service-telemetry.js";
 export {
   createNodeAgentServiceRuntimeInfrastructure,
   type CreateNodeAgentServiceRuntimeInfrastructureOptions,
@@ -390,7 +392,7 @@ export {
   type CreateNodeHostedAgentServiceRuntimeInfrastructureOptions,
   type NodeAgentServiceRuntimeInfrastructure,
   type NodeHostedAgentServiceRuntimeInfrastructure,
-} from "./node-hosted-agent-service-runtime-infrastructure.js";
+} from "./node-agent-service-runtime-infrastructure.js";
 export {
   type AgentServiceBootstrapExit,
   type AgentServiceTraceContext,
@@ -530,7 +532,7 @@ export {
   type HostedAgentServiceRoutesTrace as AgentServiceRoutesTrace,
   type HostedAgentServiceStreamExecutionInput,
   type HostedAgentServiceStreamExecutionInput as AgentServiceStreamExecutionInput,
-} from "./hosted-agent-service-routes.js";
+} from "./agent-service-routes.js";
 export {
   createHostedRuntimeStateResolver,
   type CreateHostedRuntimeStateResolverOptions,
@@ -1726,4 +1728,4 @@ export {
   type HostedServiceProjectAccessResult as AgentServiceProjectAccessResult,
   isHostedServiceAuthError,
   isHostedServiceAuthError as isAgentServiceAuthError,
-} from "./hosted-service-auth.js";
+} from "./agent-service-auth.js";