Lewati ke konten

Neuron Mesin Status Sesi

Lihat sebagai Markdown Edit di GitHub Dokumentasi di 2cc7b2b

Pola ini berguna ketika sesuatu yang Anda bangun lebih menyerupai sesi daripada satu kali eksekusi.

Mesin status Queuety mengelola siklus hidup sesi, alur kerja Queuety menangani tugas latar belakang yang mendapat manfaat dari percobaan ulang, mode penyelesaian for-each, dan agregasi, sedangkan Neuron menangani pemanggilan agent dan memori percakapan yang sebenarnya.

Pemisahan ini cocok untuk copilot dukungan, asisten riset internal, agent editorial yang mungkin menunggu tinjauan manusia, serta utas chat yang berpindah antara tahap perencanaan, menunggu, dan respons.

Bentuk siklus hidup

Dalam contoh ini, satu sesi dukungan berpindah melalui awaiting_user, planning, waiting_on_research, dan responding. Mesin menjaga siklus hidup itu tetap eksplisit, sementara alur kerja latar belakang mengumpulkan riset dan memberi sinyal kepada sesi saat tugasnya selesai.

Mesin status

PHP
use Queuety\Queuety;

$session_id = Queuety::machine( 'support_session' )
    ->version( 'support-session.v1' )
    ->state( 'awaiting_user' )
    ->on( 'user_message', 'planning' )
    ->state( 'planning' )
    ->action( DispatchResearchWorkflowAction::class )
    ->on( 'research_dispatched', 'waiting_on_research' )
    ->state( 'waiting_on_research' )
    ->on( 'research_completed', 'responding' )
    ->state( 'responding' )
    ->action( RespondWithNeuronAction::class )
    ->on( 'response_ready', 'awaiting_user' )
    ->dispatch( [
        'thread_id' => 'support:customer-42',
    ] );

Saat pengguna mengirim pesan:

PHP
Queuety::machine_event(
    $session_id,
    'user_message',
    [
        'session_machine_id' => $session_id,
        'message' => 'Can you compare our pricing to the main competitors?',
    ]
);

Mesin beralih ke planning, mengantrekan tindakannya, lalu memulai alur kerja riset.

Tindakan perencanaan: jalankan alur kerja

PHP
namespace App\StateMachines\Actions;

use Queuety\Contracts\StateAction;
use Queuety\Enums\WaitMode;
use Queuety\Queuety;

final class DispatchResearchWorkflowAction implements StateAction
{
    public function handle( array $state, ?string $event = null, array $event_payload = [], array $payload = [] ): array|string
    {
        $message = trim( (string) ( $event_payload['message'] ?? '' ) );

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

        $research_workflow = Queuety::workflow( 'support_research_packet' )
            ->then( PlanResearchTasksStep::class )
            ->start_agents( 'agent_tasks', $agent_workflow )
            ->wait_for_agents( mode: WaitMode::All, result_key: 'agent_results' )
            ->then( SynthesizeResearchPacketStep::class )
            ->then( NotifySessionResearchReadyStep::class );

        $workflow_id = $research_workflow->dispatch( [
            'machine_id'      => $state['session_machine_id'],
            'thread_id'       => $state['thread_id'],
            'customer_prompt' => $message,
        ] );

        return [
            'latest_user_message'  => $message,
            'research_workflow_id' => $workflow_id,
            '_event'               => 'research_dispatched',
        ];
    }
}

Tindakan status ini tidak mencoba melakukan riset sendiri. Tindakan ini menjalankan alur kerja dan mencatat ID alur kerja dalam status mesin.

Langkah alur kerja: beri sinyal kepada mesin saat riset siap

PHP
namespace App\Workflow\Steps;

use Queuety\Queuety;
use Queuety\Step;

final class NotifySessionResearchReadyStep implements Step
{
    public function handle( array $state ): array
    {
        Queuety::machine_event(
            $state['machine_id'],
            'research_completed',
            [
                'research_packet' => $state['research_packet'],
            ]
        );

        return [];
    }

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

Saat alur kerja selesai, alur kerja mengirim research_completed kembali ke mesin dan menyertakan paket yang telah disintesis sebagai payload peristiwa.

Tindakan respons: panggil Neuron dengan memori sesi

PHP
namespace App\StateMachines\Actions;

use App\Neuron\SupportAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Contracts\StateAction;

final class RespondWithNeuronAction implements StateAction
{
    public function handle( array $state, ?string $event = null, array $event_payload = [], array $payload = [] ): array|string
    {
        // Queuety creates actions with `new RespondWithNeuronAction()`, so build dependencies here.
        $pdo = new \PDO( $_ENV['NEURON_DB_DSN'], $_ENV['NEURON_DB_USER'], $_ENV['NEURON_DB_PASSWORD'] );

        $agent = new SupportAgent(
            threadId: $state['thread_id'],
            pdo: $pdo,
        );

        $message = $agent->chat(
            new UserMessage(
                sprintf(
                    "Answer the user message '%s' using this research packet:\n\n%s",
                    $state['latest_user_message'],
                    json_encode( $state['research_packet'] ?? [], JSON_PRETTY_PRINT )
                )
            )
        )->getMessage();

        return [
            'assistant_reply' => $message->getContent(),
            '_event'          => 'response_ready',
        ];
    }
}

Setelah respons dibuat, mesin beralih kembali ke awaiting_user dengan balasan terbaru dalam status publik. Sesi yang sama kemudian dapat menerima peristiwa user_message lain dan melanjutkan proses.

Mengapa ini lebih rapi daripada satu alur kerja besar

Pekerjaan berat tetap berbentuk alur kerja karena bagian riset memerlukan perencanaan, eksekusi spesialis, agregasi, dan sintesis. Percakapan dukungan yang berjalan lama berbentuk mesin status karena sesi harus melacak apakah sedang menunggu giliran pengguna, menunggu riset, atau boleh memberikan respons.

Pemisahan ini membuat runtime mudah dibaca dan model sesi tetap eksplisit.