# Neuron Fluxuri de lucru dependente

Acest exemplu răspunde unei întrebări frecvente despre agenții:

> Poate un flux de lucru să decidă că altul ar trebui să continue doar după finalizarea unui flux anterior?

Da. Nuanța importantă este că Queuety acceptă deja acest lucru prin `wait_for_workflow()` și `wait_for_workflows()`.

Asta înseamnă că:

- fluxul de lucru `X` poate fi lansat acum
- `X` poate rămâne în așteptare în `waiting_for_workflows`
- `X` se reia doar după finalizarea fluxului de lucru `Y`

## Exemplu: mai întâi cercetare, apoi redactare

Folosiți un flux de lucru de nivel superior pentru a crea un pachet de cercetare și un al doilea flux de lucru de nivel superior pentru a redacta textul final.

### Flux de lucru pentru cercetare

```php
use Queuety\Enums\WaitMode;
use Queuety\Queuety;

$research_agent = Queuety::workflow('research_agent')
    ->then(ResearchTopicStep::class);

$research_id = Queuety::workflow('research_packet')
    ->then(PlanResearchTasksStep::class)
    ->start_agents('agent_tasks', $research_agent)
    ->wait_for_agents(mode: WaitMode::All, result_key: 'agent_results')
    ->then(SynthesizeResearchPacketStep::class)
    ->dispatch([
        'brief_id' => 42,
        'provider' => 'anthropic',
    ]);
```

### Flux de lucru pentru redactare

```php
Queuety::workflow('write_brief')
    ->wait_for_workflow('research_workflow_id', 'research')
    ->then(WriteBriefWithNeuronStep::class)
    ->wait_for_decision(result_key: 'editor_review')
    ->then(PublishBriefStep::class)
    ->dispatch([
        'brief_id' => 42,
        'research_workflow_id' => $research_id,
        'provider' => 'openai',
    ]);
```

Când începe fluxul de lucru pentru redactare, acesta se pune imediat în așteptare în `waiting_for_workflows` până când fluxul de lucru pentru cercetare se încheie cu succes.

## Pasul de redactare Neuron

```php
namespace App\Workflow\Steps;

use App\Neuron\WriterAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Step;

final class WriteBriefWithNeuronStep implements Step
{
    public function handle(array $state): array
    {
        $agent = new WriterAgent(
            providerName: $state['provider'] ?? 'openai',
        );

        $message = $agent->chat(
            new UserMessage(sprintf(
                "Write the final brief for brief %d using this research packet:\n\n%s",
                $state['brief_id'],
                json_encode($state['research'], JSON_PRETTY_PRINT),
            ))
        )->getMessage();

        return [
            'draft_markdown' => $message->getContent(),
        ];
    }

    public function config(): array
    {
        return [];
    }
}
```

`$state['research']` este disponibil deoarece `wait_for_workflow()` a copiat starea publică finalizată din fluxul de lucru dependent în fluxul de lucru curent, sub cheia `research`.

## Când să folosiți această abordare în locul unui singur flux de lucru uriaș

Alegeți fluxuri de lucru separate de nivel superior când:

- etapele au proprietari sau cicluri operaționale de viață diferite
- doriți să le inspectați și să le reîncercați independent
- o etapă ulterioară trebuie să poată fi lansată chiar înainte de încheierea etapei anterioare

Alegeți un singur flux de lucru când:

- etapele sunt strâns legate
- au un singur ciclu de viață și un singur pachet de stare în comun

## Rolul unei mașini de stări

Dacă acest flux de redactare face parte dintr-o sesiune editorială de durată mai lungă, lăsați o [mașină de stări](https://queuety.inline0.dev/ro/docs/state-machines) să gestioneze ciclul de viață exterior și folosiți aceste fluxuri de lucru pentru etapele de execuție cu durată limitată. Astfel, stări ale ciclului de viață precum `awaiting_brief`, `researching`, `awaiting_review` și `completed` rămân explicite, păstrând totodată durabilitatea fluxului de lucru în fiecare fază.

## O distincție importantă

Acest model înseamnă că:

- `X` există acum, dar așteaptă `Y`

Nu înseamnă că:

- `X` nu este creat până când `Y` nu se încheie

Dacă doriți al doilea comportament, faceți ca un flux de lucru părinte să aștepte `Y` și apoi să apeleze `start_workflows()` sau `start_agents()` pentru `X`.

## Documentație asociată

- [Dependențe între fluxuri de lucru](https://queuety.inline0.dev/ro/docs/workflows/dependencies)
- [Transferuri asincrone](https://queuety.inline0.dev/ro/docs/workflows/async-handoffs)
- [Orchestrarea agenților](https://queuety.inline0.dev/ro/docs/workflows/agent-orchestration)
- [Mașini de stări](https://queuety.inline0.dev/ro/docs/state-machines)