ai chat app Send back the complete code with all the fix...

Prompt

ai chat app Send back the complete code with all the fixes. Fix each of the listed errors one by one, making sure to actually correct them so that there are 0 errors remaining. Keep the original imports, since the files exist. Write out every single character; do not abbreviate anything. Fix every error. There must be exactly one file. Do not write anything else; just output the complete code, and it must not contain any comments. Never, under any circumstances, use simplified, substitute, dummy, simulated, or fake code. Write the entire file as complete, unabridged, production-ready code in a single code block. It must be 100% error-free, a complete, error-free file, and must be submitted as a downloadable file. These requirements are mandatory and must be strictly adhered to. If no list of errors is provided, you must find all the errors and fix them. If there were comments in the original code, delete them. And most importantly: YOU MUST NEVER SIMPLIFY! an “autonomous” agent that doesn’t stop when the UI closes need a persistent agent loop with server-side state and checkpoints, plus real tool execution boundaries. Use an orchestratorcyclic graph + durable SQLite/Postgres checkpoints so it can resume after crashes for backend integraty this model: import os from openai import OpenAI client = OpenAI( base_url="https://api.modular.com/v1", api_key=os.environ["MODULAR_API_KEY"], ) response = client.chat.completions.create( model="zai-org/glm-5.3", messages=[ { "role": "system", "content": "You are a helpful assistant. Be concise and accurate. Answer in plain text without markdown unless asked.", }, ], stream=True, stream_options={ "include_usage": True, }, temperature=0.96, top_p=1, max_tokens=100000, frequency_penalty=0.8, presence_penalty=0.5, seed=1234, ) for chunk in response: if not chunk.choices: continue content = chunk.choices[0].delta.content if content: print(content, end="") frontend is @index.html A hagyományos, szöveges előzményeket végtelenül összefűző (append-only) ágens-ciklus helyett az ágens futásideje egy explicit, strukturált állapotátmeneti folyamattá alakul: • Állapot mint elégséges statisztika: A modell a lépés során kizárólag a statikus feladatspecifikációt ($P$), a strukturált végrehajtási állapotot ($S_t$) és a legfrissebb környezeti megfigyelést ($O_t$) kapja meg. • Átmeneti gondolkodási lánc eldobása: A lépés közbeni többlépéses okoskodási nyomvonal (reasoning trace) a determinisztikus validáció és állapotfrissítés után azonnal megsemmisül. • Véges és $O(1)$ méretű prompt-lábnyom: A kontextusméret nem nő a feladat hosszával, megakadályozva a kontextus-eróziót és a memória-túlcsordulást. A zárt modell súlyainak megváltoztatása nélkül az alkalmazkodás és a tanulás az Experiential-Working Memory (EM-WM) rétegben valósul meg: • Munkamemória (WM): Nyomon követi az aktuális feladat-előrehaladást és a még meg nem oldott célokat, ezzel vezérelve a releváns készségek behívását. • Tapasztalati Memória (EM): Újrafelhasználható, strukturált készségeket és procedurális mintákat tárol. • Validációval védett meta-hurok: A sikertelen végrehajtási nyomvonalak alapján egy rögzített meta-ágens lokalizálja a hibát egy adott memóriekomponensre, célzott javítási csomagot (patch) készít, amelyet egy determinisztikus validációs kapun keresztül léptet éle Construct a complete, production-ready, long-horizon autonomous agent runtime system that eliminates append-only conversational history accumulation by implementing explicit, structured execution states, coupled working-experiential memory, self-reflective token-level policy distillation, deterministic validation gating, and continuous cross-task skill evolution around a frozen, stateless language model API. 1. Architectural Foundation and State Transition Engine Build a deterministic runtime kernel where the agent's execution state $\Sigma_t$ serves as the sufficient statistic for all future computations, guaranteeing that cumulative prompt size scales strictly as $O(1)$ per step and total token consumption scales strictly as $O(T)$ over an execution horizon $T$. - Define an immutable procedural specification schema $P$, a structured mutable state dictionary $\Sigma_t$, and an observation schema $O_t$. - At each execution step $t$, construct the input prompt containing strictly $(P, \Sigma_t, O_t)$. Never include historical transcripts, prior actions, or past reasoning traces. - Invoke the language model to generate within-step multi-step reasoning followed by a structured state patch $\Delta\Sigma$ and an action command $A_t$. - Implement deterministic runtime validation for $\Delta\Sigma$. Apply dictionary-merge semantics with explicit null-deletion primitives ($\Sigma_{t+1} = \Sigma_t \oplus \Delta\Sigma$, where null keys delete attributes). - Discard all intermediate reasoning traces immediately after state transition validation. If validation fails, trigger an automatic rollback to $\Sigma_t$ and invoke a retry cycle. For local execution, integrate grammar-constrained schema decoders. 2. Dual-Layer Coupled Memory Architecture (WM-EM) Implement an Experiential-Working Memory layer that decouples transient task execution from durable procedural skill acquisition: - Working Memory (WM): Construct an active state tracking engine that maintains verified task progress, subgoals, unresolved dependencies, and environmental constraints. - Experiential Memory (EM): Implement a structured repository of reusable skills, procedural tools, and failure-workaround patterns. - State-Grounded Skill Invocation: Implement an event-driven router that queries EM using the compact, verified WM state rather than raw dialogue history, injecting only the single or two most relevant procedural skills into the step prompt. - Evidence Formatting: Structure all execution feedback into typed execution traces linking initial task state, selected skill, step outcome, and post-execution state delta. 3. Self-Reflective Policy Optimization and Token-Level Supervision Engine Implement a reset-with-memory self-reflective optimization engine to convert trajectory outcomes into dense token-level training signals without requiring external supervisor models: - Reflection Patch Generation: After completing a trajectory rollout, evaluate the terminal state against external boolean verifiers. Generate a compact Reflection Patch $p$ diagnosing exact failure points and pivot actions. - Privileged Teacher Scoring: Implement a dual-pass evaluation pipeline. Roll out candidate actions from the clean initial state prompt $x$ while simultaneously scoring token log-probabilities under the privileged teacher prompt $[p; x]$. - Reverse-KL Distillation: Optimize the base policy by minimizing the reverse-Kullback-Leibler divergence between the privileged teacher distribution and the unconditioned student policy. - Provide dense $O(T)$ token-level supervision per episode to eliminate exposure bias and prevent catastrophic forgetting under continuous task distribution shifts. 4. Tri-Tier Knowledge Evolution and Meta-Agent Harness Construct an out-of-loop, validation-gated recursive memory evolution harness: - Raw Trace Layer: Implement an append-only, immutable storage layer that logs all verified execution trajectories and environmental receipts. - Persistent Knowledge Layer (Wiki/Playbook): Maintain an evolving markdown knowledge base containing categorized failure patterns, environment-specific caveats, and verified workarounds. Implement Git-backed versioning with diff calculation between consolidation epochs. - Active Skill Layer: Maintain the production skill library. Implement an isolated, non-self-modifying Meta-Agent that reads failure diagnostics from the Raw Layer, attributes failures to specific memory components, and generates scoped, minimal patch proposals for the Active Skill Layer. - Deterministic Validation Gate: Route every proposed skill patch through an automated regression test suite across held-out diagnostic tasks. Reject and roll back any patch that causes performance regression. 5. Asynchronous Dual-Speed Kognitive Runtime (System 1 / System 2) Implement a decoupled execution scheduler: - Deliberative Reasoning Engine (System 2): Run a background loop operating at low frequency (e.g., 1 Hz) that processes long-term context, updates the structured working memory $\Sigma_t$, and emits continuous, dense cognition tokens $C_t \in \mathbb{R}^{K \times H}$ alongside transition gates and subgoal specifications. - Reactive Action Controller (System 1): Run an execution loop at high frequency (e.g., 20 Hz) that receives the immediate environmental observation $O_t$, the latest available cognition token $\tilde{C}_j$, and a sinusoidally encoded temporal staleness indicator representing the elapsed time since $C_t$ generation. 6. Storage, Tooling, and Enterprise Hardening - Storage Subsystem: Implement persistent storage using an ACID-compliant transactional database (PostgreSQL with `pgvector` and `tsvector` or SQLite) supporting dense vector embeddings, sparse BM25 keyword search, and Reciprocal Rank Fusion (RRF). - Filesystem Primitives: Implement atomic file operations including line-oriented appending with deduplication (`append_file(unique=True)`), line range replacement (`replace_lines`), and batched exact-line membership testing (`check_lines`). - Deterministic Governance: Enforce explicit security guardrails including multi-tenant row-level security (RLS), tool-call authorization fences, zero-trust action verification, token-budget enforcement, and external non-generative classifiers for output validation. Deliver the entire software architecture in fully written, complete, unabridged, production-ready code with all schemas, engines, harnesses, validation gates, optimization routines, and execution entry points fully implemented without any mock, stub, or placeholder functions. backend egy darab main.py legyen Send back the complete code with all the fixes. Fix each of the listed errors one by one, making sure to actually correct them so that there are 0 errors remaining. Keep the original imports, since the files exist. Write out every single character; do not abbreviate anything. Fix every error. There must be exactly one file. Do not write anything else; just output the complete code, and it must not contain any comments. Never, under any circumstances, use simplified, substitute, dummy, simulated, or fake code. Write the entire file as complete, unabridged, production-ready code in a single code block. It must be 100% error-free, a complete, error-free file, and must be submitted as a downloadable file. These requirements are mandatory and must be strictly adhered to. If no list of errors is provided, you must find all the errors and fix them. If there were comments in the original code, delete them. And most importantly: YOU MUST NEVER SIMPLIFY!