# Arbetsflödesberoenden

Använd väntan på arbetsflödesberoenden när ett överordnat arbetsflöde ska fortsätta först när andra arbetsflöden har slutförts. Då kan du samordna flera arbetsflöden utan att tvinga in allt i en enda stor arbetsflödesdefinition.

Sådan väntan fungerar särskilt bra med [Överlämningar asynkront](https://queuety.inline0.dev/sv/docs/workflows/async-handoffs), där ett arbetsflöde först startar fristående underordnade arbetsflöden och sedan väntar på dem.

För fler exempel på planerare och exekverare, se [Agentorkestrering](https://queuety.inline0.dev/sv/docs/workflows/agent-orchestration).

Queuety tillhandahåller tre byggarmetoder:

- `wait_for_workflow()` för ett arbetsflöde
- `wait_for_workflows()` för flera arbetsflöden med semantiken `all`, `any` eller `quorum`
- `wait_for_workflow_group()` när arbetsflödes-ID:na kommer från en grupp som startats tidigare

## Vänta på ett arbetsflöde

```php
$research_id = Queuety::workflow( 'research_run' )
    ->then( PlanResearchStep::class )
    ->for_each( 'tasks', ExecuteResearchTask::class, 'results' )
    ->dispatch( [ 'brief_id' => 42 ] );

$editorial_id = Queuety::workflow( 'editorial_run' )
    ->wait_for_workflow( $research_id, 'research' )
    ->then( DraftBriefStep::class )
    ->dispatch();
```

När `research_run` slutförs återupptas `editorial_run`. Om `result_key` anges lagras det slutförda beroendets tillstånd under den nyckeln:

```php
$state['research']; // public state from the completed research workflow
```

Utan `result_key` sammanfogas beroendearbetsflödets publika tillstånd med det väntande arbetsflödets tillstånd på toppnivå.

## Vänta på flera arbetsflöden

```php
use Queuety\Enums\WaitMode;

Queuety::workflow( 'synthesis_run' )
    ->wait_for_workflows(
        [ $research_id, $editorial_id, $legal_id ],
        WaitMode::All,
        'dependencies'
    )
    ->then( PublishPacketStep::class )
    ->dispatch();
```

- `WaitMode::All` återupptas först när alla angivna arbetsflöden har slutförts.
- `WaitMode::Any` återupptas när det första angivna arbetsflödet slutförs.
- `WaitMode::Quorum` återupptas när ett erforderligt antal arbetsflöden har slutförts utan fel.

```php
Queuety::workflow( 'synthesis_run' )
    ->wait_for_workflows(
        [ $research_id, $editorial_id, $legal_id ],
        WaitMode::Quorum,
        'dependencies',
        quorum: 2,
    )
    ->then( PublishPacketStep::class )
    ->dispatch();
```

Med `result_key` lagrar väntan på flera arbetsflöden de slutförda beroendenas tillstånd med arbetsflödes-ID som nyckel:

```php
[
    '42' => [ 'summary' => '...' ],
    '43' => [ 'summary' => '...' ],
]
```

Utan `result_key` sammanfogas de slutförda beroendenas tillstånd med det väntande arbetsflödets tillstånd på toppnivå i beroendeordning.

## Hämta beroende-ID:n från arbetsflödestillståndet

Du kan skjuta upp listan över beroenden till körning genom att läsa arbetsflödes-ID:n från det publika tillståndet:

```php
Queuety::workflow( 'agent_follow_up' )
    ->wait_for_workflow( 'parent_workflow_id', 'parent' )
    ->then( FinalizeAgentRunStep::class )
    ->dispatch( [ 'parent_workflow_id' => $workflow_id ] );
```

För flera beroenden:

```php
Queuety::workflow( 'aggregator' )
    ->wait_for_workflows( 'dependency_ids', WaitMode::Any, 'winner' )
    ->dispatch( [ 'dependency_ids' => [ 12, 18, 22 ] ] );
```

## Vänta på en startad arbetsflödesgrupp

Om ett tidigare steg av typen `start_workflows()` eller `start_agents()` lagrade en beständig gruppnyckel kan du vänta direkt på gruppen i stället för att själv föra arbetsflödes-ID:n genom det publika tillståndet.

```php
Queuety::workflow( 'brief_research' )
    ->then( PlanTopicsStep::class )
    ->start_agents( 'agent_tasks', $agent_run, group_key: 'researchers' )
    ->wait_for_agent_group( 'researchers', WaitMode::Quorum, 2, 'agent_results' )
    ->then( SynthesizeBriefStep::class )
    ->dispatch();
```

## Vad som händer medan arbetsflödet väntar

När ett arbetsflöde når ett av de här stegen ändras dess status till `waiting_for_workflows`. Ingen arbetare är knuten till det medan det väntar.

```php
$state = Queuety::workflow_status( $workflow_id );
echo $state->status->value; // 'waiting_for_workflows'
echo $state->wait_type;     // 'workflow'
print_r( $state->waiting_for ); // ['42', '43']
```

Om ett beroende redan har slutförts innan väntesteget nås fortsätter arbetsflödet omedelbart.

## Felhantering

Väntan på arbetsflödesberoenden är inriktad på lyckade resultat:

- `wait_for_workflow()` och `WaitMode::All` misslyckas om något obligatoriskt beroende misslyckas eller avbryts.
- `WaitMode::Any` misslyckas bara när alla beroenden har nått ett sluttillstånd och inget har slutförts utan fel.
- `WaitMode::Quorum` misslyckas när de återstående aktiva arbetsflödena inte längre kan uppfylla det erforderliga kvorumet.

Därför är väntan på arbetsflöden användbar i system med planerare och exekverare, där ett arbetsflöde kan skapa arbete och ett annat kan vänta på resultat från `all` eller på den första lyckade grenen som blir klar.