veryfront 0.1.478 → 0.1.480

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.478",
+    "version": "0.1.480",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "workspace": [

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

@@ -0,0 +1,84 @@
+import type { HostedSandboxToolsOptions, HostedSandboxToolsResult } from "../sandbox/index.js";
+import { createToolsFromRemoteDefinitions, type HostToolSet, type RemoteMCPToolSourceConfig, type RemoteToolSource, type ToolExecutionContext } from "../tool/index.js";
+import { z } from "zod";
+import type { ChildRunExecutionResult } from "./child-run-execution-snapshot.js";
+import type { ConversationRunEvent } from "./conversation-run-events.js";
+import { prepareDefaultHostedChildForkSandboxToolSources } from "./hosted-child-fork-tool-sources.js";
+import { type MutableAgentProjectContext } from "./project-context.js";
+import { type HostedDurableChildInvokeResult } from "./hosted-durable-child-fork-execution.js";
+import { type HostedChildForkRuntimeConfig } from "./hosted-child-tool-input.js";
+import type { RuntimeClientProfile } from "./runtime-client-profile.js";
+export type DefaultHostedInvokeAgentContext = MutableAgentProjectContext & {
+    authToken: string;
+    clientProfile?: RuntimeClientProfile | null;
+    model?: string;
+    conversationId?: string;
+    parentRunId?: string;
+    parentMessageId?: string;
+    publishParentRunEvents?: (events: ConversationRunEvent[]) => Promise<void> | void;
+    availableToolNames?: string[];
+    steeringRevision?: number;
+};
+export type DefaultHostedInvokeAgentConfig = {
+    apiUrl: string;
+    apiMcpUrl: string;
+    studioMcpUrl?: string | null;
+    enableDurableInvokeAgent?: boolean;
+};
+export type DefaultHostedInvokeAgentLogger = {
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+};
+export type DefaultHostedInvokeAgentTraceAttributes = Record<string, string | number | boolean | readonly (string | number | boolean)[] | null | undefined>;
+export type DefaultHostedInvokeAgentTrace = <TResult>(operationName: string, operation: () => TResult) => TResult;
+export type DefaultHostedInvokeAgentToolResult = ChildRunExecutionResult | HostedDurableChildInvokeResult;
+export type DefaultHostedInvokeAgentProjectRefresh<TContext extends DefaultHostedInvokeAgentContext> = (context: TContext) => Promise<void> | void;
+export type DefaultHostedInvokeAgentToolOptions<TContext extends DefaultHostedInvokeAgentContext> = {
+    context: TContext;
+    getConfig: () => DefaultHostedInvokeAgentConfig;
+    logger: DefaultHostedInvokeAgentLogger;
+    trace: DefaultHostedInvokeAgentTrace;
+    setTraceAttributes: (attributes: DefaultHostedInvokeAgentTraceAttributes) => void;
+    createBashTool: HostedSandboxToolsOptions["createBashTool"];
+    resolveModelId: (model: string) => string;
+    resolveProvider: (modelId: string) => string;
+    resolveProviderOptions?: (forkModel: string, thinkingConfig: HostedChildForkRuntimeConfig["thinkingConfig"]) => Record<string, unknown> | undefined;
+    shouldRethrowError?: (error: unknown) => boolean;
+    buildGlobalTools?: (context: TContext) => HostToolSet;
+    refreshProjectSkillIds?: DefaultHostedInvokeAgentProjectRefresh<TContext>;
+    defaultModel?: string;
+    defaultMaxSteps?: number;
+    resolveChildAgentId?: (input: DefaultHostedInvokeAgentInput) => string;
+    createHostedSandboxTools?: (input: HostedSandboxToolsOptions) => Promise<HostedSandboxToolsResult>;
+    createRemoteToolSource?: (config: RemoteMCPToolSourceConfig) => RemoteToolSource;
+    createToolsFromRemoteDefinitions?: typeof createToolsFromRemoteDefinitions;
+    createLiveStudioTools?: Parameters<typeof prepareDefaultHostedChildForkSandboxToolSources>[0]["createLiveStudioTools"];
+};
+export declare const defaultHostedInvokeAgentSelectionSchema: z.ZodObject<{
+    agent_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const defaultHostedInvokeAgentInputSchema: z.ZodObject<{
+    description: z.ZodString;
+    prompt: z.ZodString;
+    project_id: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+    thinking: z.ZodOptional<z.ZodNumber>;
+    max_steps: z.ZodOptional<z.ZodNumber>;
+    agent_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DefaultHostedInvokeAgentInput = z.infer<typeof defaultHostedInvokeAgentInputSchema>;
+export declare function executeDefaultHostedInvokeAgentTool<TContext extends DefaultHostedInvokeAgentContext>(options: DefaultHostedInvokeAgentToolOptions<TContext>, input: DefaultHostedInvokeAgentInput, childAgentId: string, executionContext?: ToolExecutionContext): Promise<DefaultHostedInvokeAgentToolResult>;
+export declare function createDefaultHostedInvokeAgentTool<TContext extends DefaultHostedInvokeAgentContext>(options: DefaultHostedInvokeAgentToolOptions<TContext>): import("../tool/types.js").Tool<{
+    description: string;
+    prompt: string;
+    project_id?: string | undefined;
+    tools?: string[] | undefined;
+    model?: string | undefined;
+    thinking?: number | undefined;
+    max_steps?: number | undefined;
+    agent_id?: string | undefined;
+}, DefaultHostedInvokeAgentToolResult>;
+//# sourceMappingURL=default-hosted-invoke-agent-tool.d.ts.map

package/esm/src/agent/default-hosted-invoke-agent-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-hosted-invoke-agent-tool.d.ts","sourceRoot":"","sources":["../../../src/src/agent/default-hosted-invoke-agent-tool.ts"],"names":[],"mappings":"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"}

package/esm/src/agent/default-hosted-invoke-agent-tool.js

@@ -0,0 +1,325 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { createHostedSandboxTools } from "../sandbox/index.js";
+import { createRemoteMCPToolSource, createToolsFromRemoteDefinitions, sleepTool, } from "../tool/index.js";
+import { z } from "zod";
+import { buildExecuteToolTraceAttributes } from "./agent-trace-attributes.js";
+import { isChildRunAbortError, throwIfChildRunAborted } from "./child-run-execution-support.js";
+import { createConversationChildLifecycleAdapter } from "./conversation-hosted-lifecycle.js";
+import { bootstrapHostedChildRun } from "./hosted-child-bootstrap.js";
+import { createHostedChildExecutionLogWriter } from "./hosted-child-execution-logging.js";
+import { startHostedChildForkRuntimeWithHostTools } from "./hosted-child-fork-runtime-start.js";
+import { prepareDefaultHostedChildForkSandboxToolSources, } from "./hosted-child-fork-tool-sources.js";
+import { executeHostedChildForkToolInput } from "./hosted-child-fork-execution-runner.js";
+import { createHostedChildInvokeTool } from "./hosted-child-invoke-tool.js";
+import { runHostedChildExecutionLifecycle, shouldSkipHostedChildTerminalPersistence, } from "./hosted-child-lifecycle.js";
+import { createLiveStudioMcpTools } from "./live-studio-mcp-tools.js";
+import { applyAgentProjectContextChange, } from "./project-context.js";
+import { buildHostedDurableChildInvokeFailureResult, createHostedDurableChildInvokeTraceRecorder, executeHostedDurableChildFork, executeHostedLocalChildInvoke, } from "./hosted-durable-child-fork-execution.js";
+import { DEFAULT_HOSTED_CHILD_AGENT_ID, hostedChildForkToolInputSchema, } from "./hosted-child-tool-input.js";
+import { prepareDefaultHostedChildForkToolAssembly } from "./hosted-child-requested-tools.js";
+import { withRootOwnedChildResultHint } from "./conversation-delegation-policy.js";
+export const defaultHostedInvokeAgentSelectionSchema = z.object({
+    agent_id: z.string().optional().describe("Built-in child agent type or user-defined agent id."),
+});
+export const defaultHostedInvokeAgentInputSchema = hostedChildForkToolInputSchema.extend(defaultHostedInvokeAgentSelectionSchema.shape);
+const DEFAULT_USER_AGENT_MODEL = "opus";
+const DEFAULT_USER_AGENT_MAX_STEPS = 80;
+const DURABLE_INVOKE_CONTEXT_UNAVAILABLE = "DURABLE_INVOKE_CONTEXT_UNAVAILABLE";
+const DURABLE_INVOKE_SETUP_FAILED = "DURABLE_INVOKE_SETUP_FAILED";
+function resolveDefaultChildAgentId(input) {
+    return input.agent_id?.trim() || DEFAULT_HOSTED_CHILD_AGENT_ID;
+}
+function resolveChildAgentId(options, input) {
+    return options.resolveChildAgentId?.(input) ?? resolveDefaultChildAgentId(input);
+}
+async function refreshProjectSkillIds(options) {
+    await options.refreshProjectSkillIds?.(options.context);
+}
+async function applyRequestedProjectId(options, projectId) {
+    if (!applyAgentProjectContextChange(options.context, projectId)) {
+        return;
+    }
+    await refreshProjectSkillIds(options);
+}
+async function prepareForkToolSources(options, config, abortSignal) {
+    throwIfChildRunAborted(abortSignal);
+    const globalTools = {
+        ...(options.buildGlobalTools?.(options.context) ?? {}),
+        sleep: sleepTool,
+    };
+    return prepareDefaultHostedChildForkSandboxToolSources({
+        authToken: options.context.authToken,
+        apiUrl: config.apiUrl,
+        apiMcpUrl: config.apiMcpUrl,
+        studioMcpUrl: config.studioMcpUrl,
+        clientProfile: options.context.clientProfile,
+        getProjectId: () => options.context.projectId || null,
+        conversationId: options.context.conversationId,
+        globalTools,
+        abortSignal,
+        isAbortError: isChildRunAbortError,
+        logger: options.logger,
+        createBashTool: options.createBashTool,
+        createHostedSandboxTools: options.createHostedSandboxTools ?? createHostedSandboxTools,
+        createLiveStudioTools: options.createLiveStudioTools ?? createLiveStudioMcpTools,
+        createRemoteToolSource: options.createRemoteToolSource ?? createRemoteMCPToolSource,
+        createToolsFromRemoteDefinitions: options.createToolsFromRemoteDefinitions ??
+            createToolsFromRemoteDefinitions,
+        onConfirmedStudioProjectSwitch: (projectId) => applyRequestedProjectId(options, projectId),
+    });
+}
+async function prepareForkToolAssembly(options, config, input) {
+    const toolAssembly = await prepareDefaultHostedChildForkToolAssembly({
+        prepareToolSources: () => prepareForkToolSources(options, config, input.abortSignal),
+        provider: input.provider,
+        forkModel: input.forkModel,
+        effectivePrompt: input.effectivePrompt,
+        requestedTools: input.requestedTools,
+        activeProjectId: options.context.projectId || null,
+        activeBranchId: options.context.branchId,
+        logger: options.logger,
+        onSteeringMutation: async (mutation) => {
+            if (mutation.instructionsChanged || mutation.skillsChanged) {
+                options.context.steeringRevision = (options.context.steeringRevision ?? 0) + 1;
+            }
+            if (mutation.skillsChanged) {
+                await refreshProjectSkillIds(options);
+            }
+        },
+    });
+    if (toolAssembly.ok) {
+        options.context.availableToolNames = toolAssembly.availableToolNames;
+    }
+    return toolAssembly;
+}
+function buildInstrumentation(options) {
+    return {
+        trace: options.trace,
+        setTraceAttributes: options.setTraceAttributes,
+        buildToolTraceAttributes: ({ toolName, toolCallId }) => buildExecuteToolTraceAttributes({
+            toolName,
+            toolCallId,
+        }),
+        tracePart: async ({ partType }) => {
+            await options.trace("invoke_agent.childStreamPart", async () => {
+                options.setTraceAttributes({
+                    "conversation.id": options.context.conversationId ?? "unknown",
+                    "run.id": options.context.parentRunId ?? "unknown",
+                    "stream.part.type": partType,
+                });
+            });
+        },
+        debug: (message, metadata) => options.logger.debug(message, metadata),
+        warn: (message, metadata) => options.logger.warn(message, metadata),
+        error: (message, metadata) => options.logger.error(message, metadata),
+    };
+}
+async function executeForkTask(options, input, execution, runtimeOptions = {}) {
+    const config = options.getConfig();
+    const instrumentation = buildInstrumentation(options);
+    const writeHostedChildExecutionLog = createHostedChildExecutionLogWriter(options.logger);
+    return executeHostedChildForkToolInput({
+        apiUrl: config.apiUrl,
+        authToken: options.context.authToken,
+        projectId: options.context.projectId || null,
+        forkInput: input,
+        toolCallId: execution.toolCallId,
+        contextModel: options.context.model,
+        defaultModel: options.defaultModel ?? DEFAULT_USER_AGENT_MODEL,
+        defaultMaxSteps: options.defaultMaxSteps ?? DEFAULT_USER_AGENT_MAX_STEPS,
+        resolveModelId: options.resolveModelId,
+        resolveProvider: options.resolveProvider,
+        onRequestedProjectId: (projectId) => applyRequestedProjectId(options, projectId),
+        onRuntimeConfig: (runtimeConfig) => {
+            options.logger.info("Starting child fork", {
+                conversationId: options.context.conversationId,
+                parentRunId: options.context.parentRunId,
+                description: runtimeConfig.description,
+                kind: "invoke_agent",
+                model: runtimeConfig.forkModel,
+                maxSteps: runtimeConfig.maxSteps,
+                requestedTools: runtimeConfig.requestedTools?.length,
+            });
+        },
+        prepareToolAssembly: ({ runtimeConfig, requestedTools, abortSignal }) => prepareForkToolAssembly(options, config, {
+            provider: runtimeConfig.provider,
+            forkModel: runtimeConfig.forkModel,
+            effectivePrompt: runtimeConfig.effectivePrompt,
+            requestedTools,
+            abortSignal,
+        }),
+        resolveProviderOptions: options.resolveProviderOptions,
+        forkContext: options.context,
+        abortSignal: execution.abortSignal,
+        durableChildRun: runtimeOptions.durableChildRun,
+        conversationId: options.context.conversationId,
+        parentRunId: options.context.parentRunId,
+        kind: "invoke_agent",
+        onSettled: runtimeOptions.onSettled,
+        logger: options.logger,
+        pendingToolLogWriter: options.logger,
+        writeLog: writeHostedChildExecutionLog,
+        startRuntime: startHostedChildForkRuntimeWithHostTools,
+        shouldRethrowError: options.shouldRethrowError,
+        instrumentation,
+    });
+}
+function getToolCallId(executionContext) {
+    return typeof executionContext?.toolCallId === "string" && executionContext.toolCallId.length > 0
+        ? executionContext.toolCallId
+        : `invoke_agent-${dntShim.crypto.randomUUID()}`;
+}
+function getAbortSignal(executionContext) {
+    return executionContext?.abortSignal instanceof AbortSignal
+        ? executionContext.abortSignal
+        : undefined;
+}
+export async function executeDefaultHostedInvokeAgentTool(options, input, childAgentId, executionContext) {
+    let executionSnapshot = null;
+    const config = options.getConfig();
+    const toolCallId = getToolCallId(executionContext);
+    const abortSignal = getAbortSignal(executionContext);
+    const durableInvokeRecorder = createHostedDurableChildInvokeTraceRecorder({
+        traceBase: {
+            conversationId: options.context.conversationId,
+            projectId: options.context.projectId,
+            runId: options.context.parentRunId,
+            toolCallId,
+            childAgentId,
+        },
+        executionFailedCode: "INVOKE_AGENT_FAILED",
+        setTraceAttributes: options.setTraceAttributes,
+    });
+    const executeLocalInvoke = (runtimeOptions = {}) => executeForkTask(options, input, {
+        toolCallId,
+        abortSignal,
+    }, {
+        onSettled: (snapshot) => {
+            executionSnapshot = snapshot;
+        },
+        durableChildRun: runtimeOptions.durableChildRun,
+    });
+    durableInvokeRecorder.annotate();
+    if (!config.enableDurableInvokeAgent) {
+        return executeHostedLocalChildInvoke({
+            forkInput: input,
+            abortSignal,
+            traceRecorder: durableInvokeRecorder,
+            execute: executeLocalInvoke,
+        });
+    }
+    executionSnapshot = null;
+    try {
+        return await executeHostedDurableChildFork({
+            authToken: options.context.authToken,
+            apiUrl: config.apiUrl,
+            forkInput: input,
+            executionOptions: {
+                toolCallId,
+                abortSignal,
+            },
+            childAgentId,
+            runProjectId: input.project_id ?? options.context.projectId,
+            parentConversationId: options.context.conversationId,
+            parentRunId: options.context.parentRunId,
+            parentMessageId: options.context.parentMessageId,
+            getProjectId: () => options.context.projectId,
+            getBranchId: () => options.context.branchId,
+            getContextModel: () => options.context.model,
+            defaultModel: options.defaultModel ?? DEFAULT_USER_AGENT_MODEL,
+            resolveModelId: options.resolveModelId,
+            resolveProvider: options.resolveProvider,
+            onRequestedProjectId: (projectId) => applyRequestedProjectId(options, projectId),
+            publishParentRunEvents: options.context.publishParentRunEvents,
+            contextUnavailableMessage: "invoke_agent requires durable conversation context when durable child runs are enabled.",
+            setupFailedCode: DURABLE_INVOKE_SETUP_FAILED,
+            executionFailedCode: "INVOKE_AGENT_FAILED",
+            executeLocal: executeLocalInvoke,
+            getExecutionSnapshot: () => executionSnapshot,
+            buildContextUnavailableResult: (message) => {
+                durableInvokeRecorder.annotate({
+                    status: "failed",
+                    terminalErrorCode: DURABLE_INVOKE_CONTEXT_UNAVAILABLE,
+                    terminalErrorMessage: message,
+                });
+                return buildHostedDurableChildInvokeFailureResult({
+                    terminalErrorCode: DURABLE_INVOKE_CONTEXT_UNAVAILABLE,
+                    terminalErrorMessage: message,
+                });
+            },
+            buildSetupFailureResult: (failure) => durableInvokeRecorder.recordSetupFailure(failure),
+            buildTerminalFailureResult: (failure) => durableInvokeRecorder.recordTerminalFailure(failure),
+            buildSuccessResult: (success) => durableInvokeRecorder.recordSuccess(success),
+            runtime: {
+                bootstrapChildRun: bootstrapHostedChildRun,
+                createLifecycleAdapter: createConversationChildLifecycleAdapter,
+                runLifecycle: runHostedChildExecutionLifecycle,
+                shouldSkipTerminalPersistence: shouldSkipHostedChildTerminalPersistence,
+            },
+            bootstrap: {
+                runBootstrap: (operation) => options.trace("invoke_agent.durableChildSetup", async () => {
+                    options.setTraceAttributes({
+                        "conversation.id": options.context.conversationId,
+                        "run.id": options.context.parentRunId,
+                        "tool.call.id": toolCallId,
+                    });
+                    return operation();
+                }),
+                onBootstrapStart: (bootstrapContext) => {
+                    options.logger.info("Bootstrapping durable child run", {
+                        parentConversationId: bootstrapContext.parentConversationId,
+                        parentRunId: bootstrapContext.parentRunId,
+                        toolCallId,
+                        childAgentId,
+                        description: input.description,
+                    });
+                },
+                onBootstrapComplete: (bootstrapContext) => {
+                    options.logger.info("Durable child bootstrap complete", {
+                        parentConversationId: bootstrapContext.parentConversationId,
+                        childConversationId: bootstrapContext.identifiers.childConversationId,
+                        childRunId: bootstrapContext.identifiers.childRunId,
+                        childMessageId: bootstrapContext.identifiers.childMessageId,
+                        toolCallId,
+                    });
+                },
+                onBootstrapError: ({ error, parentConversationId }) => {
+                    options.logger.warn("Durable child-run persistence failed", {
+                        parentConversationId,
+                        toolCallId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                },
+            },
+            onLifecycleError: (error) => {
+                options.logger.warn("Durable child lifecycle adapter failed", {
+                    toolCallId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            },
+            onLifecycleFinalized: ({ identifiers, status }) => options.trace("invoke_agent.durableChildFinalize", async () => {
+                options.setTraceAttributes({
+                    "child.conversation.id": identifiers.childConversationId,
+                    "child.run.id": identifiers.childRunId,
+                    "child.message.id": identifiers.childMessageId,
+                    "agent.run.final_status": status,
+                });
+            }),
+        });
+    }
+    catch (error) {
+        durableInvokeRecorder.recordLocalFailure(error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}
+export function createDefaultHostedInvokeAgentTool(options) {
+    return createHostedChildInvokeTool({
+        inputSchema: defaultHostedInvokeAgentInputSchema,
+        additionalDescriptionParts: [
+            "Use agent_id to target a specific built-in or custom child agent.",
+        ],
+        buildFailureResult: buildHostedDurableChildInvokeFailureResult,
+        decorateResult: withRootOwnedChildResultHint,
+        execute: (input, executionOptions) => executeDefaultHostedInvokeAgentTool(options, input, resolveChildAgentId(options, input), executionOptions),
+    });
+}

package/esm/src/agent/hosted-agent-service-runtime.d.ts

@@ -0,0 +1,53 @@
+import { type AgentServiceRoute, type AgentServiceRuntime } from "./agent-service.js";
+import { type DetachedRunShutdownLifecycle, type DetachedRunTracker } from "./detached-run-tracker.js";
+import { type HostedAgentServiceActiveSpanAttributes, type HostedAgentServiceDetachedCleanupInput, type HostedAgentServiceDetachedExecutionInput, type HostedAgentServiceRouteSet, type HostedAgentServiceStreamExecutionInput } from "./hosted-agent-service-routes.js";
+import { type HostedServiceAuth, type HostedServiceAuthConfig } from "./hosted-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";
+import { type NodeAgentServiceServer } from "./agent-service-server.js";
+import type { VeryfrontServiceServerLogger } from "../server/service-server.js";
+export type HostedAgentServiceRuntimeConfig = HostedServiceAuthConfig & {
+    PORT: number;
+    ALLOWED_ORIGINS: string[];
+};
+export type HostedAgentServiceRuntimeLogger = VeryfrontServiceServerLogger & {
+    info(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+};
+export type HostedAgentServiceRuntimeTrace = <TResult>(operationName: string, operation: () => Promise<TResult>) => Promise<TResult>;
+export type CreateHostedAgentServiceRuntimeOptions<TExecution extends object, TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig> = {
+    serviceName: string;
+    getConfig: () => TConfig;
+    getAgentConfig: () => RuntimeAgentMarkdownDefinition;
+    forwardedConfigNamespace?: string;
+    logger: HostedAgentServiceRuntimeLogger;
+    trace?: HostedAgentServiceRuntimeTrace;
+    setActiveSpanAttributes?: (attributes: HostedAgentServiceActiveSpanAttributes) => void;
+    prepareExecution: (req: ParsedHostedChatRequest) => Promise<TExecution>;
+    streamExecutionToAgUiResponse: (input: HostedAgentServiceStreamExecutionInput<TExecution>) => Promise<Response> | Response;
+    startDetachedExecution: (input: HostedAgentServiceDetachedExecutionInput<TExecution>) => Promise<void>;
+    cleanupExecution?: (input: HostedAgentServiceDetachedCleanupInput<TExecution>) => Promise<void>;
+    tracker?: DetachedRunTracker<AgUiResumeValue>;
+    drainTimeoutMs?: number;
+};
+export type HostedAgentServiceRuntimeBundle<TExecution extends object, TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig> = {
+    config: TConfig;
+    tracker: DetachedRunTracker<AgUiResumeValue>;
+    auth: HostedServiceAuth;
+    routeSet: HostedAgentServiceRouteSet<TExecution>;
+    routes: AgentServiceRoute[];
+    lifecycle: DetachedRunShutdownLifecycle;
+    runtime: AgentServiceRuntime;
+};
+export type StartNodeHostedAgentServiceOptions<TExecution extends object, TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig> = CreateHostedAgentServiceRuntimeOptions<TExecution, TConfig> & {
+    bindAddress?: string;
+    hardShutdownTimeoutMs?: number;
+    signals?: readonly NodeJS.Signals[];
+};
+export type StartNodeHostedAgentServiceResult<TExecution extends object, TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig> = HostedAgentServiceRuntimeBundle<TExecution, TConfig> & {
+    nodeServer: NodeAgentServiceServer;
+};
+export declare function createHostedAgentServiceRuntime<TExecution extends object, TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig>(options: CreateHostedAgentServiceRuntimeOptions<TExecution, TConfig>): HostedAgentServiceRuntimeBundle<TExecution, TConfig>;
+export declare function startNodeHostedAgentService<TExecution extends object, TConfig extends HostedAgentServiceRuntimeConfig = HostedAgentServiceRuntimeConfig>(options: StartNodeHostedAgentServiceOptions<TExecution, TConfig>): Promise<StartNodeHostedAgentServiceResult<TExecution, TConfig>>;
+//# sourceMappingURL=hosted-agent-service-runtime.d.ts.map

package/esm/src/agent/hosted-agent-service-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-agent-service-runtime.d.ts","sourceRoot":"","sources":["../../../src/src/agent/hosted-agent-service-runtime.ts"],"names":[],"mappings":"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"}

package/esm/src/agent/hosted-agent-service-runtime.js

@@ -0,0 +1,80 @@
+import { agent } from "./factory.js";
+import { defineAgentService, } from "./agent-service.js";
+import { createDetachedRunShutdownLifecycle, createDetachedRunTracker, } from "./detached-run-tracker.js";
+import { createHostedAgentServiceRouteSet, } from "./hosted-agent-service-routes.js";
+import { createHostedServiceAuth, } from "./hosted-service-auth.js";
+import { startNodeAgentServiceServer, } from "./agent-service-server.js";
+function defaultTrace(_operationName, operation) {
+    return operation();
+}
+export function createHostedAgentServiceRuntime(options) {
+    const config = options.getConfig();
+    const tracker = options.tracker ?? createDetachedRunTracker();
+    const trace = options.trace ?? defaultTrace;
+    const auth = createHostedServiceAuth({
+        getConfig: options.getConfig,
+        logger: options.logger,
+        trace,
+    });
+    const routeSet = createHostedAgentServiceRouteSet({
+        forwardedConfigNamespace: options.forwardedConfigNamespace,
+        authenticateRequest: auth.authenticateRequest,
+        verifyProjectAccess: (projectId, authToken) => auth.verifyProjectAccess(projectId, authToken),
+        tracker,
+        prepareExecution: options.prepareExecution,
+        streamExecutionToAgUiResponse: options.streamExecutionToAgUiResponse,
+        startDetachedExecution: options.startDetachedExecution,
+        cleanupExecution: options.cleanupExecution,
+        setActiveSpanAttributes: options.setActiveSpanAttributes,
+        trace,
+        logger: options.logger,
+    });
+    const agentConfig = options.getAgentConfig();
+    const service = defineAgentService({
+        serviceName: options.serviceName,
+        agent: agent({
+            id: agentConfig.id,
+            system: agentConfig.instructions,
+            model: agentConfig.model,
+            maxSteps: agentConfig.maxSteps,
+        }),
+        server: {
+            port: config.PORT,
+            cors: {
+                origins: config.ALLOWED_ORIGINS,
+                credentials: true,
+            },
+        },
+    });
+    const routes = routeSet.routes;
+    return {
+        config,
+        tracker,
+        auth,
+        routeSet,
+        routes,
+        lifecycle: createDetachedRunShutdownLifecycle({
+            tracker,
+            logger: options.logger,
+            drainTimeoutMs: options.drainTimeoutMs,
+        }),
+        runtime: service.createRuntime({ routes }),
+    };
+}
+export async function startNodeHostedAgentService(options) {
+    const bundle = createHostedAgentServiceRuntime(options);
+    const nodeServer = await startNodeAgentServiceServer({
+        runtime: bundle.runtime,
+        serviceName: options.serviceName,
+        lifecycle: bundle.lifecycle,
+        port: bundle.config.PORT,
+        bindAddress: options.bindAddress,
+        signals: options.signals,
+        logger: options.logger,
+        hardShutdownTimeoutMs: options.hardShutdownTimeoutMs,
+    });
+    return {
+        ...bundle,
+        nodeServer,
+    };
+}

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

@@ -96,6 +96,7 @@ export { agent } from "./factory.js";
 export { isResponseLike } from "./response-like.js";
 export { type AgentContract, type AgentRegistry, type AgentServiceCorsConfig, type AgentServiceDefinition, type AgentServiceRegistryContract, type AgentServiceRoute, type AgentServiceRouteMethod, type AgentServiceServerConfig, type AgentServiceSingleAgentContract, defineAgentService, type DurableRunSink, type NormalizedAgentServiceContract, } from "./agent-service.js";
 export { type AgentServiceServerLifecycle, createAgentServiceServerRuntime, type CreateAgentServiceServerRuntimeOptions, type NodeAgentServiceServer, startNodeAgentServiceServer, type StartNodeAgentServiceServerOptions, } from "./agent-service-server.js";
+export { createHostedAgentServiceRuntime, type CreateHostedAgentServiceRuntimeOptions, type HostedAgentServiceRuntimeBundle, type HostedAgentServiceRuntimeConfig, type HostedAgentServiceRuntimeLogger, type HostedAgentServiceRuntimeTrace, startNodeHostedAgentService, type StartNodeHostedAgentServiceOptions, type StartNodeHostedAgentServiceResult, } from "./hosted-agent-service-runtime.js";
 export { type AgentServiceBootstrapExit, type AgentServiceTraceContext, type AgentServiceTraceContextGetter, bootstrapAgentService, type BootstrapAgentServiceOptions, runAgentServiceMain, type RunAgentServiceMainOptions, } from "./agent-service-bootstrap.js";
 export { type AbortRejectionEvent, type AbortRejectionEventTarget, type AbortRejectionGuardLogger, type AbortRejectionProcessTarget, installAbortRejectionGuard, type InstallAbortRejectionGuardOptions, type InstalledAbortRejectionGuard, isAbortRejectionReason, } from "./abort-rejection-guard.js";
 export { type CachedRequestAuthResult, createRequestAuthCache, type CreateRequestAuthCacheOptions, type RequestAuthCache, } from "./request-auth-cache.js";
@@ -157,6 +158,7 @@ export { createHostedChildPendingToolLifecycle, createHostedChildPendingToolLife
 export { composeAbortSignals, HOSTED_CHILD_STREAM_TIMEOUT_TOKEN, HostedChildStreamIdleTimeoutError, type HostedChildStreamWatchdogPhase, type HostedChildStreamWatchdogState, resolveHostedChildPromiseWithTimeout, resolveHostedChildStreamWatchdogState, withHostedChildStreamIdleTimeout, } from "./hosted-child-stream-watchdog.js";
 export { DEFAULT_HOSTED_CHILD_AGENT_ID, type HostedChildForkRuntimeConfig, type HostedChildForkToolInput, hostedChildForkToolInputSchema, resolveHostedChildForkRuntimeConfig, type ResolveHostedChildForkRuntimeConfigInput, resolveHostedChildForkThinkingOverride, } from "./hosted-child-tool-input.js";
 export { createHostedChildInvokeTool, type CreateHostedChildInvokeToolOptions, type HostedChildInvokeFailure, } from "./hosted-child-invoke-tool.js";
+export { createDefaultHostedInvokeAgentTool, type DefaultHostedInvokeAgentConfig, type DefaultHostedInvokeAgentContext, type DefaultHostedInvokeAgentInput, defaultHostedInvokeAgentInputSchema, type DefaultHostedInvokeAgentLogger, type DefaultHostedInvokeAgentProjectRefresh, defaultHostedInvokeAgentSelectionSchema, type DefaultHostedInvokeAgentToolOptions, type DefaultHostedInvokeAgentToolResult, type DefaultHostedInvokeAgentTrace, type DefaultHostedInvokeAgentTraceAttributes, executeDefaultHostedInvokeAgentTool, } from "./default-hosted-invoke-agent-tool.js";
 export { buildDefaultHostedChildForkToolSet, buildHostedChildToolDescription, DEFAULT_HOSTED_CHILD_EXCLUDED_TOOL_NAMES, DEFAULT_HOSTED_CHILD_REQUESTED_TOOL_COMPANIONS, DEFAULT_HOSTED_CHILD_SANDBOX_REQUIRED_CUE_PATTERN, type DefaultHostedChildForkRuntimeToolPreparationResult, type DefaultHostedChildForkToolAssemblyResult, type DefaultHostedChildForkToolAssemblySourceResult, expandHostedChildRequestedTools, type HostedChildForkRuntimeToolSelectionResult, type HostedChildRequestedToolsInput, prepareDefaultHostedChildForkRuntimeTools, prepareDefaultHostedChildForkToolAssembly, sanitizeDefaultHostedChildRequestedTools, sanitizeHostedChildRequestedTools, selectDefaultHostedChildForkRuntimeTools, selectHostedChildForkRuntimeTools, shouldPruneSandboxToolsFromHostedChildRequest, } from "./hosted-child-requested-tools.js";
 export { getHostedChildWrittenArtifactPath, type HostedChildFileWriteFallbackLogger, type HostedChildFileWriteFallbackTool, type HostedChildFileWriteFallbackToolExecute, type HostedChildWrittenArtifactPathInput, isHostedChildCreateFileAlreadyExistsResult, isHostedChildTextProjectArtifactPrompt, normalizeHostedChildArtifactPath, withHostedChildRerunnableFileWriteFallbacks, } from "./hosted-child-artifact-support.js";
 export { buildDefaultResearchArtifactPathReminder, buildDefaultResearchArtifactPaths, type DefaultResearchArtifactPaths, shouldInjectDefaultResearchArtifactPath, withDefaultResearchArtifactPath, } from "./default-research-artifact-policy.js";