lauren-framework

Writes Lauren guards, interceptors, and middlewares. Covers @guard, can_activate, ExecutionContext, @interceptor, intercept/CallHandler, @middleware() (parentheses required), dispatch/call_next, use_guards, use_interceptors, use_middlewares, set_metadata, propagate_metadata, and WebSocket guards via WsConnectionContext. Use when protecting routes, transforming responses, or adding cross-cutting logic to a Lauren app.

Adds signed-cookie sessions to a Lauren app. Covers sessions=SessionConfig(...), session: Session injection, request.state.session, SessionStore backends (InMemorySessionStore, SignedCookieSessionStore, Redis), secure cookie defaults, regenerate_id()/invalidate(), rolling/idle expiry, secret rotation, and the SessionConfigError startup checks. Use when persisting per-client state across requests (carts, flash messages, the authenticated user id).

Implements an in-memory session store with cookie-based session IDs in Lauren. Use when you need server-side session state without a JWT or external cache.

Writes Lauren controllers with route handlers, typed extractors, and auto-serialization. Covers @controller, @get/@post/@put/@patch/@delete, Path/Query/Header/Cookie/Json/Form/Bytes extractors, field descriptors, pipes, all return-type patterns, propagate_metadata, and reflect_routes/get_all_routes. Use when adding routes, extractors, or HTTP handlers to a Lauren app.

Tests Lauren apps with TestClient (sync) and httpx.AsyncClient (async). Covers conftest setup, env vars before imports, app startup, mock providers, common assertion patterns, e2e multi-backend testing, and Hypothesis property tests. Use when writing unit, integration, e2e, or property tests for a Lauren app.

Writes Lauren SSE endpoints with EventStream/ServerSentEvent and WebSocket gateways with ws_controller/on_connect/on_message/on_disconnect/BroadcastGroup. Use when adding real-time streaming or bidirectional communication to a Lauren app.

Scaffolds and builds Lauren Python web framework applications. Covers LaurenFactory.create(), the @module system, project file layout, and wiring everything together. Use when creating a new Lauren project, setting up AppModule, or understanding how Lauren's startup phases work.

Provides copy-paste complete Lauren framework patterns for the most common production scenarios. Covers authenticated CRUD endpoints, health check module, background job with lifecycle hooks, and typed SSE streaming. Use when scaffolding a new feature or when a complete working example is needed rather than API reference.

Adds content safety filters to lauren-ai agents using @use_guardrails for input and output checks. Use when an agent needs prompt injection protection, PII redaction, topic filtering, length limiting, or LLM-powered content evaluation. Also covers creating custom guardrail classes injectable via @guardrail.

Aggregates per-model telemetry from SignalBus events using CostTracker and a custom PerformanceMetrics collector. Use when tracking total LLM calls, token consumption, average latency, error rate, and cost per model across agent runs.

Submit agent tasks to an asyncio queue and process them with a background worker, returning results by task ID. Use when you need non-blocking agent execution in web handlers, batch processing pipelines, or any situation where callers should not wait for agent completion.

Builds AI agents with the lauren-ai framework using @agent, @use_tools, and AgentRunner. Use when defining an agent class, setting up lifecycle hooks, streaming responses, implementing agent delegation, or configuring the agentic loop with tools, guardrails, and memory.

Creates tools for lauren-ai agents using @tool() on async functions or classes. Use when implementing a @tool() function or class, working with ToolContext for DI injection, adding caching, HITL approval, or using built-in skills like WebSearchTool, HttpFetchTool, or CodeExecutionTool.

Implements an in-memory calendar management tool for agents using @tool() class-form. Use when building agents that create, query, or cancel calendar events, with ISO 8601 time handling and date-based filtering. Supports @set_metadata for tool-type annotation.

Subscribe to SignalBus lifecycle events to build lightweight tracers that record LLM call spans, tool call spans, and run summaries. Use when you need observability into agent execution without adding a full tracing backend, or when building cost/latency dashboards.

Elicits step-by-step reasoning from models to improve accuracy on complex tasks. Use when the task involves multi-step logic, math, code analysis, or planning; when zero-shot answers are unreliable; or when you need to extract and inspect the model's reasoning separately from its final answer.