# Afhængigheder mellem arbejdsgange

Brug ventepunkter for afhængigheder mellem arbejdsgange, når én overordnet arbejdsgang først skal fortsætte, efter andre arbejdsgange er afsluttet. Det giver koordinering på tværs af arbejdsgange uden at tvinge alt ind i én enorm arbejdsgangsdefinition.

Disse ventepunkter fungerer særligt godt sammen med [Async Handoffs](https://queuety.inline0.dev/da/docs/workflows/async-handoffs), hvor én arbejdsgang først starter uafhængige underordnede arbejdsgange og derefter venter på dem.

Se [Agent Orchestration](https://queuety.inline0.dev/da/docs/workflows/agent-orchestration) for mere udførlige eksempler på planlægger og udfører.

Queuety indeholder tre builder-metoder:

- `wait_for_workflow()` til én arbejdsgang
- `wait_for_workflows()` til flere arbejdsgange med semantik af typen `all`, `any` eller `quorum`
- `wait_for_workflow_group()` når arbejdsgangs-ID'erne kommer fra en tidligere startet gruppe

## Vent på én arbejdsgang

```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` afsluttes, genoptages `editorial_run`. Når `result_key` er angivet, gemmes den afsluttede afhængighedstilstand under den nøgle:

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

Uden en `result_key` flettes afhængighedsarbejdsgangens offentlige tilstand ind i den ventende arbejdsgangs tilstand på øverste niveau.

## Vent på flere arbejdsgange

```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` genoptages først, når alle anførte workflows er fuldført.
- `WaitMode::Any` genoptages, når det første anførte workflow er fuldført.
- `WaitMode::Quorum` genoptages, når det krævede antal workflows er fuldført uden fejl.

```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` gemmes afsluttede afhængigheder ved ventetid på flere workflows med workflow-ID som nøgle:

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

Uden `result_key` flettes tilstanden for afsluttede afhængigheder ind i det ventende workflows topniveau i afhængighedernes rækkefølge.

## Find afhængigheds-ID'er fra workflowtilstanden

Du kan vente med at angive afhængighedslisten til kørselstidspunktet ved at hente workflow-ID'er fra den offentlige tilstand:

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

For flere afhængigheder:

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

## Vent på en startet workflowgruppe

Hvis et tidligere trin `start_workflows()` eller `start_agents()` gemte en permanent gruppenøgle, kan du vente direkte på gruppen i stedet for selv at føre workflow-ID'er gennem den offentlige tilstand.

```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();
```

## Hvad sker der, mens workflowet venter

Når et workflow når et af disse trin, sættes det i status `waiting_for_workflows`. Ingen worker er knyttet til det, mens det venter.

```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']
```

Hvis en afhængighed allerede er fuldført, før ventetrinnet nås, fortsætter workflowet med det samme.

## Håndtering af fejl

Ventetrin for workflowafhængigheder er baseret på succes:

- `wait_for_workflow()` og `WaitMode::All` fejler, hvis en påkrævet afhængighed fejler eller annulleres.
- `WaitMode::Any` fejler kun, når alle afhængigheder har nået en terminal tilstand, og ingen er fuldført uden fejl.
- `WaitMode::Quorum` fejler, når de resterende aktive workflows ikke længere kan opfylde det krævede quorum.

Det gør ventetrin nyttige i planner/executor-systemer, hvor et workflow kan udføre arbejde, mens et andet venter på resultater fra `all` eller på den første succesfulde gren, der afsluttes.