Translate PRD files to English for public repo

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: icebob-ai

PRD-phase2.md

@@ -1,38 +1,38 @@
 # PRD: @moleculer/agents — Phase 2 (OrchestratorMixin)
 
-## 1. Áttekintés
-- **Cél:** Multi-agent koordináció hozzáadása — egy orchestrator service felfedezheti és delegálhat feladatokat más agent service-eknek
-- **Scope:** OrchestratorMixin, direct + LLM-router strategy, integrációs tesztek, README frissítés, orchestrator example
-- **Előfeltétel:** Phase 1 kész — AgentMixin, MemoryMixin, LLMService, adapters mind működnek
+## 1. Overview
+- **Goal:** Add multi-agent coordination — an orchestrator service can discover and delegate tasks to other agent services
+- **Scope:** OrchestratorMixin, direct + LLM-router strategy, integration tests, README update, orchestrator example
+- **Prerequisite:** Phase 1 complete — AgentMixin, MemoryMixin, LLMService, adapters all working
 
-## 2. Meglévő rendszer
+## 2. Existing system
 
-A Phase 1-ben elkészült komponensek (NEM kell módosítani, csak használni):
-- `AgentMixin` — ReAct loop, tool schema extraction, run/chat action-ök (`src/agent.mixin.ts`)
-- `MemoryMixin` — conversation history cacher-ben (`src/memory.mixin.ts`)
+Components completed in Phase 1 (do NOT modify, only use):
+- `AgentMixin` — ReAct loop, tool schema extraction, run/chat actions (`src/agent.mixin.ts`)
+- `MemoryMixin` — conversation history in cacher (`src/memory.mixin.ts`)
 - `LLMService` — adapter wrapper service (`src/llm.service.ts`)
 - Adapters: OpenAI, Anthropic, Fake + registry (`src/adapters/`)
 - Types: `LLMResponse`, `ToolCall`, `AgentSettings`, `ToolSchema` (`src/types.ts`)
 - Schema converter: fastest-validator → JSON Schema (`src/schema-converter.ts`)
 
-A meglévő `AgentSettings` interface-ben már van `strategy` mező: `"direct" | "llm-router"`.
+The existing `AgentSettings` interface already has a `strategy` field: `"direct" | "llm-router"`.
 
-## 3. Új fájlok
+## 3. New files
 
 ```
 src/
   orchestrator.mixin.ts   # OrchestratorMixin factory function
-  types.ts                # Bővíteni: DiscoveredAgent interface
+  types.ts                # Extend: DiscoveredAgent interface
 test/
   unit/
     orchestrator.mixin.spec.ts
   integration/
-    orchestrator.test.ts   # Multi-agent E2E teszt
+    orchestrator.test.ts   # Multi-agent E2E test
 examples/
-  orchestrator.ts          # Futtatható orchestrator példa
+  orchestrator.ts          # Runnable orchestrator example
 ```
 
-## 4. OrchestratorMixin specifikáció
+## 4. OrchestratorMixin specification
 
 ### Factory function
 
@@ -43,59 +43,59 @@ export default function OrchestratorMixin(mixinOpts?: OrchestratorMixinOptions)
 **Options:**
 ```typescript
 interface OrchestratorMixinOptions {
-  // Nincs szükség opciókra egyelőre, de a factory pattern megmarad
+  // No options needed for now, but the factory pattern is preserved
 }
 ```
 
-### Új típus (`types.ts`-be)
+### New type (add to `types.ts`)
 
 ```typescript
 export interface DiscoveredAgent {
   name: string;
   description: string;
-  actions: string[];  // Action nevek amik tool-ként elérhetőek
+  actions: string[];  // Action names available as tools
 }
 ```
 
 ### Methods
 
 #### `discoverAgents(): DiscoveredAgent[]`
 
-Lekérdezi a Moleculer service registry-ből az összes agent service-t:
+Queries the Moleculer service registry for all agent services:
 
-1. `this.broker.registry.getServiceList({ withActions: true })` hívás (Moleculer 0.15 API)
-2. Szűrés: csak azok a service-ek amelyeknek van `settings.agent` objektuma ÉS van `settings.agent.description`
-3. Kiszűri önmagát (`this.name`-mel egyező service-ek)
-4. Minden talált service-ből `DiscoveredAgent` objektumot épít:
-   - `name`: service neve
+1. Call `this.broker.registry.getServiceList({ withActions: true })` (Moleculer 0.15 API)
+2. Filter: only services that have a `settings.agent` object AND `settings.agent.description`
+3. Exclude self (services matching `this.name`)
+4. Build `DiscoveredAgent` object from each found service:
+   - `name`: service name
    - `description`: `settings.agent.description`
-   - `actions`: az adott service action-jei közül azok neve amelyeknek van `description` mezőjük (hasonlóan ahogy az AgentMixin szűr) — DE a `run` és `chat` meta-action-öket kiszűri
-5. Visszaadja a tömböt
+   - `actions`: action names from that service which have a `description` field (similar to how AgentMixin filters) — BUT filter out the `run` and `chat` meta-actions
+5. Return the array
 
-**FONTOS:** A Moleculer 0.15-ben a `getServiceList` a remote node-ok settings-eit is visszaadja, tehát ez elosztott környezetben is működik. Nézd meg a Moleculer 0.15 forráskódját a pontos API-ért (a broker.registry vagy broker object-en kell keresni a megfelelő metódust, pl. `this.broker.registry.getServiceList` vagy `this.broker.getLocalNodeInfo`). Ha a Moleculer 0.15 API nem egyértelmű, használd a `this.broker.call("$node.services", { withActions: true })` belső action-t ami szintén visszaadja az összes service infót.
+**IMPORTANT:** In Moleculer 0.15, `getServiceList` returns settings from remote nodes as well, so this works in distributed environments. Check the Moleculer 0.15 source for the exact API (look for the appropriate method on broker.registry or broker object, e.g. `this.broker.registry.getServiceList` or `this.broker.getLocalNodeInfo`). If the Moleculer 0.15 API is unclear, use `this.broker.call("$node.services", { withActions: true })` internal action which also returns all service info.
 
 #### `delegateTo(agentName: string, task: string, sessionId?: string): Promise<string>`
 
-Egyszerű wrapper:
+Simple wrapper:
 ```typescript
 return this.broker.call(`${agentName}.run`, { task, sessionId });
 ```
 
 ### Settings
 
-Az OrchestratorMixin a meglévő `settings.agent` scope alá nem ad új mezőket — a `strategy` mező már létezik az `AgentSettings` interface-ben.
+OrchestratorMixin does not add new fields under the existing `settings.agent` scope — the `strategy` field already exists in the `AgentSettings` interface.
 
-### Hogyan működik az orchestrator
+### How the orchestrator works
 
-Az OrchestratorMixin-t az AgentMixin-nel és opcionálisan a MemoryMixin-nel EGYÜTT kell használni:
+OrchestratorMixin must be used TOGETHER with AgentMixin and optionally MemoryMixin:
 
 ```typescript
 mixins: [MemoryMixin(), OrchestratorMixin(), AgentMixin()]
 ```
 
-Az orchestrator service-nek lehetnek **saját action-jei** (amik tool-ként jelennek meg az LLM számára), és ezek az action-ok hívhatják a `this.delegateTo()` metódust más agent-ekhez delegáláshoz.
+The orchestrator service can have **its own actions** (which appear as tools for the LLM), and these actions can call `this.delegateTo()` to delegate to other agents.
 
-**Direct strategy példa:**
+**Direct strategy example:**
 ```typescript
 actions: {
   planTrip: {
@@ -115,63 +115,63 @@ actions: {
 }
 ```
 
-**LLM-router strategy:** Az orchestrator `created()` hook-jában ha `settings.agent.strategy === "llm-router"`, automatikusan generál egy extra tool-t (`_routeToAgent`) az LLM számára. Ez a tool:
-- Paraméterek: `{ agentName: "string", task: "string" }`
-- Description: tartalmazza az elérhető agent-ek listáját (discovery-ből)
-- Handler: meghívja `this.delegateTo(agentName, task)`
-- Az AgentMixin ReAct loop-ja automatikusan meghívja ha az LLM úgy dönt
+**LLM-router strategy:** In the orchestrator's `created()` hook, if `settings.agent.strategy === "llm-router"`, it automatically generates an extra tool (`_routeToAgent`) for the LLM. This tool:
+- Parameters: `{ agentName: "string", task: "string" }`
+- Description: contains the list of available agents (from discovery)
+- Handler: calls `this.delegateTo(agentName, task)`
+- The AgentMixin ReAct loop automatically invokes it if the LLM decides to
 
-A `_routeToAgent` tool description-jébe bele kell írni a felfedezett agent-ek listáját és leírását, hogy az LLM tudja melyikhez delegáljon. A discovery a `started()` hook-ban történik (amikor a többi service már regisztrált), és `$services.changed` event-re frissül.
+The `_routeToAgent` tool description must include the discovered agents list and descriptions so the LLM knows which agent to delegate to. Discovery happens in the `started()` hook (when other services are already registered), and refreshes on `$services.changed` event.
 
-## 5. Tesztelési terv
+## 5. Testing plan
 
-### Unit tesztek (`test/unit/orchestrator.mixin.spec.ts`)
+### Unit tests (`test/unit/orchestrator.mixin.spec.ts`)
 
 Vitest, FakeAdapter, ServiceBroker `{ logger: false }`.
 
-- **discoverAgents**: Hozz létre broker-t 3 service-szel (2 agent + 1 nem-agent), ellenőrizd hogy a `discoverAgents()` csak az agent service-eket adja vissza, és kiszűri önmagát
-- **delegateTo**: Mock agent service, ellenőrizd hogy `broker.call("agent-name.run", { task })` hívódik meg
-- **LLM-router _routeToAgent tool**: Ellenőrizd hogy `strategy: "llm-router"` esetén a toolSchemas tartalmaz egy `_routeToAgent` tool-t
-- **Direct strategy**: Ellenőrizd hogy `strategy: "direct"` esetén NEM generálódik `_routeToAgent` tool
+- **discoverAgents**: Create a broker with 3 services (2 agents + 1 non-agent), verify that `discoverAgents()` returns only the agent services and excludes self
+- **delegateTo**: Mock agent service, verify that `broker.call("agent-name.run", { task })` is called
+- **LLM-router _routeToAgent tool**: Verify that with `strategy: "llm-router"`, toolSchemas contains a `_routeToAgent` tool
+- **Direct strategy**: Verify that with `strategy: "direct"`, NO `_routeToAgent` tool is generated
 
-### Integrációs teszt (`test/integration/orchestrator.test.ts`)
+### Integration test (`test/integration/orchestrator.test.ts`)
 
-Teljes multi-agent E2E:
+Full multi-agent E2E:
 
-1. Broker létrehozás `{ logger: false, cacher: "Memory" }`
-2. LLM service FakeAdapter-rel
-3. 2 sub-agent service (weather-agent, calculator-agent) — AgentMixin-nel, saját tool action-ökkel
+1. Broker creation `{ logger: false, cacher: "Memory" }`
+2. LLM service with FakeAdapter
+3. 2 sub-agent services (weather-agent, calculator-agent) — with AgentMixin, with their own tool actions
 4. 1 orchestrator service — AgentMixin + OrchestratorMixin, direct strategy
-5. Teszt: `broker.call("orchestrator.run", { task: "..." })` → az orchestrator action-je meghívja `delegateTo`-t → a sub-agent válaszol → orchestrator visszaadja az eredményt
-6. Teszt: `discoverAgents()` helyes listát ad
+5. Test: `broker.call("orchestrator.run", { task: "..." })` → orchestrator action calls `delegateTo` → sub-agent responds → orchestrator returns result
+6. Test: `discoverAgents()` returns correct list
 
-### Futtatható example (`examples/orchestrator.ts`)
+### Runnable example (`examples/orchestrator.ts`)
 
-Regisztráld az example runner-be (`examples/index.ts`-be `orchestrator` kulcs alatt).
+Register in the example runner (`examples/index.ts` under `orchestrator` key).
 
-A példa:
-- 1 LLM service (auto adapter detection a `create-adapter` helper-rel)
-- 2 sub-agent (weather + calculator)
-- 1 orchestrator (direct strategy) — `planTrip` action ami delegál a sub-agent-ekhez
-- Hívás: `orchestrator.run({ task: "Plan a trip to Paris for 3 days" })`
+The example:
+- 1 LLM service (auto adapter detection via `create-adapter` helper)
+- 2 sub-agents (weather + calculator)
+- 1 orchestrator (direct strategy) — `planTrip` action that delegates to sub-agents
+- Call: `orchestrator.run({ task: "Plan a trip to Paris for 3 days" })`
 
-## 6. README frissítés
+## 6. README update
 
-A meglévő README-be adj hozzá egy "Multi-Agent Orchestration" szekciót a "Conversation Memory" szekció után, ami bemutatja:
-- OrchestratorMixin használatát
-- `discoverAgents()` és `delegateTo()` metódusokat
-- Direct strategy példát
-- LLM-router strategy példát (röviden)
+Add a "Multi-Agent Orchestration" section to the existing README after the "Conversation Memory" section, covering:
+- OrchestratorMixin usage
+- `discoverAgents()` and `delegateTo()` methods
+- Direct strategy example
+- LLM-router strategy example (brief)
 
-## 7. Index.ts frissítés
+## 7. Index.ts update
 
-Az `src/index.ts`-ből exportáld az `OrchestratorMixin`-t és a `DiscoveredAgent` típust is:
+Export `OrchestratorMixin` and the `DiscoveredAgent` type from `src/index.ts`:
 
 ```typescript
 export { default as OrchestratorMixin } from "./orchestrator.mixin.ts";
 export type { ..., DiscoveredAgent } from "./types.ts";
 ```
 
-## 8. Coding konvenciók
+## 8. Coding conventions
 
-Ugyanazok mint Phase 1-ben — lásd a CLAUDE.md-t! TypeScript, ES modules, tabs, double quotes, Vitest, file headers, etc.
+Same as Phase 1 — see CLAUDE.md! TypeScript, ES modules, tabs, double quotes, Vitest, file headers, etc.