@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/runs/foreground/invocation-execution.ts

@@ -1,465 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getArtifactsDir } from "../../shared/artifacts.ts";
-import { isParallelStep, isDynamicParallelStep } from "../../shared/settings.ts";
-import { createPerAgentForkContextResolver } from "../../shared/agent-context-policy.ts";
-import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
-import {
-  resolveIntercomBridge,
-  resolveIntercomSessionTarget,
-  resolveOrchestratorIntercomTarget,
-  type IntercomBridgeState,
-} from "../../intercom/intercom-bridge.ts";
-import { resolveControlConfig } from "../shared/subagent-control.ts";
-import { createNestedRoute, resolveInheritedNestedRouteFromEnv } from "../shared/nested-events.ts";
-import { applyForceTopLevelAsyncOverride } from "../background/top-level-async.ts";
-import { saveQuestionOwner } from "../shared/supervisor-questions.ts";
-import { buildWorkflowGraphSnapshot, workflowAgentNodes } from "../shared/workflow-graph.ts";
-import { rememberOwnedRun, workflowChildren } from "../shared/run-records.ts";
-import { errorMessage } from "../../shared/unknown.ts";
-import {
-  type SubagentExecutionResult,
-  type SubagentExecutionUpdateCallback,
-  type SubagentRunMode,
-  type ReadonlyInput,
-  checkSubagentDepth,
-} from "../../shared/types.ts";
-import {
-  type ExecutionContextData,
-  type ExecutorDeps,
-  type SubagentParamsLike,
-  resolveAsyncExecutionMode,
-} from "./subagent-params.ts";
-import {
-  buildRequestedModeError,
-  normalizeRepeatedParallelCounts,
-  normalizeRoleForegroundTimeout,
-  resolveForegroundTimeoutMs,
-  toExecutionErrorResult,
-  validateExecutionInput,
-  withForkContext,
-} from "./execution-input.ts";
-import { runAsyncPath } from "./run-async-path.ts";
-import { canClarifyInvocation, clarifyInvocation } from "./clarify-invocation.ts";
-import { waitForOwnedRun } from "./wait-run.ts";
-
-export interface ExecutionInvocation {
-  readonly params: SubagentParamsLike;
-  readonly invocationCwd: string;
-  readonly ctx: ExtensionContext;
-  readonly signal?: AbortSignal;
-  readonly onUpdate?: SubagentExecutionUpdateCallback;
-}
-import {
-  discoverInvocation,
-  validateInvocationForkModel,
-  type AgentInvocation,
-} from "./invocation-context.ts";
-interface LaunchPreparation {
-  readonly call: ExecutionInvocation;
-  readonly params: SubagentParamsLike;
-  readonly cwd: string;
-  readonly parentSessionFile: string | null;
-  readonly agents: AgentInvocation;
-  readonly runId: string;
-  readonly intercomBridge: Readonly<IntercomBridgeState>;
-  readonly nestedRoute: NonNullable<ExecutionContextData["nestedRoute"]>;
-}
-interface SessionLayout {
-  readonly root: string;
-  readonly dir: (index?: number) => string;
-}
-interface LaunchResources {
-  readonly sessions: Readonly<ReturnType<typeof createPerAgentForkContextResolver>>;
-  readonly policy: AsyncPolicy;
-  readonly layout: SessionLayout;
-  readonly artifactsDir: string;
-  readonly controlConfig: ExecutionContextData["controlConfig"];
-}
-type Assignments = readonly {
-  readonly agent: string;
-  readonly task?: string;
-  readonly label?: string;
-}[];
-interface AsyncPolicy {
-  readonly backgroundRequestedWhileClarifying: boolean;
-  readonly effectiveAsync: boolean;
-  readonly foregroundTimeoutMs?: number;
-}
-function mode(params: SubagentParamsLike): SubagentRunMode {
-  if ((params.chain?.length ?? 0) > 0) {
-    return "chain";
-  }
-  if ((params.tasks?.length ?? 0) > 0) {
-    return "parallel";
-  }
-  return "single";
-}
-function invocationModes(params: SubagentParamsLike, ctx: ExtensionContext) {
-  const hasChain = (params.chain?.length ?? 0) > 0,
-    hasTasks = (params.tasks?.length ?? 0) > 0;
-  return {
-    hasChain,
-    hasTasks,
-    hasSingle: !hasChain && !hasTasks && params.agent !== undefined && params.agent.length > 0,
-    allowClarifyTaskPrompt: hasChain && canClarifyInvocation(params, ctx),
-  };
-}
-/** Owns launch planning and its durable registration, not management or existing-run waits. */
-export class InvocationExecution {
-  private readonly deps: ExecutorDeps;
-  constructor(
-    // Launch owns the current session identity and tracked/durable run records through these dependencies.
-    deps: ExecutorDeps,
-  ) {
-    this.deps = deps;
-  }
-  async execute(call: ExecutionInvocation): Promise<SubagentExecutionResult> {
-    const depth = checkSubagentDepth(this.deps.config.maxSubagentDepth);
-    if (depth.blocked) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Nested subagent call blocked (depth=${depth.depth}, max=${depth.maxDepth}). You are running at the maximum subagent nesting depth. Complete your current task directly without delegating to further subagents.`,
-          },
-        ],
-        isError: true,
-        details: { mode: "single", results: [] },
-      };
-    }
-    const normalized = normalizeRepeatedParallelCounts(call.params);
-    if (normalized.error) {
-      return normalized.error;
-    }
-    if (!normalized.params) {
-      throw new Error("Task normalization did not return launch input.");
-    }
-    const params = applyForceTopLevelAsyncOverride(
-      normalized.params,
-      depth.depth,
-      this.deps.config.forceTopLevelAsync === true,
-    );
-    const cwd = params.cwd ?? call.invocationCwd;
-    const parentSessionFile = call.ctx.sessionManager.getSessionFile() ?? null;
-    this.deps.state.currentSessionId = resolveCurrentSessionId(call.ctx.sessionManager);
-    const agents = discoverInvocation(params, cwd, call.ctx, this.deps);
-    const fallback = resolveIntercomSessionTarget(
-      this.deps.pi.getSessionName(),
-      call.ctx.sessionManager.getSessionId(),
-    );
-    const intercomBridge = resolveIntercomBridge(
-      resolveOrchestratorIntercomTarget(this.deps.pi.events, fallback),
-    );
-    const runId = randomUUID();
-    const nestedRoute = resolveInheritedNestedRouteFromEnv() ?? createNestedRoute(runId);
-    const invalid =
-      validateExecutionInput(params, agents.agents, invocationModes(params, call.ctx)) ??
-      validateInvocationForkModel(params, agents, call.ctx);
-    if (invalid) {
-      return invalid;
-    }
-    return this.prepareLaunch({
-      call,
-      params,
-      agents,
-      cwd,
-      runId,
-      parentSessionFile,
-      intercomBridge,
-      nestedRoute,
-    });
-  }
-  private async prepareLaunch(input: LaunchPreparation): Promise<SubagentExecutionResult> {
-    const { call, params, agents, cwd, runId, parentSessionFile } = input;
-    const clarified = await this.clarify(params, agents, {
-      ctx: call.ctx,
-      signal: call.signal,
-      cwd,
-      runId,
-    });
-    if ("details" in clarified) {
-      return clarified;
-    }
-    const sessions = this.resolveForkSessions(agents, call.ctx, clarified);
-    if ("details" in sessions) {
-      return sessions;
-    }
-    const policy = this.asyncPolicy(clarified);
-    if ("details" in policy) {
-      return policy;
-    }
-    const controlConfig = resolveControlConfig(this.deps.config.control, clarified.control);
-    const artifactsDir = policy.effectiveAsync
-      ? this.deps.tempArtifactsDir
-      : getArtifactsDir(parentSessionFile);
-    const layout = this.sessionLayout(clarified, parentSessionFile, runId, agents.context);
-    if ("details" in layout) {
-      return layout;
-    }
-    return this.launch(
-      this.executionData(input, clarified, {
-        sessions,
-        policy,
-        layout,
-        artifactsDir,
-        controlConfig,
-      }),
-      agents.context,
-    );
-  }
-  private executionData(
-    input: LaunchPreparation,
-    clarified: SubagentParamsLike,
-    resources: LaunchResources,
-  ): ExecutionContextData {
-    const { call, agents, cwd, runId, intercomBridge, nestedRoute } = input;
-    const { sessions, policy, layout, artifactsDir, controlConfig } = resources;
-    const update = this.progressUpdate(runId, agents.context, call.onUpdate);
-    return {
-      params: clarified,
-      effectiveCwd: cwd,
-      ctx: call.ctx,
-      signal: call.signal,
-      onUpdate: update,
-      agents: agents.agents,
-      runId,
-      shareEnabled: clarified.share === true,
-      sessionRoot: layout.root,
-      sessionDirForIndex: layout.dir,
-      sessionFileForIndex: (index) =>
-        sessions.sessionFileForIndex(index) ?? path.join(layout.dir(index), "session.jsonl"),
-      sessionFileForAgentIndex: (agent, index) =>
-        sessions.sessionFileForAgentIndex(agent, index) ??
-        path.join(layout.dir(index), "session.jsonl"),
-      artifactsEnabled: clarified.artifacts !== false,
-      artifactsDir,
-      ...policy,
-      controlConfig,
-      intercomBridge,
-      nestedRoute,
-    };
-  }
-  private async clarify(
-    params: SubagentParamsLike,
-    agents: AgentInvocation,
-    call: {
-      readonly ctx: ExtensionContext;
-      readonly signal?: AbortSignal;
-      readonly cwd: string;
-      readonly runId: string;
-    },
-  ): Promise<SubagentParamsLike | SubagentExecutionResult> {
-    try {
-      const clarified = await clarifyInvocation({
-        params,
-        agents: agents.agents,
-        ctx: call.ctx,
-        cwd: call.cwd,
-        runId: call.runId,
-      });
-      if (!clarified) {
-        return {
-          content: [{ type: "text", text: "Cancelled" }],
-          details: { mode: mode(params), results: [] },
-        };
-      }
-      if (call.signal?.aborted === true) {
-        return toExecutionErrorResult(
-          clarified,
-          new Error("Subagent cancelled before launch."),
-          agents.context,
-        );
-      }
-      return clarified;
-    } catch (error) {
-      return toExecutionErrorResult(params, error, agents.context);
-    }
-  }
-  private resolveForkSessions(
-    agents: AgentInvocation,
-    ctx: ExtensionContext,
-    params: SubagentParamsLike,
-  ): ReturnType<typeof createPerAgentForkContextResolver> | SubagentExecutionResult {
-    try {
-      return createPerAgentForkContextResolver(ctx.sessionManager, agents.resolveContextForIndex, {
-        resolveContextForAgentIndex: (name) => agents.resolveContextForAgent(name),
-      });
-    } catch (error) {
-      return toExecutionErrorResult(params, error, agents.context);
-    }
-  }
-  private asyncPolicy(params: SubagentParamsLike): AsyncPolicy | SubagentExecutionResult {
-    const async = resolveAsyncExecutionMode(params, this.deps.asyncByDefault);
-    const timeout = resolveForegroundTimeoutMs(params);
-    if (timeout.error !== undefined) {
-      return buildRequestedModeError(params, timeout.error);
-    }
-    if (async.effectiveAsync && timeout.timeoutMs !== undefined) {
-      return buildRequestedModeError(
-        params,
-        "timeoutMs/maxRuntimeMs only applies to foreground subagent runs. Set async:false or use action:'interrupt' for background runs.",
-      );
-    }
-    return {
-      effectiveAsync: async.effectiveAsync,
-      backgroundRequestedWhileClarifying:
-        mode(params) !== "single" && async.backgroundRequestedWhileClarifying,
-      foregroundTimeoutMs: async.effectiveAsync
-        ? timeout.timeoutMs
-        : normalizeRoleForegroundTimeout(params, timeout.timeoutMs),
-    };
-  }
-  private sessionLayout(
-    params: SubagentParamsLike,
-    parent: string | null,
-    runId: string,
-    context: SubagentParamsLike["context"],
-  ): { readonly root: string; readonly dir: (index?: number) => string } | SubagentExecutionResult {
-    const requested = params.sessionDir;
-    const configured = this.deps.config.defaultSessionDir;
-    let root: string;
-    if (requested !== undefined && requested.length > 0) {
-      root = path.resolve(this.deps.expandTilde(requested));
-    } else {
-      const base =
-        configured !== undefined && configured.length > 0
-          ? path.resolve(this.deps.expandTilde(configured))
-          : this.deps.getSubagentSessionRoot(parent);
-      root = path.join(base, runId);
-    }
-    try {
-      fs.mkdirSync(root, { recursive: true });
-    } catch (error) {
-      return toExecutionErrorResult(
-        params,
-        new Error(`Failed to create session directory '${root}': ${errorMessage(error)}`),
-        context,
-      );
-    }
-    return { root, dir: (index) => path.join(root, `run-${index ?? 0}`) };
-  }
-  private progressUpdate(
-    runId: string,
-    context: SubagentParamsLike["context"],
-    onUpdate: SubagentExecutionUpdateCallback | undefined,
-  ): SubagentExecutionUpdateCallback {
-    return (result) => {
-      const owned = this.deps.state.ownedRuns?.get(runId);
-      if (owned && result.details.workflowGraph) {
-        rememberOwnedRun(this.deps.state, {
-          ...owned,
-          children: workflowChildren(owned.children, result.details.workflowGraph),
-        });
-      }
-      onUpdate?.(withForkContext(result, context));
-    };
-  }
-  private rememberLaunch(
-    data: ExecutionContextData,
-    result: SubagentExecutionResult,
-    nodes: ReadonlyInput<ReturnType<typeof workflowAgentNodes>> | undefined,
-    assignments: Assignments,
-  ): void {
-    const params = data.params;
-    rememberOwnedRun(this.deps.state, {
-      runId: data.runId,
-      ownerSessionId: data.ctx.sessionManager.getSessionId(),
-      rootRunId: data.runId,
-      source: "async",
-      mode: mode(params),
-      cwd: data.effectiveCwd,
-      task:
-        params.task ?? params.tasks?.map((task) => task.task).join("\n") ?? "Delegated workflow",
-      asyncDir: result.details.asyncDir,
-      pid: result.details.asyncPid ?? this.deps.state.asyncJobs.get(data.runId)?.pid,
-      startedAt: Date.now(),
-      children: assignments.map((assignment, index) => ({
-        agent: assignment.agent,
-        index,
-        task: assignment.task,
-        label: assignment.label,
-        workflowNodeId: nodes?.at(index)?.id,
-      })),
-    });
-  }
-  private assignments(params: SubagentParamsLike): Assignments {
-    if (params.tasks) {
-      return params.tasks;
-    }
-    if (params.chain) {
-      return params.chain.flatMap((step) => {
-        if (isParallelStep(step)) {
-          return step.parallel;
-        }
-        return isDynamicParallelStep(step) ? [step.parallel] : [step];
-      });
-    }
-    if (params.agent === undefined) {
-      throw new Error("Single launch requires an agent.");
-    }
-    return [{ agent: params.agent, task: params.task, label: params.label }];
-  }
-  private async launch(
-    data: ExecutionContextData,
-    context: SubagentParamsLike["context"],
-  ): Promise<SubagentExecutionResult> {
-    const graph = data.params.chain
-      ? buildWorkflowGraphSnapshot({ runId: data.runId, steps: data.params.chain })
-      : undefined;
-    const nodes = graph ? workflowAgentNodes(graph) : undefined;
-    const assignments = this.assignments(data.params);
-    saveQuestionOwner(data.runId, data.ctx.sessionManager.getSessionId());
-    try {
-      const result = runAsyncPath(data, this.deps);
-      if (!result) {
-        throw new Error("Invalid subagent execution mode.");
-      }
-      if (result.isError === true) {
-        return withForkContext(result, context);
-      }
-      this.rememberLaunch(data, result, nodes, assignments);
-      if (this.foregroundWaitNeeded(data, result)) {
-        return withForkContext(
-          await waitForOwnedRun({
-            id: data.runId,
-            deps: this.deps,
-            ctx: data.ctx,
-            signal: data.signal,
-            onUpdate: data.onUpdate,
-            cancelNewRun: true,
-            executionResult: true,
-            includeProgress: data.params.includeProgress,
-          }),
-          context,
-        );
-      }
-      return withForkContext(result, context);
-    } catch (error) {
-      const result = toExecutionErrorResult(data.params, error, context);
-      this.rememberLaunchFailure(data.runId, result);
-      return result;
-    }
-  }
-  private foregroundWaitNeeded(
-    data: ExecutionContextData,
-    result: SubagentExecutionResult,
-  ): boolean {
-    const id = result.details.asyncId;
-    return !data.effectiveAsync && id !== undefined && id.length > 0;
-  }
-  private rememberLaunchFailure(runId: string, result: SubagentExecutionResult): void {
-    const owned = this.deps.state.ownedRuns?.get(runId);
-    if (owned) {
-      rememberOwnedRun(this.deps.state, {
-        ...owned,
-        error: result.content
-          .filter((part) => part.type === "text")
-          .map((part) => part.text)
-          .join("\n"),
-      });
-    }
-  }
-}

package/src/runs/foreground/invocation-expansion.ts

@@ -1,58 +0,0 @@
-import { isParallelStep, type ChainStep } from "../../shared/settings.ts";
-import type { SubagentExecutionResult } from "../../shared/types.ts";
-import type { SubagentParamsLike } from "./subagent-params.ts";
-
-function expandTasks<T extends { readonly count?: number }>(
-  tasks: readonly T[],
-  prefix: string,
-): Omit<T, "count">[] {
-  const expanded: Omit<T, "count">[] = [];
-  for (const [index, task] of tasks.entries()) {
-    const count: unknown = task.count;
-    if (
-      count !== undefined &&
-      (typeof count !== "number" || !Number.isInteger(count) || count < 1)
-    ) {
-      throw new Error(`${prefix}[${index}].count must be an integer >= 1`);
-    }
-    const { count: _count, ...concrete } = task;
-    for (let repeat = 0; repeat < (typeof count === "number" ? count : 1); repeat++) {
-      expanded.push({ ...concrete });
-    }
-  }
-  return expanded;
-}
-function expandChain(chain: readonly ChainStep[]): ChainStep[] {
-  return chain.map((step, index) => {
-    if (!isParallelStep(step)) {
-      return step;
-    }
-    const parallel = expandTasks(step.parallel, `chain[${index}].parallel`);
-    return { ...step, parallel };
-  });
-}
-export function normalizeRepeatedParallelCounts(params: SubagentParamsLike): {
-  params?: SubagentParamsLike;
-  error?: SubagentExecutionResult;
-} {
-  try {
-    if (params.tasks) {
-      return { params: { ...params, tasks: expandTasks(params.tasks, "tasks") } };
-    }
-    if (params.chain) {
-      return { params: { ...params, chain: expandChain(params.chain) } };
-    }
-    return { params };
-  } catch (error) {
-    const mode = params.tasks ? "parallel" : "chain";
-    return {
-      error: {
-        isError: true,
-        content: [
-          { type: "text", text: error instanceof Error ? error.message : "Task expansion failed." },
-        ],
-        details: { mode, results: [], ...(params.context === "fork" ? { context: "fork" } : {}) },
-      },
-    };
-  }
-}