veryfront 0.1.516 → 0.1.518

package/src/src/agent/hosted-child-execution-logging.ts

@@ -1,114 +0,0 @@
-import { HostedChildStreamIdleTimeoutError } from "./hosted-child-stream-watchdog.js";
-
-export type HostedChildExecutionLogLevel = "error" | "info" | "warn";
-
-export interface HostedChildExecutionLogEntry {
-  level: HostedChildExecutionLogLevel;
-  message: string;
-  context: Record<string, unknown>;
-}
-
-export interface HostedChildExecutionLogWriter {
-  error: (message: string, context: Record<string, unknown>) => void;
-  info: (message: string, context: Record<string, unknown>) => void;
-  warn: (message: string, context: Record<string, unknown>) => void;
-}
-
-export function writeHostedChildExecutionLogEntry(
-  entry: HostedChildExecutionLogEntry,
-  writer: HostedChildExecutionLogWriter,
-): void {
-  if (entry.level === "error") {
-    writer.error(entry.message, entry.context);
-    return;
-  }
-
-  if (entry.level === "info") {
-    writer.info(entry.message, entry.context);
-    return;
-  }
-
-  writer.warn(entry.message, entry.context);
-}
-
-export function createHostedChildExecutionLogWriter(
-  writer: HostedChildExecutionLogWriter,
-): (entry: HostedChildExecutionLogEntry) => void {
-  return (entry) => {
-    writeHostedChildExecutionLogEntry(entry, writer);
-  };
-}
-
-export function buildHostedChildExhaustedStepBudgetLog(input: {
-  description: string;
-  kind: string;
-  stepCount: number;
-  maxSteps: number;
-  toolCallsLength: number;
-}): HostedChildExecutionLogEntry {
-  return {
-    level: "warn",
-    message: "Child fork exhausted step budget",
-    context: {
-      description: input.description,
-      kind: input.kind,
-      stepCount: input.stepCount,
-      maxSteps: input.maxSteps,
-      toolCalls: input.toolCallsLength,
-    },
-  };
-}
-
-export function buildHostedChildCompletedLog(input: {
-  description: string;
-  kind: string;
-  toolCallsLength: number;
-  finalText: string;
-}): HostedChildExecutionLogEntry {
-  return {
-    level: "info",
-    message: "Child fork completed",
-    context: {
-      description: input.description,
-      kind: input.kind,
-      toolCalls: input.toolCallsLength,
-      resultLength: input.finalText.length,
-      resultPreview: input.finalText.substring(0, 200),
-    },
-  };
-}
-
-export function buildHostedChildErrorLog(input: {
-  description: string;
-  kind: string;
-  error: unknown;
-  finalText: string;
-  toolCallsLength: number;
-  toolResultsLength: number;
-}): HostedChildExecutionLogEntry {
-  if (input.error instanceof HostedChildStreamIdleTimeoutError) {
-    return {
-      level: "warn",
-      message: "Child fork stream stalled",
-      context: {
-        description: input.description,
-        kind: input.kind,
-        phase: input.error.phase,
-        idleTimeoutMs: input.error.timeoutMs,
-        partialTextLength: input.finalText.length,
-        toolCalls: input.toolCallsLength,
-        toolResults: input.toolResultsLength,
-      },
-    };
-  }
-
-  return {
-    level: "error",
-    message: "Child fork failed",
-    context: {
-      description: input.description,
-      kind: input.kind,
-      error: input.error,
-    },
-  };
-}

package/src/src/agent/hosted-child-fork-execution-runner.ts

@@ -1,393 +0,0 @@
-import type { HostToolTraceAttributes } from "../tool/index.js";
-import { buildChildRunFailureResult } from "./child-run-execution-snapshot.js";
-import {
-  createHostedDurableChildForkRunContext,
-  executeHostedChildForkRunContextStream,
-  finalizeHostedChildForkRunContextResources,
-  handleHostedChildForkRunContextError,
-  type HostedDurableChildForkRunContext,
-} from "./hosted-child-fork-run-context.js";
-import { type DefaultHostedChildForkToolAssemblyResult } from "./hosted-child-requested-tools.js";
-import {
-  addLoadSkillContinuationReminder,
-  shouldReinforceLoadSkillContinuation,
-} from "./conversation-delegation-policy.js";
-import {
-  buildHostedChildForkInstructions,
-  type HostedChildForkInstructionsContext,
-} from "./hosted-child-fork-instructions.js";
-import {
-  type HostedChildForkRuntimeStepSystemResolver,
-  prepareHostedChildForkRuntimeStepMessages,
-} from "./hosted-child-fork-step-message-preparation.js";
-import {
-  type StartedHostedChildForkRuntime,
-  startHostedChildForkRuntimeWithHostTools,
-  type StartHostedChildForkRuntimeWithHostToolsInput,
-} from "./hosted-child-fork-runtime-start.js";
-import { type AgentRuntimeForkStepRunner, runAgentRuntimeForkStep } from "./fork-runtime-stream.js";
-import type {
-  ChildRunExecutionResult,
-  ChildRunExecutionSnapshot,
-} from "./child-run-execution-snapshot.js";
-import type {
-  HostedConversationRunChunkMirrorInstrumentation,
-  HostedConversationRunChunkMirrorTraceAttributes,
-} from "./conversation-run-chunk-mirror.js";
-import type { HostedChildExecutionLogEntry } from "./hosted-child-execution-logging.js";
-import type {
-  HostedChildForkStreamLogger,
-  HostedChildForkStreamTraceInput,
-} from "./hosted-child-fork-stream-execution.js";
-import type { HostedChildRunIdentifiers } from "./hosted-child-status.js";
-import { throwIfChildRunAborted } from "./child-run-execution-support.js";
-import {
-  type HostedChildForkRuntimeConfig,
-  type HostedChildForkToolInput,
-  resolveHostedChildForkRuntimeConfig,
-  type ResolveHostedChildForkRuntimeConfigInput,
-} from "./hosted-child-tool-input.js";
-
-export const DEFAULT_HOSTED_CHILD_FORK_STREAM_IDLE_TIMEOUT_MS = 45_000;
-export const DEFAULT_HOSTED_CHILD_FORK_STREAM_ACTIVE_TOOL_TIMEOUT_MS = 5 * 60_000;
-export const DEFAULT_HOSTED_CHILD_FORK_STREAM_POST_TOOL_IDLE_TIMEOUT_MS = 2 * 60_000;
-export const DEFAULT_HOSTED_CHILD_FORK_STREAM_FINALIZATION_TIMEOUT_MS = 10_000;
-export const DEFAULT_HOSTED_CHILD_STATUS_POLL_INTERVAL_MS = 2_000;
-
-export type HostedChildForkExecutionInstrumentation<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
-> = {
-  trace?: <TResult>(operationName: string, operation: () => TResult) => TResult;
-  setTraceAttributes?: (
-    attributes: TAttributes | HostedConversationRunChunkMirrorTraceAttributes,
-  ) => void;
-  buildToolTraceAttributes?: (input: {
-    toolName: string;
-    toolCallId: string | undefined;
-  }) => TAttributes | undefined;
-  tracePart?: (input: HostedChildForkStreamTraceInput) => void | Promise<void>;
-  debug?: (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 HostedChildForkExecutionRunContextFactoryInput<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
-> = {
-  authToken: string;
-  apiUrl: string;
-  durableChildRun?: HostedChildRunIdentifiers;
-  conversationId?: string;
-  parentRunId?: string;
-  description: string;
-  instrumentation?: HostedChildForkExecutionInstrumentation<TAttributes>;
-  pendingToolLogWriter?: { warn: (message: string, metadata?: Record<string, unknown>) => void };
-};
-
-export type ExecuteHostedChildForkWithPreparedToolsInput<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
-> = {
-  authToken: string;
-  apiUrl: string;
-  projectId?: string | null;
-  description: string;
-  kind: string;
-  provider: string;
-  forkModel: string;
-  maxSteps: number;
-  effectivePrompt: string;
-  forkContext?: HostedChildForkInstructionsContext;
-  toolAssembly: DefaultHostedChildForkToolAssemblyResult;
-  abortSignal?: AbortSignal;
-  durableChildRun?: HostedChildRunIdentifiers;
-  conversationId?: string;
-  parentRunId?: string;
-  pendingToolLogWriter?: { warn: (message: string, metadata?: Record<string, unknown>) => void };
-  logger?: HostedChildForkStreamLogger;
-  instrumentation?: HostedChildForkExecutionInstrumentation<TAttributes>;
-  providerOptions?: Record<string, unknown>;
-  maxContinuationSteps?: number;
-  resolveSystem?: HostedChildForkRuntimeStepSystemResolver;
-  buildInstructions?: () => string;
-  onBeforeStop?: StartHostedChildForkRuntimeWithHostToolsInput<TAttributes>["onBeforeStop"];
-  runStep?: AgentRuntimeForkStepRunner;
-  createRunContext?: (
-    input: HostedChildForkExecutionRunContextFactoryInput<TAttributes>,
-  ) => HostedDurableChildForkRunContext;
-  startRuntime?: (
-    input: StartHostedChildForkRuntimeWithHostToolsInput<TAttributes>,
-  ) => StartedHostedChildForkRuntime | Promise<StartedHostedChildForkRuntime>;
-  childRunMonitorPollIntervalMs?: number;
-  idleTimeoutMs?: number;
-  activeToolTimeoutMs?: number;
-  postToolIdleTimeoutMs?: number;
-  finalizationTimeoutMs?: number;
-  startTime?: number;
-  onSettled?: (snapshot: ChildRunExecutionSnapshot) => void | Promise<void>;
-  writeLog?: (entry: HostedChildExecutionLogEntry) => void;
-  shouldRethrowError?: (error: unknown) => boolean;
-};
-
-function createForkRunContext<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
->(
-  input: HostedChildForkExecutionRunContextFactoryInput<TAttributes>,
-): HostedDurableChildForkRunContext {
-  const sourceInstrumentation = input.instrumentation;
-  const sourceTrace = sourceInstrumentation?.trace;
-  const instrumentation: HostedConversationRunChunkMirrorInstrumentation | undefined =
-    sourceInstrumentation
-      ? {
-        trace: sourceTrace
-          ? <TResult>(operationName: string, operation: () => Promise<TResult>) =>
-            sourceTrace(operationName, operation)
-          : undefined,
-        setTraceAttributes: sourceInstrumentation.setTraceAttributes,
-        debug: sourceInstrumentation.debug,
-        warn: sourceInstrumentation.warn,
-        error: sourceInstrumentation.error,
-      }
-      : undefined;
-
-  return createHostedDurableChildForkRunContext({
-    authToken: input.authToken,
-    apiUrl: input.apiUrl,
-    durableChildRun: input.durableChildRun,
-    instrumentation,
-    pendingToolLogContext: {
-      conversationId: input.conversationId,
-      parentRunId: input.parentRunId,
-      description: input.description,
-    },
-    pendingToolLogWriter: input.pendingToolLogWriter,
-  });
-}
-
-function defaultResolveSystem(input: {
-  system: string;
-  compactedMessages: Parameters<HostedChildForkRuntimeStepSystemResolver>[0]["compactedMessages"];
-}): string {
-  if (!shouldReinforceLoadSkillContinuation([...input.compactedMessages])) {
-    return input.system;
-  }
-
-  const remindedSystem = addLoadSkillContinuationReminder(input.system);
-  return typeof remindedSystem === "string" ? remindedSystem : input.system;
-}
-
-export type ExecuteHostedChildForkToolInputOptions<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
-> =
-  & Omit<
-    ExecuteHostedChildForkWithPreparedToolsInput<TAttributes>,
-    | "description"
-    | "provider"
-    | "forkModel"
-    | "maxSteps"
-    | "effectivePrompt"
-    | "toolAssembly"
-    | "providerOptions"
-  >
-  & {
-    forkInput: HostedChildForkToolInput;
-    toolCallId: string;
-    defaultModel: string;
-    defaultMaxSteps: number;
-    contextModel?: string;
-    onRequestedProjectId?: (projectId: string) => void | Promise<void>;
-    prepareToolAssembly: (input: {
-      runtimeConfig: HostedChildForkRuntimeConfig;
-      requestedTools?: HostedChildForkToolInput["tools"];
-      abortSignal?: AbortSignal;
-    }) =>
-      | DefaultHostedChildForkToolAssemblyResult
-      | Promise<DefaultHostedChildForkToolAssemblyResult>;
-    resolveModelId: ResolveHostedChildForkRuntimeConfigInput["resolveModelId"];
-    resolveProvider: ResolveHostedChildForkRuntimeConfigInput["resolveProvider"];
-    resolveProviderOptions?: (
-      forkModel: string,
-      thinkingConfig: HostedChildForkRuntimeConfig["thinkingConfig"],
-    ) => Record<string, unknown> | undefined;
-    onRuntimeConfig?: (runtimeConfig: HostedChildForkRuntimeConfig) => void | Promise<void>;
-  };
-
-export async function executeHostedChildForkToolInput<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
->(
-  input: ExecuteHostedChildForkToolInputOptions<TAttributes>,
-): Promise<ChildRunExecutionResult> {
-  if (input.forkInput.project_id) {
-    await input.onRequestedProjectId?.(input.forkInput.project_id);
-  }
-
-  const runtimeConfig = resolveHostedChildForkRuntimeConfig({
-    forkInput: input.forkInput,
-    contextModel: input.contextModel,
-    defaultModel: input.defaultModel,
-    defaultMaxSteps: input.defaultMaxSteps,
-    runId: input.durableChildRun?.childRunId ?? input.toolCallId,
-    resolveModelId: input.resolveModelId,
-    resolveProvider: input.resolveProvider,
-  });
-
-  await input.onRuntimeConfig?.(runtimeConfig);
-
-  const toolAssembly = await input.prepareToolAssembly({
-    runtimeConfig,
-    requestedTools: runtimeConfig.requestedTools,
-    abortSignal: input.abortSignal,
-  });
-
-  return executeHostedChildForkWithPreparedTools({
-    ...input,
-    description: runtimeConfig.description,
-    provider: runtimeConfig.provider,
-    forkModel: runtimeConfig.forkModel,
-    maxSteps: runtimeConfig.maxSteps,
-    effectivePrompt: runtimeConfig.effectivePrompt,
-    toolAssembly,
-    providerOptions: input.resolveProviderOptions?.(
-      runtimeConfig.forkModel,
-      runtimeConfig.thinkingConfig,
-    ),
-  });
-}
-
-export async function executeHostedChildForkWithPreparedTools<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
->(
-  input: ExecuteHostedChildForkWithPreparedToolsInput<TAttributes>,
-): Promise<ChildRunExecutionResult> {
-  const startTime = input.startTime ?? Date.now();
-  const createRunContext = input.createRunContext ?? createForkRunContext;
-  const runContext = createRunContext({
-    authToken: input.authToken,
-    apiUrl: input.apiUrl,
-    durableChildRun: input.durableChildRun,
-    conversationId: input.conversationId,
-    parentRunId: input.parentRunId,
-    description: input.description,
-    instrumentation: input.instrumentation,
-    pendingToolLogWriter: input.pendingToolLogWriter,
-  });
-
-  let closeTooling: (() => Promise<void>) | undefined;
-  let closeRuntime: (() => Promise<void>) | undefined;
-  let childRunMonitorAbortController: AbortController | null = null;
-  let childRunMonitorPromise: Promise<void> = Promise.resolve();
-
-  try {
-    throwIfChildRunAborted(input.abortSignal);
-    if (!input.toolAssembly.ok) {
-      return buildChildRunFailureResult(
-        {
-          description: input.description,
-          steps: 0,
-          toolCalls: [],
-          toolResults: [],
-          durationMs: Date.now() - startTime,
-        },
-        input.toolAssembly.errorMessage,
-      );
-    }
-
-    closeTooling = input.toolAssembly.closeTooling;
-    closeRuntime = input.toolAssembly.closeRuntime;
-    const buildInstructions = input.buildInstructions ??
-      (() => buildHostedChildForkInstructions(input.forkContext));
-    const sourceInstrumentation = input.instrumentation;
-    const sourceTrace = sourceInstrumentation?.trace;
-    const traceTools = sourceTrace
-      ? {
-        trace: <TResult>(spanName: string, operation: () => TResult): TResult =>
-          sourceTrace(spanName, operation),
-        buildAttributes: sourceInstrumentation.buildToolTraceAttributes,
-        setAttributes: sourceInstrumentation.setTraceAttributes,
-      }
-      : undefined;
-    const startRuntime = input.startRuntime ?? startHostedChildForkRuntimeWithHostTools;
-    const started = await startRuntime({
-      apiUrl: input.apiUrl,
-      authToken: input.authToken,
-      projectId: input.projectId ?? null,
-      provider: input.provider,
-      forkModel: input.forkModel,
-      maxSteps: input.maxSteps,
-      prompt: input.effectivePrompt,
-      maxContinuationSteps: input.maxContinuationSteps ?? 0,
-      abortSignal: input.abortSignal,
-      forkTools: input.toolAssembly.forkTools,
-      providerOptions: input.providerOptions,
-      buildInstructions,
-      onBeforeStop: input.onBeforeStop ?? (() => null),
-      durableChildRun: input.durableChildRun,
-      childRunMonitorPollIntervalMs: input.childRunMonitorPollIntervalMs ??
-        DEFAULT_HOSTED_CHILD_STATUS_POLL_INTERVAL_MS,
-      logger: input.logger?.warn ? { warn: input.logger.warn } : undefined,
-      prepareStep: ({ messages, buildInstructions: prepareBuildInstructions, forkToolNames }) =>
-        prepareHostedChildForkRuntimeStepMessages({
-          messages,
-          buildInstructions: prepareBuildInstructions,
-          forkToolNames,
-          resolveSystem: input.resolveSystem ?? defaultResolveSystem,
-        }),
-      runStep: input.runStep ?? runAgentRuntimeForkStep,
-      traceTools,
-    });
-    childRunMonitorAbortController = started.childRunMonitorAbortController;
-    childRunMonitorPromise = started.childRunMonitorPromise;
-
-    return await executeHostedChildForkRunContextStream({
-      runContext,
-      streamResult: started.streamResult,
-      abortSignal: input.abortSignal,
-      abortForkStream: (error) => {
-        if (!started.forkStreamAbortController.signal.aborted) {
-          started.forkStreamAbortController.abort(error);
-        }
-      },
-      conversationId: input.conversationId,
-      parentRunId: input.parentRunId,
-      description: input.description,
-      kind: input.kind,
-      usage: undefined,
-      maxSteps: input.maxSteps,
-      startTime,
-      finalizationTimeoutMs: input.finalizationTimeoutMs ??
-        DEFAULT_HOSTED_CHILD_FORK_STREAM_FINALIZATION_TIMEOUT_MS,
-      onSettled: input.onSettled,
-      idleTimeoutMs: input.idleTimeoutMs ?? DEFAULT_HOSTED_CHILD_FORK_STREAM_IDLE_TIMEOUT_MS,
-      activeToolTimeoutMs: input.activeToolTimeoutMs ??
-        DEFAULT_HOSTED_CHILD_FORK_STREAM_ACTIVE_TOOL_TIMEOUT_MS,
-      postToolIdleTimeoutMs: input.postToolIdleTimeoutMs ??
-        DEFAULT_HOSTED_CHILD_FORK_STREAM_POST_TOOL_IDLE_TIMEOUT_MS,
-      logger: input.logger,
-      writeLog: input.writeLog,
-      tracePart: input.instrumentation?.tracePart,
-    });
-  } catch (error) {
-    return handleHostedChildForkRunContextError({
-      error,
-      abortSignal: input.abortSignal,
-      description: input.description,
-      kind: input.kind,
-      runContext,
-      usage: undefined,
-      startTime,
-      onSettled: input.onSettled,
-      shouldRethrowError: input.shouldRethrowError,
-      writeLog: input.writeLog,
-    });
-  } finally {
-    await finalizeHostedChildForkRunContextResources({
-      runContext,
-      monitorAbortController: childRunMonitorAbortController,
-      monitorPromise: childRunMonitorPromise,
-      flushMirror: () => runContext.durableRunMirror?.flush() ?? Promise.resolve(),
-      closeTooling,
-      closeRuntime,
-    });
-    closeTooling = undefined;
-    closeRuntime = undefined;
-  }
-}