Method startChildTurnClaimed

packages/runtime/src/runtime-kernel.ts:1144–1210

(
    sessionId: string,
    input: ChildAgentTurnInput,
    execution: PendingExecutionClaim,
  )

  }

  private async *startChildTurnClaimed(
    sessionId: string,
    input: ChildAgentTurnInput,
    execution: PendingExecutionClaim,
  ): AsyncIterable<SessionEvent> {
    await this.enterExecutionClaim(execution);
    const parentHeader = await this.deps.store.readHeader(sessionId);
    const definition = requireBuiltinAgentDefinition(input.spec.id);
    const availableChildTools = this.deps.childTools ?? [];
    assertAgentDefinitionRunnable({
      definition,
      tools: availableChildTools,
    });
    const childTools = buildToolsForAgentDefinition(availableChildTools, definition);
    const childHeader: SessionHeader = {
      ...parentHeader,
      permissionMode: definition.permissionMode,
      connectionLocked: true,
    };
    const userInput: UserMessageInput = {
      turnId: input.turnId,
      text: input.prompt,
      parentRunId: input.parentRunId,
      ...(input.resumedFromRunId ? { resumedFromRunId: input.resumedFromRunId } : {}),
      agentId: definition.id,
      agentName: definition.name,
    };
    const activeKey = childActiveKey(sessionId, input.turnId);
    const run = new AgentRun({
      sessionId,
      header: childHeader,
      userInput,
      store: this.deps.store,
      runStore: this.deps.runStore,
      runtimeEventStore: this.deps.runtimeEventStore,
      ...(runtimeToolBoundaryProtocol(this.deps, childHeader)
        ? { toolBoundaryProtocol: runtimeToolBoundaryProtocol(this.deps, childHeader) }
        : {}),
      repairRunRuntimeLedger: this.deps.repairRunRuntimeLedger,
      newId: this.deps.newId,
      now: this.deps.now,
      effectiveOrchestration: resolveEffectiveOrchestration('default', undefined),
      recordSessionMessages: false,
      hooks: {
        reserveRun: async (targetSessionId, nextHeader, activeRun) => {
          const active = await this.reserveChildRun(
            activeKey,
            targetSessionId,
            nextHeader,
            definition.systemPrompt,
            childTools,
            activeRun,
            execution,
          );
          this.reserveExecutionClaim(execution, active, activeRun);
          return active;
        },
        unregisterRun: (active, activeRun) => this.unregisterChildRun(active, activeRun),