Method findChildRunForOutput

packages/runtime/src/session-manager.ts:5141–5218

(
    sessionId: string,
    input: AgentOutputInput,
  )

  }

  private async findChildRunForOutput(
    sessionId: string,
    input: AgentOutputInput,
  ): Promise<{
    header: AgentRunHeader;
    execution: SubagentExecutionRef;
    graph?: NonNullable<SubagentSessionParent['graph']>;
  }> {
    if (Number(!!input.execution) + Number(!!input.runId) + Number(!!input.turnId) !== 1) {
      throw new Error('agent_output requires exactly one execution, runId, or turnId locator');
    }
    if (input.execution?.kind === 'child_session') {
      const execution = input.execution;
      const child = await this.deps.store.readHeader(execution.sessionId).catch((error) => {
        if (isNotFoundError(error)) return undefined;
        throw error;
      });
      if (
        !child ||
        child.subagentParent?.kind !== 'subagent' ||
        child.subagentParent.parentSessionId !== sessionId
      ) {
        throw new Error('agent_output could not find the requested child session');
      }
      const runs = await this.deps.runStore?.listSessionRuns(child.id);
      const selected = execution.currentRunId
        ? runs?.find((run) => run.runId === execution.currentRunId)
        : runs
            ?.slice()
            .sort(
              (left, right) =>
                right.createdAt - left.createdAt ||
                right.updatedAt - left.updatedAt ||
                right.runId.localeCompare(left.runId),
            )[0];
      if (!selected || !isSessionInlineRun(selected)) {
        throw new Error('agent_output could not find the requested child session run');
      }
      const header = await this.effectiveRunHeaderFromRuntimeLedger(selected);
      return {
        header,
        execution: {
          kind: 'child_session',
          sessionId: child.id,
          currentRunId: header.runId,
        },
        ...(child.subagentParent.graph ? { graph: child.subagentParent.graph } : {}),
      };
    }

    const legacyExecution =
      input.execution?.kind === 'legacy_child_run' ? input.execution : undefined;
    if (legacyExecution && legacyExecution.sessionId !== sessionId) {
      throw new Error('agent_output could not find the requested legacy child run');
    }
    const runs = await this.deps.runStore?.listSessionRuns(sessionId);
    const header = runs?.find((run) =>
      legacyExecution