From cb8d337cf9cabf34a83653bad04f94893309ad0d Mon Sep 17 00:00:00 2001 From: ValueOn AG Date: Tue, 23 Sep 2025 22:48:00 +0200 Subject: [PATCH] Refactor full workflow engine 3.0 --- poweron/README-react-mode.md | 79 ++++++++++++++++ .../.$doc_architecture_gateway.drawio.bkp | 1 + .../appdoc/doc_architecture_gateway.drawio | 2 +- poweron/spec-workflow-architecture.md | 69 ++++++++++++++ poweron/spec-workflow-implementation.md | 91 +++++++++++++++++++ 5 files changed, 241 insertions(+), 1 deletion(-) create mode 100644 poweron/README-react-mode.md create mode 100644 poweron/appdoc/.$doc_architecture_gateway.drawio.bkp create mode 100644 poweron/spec-workflow-architecture.md create mode 100644 poweron/spec-workflow-implementation.md diff --git a/poweron/README-react-mode.md b/poweron/README-react-mode.md new file mode 100644 index 0000000..3cc3d99 --- /dev/null +++ b/poweron/README-react-mode.md @@ -0,0 +1,79 @@ +## React Mode (Plan–Act–Observe–Refine) + +This introduces a compact iterative workflow that replaces bulk action plans with a tight loop: + +- Plan (select): Model selects exactly one action +- Act (execute): Host requests only parameters for that action and executes +- Observe (summarize): Host returns a compact observation object +- Refine (decide): Model decides whether to continue or stop + +### How to enable + +Set the mode on `ChatWorkflow` (persisted in DB / passed through the API): + +- `workflowMode: string` – "Actionplan" (legacy) or "React" (iterative) +- `maxSteps: number` – maximum iterations per task in React mode (default 5) + +When `workflowMode="Actionplan"`, the legacy batch action planning path is used. + +### Data models + +Defined in `gateway/modules/interfaces/interfaceChatModel.py`: + +- `ActionSelection`: `{ method: str, name: str }` +- `ActionParameters`: `{ parameters: dict }` +- `Observation`: `{ success: bool, resultLabel: str, documentsCount: int, previews: [{name,mime,snippet}], notes: [str] }` +- `TaskContext` additions: `reactMode: bool`, `maxSteps: int` +- `ChatWorkflow` additions: `workflowMode: str`, `maxSteps: int` + +### Prompts + +Defined in `gateway/modules/chat/handling/promptFactory.py`: + +- `createActionSelectionPrompt(context)` → returns one action +- `createActionParameterPrompt(context, selected_action)` → returns parameters only +- `createRefinementPrompt(context, observation)` → returns `{ decision: continue|stop, reason }` + +### Execution flow + +Implemented in `gateway/modules/chat/handling/handlingTasks.py`: + +- `plan_select(context)` → `{ action: { method, name } }` +- `act_execute(context, selection, task_step, workflow, step)` → executes one action and returns `ActionResult` +- `observe_build(action_result)` → builds `Observation` +- `refine_decide(context, observation)` → `{ decision, reason }` +- Integrated loop lives inside `executeTask(...)` when `context.reactMode` is true + +Iteration control helper in `gateway/modules/chat/handling/executionState.py`: + +- `should_continue(observation, review_dict, current_step, max_steps)` + +### Observation format + +Compact, machine-friendly, with small previews only: + +``` +{ + success: boolean, + resultLabel: string, + documentsCount: number, + previews: [ { name, mime, snippet } ], + notes: [ string ] +} +``` + +### Telemetry + +Each iteration logs duration (seconds) to workflow logs. No specific token metrics required. + +### Backward compatibility + +- Legacy planning/execution remains the default when `workflowMode="Actionplan"`. +- No breaking changes to action or document structures. + +### Notes + +- Document routing uses deterministic `resultLabel`: `round{r}_task{t}_action{a}_...` +- Previews are capped to ≤5 items and keep `name`, `mime`, and a short `snippet`. + + diff --git a/poweron/appdoc/.$doc_architecture_gateway.drawio.bkp b/poweron/appdoc/.$doc_architecture_gateway.drawio.bkp new file mode 100644 index 0000000..96b9b10 --- /dev/null +++ b/poweron/appdoc/.$doc_architecture_gateway.drawio.bkp @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/poweron/appdoc/doc_architecture_gateway.drawio b/poweron/appdoc/doc_architecture_gateway.drawio index 96b9b10..3412339 100644 --- a/poweron/appdoc/doc_architecture_gateway.drawio +++ b/poweron/appdoc/doc_architecture_gateway.drawio @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file diff --git a/poweron/spec-workflow-architecture.md b/poweron/spec-workflow-architecture.md new file mode 100644 index 0000000..7a80f4a --- /dev/null +++ b/poweron/spec-workflow-architecture.md @@ -0,0 +1,69 @@ +Title: Plan–Act–Observe–Refine Workflow Architecture (PowerOn) + +Overview +- Objective: Replace bulk “task plan → full action plan → execute later” with a compact iterative loop: plan (select one action) → act (execute with minimal params) → observe (summarize results) → refine (decide next step or stop). +- Benefits: Lower token usage, higher accuracy via tight feedback, less overplanning, clearer document routing, and better failure recovery. + +Core Loop +1) Plan (Select) + - Input: objective, success criteria, tiny tool catalog (names + parameter names only), minimal available documents/connections, and short rules. + - Output (JSON): {"action": {"method": "", "name": ""}} + - Constraints: exactly one action per iteration. + +2) Act (Specify + Execute) + - Input: selected action name from Plan. + - Model returns only required parameters for that action: {"parameters": {...}}. + - Host validates and applies in-code defaults (user language, depth, recency) then executes. + +3) Observe (Summarize Results) + - Host returns a compact observation object, not raw payloads: + { + "success": true|false, + "resultLabel": "roundX_taskY_actionZ_label", + "documentsCount": N, + "previews": [{"name":"..","mime":"..","snippet":".."}], + "notes": ["short fact"], + } + - For web results, include per-URL relevance, key points, entities if available. + +4) Refine (Decide Next or Stop) + - Model decides: stop with final answer or propose next single action (return to Plan). + - Stop criteria: all success_criteria met; or no further actions can improve score; or max steps reached. + +Minimal Tool Catalog (names + param names only) +- web.search(query,maxResults,searchDepth,timeRange,topic,includeDomains,excludeDomains,language,includeAnswer,includeRawContent) +- web.scrape(query,maxResults,searchDepth,timeRange,topic,includeDomains,excludeDomains,language,includeAnswer,includeRawContent,extractDepth,format) +- web.crawl(documentList,extractDepth,format) +- ai.process(documentList,aiPrompt,processingMode,includeMetadata,customInstructions,expectedDocumentFormats) +- document.extract(documentList,aiPrompt) +- document.generateReport(documentList,title) + +Business Rules (Prompt-Level, ≤7 lines) +- Pick exactly one action per step; then specify only its parameters. +- Derive parameters from objective + criteria; use user language; add recency only if freshness is implied. +- Only request machine-readable formats when explicitly required; otherwise narrative text/markdown. +- Keep parameters minimal; avoid connector-specific knobs; chain outputs so next step is consumable. +- Stop when criteria are met; otherwise iterate with a new single action. + +Defaults (Code-Level, not Prompt) +- Language default from user profile; depth advanced for analysis, basic for lookups. +- Time window only when criteria imply freshness. +- ai.process defaults to markdown narrative unless expectedDocumentFormats explicitly requests structured data. + +State and Routing +- Workflow context tracks (currentRound, currentTask, currentAction). +- Each action execution attaches documents with a deterministic resultLabel: round{r}_task{t}_action{a}_{label}. +- Observation objects reference only labels and previews to limit prompt size. + +Failure Handling +- After observe, a lightweight review step classifies: success | retry | failed, with improvements. +- Retry increments a small counter; criteria progress tracked across attempts. + +Security & Limits +- Allowed methods per task type; deny-list for risky methods. +- Max steps per task; token budget guard; truncate observations to safe size. + +Final Output +- When stopping, model produces a concise final message and, if applicable, invokes a last formatting action (e.g., ai.process → report md) before ending. + + diff --git a/poweron/spec-workflow-implementation.md b/poweron/spec-workflow-implementation.md new file mode 100644 index 0000000..232ce2f --- /dev/null +++ b/poweron/spec-workflow-implementation.md @@ -0,0 +1,91 @@ +Title: Plan–Act–Observe–Refine Implementation Specification (PowerOn) + +Scope +- This document specifies concrete, stepwise changes to adopt the iterative loop across models, workflow engine, state machine, prompts, and handlers. + +1) Data Models (modules/interfaces/interfaceChatModel.py) +- Add minimal schemas for the two-step protocol: + - ActionSelection: { method: str, name: str } + - ActionParameters: { parameters: dict } +- Add Observation model returned to the model after each action: + Observation: { success: bool, resultLabel: str, documentsCount: int, previews: [{name,mime,snippet}], notes: [str] } +- Extend TaskWorkflow context with: maxSteps (int), reactMode (bool). +- No breaking changes to ActionResult/ActionDocument; keep stable. + +2) Workflow Engine (gateway/modules/chat/managerChat.py) +- Entry point remains executeUnifiedWorkflow. +- Per task, switch to plan–act loop instead of generating a full action list: + - For each iteration (<= maxSteps): + 1) Call createActionSelectionPrompt → get {action:{method,name}}. + 2) Validate allowed method; if invalid, request another selection (one retry). + 3) Call createActionParameterPrompt with the selected action → get {parameters:{...}}. + 4) Validate/fill defaults in code; executeSingleAction. + 5) Build Observation (compact) and feed to createRefinementPrompt; if “stop”, break. +- Preserve current messaging (start/step/complete) but at iteration granularity; keep document routing the same. + +3) State Machine (gateway/modules/chat/handling/executionState.py) +- Track iteration count (current_step) and max_steps. +- Maintain criteria progress across steps as today, but per-iteration. +- Provide helper: should_continue(observation, review) -> bool. + +4) Prompts (gateway/modules/chat/handling/promptFactory.py) +- New compact prompts: + a) createActionSelectionPrompt(context): returns only one action selection. + b) createActionParameterPrompt(context, selected_action): returns only parameters for that action. + c) createRefinementPrompt(context, observation): returns decision: {"decision":"continue|stop","reason":"..."} and, if continue, optionally a hint for next subgoal. +- Keep existing task planning and review prompts; they remain for high-level plan and QA. +- Replace the long “available methods” JSON with a tiny catalog (names + parameter names only). +- Embed 5-line business rules; drop provider specifics. + +5) HandlingTasks (gateway/modules/chat/handling/handlingTasks.py) +- New flow inside executeTask: + - Initialize iteration=0; while iteration run existing reviewTaskCompletion to finalize; else continue. +- Keep createTaskAction for backward compatibility (batch plans) but mark as legacy. + +6) Defaults & Validation (code, not prompts) +- Derive userLanguage from workflow/user; set defaults for web.* depth/time if implied by criteria. +- ai.process defaults to markdown narrative unless expectedDocumentFormats requires JSON/CSV. +- Strict validation: reject missing required params; soft-fill optional ones. + +7) Web Accuracy Enhancements (optional but recommended) +- In methodWeb.scrape, keep enrichment + reranking (already added) behind a config flag. +- Observation should surface relevance_score, key_points, entities for top-k results. + +8) Telemetry and Limits +- Track per-iteration tokens/time; stop early if budget exceeded. +- Expose step count and decision reasons in logs for auditability. + +Migration Plan +Step A (Non-breaking): + - Add Observation model/types; add compact prompt creators (unused initially). + - Gate enrichment in methodWeb.scrape via config. +Step B (Switch path): + - Add reactMode flag; if true, executeTask uses iterative loop; else keep legacy full action plan. +Step C (Tighten prompts): + - Replace verbose catalog with tiny catalog when reactMode. + - Add 5-line rules and schema caps (one action per step; minimal params). +Step D (Clean up): + - Deprecate bulk action plan path after validation; keep fallback. + +Testing Strategy +- Unit: selection -> parameters validators; defaults application; observation builder. +- Integration: run a research task in reactMode and verify iterations, labels, and final output. +- Regression: legacy flow must still pass existing tests when reactMode=false. + +Security Considerations +- Whitelist allowed methods per task type; sanitize parameters (URLs, file refs). +- Limit step count and token budget to avoid runaways. + +Appendix: Minimal JSON Schemas +- Selection: {"action":{"method":"web","name":"scrape"}} +- Parameters: {"parameters":{"query":"...","maxResults":10,"language":"de"}} +- Observation: {"success":true,"resultLabel":"round1_task1_action1_results","documentsCount":3,"previews":[{"name":"...","mime":"application/json","snippet":"..."}]} +- Refinement decision: {"decision":"continue","reason":"Need more sources on Q3 2024"} + +