Release v0.3.151

fix: rename sessions from the chat rail

.github/automation.meta.json

@@ -3,7 +3,7 @@
   "stack": "claude",
   "profile": "sdk",
   "mode": "hub",
-  "hubRef": "v1.1.6",
-  "templateVersion": "1.1.6",
+  "hubRef": "v1.1.11",
+  "templateVersion": "1.1.7",
   "installedAt": "2026-09-07T10:02:11Z"
 }

.github/scripts/gate-config.js

@@ -4,6 +4,10 @@
 
 module.exports = {
   repoFullName: 'MervinPraison/PraisonAIUI',
+  gitUser: 'MervinPraison',
+  gitEmail: '[email protected]',
+  triggerLogins: ['MervinPraison', 'github-actions[bot]'],
+  allowedTriageBots: ['praisonai-triage-agent[bot]'],
   productPathPrefixes: ['src/praisonaiui/', 'src/frontend/', 'tests/'],
   sensitivePathPatterns: [
     /^\.github\/workflows\//,

.github/workflows/auto-pr-comment.yml

@@ -10,7 +10,7 @@ on:
   pull_request_target:
     types: [opened, synchronize]
   schedule:
-    - cron: '30 3,9,15,21 * * *'
+    - cron: '30 * * * *'
   workflow_dispatch:
 
 env:
@@ -27,7 +27,7 @@ jobs:
     permissions:
       issues: write
       pull-requests: write
-    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].6
+    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].20
     secrets: inherit
     with:
-      hub_ref: v1.1.6
+      hub_ref: v1.1.20

.github/workflows/bot-pr-recovery.yml

@@ -16,8 +16,8 @@ permissions:
 
 jobs:
   recover:
-    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].6
+    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].20
     secrets: inherit
     with:
-      hub_ref: v1.1.6
+      hub_ref: v1.1.20
       pr_number: ${{ github.event.inputs.pr_number || '' }}

.github/workflows/ci-failure-claude.yml

@@ -25,8 +25,8 @@ permissions:
 
 jobs:
   detect-and-trigger:
-    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].6
+    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].20
     secrets: inherit
     with:
-      hub_ref: v1.1.6
+      hub_ref: v1.1.20
       pr_number: ${{ github.event.inputs.pr_number || '' }}

.github/workflows/ci.yml

@@ -36,6 +36,30 @@ jobs:
       - name: Integration smoke tests
         run: pytest tests/integration/test_agentic_roundtrip.py tests/test_feature_sdk_backends.py -q --no-cov --timeout=120
 
+  frontend:
+    name: frontend
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: npm
+          cache-dependency-path: src/frontend/package-lock.json
+
+      - name: Install dependencies
+        run: npm ci
+        working-directory: src/frontend
+
+      # `npm run build` is the dashboard ship path: dist/ is synced to
+      # src/praisonaiui/templates/frontend/ (see src/frontend/README.md).
+      - name: Build frontend
+        run: npm run build
+        working-directory: src/frontend
+
   docs:
     runs-on: ubuntu-latest
     if: github.ref == 'refs/heads/main'

.github/workflows/claude-merge-gate.yml

@@ -43,9 +43,9 @@ jobs:
       id-token: write
     steps:
       - uses: actions/checkout@v4
-      - uses: MervinPraison/github-automation-template/.github/actions/[email protected].6
+      - uses: MervinPraison/github-automation-template/.github/actions/[email protected].20
         with:
-          hub_ref: v1.1.6
+          hub_ref: v1.1.20
       - name: Generate GitHub App token
         id: app-token
         uses: actions/create-github-app-token@v1
@@ -87,9 +87,10 @@ jobs:
       issues: write
       actions: read
       id-token: write
-    uses: MervinPraison/github-automation-template/.github/workflows/[email protected]
+      statuses: write   # the assess job records security/outsider-review
+    uses: MervinPraison/github-automation-template/.github/workflows/[email protected]
     secrets: inherit
     with:
-      hub_ref: v1.1.6
+      hub_ref: v1.1.20
       pr_number: ${{ github.event.inputs.pr_number || github.event.client_payload.pr_number || '' }}
       merge_method: ${{ github.event.inputs.merge_method || 'merge' }}

.github/workflows/claude.yml

@@ -18,7 +18,7 @@ jobs:
       issues: write
       actions: read
       id-token: write
-    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].6
+    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].20
     secrets: inherit
     with:
-      hub_ref: v1.1.6
+      hub_ref: v1.1.20

.github/workflows/merge-conflict-claude.yml

@@ -25,9 +25,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: MervinPraison/github-automation-template/.github/actions/[email protected].6
+      - uses: MervinPraison/github-automation-template/.github/actions/[email protected].20
         with:
-          hub_ref: v1.1.6
+          hub_ref: v1.1.20
       - name: Detect conflicting PRs and trigger Claude
         uses: actions/github-script@v7
         with:

.github/workflows/pipeline-status-sync.yml

@@ -13,7 +13,7 @@ permissions:
 
 jobs:
   sync:
-    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].6
+    uses: MervinPraison/github-automation-template/.github/workflows/[email protected].20
     secrets: inherit
     with:
-      hub_ref: v1.1.6
+      hub_ref: v1.1.20

.gitignore

@@ -44,6 +44,7 @@ Thumbs.db
 # Project specific
 aiui/
 *.log
+*.err
 .praison/
 .gemini/
 .internal/

README.md

@@ -366,3 +366,7 @@ pytest tests -v
 ## License
 
 MIT © [Praison Limited](https://praison.ai)
+
+Third-party vendored source is documented in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
+See the [BeautifulUI upgrade playbook](docs/frontend/beautifului.md) for how BeautifulUI
+primitives are vendored and pinned.

SECURITY.md

@@ -0,0 +1,37 @@
+# Security Policy
+
+We take the security of PraisonAIUI seriously and appreciate responsible
+disclosure of vulnerabilities.
+
+## Supported Versions
+
+Security fixes are applied to the latest released version of PraisonAIUI.
+Please make sure you are on the most recent release before reporting.
+
+## Reporting a Vulnerability
+
+**Please do not open a public issue for security vulnerabilities.**
+
+Report privately through GitHub's **Private Vulnerability Reporting**:
+
+1. Go to the [Security tab](https://github.com/MervinPraison/PraisonAIUI/security)
+   of this repository.
+2. Click **"Report a vulnerability"** to open a private advisory.
+3. Include as much detail as you can:
+   - Affected component(s) and version.
+   - Steps to reproduce.
+   - Impact assessment.
+   - Any suggested fix or mitigation.
+
+If you are unable to use private reporting, you may open a public issue that
+contains **no technical specifics** and requests a private channel, and a
+maintainer will follow up.
+
+## What to Expect
+
+- We aim to acknowledge new reports within a few business days.
+- We will keep you informed as we investigate and work on a fix.
+- Once a fix is released, we are happy to credit you in the advisory (unless
+  you prefer to remain anonymous).
+
+Thank you for helping keep PraisonAIUI and its users safe.

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,43 @@
+# Third-Party Notices
+
+PraisonAIUI incorporates or vendors source from the third-party projects listed below.
+Their licences and copyright notices are retained here as required.
+
+---
+
+## BeautifulUI
+
+- Project: BeautifulUI — <https://www.beautifului.dev/>
+- Source: <https://github.com/slev12397/beautiful-ui>
+- Licence: MIT
+
+BeautifulUI is distributed as a shadcn registry / copy-paste library (no npm package).
+When its React primitives are vendored into `src/frontend`, the following MIT licence
+applies to that copied source.
+
+```
+MIT License
+
+Copyright (c) Shane Levine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+See the upgrade playbook at [`docs/frontend/beautifului.md`](docs/frontend/beautifului.md)
+for how BeautifulUI is vendored and pinned.

aiui.template.yaml

@@ -59,6 +59,11 @@ navigation:
             - typescript/runtime
             - typescript/nextjs
             - typescript/components
+        - group: "Frontend"
+          icon: "layout"
+          prefix: "frontend"
+          pages:
+            - frontend/beautifului
         - group: "Examples"
           icon: "folder-open"
           prefix: "examples"

docs/adr/0001-replay-view-clean-room.md

@@ -0,0 +1,94 @@
+# ADR 0001: PraisonAI Replay view, a clean-room design
+
+- **Status:** accepted
+- **Date:** 2026-10-26
+- **Scope:** `src/praisonaiui/features/replay.py`, `features/_trace_jsonl.py`,
+  `templates/frontend/plugins/views/replay-core.js`, `templates/frontend/plugins/views/replay.js`
+
+## Context
+
+PraisonAI records agent runs as context-trace JSONL (one `ContextEvent.to_dict()` per
+line). People need to see what a team or flow did: who did what, when, why, and at what
+cost, both after the fact and live. Other tools have shown that a graph plus a trace is a
+useful way to look at agent runs. We want that value without copying anyone's product,
+code or look, and without adding dependencies.
+
+## Decision
+
+Build our own view, in plain DOM and SVG, with our own layout code, palette and words.
+
+### Ideas we took (ideas only)
+
+| Idea | Where it came from | What we did with it |
+|---|---|---|
+| Show the graph of a multi-agent program next to the trace of a run | The general concept behind LangGraph Studio's graph-plus-trace view, known from public talks and articles | A **Map** view drawn by our own layered layout (`layoutMap`); the default view is a **Timeline**, which Studio does not have |
+| Parallel voices on shared time, read left to right | Musical scores and swimlane diagrams | One lane per agent plus Manager and You; parallel branches as sub-lanes; tasks and steps as "chapters" across the top |
+| Vocabulary for LLM and tool spans, tokens and cost | OpenTelemetry GenAI semantic conventions (public specification) | Block kinds (LLM, tool), token and cost totals; the wrapper's OTLP export uses the conventions, the UI only borrows the concepts |
+
+### What we did not use
+
+- **No third-party UI code, CSS, icons, layouts or screenshots** were used to build this
+  view. Shapes, palette, spacing, wording ("Brief", "Delivered", "Waiting for you") and
+  the layout algorithm are our own.
+- **LangGraph's server (Elastic License 2.0) and the proprietary LangGraph Studio were
+  not consulted for code**, and none of their assets, markup or styles were copied. We
+  do not use the name "Studio", any "Lang…" naming, or `__start__`/`__end__` pills.
+- No Mermaid, D3, React Flow, dagre, ELK or other graph libraries. The dashboard's
+  existing Mermaid CDN plugin is not used by Replay.
+
+### How it is built
+
+- `replay-core.js`: pure functions (`buildModel`, `narrate`, `layoutMap`,
+  `deriveGraph`). No DOM, no network. Tested with `node --test`.
+- `replay.js`: DOM/SVG rendering, keyboard handling, SSE follow and approvals. It also
+  boots by itself when `window.__REPLAY_DATA__ = {events, graph}` is set, which is how
+  the wrapper's single-file HTML export works (`standalone_html()` inlines both files).
+- `layoutMap` is a textbook layered layout written from scratch: depth-first search to
+  find back edges (loops), longest-path layering, one virtual waypoint per crossed layer
+  for long edges, and a few barycentre sweeps to order each layer. It is deterministic.
+- Narration is template text, chosen per event type. No LLM, no randomness.
+
+## Palette and accessibility rationale
+
+| Role | Fill | Shape | Why |
+|---|---|---|---|
+| Agent | `#8B0000` | circle | PraisonAI's brand red; white text on it is 10.0:1 |
+| Tool | `#0F7287` | rounded rectangle | Teal kept from the brand but darkened from `#189AB4` (white text on `#189AB4` fails AA); white on `#0F7287` is 5.6:1 |
+| You (human) | `#8A5A00` | diamond | Amber distinct from red and teal for common colour-vision deficiencies; white on it is 5.9:1 |
+| Manager | `#3C4A5C` | square | Neutral slate, so the manager reads as coordination, not work; white on it is 9.0:1 |
+
+- **Never colour alone.** Every lane, block, node and step has a shape and a text label;
+  arrows differ by dash pattern and carry words ("hands off", "delegates", "routes").
+  Heat in the cost/latency overlay is a bar whose height and shade both grow, plus the
+  value in text.
+- **Theme.** Follows the system setting (`prefers-color-scheme`) by default, with a
+  Light/Dark override; the light theme is the design baseline.
+- **Light theme first.** Text tokens are at least 6.9:1 on their backgrounds in light mode
+  and 7.7:1 in dark mode. In dark mode the palette fills keep white text at AA, and get a
+  light 2 px outline so each shape's boundary stays above 3:1 against the dark page.
+- **Keyboard throughout.** ← → (and ↑ ↓ in the step list) move the replay cursor, Home
+  and End jump to the ends, tabs follow the ARIA tabs pattern, map nodes use a roving
+  tab stop, and every action has a real button.
+- **Screen readers.** The narration column is a real ordered list and is the main way
+  through a run. Timeline blocks and map nodes are named buttons whose names start with
+  their visible text (WCAG 2.5.3). Live updates are announced through a polite live
+  region, throttled.
+- **Motion.** The only animation (the live dot) runs only under
+  `prefers-reduced-motion: no-preference`; scrolling is instant when motion is reduced.
+- Checked with axe-core against WCAG 2.0, 2.1 and 2.2 A/AA in both themes (dev-only test
+  in `tests/browser/`).
+
+## Dependency licences
+
+No new runtime or build dependencies. The Python side uses only the standard library and
+Starlette, which aiui already depends on. The browser side is plain ES modules with no
+imports beyond our own file. Dev-only test tools that are not shipped: Playwright
+(Apache-2.0, already used in this environment) and axe-core (MPL-2.0, loaded from a path
+given by `AXE_CORE_JS`; not vendored).
+
+## Consequences
+
+- We own the look and the layout code, and can change them without licence questions.
+- The layout is simpler than a dedicated graph engine. It is fine for the team and flow
+  sizes we see (tens of nodes). Very large graphs may need a better crossing-reduction
+  step later.

docs/features/beautifului-integration.md

@@ -0,0 +1,56 @@
+# BeautifulUI Integration Strategy
+
+> **Epic:** [#292](https://github.com/MervinPraison/PraisonAIUI/issues/292) — BeautifulUI integration strategy for AI-native dashboard UX.
+> This is the durable, agreed strategy that the linked child issues execute against.
+
+[BeautifulUI](https://www.beautifului.dev/) (MIT, Shane Levine / Turbo) is a **copy-paste / shadcn-registry** library of React primitives for AI-native interfaces: thinking traces, streaming answers with inline sources, HITL approval cards, tool chips, task rows, context chunks, diff/records tables, prompt bars, and a reference chat harness.
+
+There is **no published npm package** named `beautiful-ui`. It ships only as source consumed via the shadcn registry or manual copy.
+
+## 1. Strategic decision
+
+BeautifulUI is adopted as **vendored source**, not a runtime dependency, and is exposed to dashboard plugins **only through the existing `@praisonaiui/react` package** — never by importing upstream file paths directly. Rollout is **phased behind a feature flag**, keeping the current vanilla dashboard as the fallback until parity is proven.
+
+Upstream stack (Next.js 15 · React 19 · Tailwind v4 · TypeScript) is closely aligned with PraisonAIUI's `src/frontend` (Vite · React 19 · Tailwind v4 · shadcn/Radix), so primitives port with adapter work rather than a runtime bridge.
+
+## 2. Pillars
+
+| # | Pillar | Decision |
+|---|--------|----------|
+| 1 | **Vendoring model** | Add primitives into `src/frontend` via `npx shadcn add https://www.beautifului.dev/r/<component>.json`, or manual copy from [github.com/slev12397/beautiful-ui](https://github.com/slev12397/beautiful-ui). Pin via lockfile plus a recorded registry URL / git SHA. No `beautiful-ui` npm dependency in production builds. |
+| 2 | **Adapter layer** | Map PraisonAIUI chat / approval / trace **protocol events** to stable internal props. Primitives sit behind `@praisonaiui/react` exports; dashboard plugins consume those exports, not upstream paths. See [#294](https://github.com/MervinPraison/PraisonAIUI/issues/294). |
+| 3 | **Hybrid rollout** | Mount React **islands** (or expand `@praisonaiui/react`) for high-value surfaces first — chat streaming/thinking/tools, then approvals. Vanilla chat (`templates/frontend/plugins/views/chat.js`) stays as the flag-gated fallback until parity is proven. |
+| 4 | **Token strategy** | Merge BeautifulUI foundation CSS **selectively** into the existing shadcn theme generation (`praisonaiui/themes.py`). One design system per page — avoid two competing token sets. |
+| 5 | **Icon licence** | Upstream `SidebarNav` uses the paid `@central-icons-react`. Port nav patterns with **lucide-react** (already in PraisonAIUI) instead. |
+
+## 3. Phasing
+
+1. **Spike** — evaluate primitives in the dev environment, confirm React 19 / Tailwind v4 alignment. [#293](https://github.com/MervinPraison/PraisonAIUI/issues/293)
+2. **Architecture** — adapter layer + upstream pin policy. [#294](https://github.com/MervinPraison/PraisonAIUI/issues/294)
+3. **CI gate** — frontend build + BeautifulUI compatibility check (no frontend build gate exists today). [#295](https://github.com/MervinPraison/PraisonAIUI/issues/295)
+4. **Migrations** — chat streaming / thinking / tool chips ([#296](https://github.com/MervinPraison/PraisonAIUI/issues/296)), then the approval card ([#297](https://github.com/MervinPraison/PraisonAIUI/issues/297)).
+5. **Docs** — upgrade playbook + MIT attribution. [#298](https://github.com/MervinPraison/PraisonAIUI/issues/298)
+
+## 4. Risks
+
+| Risk | Mitigation |
+|------|------------|
+| No semver npm package | Vendor the source; pin to a recorded registry URL / git SHA in the lockfile. |
+| Upstream breaking registry JSON | Vendoring decouples builds from live registry; re-sync is a deliberate, reviewed step. |
+| Icon licence (`@central-icons-react` is paid) | Use lucide-react for ported nav patterns; never vendor the paid package. |
+| Two competing design systems on one page | Selective CSS token merge into `themes.py`; adapter-only prop surface. |
+| React / Tailwind drift | Upstream (React 19 / Tailwind v4) already matches `src/frontend`; the CI gate catches drift. |
+
+## 5. Out of scope
+
+- Replacing the entire dashboard shell in one PR.
+- PyPI packaging of BeautifulUI.
+- iframe embedding of beautifului.dev.
+- Depending on any unpublished npm package for production builds.
+
+## 6. Acceptance criteria status
+
+- [x] Written integration strategy agreed (vendoring + adapter + phased rollout) — this document.
+- [x] Risks documented — section 4.
+- [x] Child issues filed and prioritised — [#293](https://github.com/MervinPraison/PraisonAIUI/issues/293)–[#298](https://github.com/MervinPraison/PraisonAIUI/issues/298).
+- [x] No requirement to depend on unpublished npm packages for production builds — pillar 1, out of scope.

docs/features/replay.md

@@ -0,0 +1,176 @@
+# Replay
+
+**PraisonAI Replay** shows a recorded agent run as a story: who did what, when, why, and
+at what cost. It works for finished runs and for runs that are still going.
+
+## Record a run, then open it
+
+```bash
+praisonai replay view agents.yaml      # records the run and opens Replay on it
+```
+
+or from Python:
+
+```python
+from praisonai.replay import record
+
+with record(live=True):
+    team.start()
+```
+
+Every recorded run is a file `<id>.jsonl` in the traces folder. Replay reads it from
+`$PRAISONAI_TRACES_DIR`, else `$PRAISON_HOME/traces`, else `~/.praison/traces`.
+
+To open aiui on Replay yourself:
+
+```bash
+aiui run "$(python -c 'import praisonaiui.replay_app as m; print(m.__file__)')" \
+    --style dashboard --host 127.0.0.1 --port 8090
+# then open http://127.0.0.1:8090/replay?run=<id>
+```
+
+`/#/replay?run=<id>` works too. In a full dashboard, Replay is in the sidebar under
+**Control**.
+
+## Watch a run live: the Run button
+
+For learning, demos and debugging, open a page with a **Run** button. Each click records
+a new run, and the page draws it as it happens:
+
+```python
+from praisonai.replay import watch
+
+watch(flow, input="solar sails")   # an Agent, AgentTeam, AgentFlow or agents.yaml
+```
+
+```bash
+praisonai replay watch agents.yaml
+```
+
+On the **Map**, each step and agent shows where the run is: dashed means not reached,
+blue (pulsing) means running now, green means done and red means failed. After a run,
+**▶ Play** moves through it again one step at a time, and the map rewinds with it. One
+run goes at a time. Each run of a team starts its tasks afresh; an Agent keeps its chat
+history between runs.
+
+## Show progress inside your own app
+
+`create_replay_app()` is the same view as a small ASGI app, without the dashboard. Mount
+it in any FastAPI or Starlette app:
+
+```python
+from praisonai.replay import record, replay_app
+
+app.mount("/replay", replay_app())         # read-only: shows recorded runs
+
+# wherever your app starts work:
+with record(run_id, live=True):
+    team.start()
+```
+
+Then show one run, live, in your page, for example in an `<iframe>`:
+
+```html
+<iframe src="/replay/?run=RUN_ID" style="width:100%;height:640px"></iframe>
+```
+
+| URL | Shows |
+|---|---|
+| `/replay/` | The run list and the selected run |
+| `/replay/?run=<id>` | Only that run, no list. A run that has not started yet is waited for. |
+
+`replay_app(team)` adds the Run box to the mounted page. Without the PraisonAI wrapper,
+pass any `run(input, run_id)` callable to `praisonaiui.features.replay.create_replay_app`;
+it must record the run under `run_id`. For a page you build yourself, the view is one
+module:
+
+```html
+<div id="progress"></div>
+<script type="module">
+  import { render } from "/replay/replay.js";
+  render(document.getElementById("progress"), { base: "/replay", run: "RUN_ID", approve: false });
+</script>
+```
+
+`render()` options: `base` (where the API is mounted), `run` (show only this run),
+`runner` (`{input, placeholder, ask}` to show the Run box) and `approve` (`false` hides
+the approve and deny buttons; the embedded app has no approvals API, so answer approvals
+where your app asks for them).
+
+Anyone who can reach the mounted app can read the runs, and with a runner can start one.
+Keep it on localhost or behind your app's login. `POST /api/replay/run` only accepts
+`Content-Type: application/json`, so another website cannot start a run from a visitor's
+browser.
+
+## What you see
+
+| Part | What it shows |
+|---|---|
+| **Runs** | Recorded runs, newest first. A run that is still being written has a **Live** badge. |
+| **Timeline** (default) | One lane per agent, plus **Manager** and **You**. Time runs left to right. LLM calls and tool calls are blocks in their agent's lane. Arrows show hand-offs, delegation, routing and approval requests. Parallel branches get their own sub-lanes. A call or step repeated back to back is one block marked ×N. Tasks and steps run across the top. |
+| **Map** | The team or flow as a graph, drawn from the graph recorded at the start of the run and fitted to the page (−, Fit and + zoom; drag to pan). Agents that took part but are not in the graph, for example after a hand-off to an agent outside the team, appear in an **Outside the team** group with their hand-offs. Older recordings without a graph get a "who talked to whom" map built from the events. Each node shows its state at the cursor: dashed means not reached, blue means running, green means done (×N when it ran more than once) and red means failed; the node the cursor is on has a bold outline. |
+| **What happened** | One plain sentence per step, for example *"Researcher asked web_search for 'solar sail facts' — 1.2 s, $0.002."* Hovering or focusing a sentence highlights its block, and the other way round. |
+| **Details** | Three tabs for the selected step. **What happened**: when, who, how long, cost, tokens, output. **Why**: only what the recording holds, such as the input given to a tool, the context passed in a hand-off and its reason, the manager's task snapshot, the route a step chose, and an approval's decision and where an automatic approval came from. **Raw JSON**: the events themselves. |
+| **Cost & latency** | Adds a bar under each block (taller and darker means more cost, or more time) and per-agent totals in the lane labels. |
+
+Shapes always carry meaning as well as colour: agents are circles, tools are rounded
+rectangles, you are a diamond and the manager is a square. In each lane, LLM calls sit on
+the top row and that agent's tool calls on a thinner row under them, so a long LLM call
+never hides its tools. Labels that do not fit end in "…"; hover or focus a block to see the
+whole label.
+
+The **Theme** menu follows your system's light or dark setting by default; choose Light or
+Dark to override it. On a phone the run list, timeline and steps stack in one column.
+
+## Moving through a run
+
+Replay opens at the end of the run, so you see everything. Move the cursor to replay it:
+anything after the cursor is drawn as an outline.
+
+| Key | Action |
+|---|---|
+| ← → | Previous / next step |
+| ↑ ↓ | Previous / next step in the step list; previous / next node in the map |
+| Home / End | First / last step |
+| Enter or Space | Open the focused block or node |
+| ← → in the tabs | Switch between What happened, Why and Raw JSON |
+
+The scrubber under the timeline does the same with a mouse or touch, and **▶ Play** steps
+through on its own. On a live run the
+cursor follows new events; if you step back, **Jump to live** takes you to the latest.
+
+## Approving from Replay
+
+When an agent asks for approval and the run uses aiui's approval store, a **Waiting for
+you** card appears above the timeline:
+
+- **Approve** or **Deny**, with an optional reason.
+- **Edit arguments…** opens the arguments as JSON (taken from the server, not the redacted
+  recording when the server has them). The JSON must be an object; mistakes are shown
+  as you type. **Approve with these arguments** sends them as `modified_args`.
+
+These buttons call `POST /api/approvals/{id}/approve` and `/deny`. The agent waits until
+you answer, and is denied if nobody answers before the approval timeout.
+
+## Sharing a run as one file
+
+`praisonai replay export RUN --format html` writes a single HTML file with the run and
+this viewer inside. It needs no server and no network. Approvals cannot be answered from
+an exported file.
+
+## HTTP API
+
+| Endpoint | Returns |
+|---|---|
+| `GET /api/replay/runs` | `[{run_id, session_id, path, started_at, ended_at?, status, kind, name, agents, events, cost_usd, live}]`, newest first |
+| `GET /api/replay/runs/{id}/events?after_seq=N` | `{events, graph, run}`; `after_seq` keeps only events with a larger `sequence_num`; `wait=1` answers `{events: [], graph: null, run: null}` instead of 404 for a run that has not started yet |
+| `GET /api/replay/runs/{id}/stream` | Server-sent events: `event: ctx` per trace event (with `id:` = `sequence_num`), `ping` every 15 s, `end` once the run has finished and gone quiet for 2 s. Honours `after_seq` and `Last-Event-ID`. |
+
+With a runner (`create_replay_app(run=...)`), `POST /api/replay/run` with
+`{"input": "..."}` starts a run and returns `{run_id}` (409 while one is going).
+
+Run ids must match `^[A-Za-z0-9._-]+$`. Replay never writes trace files itself. Half-written last lines, unknown fields and unknown event types are skipped
+safely, and schema 1.0 recordings still open.
+
+The **Traces** page reads the same files: each run is a trace, and its spans come from
+matching start and end events.

docs/frontend/BEAUTIFULUI_UPSTREAM.md

@@ -0,0 +1,35 @@
+# BeautifulUI upstream pin record
+
+BeautifulUI is vendored (shadcn-style registry copy), **not** an npm dependency.
+This file is the single source of truth for what upstream revision is vendored.
+Update it in the **same PR** that adds or bumps any vendored component, and make
+sure the frontend CI gate (issue #295) passes.
+
+See [beautifului-adapter-architecture.md](./beautifului-adapter-architecture.md)
+for the adapter boundary and folder layout.
+
+## Pin
+
+| Field | Value |
+|-------|-------|
+| Upstream repo | _TBD — record on first vendor_ |
+| Git SHA | _TBD_ |
+| Vendored on (date) | _TBD_ |
+| Registry base URL | _TBD_ |
+| License | MIT (kept in-tree) |
+
+## Vendored components
+
+Record one row per component the first time it is copied in.
+
+| Component | Registry URL | SHA | Vendored path | Date |
+|-----------|--------------|-----|---------------|------|
+| _(none yet)_ | | | | |
+
+## Upgrade checklist
+
+1. Update the SHA / date / registry rows above.
+2. Re-copy changed components into `src/frontend/src/agent-ui/vendors/beautifului/`.
+3. Keep all upstream imports inside `src/agent-ui/` (adapter boundary rule).
+4. Run the frontend build + adapter unit tests (frontend CI gate, #295).
+5. Do **not** add a `beautiful-ui` entry to `package.json` dependencies.

docs/frontend/beautifului-adapter-architecture.md

@@ -0,0 +1,102 @@
+# ADR: BeautifulUI adapter layer & upstream pin policy
+
+**Status:** Accepted · **Issue:** [#294](https://github.com/MervinPraison/PraisonAIUI/issues/294)
+
+## Context
+
+BeautifulUI is **not** a semver npm library — it is distributed as shadcn-style
+registry components that are copied into the consuming repo. PraisonAIUI must
+integrate it without leaking upstream types or import paths across the codebase,
+and without breaking when either side updates.
+
+## Decision
+
+Introduce a single **adapter boundary** between transport payloads and the UI,
+and vendor BeautifulUI components behind that boundary.
+
+```
+Agent APIs (Python) ──► event bus / WS messages
+                              │
+                              ▼
+                    Agent-UI adapter (src/agent-ui/adapter.ts)
+                    (stable PraisonAIUI contracts)
+                              │
+                              ▼
+              @praisonaiui/react re-exports
+              (BeautifulUI vendored components)
+                              │
+                              ▼
+         Dashboard / chat mount points (React islands, then full shell)
+```
+
+### 1. Folder layout
+
+```
+src/frontend/src/agent-ui/
+├── contracts.ts        # Stable PraisonAIUI view models (the ONLY types consumers import)
+├── adapter.ts          # Pure mappers: wire payload -> contracts
+├── adapter.test.ts     # Unit tests (mock events -> props), node:test
+├── index.ts            # Barrel: contracts + adapters + (later) vendored re-exports
+└── vendors/
+    └── beautifului/    # Vendored BeautifulUI components (added during migration)
+```
+
+**Rule:** BeautifulUI / upstream prop types must **never** be imported outside
+`src/agent-ui/`. Consumers depend on `contracts.ts` only, so the vendored
+implementation can be swapped later without touching call sites.
+
+### 2. Adapter contracts
+
+Internal, transport-agnostic types live in `contracts.ts`:
+
+- `AgentStreamEvent` — normalized form of the WebSocket frames handled in
+  `chat.js` (`run_started`, `run_content`, `tool_call_started`, …). Unknown
+  frame `type`s degrade to `kind: 'unknown'` with `rawType` preserved instead
+  of throwing, so new upstream events never break the UI.
+- `ToolCallChipModel` — tool-call chip view model.
+- `ApprovalPromptModel` — approval card view model, mapped from the
+  `/api/approvals/pending` REST payload.
+
+Mappers (`adapter.ts`): `mapChatEventToUi(frame)` and
+`mapApprovalToCardProps(item)`. Both are **pure** and unit tested.
+
+### 3. Vendoring & pin policy
+
+| Mechanism | Purpose |
+|-----------|---------|
+| [`BEAUTIFULUI_UPSTREAM.md`](./BEAUTIFULUI_UPSTREAM.md) | Record git SHA, date, registry base URL for every vendored component |
+| shadcn registry URLs | Per-component install, pinned in the upstream doc |
+| **No** `dependencies.beautiful-ui` in `package.json` | Avoid a phantom npm package |
+
+**Upgrade rule:** bump upstream **only** via a PR that updates
+`BEAUTIFULUI_UPSTREAM.md` and passes the frontend CI gate (issue #295). Icons
+stay on `lucide-react`; do not vendor paid Central icons.
+
+### 4. Feature flag (default **off**)
+
+Integration is gated so the existing vanilla-JS chat/approvals plugins remain
+the fallback until migration milestones (#296, #297) complete.
+
+- **Flag:** `AIUI_BEAUTIFULUI` (build-time env / dashboard config JSON).
+- **Default:** off — vanilla JS renders; the adapter is imported but not mounted.
+- **On:** React islands mount using `src/agent-ui` contracts.
+- **Fallback:** if a vendored component fails to load, the flag is treated as
+  off and the vanilla path renders. No user-facing regression when off.
+
+### 5. Design tokens
+
+Scope agent-UI primitives under an `.aiui-agent-ui { … }` CSS layer (or extend
+the existing shadcn presets in `themes.py`) so vendored component tokens cannot
+collide with the global dashboard theme.
+
+### 6. Deprecation / upstream abandonment
+
+Vendored code stays MIT-licensed in-tree. Because consumers depend only on the
+`contracts.ts` view models, a future first-party implementation can satisfy the
+same contracts and replace the vendored components with no call-site churn.
+
+## Consequences
+
+- One place (`src/agent-ui/`) owns the upstream coupling.
+- Adapters are testable without a browser or the transport layer.
+- The default-off flag keeps the migration reversible at every step.

docs/frontend/beautifului.md

@@ -0,0 +1,107 @@
+# BeautifulUI Upgrade Playbook
+
+How PraisonAIUI vendors [BeautifulUI](https://www.beautifului.dev/) React primitives so
+upgrades are **repeatable** and licence obligations are **explicit**.
+
+!!! info "Related planning"
+    Epic [#292](https://github.com/MervinPraison/PraisonAIUI/issues/292) (integration
+    strategy) and the adapter/pin policy in
+    [#294](https://github.com/MervinPraison/PraisonAIUI/issues/294).
+
+## 1. What BeautifulUI is
+
+BeautifulUI (MIT, © Shane Levine / Turbo) is a library of React primitives aimed at
+**AI-native interfaces** — thinking traces, streaming answers with inline sources,
+human-in-the-loop approval cards, tool chips, task rows, context chunks, and a reference
+chat harness.
+
+**It is a shadcn registry + copy-paste library — not an npm package.** There is no
+published `beautiful-ui` package. You install components by resolving a registry URL, and
+the source is copied into your tree (like any other shadcn/ui primitive).
+
+- Website & registry: <https://www.beautifului.dev/>
+- Upstream source: <https://github.com/slev12397/beautiful-ui>
+
+Upstream stack (Next.js 15 · React 19 · Tailwind CSS v4 · TypeScript) is closely aligned
+with PraisonAIUI's `src/frontend` (Vite · React 19 · Tailwind v4 · shadcn/Radix), which is
+why copy-paste vendoring works without a framework shim.
+
+## 2. One-time foundation setup
+
+PraisonAIUI already carries the shadcn/ui foundation that BeautifulUI primitives depend on:
+
+- **shadcn config** — `src/frontend/components.json` (`style: new-york`,
+  `baseColor: neutral`, `iconLibrary: lucide`, `cssVariables: true`). Its `registries`
+  map is where pinned BeautifulUI registry URLs are added (see §3).
+- **Theme tokens** — `src/praisonaiui/themes.py` generates the shadcn CSS variables
+  (`--background`, `--foreground`, `--primary`, `--radius`, …) at build time for all 22
+  official presets, offline. BeautifulUI's foundation CSS (upstream `app/globals.css`)
+  must only contribute **new** tokens/utilities; it must **not** redefine variables that
+  `themes.py` already owns, or theme switching and dark mode break.
+
+**Rule:** when merging upstream `app/globals.css`, diff it against the variables emitted by
+`themes.py` and keep only the additive slices (new keyframes, component-scoped utilities).
+Record what was merged in the pin doc (§3).
+
+## 3. Adding or updating a primitive
+
+1. **Install with a pinned registry URL** from `src/frontend/`:
+   ```bash
+   npx shadcn add https://www.beautifului.dev/r/<component>.json
+   ```
+   The registry resolves dependencies and CSS slices. Commit the resulting
+   `package-lock.json` change in the same PR.
+2. **Re-export through the adapter** — add the component to
+   `src/frontend/src/components/index.ts` (`@praisonaiui/react`). Consumers never import
+   the raw vendored path (see §4).
+3. **Update the pin record** — create/update `docs/frontend/BEAUTIFULUI_UPSTREAM.md` with:
+   the upstream **git SHA**, the **date**, the **registry base URL**, and the **component
+   list** vendored so far. This file is the single source of truth for "what version are
+   we on". (It is created the first time a real primitive is vendored — do not add it
+   empty.)
+4. **Rebuild & sync the bundle** — the committed frontend bundle must be regenerated:
+   ```bash
+   cd src/frontend && npm run build
+   # then sync dist/{index.html,assets/,icon.svg} → src/praisonaiui/templates/frontend/
+   ```
+   (See `AGENTS.md` → "Frontend Build".)
+5. **Run frontend CI** — `.github/workflows/ci.yml` (ruff + pytest) must pass, plus the
+   frontend build step.
+
+## 4. Adapter boundary
+
+Consumers import from **`@praisonaiui/react` only** — never from raw vendored paths such as
+`@/components/ui/...` or any upstream module.
+
+```tsx
+// ✅ stable PraisonAIUI contract
+import { Button, ThemeToggle } from '@praisonaiui/react'
+
+// ❌ leaks upstream/shadcn paths across the codebase
+import { Button } from '@/components/ui/button'
+```
+
+This keeps the upstream surface behind one file (`components/index.ts`), so a BeautifulUI
+bump changes vendored source but not consumer imports.
+
+## 5. Rollback
+
+- BeautifulUI-backed views mount behind a **feature flag**; the **vanilla dashboard views**
+  (`src/praisonaiui/templates/frontend/plugins/*`) remain the fallback and are kept working.
+- To roll back a bad bump: revert the vendoring PR (source + `BEAUTIFULUI_UPSTREAM.md` +
+  rebuilt bundle move together in one commit), and disable the flag. No consumer import
+  changes are needed because everything routes through the adapter (§4).
+
+## 6. Licence
+
+BeautifulUI is **MIT, © Shane Levine**. The full licence text is retained in
+[`THIRD_PARTY_NOTICES.md`](https://github.com/MervinPraison/PraisonAIUI/blob/main/THIRD_PARTY_NOTICES.md)
+at the repository root. Any PR that vendors or bumps BeautifulUI source must keep that
+notice present and current.
+
+## 7. Commercial icons — do not vendor
+
+Do **not** use `@central-icons-react` without a licence — it is commercial. PraisonAIUI
+standardises on **`lucide-react`** (`iconLibrary: lucide` in `components.json`). If an
+upstream BeautifulUI primitive imports commercial icons, swap them for lucide equivalents
+during vendoring.

examples/python/meeting-agent/.env.example

@@ -1,12 +1,34 @@
 # Meeting Agent example — copy to .env and fill in. Never commit real secrets.
 
-# Used by the PraisonAI agent (PAI-MEET-CORE) for summarization/embeddings.
+# Used by the PraisonAI agent for summarization/embeddings.
 OPENAI_API_KEY=
 
 # Optional: enable Slack summary delivery via the built-in SlackChannelAdapter.
-# Leave blank to run dashboard-only (no Slack required).
 SLACK_BOT_TOKEN=
 SLACK_APP_TOKEN=
 
 # Local dev server port for `python app.py`.
 MEETING_AGENT_PORT=8000
+
+# ── Recall.ai (EU workspace: Praison) ───────────────────────────────────────
+# Region must match dashboard: eu-central-1 (Frankfurt).
+RECALL_REGION=eu-central-1
+# Optional: your Recall workspace ID (shown in the config-status API only; the
+# API key already scopes requests to a workspace).
+RECALL_WORKSPACE_ID=
+
+# REST API key from Recall dashboard (Developers → API Keys). Server-side only.
+RECALL_API_KEY=
+
+# Workspace verification secret (whsec_…) from Recall MCP or dashboard.
+RECALL_WEBHOOK_VERIFICATION_SECRET=
+
+# Stable public HTTPS backend URL (reserved ngrok domain in dev). Required for
+# webhooks and Google Calendar V2 OAuth callback forwarding.
+PUBLIC_API_BASE_URL=
+
+# Bot display name in meetings.
+RECALL_BOT_NAME=Praison Meeting Agent
+
+# Calendar V2: when true (default), eligible future events with video links get bots.
+CALENDAR_AUTO_RECORD=true

examples/python/meeting-agent/README.md

@@ -1,49 +1,115 @@
-# Meeting Agent (thin UI example)
+# Meeting Agent (Phase 1 upload + Phase 2 Recall.ai live bots)
 
-A lightweight PraisonAIUI example that wires **existing** features together via
-YAML/config to build a meeting assistant dashboard. It adds no agent-runtime
-logic and no agent-callable tools.
+A PraisonAIUI example that wires the dashboard to **PraisonAI-Tools** meeting
+tools for upload → transcribe → summarize → index → search, plus **Recall.ai**
+Meeting Bots for live Zoom / Meet / Teams capture.
 
 ## What this example includes
 
 | Page | Built from |
 |------|-----------|
-| Upload | `attachments` feature (`POST /api/chat/attachments`) + status copy |
-| Meetings | dashboard page (`aiui.table` / `aiui.metric`) |
-| Meeting detail | tabbed dashboard page — Transcript / Summary / Action items |
-| Chat | `@aiui.reply` with a system prompt enforcing *search meetings first* + citation chips |
+| Upload | `POST /api/meetings/upload` (audio → Phase 1 pipeline) |
+| Live bot | `POST /api/recall/bots` — send a Recall bot to a meeting URL |
+| Meetings | dashboard table backed by `list_meetings` |
+| Meeting detail | transcript / summary / action items + live status |
+| Calendar | Calendar V2 setup instructions + status API |
+| Chat | meeting agent with `search_meetings` + optional `schedule_recall_bot` tool |
 
-Slack delivery (`/meeting-summary <id>`) uses the existing
-`SlackChannelAdapter` and is **optional** — the dashboard runs without any Slack
-tokens (dashboard-only mode). `slack_sdk` is imported lazily, only when tokens
-are present.
+## Recall.ai workspace
+
+This integration targets your Recall workspace in **EU (Frankfurt)** by default:
+
+- Workspace ID: set `RECALL_WORKSPACE_ID` to your own (optional — the API key
+  already scopes requests to a workspace)
+- API region: `eu-central-1`
+
+Follow the [Recall onboarding guide](https://docs.recall.ai/docs/agent-quickstarts) via Recall MCP (`recall://guides/onboarding`) for credential and webhook setup.
 
 ## Run
 
 ```bash
-cp .env.example .env   # optional; dashboard works without any tokens
+cp .env.example .env   # set OPENAI_API_KEY + Recall vars (server-side only)
+pip install praisonai-tools[meeting] httpx
 aiui run app.py
 # or
 python app.py          # honours MEETING_AGENT_PORT
+python app.py --smoke  # non-binding Recall boundary smoke
 ```
 
-## Where the rest lives (routed out)
+## Schedule a live bot
 
-This repo intentionally hosts only the thin UI slice. The agent and tools live
-in separate repositories:
+```bash
+curl -X POST http://127.0.0.1:8000/api/recall/bots \
+  -H "Content-Type: application/json" \
+  -d '{"meeting_url":"https://zoom.us/j/123456789","title":"Standup"}'
+```
 
-- **Agent core** (`build_agent`, instructions, summarization pipeline, storage,
-  status state machine) → `MervinPraison/PraisonAI` (**PAI-MEET-CORE**).
-- **Tools** (`search_meetings`, transcription, indexing, etc.) →
-  `MervinPraison/PraisonAI-Tools` (**PAI-MEET-TOOLS**).
+Flow: **Create Bot** → webhooks (`bot.*`, `recording.done`, `transcript.done`) →
+async Recall transcription → Phase 1 summarize + index → dashboard `ready`.
 
-Point this UI at your running agent via the standard PraisonAI provider/jobs
-configuration; no changes to `praisonaiui` internals are required.
+## Webhooks (required)
+
+Set `PUBLIC_API_BASE_URL` to a stable **HTTPS** backend URL (reserved ngrok
+domain in dev — not localhost). Register in Recall:
+
+- URL: `{PUBLIC_API_BASE_URL}/webhooks/recall`
+- Events: `bot.joining_call`, `bot.in_call_recording`, `bot.done`, `bot.fatal`,
+  `recording.done`, `transcript.done`, `transcript.failed`, `transcript.data`
+- Calendar (Part B): `calendar.sync_events`, `calendar.update` on the same URL
+
+Use Recall MCP `create_webhook_endpoint` or the dashboard. Verify with
+`send_test_webhook_endpoint`.
+
+## Google Calendar V2
+
+Default **CALENDAR_AUTO_RECORD=true** schedules bots for eligible future events
+with video links once Calendar V2 is connected.
+
+1. Set `PUBLIC_API_BASE_URL` (HTTPS tunnel).
+2. Run Recall MCP `start_calendar_integration_setup` with
+   `production_redirect_uri={PUBLIC_API_BASE_URL}/api/recall/calendar/callback`.
+3. Bootstrap the app: `POST /api/recall/calendar/setup/bootstrap` with
+   `setup_id` and `regional_callback_uri` from MCP.
+4. Complete Google OAuth per `recall://guides/calendar-v2-setup-google`.
+
+**Recording opt-in:** calendar sync ≠ automatic recording for every meeting;
+this app uses `CALENDAR_AUTO_RECORD` (default on). Set `false` to disable
+auto-schedule while keeping calendar connected.
 
 ## Environment
 
 See `.env.example`:
 
-- `OPENAI_API_KEY` — used by the agent (PAI-MEET-CORE).
-- `SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN` — optional Slack delivery.
-- `MEETING_AGENT_PORT` — local dev port.
+| Variable | Purpose |
+|----------|---------|
+| `OPENAI_API_KEY` | Summaries, embeddings, chat |
+| `RECALL_REGION` | `eu-central-1` |
+| `RECALL_API_KEY` | Recall REST API (backend only) |
+| `RECALL_WEBHOOK_VERIFICATION_SECRET` | Webhook signature verification |
+| `PUBLIC_API_BASE_URL` | Public HTTPS origin for webhooks + calendar callback |
+| `CALENDAR_AUTO_RECORD` | Auto-schedule bots from calendar (default `true`) |
+
+Never commit real secrets. Reuse the existing REST key (`Mervin Praison`) when
+its purpose is clear; otherwise create a purpose-named key via Recall MCP.
+
+## Phase 2 Part B — live transcript + calendar auto-schedule
+
+| Feature | API |
+|---------|-----|
+| Live transcript (SSE) | `GET /api/meetings/{id}/live-transcript` (`Accept: text/event-stream`) |
+| Live transcript (poll) | Same URL, default JSON |
+| Upcoming calendar events | `GET /api/recall/calendar/upcoming?hours=24` |
+| Manual calendar sync | `POST /api/recall/calendar/sync` `{"calendar_id":"..."}` |
+| Agent tool | `get_upcoming_meetings(hours=24)` in chat when Recall is configured |
+
+Every new bot schedule **automatically** attaches `recording_config.realtime_endpoints`
+pointing at `{PUBLIC_API_BASE_URL}/webhooks/recall` with `transcript.data` — no Recall
+dashboard toggle for live transcript. Requires `PUBLIC_API_BASE_URL` in `.env`.
+
+## Tests
+
+From repo root:
+
+```bash
+pytest tests/unit/test_meeting_agent_example.py tests/unit/test_meeting_agent_pipeline.py tests/unit/test_meeting_agent_recall.py tests/unit/test_meeting_agent_part_b.py -v
+```

examples/python/meeting-agent/app.py

@@ -1,32 +1,75 @@
-"""Meeting Agent — thin PraisonAIUI example (PAI-MEET-UI, issue #260).
+"""Meeting Agent — PraisonAIUI example with Phase 1 upload pipeline + Recall.ai live bots.
 
-Composes existing PraisonAIUI features via YAML/config only:
+Composes existing PraisonAIUI features plus PraisonAI-Tools meeting tools:
 
-  - Upload page          → reuses the ``attachments`` feature (POST /api/chat/attachments)
-  - Meetings list        → dashboard page built from ``aiui.ui`` helpers
-  - Meeting detail       → tabbed dashboard page (Transcript / Summary / Action items)
-  - Chat                 → system prompt enforces "search meetings first" + citation chips
-  - Slack delivery       → optional, via the existing SlackChannelAdapter (lazy slack_sdk)
-
-This example adds NO agent-runtime logic and NO agent-callable tools. Those live in
-external repositories:
-
-  - Agent core → MervinPraison/PraisonAI          (PAI-MEET-CORE)
-  - Tools      → MervinPraison/PraisonAI-Tools    (PAI-MEET-TOOLS)
-
-The dashboard runs without any Slack tokens (dashboard-only mode). Heavy deps
-(openai, slack_sdk, chromadb) are never imported eagerly here.
+  - Upload API          → POST /api/meetings/upload (transcribe → summarize → index)
+  - Live bot API        → POST /api/recall/bots (Recall Meeting Bot join)
+  - Recall webhooks     → POST /webhooks/recall (verified, async processing)
+  - Calendar callback   → GET /api/recall/calendar/callback (Calendar V2 OAuth)
+  - Meetings list       → dashboard page backed by ``list_meetings``
+  - Meeting detail      → latest stored meeting (transcript / summary / actions)
+  - Chat                → PraisonAI Agent with ``search_meetings`` + meeting tools
+  - Slack delivery      → optional via SlackChannelAdapter
 
 Run:
     aiui run app.py
+    python app.py
+    python smoke_recall.py   # non-binding integration smoke
 """
 
 from __future__ import annotations
 
+import asyncio
 import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
 
 import praisonaiui as aiui
 from praisonaiui.server import create_app
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+_EXAMPLE_DIR = Path(__file__).resolve().parent
+if str(_EXAMPLE_DIR) not in sys.path:
+    sys.path.insert(0, str(_EXAMPLE_DIR))
+
+
+def _load_local_env() -> None:
+    """Load ``.env`` from the example dir when vars are not already set."""
+    env_path = _EXAMPLE_DIR / ".env"
+    if not env_path.is_file():
+        return
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+_load_local_env()
+
+aiui.set_custom_js(_EXAMPLE_DIR / "plugin.js")
+
+from pipeline import retry_pipeline, run_ingest_pipeline
+from recall_routes import (
+    api_meeting_live_transcript,
+    api_recall_bot_status,
+    api_recall_calendar_bootstrap,
+    api_recall_calendar_callback,
+    api_recall_calendar_status,
+    api_recall_calendar_sync,
+    api_recall_calendar_upcoming,
+    api_recall_cancel_bot,
+    api_recall_config_status,
+    api_recall_schedule_bot,
+    webhook_recall,
+)
 
 CHAT_SYSTEM_PROMPT = (
     "You are a meeting assistant. For any question about past meetings, decisions, "
@@ -36,6 +79,7 @@ CHAT_SYSTEM_PROMPT = (
     "title linked to its detail page."
 )
 
+# Fallback demo rows for Slack block-shape tests and offline dashboard preview.
 SAMPLE_MEETINGS: list[dict] = [
     {
         "id": "m-1001",
@@ -50,25 +94,215 @@ SAMPLE_MEETINGS: list[dict] = [
             {"task": "Audit billing retries", "owner": "Bob", "due": "2026-07-10"},
         ],
     },
-    {
-        "id": "m-1002",
-        "title": "Billing Reliability Review",
-        "date": "2026-07-09",
-        "status": "Summarizing",
-        "duration": "32m",
-        "transcript": "Bob: Retry storms caused duplicate charges...\nCara: We need idempotency keys.",
-        "summary": "Root-caused duplicate charges to missing idempotency keys; fix scheduled.",
-        "actions": [
-            {"task": "Add idempotency keys", "owner": "Cara", "due": "2026-07-16"},
-        ],
-    },
 ]
 
+_agent: Any | None = None
+
+
+def _recall_schedule_tool():
+    from praisonai_tools.tools.decorator import tool
+
+    from meeting_integrations.recall.service import schedule_recall_bot as _schedule
+
+    @tool
+    def schedule_recall_bot(meeting_url: str, title: str = "") -> dict:
+        """Schedule a Recall.ai bot to join a meeting URL (Zoom, Meet, Teams)."""
+        return _schedule(meeting_url, title)
+
+    return schedule_recall_bot
+
+
+def _upcoming_meetings_tool():
+    from praisonai_tools.tools.decorator import tool
+
+    from meeting_integrations.recall.calendar_service import list_upcoming_calendar_meetings
+
+    @tool
+    def get_upcoming_meetings(hours: int = 24) -> list[dict]:
+        """List upcoming calendar events with video links and bot schedule status."""
+        return list_upcoming_calendar_meetings(hours=hours)
+
+    return get_upcoming_meetings
+
+
+def _load_meeting_tools():
+    """Lazy-load meeting tools (keeps import-time deps light)."""
+    from praisonai_tools.tools.meeting_tools import (
+        extract_action_items,
+        get_meeting,
+        index_meeting,
+        list_meetings,
+        save_meeting,
+        search_meetings,
+        summarize_transcript,
+        transcribe_file,
+    )
+
+    tools = [
+        transcribe_file,
+        save_meeting,
+        get_meeting,
+        list_meetings,
+        summarize_transcript,
+        extract_action_items,
+        index_meeting,
+        search_meetings,
+    ]
+    if os.getenv("RECALL_API_KEY"):
+        tools.append(_recall_schedule_tool())
+        tools.append(_upcoming_meetings_tool())
+    return tools
+
+
+def get_agent():
+    """Return the meeting agent (created lazily on first chat)."""
+    global _agent
+    if _agent is not None:
+        return _agent
+    try:
+        from praisonaiagents import Agent
+    except ImportError as exc:
+        raise ImportError(
+            "praisonaiagents required. Install with: pip install praisonai"
+        ) from exc
+
+    _agent = Agent(
+        name="Meeting Assistant",
+        instructions=CHAT_SYSTEM_PROMPT,
+        model="gpt-4o-mini",
+        tools=_load_meeting_tools(),
+    )
+    # Default loop guard kills chat after 120s while search_meetings runs.
+    from praisonaiagents.escalation.loop_guard import LoopGuard, LoopGuardConfig
+
+    max_turn_sec = float(os.getenv("MEETING_AGENT_LOOP_GUARD_MAX_SEC", "600"))
+    _agent._loop_guard = LoopGuard(
+        LoopGuardConfig(enabled=True, max_time_per_turn=max_turn_sec)
+    )
+    return _agent
+
+
+def _sync_stale_recall_status(record: dict[str, Any]) -> dict[str, Any]:
+    """Refresh Recall bot status for meetings still marked joining/scheduled."""
+    meta = record.get("metadata") or {}
+    live = (meta.get("live_status") or "").lower()
+    bot_id = meta.get("recall_bot_id")
+    if not bot_id or live in ("ready", "failed", "cancelled", "processing"):
+        return record
+    if live not in ("joining", "scheduled", "waiting_room", "live", "ended", ""):
+        return record
+    if not os.getenv("RECALL_API_KEY"):
+        return record
+    try:
+        from meeting_integrations.recall.client import RecallClient
+        from meeting_integrations.recall.config import load_recall_settings
+        from pipeline import merge_meeting_metadata
+
+        bot = RecallClient(load_recall_settings()).get_bot(str(bot_id))
+        changes = bot.get("status_changes") or []
+        status = (changes[-1].get("code") if changes else bot.get("status") or "").lower()
+        meeting_id = record.get("meeting_id", "")
+        patch: dict[str, Any] = {}
+        if status == "in_waiting_room":
+            patch = {
+                "live_status": "waiting_room",
+                "status": "Scheduled",
+                "error": (
+                    "Bot is in the Google Meet waiting room — admit "
+                    "'Praison Meeting Agent' to start recording."
+                ),
+            }
+        elif status in ("done", "call_ended") and not (bot.get("recordings") or []):
+            patch = {
+                "live_status": "failed",
+                "status": "failed",
+                "error": "Meeting ended but bot never recorded (likely not admitted from waiting room).",
+            }
+        elif status == "done" and (bot.get("recordings") or []):
+            patch = {"live_status": "processing"}
+        if patch and meeting_id:
+            merge_meeting_metadata(meeting_id, patch)
+            meta = {**meta, **patch}
+            record = {**record, "metadata": meta}
+    except Exception:
+        pass
+    return record
+
+
+def _record_to_view(record: dict[str, Any]) -> dict[str, Any]:
+    """Normalise a tool meeting record for dashboard rendering."""
+    meta = record.get("metadata") or {}
+    actions = meta.get("action_items") or []
+    return {
+        "id": record.get("meeting_id", ""),
+        "title": record.get("title", "Untitled"),
+        "date": (record.get("created_at") or "")[:10],
+        "status": meta.get("status", "Ready").replace("ready", "Ready").title(),
+        "live_status": meta.get("live_status") or "",
+        "recall_bot_id": meta.get("recall_bot_id") or "",
+        "meeting_url": meta.get("meeting_url") or record.get("source") or "",
+        "duration": _format_duration(meta.get("duration_seconds")),
+        "transcript": meta.get("transcript") or "",
+        "summary": meta.get("summary") or "",
+        "error": meta.get("error") or "",
+        "actions": [
+            {
+                "task": a.get("description", ""),
+                "owner": a.get("owner") or "—",
+                "due": a.get("due_date") or "—",
+            }
+            for a in actions
+            if isinstance(a, dict)
+        ],
+    }
+
+
+def _format_duration(seconds: Any) -> str:
+    if not seconds:
+        return "—"
+    try:
+        total = int(float(seconds))
+    except (TypeError, ValueError):
+        return "—"
+    minutes, secs = divmod(total, 60)
+    return f"{minutes}m {secs}s" if minutes else f"{secs}s"
+
+
+def _list_meeting_views() -> list[dict[str, Any]]:
+    try:
+        from praisonai_tools.tools.meeting_tools import list_meetings
+
+        rows = list_meetings.__wrapped__(limit=50, offset=0)
+        if rows and isinstance(rows[0], dict) and "error" in rows[0]:
+            return SAMPLE_MEETINGS
+        rows = [_sync_stale_recall_status(r) for r in rows]
+        views = [_record_to_view(r) for r in rows]
+        return views or SAMPLE_MEETINGS
+    except ImportError:
+        return SAMPLE_MEETINGS
+
 
 def _meeting(meeting_id: str) -> dict | None:
+    try:
+        from praisonai_tools.tools.meeting_tools import get_meeting
+
+        record = get_meeting.__wrapped__(meeting_id)
+        if "error" not in record:
+            return _record_to_view(record)
+    except ImportError:
+        pass
     return next((m for m in SAMPLE_MEETINGS if m["id"] == meeting_id), None)
 
 
+def _pick_detail_meeting(meetings: list[dict[str, Any]]) -> dict[str, Any]:
+    """Prefer an in-progress live meeting for the detail view."""
+    for live in ("live", "joining", "waiting_room"):
+        for m in meetings:
+            if (m.get("live_status") or "").lower() == live:
+                return m
+    return meetings[0] if meetings else SAMPLE_MEETINGS[0]
+
+
 def _status_variant(status: str) -> str:
     return {
         "Ready": "default",
@@ -77,16 +311,94 @@ def _status_variant(status: str) -> str:
         "Transcribing": "secondary",
         "Uploading": "secondary",
         "Error": "destructive",
+        "Failed": "destructive",
+        "Scheduled": "secondary",
+        "Live": "default",
+        "Processing": "secondary",
     }.get(status, "outline")
 
 
 aiui.set_style("dashboard")
 aiui.set_branding(title="Meeting Agent", logo="🗓️")
-aiui.set_pages(["upload", "meetings", "meeting-detail", "chat"])
+aiui.set_pages(
+    ["upload", "live-bot", "meetings", "meeting-detail", "calendar", "chat"]
+)
 aiui.set_dashboard(sidebar=True, page_header=True)
 aiui.set_chat_features(file_upload=True, feedback=True)
 
 
+async def _emit_pipeline_chat_result(result: dict[str, Any]) -> None:
+    """Surface pipeline progress/errors via standard chat status events."""
+    if result.get("status") == "ready":
+        await aiui.say(
+            f"✅ **{result.get('title', 'Meeting')}** is ready. "
+            f"Indexed {result.get('chunks_indexed', 0)} chunk(s)."
+        )
+        return
+    if "error" in result:
+        await aiui.say(f"❌ {result['error']}")
+        meeting_id = result.get("meeting_id")
+        if meeting_id:
+            await aiui.action_buttons(
+                [
+                    {
+                        "name": "retry-meeting",
+                        "label": "Retry",
+                        "payload": {"meeting_id": meeting_id},
+                    }
+                ]
+            )
+        return
+    await aiui.say(str(result))
+
+
+async def _chat_run_pipeline(fn, *args: Any) -> None:
+    await aiui.think("Running meeting pipeline...")
+    result = await asyncio.to_thread(fn, *args)
+    await _emit_pipeline_chat_result(result)
+
+
+@aiui.reply
+async def on_message(message: str):
+    """Chat: Q&A via meeting agent; retry failed uploads via chat commands."""
+    text = str(message).strip()
+    lower = text.lower()
+
+    if lower.startswith("retry meeting "):
+        meeting_id = text.split(maxsplit=2)[-1].strip()
+        await _chat_run_pipeline(retry_pipeline, meeting_id)
+        return
+    if lower.startswith("/retry "):
+        meeting_id = text.split(maxsplit=1)[-1].strip()
+        await _chat_run_pipeline(retry_pipeline, meeting_id)
+        return
+
+    if not os.getenv("OPENAI_API_KEY"):
+        await aiui.say("Set `OPENAI_API_KEY` to chat with the meeting assistant.")
+        return
+
+    await aiui.think("Searching meetings before answering...")
+    agent = get_agent()
+    response = await asyncio.to_thread(agent.chat, text)
+    await aiui.say(str(response))
+
+
+def _register_retry_action() -> None:
+    from praisonaiui.actions import register_action_callback
+
+    async def _on_retry_meeting(action) -> None:
+        meeting_id = (action.payload or {}).get("meeting_id", "")
+        if not meeting_id:
+            await aiui.say("Missing meeting id for retry.")
+            return
+        await _chat_run_pipeline(retry_pipeline, meeting_id)
+
+    register_action_callback("retry-meeting", _on_retry_meeting)
+
+
+_register_retry_action()
+
+
 @aiui.page("upload", title="Upload", icon="⬆️", group="Meetings", order=1)
 async def upload_page():
     steps = ["Uploading", "Transcribing", "Summarizing", "Indexing", "Ready"]
@@ -94,71 +406,178 @@ async def upload_page():
         [
             aiui.text("Drop an audio or transcript file to add a meeting."),
             aiui.alert(
-                "Files are uploaded via the built-in attachments feature "
-                "(POST /api/chat/attachments). Transcription, summarization and "
-                "indexing run in the PraisonAI agent (PAI-MEET-CORE).",
+                "POST a multipart file to /api/meetings/upload with field ``file`` "
+                "(optional ``title``). Supported: mp3, mp4, wav, webm, m4a, ogg.",
                 variant="info",
-                title="How it works",
+                title="Upload API",
             ),
-            aiui.card(
-                "Processing pipeline",
-                footer=" → ".join(steps),
+            aiui.code_block(
+                'curl -F "[email protected]" -F "title=Weekly standup" '
+                "http://127.0.0.1:8000/api/meetings/upload",
+                language="bash",
             ),
+            aiui.card("Processing pipeline", footer=" → ".join(steps)),
             aiui.text(
                 "On error the pipeline surfaces a retry action via the standard "
-                "chat status events; no bespoke state machine lives in the UI."
+                "chat status events; no bespoke state machine lives in the UI. "
+                "In Chat, send ``retry meeting <id>`` or click **Retry** when offered."
             ),
         ]
     )
 
 
-@aiui.page("meetings", title="Meetings", icon="📋", group="Meetings", order=2)
+@aiui.page("live-bot", title="Live bot", icon="🤖", group="Meetings", order=2)
+async def live_bot_page():
+    port = os.environ.get("MEETING_AGENT_PORT", "8000")
+    return aiui.layout(
+        [
+            aiui.text(
+                "Send a Recall.ai Meeting Bot to a Zoom, Google Meet, or Teams URL. "
+                "Real-time ``transcript.data`` chunks stream during the call; when the "
+                "call ends, the Phase 1 summarize + index pipeline runs on the full transcript."
+            ),
+            aiui.alert(
+                "Requires RECALL_API_KEY, RECALL_WEBHOOK_VERIFICATION_SECRET, and "
+                "PUBLIC_API_BASE_URL (HTTPS tunnel). Register ``transcript.data`` on the "
+                "same /webhooks/recall endpoint for live captions.",
+                variant="info",
+                title="Recall credentials",
+            ),
+            aiui.code_block(
+                'curl -X POST http://127.0.0.1:'
+                f"{port}/api/recall/bots "
+                '-H "Content-Type: application/json" '
+                '-d \'{"meeting_url":"https://zoom.us/j/123456789","title":"Standup"}\'',
+                language="bash",
+            ),
+            aiui.text(
+                "Live transcript SSE: ``GET /api/meetings/{meeting_id}/live-transcript`` "
+                "with ``Accept: text/event-stream``. Poll fallback: same URL without SSE."
+            ),
+        ]
+    )
+
+
+@aiui.page("calendar", title="Calendar", icon="📅", group="Meetings", order=5)
+async def calendar_page():
+    upcoming: list[dict[str, Any]] = []
+    status_note = "Set RECALL_API_KEY to load calendar status."
+    if os.getenv("RECALL_API_KEY"):
+        try:
+            from meeting_integrations.recall.calendar_service import list_upcoming_calendar_meetings
+
+            upcoming = list_upcoming_calendar_meetings(hours=48)
+            status_note = f"{len(upcoming)} upcoming event(s) with video links (48h window)."
+        except Exception as exc:  # noqa: BLE001
+            status_note = f"Calendar API unavailable: {exc}"
+
+    rows = [
+        [
+            e.get("title", "—"),
+            str(e.get("start", ""))[:16],
+            e.get("platform") or "—",
+            "Yes" if e.get("bot_scheduled") else "No",
+        ]
+        for e in upcoming[:10]
+    ]
+    return aiui.layout(
+        [
+            aiui.text(
+                "Google Calendar V2 auto-schedules Recall bots for eligible future "
+                "events with video links when CALENDAR_AUTO_RECORD=true (default)."
+            ),
+            aiui.alert(status_note, variant="info", title="Calendar status"),
+            aiui.table(
+                headers=["Title", "Start", "Platform", "Bot scheduled"],
+                rows=rows or [["—", "—", "—", "—"]],
+            ),
+            aiui.alert(
+                "Complete Calendar V2 setup via Recall MCP, bootstrap OAuth callback, "
+                "then register calendar webhooks (calendar.sync_events, calendar.update) "
+                "on /webhooks/recall.",
+                variant="info",
+                title="Setup",
+            ),
+            aiui.code_block(
+                "GET /api/recall/calendar/status\n"
+                "GET /api/recall/calendar/upcoming?hours=24\n"
+                "POST /api/recall/calendar/sync {\"calendar_id\":\"...\"}",
+                language="bash",
+            ),
+        ]
+    )
+
+
+@aiui.page("meetings", title="Meetings", icon="📋", group="Meetings", order=3)
 async def meetings_page():
+    meetings = _list_meeting_views()
     rows = [
         [
             m["title"],
             m["date"],
             m["status"],
-            str(len(m["actions"])),
+            m.get("live_status") or "—",
+            m["id"],
             m["duration"],
         ]
-        for m in SAMPLE_MEETINGS
+        for m in meetings
     ]
     return aiui.layout(
         [
-            aiui.metric("Meetings", value=len(SAMPLE_MEETINGS)),
+            aiui.metric("Meetings", value=len(meetings)),
             aiui.table(
-                headers=["Title", "Date", "Status", "Actions", "Duration"],
+                headers=["Title", "Date", "Status", "Live", "ID", "Duration"],
                 rows=rows,
             ),
         ]
     )
 
 
-@aiui.page("meeting-detail", title="Meeting detail", icon="📝", group="Meetings", order=3)
+@aiui.page("meeting-detail", title="Meeting detail", icon="📝", group="Meetings", order=4)
 async def meeting_detail_page():
-    meeting = SAMPLE_MEETINGS[0]
+    meetings = _list_meeting_views()
+    meeting = _pick_detail_meeting(meetings)
     action_rows = [[a["task"], a["owner"], a["due"]] for a in meeting["actions"]]
+    live = (meeting.get("live_status") or "").lower()
+    header: list[Any] = [
+        aiui.text(meeting["title"]),
+        aiui.badge(meeting["status"], variant=_status_variant(meeting["status"])),
+        aiui.text(f"ID: {meeting['id']}"),
+    ]
+    if live:
+        variant = "default" if live == "live" else "outline"
+        header.append(aiui.badge(live.title(), variant=variant))
+    body: list[Any] = []
+    if meeting.get("error"):
+        body.append(aiui.alert(meeting["error"], variant="warning"))
+    if live == "live":
+        body.append(
+            aiui.alert(
+                "Live transcript auto-refreshes every 3 seconds on this page.",
+                variant="info",
+                title="Live",
+            )
+        )
     return aiui.layout(
-        [
-            aiui.text(meeting["title"]),
-            aiui.badge(meeting["status"], variant=_status_variant(meeting["status"])),
+        header
+        + body
+        + [
             aiui.tabs(
                 [
                     {
                         "label": "Transcript",
-                        "children": [aiui.code_block(meeting["transcript"], language="text")],
+                        "children": [aiui.code_block(meeting["transcript"] or "(empty)", language="text")],
                     },
                     {
                         "label": "Summary",
-                        "children": [aiui.text(meeting["summary"])],
+                        "children": [aiui.text(meeting["summary"] or "(not summarised yet)")],
                     },
                     {
                         "label": "Action items",
                         "children": [
                             aiui.table(
                                 headers=["Task", "Owner", "Due"],
-                                rows=action_rows,
+                                rows=action_rows or [["—", "—", "—"]],
                             )
                         ],
                     },
@@ -168,29 +587,6 @@ async def meeting_detail_page():
     )
 
 
-@aiui.reply
-async def on_message(message: str):
-    await aiui.think("Searching meetings before answering...")
-    hits = [
-        m
-        for m in SAMPLE_MEETINGS
-        if message.lower() in (m["title"] + " " + m["summary"]).lower()
-    ]
-    if not hits:
-        hits = SAMPLE_MEETINGS
-    top = hits[0]
-    await aiui.say(top["summary"])
-    await aiui.action_buttons(
-        [
-            {
-                "name": f"open:{m['id']}",
-                "label": f"📎 {m['title']}",
-            }
-            for m in hits
-        ]
-    )
-
-
 def _slack_adapter():
     """Construct a Slack adapter only when tokens are configured (lazy slack_sdk)."""
     bot = os.environ.get("SLACK_BOT_TOKEN", "")
@@ -205,7 +601,7 @@ def _slack_adapter():
 def _summary_blocks(meeting: dict) -> list[dict]:
     action_lines = "\n".join(
         f"• {a['task']} — {a['owner']} (due {a['due']})" for a in meeting["actions"]
-    )
+    ) or "• (none)"
     return [
         {"type": "header", "text": {"type": "plain_text", "text": meeting["title"]}},
         {"type": "section", "text": {"type": "mrkdwn", "text": f"*Date:* {meeting['date']}"}},
@@ -219,10 +615,7 @@ def _summary_blocks(meeting: dict) -> list[dict]:
 
 
 async def post_meeting_summary(meeting_id: str, channel_id: str) -> bool:
-    """Deliver a meeting summary to Slack (/meeting-summary <id>).
-
-    Returns False when Slack is not configured — the dashboard still works.
-    """
+    """Deliver a meeting summary to Slack (/meeting-summary <id>)."""
     meeting = _meeting(meeting_id)
     if meeting is None:
         return False
@@ -241,10 +634,98 @@ async def post_meeting_summary(meeting_id: str, channel_id: str) -> bool:
     return True
 
 
+async def api_meetings_upload(request: Request) -> JSONResponse:
+    """Accept multipart upload and run the ingest pipeline."""
+    form = await request.form()
+    upload = form.get("file")
+    title = str(form.get("title") or "").strip() or None
+    if upload is None or not getattr(upload, "filename", None):
+        return JSONResponse({"error": "file field is required"}, status_code=400)
+
+    suffix = Path(upload.filename).suffix.lower() or ".bin"
+    from pipeline import AUDIO_SUFFIXES
+
+    if suffix not in AUDIO_SUFFIXES:
+        return JSONResponse(
+            {"error": f"Unsupported file type: {suffix}. Allowed: {sorted(AUDIO_SUFFIXES)}"},
+            status_code=400,
+        )
+
+    data = await upload.read()
+    if not data:
+        return JSONResponse({"error": "empty file"}, status_code=400)
+
+    uploads_dir = Path(tempfile.gettempdir()) / "praisonai_meeting_uploads"
+    uploads_dir.mkdir(parents=True, exist_ok=True)
+    dest = uploads_dir / f"{os.urandom(8).hex()}{suffix}"
+    dest.write_bytes(data)
+
+    result = await asyncio.to_thread(run_ingest_pipeline, str(dest), title)
+    if "error" in result and result.get("meeting_id"):
+        result["retry_hint"] = f"retry meeting {result['meeting_id']}"
+        result["retry_url"] = f"/api/meetings/{result['meeting_id']}/retry"
+    status = 200 if result.get("status") == "ready" else 400 if "error" in result else 500
+    return JSONResponse(result, status_code=status)
+
+
+async def api_meeting_retry(request: Request) -> JSONResponse:
+    meeting_id = request.path_params["meeting_id"]
+    result = await asyncio.to_thread(retry_pipeline, meeting_id)
+    if "error" in result and result.get("meeting_id"):
+        result["retry_hint"] = f"retry meeting {result['meeting_id']}"
+    status = 200 if result.get("status") == "ready" else 400 if "error" in result else 500
+    return JSONResponse(result, status_code=status)
+
+
+async def api_meetings_list(_request: Request) -> JSONResponse:
+    return JSONResponse({"meetings": _list_meeting_views()})
+
+
+async def api_meeting_detail(request: Request) -> JSONResponse:
+    meeting_id = request.path_params["meeting_id"]
+    meeting = _meeting(meeting_id)
+    if meeting is None:
+        return JSONResponse({"error": "not found"}, status_code=404)
+    return JSONResponse(meeting)
+
+
 app = create_app()
+_meeting_routes = [
+        Route("/api/meetings/upload", api_meetings_upload, methods=["POST"]),
+        Route("/api/meetings/{meeting_id}/retry", api_meeting_retry, methods=["POST"]),
+        Route("/api/meetings", api_meetings_list, methods=["GET"]),
+        Route("/api/meetings/{meeting_id}", api_meeting_detail, methods=["GET"]),
+        Route("/api/recall/bots", api_recall_schedule_bot, methods=["POST"]),
+        Route("/api/recall/bots/{meeting_id}", api_recall_bot_status, methods=["GET"]),
+        Route("/api/recall/bots/{meeting_id}/cancel", api_recall_cancel_bot, methods=["POST"]),
+        Route("/api/recall/config", api_recall_config_status, methods=["GET"]),
+        Route("/webhooks/recall", webhook_recall, methods=["POST"]),
+        Route("/api/recall/calendar/callback", api_recall_calendar_callback, methods=["GET"]),
+        Route(
+            "/api/recall/calendar/setup/bootstrap",
+            api_recall_calendar_bootstrap,
+            methods=["POST"],
+        ),
+        Route("/api/recall/calendar/status", api_recall_calendar_status, methods=["GET"]),
+        Route("/api/recall/calendar/upcoming", api_recall_calendar_upcoming, methods=["GET"]),
+        Route("/api/recall/calendar/sync", api_recall_calendar_sync, methods=["POST"]),
+        Route(
+            "/api/meetings/{meeting_id}/live-transcript",
+            api_meeting_live_transcript,
+            methods=["GET"],
+        ),
+    ]
+# Prepend so custom /api/* routes win over the SPA catch-all from create_app().
+app.routes[0:0] = _meeting_routes
 
 
 if __name__ == "__main__":
+    if "--smoke" in sys.argv:
+        from smoke_recall import run_smoke
+
+        run_smoke()
+        raise SystemExit(0)
+
     import uvicorn
 
     host = os.environ.get("HOST", "127.0.0.1")

examples/python/meeting-agent/meeting_integrations/__init__.py

@@ -0,0 +1 @@
+"""Meeting-agent integrations (Recall.ai, etc.)."""

examples/python/meeting-agent/meeting_integrations/recall/__init__.py

@@ -0,0 +1,13 @@
+"""Recall.ai Meeting Bot integration for the meeting-agent example."""
+
+from meeting_integrations.recall.client import RecallClient
+from meeting_integrations.recall.config import RecallSettings, load_recall_settings
+from meeting_integrations.recall.verify import VerificationError, verify_request_from_recall
+
+__all__ = [
+    "RecallClient",
+    "RecallSettings",
+    "VerificationError",
+    "load_recall_settings",
+    "verify_request_from_recall",
+]

examples/python/meeting-agent/meeting_integrations/recall/calendar.py

@@ -0,0 +1,33 @@
+"""Calendar V2 OAuth callback forwarding for Recall-hosted setup."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+from urllib.parse import urlencode
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+FORWARD_PARAMS = ("state", "code", "error", "recall_calendar_setup_probe")
+
+
+def forward_calendar_callback(
+    *,
+    regional_callback_uri: str,
+    query_params: dict[str, str],
+) -> tuple[int, str]:
+    """Forward allowed query params to Recall's regional callback URI."""
+    filtered = {k: v for k, v in query_params.items() if k in FORWARD_PARAMS and v}
+    if not filtered.get("state") and "recall_calendar_setup_probe" not in filtered:
+        return 400, "missing state"
+
+    url = regional_callback_uri
+    if filtered:
+        url = f"{url}?{urlencode(filtered)}"
+
+    logger.info("Forwarding calendar callback to Recall (state redacted)")
+    with httpx.Client(timeout=30.0, follow_redirects=True) as client:
+        response = client.get(url)
+    return response.status_code, response.text[:500]

examples/python/meeting-agent/meeting_integrations/recall/calendar_service.py

@@ -0,0 +1,261 @@
+"""Google Calendar V2 sync and auto-schedule via Recall Calendar API."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from meeting_integrations.recall.client import RecallAPIError, RecallClient
+from meeting_integrations.recall.config import RecallSettings
+from meeting_integrations.recall.store import RecallStore
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_iso(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    try:
+        normalized = value.replace("Z", "+00:00")
+        if normalized.endswith("+0000"):
+            normalized = normalized[:-5] + "+00:00"
+        return datetime.fromisoformat(normalized)
+    except ValueError:
+        return None
+
+
+def _event_title(event: dict[str, Any]) -> str:
+    raw = event.get("raw") or {}
+    if isinstance(raw, dict):
+        summary = raw.get("summary") or raw.get("subject")
+        if summary:
+            return str(summary)
+    return "Calendar meeting"
+
+
+def _deduplication_key(event: dict[str, Any]) -> str:
+    start = str(event.get("start_time") or "")
+    url = str(event.get("meeting_url") or "")
+    return f"{start}-{url}"
+
+
+def is_eligible_for_auto_record(event: dict[str, Any]) -> bool:
+    """Return True when Recall should schedule a bot for this calendar event."""
+    if event.get("is_deleted"):
+        return False
+    if not event.get("meeting_url"):
+        return False
+    end = _parse_iso(str(event.get("end_time") or ""))
+    if end and end < datetime.now(timezone.utc):
+        return False
+    raw = event.get("raw") or {}
+    if isinstance(raw, dict):
+        status = str(raw.get("status") or "").lower()
+        if status == "cancelled":
+            return False
+    return True
+
+
+def list_upcoming_calendar_meetings(
+    *,
+    hours: int = 24,
+    settings: RecallSettings | None = None,
+    client: RecallClient | None = None,
+) -> list[dict[str, Any]]:
+    """List upcoming Recall calendar events with video links (for UI + agent tool)."""
+    from meeting_integrations.recall.config import load_recall_settings
+
+    settings = settings or load_recall_settings()
+    client = client or RecallClient(settings)
+
+    try:
+        events = client.list_calendar_events(is_deleted=False)
+    except RecallAPIError as exc:
+        logger.warning("Calendar events unavailable: %s", exc)
+        return []
+
+    now = datetime.now(timezone.utc)
+    horizon = now + timedelta(hours=max(1, hours))
+
+    rows: list[dict[str, Any]] = []
+    for event in events:
+        if not is_eligible_for_auto_record(event):
+            continue
+        start = _parse_iso(str(event.get("start_time") or ""))
+        if start and start > horizon:
+            continue
+        bots = event.get("bots") or []
+        rows.append(
+            {
+                "event_id": event.get("id"),
+                "title": _event_title(event),
+                "start": event.get("start_time"),
+                "end": event.get("end_time"),
+                "platform": (event.get("meeting_platform") or {}).get("name")
+                if isinstance(event.get("meeting_platform"), dict)
+                else event.get("meeting_platform"),
+                "meeting_url": event.get("meeting_url"),
+                "bot_scheduled": bool(bots),
+                "calendar_id": event.get("calendar_id"),
+            }
+        )
+
+    rows.sort(key=lambda r: str(r.get("start") or ""))
+    return rows
+
+
+def _ensure_local_meeting_for_event(
+    event: dict[str, Any],
+    *,
+    settings: RecallSettings,
+) -> str:
+    """Create or reuse a local meeting row for a calendar event."""
+    event_id = str(event.get("id") or "")
+    if RecallStore.is_event_scheduled(event_id):
+        row = RecallStore.get_scheduled_bot(event_id)
+        if row and row.get("meeting_id"):
+            return str(row["meeting_id"])
+
+    from praisonai_tools.tools.meeting_tools import save_meeting
+
+    title = _event_title(event)
+    url = str(event.get("meeting_url") or "")
+    saved = save_meeting.__wrapped__(
+        title=title,
+        source=url,
+        metadata={
+            "status": "scheduled",
+            "live_status": "scheduled",
+            "meeting_url": url,
+            "source": "calendar",
+            "recall_calendar_event_id": event_id,
+        },
+    )
+    if "error" in saved:
+        raise RecallAPIError(0, saved["error"])
+    return str(saved["meeting_id"])
+
+
+def sync_calendar_events(
+    calendar_id: str,
+    *,
+    updated_since: str | None = None,
+    settings: RecallSettings,
+    client: RecallClient | None = None,
+    auto_record: bool | None = None,
+) -> dict[str, Any]:
+    """Fetch changed calendar events and schedule/remove bots per policy."""
+    client = client or RecallClient(settings)
+    should_record = (
+        settings.calendar_auto_record if auto_record is None else auto_record
+    )
+
+    events = client.list_calendar_events(
+        calendar_id=calendar_id,
+        updated_at_gte=updated_since,
+    )
+
+    scheduled = 0
+    removed = 0
+    skipped = 0
+    errors: list[str] = []
+
+    for event in events:
+        event_id = str(event.get("id") or "")
+        if not event_id:
+            continue
+
+        eligible = is_eligible_for_auto_record(event) and should_record
+        has_bots = bool(event.get("bots"))
+
+        if not eligible:
+            if has_bots and (event.get("is_deleted") or not should_record):
+                try:
+                    client.remove_bot_from_calendar_event(event_id)
+                    removed += 1
+                except RecallAPIError as exc:
+                    errors.append(f"{event_id}: remove failed: {exc.detail}")
+            else:
+                skipped += 1
+            continue
+
+        if RecallStore.is_event_scheduled(event_id) and has_bots:
+            skipped += 1
+            continue
+
+        try:
+            meeting_id = _ensure_local_meeting_for_event(event, settings=settings)
+            bot_config = client.build_bot_config(
+                meeting_id=meeting_id,
+                title=_event_title(event),
+            )
+            updated = client.schedule_bot_for_calendar_event(
+                event_id,
+                deduplication_key=_deduplication_key(event),
+                bot_config=bot_config,
+            )
+            bot_id = None
+            bots = updated.get("bots") or []
+            if bots and isinstance(bots[0], dict):
+                bot_id = bots[0].get("bot_id") or bots[0].get("id")
+            RecallStore.record_scheduled_bot(event_id, meeting_id, bot_id)
+            from pipeline import merge_meeting_metadata
+
+            merge_meeting_metadata(
+                meeting_id,
+                {
+                    "recall_calendar_event_id": event_id,
+                    "recall_bot_id": bot_id,
+                    "status": "scheduled",
+                    "live_status": "scheduled",
+                },
+            )
+            scheduled += 1
+        except RecallAPIError as exc:
+            logger.warning("Calendar schedule failed for %s: %s", event_id, exc.detail)
+            errors.append(f"{event_id}: {exc.detail}")
+
+    return {
+        "calendar_id": calendar_id,
+        "fetched": len(events),
+        "scheduled": scheduled,
+        "removed": removed,
+        "skipped": skipped,
+        "errors": errors,
+    }
+
+
+def process_calendar_webhook(
+    event_type: str,
+    payload: dict[str, Any],
+    *,
+    settings: RecallSettings,
+    client: RecallClient | None = None,
+) -> None:
+    """Handle Recall Calendar V2 webhooks (calendar.update, calendar.sync_events)."""
+    data = payload.get("data") or {}
+    if not isinstance(data, dict):
+        return
+
+    calendar_id = str(data.get("calendar_id") or "")
+    if not calendar_id:
+        logger.warning("Calendar webhook %s missing calendar_id", event_type)
+        return
+
+    if event_type == "calendar.update":
+        logger.info("Calendar %s updated — refresh status in UI", calendar_id)
+        return
+
+    if event_type == "calendar.sync_events":
+        updated_since = str(data.get("last_updated_ts") or "") or None
+        result = sync_calendar_events(
+            calendar_id,
+            updated_since=updated_since,
+            settings=settings,
+            client=client,
+        )
+        logger.info("Calendar sync %s: %s", calendar_id, result)
+        return
+
+    logger.debug("Ignoring calendar webhook event %s", event_type)

examples/python/meeting-agent/meeting_integrations/recall/client.py

@@ -0,0 +1,290 @@
+"""Minimal Recall.ai REST client (EU region, v1.11)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import random
+import time
+from typing import Any
+
+import httpx
+
+from meeting_integrations.recall.config import RecallSettings
+
+logger = logging.getLogger(__name__)
+
+
+class RecallAPIError(RuntimeError):
+    """Recall API returned a non-success response."""
+
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(detail)
+        self.status_code = status_code
+        self.detail = detail
+
+
+class RecallClient:
+    """HTTP client for Recall Meeting Bots and async transcription."""
+
+    def __init__(self, settings: RecallSettings):
+        self._settings = settings
+        self._base = settings.api_base.rstrip("/")
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Authorization": self._settings.api_key,
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: dict[str, Any] | None = None,
+        max_attempts: int = 4,
+    ) -> dict[str, Any]:
+        url = f"{self._base}{path}"
+        last_error: Exception | None = None
+        for attempt in range(max_attempts):
+            try:
+                with httpx.Client(timeout=30.0) as client:
+                    response = client.request(
+                        method,
+                        url,
+                        headers=self._headers(),
+                        json=json_body,
+                    )
+            except httpx.HTTPError as exc:
+                last_error = exc
+                if attempt + 1 >= max_attempts:
+                    raise RecallAPIError(0, str(exc)) from exc
+                time.sleep(min(2**attempt + random.random(), 8))
+                continue
+
+            if response.status_code == 429:
+                retry_after = response.headers.get("Retry-After")
+                delay = float(retry_after) if retry_after else min(2**attempt, 30)
+                time.sleep(delay + random.random())
+                continue
+
+            if response.status_code in {503, 507} and attempt + 1 < max_attempts:
+                time.sleep(min(2**attempt + random.random(), 8))
+                continue
+
+            if response.status_code >= 400:
+                detail = response.text[:500] or response.reason_phrase
+                raise RecallAPIError(response.status_code, detail)
+
+            if not response.content:
+                return {}
+            return response.json()
+
+        raise RecallAPIError(0, str(last_error or "request failed"))
+
+    def create_bot(
+        self,
+        *,
+        meeting_url: str,
+        meeting_id: str,
+        title: str,
+        join_at: str | None = None,
+        enable_realtime_transcription: bool = True,
+    ) -> dict[str, Any]:
+        """Schedule a Recall bot; attach local meeting_id in metadata for webhook routing."""
+        body: dict[str, Any] = {
+            "meeting_url": meeting_url,
+            "bot_name": self._settings.bot_name,
+            "metadata": {"meeting_id": meeting_id, "title": title},
+        }
+        if join_at:
+            body["join_at"] = join_at
+        if enable_realtime_transcription:
+            recording_config = self._settings.realtime_recording_config()
+            if recording_config:
+                body["recording_config"] = recording_config
+                logger.info(
+                    "Live transcript enabled for meeting_id=%s → %s",
+                    meeting_id,
+                    self._settings.webhook_url,
+                )
+            else:
+                logger.warning(
+                    "Live transcript skipped for meeting_id=%s — set PUBLIC_API_BASE_URL",
+                    meeting_id,
+                )
+        logger.info(
+            "Creating Recall bot for meeting_id=%s (url redacted)",
+            meeting_id,
+        )
+        return self._request("POST", "/api/v1/bot/", json_body=body)
+
+    def build_bot_config(
+        self,
+        *,
+        meeting_id: str,
+        title: str,
+        enable_realtime_transcription: bool = True,
+    ) -> dict[str, Any]:
+        """Bot config payload for Calendar V2 schedule-bot requests."""
+        config: dict[str, Any] = {
+            "bot_name": self._settings.bot_name,
+            "metadata": {"meeting_id": meeting_id, "title": title},
+        }
+        if enable_realtime_transcription:
+            recording_config = self._settings.realtime_recording_config()
+            if recording_config:
+                config["recording_config"] = recording_config
+        return config
+
+    def get_bot(self, bot_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/bot/{bot_id}/")
+
+    def cancel_bot(self, bot_id: str) -> dict[str, Any]:
+        return self._request("POST", f"/api/v1/bot/{bot_id}/leave_call/")
+
+    def create_async_transcript(self, recording_id: str) -> dict[str, Any]:
+        body = {
+            "provider": {"recallai_async": {"language_code": "auto"}},
+            "diarization": {"use_separate_streams_when_available": True},
+        }
+        return self._request(
+            "POST",
+            f"/api/v1/recording/{recording_id}/create_transcript/",
+            json_body=body,
+        )
+
+    def get_transcript(self, transcript_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/transcript/{transcript_id}/")
+
+    @staticmethod
+    def extract_recording_id(payload: dict[str, Any]) -> str | None:
+        data = payload.get("data") or {}
+        if isinstance(data, dict):
+            recording = data.get("recording") or {}
+            if isinstance(recording, dict) and recording.get("id"):
+                return str(recording["id"])
+            inner = data.get("data") or {}
+            if isinstance(inner, dict):
+                rec = inner.get("recording") or {}
+                if isinstance(rec, dict) and rec.get("id"):
+                    return str(rec["id"])
+        return None
+
+    @staticmethod
+    def extract_transcript_id(payload: dict[str, Any]) -> str | None:
+        data = payload.get("data") or {}
+        if isinstance(data, dict):
+            transcript = data.get("transcript") or {}
+            if isinstance(transcript, dict) and transcript.get("id"):
+                return str(transcript["id"])
+        return None
+
+    @staticmethod
+    def extract_bot_id(payload: dict[str, Any]) -> str | None:
+        data = payload.get("data") or {}
+        if isinstance(data, dict):
+            bot = data.get("bot") or {}
+            if isinstance(bot, dict) and bot.get("id"):
+                return str(bot["id"])
+        return None
+
+    @staticmethod
+    def extract_meeting_id_from_bot_metadata(payload: dict[str, Any]) -> str | None:
+        data = payload.get("data") or {}
+        if not isinstance(data, dict):
+            return None
+        bot = data.get("bot") or {}
+        if not isinstance(bot, dict):
+            return None
+        metadata = bot.get("metadata") or {}
+        if isinstance(metadata, dict):
+            mid = metadata.get("meeting_id")
+            return str(mid) if mid else None
+        return None
+
+    @staticmethod
+    def download_json(url: str) -> Any:
+        with httpx.Client(timeout=60.0) as client:
+            response = client.get(url)
+            response.raise_for_status()
+            return response.json()
+
+    def list_calendars(self, *, status: str | None = "connected") -> list[dict[str, Any]]:
+        params: dict[str, str] = {}
+        if status:
+            params["status"] = status
+        results: list[dict[str, Any]] = []
+        cursor: str | None = None
+        while True:
+            query = dict(params)
+            if cursor:
+                query["cursor"] = cursor
+            path = "/api/v2/calendars/"
+            if query:
+                from urllib.parse import urlencode
+
+                path = f"{path}?{urlencode(query)}"
+            page = self._request("GET", path)
+            batch = page.get("results") or []
+            if isinstance(batch, list):
+                results.extend(item for item in batch if isinstance(item, dict))
+            cursor = page.get("next")
+            if not cursor:
+                break
+        return results
+
+    def list_calendar_events(
+        self,
+        *,
+        calendar_id: str | None = None,
+        updated_at_gte: str | None = None,
+        is_deleted: bool | None = False,
+    ) -> list[dict[str, Any]]:
+        from urllib.parse import urlencode
+
+        params: dict[str, str] = {}
+        if calendar_id:
+            params["calendar_id"] = calendar_id
+        if updated_at_gte:
+            params["updated_at__gte"] = updated_at_gte
+        if is_deleted is not None:
+            params["is_deleted"] = "true" if is_deleted else "false"
+
+        results: list[dict[str, Any]] = []
+        cursor: str | None = None
+        while True:
+            query = dict(params)
+            if cursor:
+                query["cursor"] = cursor
+            path = f"/api/v2/calendar-events/?{urlencode(query)}" if query else "/api/v2/calendar-events/"
+            page = self._request("GET", path)
+            batch = page.get("results") or []
+            if isinstance(batch, list):
+                results.extend(item for item in batch if isinstance(item, dict))
+            cursor = page.get("next")
+            if not cursor:
+                break
+        return results
+
+    def schedule_bot_for_calendar_event(
+        self,
+        event_id: str,
+        *,
+        deduplication_key: str,
+        bot_config: dict[str, Any],
+    ) -> dict[str, Any]:
+        body = {
+            "deduplication_key": deduplication_key,
+            "bot_config": bot_config,
+        }
+        return self._request(
+            "POST",
+            f"/api/v2/calendar-events/{event_id}/bot/",
+            json_body=body,
+        )
+
+    def remove_bot_from_calendar_event(self, event_id: str) -> dict[str, Any]:
+        return self._request("DELETE", f"/api/v2/calendar-events/{event_id}/bot/")

examples/python/meeting-agent/meeting_integrations/recall/config.py

@@ -0,0 +1,100 @@
+"""Recall.ai runtime configuration — credentials stay server-side only."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlparse
+
+
+class RecallConfigError(ValueError):
+    """Raised when required Recall settings are missing or invalid."""
+
+
+@dataclass(frozen=True)
+class RecallSettings:
+    """Validated Recall workspace settings injected into the API client."""
+
+    region: str
+    api_key: str
+    webhook_verification_secret: str
+    public_api_base_url: str
+    workspace_id: str
+    bot_name: str
+    calendar_auto_record: bool
+
+    @property
+    def api_base(self) -> str:
+        return f"https://{self.region}.recall.ai"
+
+    @property
+    def webhook_url(self) -> str:
+        return f"{self.public_api_base_url.rstrip('/')}/webhooks/recall"
+
+    @property
+    def calendar_callback_url(self) -> str:
+        return f"{self.public_api_base_url.rstrip('/')}/api/recall/calendar/callback"
+
+    def realtime_recording_config(self) -> dict[str, Any] | None:
+        """Recording config with live ``transcript.data`` webhooks (no dashboard toggle)."""
+        if not self.public_api_base_url:
+            return None
+        return {
+            "transcript": {
+                "provider": {
+                    "recallai_streaming": {
+                        "mode": "prioritize_low_latency",
+                        "language_code": "en",
+                    }
+                },
+                "diarization": {
+                    "use_separate_streams_when_available": True,
+                },
+            },
+            "realtime_endpoints": [
+                {
+                    "type": "webhook",
+                    "url": self.webhook_url,
+                        "events": ["transcript.data", "transcript.partial_data"],
+                }
+            ],
+        }
+
+
+def _require(name: str) -> str:
+    value = os.getenv(name, "").strip()
+    if not value:
+        raise RecallConfigError(f"{name} is required for Recall integration")
+    return value
+
+
+def load_recall_settings(*, require_public_url: bool = False) -> RecallSettings:
+    """Load Recall settings from the process environment."""
+    region = os.getenv("RECALL_REGION", "eu-central-1").strip() or "eu-central-1"
+    public_url = os.getenv("PUBLIC_API_BASE_URL", "").strip()
+    if require_public_url and not public_url:
+        raise RecallConfigError(
+            "PUBLIC_API_BASE_URL is required (stable HTTPS backend URL for webhooks "
+            "and calendar OAuth callback forwarding)"
+        )
+    if public_url:
+        parsed = urlparse(public_url)
+        if parsed.scheme not in {"https", "http"} or not parsed.netloc:
+            raise RecallConfigError("PUBLIC_API_BASE_URL must be an absolute http(s) URL")
+        if parsed.hostname in {"localhost", "127.0.0.1"}:
+            raise RecallConfigError(
+                "PUBLIC_API_BASE_URL must not be localhost; use a reserved tunnel domain"
+            )
+
+    auto_record = os.getenv("CALENDAR_AUTO_RECORD", "true").strip().lower()
+    return RecallSettings(
+        region=region,
+        api_key=_require("RECALL_API_KEY"),
+        webhook_verification_secret=_require("RECALL_WEBHOOK_VERIFICATION_SECRET"),
+        public_api_base_url=public_url,
+        workspace_id=os.getenv("RECALL_WORKSPACE_ID", "").strip(),
+        bot_name=os.getenv("RECALL_BOT_NAME", "Praison Meeting Agent").strip()
+        or "Praison Meeting Agent",
+        calendar_auto_record=auto_record not in {"0", "false", "no", "off"},
+    )

examples/python/meeting-agent/meeting_integrations/recall/live.py

@@ -0,0 +1,83 @@
+"""In-process live transcript fan-out for SSE subscribers."""
+
+from __future__ import annotations
+
+import threading
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class LiveTranscriptState:
+    """Latest live transcript snapshot for a meeting."""
+
+    lines: list[str] = field(default_factory=list)
+    text: str = ""
+    live_status: str = ""
+
+
+_lock = threading.Lock()
+_states: dict[str, LiveTranscriptState] = {}
+_subscribers: dict[str, list[threading.Event]] = defaultdict(list)
+
+
+def get_live_state(meeting_id: str) -> LiveTranscriptState | None:
+    with _lock:
+        return _states.get(meeting_id)
+
+
+def publish_live_chunk(
+    meeting_id: str,
+    *,
+    line: str,
+    full_text: str,
+    live_status: str = "live",
+) -> None:
+    """Record a new utterance and notify SSE waiters."""
+    with _lock:
+        state = _states.setdefault(meeting_id, LiveTranscriptState())
+        if line:
+            state.lines.append(line)
+        state.text = full_text
+        state.live_status = live_status
+        waiters = list(_subscribers.get(meeting_id, []))
+    for event in waiters:
+        event.set()
+
+
+def set_live_status(meeting_id: str, live_status: str) -> None:
+    with _lock:
+        state = _states.setdefault(meeting_id, LiveTranscriptState())
+        state.live_status = live_status
+        waiters = list(_subscribers.get(meeting_id, []))
+    for event in waiters:
+        event.set()
+
+
+def wait_for_update(meeting_id: str, timeout: float = 25.0) -> LiveTranscriptState | None:
+    """Block until the meeting transcript changes or timeout (for SSE long-poll)."""
+    event = threading.Event()
+    with _lock:
+        _subscribers[meeting_id].append(event)
+        state = _states.get(meeting_id)
+    event.wait(timeout=timeout)
+    with _lock:
+        subs = _subscribers.get(meeting_id, [])
+        if event in subs:
+            subs.remove(event)
+        return _states.get(meeting_id)
+
+
+def snapshot_for_api(meeting_id: str, record: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Merge in-memory live state with persisted meeting metadata."""
+    meta = (record or {}).get("metadata") or {}
+    live = get_live_state(meeting_id)
+    text = (live.text if live and live.text else meta.get("transcript")) or ""
+    return {
+        "meeting_id": meeting_id,
+        "live_status": (live.live_status if live and live.live_status else meta.get("live_status"))
+        or "",
+        "transcript": text,
+        "line_count": len([ln for ln in text.splitlines() if ln.strip()]),
+    }

examples/python/meeting-agent/meeting_integrations/recall/processor.py

@@ -0,0 +1,226 @@
+"""Async Recall webhook event processing."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from meeting_integrations.recall.client import RecallAPIError, RecallClient
+from meeting_integrations.recall.config import RecallSettings
+from meeting_integrations.recall.store import RecallStore, webhook_event_key
+from meeting_integrations.recall.transcript import transcript_data_to_line, transcript_download_to_text
+
+logger = logging.getLogger(__name__)
+
+
+def _speaker_prefix(line: str) -> str:
+    if ":" in line:
+        return line.split(":", 1)[0] + ":"
+    return ""
+
+
+def _upsert_live_transcript(meeting_id: str, line: str, *, partial: bool = False) -> str:
+    """Merge one live caption line; partial updates replace the last same-speaker line."""
+    from praisonai_tools.tools.meeting_tools import get_meeting
+    from meeting_integrations.recall.live import publish_live_chunk
+    from pipeline import _metadata_lock
+
+    # Hold the merge lock across the read too: streaming transcript events are
+    # dispatched one-thread-each, so an unsynchronized read-append-write would
+    # let concurrent captions clobber each other and drop lines.
+    with _metadata_lock:
+        record = get_meeting.__wrapped__(meeting_id)
+        meta = record.get("metadata") or {} if isinstance(record, dict) else {}
+        existing = str(meta.get("transcript") or "")
+        lines = existing.splitlines()
+        prefix = _speaker_prefix(line)
+
+        if lines and lines[-1] == line:
+            full = existing
+        elif partial and lines and prefix and lines[-1].startswith(prefix):
+            lines[-1] = line
+            full = "\n".join(lines)
+        elif not partial and lines and prefix and lines[-1].startswith(prefix):
+            # Final utterance replaces the in-progress partial for this speaker.
+            lines[-1] = line
+            full = "\n".join(lines)
+        else:
+            full = f"{existing}\n{line}".strip() if existing else line
+
+        _merge_metadata(
+            meeting_id,
+            {"transcript": full, "live_status": "live", "status": "live"},
+        )
+    publish_live_chunk(meeting_id, line=line, full_text=full, live_status="live")
+    return full
+
+
+def _append_live_transcript(meeting_id: str, line: str) -> str:
+    return _upsert_live_transcript(meeting_id, line, partial=False)
+
+
+def _merge_metadata(meeting_id: str, patch: dict[str, Any]) -> None:
+    from pipeline import merge_meeting_metadata
+
+    merge_meeting_metadata(meeting_id, patch)
+
+
+def _resolve_meeting_id(payload: dict[str, Any], bot_id: str | None) -> str | None:
+    meeting_id = RecallClient.extract_meeting_id_from_bot_metadata(payload)
+    if meeting_id:
+        return meeting_id
+    if not bot_id:
+        return None
+    try:
+        from praisonai_tools.tools.meeting_tools import list_meetings
+
+        rows = list_meetings.__wrapped__(limit=200, offset=0)
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            meta = row.get("metadata") or {}
+            if meta.get("recall_bot_id") == bot_id:
+                return row.get("meeting_id")
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Could not resolve meeting by bot_id: %s", exc)
+    return None
+
+
+def process_recall_webhook(
+    event_type: str,
+    payload: dict[str, Any],
+    *,
+    settings: RecallSettings,
+    client: RecallClient | None = None,
+) -> None:
+    """Handle a verified Recall webhook (runs off the request thread)."""
+    event_key = webhook_event_key(event_type, payload)
+    if not RecallStore.mark_event_processed(event_key, event_type):
+        logger.info("Skipping duplicate Recall event %s", event_type)
+        return
+
+    client = client or RecallClient(settings)
+    bot_id = RecallClient.extract_bot_id(payload)
+    meeting_id = _resolve_meeting_id(payload, bot_id)
+
+    if event_type == "bot.joining_call" and meeting_id:
+        _merge_metadata(meeting_id, {"live_status": "joining", "recall_bot_id": bot_id})
+        return
+
+    if event_type == "bot.in_waiting_room" and meeting_id:
+        _merge_metadata(
+            meeting_id,
+            {
+                "live_status": "waiting_room",
+                "status": "Scheduled",
+                "error": "Bot is in the meeting waiting room — admit 'Praison Meeting Agent' to record.",
+            },
+        )
+        return
+
+    if event_type == "bot.in_call_recording" and meeting_id:
+        _merge_metadata(meeting_id, {"live_status": "live", "status": "live", "error": ""})
+        from meeting_integrations.recall.live import set_live_status
+
+        set_live_status(meeting_id, "live")
+        return
+
+    if event_type == "transcript.data" and meeting_id:
+        line = transcript_data_to_line(payload)
+        if line:
+            _append_live_transcript(meeting_id, line)
+        return
+
+    if event_type == "transcript.partial_data" and meeting_id:
+        line = transcript_data_to_line(payload)
+        if line:
+            _upsert_live_transcript(meeting_id, line, partial=True)
+        return
+
+    if event_type == "bot.call_ended" and meeting_id:
+        _merge_metadata(meeting_id, {"live_status": "ended"})
+        from meeting_integrations.recall.live import set_live_status
+
+        set_live_status(meeting_id, "ended")
+        return
+
+    if event_type == "bot.fatal" and meeting_id:
+        sub = ((payload.get("data") or {}).get("data") or {}).get("sub_code")
+        _merge_metadata(
+            meeting_id,
+            {
+                "live_status": "failed",
+                "status": "failed",
+                "error": f"Recall bot fatal: {sub or 'unknown'}",
+            },
+        )
+        return
+
+    if event_type == "bot.done" and meeting_id:
+        _merge_metadata(meeting_id, {"live_status": "processing"})
+        return
+
+    if event_type == "recording.done":
+        recording_id = RecallClient.extract_recording_id(payload)
+        if not recording_id:
+            logger.warning("recording.done without recording id")
+            return
+        if meeting_id:
+            _merge_metadata(meeting_id, {"recall_recording_id": recording_id})
+            started_at = ((payload.get("data") or {}).get("recording") or {}).get("started_at")
+            completed_at = ((payload.get("data") or {}).get("recording") or {}).get("completed_at")
+            if started_at and completed_at:
+                try:
+                    from datetime import datetime
+
+                    fmt = "%Y-%m-%dT%H:%M:%S.%f%z"
+                    start = datetime.strptime(started_at.replace("Z", "+0000"), fmt)
+                    end = datetime.strptime(completed_at.replace("Z", "+0000"), fmt)
+                    _merge_metadata(
+                        meeting_id,
+                        {"duration_seconds": int((end - start).total_seconds())},
+                    )
+                except (TypeError, ValueError):
+                    pass
+        try:
+            client.create_async_transcript(recording_id)
+            logger.info("Started async transcript for recording %s", recording_id)
+        except RecallAPIError as exc:
+            logger.error("create_async_transcript failed: %s", exc)
+            if meeting_id:
+                _merge_metadata(
+                    meeting_id,
+                    {"status": "failed", "error": f"Transcript start failed: {exc}"},
+                )
+        return
+
+    if event_type == "transcript.failed" and meeting_id:
+        _merge_metadata(
+            meeting_id,
+            {"status": "failed", "error": "Recall transcript generation failed"},
+        )
+        return
+
+    if event_type == "transcript.done":
+        transcript_id = RecallClient.extract_transcript_id(payload)
+        if not transcript_id:
+            logger.warning("transcript.done without transcript id")
+            return
+        if not meeting_id:
+            logger.warning("transcript.done without meeting_id")
+            return
+        try:
+            artifact = client.get_transcript(transcript_id)
+            download_url = (artifact.get("data") or {}).get("download_url")
+            if not download_url:
+                raise RecallAPIError(0, "missing transcript download_url")
+            raw = client.download_json(download_url)
+            text = transcript_download_to_text(raw)
+            if not text.strip():
+                raise RecallAPIError(0, "empty transcript")
+            from pipeline import run_post_transcript_pipeline
+
+            run_post_transcript_pipeline(meeting_id, text)
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("Post-transcript pipeline failed")
+            _merge_metadata(meeting_id, {"status": "failed", "error": str(exc)})

examples/python/meeting-agent/meeting_integrations/recall/service.py

@@ -0,0 +1,138 @@
+"""High-level Recall bot scheduling used by API routes and the agent."""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from meeting_integrations.recall.client import RecallAPIError, RecallClient
+from meeting_integrations.recall.config import RecallConfigError, RecallSettings, load_recall_settings
+
+logger = logging.getLogger(__name__)
+
+_MEETING_URL_RE = re.compile(r"^https?://", re.I)
+
+
+def schedule_recall_bot(
+    meeting_url: str,
+    title: str = "",
+    *,
+    join_at: str | None = None,
+    settings: RecallSettings | None = None,
+    client: RecallClient | None = None,
+) -> dict[str, Any]:
+    """Persist local intent, create the Recall bot, and store the returned bot id."""
+    url = (meeting_url or "").strip()
+    if not _MEETING_URL_RE.match(url):
+        return {"error": "meeting_url must be an http(s) URL"}
+
+    meeting_title = (title or "Live meeting").strip() or "Live meeting"
+
+    try:
+        settings = settings or load_recall_settings()
+    except RecallConfigError as exc:
+        return {"error": str(exc)}
+
+    from praisonai_tools.tools.meeting_tools import save_meeting
+
+    saved = save_meeting.__wrapped__(
+        title=meeting_title,
+        source=url,
+        metadata={
+            "status": "scheduled",
+            "live_status": "scheduled",
+            "meeting_url": url,
+            "source": "recall",
+        },
+    )
+    if "error" in saved:
+        return saved
+
+    meeting_id = saved["meeting_id"]
+    api = client or RecallClient(settings)
+
+    try:
+        bot = api.create_bot(
+            meeting_url=url,
+            meeting_id=meeting_id,
+            title=meeting_title,
+            join_at=join_at,
+        )
+    except RecallAPIError as exc:
+        from pipeline import merge_meeting_metadata
+
+        merge_meeting_metadata(
+            meeting_id,
+            {
+                "status": "failed",
+                "live_status": "failed",
+                "error": f"Recall create bot failed: {exc.detail}",
+            },
+        )
+        return {
+            "meeting_id": meeting_id,
+            "error": f"Recall create bot failed: {exc.detail}",
+        }
+
+    bot_id = bot.get("id")
+    from pipeline import merge_meeting_metadata
+
+    merge_meeting_metadata(
+        meeting_id,
+        {
+            "recall_bot_id": bot_id,
+            "status": "scheduled",
+            "live_status": "scheduled",
+            "meeting_url": url,
+        },
+    )
+
+    realtime = settings.realtime_recording_config() is not None
+    logger.info("Scheduled Recall bot %s for meeting %s", bot_id, meeting_id)
+    return {
+        "meeting_id": meeting_id,
+        "recall_bot_id": bot_id,
+        "status": "scheduled",
+        "live_status": "scheduled",
+        "title": meeting_title,
+        "meeting_url": url,
+        "realtime_transcript_enabled": realtime,
+        "realtime_webhook_url": settings.webhook_url if realtime else None,
+    }
+
+
+def cancel_recall_bot(
+    meeting_id: str,
+    *,
+    settings: RecallSettings | None = None,
+    client: RecallClient | None = None,
+) -> dict[str, Any]:
+    """Cancel a scheduled or in-call Recall bot."""
+    from praisonai_tools.tools.meeting_tools import get_meeting
+    from pipeline import merge_meeting_metadata
+
+    record = get_meeting.__wrapped__(meeting_id)
+    if "error" in record:
+        return record
+
+    bot_id = (record.get("metadata") or {}).get("recall_bot_id")
+    if not bot_id:
+        return {"error": "No Recall bot linked to this meeting", "meeting_id": meeting_id}
+
+    try:
+        settings = settings or load_recall_settings()
+    except RecallConfigError as exc:
+        return {"error": str(exc)}
+
+    api = client or RecallClient(settings)
+    try:
+        api.cancel_bot(str(bot_id))
+    except RecallAPIError as exc:
+        return {"meeting_id": meeting_id, "error": str(exc)}
+
+    merge_meeting_metadata(
+        meeting_id,
+        {"live_status": "cancelled", "status": "cancelled"},
+    )
+    return {"meeting_id": meeting_id, "recall_bot_id": bot_id, "status": "cancelled"}

examples/python/meeting-agent/meeting_integrations/recall/store.py

@@ -0,0 +1,213 @@
+"""Persist Recall webhook idempotency and calendar setup state."""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from contextlib import closing
+from pathlib import Path
+from typing import Any
+
+from meeting_integrations.recall.client import RecallClient
+
+
+def _state_db_path() -> str:
+    env = os.getenv("PRAISONAI_MEETINGS_DIR")
+    base = Path(env) if env else Path.home() / ".praisonai" / "meetings"
+    base.mkdir(parents=True, exist_ok=True)
+    return str(base / "recall_state.db")
+
+
+def _connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(_state_db_path())
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS recall_webhook_events (
+            event_key TEXT PRIMARY KEY,
+            event_type TEXT NOT NULL,
+            processed_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS recall_calendar_setup (
+            setup_id TEXT PRIMARY KEY,
+            platform TEXT NOT NULL,
+            state_json TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS recall_scheduled_bots (
+            event_id TEXT PRIMARY KEY,
+            meeting_id TEXT NOT NULL,
+            bot_id TEXT,
+            scheduled_at TEXT NOT NULL
+        )
+        """
+    )
+    return conn
+
+
+def webhook_event_key(event_type: str, payload: dict[str, Any]) -> str:
+    """Build a stable idempotency key from webhook metadata."""
+    data = payload.get("data") or {}
+
+    # Streaming transcript events fire many times per bot — never dedupe on bot_id alone.
+    if event_type in ("transcript.data", "transcript.partial_data"):
+        inner = data.get("data") if isinstance(data, dict) else {}
+        bot_id = RecallClient.extract_bot_id(payload) or ""
+        if isinstance(inner, dict):
+            words = inner.get("words")
+            if isinstance(words, list) and words:
+                first = words[0] if isinstance(words[0], dict) else {}
+                last = words[-1] if isinstance(words[-1], dict) else {}
+                word_text = " ".join(
+                    w.get("text", "") for w in words if isinstance(w, dict)
+                ).strip()
+                return (
+                    f"{event_type}:{bot_id}:"
+                    f"{first.get('start', first.get('start_time', ''))}:"
+                    f"{last.get('end', last.get('end_time', ''))}:"
+                    f"{word_text}"
+                )
+            text = str(inner.get("text") or "").strip()
+            start = inner.get("start") or inner.get("start_time") or ""
+            end = inner.get("end") or inner.get("end_time") or ""
+            speaker = inner.get("speaker") or inner.get("speaker_name") or ""
+            return f"{event_type}:{bot_id}:{start}:{end}:{speaker}:{text}"
+        return f"{event_type}:{json.dumps(payload, sort_keys=True)}"
+
+    for part in (
+        payload.get("id"),
+        data.get("id") if isinstance(data, dict) else None,
+    ):
+        if part:
+            return f"{event_type}:{part}"
+    bot_id = RecallStore.extract_bot_id(payload)
+    recording_id = RecallStore.extract_recording_id(payload)
+    transcript_id = RecallStore.extract_transcript_id(payload)
+    suffix = bot_id or recording_id or transcript_id or json.dumps(payload, sort_keys=True)
+    return f"{event_type}:{suffix}"
+
+
+class RecallStore:
+    """SQLite-backed Recall integration state."""
+
+    @staticmethod
+    def extract_bot_id(payload: dict[str, Any]) -> str | None:
+        from meeting_integrations.recall.client import RecallClient
+
+        return RecallClient.extract_bot_id(payload)
+
+    @staticmethod
+    def extract_recording_id(payload: dict[str, Any]) -> str | None:
+        from meeting_integrations.recall.client import RecallClient
+
+        return RecallClient.extract_recording_id(payload)
+
+    @staticmethod
+    def extract_transcript_id(payload: dict[str, Any]) -> str | None:
+        from meeting_integrations.recall.client import RecallClient
+
+        return RecallClient.extract_transcript_id(payload)
+
+    @staticmethod
+    def mark_event_processed(event_key: str, event_type: str) -> bool:
+        """Claim an event for processing; return False if already processed.
+
+        Uses an atomic ``INSERT OR IGNORE`` so concurrent duplicate webhook
+        deliveries (Svix retries/fan-out) cannot both pass the check — the
+        second insert is ignored and reports zero changed rows.
+        """
+        from datetime import datetime, timezone
+
+        with closing(_connect()) as conn, conn:
+            cursor = conn.execute(
+                """
+                INSERT OR IGNORE INTO recall_webhook_events
+                    (event_key, event_type, processed_at)
+                VALUES (?, ?, ?)
+                """,
+                (event_key, event_type, datetime.now(timezone.utc).isoformat()),
+            )
+            return cursor.rowcount > 0
+
+    @staticmethod
+    def save_calendar_setup(setup_id: str, platform: str, state: dict[str, Any]) -> None:
+        from datetime import datetime, timezone
+
+        with closing(_connect()) as conn, conn:
+            conn.execute(
+                """
+                INSERT INTO recall_calendar_setup (setup_id, platform, state_json, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(setup_id) DO UPDATE SET
+                    platform = excluded.platform,
+                    state_json = excluded.state_json,
+                    updated_at = excluded.updated_at
+                """,
+                (
+                    setup_id,
+                    platform,
+                    json.dumps(state, sort_keys=True),
+                    datetime.now(timezone.utc).isoformat(),
+                ),
+            )
+
+    @staticmethod
+    def get_calendar_setup(setup_id: str) -> dict[str, Any] | None:
+        with closing(_connect()) as conn:
+            row = conn.execute(
+                "SELECT state_json FROM recall_calendar_setup WHERE setup_id = ?",
+                (setup_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return json.loads(row[0])
+
+    @staticmethod
+    def record_scheduled_bot(event_id: str, meeting_id: str, bot_id: str | None) -> None:
+        from datetime import datetime, timezone
+
+        with closing(_connect()) as conn, conn:
+            conn.execute(
+                """
+                INSERT INTO recall_scheduled_bots (event_id, meeting_id, bot_id, scheduled_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(event_id) DO NOTHING
+                """,
+                (event_id, meeting_id, bot_id, datetime.now(timezone.utc).isoformat()),
+            )
+
+    @staticmethod
+    def is_event_scheduled(event_id: str) -> bool:
+        with closing(_connect()) as conn:
+            row = conn.execute(
+                "SELECT 1 FROM recall_scheduled_bots WHERE event_id = ?",
+                (event_id,),
+            ).fetchone()
+        return row is not None
+
+    @staticmethod
+    def get_scheduled_bot(event_id: str) -> dict[str, Any] | None:
+        with closing(_connect()) as conn:
+            row = conn.execute(
+                """
+                SELECT event_id, meeting_id, bot_id, scheduled_at
+                FROM recall_scheduled_bots WHERE event_id = ?
+                """,
+                (event_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return {
+            "event_id": row[0],
+            "meeting_id": row[1],
+            "bot_id": row[2],
+            "scheduled_at": row[3],
+        }

examples/python/meeting-agent/meeting_integrations/recall/transcript.py

@@ -0,0 +1,62 @@
+"""Convert Recall transcript download payloads to plain text."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def transcript_data_to_line(payload: dict[str, Any]) -> str:
+    """Flatten a verified ``transcript.data`` webhook payload to one line."""
+    data = payload.get("data") or {}
+    if not isinstance(data, dict):
+        return ""
+
+    inner = data.get("data") or data
+    if not isinstance(inner, dict):
+        return ""
+
+    words = inner.get("words")
+    if isinstance(words, list) and words:
+        text = " ".join(
+            w.get("text", "") for w in words if isinstance(w, dict)
+        ).strip()
+    else:
+        text = str(inner.get("text") or "").strip()
+
+    if not text:
+        return ""
+
+    speaker = inner.get("speaker") or inner.get("speaker_name")
+    participant = inner.get("participant")
+    if not speaker and isinstance(participant, dict):
+        speaker = participant.get("name")
+    return f"{speaker}: {text}" if speaker else text
+
+
+def transcript_download_to_text(data: Any) -> str:
+    """Flatten Recall transcript JSON into a readable multi-line string."""
+    if isinstance(data, str):
+        return data.strip()
+    if not isinstance(data, list):
+        return str(data)
+
+    lines: list[str] = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        speaker = item.get("speaker") or item.get("speaker_name")
+        participant = item.get("participant")
+        if not speaker and isinstance(participant, dict):
+            speaker = participant.get("name")
+        words = item.get("words")
+        if isinstance(words, list) and words:
+            text = " ".join(
+                w.get("text", "") for w in words if isinstance(w, dict)
+            ).strip()
+        else:
+            text = str(item.get("text") or "").strip()
+        if not text:
+            continue
+        prefix = f"{speaker}: " if speaker else ""
+        lines.append(f"{prefix}{text}")
+    return "\n".join(lines)

examples/python/meeting-agent/meeting_integrations/recall/verify.py

@@ -0,0 +1,48 @@
+"""Verify incoming Recall webhook and callback requests."""
+
+from __future__ import annotations
+
+import base64
+import hmac
+import hashlib
+
+
+class VerificationError(ValueError):
+    """Signature verification failed."""
+
+
+def verify_request_from_recall(
+    *,
+    secret: str,
+    headers: dict[str, str],
+    payload: str | None,
+) -> None:
+    """Verify Recall/Svix-style webhook signatures on the raw request body."""
+    if not secret or not secret.startswith("whsec_"):
+        raise VerificationError("Verification secret is missing or invalid")
+
+    lowered = {k.lower(): v for k, v in headers.items()}
+    msg_id = lowered.get("webhook-id") or lowered.get("svix-id")
+    msg_timestamp = lowered.get("webhook-timestamp") or lowered.get("svix-timestamp")
+    msg_signature = lowered.get("webhook-signature") or lowered.get("svix-signature")
+
+    if not msg_id or not msg_timestamp or not msg_signature:
+        raise VerificationError("Missing webhook id, timestamp, or signature")
+
+    key = base64.b64decode(secret.removeprefix("whsec_"))
+    payload_str = payload or ""
+    to_sign = f"{msg_id}.{msg_timestamp}.{payload_str}"
+    expected_sig = base64.b64encode(
+        hmac.new(key, to_sign.encode("utf-8"), hashlib.sha256).digest()
+    ).decode("ascii")
+
+    for versioned_sig in msg_signature.split(" "):
+        if "," not in versioned_sig:
+            continue
+        version, signature = versioned_sig.split(",", 1)
+        if version != "v1":
+            continue
+        if hmac.compare_digest(signature, expected_sig):
+            return
+
+    raise VerificationError("No matching signature found")

examples/python/meeting-agent/pipeline.py

@@ -0,0 +1,295 @@
+"""Meeting ingest pipeline — upload → transcribe → summarize → index.
+
+Uses PraisonAI-Tools meeting tools with lazy imports so the UI app stays
+lightweight at import time. Updates meeting metadata in SQLite between steps.
+Status lives in meeting metadata (tools layer), not in UI state.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import threading
+from contextlib import closing
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Serializes metadata read-modify-write. Webhooks are dispatched one-thread-each
+# (asyncio.to_thread), so concurrent transcript events would otherwise clobber
+# each other's appends. Reentrant so callers can hold it across their own
+# read + merge (see processor._upsert_live_transcript).
+_metadata_lock = threading.RLock()
+
+AUDIO_SUFFIXES = {".mp3", ".mp4", ".m4a", ".wav", ".webm", ".ogg", ".mpeg", ".mpga"}
+_MEETING_ID_RE = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+    re.I,
+)
+
+
+def merge_meeting_metadata(meeting_id: str, patch: dict[str, Any]) -> dict[str, Any]:
+    """Merge keys into a meeting's metadata blob."""
+    from praisonai_tools.tools import meeting_tools as mt
+
+    with _metadata_lock:
+        record = mt.get_meeting.__wrapped__(meeting_id)
+        if "error" in record:
+            return record
+        meta = {**(record.get("metadata") or {}), **patch}
+        try:
+            with closing(mt._connect()) as conn, conn:
+                conn.execute(
+                    "UPDATE meetings SET metadata = ? WHERE meeting_id = ?",
+                    (json.dumps(meta, sort_keys=True), meeting_id),
+                )
+        except Exception as exc:  # noqa: BLE001
+            logger.error("merge_meeting_metadata failed: %s", exc)
+            return {"error": str(exc)}
+    return {"meeting_id": meeting_id, "metadata": meta}
+
+
+def _pipeline_from_transcribe(
+    meeting_id: str,
+    file_path: str,
+    meeting_title: str,
+) -> dict[str, Any]:
+    """Shared tail: transcribe → summarize → index for a known meeting_id."""
+    from praisonai_tools.tools.meeting_tools import (
+        extract_action_items,
+        index_meeting,
+        summarize_transcript,
+        transcribe_file,
+    )
+
+    path = Path(file_path)
+    if not path.exists():
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": f"File not found: {file_path}"},
+        )
+        return {"meeting_id": meeting_id, "error": f"File not found: {file_path}"}
+
+    merge_meeting_metadata(
+        meeting_id,
+        {"status": "transcribing", "file_path": str(path), "error": None},
+    )
+
+    transcript_result = transcribe_file.__wrapped__(str(path))
+    if "error" in transcript_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": transcript_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **transcript_result}
+
+    transcript = transcript_result.get("text", "")
+    segments = transcript_result.get("segments") or []
+    merge_meeting_metadata(
+        meeting_id,
+        {
+            "status": "summarizing",
+            "transcript": transcript,
+            "segments": segments,
+            "duration_seconds": transcript_result.get("duration_seconds"),
+            "language": transcript_result.get("language"),
+        },
+    )
+
+    summary_result = summarize_transcript.__wrapped__(transcript)
+    if "error" in summary_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": summary_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **summary_result}
+
+    actions_result = extract_action_items.__wrapped__(transcript)
+    if "error" in actions_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": actions_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **actions_result}
+
+    merge_meeting_metadata(
+        meeting_id,
+        {
+            "status": "indexing",
+            "summary": summary_result.get("summary", ""),
+            "decisions": summary_result.get("decisions", []),
+            "topics": summary_result.get("topics", []),
+            "key_quotes": summary_result.get("key_quotes", []),
+            "action_items": actions_result.get("action_items", []),
+        },
+    )
+
+    index_result = index_meeting.__wrapped__(
+        meeting_id,
+        transcript=transcript,
+        segments=segments,
+    )
+    if "error" in index_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": index_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **index_result}
+
+    merge_meeting_metadata(meeting_id, {"status": "ready", "error": None})
+
+    return {
+        "meeting_id": meeting_id,
+        "status": "ready",
+        "title": meeting_title,
+        "summary": summary_result.get("summary", ""),
+        "action_items": actions_result.get("action_items", []),
+        "chunks_indexed": index_result.get("chunks_indexed", 0),
+    }
+
+
+def run_ingest_pipeline(
+    file_path: str,
+    title: str | None = None,
+    *,
+    meeting_id: str | None = None,
+) -> dict[str, Any]:
+    """Run the full Phase 1 pipeline for an audio/video upload."""
+    from praisonai_tools.tools.meeting_tools import get_meeting, save_meeting
+
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": f"File not found: {file_path}"}
+
+    meeting_title = (title or path.stem).strip() or "Untitled meeting"
+
+    if meeting_id:
+        record = get_meeting.__wrapped__(meeting_id)
+        if "error" in record:
+            return record
+        if title:
+            meeting_title = title
+        elif record.get("title"):
+            meeting_title = record["title"]
+    else:
+        saved = save_meeting.__wrapped__(
+            title=meeting_title,
+            source=str(path),
+            metadata={"status": "transcribing", "file_path": str(path)},
+        )
+        if "error" in saved:
+            return saved
+        meeting_id = saved["meeting_id"]
+
+    return _pipeline_from_transcribe(meeting_id, str(path), meeting_title)
+
+
+def run_post_transcript_pipeline(
+    meeting_id: str,
+    transcript: str,
+    *,
+    segments: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Run summarize → index for a Recall (or other) transcript without transcribe step."""
+    from praisonai_tools.tools.meeting_tools import (
+        extract_action_items,
+        get_meeting,
+        index_meeting,
+        summarize_transcript,
+    )
+
+    record = get_meeting.__wrapped__(meeting_id)
+    if "error" in record:
+        return record
+
+    meeting_title = record.get("title") or "Untitled meeting"
+    merge_meeting_metadata(
+        meeting_id,
+        {
+            "status": "summarizing",
+            "transcript": transcript,
+            "segments": segments or [],
+            "source": "recall",
+            "live_status": "ready",
+            "error": None,
+        },
+    )
+
+    summary_result = summarize_transcript.__wrapped__(transcript)
+    if "error" in summary_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": summary_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **summary_result}
+
+    actions_result = extract_action_items.__wrapped__(transcript)
+    if "error" in actions_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": actions_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **actions_result}
+
+    merge_meeting_metadata(
+        meeting_id,
+        {
+            "status": "indexing",
+            "summary": summary_result.get("summary", ""),
+            "decisions": summary_result.get("decisions", []),
+            "topics": summary_result.get("topics", []),
+            "key_quotes": summary_result.get("key_quotes", []),
+            "action_items": actions_result.get("action_items", []),
+        },
+    )
+
+    index_result = index_meeting.__wrapped__(
+        meeting_id,
+        transcript=transcript,
+        segments=segments or [],
+    )
+    if "error" in index_result:
+        merge_meeting_metadata(
+            meeting_id,
+            {"status": "failed", "error": index_result["error"]},
+        )
+        return {"meeting_id": meeting_id, **index_result}
+
+    merge_meeting_metadata(meeting_id, {"status": "ready", "error": None})
+
+    return {
+        "meeting_id": meeting_id,
+        "status": "ready",
+        "title": meeting_title,
+        "summary": summary_result.get("summary", ""),
+        "action_items": actions_result.get("action_items", []),
+        "chunks_indexed": index_result.get("chunks_indexed", 0),
+    }
+
+
+def retry_pipeline(meeting_id: str) -> dict[str, Any]:
+    """Re-run ingest for a failed meeting using its stored file path."""
+    if not meeting_id or not _MEETING_ID_RE.match(meeting_id):
+        return {"error": "invalid meeting_id", "meeting_id": meeting_id}
+
+    from praisonai_tools.tools.meeting_tools import get_meeting
+
+    record = get_meeting.__wrapped__(meeting_id)
+    if "error" in record:
+        return record
+
+    meta = record.get("metadata") or {}
+    file_path = meta.get("file_path") or record.get("source")
+    if not file_path:
+        return {
+            "meeting_id": meeting_id,
+            "error": "No uploaded file stored for this meeting",
+        }
+
+    return run_ingest_pipeline(
+        str(file_path),
+        title=record.get("title"),
+        meeting_id=meeting_id,
+    )

examples/python/meeting-agent/plugin.js

@@ -0,0 +1,57 @@
+/**
+ * Meeting Agent dashboard hooks — auto-refresh live transcript on meeting-detail.
+ */
+(function () {
+  'use strict';
+
+  let pollTimer = null;
+
+  function stopPolling() {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  }
+
+  async function refreshLiveTranscript() {
+    const host = document.querySelector('[data-page="meeting-detail"]');
+    if (!host) return;
+
+    const code = host.querySelector('.db-code-block code');
+    if (!code) return;
+
+    try {
+      const meetingsRes = await fetch('/api/meetings');
+      if (!meetingsRes.ok) return;
+      const meetingsJson = await meetingsRes.json();
+      const meetings = meetingsJson.meetings || [];
+      const live = meetings.find((m) =>
+        ['live', 'joining', 'waiting_room'].includes(String(m.live_status || '').toLowerCase())
+      );
+      if (!live || !live.id) return;
+
+      const snapRes = await fetch(`/api/meetings/${live.id}/live-transcript`);
+      if (!snapRes.ok) return;
+      const snap = await snapRes.json();
+      const text = snap.transcript || '(empty)';
+      if (code.textContent !== text) {
+        code.textContent = text;
+      }
+    } catch (_err) {
+      /* ignore transient network errors */
+    }
+  }
+
+  function startPolling() {
+    stopPolling();
+    refreshLiveTranscript();
+    pollTimer = setInterval(refreshLiveTranscript, 3000);
+  }
+
+  window.addEventListener('aiui:page-change', (event) => {
+    stopPolling();
+    if (event.detail && event.detail.pageId === 'meeting-detail') {
+      startPolling();
+    }
+  });
+})();

examples/python/meeting-agent/poll_live_transcript.ps1

@@ -0,0 +1,61 @@
+# Poll live transcript for a meeting (Part B dev test).
+# Usage:
+#   .\poll_live_transcript.ps1
+#   .\poll_live_transcript.ps1 -MeetingId "aecf34bc-7194-4123-9c67-a298b56011da"
+#   .\poll_live_transcript.ps1 -IntervalSec 2
+
+param(
+    [string]$MeetingId = "",
+    [int]$Port = 8000,
+    [int]$IntervalSec = 3
+)
+
+$ErrorActionPreference = "Stop"
+$base = "http://127.0.0.1:$Port"
+
+if (-not $MeetingId) {
+    $meetings = Invoke-RestMethod -Uri "$base/api/meetings"
+    $live = $meetings.meetings | Where-Object { @("live","joining","waiting_room") -contains ($_.live_status).ToLower() } | Select-Object -First 1
+    if ($live) {
+        $MeetingId = $live.id
+    } elseif ($meetings.meetings.Count -gt 0) {
+        $MeetingId = $meetings.meetings[0].id
+    } else {
+        throw "No meetings found. Schedule a bot first."
+    }
+}
+
+$url = "$base/api/meetings/$MeetingId/live-transcript"
+
+Write-Host "Polling $url every ${IntervalSec}s (Ctrl+C to stop)"
+Write-Host ""
+
+$lastCount = -1
+$lastText = ""
+
+while ($true) {
+    try {
+        $r = Invoke-RestMethod -Uri $url -TimeoutSec 10
+        $count = [int]$r.line_count
+        $status = $r.live_status
+        $text = [string]$r.transcript
+
+        if ($count -ne $lastCount -or $text -ne $lastText) {
+            $ts = Get-Date -Format "HH:mm:ss"
+            Write-Host "[$ts] live_status=$status  lines=$count"
+            if ($text) {
+                Write-Host "---"
+                Write-Host $text
+                Write-Host "---"
+            } else {
+                Write-Host "(empty transcript)"
+            }
+            Write-Host ""
+            $lastCount = $count
+            $lastText = $text
+        }
+    } catch {
+        Write-Host "[$(Get-Date -Format 'HH:mm:ss')] ERROR: $($_.Exception.Message)"
+    }
+    Start-Sleep -Seconds $IntervalSec
+}

examples/python/meeting-agent/recall_routes.py

@@ -0,0 +1,337 @@
+"""Recall.ai HTTP routes for the meeting-agent example."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from typing import Any
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse, PlainTextResponse, Response, StreamingResponse
+
+from meeting_integrations.recall.calendar import forward_calendar_callback
+from meeting_integrations.recall.calendar_service import (
+    list_upcoming_calendar_meetings,
+    process_calendar_webhook,
+    sync_calendar_events,
+)
+from meeting_integrations.recall.config import RecallConfigError, load_recall_settings
+from meeting_integrations.recall.live import snapshot_for_api, wait_for_update
+from meeting_integrations.recall.processor import process_recall_webhook
+from meeting_integrations.recall.service import cancel_recall_bot, schedule_recall_bot
+from meeting_integrations.recall.store import RecallStore
+from meeting_integrations.recall.verify import VerificationError, verify_request_from_recall
+
+logger = logging.getLogger(__name__)
+
+_calendar_regional_uri: str | None = None
+
+# asyncio keeps only weak references to tasks, so a bare create_task() can be
+# garbage-collected mid-flight and silently drop a webhook event. Hold a strong
+# reference until each background task finishes.
+_background_tasks: set[asyncio.Task] = set()
+
+
+def _dispatch_background(coro) -> None:
+    task = asyncio.create_task(coro)
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
+
+
+def set_calendar_regional_callback_uri(uri: str | None) -> None:
+    global _calendar_regional_uri
+    _calendar_regional_uri = uri
+
+
+async def api_recall_schedule_bot(request: Request) -> JSONResponse:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+
+    meeting_url = str(body.get("meeting_url") or "").strip()
+    title = str(body.get("title") or "").strip()
+    join_at = body.get("join_at")
+    join_at_str = str(join_at).strip() if join_at else None
+
+    result = await asyncio.to_thread(
+        schedule_recall_bot,
+        meeting_url,
+        title,
+        join_at=join_at_str,
+    )
+    status = 201 if result.get("recall_bot_id") else 400 if "error" in result else 500
+    return JSONResponse(result, status_code=status)
+
+
+async def api_recall_cancel_bot(request: Request) -> JSONResponse:
+    meeting_id = request.path_params["meeting_id"]
+    result = await asyncio.to_thread(cancel_recall_bot, meeting_id)
+    status = 200 if "error" not in result else 400
+    return JSONResponse(result, status_code=status)
+
+
+async def api_recall_bot_status(request: Request) -> JSONResponse:
+    meeting_id = request.path_params["meeting_id"]
+    try:
+        from praisonai_tools.tools.meeting_tools import get_meeting
+
+        record = get_meeting.__wrapped__(meeting_id)
+    except ImportError:
+        return JSONResponse({"error": "meeting tools unavailable"}, status_code=503)
+    if "error" in record:
+        return JSONResponse(record, status_code=404)
+    meta = record.get("metadata") or {}
+    return JSONResponse(
+        {
+            "meeting_id": meeting_id,
+            "title": record.get("title"),
+            "status": meta.get("status"),
+            "live_status": meta.get("live_status"),
+            "recall_bot_id": meta.get("recall_bot_id"),
+            "meeting_url": meta.get("meeting_url"),
+            "transcript_preview": (meta.get("transcript") or "")[:500],
+        }
+    )
+
+
+async def webhook_recall(request: Request) -> Response:
+    raw = (await request.body()).decode("utf-8")
+    try:
+        settings = load_recall_settings()
+    except RecallConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+
+    headers = {k: v for k, v in request.headers.items()}
+    try:
+        verify_request_from_recall(
+            secret=settings.webhook_verification_secret,
+            headers=headers,
+            payload=raw,
+        )
+    except VerificationError:
+        return JSONResponse({"error": "invalid signature"}, status_code=401)
+
+    try:
+        payload = json.loads(raw) if raw else {}
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid JSON"}, status_code=400)
+
+    event_type = str(payload.get("event") or payload.get("type") or "unknown")
+    if event_type.startswith("calendar."):
+        _dispatch_background(
+            asyncio.to_thread(
+                process_calendar_webhook,
+                event_type,
+                payload,
+                settings=settings,
+            )
+        )
+        return PlainTextResponse("ok", status_code=200)
+
+    _dispatch_background(
+        asyncio.to_thread(process_recall_webhook, event_type, payload, settings=settings)
+    )
+    return PlainTextResponse("ok", status_code=200)
+
+
+async def api_recall_calendar_callback(request: Request) -> Response:
+    if not _calendar_regional_uri:
+        return JSONResponse(
+            {
+                "error": "Calendar callback not configured. Bootstrap setup via "
+                "POST /api/recall/calendar/setup/bootstrap with regional_callback_uri "
+                "from Recall MCP start_calendar_integration_setup."
+            },
+            status_code=503,
+        )
+    params = dict(request.query_params)
+    status, body = await asyncio.to_thread(
+        forward_calendar_callback,
+        regional_callback_uri=_calendar_regional_uri,
+        query_params=params,
+    )
+    return PlainTextResponse(body, status_code=status)
+
+
+async def api_recall_calendar_bootstrap(request: Request) -> JSONResponse:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid JSON"}, status_code=400)
+
+    setup_id = str(body.get("setup_id") or "").strip()
+    platform = str(body.get("platform") or "google_calendar").strip()
+    regional_uri = str(body.get("regional_callback_uri") or "").strip()
+    state = body.get("state") if isinstance(body.get("state"), dict) else {}
+
+    if not setup_id or not regional_uri:
+        return JSONResponse(
+            {"error": "setup_id and regional_callback_uri are required"},
+            status_code=400,
+        )
+
+    set_calendar_regional_callback_uri(regional_uri)
+    RecallStore.save_calendar_setup(
+        setup_id,
+        platform,
+        {
+            **state,
+            "regional_callback_uri": regional_uri,
+            "platform": platform,
+        },
+    )
+    callback_url = "(set PUBLIC_API_BASE_URL)"
+    if os.getenv("PUBLIC_API_BASE_URL", "").strip():
+        try:
+            callback_url = load_recall_settings().calendar_callback_url
+        except RecallConfigError:
+            pass
+    return JSONResponse(
+        {
+            "setup_id": setup_id,
+            "callback_url": callback_url,
+            "status": "bootstrapped",
+        }
+    )
+
+
+async def api_recall_calendar_status(_request: Request) -> JSONResponse:
+    auto_record = os.getenv("CALENDAR_AUTO_RECORD", "true").strip().lower() not in {
+        "0",
+        "false",
+        "no",
+        "off",
+    }
+    public_url = os.getenv("PUBLIC_API_BASE_URL", "").strip()
+    calendars: list[dict[str, Any]] = []
+    try:
+        from meeting_integrations.recall.client import RecallClient
+
+        settings = load_recall_settings()
+        calendars = RecallClient(settings).list_calendars(status="connected")
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("Could not list calendars: %s", exc)
+
+    return JSONResponse(
+        {
+            "calendar_v2": {
+                "auto_record_eligible_events": auto_record,
+                "connected_calendars": len(calendars),
+                "calendars": [
+                    {
+                        "id": c.get("id"),
+                        "platform": c.get("platform"),
+                        "email": c.get("platform_email") or c.get("email"),
+                        "status": c.get("status"),
+                    }
+                    for c in calendars
+                    if isinstance(c, dict)
+                ],
+                "callback_configured": bool(_calendar_regional_uri),
+                "public_api_base_url_set": bool(public_url),
+                "webhook_events": ["calendar.sync_events", "calendar.update"],
+                "next_step": (
+                    "Register calendar webhooks on the same /webhooks/recall URL, "
+                    "then complete Google Calendar V2 OAuth via Recall MCP."
+                ),
+            }
+        }
+    )
+
+
+async def api_recall_calendar_upcoming(request: Request) -> JSONResponse:
+    hours = int(request.query_params.get("hours", "24"))
+    try:
+        rows = await asyncio.to_thread(list_upcoming_calendar_meetings, hours=hours)
+    except RecallConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+    except Exception as exc:  # noqa: BLE001
+        return JSONResponse({"error": str(exc)}, status_code=502)
+    return JSONResponse({"events": rows, "hours": hours})
+
+
+async def api_recall_calendar_sync(request: Request) -> JSONResponse:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        body = {}
+    calendar_id = str(body.get("calendar_id") or request.query_params.get("calendar_id") or "").strip()
+    if not calendar_id:
+        return JSONResponse({"error": "calendar_id is required"}, status_code=400)
+    try:
+        settings = load_recall_settings()
+        result = await asyncio.to_thread(
+            sync_calendar_events,
+            calendar_id,
+            updated_since=body.get("updated_at__gte"),
+            settings=settings,
+        )
+    except RecallConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+    except Exception as exc:  # noqa: BLE001
+        return JSONResponse({"error": str(exc)}, status_code=502)
+    return JSONResponse(result)
+
+
+async def api_meeting_live_transcript(request: Request) -> Response:
+    meeting_id = request.path_params["meeting_id"]
+    accept = request.headers.get("accept", "")
+    try:
+        from praisonai_tools.tools.meeting_tools import get_meeting
+
+        record = get_meeting.__wrapped__(meeting_id)
+    except ImportError:
+        return JSONResponse({"error": "meeting tools unavailable"}, status_code=503)
+    if "error" in record:
+        return JSONResponse(record, status_code=404)
+
+    if "text/event-stream" not in accept:
+        return JSONResponse(snapshot_for_api(meeting_id, record))
+
+    async def event_stream():
+        last_text = ""
+        while True:
+            try:
+                from praisonai_tools.tools.meeting_tools import get_meeting
+
+                record = get_meeting.__wrapped__(meeting_id)
+            except ImportError:
+                break
+            snap = snapshot_for_api(meeting_id, record)
+            text = snap.get("transcript") or ""
+            live = (snap.get("live_status") or "").lower()
+            if text != last_text:
+                yield f"data: {json.dumps(snap)}\n\n"
+                last_text = text
+            if live not in ("live", "joining", "waiting_room", "scheduled", ""):
+                break
+            await asyncio.to_thread(wait_for_update, meeting_id, 25.0)
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+async def api_recall_config_status(_request: Request) -> JSONResponse:
+    try:
+        settings = load_recall_settings()
+        configured = True
+    except RecallConfigError as exc:
+        settings = None
+        configured = False
+        error = str(exc)
+    else:
+        error = None
+
+    return JSONResponse(
+        {
+            "configured": configured,
+            "error": error,
+            "region": settings.region if settings else os.getenv("RECALL_REGION"),
+            "workspace_id": settings.workspace_id if settings else None,
+            "webhook_url": settings.webhook_url if settings and settings.public_api_base_url else None,
+            "bot_name": settings.bot_name if settings else None,
+        }
+    )
+

examples/python/meeting-agent/recover_recall_meeting.py

@@ -0,0 +1,133 @@
+"""Recover a Recall meeting when webhooks missed (stale tunnel URL).
+
+Usage:
+    py -3.13 recover_recall_meeting.py <meeting_id> [bot_id]
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+_EXAMPLE_DIR = Path(__file__).resolve().parent
+if str(_EXAMPLE_DIR) not in sys.path:
+    sys.path.insert(0, str(_EXAMPLE_DIR))
+
+
+def _load_env() -> None:
+    import os
+
+    env_path = _EXAMPLE_DIR / ".env"
+    if not env_path.is_file():
+        return
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+def _duration_seconds(started_at: str | None, completed_at: str | None) -> int | None:
+    if not started_at or not completed_at:
+        return None
+    try:
+        fmt = "%Y-%m-%dT%H:%M:%S.%f%z"
+        start = datetime.strptime(started_at.replace("Z", "+0000"), fmt)
+        end = datetime.strptime(completed_at.replace("Z", "+0000"), fmt)
+        return int((end - start).total_seconds())
+    except (TypeError, ValueError):
+        return None
+
+
+def recover(meeting_id: str, bot_id: str | None = None) -> dict:
+    from meeting_integrations.recall.client import RecallClient
+    from meeting_integrations.recall.config import load_recall_settings
+    from meeting_integrations.recall.transcript import transcript_download_to_text
+    from pipeline import merge_meeting_metadata, run_post_transcript_pipeline
+    from praisonai_tools.tools.meeting_tools import get_meeting
+
+    _load_env()
+    settings = load_recall_settings()
+    client = RecallClient(settings)
+
+    record = get_meeting.__wrapped__(meeting_id)
+    if "error" in record:
+        raise SystemExit(record["error"])
+
+    meta = record.get("metadata") or {}
+    bot_id = bot_id or meta.get("recall_bot_id")
+    if not bot_id:
+        raise SystemExit("No recall_bot_id — pass bot_id as second argument")
+
+    bot = client.get_bot(str(bot_id))
+    recordings = bot.get("recordings") or []
+    if not recordings:
+        raise SystemExit("Bot has no recordings yet")
+
+    rec_wrap = recordings[0].get("recording") or recordings[0]
+    recording_id = rec_wrap.get("id")
+    if not recording_id:
+        raise SystemExit("Missing recording id on bot")
+
+    duration = _duration_seconds(rec_wrap.get("started_at"), rec_wrap.get("completed_at"))
+    merge_meeting_metadata(
+        meeting_id,
+        {
+            "recall_bot_id": bot_id,
+            "recall_recording_id": recording_id,
+            "live_status": "processing",
+            "status": "transcribing",
+            **({"duration_seconds": duration} if duration else {}),
+        },
+    )
+
+    transcript_id = None
+    for _ in range(30):
+        bot = client.get_bot(str(bot_id))
+        recs = bot.get("recordings") or []
+        if recs:
+            rec = recs[0].get("recording") or recs[0]
+            shortcuts = rec.get("media_shortcuts") or {}
+            tr = shortcuts.get("transcript")
+            if isinstance(tr, dict) and tr.get("id"):
+                transcript_id = str(tr["id"])
+                break
+            artifacts = recs[0].get("transcript_artifacts") or rec.get("transcript_artifacts") or []
+            if artifacts:
+                transcript_id = str(artifacts[0].get("id") or "")
+                if transcript_id:
+                    break
+        if not transcript_id:
+            print("Starting async transcript…")
+            client.create_async_transcript(str(recording_id))
+            time.sleep(10)
+        else:
+            break
+
+    if not transcript_id:
+        raise SystemExit("Timed out waiting for transcript — webhook may still deliver it")
+
+    artifact = client.get_transcript(transcript_id)
+    download_url = (artifact.get("data") or {}).get("download_url")
+    if not download_url:
+        raise SystemExit("Transcript ready but no download_url")
+
+    raw = client.download_json(download_url)
+    text = transcript_download_to_text(raw)
+    if not text.strip():
+        raise SystemExit("Transcript download was empty")
+
+    result = run_post_transcript_pipeline(meeting_id, text)
+    print("Recovered:", result)
+    return result
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        raise SystemExit("Usage: recover_recall_meeting.py <meeting_id> [bot_id]")
+    recover(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else None)

examples/python/meeting-agent/smoke_recall.py

@@ -0,0 +1,87 @@
+"""Non-binding smoke checks for Recall integration boundaries."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+from starlette.testclient import TestClient
+
+_EXAMPLE_DIR = Path(__file__).resolve().parent
+_REPO_SRC = _EXAMPLE_DIR.parents[2] / "src"
+for _p in (_EXAMPLE_DIR, str(_REPO_SRC)):
+    if str(_p) not in sys.path:
+        sys.path.insert(0, str(_p))
+
+
+def _sign_payload(secret: str, body: str) -> dict[str, str]:
+    key = base64.b64decode(secret.removeprefix("whsec_"))
+    msg_id = "msg_smoke_test"
+    timestamp = "1700000000"
+    to_sign = f"{msg_id}.{timestamp}.{body}"
+    signature = base64.b64encode(
+        hmac.new(key, to_sign.encode("utf-8"), hashlib.sha256).digest()
+    ).decode("ascii")
+    return {
+        "webhook-id": msg_id,
+        "webhook-timestamp": timestamp,
+        "webhook-signature": f"v1,{signature}",
+    }
+
+
+def run_smoke() -> None:
+    os.environ.setdefault("RECALL_REGION", "eu-central-1")
+    os.environ.setdefault("RECALL_API_KEY", "smoke-test-key")
+    os.environ.setdefault("RECALL_WEBHOOK_VERIFICATION_SECRET", "whsec_" + base64.b64encode(b"smoke-secret-key-32-bytes-long!!").decode())
+    os.environ.setdefault("RECALL_WORKSPACE_ID", "smoke-workspace")
+    os.environ.setdefault("PUBLIC_API_BASE_URL", "https://smoke.example.test")
+
+    import app as meeting_app  # noqa: WPS433
+    from meeting_integrations.recall.config import load_recall_settings
+    from meeting_integrations.recall.verify import verify_request_from_recall
+
+    settings = load_recall_settings()
+    assert settings.api_key == "smoke-test-key"
+
+    body = json.dumps({"event": "bot.joining_call", "data": {"bot": {"id": "b1", "metadata": {"meeting_id": "m1"}}}})
+    headers = _sign_payload(settings.webhook_verification_secret, body)
+    verify_request_from_recall(
+        secret=settings.webhook_verification_secret,
+        headers=headers,
+        payload=body,
+    )
+
+    client = TestClient(meeting_app.app)
+    assert client.get("/health").status_code == 200
+
+    bad = client.post("/webhooks/recall", content=body, headers={"webhook-id": "x"})
+    assert bad.status_code == 401
+
+    ok = client.post("/webhooks/recall", content=body, headers=headers)
+    assert ok.status_code == 200
+
+    with patch(
+        "recall_routes.schedule_recall_bot",
+        return_value={
+            "meeting_id": "m-smoke",
+            "recall_bot_id": "bot-smoke",
+            "status": "scheduled",
+        },
+    ):
+        schedule = client.post(
+            "/api/recall/bots",
+            json={"meeting_url": "https://zoom.us/j/123", "title": "Smoke"},
+        )
+    assert schedule.status_code == 201
+
+    print("Recall smoke checks passed")
+
+
+if __name__ == "__main__":
+    run_smoke()

examples/python/meeting-agent/start_dev.ps1

@@ -0,0 +1,112 @@
+# Start meeting-agent (Part B) + Cloudflare tunnel for Recall webhooks.
+# Usage: .\start_dev.ps1
+# Optional: $env:TEST_MEETING_URL = "https://meet.google.com/..." ; .\start_dev.ps1 -ScheduleBot
+
+param(
+    [switch]$ScheduleBot,
+    [string]$MeetingUrl = $env:TEST_MEETING_URL,
+    [int]$Port = 8000
+)
+
+$ErrorActionPreference = "Stop"
+$Root = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $Root
+
+function Load-DotEnv {
+    $envFile = Join-Path $Root ".env"
+    if (-not (Test-Path $envFile)) { return }
+    Get-Content $envFile | ForEach-Object {
+        $line = $_.Trim()
+        if (-not $line -or $line.StartsWith("#") -or $line -notmatch "=") { return }
+        $key, $value = $line -split "=", 2
+        if ($key -and -not [string]::IsNullOrWhiteSpace($key) -and -not (Get-Item "Env:$key" -ErrorAction SilentlyContinue)) {
+            Set-Item -Path "Env:$key" -Value $value.Trim()
+        }
+    }
+}
+
+function Test-PortListening([int]$p) {
+    try {
+        $r = Invoke-WebRequest -Uri "http://127.0.0.1:$p/api/recall/config" -UseBasicParsing -TimeoutSec 2
+        return $r.StatusCode -eq 200
+    } catch { return $false }
+}
+
+function Update-PublicUrl([string]$baseUrl) {
+    $envFile = Join-Path $Root ".env"
+    $content = Get-Content $envFile -Raw
+    if ($content -match "PUBLIC_API_BASE_URL=.*") {
+        $newContent = $content -replace "PUBLIC_API_BASE_URL=.*", "PUBLIC_API_BASE_URL=$baseUrl"
+    } else {
+        $newContent = $content.TrimEnd() + "`nPUBLIC_API_BASE_URL=$baseUrl`n"
+    }
+    Set-Content -Path $envFile -Value $newContent -NoNewline
+    $env:PUBLIC_API_BASE_URL = $baseUrl
+    Write-Host "Updated .env PUBLIC_API_BASE_URL=$baseUrl"
+}
+
+Load-DotEnv
+$env:MEETING_AGENT_PORT = "$Port"
+
+if (-not (Test-PortListening $Port)) {
+    Write-Host "Starting meeting-agent on port $Port..."
+    Start-Process -FilePath "py" -ArgumentList "-3.13", "app.py" -WorkingDirectory $Root -WindowStyle Minimized
+    $deadline = (Get-Date).AddSeconds(45)
+    while ((Get-Date) -lt $deadline) {
+        if (Test-PortListening $Port) { break }
+        Start-Sleep -Seconds 2
+    }
+    if (-not (Test-PortListening $Port)) {
+        throw "App did not become ready on http://127.0.0.1:$Port"
+    }
+    Write-Host "App ready: http://127.0.0.1:$Port"
+} else {
+    Write-Host "App already running on port $Port"
+}
+
+$public = $env:PUBLIC_API_BASE_URL
+try {
+    $null = Invoke-WebRequest -Uri "$public/api/recall/config" -UseBasicParsing -TimeoutSec 5
+    Write-Host "Tunnel OK: $public"
+} catch {
+    Write-Host "Starting Cloudflare tunnel (quick tunnel - URL may change)..."
+    $log = Join-Path $Root ".tunnel.log"
+    $logErr = "${log}.err"
+    if (Test-Path $log) { Remove-Item $log -Force }
+    if (Test-Path $logErr) { Remove-Item $logErr -Force }
+    Start-Process -FilePath "cloudflared" -ArgumentList "tunnel", "--url", "http://127.0.0.1:$Port" `
+        -RedirectStandardOutput $log -RedirectStandardError $logErr -WindowStyle Minimized
+    $deadline = (Get-Date).AddSeconds(90)
+    $newUrl = $null
+    while ((Get-Date) -lt $deadline -and -not $newUrl) {
+        Start-Sleep -Seconds 2
+        foreach ($path in @($logErr, $log)) {
+            if (-not (Test-Path $path)) { continue }
+            $match = Select-String -Path $path -Pattern "https://[a-z0-9-]+\.trycloudflare\.com" | Select-Object -First 1
+            if ($match) {
+                $newUrl = $match.Matches[0].Value
+                break
+            }
+        }
+    }
+    if (-not $newUrl) { throw "Could not read tunnel URL from $logErr (or $log). Check cloudflared is installed." }
+    Update-PublicUrl $newUrl
+    Write-Host "Tunnel ready: $newUrl"
+    Write-Host "If Recall webhook URL changed, update it in Recall dashboard Webhooks"
+}
+
+$config = Invoke-RestMethod -Uri "http://127.0.0.1:$Port/api/recall/config"
+Write-Host "Recall configured: $($config.configured)"
+
+if ($ScheduleBot) {
+    if (-not $MeetingUrl) {
+        Write-Host "No TEST_MEETING_URL - skip bot schedule. Set env TEST_MEETING_URL or pass -MeetingUrl"
+    } else {
+        $body = @{ meeting_url = $MeetingUrl; title = "Part B live transcript test" } | ConvertTo-Json
+        $result = Invoke-RestMethod -Method Post -Uri "http://127.0.0.1:$Port/api/recall/bots" `
+            -ContentType "application/json" -Body $body
+        Write-Host "Bot scheduled:" ($result | ConvertTo-Json -Compress)
+    }
+}
+
+Write-Host "Done. Dashboard: http://127.0.0.1:$Port"

examples/python/voice-agent/.env.example

@@ -0,0 +1,51 @@
+# Voice Agent — local secrets. Never commit.
+
+OPENAI_API_KEY=
+
+VOICE_AGENT_PORT=8001
+
+# LLM for voice assistant (synced to provider on setup / start_dev)
+VOICE_AGENT_MODEL=gpt-4o-mini
+
+# Voice telephony provider
+VOICE_API_BASE=
+VOICE_PRIVATE_API_KEY=
+VOICE_PUBLIC_API_KEY=
+VOICE_SERVER_URL_SECRET=
+VOICE_ASSISTANT_ID=
+VOICE_PHONE_NUMBER_ID=
+
+# Phase 2 — browser web talk (provider web SDK)
+# VOICE_WEB_SDK_URL=https://esm.sh/@vapi-ai/[email protected]
+# VOICE_WEB_SDK_GLOBAL=VoiceWebClient
+
+# Dynamic assistant (assistant-request returns inline config + agent tools)
+# VOICE_DYNAMIC_ASSISTANT=true
+# VOICE_AGENT_EXTRA_TOOLS=meeting_search
+
+# ElevenLabs Speech Engine — OpenAI tool calling on the sidecar LLM path
+# VOICE_SPEECH_USE_TOOLS=true
+
+# Cross-call memory — stable browser user id → PraisonAI session reload
+# VOICE_MEMORY_ENABLED=true
+# VOICE_MEMORY_HISTORY_LIMIT=20
+# VOICE_MEMORY_USE_KNOWLEDGE=true
+
+# OpenAI Realtime (browser speech-to-speech — higher audio token cost; keep demos short)
+# REALTIME_MODEL=gpt-realtime-2.1-mini
+# REALTIME_VOICE=marin
+# REALTIME_REASONING_EFFORT=low
+# REALTIME_INSTRUCTIONS=You are a helpful voice assistant. Keep replies to one or two short sentences.
+# REALTIME_FIRST_MESSAGE=
+
+# ElevenLabs Speech Engine (Phase 3 — browser voice, BYO LLM)
+# ELEVENLABS_API_KEY=
+# SPEECH_ENGINE_ID=          # auto-written by setup_speech_engine.py
+# SPEECH_ENGINE_PUBLIC_URL=  # auto-written — dedicated tunnel for sidecar :8002
+# SPEECH_ENGINE_PORT=8002
+# SPEECH_ENGINE_FIRST_MESSAGE=Hello! How can I help you today?
+# ELEVENLABS_VOICE_ID=          # Praison/custom voice from ElevenLabs dashboard
+
+# Public HTTPS URL for provider webhook (Cloudflare tunnel)
+# cloudflared tunnel --url http://127.0.0.1:8001
+PUBLIC_API_BASE_URL=

examples/python/voice-agent/README.md

@@ -0,0 +1,118 @@
+# Voice Agent example — PraisonAIUI
+
+Phone and web voice agents using an external telephony/voice platform for STT/TTS/calls and PraisonAI for tools + dashboard.
+
+## Quick start
+
+```powershell
+cd examples/python/voice-agent
+copy .env.example .env
+# Fill VOICE_API_BASE, VOICE_PRIVATE_API_KEY, VOICE_ASSISTANT_ID, etc.
+
+# Fully automatic (app + tunnel + provider config):
+.\setup_all.ps1
+
+# Or step by step:
+.\start_dev.ps1
+```
+
+Dashboard: http://127.0.0.1:8001
+
+## Provider setup
+
+1. Create an **assistant** with tools `get_current_time` and `echo_message`
+2. Set **webhook URL** to `{PUBLIC_API_BASE_URL}/webhooks/voice`
+3. Set **webhook secret header** `X-Voice-Webhook-Secret` → same as `VOICE_SERVER_URL_SECRET` in `.env`
+4. Add a phone number and copy `VOICE_PHONE_NUMBER_ID`
+
+Or run `py -3.13 setup_voice_provider.py` after `start_dev.ps1`.
+
+## API
+
+| Route | Method | Purpose |
+|-------|--------|---------|
+| `/api/voice/calls` | POST | Outbound call `{ "customer_number": "+1..." }` |
+| `/api/voice/calls` | GET | List stored calls |
+| `/api/voice/calls/{id}` | GET | Call detail + transcript |
+| `/api/voice/calls/{id}/live-transcript` | GET | SSE live transcript stream |
+| `/api/voice/web-config` | GET | Browser talk widget config |
+| `/webhooks/voice` | POST | Provider webhooks (tool-calls, transcript, end-of-call) |
+| `/api/voice/config` | GET | Config status |
+| `/api/voice/doctor` | GET | Voice stack health checks (.env, ports, APIs, tunnel) |
+
+## Phase 2 features
+
+- **Live transcript** — `GET /api/voice/calls/{id}/live-transcript` (SSE); **Call detail** page uses `plugin.js` + EventSource
+- **Dynamic assistant** — set `VOICE_DYNAMIC_ASSISTANT=true` so `assistant-request` returns inline config with agent tool names
+- **Agent tools** — `tool-calls` run through `integrations/voice/agent_runner.py` (same registry as dashboard chat)
+- **Web talk** — **Web talk** page loads provider web SDK from `VOICE_WEB_SDK_URL` / `VOICE_WEB_SDK_GLOBAL`
+- **Chat bridge** — final transcript lines and end-of-call summaries appear in **Chat** sidebar as `📞 Call …` sessions
+
+Optional: `VOICE_AGENT_EXTRA_TOOLS=meeting_search` adds meeting search when `praisonai_tools` is installed.
+
+## Cross-call memory (PraisonAI sessions)
+
+Stable browser `voice-user-id` (localStorage) maps to `voice-user-{id}` PraisonAI session folder. Prior turns reload on new calls/restarts when `VOICE_MEMORY_ENABLED=true` (default).
+
+| Route | Purpose |
+|-------|---------|
+| `/api/voice/memory/attach-user` | ElevenLabs — attach user before conversation starts |
+| `/api/voice/memory/bind` | Bind `call_id` + `user_id` |
+| `/api/voice/memory/resolve?user_id=` | Resolve Praison session id |
+
+Knowledge base entries are injected into voice prompts when available.
+
+## Call detail UI (PraisonAIUI components)
+
+Call detail uses server-built components (`code_block`, `badge`, `key_value_list`, `tabs`) via `GET /api/voice/calls/{id}/ui`. Live SSE updates the transcript code block. Mic/WebRTC talk pages still use minimal `plugin.js`.
+
+## End-of-call summary & analytics
+
+When a session ends (ElevenLabs, GPT Realtime, or telephony webhook), `integrations/voice/call_finalize.py`:
+
+- Generates a one-sentence summary (OpenAI) when the provider did not send one
+- Stores **duration** and **turn count** in call metadata
+- Posts the summary to the **Chat** sidebar via the chat bridge
+
+**Voice calls** table shows Duration and Turns. **Config** page runs the voice doctor (`GET /api/voice/doctor` or `py -3.13 doctor.py`).
+
+## MCP manager
+
+The dashboard **MCP** page lists configured Model Context Protocol servers (`GET /api/mcp/servers`) and supports connect/disconnect from the UI.
+
+## Phase 3 — ElevenLabs Speech Engine
+
+Bring-your-own-LLM browser voice ([Speech Engine docs](https://elevenlabs.io/docs/overview/capabilities/speech-engine)):
+
+```powershell
+pip install -r requirements-voice.txt
+# Add ELEVENLABS_API_KEY to .env
+.\start_dev.ps1 -Restart
+```
+
+- **ElevenLabs talk** page — WebRTC client, token from `/api/voice/speech-engine/token`
+- **Speech Engine sidecar** (`speech_engine_sidecar.py` on port **8002**) — official SDK WebSocket server
+- **Dedicated tunnel** — `SPEECH_ENGINE_PUBLIC_URL` → `wss://…/ws` (separate from dashboard tunnel)
+- **`setup_speech_engine.py`** — registers the public WebSocket URL with ElevenLabs
+
+| Route | Purpose |
+|-------|---------|
+| `/api/voice/speech-engine/config` | Client config |
+| `/api/voice/speech-engine/token` | Browser conversation token |
+| `/ws` | Speech Engine WebSocket (ElevenLabs → your server) |
+
+## Architecture
+
+External platform handles voice pipeline (phone, STT, TTS, turn-taking). This app handles:
+
+- **tool-calls** → PraisonAI agent tools (`integrations/voice/agent_runner.py`)
+- **transcript** / **end-of-call-report** → SQLite store, SSE hub, chat bridge
+- **assistant-request** → default `VOICE_ASSISTANT_ID` or dynamic inline assistant
+
+Same pattern as `examples/python/meeting-agent` (Recall webhooks).
+
+## Tests
+
+```bash
+pytest tests/unit/test_voice_agent.py -v
+```

examples/python/voice-agent/app.py

@@ -0,0 +1,285 @@
+"""Voice Agent — PraisonAIUI example with telephony webhooks.
+
+  - Outbound calls     → POST /api/voice/calls
+  - Provider webhooks  → POST /webhooks/voice (tool-calls, transcript, end-of-call)
+  - Dashboard          → Calls list + live call detail + web talk + chat bridge
+
+Run:
+    cd examples/python/voice-agent
+    pip install httpx
+    copy .env.example .env
+    .\\start_dev.ps1
+    python app.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import praisonaiui as aiui
+from praisonaiui.server import create_app
+from starlette.routing import Route, WebSocketRoute
+
+from memory_routes import (
+    api_voice_memory_attach_user,
+    api_voice_memory_bind,
+    api_voice_memory_config,
+    api_voice_memory_for_call,
+    api_voice_memory_resolve,
+)
+from realtime_routes import (
+    api_realtime_config,
+    api_realtime_end,
+    api_realtime_new_call,
+    api_realtime_session,
+    api_realtime_transcript,
+)
+from speech_engine_routes import (
+    api_speech_engine_config,
+    api_speech_engine_token,
+    speech_engine_websocket,
+)
+from voice_routes import (
+    api_voice_call_detail,
+    api_voice_call_detail_ui,
+    api_voice_config_status,
+    api_voice_create_call,
+    api_voice_doctor,
+    api_voice_list_calls,
+    api_voice_live_transcript,
+    api_voice_web_config,
+    webhook_voice,
+)
+
+_EXAMPLE_DIR = Path(__file__).resolve().parent
+if str(_EXAMPLE_DIR) not in sys.path:
+    sys.path.insert(0, str(_EXAMPLE_DIR))
+
+
+def _load_local_env() -> None:
+    env_path = _EXAMPLE_DIR / ".env"
+    if not env_path.is_file():
+        return
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key:
+            os.environ[key] = value
+
+
+_load_local_env()
+
+aiui.set_pages(
+    [
+        "chat",
+        "voice-calls",
+        "call-detail",
+        "web-talk",
+        "eleven-talk",
+        "realtime-talk",
+        "mcp",
+        "config",
+    ]
+)
+aiui.set_style("dashboard")
+aiui.set_custom_js(_EXAMPLE_DIR / "plugin.js")
+
+
+def get_agent():
+    from integrations.voice.agent_runner import get_voice_agent
+
+    return get_voice_agent()
+
+
+aiui.register_agent("voice-assistant", get_agent())
+
+
+@aiui.on_app_startup
+async def _start_voice_chat_bridge() -> None:
+    from integrations.voice.chat_bridge import start_chat_bridge_worker
+
+    start_chat_bridge_worker()
+
+
+@aiui.reply
+async def on_message(message: str):
+    """Chat with the voice demo agent."""
+    from integrations.voice.tools import demo_tool_reply
+
+    text = str(message).strip()
+    if not text:
+        return
+
+    demo = demo_tool_reply(text)
+    if demo is not None:
+        await aiui.say(demo)
+        return
+
+    if not os.getenv("OPENAI_API_KEY"):
+        await aiui.say(
+            "Set `OPENAI_API_KEY` for open-ended chat. "
+            'Demo without API key: "What time is it?" or "Echo hello world".'
+        )
+        return
+    await aiui.think("Running voice assistant...")
+    agent = get_agent()
+    response = await asyncio.to_thread(agent.chat, text)
+    await aiui.say(str(response))
+
+
+def _list_calls() -> list[dict[str, Any]]:
+    from integrations.voice.call_finalize import analytics_for_record
+    from integrations.voice.store import VoiceCallStore
+
+    rows = VoiceCallStore.list_calls()
+    out: list[dict[str, Any]] = []
+    for r in rows:
+        analytics = analytics_for_record(r)
+        out.append(
+            {
+                "id": r["call_id"],
+                "status": r["status"],
+                "customer_number": r.get("customer_number") or "—",
+                "transcript_preview": (r.get("transcript") or "")[:120],
+                "duration": analytics.get("duration") or "—",
+                "turn_count": analytics.get("turn_count") or 0,
+                "updated_at": r.get("updated_at") or "",
+            }
+        )
+    return out
+
+
+def _pick_call(calls: list[dict[str, Any]]) -> dict[str, Any]:
+    live = next((c for c in calls if "progress" in (c.get("status") or "").lower()), None)
+    return live or (calls[0] if calls else {"id": "—", "status": "none", "customer_number": "—", "transcript_preview": ""})
+
+
+@aiui.page("voice-calls", title="Voice calls", icon="📞", group="Voice", order=1)
+async def voice_calls_page():
+    calls = _list_calls()
+    rows = [
+        [c["id"], c["customer_number"], c["status"], c["duration"], str(c["turn_count"]), c["updated_at"]]
+        for c in calls
+    ]
+    return aiui.layout(
+        [
+            aiui.text("Outbound and inbound voice calls via telephony provider"),
+            aiui.table(
+                headers=["Call ID", "Customer", "Status", "Duration", "Turns", "Updated"],
+                rows=rows or [["—", "—", "—", "—", "—", "—"]],
+            ),
+            aiui.alert(
+                "Open **Call detail** for live transcript (SSE). "
+                "Voice sessions also appear in **Chat** sidebar as 📞 entries.",
+                variant="info",
+                title="Phase 2",
+            ),
+        ]
+    )
+
+
+@aiui.page("call-detail", title="Call detail", icon="🎙️", group="Voice", order=2)
+async def call_detail_page():
+    """Server fallback — plugin.js registerView overrides with live SSE + UI components."""
+    from integrations.voice.call_detail_ui import build_call_detail_layout
+    from integrations.voice.store import VoiceCallStore
+
+    calls = _list_calls()
+    picked = _pick_call(calls)
+    record = VoiceCallStore.get_call(picked["id"]) if picked.get("id") and picked["id"] != "—" else None
+    if record:
+        return build_call_detail_layout(record)
+    return aiui.layout(
+        [
+            aiui.alert(
+                "No calls yet. Start from ElevenLabs talk, GPT Realtime, or Web talk.",
+                variant="info",
+                title="Call detail",
+            ),
+        ]
+    )
+
+
+@aiui.page("web-talk", title="Web talk", icon="🎤", group="Voice", order=3)
+async def web_talk_page():
+    return aiui.layout(
+        [
+            aiui.text("Browser voice widget — client view loads from plugin.js"),
+            aiui.alert(
+                "Set VOICE_PUBLIC_API_KEY, VOICE_ASSISTANT_ID, VOICE_WEB_SDK_URL, and "
+                "VOICE_WEB_SDK_GLOBAL in .env.",
+                variant="info",
+                title="Web SDK",
+            ),
+        ]
+    )
+
+
+@aiui.page("eleven-talk", title="ElevenLabs talk", icon="🗣️", group="Voice", order=4)
+async def eleven_talk_page():
+    return aiui.layout(
+        [
+            aiui.text("Browser voice via ElevenLabs Speech Engine — loads from plugin.js"),
+            aiui.alert(
+                "Set ELEVENLABS_API_KEY, run setup_speech_engine.py after start_dev.ps1, "
+                "then click Start conversation.",
+                variant="info",
+                title="Speech Engine",
+            ),
+        ]
+    )
+
+
+@aiui.page("realtime-talk", title="GPT Realtime", icon="⚡", group="Voice", order=5)
+async def realtime_talk_page():
+    return aiui.layout(
+        [
+            aiui.text("Browser voice via OpenAI gpt-realtime-2.1-mini — loads from plugin.js"),
+            aiui.alert(
+                "Set OPENAI_API_KEY and REALTIME_MODEL=gpt-realtime-2.1-mini.",
+                variant="warning",
+                title="OpenAI Realtime",
+            ),
+        ]
+    )
+
+
+app = create_app()
+app.routes[0:0] = [
+    Route("/api/voice/calls", api_voice_create_call, methods=["POST"]),
+    Route("/api/voice/calls", api_voice_list_calls, methods=["GET"]),
+    Route("/api/voice/calls/{call_id}", api_voice_call_detail, methods=["GET"]),
+    Route("/api/voice/calls/{call_id}/ui", api_voice_call_detail_ui, methods=["GET"]),
+    Route("/api/voice/calls/{call_id}/live-transcript", api_voice_live_transcript, methods=["GET"]),
+    Route("/api/voice/config", api_voice_config_status, methods=["GET"]),
+    Route("/api/voice/doctor", api_voice_doctor, methods=["GET"]),
+    Route("/api/voice/web-config", api_voice_web_config, methods=["GET"]),
+    Route("/api/voice/speech-engine/config", api_speech_engine_config, methods=["GET"]),
+    Route("/api/voice/speech-engine/token", api_speech_engine_token, methods=["GET"]),
+    Route("/api/voice/memory/config", api_voice_memory_config, methods=["GET"]),
+    Route("/api/voice/memory/bind", api_voice_memory_bind, methods=["POST"]),
+    Route("/api/voice/memory/attach-user", api_voice_memory_attach_user, methods=["POST"]),
+    Route("/api/voice/memory/resolve", api_voice_memory_resolve, methods=["GET"]),
+    Route("/api/voice/memory/for-call", api_voice_memory_for_call, methods=["GET"]),
+    Route("/api/voice/realtime/config", api_realtime_config, methods=["GET"]),
+    Route("/api/voice/realtime/new-call", api_realtime_new_call, methods=["POST"]),
+    Route("/api/voice/realtime/session", api_realtime_session, methods=["POST"]),
+    Route("/api/voice/realtime/transcript", api_realtime_transcript, methods=["POST"]),
+    Route("/api/voice/realtime/end", api_realtime_end, methods=["POST"]),
+    Route("/webhooks/voice", webhook_voice, methods=["POST"]),
+    WebSocketRoute("/ws", speech_engine_websocket),
+]
+
+if __name__ == "__main__":
+    import uvicorn
+
+    host = os.environ.get("HOST", "127.0.0.1")
+    port = int(os.environ.get("VOICE_AGENT_PORT", "8001"))
+    uvicorn.run(app, host=host, port=port)

examples/python/voice-agent/doctor.py

@@ -0,0 +1,41 @@
+"""CLI for voice-agent stack diagnostics."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+_EXAMPLE_DIR = Path(__file__).resolve().parent
+if str(_EXAMPLE_DIR) not in sys.path:
+    sys.path.insert(0, str(_EXAMPLE_DIR))
+
+
+def _load_local_env() -> None:
+    env_path = _EXAMPLE_DIR / ".env"
+    if not env_path.is_file():
+        return
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key:
+            os.environ[key] = value
+
+
+def main() -> int:
+    _load_local_env()
+    from integrations.voice.doctor import run_voice_doctor
+
+    app_port = int(os.getenv("VOICE_AGENT_PORT", "8001"))
+    sidecar_port = int(os.getenv("SPEECH_ENGINE_SIDECAR_PORT", "8002"))
+    report = run_voice_doctor(app_port=app_port, sidecar_port=sidecar_port)
+    print(json.dumps(report, indent=2))
+    return 1 if report["summary"]["failed"] else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examples/python/voice-agent/integrations/__init__.py

@@ -0,0 +1 @@
+"""Voice agent integrations."""

examples/python/voice-agent/integrations/voice/__init__.py

@@ -0,0 +1 @@
+"""Voice telephony provider integration."""

examples/python/voice-agent/integrations/voice/agent_runner.py

@@ -0,0 +1,171 @@
+"""Run voice tool-calls through the PraisonAI agent tool registry."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Callable
+
+from integrations.voice.tools import execute_tool, register_tool
+
+_agent: Any | None = None
+_session_agents: dict[str, Any] = {}
+
+
+def _tool_name(tool: Any) -> str | None:
+    for attr in ("name", "__name__"):
+        value = getattr(tool, attr, None)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    fn = getattr(tool, "func", None) or getattr(tool, "function", None)
+    if fn is not None:
+        return _tool_name(fn)
+    return None
+
+
+def _build_voice_agent(*, session_id: str | None = None):
+    from praisonaiagents import Agent
+    from praisonaiagents.config.feature_configs import MemoryConfig
+    from praisonaiagents.escalation.loop_guard import LoopGuard, LoopGuardConfig
+
+    from integrations.voice.session_memory import memory_enabled
+    from integrations.voice.tools import echo_message, get_current_time
+
+    register_tool("get_current_time", get_current_time)
+    register_tool("echo_message", echo_message)
+
+    tools: list[Any] = [get_current_time, echo_message]
+    extra = os.getenv("VOICE_AGENT_EXTRA_TOOLS", "").strip()
+    if extra == "meeting_search":
+        try:
+            from praisonai_tools.tools.meeting_tools import search_meetings
+
+            tools.append(search_meetings)
+            register_tool("search_meetings", search_meetings)
+        except ImportError:
+            pass
+
+    memory_cfg = None
+    if memory_enabled() and session_id:
+        memory_cfg = MemoryConfig(
+            history=True,
+            session_id=session_id,
+            history_limit=int(os.getenv("VOICE_MEMORY_HISTORY_LIMIT", "20")),
+        )
+
+    agent = Agent(
+        name="Voice Assistant",
+        instructions=(
+            "You help with voice and phone agent demos. "
+            "Use tools when the caller asks for the time, wants a message echoed, "
+            "or asks about past meetings."
+        ),
+        model=os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini"),
+        tools=tools,
+        memory=memory_cfg or False,
+    )
+    max_turn_sec = float(os.getenv("VOICE_AGENT_LOOP_GUARD_MAX_SEC", "600"))
+    agent._loop_guard = LoopGuard(LoopGuardConfig(enabled=True, max_time_per_turn=max_turn_sec))
+
+    for tool in tools:
+        name = _tool_name(tool)
+        if name:
+            register_tool(name, _callable_tool(tool))
+    return agent
+
+
+def get_voice_agent(session_id: str | None = None):
+    """Lazy-load the voice assistant (optionally bound to a PraisonAI session)."""
+    global _agent
+    if session_id:
+        cached = _session_agents.get(session_id)
+        if cached is not None:
+            return cached
+        agent = _build_voice_agent(session_id=session_id)
+        _session_agents[session_id] = agent
+        return agent
+    if _agent is not None:
+        return _agent
+    _agent = _build_voice_agent()
+    return _agent
+
+
+def _callable_tool(tool: Any) -> Callable[..., Any]:
+    fn = getattr(tool, "func", None) or getattr(tool, "run", None) or tool
+    return fn  # type: ignore[return-value]
+
+
+def execute_voice_tool(
+    name: str,
+    parameters: dict[str, Any] | None,
+    *,
+    session_id: str | None = None,
+) -> str:
+    """Execute via agent tool registry, then fall back to static registry."""
+    params = parameters or {}
+    agent = get_voice_agent(session_id)
+    for tool in agent.tools or []:
+        tname = _tool_name(tool)
+        if tname != name:
+            continue
+        fn = _callable_tool(tool)
+        try:
+            result = fn(**params)
+        except TypeError:
+            try:
+                result = fn(params)
+            except Exception as exc:  # noqa: BLE001
+                return json.dumps({"error": str(exc)})
+        except Exception as exc:  # noqa: BLE001
+            return json.dumps({"error": str(exc)})
+        if isinstance(result, str):
+            return result
+        return json.dumps(result)
+    return execute_tool(name, params)
+
+
+def list_registered_tool_names() -> list[str]:
+    agent = get_voice_agent()
+    names: list[str] = []
+    for tool in agent.tools or []:
+        tname = _tool_name(tool)
+        if tname:
+            names.append(tname)
+    return names
+
+
+def build_assistant_request_response(settings: Any) -> dict[str, Any]:
+    """Return provider assistant config for dynamic assistant-request events."""
+    if settings.default_assistant_id and not os.getenv("VOICE_DYNAMIC_ASSISTANT", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    ):
+        return {"assistantId": settings.default_assistant_id}
+
+    tool_names = list_registered_tool_names()
+    assistant: dict[str, Any] = {
+        "name": "Praison Voice Assistant",
+        "firstMessage": os.getenv("VOICE_FIRST_MESSAGE", "Hello! How can I help you today?"),
+        "model": {
+            "provider": os.getenv("VOICE_MODEL_PROVIDER", "openai"),
+            "model": os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini"),
+            "messages": [
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a helpful voice assistant. When asked for the time, call get_current_time. "
+                        "When asked to repeat or echo text, call echo_message with the message parameter. "
+                        "Available tools: "
+                        + ", ".join(tool_names or ["get_current_time", "echo_message"])
+                    ),
+                }
+            ],
+        },
+    }
+    if settings.webhook_url and settings.server_url_secret:
+        assistant["server"] = {
+            "url": settings.webhook_url,
+            "headers": {"X-Voice-Webhook-Secret": settings.server_url_secret},
+        }
+    return {"assistant": assistant}

examples/python/voice-agent/integrations/voice/call_detail_ui.py

@@ -0,0 +1,57 @@
+"""Build PraisonAIUI components for the call detail page."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import praisonaiui as aiui
+
+
+def build_call_detail_layout(record: dict[str, Any]) -> dict[str, Any]:
+    """Return dashboard component tree for call detail (code_block + metadata)."""
+    from integrations.voice.call_finalize import analytics_for_record
+
+    metadata = record.get("metadata") or {}
+    analytics = analytics_for_record(record)
+    transcript = (record.get("transcript") or "").strip() or "(empty — waiting for speech…)"
+    summary = (record.get("summary") or "").strip() or "(not available yet)"
+    status = str(record.get("status") or "unknown")
+
+    kv_items: list[dict[str, str]] = [
+        {"label": "Call ID", "value": str(record.get("call_id") or "—")},
+        {"label": "Status", "value": status},
+        {"label": "Customer", "value": str(record.get("customer_number") or "—")},
+    ]
+    if metadata.get("user_id"):
+        kv_items.append({"label": "User ID", "value": str(metadata["user_id"])})
+    if metadata.get("praison_session_id"):
+        kv_items.append({"label": "Memory session", "value": str(metadata["praison_session_id"])})
+    kv_items.append({"label": "Duration", "value": str(analytics.get("duration") or "—")})
+    kv_items.append({"label": "Turns", "value": str(analytics.get("turn_count") or 0)})
+
+    return aiui.layout(
+        [
+            aiui.text("Live voice call transcript and metadata"),
+            aiui.badge(status, variant="default"),
+            aiui.definition_list(kv_items, title="Call metadata"),
+            aiui.alert(
+                "Transcript updates live via SSE. Final lines use PraisonAIUI code blocks.",
+                variant="info",
+                title="Live feed",
+            ),
+            aiui.tabs(
+                [
+                    {
+                        "label": "Transcript",
+                        "children": [
+                            aiui.code_block(transcript, language="text"),
+                        ],
+                    },
+                    {
+                        "label": "Summary",
+                        "children": [aiui.text(summary)],
+                    },
+                ]
+            ),
+        ]
+    )

examples/python/voice-agent/integrations/voice/call_finalize.py

@@ -0,0 +1,126 @@
+"""End-of-call summary, analytics, and chat bridge on session close."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from datetime import datetime, timezone
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def count_turns(transcript: str) -> int:
+    """Count user/agent lines in stored transcript."""
+    turns = 0
+    for line in (transcript or "").splitlines():
+        text = line.strip()
+        if text.startswith("user:") or text.startswith("agent:") or text.startswith("assistant:"):
+            turns += 1
+    return turns
+
+
+def duration_seconds(created_at: str | None, ended_at: str | None) -> int | None:
+    if not created_at or not ended_at:
+        return None
+    try:
+        start = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+        end = datetime.fromisoformat(ended_at.replace("Z", "+00:00"))
+        return max(0, int((end - start).total_seconds()))
+    except ValueError:
+        return None
+
+
+def format_duration(seconds: int | None) -> str:
+    if seconds is None:
+        return "—"
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, rem = divmod(seconds, 60)
+    return f"{minutes}m {rem}s"
+
+
+async def generate_call_summary(transcript: str) -> str:
+    """One-sentence LLM summary for call detail + chat sidebar."""
+    text = (transcript or "").strip()
+    if not text:
+        return "Empty call — no conversation captured."
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not api_key:
+        lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+        preview = " · ".join(lines[:3])
+        return f"Call covered: {preview[:240]}"
+
+    from openai import AsyncOpenAI
+
+    client = AsyncOpenAI(api_key=api_key)
+    try:
+        response = await asyncio.wait_for(
+            client.chat.completions.create(
+                model=os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini"),
+                messages=[
+                    {
+                        "role": "system",
+                        "content": (
+                            "Summarize this voice call in one concise sentence for a dashboard. "
+                            "Mention main topic and outcome only."
+                        ),
+                    },
+                    {"role": "user", "content": text[:6000]},
+                ],
+                max_tokens=80,
+            ),
+            timeout=15.0,
+        )
+        summary = (response.choices[0].message.content or "").strip()
+        return summary or "Call completed."
+    except Exception:  # noqa: BLE001
+        logger.exception("Call summary generation failed")
+        return "Call completed — summary unavailable."
+
+
+async def finalize_call(call_id: str, *, status: str) -> None:
+    """Persist analytics, optional summary, and notify chat bridge."""
+    from integrations.voice.chat_bridge import enqueue_call_summary
+    from integrations.voice.store import VoiceCallStore
+
+    record = VoiceCallStore.get_call(call_id)
+    if not record:
+        return
+
+    transcript = (record.get("transcript") or "").strip()
+    metadata: dict[str, Any] = dict(record.get("metadata") or {})
+    ended_at = datetime.now(timezone.utc).isoformat()
+    metadata["ended_at"] = ended_at
+    metadata["turn_count"] = count_turns(transcript)
+    metadata["duration_sec"] = duration_seconds(record.get("created_at"), ended_at)
+
+    summary = (record.get("summary") or "").strip()
+    if not summary and transcript:
+        summary = await generate_call_summary(transcript)
+
+    VoiceCallStore.upsert_call(
+        call_id,
+        status=status,
+        summary=summary or None,
+        metadata=metadata,
+    )
+    enqueue_call_summary(call_id, summary or "(no summary)", status)
+
+
+def analytics_for_record(record: dict[str, Any]) -> dict[str, Any]:
+    """Derived analytics for API + dashboard tables."""
+    metadata = record.get("metadata") or {}
+    transcript = record.get("transcript") or ""
+    turns = metadata.get("turn_count")
+    if turns is None:
+        turns = count_turns(transcript)
+    duration_sec = metadata.get("duration_sec")
+    if duration_sec is None:
+        duration_sec = duration_seconds(record.get("created_at"), metadata.get("ended_at"))
+    return {
+        "turn_count": turns,
+        "duration_sec": duration_sec,
+        "duration": format_duration(duration_sec if isinstance(duration_sec, int) else None),
+    }

examples/python/voice-agent/integrations/voice/chat_bridge.py

@@ -0,0 +1,150 @@
+"""Bridge voice call events into Chat UI sessions (sidebar + history)."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import queue
+import threading
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_bridge_queue: queue.Queue[dict[str, Any]] = queue.Queue(maxsize=512)
+_worker_lock = threading.Lock()
+_worker_task: asyncio.Task[None] | None = None
+
+
+def voice_session_id(call_id: str) -> str:
+    return f"voice-{call_id}"
+
+
+def enqueue_transcript(call_id: str, role: str, text: str, *, final: bool) -> None:
+    if not call_id or not text.strip():
+        return
+    _enqueue(
+        {
+            "kind": "transcript",
+            "call_id": call_id,
+            "role": role,
+            "text": text.strip(),
+            "final": final,
+        }
+    )
+
+
+def enqueue_call_summary(call_id: str, summary: str, status: str) -> None:
+    if not call_id:
+        return
+    _enqueue(
+        {
+            "kind": "summary",
+            "call_id": call_id,
+            "summary": summary.strip(),
+            "status": status,
+        }
+    )
+
+
+def _enqueue(item: dict[str, Any]) -> None:
+    try:
+        _bridge_queue.put_nowait(item)
+    except queue.Full:
+        logger.warning("Voice chat bridge queue full; dropping event")
+
+
+async def _ensure_session(call_id: str) -> str:
+    from praisonaiui.server import _datastore
+
+    session_id = voice_session_id(call_id)
+    existing = await _datastore.get_session(session_id)
+    if existing is None:
+        await _datastore.create_session(session_id)
+        await _datastore.update_session(
+            session_id,
+            platform="voice",
+            icon="📞",
+            title=f"📞 Call {call_id[:8]}",
+        )
+    return session_id
+
+
+async def _process_item(item: dict[str, Any]) -> None:
+    from praisonaiui.features.chat import get_chat_manager
+    from praisonaiui.server import _datastore
+
+    call_id = str(item.get("call_id") or "")
+    if not call_id:
+        return
+    session_id = await _ensure_session(call_id)
+    mgr = get_chat_manager()
+
+    if item.get("kind") == "transcript":
+        role = str(item.get("role") or "unknown")
+        text = str(item.get("text") or "")
+        final = bool(item.get("final"))
+        if not final:
+            await mgr.broadcast(
+                session_id,
+                {
+                    "type": "voice_transcript_partial",
+                    "session_id": session_id,
+                    "call_id": call_id,
+                    "role": role,
+                    "content": text,
+                },
+            )
+            return
+        content = f"**{role}:** {text}"
+        await _datastore.add_message(
+            session_id,
+            {"role": "user" if role == "user" else "assistant", "content": content, "platform": "voice"},
+        )
+        await mgr.broadcast(
+            session_id,
+            {
+                "type": "voice_transcript",
+                "session_id": session_id,
+                "call_id": call_id,
+                "role": role,
+                "content": text,
+            },
+        )
+        return
+
+    if item.get("kind") == "summary":
+        summary = str(item.get("summary") or "(call ended)")
+        status = str(item.get("status") or "ended")
+        content = f"**Call {status}**\n\n{summary}"
+        await _datastore.add_message(session_id, {"role": "assistant", "content": content, "platform": "voice"})
+        await mgr.broadcast(
+            session_id,
+            {
+                "type": "voice_call_ended",
+                "session_id": session_id,
+                "call_id": call_id,
+                "status": status,
+                "summary": summary,
+            },
+        )
+
+
+async def run_chat_bridge_worker() -> None:
+    while True:
+        try:
+            item = await asyncio.to_thread(_bridge_queue.get, True, 1.0)
+        except queue.Empty:
+            continue
+        try:
+            await _process_item(item)
+        except Exception as exc:  # noqa: BLE001
+            logger.debug("Voice chat bridge error: %s", exc)
+
+
+def start_chat_bridge_worker() -> None:
+    global _worker_task
+    with _worker_lock:
+        if _worker_task is not None and not _worker_task.done():
+            return
+        loop = asyncio.get_running_loop()
+        _worker_task = loop.create_task(run_chat_bridge_worker())

examples/python/voice-agent/integrations/voice/client.py

@@ -0,0 +1,76 @@
+"""Minimal voice provider REST client."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from integrations.voice.config import VoiceSettings
+
+logger = logging.getLogger(__name__)
+
+
+class VoiceAPIError(RuntimeError):
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(detail)
+        self.status_code = status_code
+        self.detail = detail
+
+
+class VoiceClient:
+    """HTTP client for voice provider calls and assistants."""
+
+    def __init__(self, settings: VoiceSettings):
+        self._settings = settings
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self._settings.api_key}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        import httpx  # lazy: optional dependency for the example (pip install httpx)
+
+        url = f"{self._settings.api_base.rstrip('/')}{path}"
+        with httpx.Client(timeout=30.0) as client:
+            response = client.request(method, url, headers=self._headers(), json=json_body)
+        if response.status_code >= 400:
+            raise VoiceAPIError(response.status_code, response.text[:500] or response.reason_phrase)
+        if not response.content:
+            return {}
+        data = response.json()
+        return data if isinstance(data, dict) else {"data": data}
+
+    def create_call(
+        self,
+        *,
+        customer_number: str,
+        assistant_id: str | None = None,
+        phone_number_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        assistant_id = assistant_id or self._settings.default_assistant_id
+        phone_number_id = phone_number_id or self._settings.default_phone_number_id
+        if not assistant_id:
+            raise VoiceAPIError(0, "assistant_id is required (set VOICE_ASSISTANT_ID or pass explicitly)")
+        if not phone_number_id:
+            raise VoiceAPIError(0, "phone_number_id is required (set VOICE_PHONE_NUMBER_ID or pass explicitly)")
+        body: dict[str, Any] = {
+            "assistantId": assistant_id,
+            "phoneNumberId": phone_number_id,
+            "customer": {"number": customer_number},
+        }
+        if metadata:
+            body["metadata"] = metadata
+        return self._request("POST", "/call", json_body=body)
+
+    def get_call(self, call_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/call/{call_id}")

examples/python/voice-agent/integrations/voice/config.py

@@ -0,0 +1,74 @@
+"""Voice provider configuration loaded from environment."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class VoiceConfigError(ValueError):
+    """Missing or invalid voice provider configuration."""
+
+
+@dataclass(frozen=True)
+class VoiceSettings:
+    api_key: str
+    server_url_secret: str | None
+    public_api_base_url: str | None
+    default_assistant_id: str | None
+    default_phone_number_id: str | None
+    public_api_key: str | None
+    api_base: str
+
+    @property
+    def webhook_url(self) -> str | None:
+        if not self.public_api_base_url:
+            return None
+        return f"{self.public_api_base_url.rstrip('/')}/webhooks/voice"
+
+    @property
+    def configured(self) -> bool:
+        return bool(self.api_key and self.api_base)
+
+
+def _read_dotenv(name: str) -> str | None:
+    root = Path(__file__).resolve().parents[2]
+    env_path = root / ".env"
+    if not env_path.is_file():
+        return None
+    prefix = f"{name}="
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if line.startswith(prefix):
+            return line[len(prefix) :].strip() or None
+    return None
+
+
+def _env(name: str) -> str:
+    return os.getenv(name, "").strip() or (_read_dotenv(name) or "")
+
+
+def load_voice_settings(*, require_key: bool = True) -> VoiceSettings:
+    api_key = _env("VOICE_PRIVATE_API_KEY") or _env("VOICE_API_KEY")
+    api_base = _env("VOICE_API_BASE")
+    if require_key and not api_key:
+        raise VoiceConfigError("VOICE_PRIVATE_API_KEY (or VOICE_API_KEY) is required")
+    if require_key and not api_base:
+        raise VoiceConfigError("VOICE_API_BASE is required")
+    return VoiceSettings(
+        api_key=api_key,
+        server_url_secret=_env("VOICE_SERVER_URL_SECRET") or None,
+        public_api_base_url=_env("PUBLIC_API_BASE_URL") or None,
+        default_assistant_id=_env("VOICE_ASSISTANT_ID") or None,
+        default_phone_number_id=_env("VOICE_PHONE_NUMBER_ID") or None,
+        public_api_key=_env("VOICE_PUBLIC_API_KEY") or None,
+        api_base=api_base.rstrip("/"),
+    )
+
+
+def get_web_sdk_settings() -> tuple[str, str]:
+    """Browser SDK URL + legacy global name (global unused for ESM imports)."""
+    url = _env("VOICE_WEB_SDK_URL") or "https://esm.sh/@vapi-ai/[email protected]"
+    global_name = _env("VOICE_WEB_SDK_GLOBAL") or "Vapi"
+    return url, global_name

examples/python/voice-agent/integrations/voice/doctor.py

@@ -0,0 +1,119 @@
+"""Voice agent stack diagnostics (OpenClaw-style doctor)."""
+
+from __future__ import annotations
+
+import os
+import socket
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+
+def _tcp_open(host: str, port: int, timeout: float = 2.0) -> bool:
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except OSError:
+        return False
+
+
+_MCP_PROBE_TIMEOUT_SEC = 2.0
+
+
+def _is_slow_mcp_probe(detail: str) -> bool:
+    lowered = detail.lower()
+    return any(token in lowered for token in ("timed out", "timeout", "temporarily unavailable"))
+
+
+def _mcp_servers_probe(app_port: int) -> tuple[str, str]:
+    """Probe MCP list endpoint; slow stdio connect must not fail the whole doctor run."""
+    status, detail = _http_status(
+        f"http://127.0.0.1:{app_port}/api/mcp/servers",
+        timeout=_MCP_PROBE_TIMEOUT_SEC,
+    )
+    if status == "fail" and _is_slow_mcp_probe(detail):
+        return "warn", detail
+    return status, detail
+
+
+def _http_status(url: str, timeout: float = 5.0) -> tuple[str, str]:
+    try:
+        req = Request(url, headers={"User-Agent": "praisonai-voice-doctor"})
+        with urlopen(req, timeout=timeout) as resp:
+            code = resp.getcode()
+            if 200 <= code < 500:
+                return "pass", f"HTTP {code}"
+            return "warn", f"HTTP {code}"
+    except HTTPError as exc:
+        if 200 <= exc.code < 500:
+            return "pass", f"HTTP {exc.code}"
+        return "fail", f"HTTP {exc.code}"
+    except URLError as exc:
+        return "fail", str(exc.reason)
+    except Exception as exc:  # noqa: BLE001
+        return "fail", str(exc)
+
+
+def _env_check(name: str, *, required: bool = False) -> dict[str, Any]:
+    value = os.getenv(name, "").strip()
+    if value:
+        masked = value[:4] + "…" if len(value) > 8 else "set"
+        return {"name": name, "status": "pass", "detail": masked}
+    if required:
+        return {"name": name, "status": "fail", "detail": "missing"}
+    return {"name": name, "status": "warn", "detail": "not set"}
+
+
+def run_voice_doctor(*, app_port: int = 8001, sidecar_port: int = 8002) -> dict[str, Any]:
+    """Run local voice-agent health checks."""
+    checks: list[dict[str, Any]] = []
+
+    checks.append(_env_check("OPENAI_API_KEY", required=True))
+    checks.append(_env_check("ELEVENLABS_API_KEY"))
+    checks.append(_env_check("SPEECH_ENGINE_ID"))
+    checks.append(_env_check("SPEECH_ENGINE_PUBLIC_URL"))
+    checks.append(_env_check("PUBLIC_API_BASE_URL"))
+    checks.append(_env_check("VOICE_PRIVATE_API_KEY"))
+
+    if _tcp_open("127.0.0.1", app_port):
+        checks.append({"name": f"App port {app_port}", "status": "pass", "detail": "listening"})
+        status, detail = _http_status(f"http://127.0.0.1:{app_port}/api/voice/config")
+        checks.append({"name": "Voice config API", "status": status, "detail": detail})
+        status, detail = _http_status(f"http://127.0.0.1:{app_port}/api/voice/speech-engine/config")
+        checks.append({"name": "Speech Engine config", "status": status, "detail": detail})
+        status, detail = _http_status(f"http://127.0.0.1:{app_port}/api/voice/realtime/config")
+        checks.append({"name": "GPT Realtime config", "status": status, "detail": detail})
+        status, detail = _mcp_servers_probe(app_port)
+        checks.append({"name": "MCP servers API", "status": status, "detail": detail})
+    else:
+        checks.append(
+            {
+                "name": f"App port {app_port}",
+                "status": "fail",
+                "detail": "not listening — run .\\start_dev.ps1",
+            }
+        )
+
+    if _tcp_open("127.0.0.1", sidecar_port):
+        checks.append({"name": f"Speech sidecar {sidecar_port}", "status": "pass", "detail": "listening"})
+    else:
+        checks.append(
+            {
+                "name": f"Speech sidecar {sidecar_port}",
+                "status": "warn",
+                "detail": "not listening (ElevenLabs path needs sidecar)",
+            }
+        )
+
+    speech_url = os.getenv("SPEECH_ENGINE_PUBLIC_URL", "").strip().rstrip("/")
+    if speech_url:
+        status, detail = _http_status(speech_url)
+        checks.append({"name": "Speech Engine tunnel", "status": status, "detail": detail})
+
+    passed = sum(1 for c in checks if c["status"] == "pass")
+    warnings = sum(1 for c in checks if c["status"] == "warn")
+    failed = sum(1 for c in checks if c["status"] == "fail")
+    return {
+        "checks": checks,
+        "summary": {"passed": passed, "warnings": warnings, "failed": failed},
+    }

examples/python/voice-agent/integrations/voice/live.py

@@ -0,0 +1,51 @@
+"""Live transcript pub/sub for voice calls (SSE)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import queue
+import threading
+from collections import defaultdict
+from typing import Any, AsyncIterator
+
+
+class TranscriptHub:
+    """Thread-safe hub broadcasting transcript events per call_id."""
+
+    def __init__(self) -> None:
+        self._queues: dict[str, list[queue.Queue[dict[str, Any]]]] = defaultdict(list)
+        self._lock = threading.Lock()
+
+    def publish(self, call_id: str, event: dict[str, Any]) -> None:
+        if not call_id:
+            return
+        with self._lock:
+            queues = list(self._queues.get(call_id, []))
+        for sub in queues:
+            try:
+                sub.put_nowait(event)
+            except queue.Full:
+                pass
+
+    async def subscribe(self, call_id: str) -> AsyncIterator[dict[str, Any]]:
+        sub: queue.Queue[dict[str, Any]] = queue.Queue(maxsize=256)
+        with self._lock:
+            self._queues[call_id].append(sub)
+        try:
+            while True:
+                try:
+                    event = await asyncio.to_thread(sub.get, True, 1.0)
+                except queue.Empty:
+                    continue
+                yield event
+        finally:
+            with self._lock:
+                if call_id in self._queues and sub in self._queues[call_id]:
+                    self._queues[call_id].remove(sub)
+
+    def snapshot_sse(self, event: dict[str, Any]) -> str:
+        return f"data: {json.dumps(event, ensure_ascii=False)}\n\n"
+
+
+transcript_hub = TranscriptHub()

examples/python/voice-agent/integrations/voice/processor.py

@@ -0,0 +1,180 @@
+"""Process voice provider webhook events."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from integrations.voice.agent_runner import build_assistant_request_response, execute_voice_tool
+from integrations.voice.config import VoiceSettings
+from integrations.voice.live import transcript_hub
+from integrations.voice.store import VoiceCallStore, webhook_event_key
+
+logger = logging.getLogger(__name__)
+
+
+def _message(payload: dict[str, Any]) -> dict[str, Any]:
+    msg = payload.get("message")
+    return msg if isinstance(msg, dict) else payload
+
+
+def _call_id(payload: dict[str, Any]) -> str | None:
+    msg = _message(payload)
+    call = msg.get("call")
+    if isinstance(call, dict) and call.get("id"):
+        return str(call["id"])
+    return None
+
+
+def _customer_number(payload: dict[str, Any]) -> str | None:
+    msg = _message(payload)
+    call = msg.get("call") if isinstance(msg.get("call"), dict) else {}
+    customer = call.get("customer") if isinstance(call, dict) else {}
+    if isinstance(customer, dict) and customer.get("number"):
+        return str(customer["number"])
+    return None
+
+
+def _tool_parameters(item: dict[str, Any]) -> dict[str, Any]:
+    """Extract tool params from provider payloads (parameters or arguments)."""
+    for key in ("parameters", "arguments"):
+        value = item.get(key)
+        if isinstance(value, dict):
+            return value
+    fn = item.get("function")
+    if isinstance(fn, dict):
+        for key in ("parameters", "arguments"):
+            value = fn.get(key)
+            if isinstance(value, dict):
+                return value
+    return {}
+
+
+def _spoken_tool_result(raw: str) -> str:
+    """Return plain spoken text for the voice pipeline (no newlines)."""
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            spoken = data.get("spoken") or data.get("message")
+            if spoken:
+                return str(spoken).replace("\n", " ").strip()
+    except json.JSONDecodeError:
+        pass
+    return str(raw).replace("\n", " ").strip()
+
+
+def process_voice_webhook(
+    event_type: str, payload: dict[str, Any], *, settings: VoiceSettings
+) -> dict[str, Any] | None:
+    """Handle a verified provider webhook POST. Returns response body when required."""
+    event_key = webhook_event_key(event_type, payload)
+    if event_type not in ("tool-calls", "assistant-request", "transfer-destination-request", "knowledge-base-request"):
+        if not VoiceCallStore.mark_event_processed(event_key, event_type):
+            logger.info("Skipping duplicate voice event %s", event_type)
+            return None
+
+    msg = _message(payload)
+    call_id = _call_id(payload)
+
+    if event_type == "assistant-request":
+        return build_assistant_request_response(settings)
+
+    if event_type == "tool-calls" and call_id:
+        tool_calls = msg.get("toolCallList") or []
+        if not tool_calls and isinstance(msg.get("toolWithToolCallList"), list):
+            for entry in msg["toolWithToolCallList"]:
+                if not isinstance(entry, dict):
+                    continue
+                tool_call = entry.get("toolCall")
+                if isinstance(tool_call, dict):
+                    tool_calls.append(
+                        {
+                            "id": tool_call.get("id"),
+                            "name": entry.get("name") or (tool_call.get("function") or {}).get("name"),
+                            "parameters": _tool_parameters(tool_call),
+                            "arguments": _tool_parameters(tool_call),
+                        }
+                    )
+        results = []
+        for item in tool_calls:
+            if not isinstance(item, dict):
+                continue
+            tool_call_id = str(item.get("id") or "")
+            name = str(item.get("name") or "")
+            if not name:
+                fn = item.get("function")
+                if isinstance(fn, dict):
+                    name = str(fn.get("name") or "")
+            params = _tool_parameters(item)
+            result = _spoken_tool_result(execute_voice_tool(name, params))
+            results.append({"toolCallId": tool_call_id, "name": name, "result": result})
+        VoiceCallStore.upsert_call(call_id, status="in-progress", customer_number=_customer_number(payload))
+        return {"results": results}
+
+    if event_type == "status-update" and call_id:
+        status = str(msg.get("status") or "unknown")
+        VoiceCallStore.upsert_call(call_id, status=status, customer_number=_customer_number(payload))
+        return None
+
+    if event_type == "transcript" and call_id:
+        role = str(msg.get("role") or "unknown")
+        text = str(msg.get("transcript") or "").strip()
+        kind = str(msg.get("transcriptType") or "final")
+        if text:
+            line = f"{role}: {text}"
+            if kind == "final":
+                VoiceCallStore.append_transcript_line(call_id, line)
+            else:
+                VoiceCallStore.upsert_call(
+                    call_id,
+                    status="in-progress",
+                    customer_number=_customer_number(payload),
+                    metadata={"partial_transcript": line},
+                )
+            transcript_hub.publish(
+                call_id,
+                {"type": "transcript", "role": role, "text": text, "transcriptType": kind},
+            )
+            from integrations.voice.chat_bridge import enqueue_transcript
+
+            enqueue_transcript(call_id, role, text, final=kind == "final")
+        return None
+
+    if event_type == "end-of-call-report" and call_id:
+        artifact = msg.get("artifact") if isinstance(msg.get("artifact"), dict) else {}
+        transcript = artifact.get("transcript") if isinstance(artifact, dict) else None
+        summary = str(msg.get("summary") or "")
+        ended = str(msg.get("endedReason") or "ended")
+        VoiceCallStore.upsert_call(
+            call_id,
+            status=f"ended ({ended})",
+            customer_number=_customer_number(payload),
+            transcript=str(transcript) if transcript else None,
+            summary=summary or None,
+            metadata={"artifact": artifact},
+        )
+        from integrations.voice.call_finalize import finalize_call
+
+        asyncio.run(finalize_call(call_id, status=f"ended ({ended})"))
+        return None
+
+    if event_type == "conversation-update" and call_id:
+        messages = msg.get("messages") or []
+        lines = []
+        for item in messages:
+            if not isinstance(item, dict):
+                continue
+            role = item.get("role") or "unknown"
+            text = item.get("message") or item.get("content") or ""
+            if text:
+                lines.append(f"{role}: {text}")
+        if lines:
+            VoiceCallStore.upsert_call(
+                call_id, transcript="\n".join(lines), customer_number=_customer_number(payload)
+            )
+        return None
+
+    logger.debug("Unhandled voice event %s: %s", event_type, json.dumps(payload)[:300])
+    return None

examples/python/voice-agent/integrations/voice/realtime.py

@@ -0,0 +1,180 @@
+"""OpenAI Realtime API — browser WebRTC voice (gpt-realtime-2.1-mini)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+OPENAI_REALTIME_CALLS_URL = "https://api.openai.com/v1/realtime/calls"
+OPENAI_CLIENT_SECRETS_URL = "https://api.openai.com/v1/realtime/client_secrets"
+
+
+class RealtimeConfigError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class RealtimeSettings:
+    api_key: str
+    model: str
+    voice: str
+    reasoning_effort: str
+    instructions: str
+    first_message: str | None
+
+
+def load_realtime_settings() -> RealtimeSettings:
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not api_key:
+        raise RealtimeConfigError("Set OPENAI_API_KEY in .env")
+    first_message = os.getenv("REALTIME_FIRST_MESSAGE", "").strip() or None
+    return RealtimeSettings(
+        api_key=api_key,
+        model=os.getenv("REALTIME_MODEL", "gpt-realtime-2.1-mini").strip(),
+        voice=os.getenv("REALTIME_VOICE", "marin").strip(),
+        reasoning_effort=os.getenv("REALTIME_REASONING_EFFORT", "low").strip(),
+        instructions=os.getenv(
+            "REALTIME_INSTRUCTIONS",
+            "You are a helpful voice assistant for PraisonAI demos. "
+            "Keep every reply to one or two short sentences.",
+        ).strip(),
+        first_message=first_message,
+    )
+
+
+def realtime_enabled() -> bool:
+    try:
+        load_realtime_settings()
+    except RealtimeConfigError:
+        return False
+    return True
+
+
+def build_session_config(
+    settings: RealtimeSettings | None = None,
+    *,
+    praison_session_id: str | None = None,
+) -> dict[str, Any]:
+    from integrations.voice.session_memory import instructions_with_memory
+
+    cfg = settings or load_realtime_settings()
+    session: dict[str, Any] = {
+        "type": "realtime",
+        "model": cfg.model,
+        "instructions": instructions_with_memory(cfg.instructions, session_id=praison_session_id),
+        "audio": {"output": {"voice": cfg.voice}},
+        # Required for user transcript events in the browser data channel.
+        "input_audio_transcription": {
+            "model": os.getenv("REALTIME_TRANSCRIBE_MODEL", "gpt-4o-mini-transcribe"),
+        },
+    }
+    if cfg.reasoning_effort:
+        session["reasoning"] = {"effort": cfg.reasoning_effort}
+    return session
+
+
+def new_call_id() -> str:
+    return f"rt-{uuid.uuid4().hex[:12]}"
+
+
+async def create_webrtc_session(sdp_offer: str, *, call_id: str | None = None) -> str:
+    """Relay browser SDP to OpenAI unified Realtime calls endpoint."""
+    from integrations.voice.session_memory import resolve_praison_session_id
+
+    settings = load_realtime_settings()
+    praison_session_id = resolve_praison_session_id(call_id)
+    session_json = json.dumps(build_session_config(settings, praison_session_id=praison_session_id))
+    files = {
+        "sdp": (None, sdp_offer, "application/sdp"),
+        "session": (None, session_json, "application/json"),
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(
+            OPENAI_REALTIME_CALLS_URL,
+            headers={"Authorization": f"Bearer {settings.api_key}"},
+            files=files,
+        )
+    if response.status_code >= 400:
+        detail = response.text[:500]
+        logger.error("OpenAI Realtime session failed (%s): %s", response.status_code, detail)
+        raise RealtimeConfigError(f"OpenAI Realtime session failed: HTTP {response.status_code}")
+    return response.text
+
+
+async def mint_client_secret() -> str:
+    """Mint ephemeral key (alternative to unified SDP relay)."""
+    settings = load_realtime_settings()
+    payload = {"session": build_session_config(settings)}
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(
+            OPENAI_CLIENT_SECRETS_URL,
+            headers={
+                "Authorization": f"Bearer {settings.api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+    if response.status_code >= 400:
+        detail = response.text[:500]
+        raise RealtimeConfigError(f"OpenAI client secret failed: HTTP {response.status_code} — {detail}")
+    data = response.json()
+    token = data.get("value") or data.get("client_secret", {}).get("value")
+    if not token:
+        raise RealtimeConfigError("OpenAI client secret response missing value")
+    return str(token)
+
+
+def persist_transcript_line(call_id: str, role: str, text: str) -> None:
+    from integrations.voice.live import transcript_hub
+    from integrations.voice.store import VoiceCallStore
+
+    text = text.strip()
+    if not call_id or not text:
+        return
+    record = VoiceCallStore.get_call(call_id) or {}
+    prefix = f"{role}: {text}"
+    existing = (record.get("transcript") or "").strip()
+    merged = f"{existing}\n{prefix}".strip() if existing else prefix
+    VoiceCallStore.upsert_call(
+        call_id,
+        status=record.get("status") or "in-progress",
+        customer_number="web-openai-realtime",
+        transcript=merged,
+    )
+    transcript_hub.publish(
+        call_id,
+        {
+            "type": "transcript",
+            "role": role,
+            "transcriptType": "final",
+            "text": text,
+        },
+    )
+
+
+def mark_session_started(call_id: str) -> None:
+    from integrations.voice.store import VoiceCallStore
+
+    VoiceCallStore.upsert_call(
+        call_id,
+        status="in-progress",
+        customer_number="web-openai-realtime",
+    )
+
+
+def mark_session_ended(call_id: str) -> None:
+    from integrations.voice.store import VoiceCallStore
+
+    VoiceCallStore.upsert_call(
+        call_id,
+        status="ended (customer-ended-call)",
+        customer_number="web-openai-realtime",
+    )

examples/python/voice-agent/integrations/voice/session_memory.py

@@ -0,0 +1,251 @@
+"""Cross-call voice memory via PraisonAI session reload by stable user ID."""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_CALL_USER: dict[str, str] = {}
+
+
+def memory_enabled() -> bool:
+    return os.getenv("VOICE_MEMORY_ENABLED", "true").lower() in ("1", "true", "yes")
+
+
+def voice_user_session_id(user_id: str) -> str:
+    clean = str(user_id or "").strip()
+    if not clean:
+        raise ValueError("user_id required")
+    return f"voice-user-{clean}"
+
+
+def attach_pending_user(user_id: str) -> None:
+    from integrations.voice.store import VoiceCallStore
+
+    clean = str(user_id or "").strip()
+    if clean:
+        VoiceCallStore.set_pending_user(clean)
+
+
+def consume_pending_user() -> str | None:
+    from integrations.voice.store import VoiceCallStore
+
+    return VoiceCallStore.consume_pending_user()
+
+
+def bind_call_user(call_id: str, user_id: str) -> str:
+    """Associate a provider call/conversation id with a stable browser user id."""
+    from integrations.voice.store import VoiceCallStore
+
+    call_id = str(call_id or "").strip()
+    user_id = str(user_id or "").strip()
+    if not call_id or not user_id:
+        raise ValueError("call_id and user_id required")
+    session_id = voice_user_session_id(user_id)
+    _CALL_USER[call_id] = user_id
+    VoiceCallStore.upsert_call(
+        call_id,
+        metadata={"user_id": user_id, "praison_session_id": session_id},
+    )
+    return session_id
+
+
+def resolve_call_user(call_id: str | None) -> str | None:
+    if not call_id:
+        return None
+    if call_id in _CALL_USER:
+        return _CALL_USER[call_id]
+    from integrations.voice.store import VoiceCallStore
+
+    record = VoiceCallStore.get_call(call_id)
+    if not record:
+        return None
+    user_id = (record.get("metadata") or {}).get("user_id")
+    if user_id:
+        _CALL_USER[call_id] = str(user_id)
+    return str(user_id) if user_id else None
+
+
+def resolve_praison_session_id(call_id: str | None) -> str | None:
+    user_id = resolve_call_user(call_id)
+    if not user_id:
+        return None
+    return voice_user_session_id(user_id)
+
+
+def _history_limit() -> int:
+    try:
+        return max(1, int(os.getenv("VOICE_MEMORY_HISTORY_LIMIT", "20")))
+    except ValueError:
+        return 20
+
+
+def load_session_history(session_id: str) -> list[dict[str, str]]:
+    """Load prior turns from PraisonAI DefaultSessionStore."""
+    try:
+        from praisonaiagents.session.store import DefaultSessionStore
+
+        store = DefaultSessionStore()
+        return store.get_chat_history(session_id, max_messages=_history_limit())
+    except Exception:  # noqa: BLE001
+        logger.debug("Failed to load session history for %s", session_id, exc_info=True)
+        return []
+
+
+def append_session_turn(session_id: str, role: str, content: str) -> None:
+    """Persist one voice turn into the PraisonAI session folder."""
+    text = str(content or "").strip()
+    if not session_id or not text:
+        return
+    try:
+        from praisonaiagents.session.store import DefaultSessionStore
+
+        store = DefaultSessionStore()
+        if role == "user":
+            store.add_user_message(session_id, text, metadata={"platform": "voice"})
+        else:
+            store.add_assistant_message(session_id, text, metadata={"platform": "voice"})
+    except Exception:  # noqa: BLE001
+        logger.debug("Failed to append session turn for %s", session_id, exc_info=True)
+
+
+async def ensure_ui_session(session_id: str, *, user_id: str | None = None, call_id: str | None = None) -> None:
+    """Ensure PraisonAIUI datastore session exists for sidebar reload."""
+    try:
+        from praisonaiui.server import _datastore
+    except Exception:  # noqa: BLE001
+        return
+    existing = await _datastore.get_session(session_id)
+    title = "Voice memory"
+    if call_id:
+        title = f"Voice user {user_id or call_id[:8]}"
+    if existing is None:
+        await _datastore.create_session(session_id)
+        await _datastore.update_session(
+            session_id,
+            platform="voice",
+            icon="🎙️",
+            title=title,
+        )
+
+
+async def append_ui_message(session_id: str, role: str, content: str) -> None:
+    try:
+        from praisonaiui.server import _datastore
+
+        await _datastore.add_message(
+            session_id,
+            {"role": "user" if role == "user" else "assistant", "content": content, "platform": "voice"},
+        )
+    except Exception:  # noqa: BLE001
+        logger.debug("Failed to append UI message for %s", session_id, exc_info=True)
+
+
+def _apply_knowledge_augmentation(prompt: str) -> str:
+    from praisonaiui.features.knowledge import get_knowledge_manager
+
+    k_mgr = get_knowledge_manager()
+    if not k_mgr.list_all():
+        return prompt
+    results = k_mgr.search(prompt, limit=5)
+    lines = [r.get("text", "") for r in results if r.get("text")]
+    if not lines:
+        return prompt
+    block = "\n".join(lines)
+    return f"[Knowledge Context]\n{block}\n[/Knowledge Context]\n\n{prompt}"
+
+
+def build_knowledge_augmented_prompt(prompt: str, *, timeout_s: float | None = 2.0) -> str:
+    """Inject knowledge search results like dashboard chat run_agent().
+
+    Knowledge indexing can take tens of seconds on cold start; Speech Engine
+    disconnects if the LLM path blocks too long, so callers use a short timeout.
+    """
+    if not os.getenv("VOICE_MEMORY_USE_KNOWLEDGE", "true").lower() in ("1", "true", "yes"):
+        return prompt
+    try:
+        if timeout_s is None:
+            return _apply_knowledge_augmentation(prompt)
+        from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(_apply_knowledge_augmentation, prompt)
+            return future.result(timeout=timeout_s)
+    except FuturesTimeoutError:
+        logger.warning("Knowledge augmentation timed out after %.1fs; using plain prompt", timeout_s)
+        return prompt
+    except Exception:  # noqa: BLE001
+        logger.debug("Knowledge augmentation skipped", exc_info=True)
+        return prompt
+
+
+def history_context_block(session_id: str | None) -> str:
+    if not memory_enabled() or not session_id:
+        return ""
+    history = load_session_history(session_id)
+    if not history:
+        return ""
+    lines = []
+    for item in history[-_history_limit() :]:
+        role = item.get("role", "user")
+        content = str(item.get("content") or "").strip()
+        if content:
+            lines.append(f"{role}: {content}")
+    if not lines:
+        return ""
+    return "Previous conversation with this user:\n" + "\n".join(lines)
+
+
+def openai_messages_with_memory(
+    transcript_lines: list[str],
+    *,
+    session_id: str | None,
+    base_instructions: str,
+) -> list[dict[str, str]]:
+    messages: list[dict[str, str]] = [{"role": "system", "content": base_instructions}]
+    prior = history_context_block(session_id)
+    if prior:
+        messages.append({"role": "system", "content": prior})
+    for line in transcript_lines:
+        if line.startswith("user:"):
+            messages.append({"role": "user", "content": line[5:].strip()})
+        elif line.startswith("agent:"):
+            messages.append({"role": "assistant", "content": line[6:].strip()})
+    return messages
+
+
+def bind_call_from_pending(call_id: str) -> str | None:
+    user_id = consume_pending_user()
+    if not user_id:
+        return None
+    return bind_call_user(call_id, user_id)
+
+
+async def record_voice_turn(
+    call_id: str | None,
+    *,
+    user_text: str | None = None,
+    agent_text: str | None = None,
+) -> None:
+    """Save latest user/agent lines to Praison session + chat UI."""
+    session_id = resolve_praison_session_id(call_id)
+    if not session_id:
+        return
+    user_id = resolve_call_user(call_id)
+    await ensure_ui_session(session_id, user_id=user_id, call_id=call_id)
+    if user_text:
+        append_session_turn(session_id, "user", user_text)
+        await append_ui_message(session_id, "user", user_text)
+    if agent_text:
+        append_session_turn(session_id, "assistant", agent_text)
+        await append_ui_message(session_id, "assistant", agent_text)
+
+
+def instructions_with_memory(base: str, *, session_id: str | None) -> str:
+    prior = history_context_block(session_id)
+    if not prior:
+        return base
+    return f"{base}\n\n{prior}\nUse prior conversation when the user refers to earlier calls."

examples/python/voice-agent/integrations/voice/speech_engine.py

@@ -0,0 +1,346 @@
+"""ElevenLabs Speech Engine — WebSocket LLM bridge for browser voice."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_engine_resource: Any | None = None
+_engine_lock = asyncio.Lock()
+
+
+class SpeechEngineConfigError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class SpeechEngineSettings:
+    api_key: str
+    engine_id: str | None
+    public_ws_url: str | None
+    first_message: str
+
+
+def _public_ws_url() -> str | None:
+    speech_base = os.getenv("SPEECH_ENGINE_PUBLIC_URL", "").strip().rstrip("/")
+    base = speech_base or os.getenv("PUBLIC_API_BASE_URL", "").strip().rstrip("/")
+    if not base:
+        return None
+    if base.startswith("https://"):
+        return "wss://" + base[len("https://") :] + "/ws"
+    if base.startswith("http://"):
+        return "ws://" + base[len("http://") :] + "/ws"
+    return None
+
+
+def load_speech_engine_settings(*, require_engine_id: bool = False) -> SpeechEngineSettings:
+    api_key = os.getenv("ELEVENLABS_API_KEY", "").strip()
+    if not api_key:
+        raise SpeechEngineConfigError("Set ELEVENLABS_API_KEY in .env")
+    engine_id = os.getenv("SPEECH_ENGINE_ID", "").strip() or None
+    if require_engine_id and not engine_id:
+        raise SpeechEngineConfigError("Set SPEECH_ENGINE_ID in .env (run setup_speech_engine.py)")
+    return SpeechEngineSettings(
+        api_key=api_key,
+        engine_id=engine_id,
+        public_ws_url=_public_ws_url(),
+        first_message=os.getenv(
+            "SPEECH_ENGINE_FIRST_MESSAGE", "Hello! How can I help you today?"
+        ).strip(),
+    )
+
+
+def speech_engine_enabled() -> bool:
+    try:
+        settings = load_speech_engine_settings()
+    except SpeechEngineConfigError:
+        return False
+    return bool(settings.engine_id and settings.public_ws_url)
+
+
+async def get_engine_resource():
+    """Lazy-load the ElevenLabs SpeechEngineResource."""
+    global _engine_resource
+    if _engine_resource is not None:
+        return _engine_resource
+
+    async with _engine_lock:
+        if _engine_resource is not None:
+            return _engine_resource
+        settings = load_speech_engine_settings(require_engine_id=True)
+        try:
+            from elevenlabs import AsyncElevenLabs
+        except ImportError as exc:
+            raise SpeechEngineConfigError(
+                "Install Speech Engine SDK: pip install 'elevenlabs>=2.47.0'"
+            ) from exc
+
+        if not hasattr(AsyncElevenLabs(api_key=settings.api_key), "speech_engine"):
+            raise SpeechEngineConfigError(
+                "elevenlabs package is too old. Run: pip install -U 'elevenlabs>=2.47.0'"
+            )
+
+        client = AsyncElevenLabs(api_key=settings.api_key)
+        _engine_resource = await client.speech_engine.get(settings.engine_id)
+        return _engine_resource
+
+
+def _conversation_id(session: Any) -> str | None:
+    cid = getattr(session, "conversation_id", None)
+    return str(cid) if cid else None
+
+
+def _transcript_display_text(transcript: list[Any], agent_reply: str | None = None) -> str:
+    text = _transcript_to_prompt(transcript)
+    if agent_reply:
+        agent_line = f"agent: {agent_reply.strip()}"
+        text = f"{text}\n{agent_line}".strip() if text else agent_line
+    return text
+
+
+def _persist_conversation_turn(call_id: str, transcript: list[Any], agent_reply: str) -> None:
+    from integrations.voice.live import transcript_hub
+    from integrations.voice.store import VoiceCallStore
+
+    display = _transcript_display_text(transcript, agent_reply)
+    VoiceCallStore.upsert_call(
+        call_id,
+        status="in-progress",
+        customer_number="web-speech-engine",
+        transcript=display,
+    )
+    prompt = _transcript_to_prompt(transcript)
+    if prompt:
+        last_line = prompt.splitlines()[-1]
+        role, _, content = last_line.partition(": ")
+        transcript_hub.publish(
+            call_id,
+            {
+                "type": "transcript",
+                "role": role or "user",
+                "transcriptType": "final",
+                "text": content,
+            },
+        )
+    transcript_hub.publish(
+        call_id,
+        {
+            "type": "transcript",
+            "role": "assistant",
+            "transcriptType": "final",
+            "text": agent_reply,
+        },
+    )
+
+
+def _transcript_to_prompt(transcript: list[Any]) -> str:
+    lines: list[str] = []
+    for message in transcript:
+        role = getattr(message, "role", None) or (message.get("role") if isinstance(message, dict) else "user")
+        content = getattr(message, "content", None) or (
+            message.get("content") if isinstance(message, dict) else ""
+        )
+        text = str(content or "").strip()
+        if text:
+            lines.append(f"{role}: {text}")
+    if not lines:
+        return ""
+    return "\n".join(lines)
+
+
+def _try_demo_tool_reply(transcript: list[Any]) -> str | None:
+    from integrations.voice.tools import demo_tool_reply
+
+    user_text = _latest_user_text(transcript)
+    if not user_text:
+        return None
+    return demo_tool_reply(user_text)
+
+
+async def _run_openai_reply(transcript: list[Any], *, session_id: str | None = None) -> str:
+    """Voice LLM path with demo fast-path + OpenAI tool calling."""
+    import json
+
+    from openai import AsyncOpenAI
+
+    from integrations.voice.agent_runner import execute_voice_tool
+    from integrations.voice.session_memory import openai_messages_with_memory
+    from integrations.voice.tools import openai_tool_schemas, tool_result_for_voice
+
+    prompt = _transcript_to_prompt(transcript)
+    if not prompt:
+        return "I did not catch that. Could you repeat?"
+
+    fast = _try_demo_tool_reply(transcript)
+    if fast:
+        return fast
+
+    client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY", "").strip())
+    model = os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini")
+    base_instructions = (
+        "You are a helpful voice assistant for PraisonAI demos. "
+        "Keep answers concise (1-3 sentences) and conversational. "
+        "When the caller asks for the time, call get_current_time. "
+        "When they ask you to repeat or echo text, call echo_message."
+    )
+    messages = openai_messages_with_memory(
+        prompt.splitlines(),
+        session_id=session_id,
+        base_instructions=base_instructions,
+    )
+    use_tools = os.getenv("VOICE_SPEECH_USE_TOOLS", "true").lower() in ("1", "true", "yes")
+    create_kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": messages,
+        "max_tokens": 200,
+    }
+    if use_tools:
+        create_kwargs["tools"] = openai_tool_schemas()
+        create_kwargs["tool_choice"] = "auto"
+
+    response = await client.chat.completions.create(**create_kwargs)
+    choice = response.choices[0].message
+
+    if use_tools and choice.tool_calls:
+        messages.append(choice.model_dump(exclude_none=True))
+        fallback = "Done."
+        for tool_call in choice.tool_calls:
+            fn = tool_call.function
+            name = fn.name if fn else ""
+            try:
+                args = json.loads(fn.arguments or "{}") if fn else {}
+            except json.JSONDecodeError:
+                args = {}
+            raw = execute_voice_tool(name, args, session_id=session_id)
+            fallback = tool_result_for_voice(raw)
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": raw,
+                }
+            )
+        final = await client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=200,
+        )
+        text = (final.choices[0].message.content or "").strip()
+        return text or fallback
+
+    text = (choice.content or "").strip()
+    return text or "Sorry, I could not generate a response."
+
+
+async def _run_agent_reply(transcript: list[Any], *, session_id: str | None = None) -> str:
+    prompt = _transcript_to_prompt(transcript)
+    if not prompt:
+        return "I did not catch that. Could you repeat?"
+
+    # Prefer fast OpenAI streaming for Speech Engine turn latency.
+    if os.getenv("OPENAI_API_KEY", "").strip():
+        try:
+            return await asyncio.wait_for(
+                _run_openai_reply(transcript, session_id=session_id),
+                timeout=20.0,
+            )
+        except TimeoutError:
+            return "Sorry, that took too long. Could you ask again with a shorter question?"
+        except Exception:  # noqa: BLE001
+            logger.exception("OpenAI Speech Engine reply failed; falling back to agent")
+
+    from integrations.voice.agent_runner import get_voice_agent
+
+    agent = get_voice_agent(session_id)
+    reply = await asyncio.wait_for(asyncio.to_thread(agent.chat, prompt), timeout=25.0)
+    return str(reply).strip() or "Sorry, I could not generate a response."
+
+
+def _latest_user_text(transcript: list[Any]) -> str:
+    prompt = _transcript_to_prompt(transcript)
+    if not prompt:
+        return ""
+    for line in reversed(prompt.splitlines()):
+        if line.startswith("user:"):
+            return line[5:].strip()
+    return ""
+
+
+async def handle_user_transcript(transcript: list[Any], session: Any) -> None:
+    """Run voice LLM on transcript and send text back to Speech Engine."""
+    from integrations.voice.session_memory import record_voice_turn, resolve_praison_session_id
+
+    call_id = _conversation_id(session)
+    praison_session_id = resolve_praison_session_id(call_id)
+    preview = _transcript_to_prompt(transcript)
+    print(f"[speech sidecar] transcript: {preview[:200]!r}", flush=True)
+    reply = ""
+    try:
+        reply = await _run_agent_reply(transcript, session_id=praison_session_id)
+        print(f"[speech sidecar] reply: {reply[:200]!r}", flush=True)
+        await session.send_response(reply)
+    except TimeoutError:
+        reply = "Sorry, that took too long. Please try a shorter question."
+        await session.send_response(reply)
+    except Exception:  # noqa: BLE001
+        logger.exception("Speech Engine agent reply failed")
+        reply = "Sorry, something went wrong on my side."
+        await session.send_response(reply)
+    if call_id and reply:
+        _persist_conversation_turn(call_id, transcript, reply)
+        user_text = _latest_user_text(transcript)
+        await record_voice_turn(call_id, user_text=user_text or None, agent_text=reply)
+
+
+async def handle_session_init(conversation_id: str, session: Any) -> None:
+    from integrations.voice.session_memory import bind_call_from_pending, ensure_ui_session, resolve_praison_session_id
+    from integrations.voice.store import VoiceCallStore
+
+    call_id = str(conversation_id)
+    bind_call_from_pending(call_id)
+    VoiceCallStore.upsert_call(
+        call_id,
+        status="in-progress",
+        customer_number="web-speech-engine",
+    )
+    session_id = resolve_praison_session_id(call_id)
+    if session_id:
+        await ensure_ui_session(session_id, call_id=call_id)
+    logger.info("Speech Engine session started: %s", conversation_id)
+
+
+async def handle_session_close(session: Any) -> None:
+    from integrations.voice.call_finalize import finalize_call
+
+    conversation_id = _conversation_id(session)
+    if conversation_id:
+        await finalize_call(conversation_id, status="ended (customer-ended-call)")
+        logger.info("Speech Engine session ended: %s", conversation_id)
+
+
+async def handle_session_disconnect(session: Any) -> None:
+    """Fallback when WebSocket drops without a formal close message."""
+    await handle_session_close(session)
+
+
+def get_webrtc_token() -> str:
+    """Mint a browser conversation token (keeps API key server-side)."""
+    settings = load_speech_engine_settings(require_engine_id=True)
+    try:
+        from elevenlabs import ElevenLabs
+    except ImportError as exc:
+        raise SpeechEngineConfigError("Install elevenlabs: pip install elevenlabs") from exc
+
+    client = ElevenLabs(api_key=settings.api_key)
+    response = client.conversational_ai.conversations.get_webrtc_token(
+        agent_id=settings.engine_id,
+    )
+    token = getattr(response, "token", None) or (response.get("token") if isinstance(response, dict) else None)
+    if not token:
+        raise SpeechEngineConfigError("Could not mint Speech Engine conversation token")
+    return str(token)

examples/python/voice-agent/integrations/voice/store.py

@@ -0,0 +1,252 @@
+"""Persist voice call state and webhook idempotency."""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from contextlib import closing
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def _state_db_path() -> str:
+    env = os.getenv("PRAISONAI_VOICE_DIR")
+    base = Path(env) if env else Path.home() / ".praisonai" / "voice"
+    base.mkdir(parents=True, exist_ok=True)
+    return str(base / "voice_state.db")
+
+
+def _connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(_state_db_path())
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS voice_calls (
+            call_id TEXT PRIMARY KEY,
+            status TEXT NOT NULL,
+            customer_number TEXT,
+            transcript TEXT NOT NULL DEFAULT '',
+            summary TEXT NOT NULL DEFAULT '',
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS voice_webhook_events (
+            event_key TEXT PRIMARY KEY,
+            event_type TEXT NOT NULL,
+            processed_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS voice_memory_pending (
+            key TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        )
+        """
+    )
+    return conn
+
+
+def webhook_event_key(event_type: str, payload: dict[str, Any]) -> str:
+    message = payload.get("message") if isinstance(payload.get("message"), dict) else payload
+    call = (message or {}).get("call") if isinstance(message, dict) else {}
+    call_id = call.get("id") if isinstance(call, dict) else None
+    if isinstance(message, dict):
+        # Derive the key from the fields that actually distinguish one event from
+        # the next. A truncated JSON dump is unsafe here: when a large static field
+        # (e.g. ``call``) sorts before the discriminating field, successive events
+        # collapse to the same prefix and later ones get dropped as "duplicates"
+        # (e.g. a status-update stuck on "ringing").
+        if event_type == "transcript":
+            text = str(message.get("transcript") or "")
+            role = str(message.get("role") or "")
+            kind = str(message.get("transcriptType") or "")
+            return f"{event_type}:{call_id}:{role}:{kind}:{text}"
+        if event_type == "status-update":
+            return f"{event_type}:{call_id}:{message.get('status')}"
+        if event_type == "conversation-update":
+            messages = message.get("messages")
+            count = len(messages) if isinstance(messages, list) else 0
+            return f"{event_type}:{call_id}:{count}"
+        if event_type == "end-of-call-report":
+            return f"{event_type}:{call_id}:{message.get('endedReason')}"
+    if call_id:
+        return f"{event_type}:{call_id}:{json.dumps(message, sort_keys=True)[:200]}"
+    return f"{event_type}:{json.dumps(payload, sort_keys=True)[:300]}"
+
+
+class VoiceCallStore:
+    @staticmethod
+    def mark_event_processed(event_key: str, event_type: str) -> bool:
+        now = datetime.now(timezone.utc).isoformat()
+        with closing(_connect()) as conn, conn:
+            row = conn.execute(
+                "SELECT 1 FROM voice_webhook_events WHERE event_key = ?",
+                (event_key,),
+            ).fetchone()
+            if row:
+                return False
+            conn.execute(
+                """
+                INSERT INTO voice_webhook_events (event_key, event_type, processed_at)
+                VALUES (?, ?, ?)
+                """,
+                (event_key, event_type, now),
+            )
+        return True
+
+    @staticmethod
+    def upsert_call(
+        call_id: str,
+        *,
+        status: str | None = None,
+        customer_number: str | None = None,
+        transcript: str | None = None,
+        summary: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        now = datetime.now(timezone.utc).isoformat()
+        with closing(_connect()) as conn, conn:
+            row = conn.execute(
+                "SELECT transcript, summary, metadata_json, customer_number, status FROM voice_calls WHERE call_id = ?",
+                (call_id,),
+            ).fetchone()
+            existing_transcript = row[0] if row else ""
+            existing_summary = row[1] if row else ""
+            existing_meta = json.loads(row[2]) if row and row[2] else {}
+            existing_number = row[3] if row else None
+            existing_status = row[4] if row else None
+            # Preserve prior status when the caller doesn't supply one (e.g. transcript
+            # / conversation-update events) so partial updates don't clobber live state.
+            final_status = status if status is not None else (existing_status or "unknown")
+            merged_meta = {**existing_meta, **(metadata or {})}
+            conn.execute(
+                """
+                INSERT INTO voice_calls (
+                    call_id, status, customer_number, transcript, summary, metadata_json, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(call_id) DO UPDATE SET
+                    status = excluded.status,
+                    customer_number = COALESCE(excluded.customer_number, voice_calls.customer_number),
+                    transcript = excluded.transcript,
+                    summary = COALESCE(excluded.summary, voice_calls.summary),
+                    metadata_json = excluded.metadata_json,
+                    updated_at = excluded.updated_at
+                """,
+                (
+                    call_id,
+                    final_status,
+                    customer_number or existing_number,
+                    transcript if transcript is not None else existing_transcript,
+                    summary if summary is not None else existing_summary,
+                    json.dumps(merged_meta, sort_keys=True),
+                    now,
+                    now,
+                ),
+            )
+
+    @staticmethod
+    def append_transcript_line(call_id: str, line: str) -> str:
+        now = datetime.now(timezone.utc).isoformat()
+        with closing(_connect()) as conn, conn:
+            row = conn.execute(
+                "SELECT transcript FROM voice_calls WHERE call_id = ?",
+                (call_id,),
+            ).fetchone()
+            existing = row[0] if row else ""
+            full = f"{existing}\n{line}".strip() if existing else line
+            conn.execute(
+                """
+                INSERT INTO voice_calls (
+                    call_id, status, transcript, summary, metadata_json, created_at, updated_at
+                ) VALUES (?, 'unknown', ?, '', '{}', ?, ?)
+                ON CONFLICT(call_id) DO UPDATE SET
+                    transcript = excluded.transcript,
+                    updated_at = excluded.updated_at
+                """,
+                (call_id, full, now, now),
+            )
+        return full
+
+    @staticmethod
+    def list_calls(limit: int = 50) -> list[dict[str, Any]]:
+        with closing(_connect()) as conn:
+            rows = conn.execute(
+                """
+                SELECT call_id, status, customer_number, transcript, summary, metadata_json,
+                       created_at, updated_at
+                FROM voice_calls ORDER BY updated_at DESC LIMIT ?
+                """,
+                (max(1, limit),),
+            ).fetchall()
+        out: list[dict[str, Any]] = []
+        for row in rows:
+            out.append(
+                {
+                    "call_id": row[0],
+                    "status": row[1],
+                    "customer_number": row[2],
+                    "transcript": row[3],
+                    "summary": row[4],
+                    "metadata": json.loads(row[5] or "{}"),
+                    "created_at": row[6],
+                    "updated_at": row[7],
+                }
+            )
+        return out
+
+    @staticmethod
+    def set_pending_user(user_id: str) -> None:
+        now = datetime.now(timezone.utc).isoformat()
+        with closing(_connect()) as conn, conn:
+            conn.execute(
+                """
+                INSERT INTO voice_memory_pending (key, user_id, updated_at)
+                VALUES ('browser', ?, ?)
+                ON CONFLICT(key) DO UPDATE SET user_id = excluded.user_id, updated_at = excluded.updated_at
+                """,
+                (user_id, now),
+            )
+
+    @staticmethod
+    def consume_pending_user() -> str | None:
+        with closing(_connect()) as conn, conn:
+            row = conn.execute(
+                "SELECT user_id FROM voice_memory_pending WHERE key = 'browser'",
+            ).fetchone()
+            if not row:
+                return None
+            conn.execute("DELETE FROM voice_memory_pending WHERE key = 'browser'")
+            return str(row[0])
+
+    @staticmethod
+    def get_call(call_id: str) -> dict[str, Any] | None:
+        with closing(_connect()) as conn:
+            row = conn.execute(
+                """
+                SELECT call_id, status, customer_number, transcript, summary, metadata_json,
+                       created_at, updated_at
+                FROM voice_calls WHERE call_id = ?
+                """,
+                (call_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return {
+            "call_id": row[0],
+            "status": row[1],
+            "customer_number": row[2],
+            "transcript": row[3],
+            "summary": row[4],
+            "metadata": json.loads(row[5] or "{}"),
+            "created_at": row[6],
+            "updated_at": row[7],
+        }

examples/python/voice-agent/integrations/voice/tools.py

@@ -0,0 +1,108 @@
+"""Tools callable from voice provider ``tool-calls`` webhook events."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+
+def get_current_time() -> dict[str, Any]:
+    """Return current UTC time for voice agent demos."""
+    now = datetime.now(timezone.utc).isoformat()
+    return {"utc": now, "spoken": f"The current UTC time is {now}"}
+
+
+def echo_message(message: str = "") -> dict[str, Any]:
+    """Echo a message back to the caller."""
+    text = message.strip() or "nothing"
+    return {"message": text, "spoken": f"You said {text}"}
+
+
+def demo_tool_reply(text: str) -> str | None:
+    """Fast path for common voice tool queries — no LLM round-trip."""
+    lower = text.lower().strip()
+    if any(p in lower for p in ("what time", "current time", "tell me the time", "time is it")):
+        return str(get_current_time()["spoken"])
+    if lower.startswith("echo "):
+        return str(echo_message(text[5:])["spoken"])
+    if lower.startswith("repeat "):
+        return str(echo_message(text[7:])["spoken"])
+    return None
+
+
+def openai_tool_schemas() -> list[dict[str, Any]]:
+    """OpenAI function schemas for Speech Engine / voice LLM paths."""
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_time",
+                "description": "Return the current UTC time when the caller asks for the time.",
+                "parameters": {"type": "object", "properties": {}, "required": []},
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "echo_message",
+                "description": "Repeat or echo back a phrase the caller wants repeated.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "description": "The text to echo back to the caller",
+                        }
+                    },
+                    "required": ["message"],
+                },
+            },
+        },
+    ]
+
+
+def tool_result_for_voice(raw_result: str) -> str:
+    """Convert tool JSON output to speakable voice text."""
+    try:
+        data = json.loads(raw_result)
+    except json.JSONDecodeError:
+        return raw_result.strip() or "Done."
+    if isinstance(data, dict):
+        spoken = data.get("spoken")
+        if spoken:
+            return str(spoken)
+        err = data.get("error")
+        if err:
+            return f"Sorry, {err}"
+    return raw_result.strip() or "Done."
+
+
+_TOOL_REGISTRY: dict[str, Callable[..., Any]] = {
+    "get_current_time": get_current_time,
+    "echo_message": echo_message,
+}
+
+
+def register_tool(name: str, fn: Callable[..., Any]) -> None:
+    _TOOL_REGISTRY[name] = fn
+
+
+def execute_tool(name: str, parameters: dict[str, Any] | None) -> str:
+    """Run a registered tool and return a JSON string for the provider."""
+    fn = _TOOL_REGISTRY.get(name)
+    if fn is None:
+        return json.dumps({"error": f"Unknown tool: {name}"})
+    try:
+        result = fn(**(parameters or {}))
+        if isinstance(result, str):
+            return result
+        return json.dumps(result)
+    except TypeError:
+        try:
+            result = fn(parameters or {})
+            return json.dumps(result)
+        except Exception as exc:  # noqa: BLE001
+            return json.dumps({"error": str(exc)})
+    except Exception as exc:  # noqa: BLE001
+        return json.dumps({"error": str(exc)})

examples/python/voice-agent/integrations/voice/verify.py

@@ -0,0 +1,21 @@
+"""Verify incoming voice provider webhook requests."""
+
+from __future__ import annotations
+
+import hmac
+
+_SECRET_HEADERS = ("x-voice-webhook-secret", "x-webhook-secret")
+
+
+class VerificationError(ValueError):
+    """Webhook secret verification failed."""
+
+
+def verify_webhook_request(*, secret: str | None, headers: dict[str, str]) -> None:
+    """Validate webhook secret header when ``VOICE_SERVER_URL_SECRET`` is configured."""
+    if not secret:
+        return
+    lowered = {k.lower(): v for k, v in headers.items()}
+    incoming = next((lowered[name] for name in _SECRET_HEADERS if lowered.get(name)), None)
+    if not incoming or not hmac.compare_digest(incoming, secret):
+        raise VerificationError("Invalid or missing webhook secret header")

examples/python/voice-agent/memory_routes.py

@@ -0,0 +1,76 @@
+"""HTTP routes for stable voice user sessions."""
+
+from __future__ import annotations
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from integrations.voice.session_memory import (
+    attach_pending_user,
+    bind_call_user,
+    memory_enabled,
+    resolve_praison_session_id,
+    voice_user_session_id,
+)
+
+
+async def api_voice_memory_config(_request: Request) -> JSONResponse:
+    return JSONResponse({"enabled": memory_enabled()})
+
+
+async def api_voice_memory_bind(request: Request) -> JSONResponse:
+    try:
+        payload = await request.json()
+    except Exception:  # noqa: BLE001
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+    call_id = str(payload.get("call_id") or "").strip()
+    user_id = str(payload.get("user_id") or "").strip()
+    if not call_id or not user_id:
+        return JSONResponse({"error": "call_id and user_id required"}, status_code=400)
+    try:
+        session_id = bind_call_user(call_id, user_id)
+    except ValueError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=400)
+    return JSONResponse(
+        {
+            "ok": True,
+            "call_id": call_id,
+            "user_id": user_id,
+            "praison_session_id": session_id,
+        }
+    )
+
+
+async def api_voice_memory_resolve(request: Request) -> JSONResponse:
+    user_id = request.query_params.get("user_id", "").strip()
+    if not user_id:
+        return JSONResponse({"error": "user_id required"}, status_code=400)
+    session_id = voice_user_session_id(user_id)
+    return JSONResponse({"user_id": user_id, "praison_session_id": session_id})
+
+
+async def api_voice_memory_attach_user(request: Request) -> JSONResponse:
+    """ElevenLabs: browser attaches user before conversation id exists."""
+    try:
+        payload = await request.json()
+    except Exception:  # noqa: BLE001
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+    user_id = str(payload.get("user_id") or "").strip()
+    if not user_id:
+        return JSONResponse({"error": "user_id required"}, status_code=400)
+    attach_pending_user(user_id)
+    return JSONResponse(
+        {
+            "ok": True,
+            "user_id": user_id,
+            "praison_session_id": voice_user_session_id(user_id),
+        }
+    )
+
+
+async def api_voice_memory_for_call(request: Request) -> JSONResponse:
+    call_id = request.query_params.get("call_id", "").strip()
+    if not call_id:
+        return JSONResponse({"error": "call_id required"}, status_code=400)
+    session_id = resolve_praison_session_id(call_id)
+    return JSONResponse({"call_id": call_id, "praison_session_id": session_id})

examples/python/voice-agent/plugin.js

@@ -0,0 +1,781 @@
+/**
+ * Voice Agent Phase 2 — live transcript + browser talk widget.
+ *
+ * custom.js can run before dashboard.js defines window.aiui, so we wait.
+ */
+(function () {
+  function whenReady(fn) {
+    if (window.aiui && typeof window.aiui.registerView === 'function') {
+      fn();
+      return;
+    }
+    var n = 0;
+    var t = setInterval(function () {
+      n += 1;
+      if (window.aiui && typeof window.aiui.registerView === 'function') {
+        clearInterval(t);
+        fn();
+      } else if (n > 150) {
+        clearInterval(t);
+        console.warn('[voice plugin] window.aiui never became ready');
+      }
+    }, 100);
+  }
+
+  function el(tag, style, text) {
+    var node = document.createElement(tag);
+    if (style) node.style.cssText = style;
+    if (text != null) node.textContent = text;
+    return node;
+  }
+
+  function currentCallId() {
+    return new URLSearchParams(window.location.search).get('call_id') || '';
+  }
+
+  function voiceUserId() {
+    var key = 'voice-user-id';
+    var id = localStorage.getItem(key);
+    if (!id) {
+      id = 'u-' + Math.random().toString(36).slice(2, 12);
+      localStorage.setItem(key, id);
+    }
+    return id;
+  }
+
+  async function postJson(url, body) {
+    var resp = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body || {}),
+    });
+    if (!resp.ok) throw new Error('HTTP ' + resp.status);
+    return resp.json();
+  }
+
+  async function attachVoiceUser() {
+    return postJson('/api/voice/memory/attach-user', { user_id: voiceUserId() });
+  }
+
+  function renderUiComponent(comp) {
+    if (window.aiui && typeof window.aiui.renderComponent === 'function') {
+      return window.aiui.renderComponent(comp);
+    }
+    var wrap = el('div');
+    if (comp.type === 'code_block') {
+      var pre = el(
+        'pre',
+        'margin:0;padding:16px;border-radius:10px;background:var(--db-card-bg,#1f2937);' +
+          'border:1px solid var(--db-border,#334155);white-space:pre-wrap;font-family:ui-monospace,monospace;font-size:13px'
+      );
+      pre.textContent = comp.code || '';
+      wrap.appendChild(pre);
+      wrap.className = 'db-code-block';
+      return wrap;
+    }
+    if (comp.type === 'text') {
+      wrap.textContent = comp.content || '';
+      return wrap;
+    }
+    wrap.textContent = JSON.stringify(comp);
+    return wrap;
+  }
+
+  function renderUiTree(data, container) {
+    if (!data) return;
+    if (data._components) {
+      data._components.forEach(function (c) {
+        container.appendChild(renderUiComponent(c));
+      });
+      return;
+    }
+    if (data.type === 'layout' && data.children) {
+      data.children.forEach(function (c) {
+        container.appendChild(renderUiComponent(c));
+      });
+    }
+  }
+
+  function findTranscriptCodeEl(root) {
+    var blocks = root.querySelectorAll('.db-code-block code');
+    if (!blocks.length) {
+      blocks = root.querySelectorAll('.db-code-block pre');
+    }
+    return blocks.length ? blocks[blocks.length - 1] : null;
+  }
+
+  async function fetchJson(url, retries) {
+    var attempts = retries == null ? 1 : retries;
+    var lastErr = null;
+    for (var i = 0; i < attempts; i += 1) {
+      try {
+        var resp = await fetch(url);
+        if (!resp.ok) throw new Error('HTTP ' + resp.status);
+        return resp.json();
+      } catch (err) {
+        lastErr = err;
+        if (i < attempts - 1) {
+          await new Promise(function (r) {
+            setTimeout(r, 1500);
+          });
+        }
+      }
+    }
+    throw lastErr || new Error('fetch failed');
+  }
+
+  async function resolveCallId() {
+    var fromQuery = currentCallId();
+    if (fromQuery) return fromQuery;
+    var data = await fetchJson('/api/voice/calls');
+    var calls = data.calls || [];
+    var live = calls.find(function (c) {
+      return String(c.status || '').toLowerCase().indexOf('progress') >= 0;
+    });
+    return (live && live.call_id) || (calls[0] && calls[0].call_id) || '';
+  }
+
+  async function loadWebSdk(cfg) {
+    var candidates = [];
+    var configured = cfg.sdk_url || '';
+    if (configured && configured.indexOf('dist/vapi.js') < 0) {
+      candidates.push(configured);
+    }
+    candidates.push('https://esm.sh/@vapi-ai/[email protected]');
+
+    var lastErr = null;
+    for (var i = 0; i < candidates.length; i++) {
+      try {
+        var mod = await import(/* webpackIgnore: true */ candidates[i]);
+        var Sdk = mod.default || mod.Vapi;
+        if (typeof Sdk === 'function') return Sdk;
+        lastErr = new Error('Module loaded but no Vapi class');
+      } catch (err) {
+        lastErr = err;
+        console.warn('[voice plugin] SDK load failed for', candidates[i], err);
+      }
+    }
+    throw new Error(
+      'Could not load voice web SDK' + (lastErr && lastErr.message ? ': ' + lastErr.message : '')
+    );
+  }
+
+  function registerVoiceViews() {
+    window.aiui.registerView(
+      'call-detail',
+      async function (container) {
+        container.innerHTML = '';
+        var wrap = el(
+          'div',
+          'padding:20px;display:flex;flex-direction:column;gap:16px;color:var(--db-text,#eee)'
+        );
+        var uiHost = el('div', 'display:flex;flex-direction:column;gap:12px');
+        var statusLine = el(
+          'div',
+          'font-size:12px;color:var(--db-text-dim,#94a3b8)',
+          'Loading PraisonAIUI components…'
+        );
+        wrap.appendChild(uiHost);
+        wrap.appendChild(statusLine);
+        container.appendChild(wrap);
+
+        var es = null;
+        var lines = [];
+        var transcriptEl = null;
+
+        function renderTranscript(fullText) {
+          if (!transcriptEl) return;
+          if (fullText) {
+            transcriptEl.textContent = fullText;
+            return;
+          }
+          transcriptEl.textContent = lines.length ? lines.join('\n') : '(empty)';
+        }
+
+        function appendLine(role, text) {
+          lines.push(role + ': ' + text);
+          renderTranscript('');
+        }
+
+        try {
+          var callId = await resolveCallId();
+          if (!callId) {
+            renderUiTree(
+              {
+                type: 'layout',
+                children: [
+                  {
+                    type: 'alert',
+                    variant: 'info',
+                    title: 'Call detail',
+                    message: 'No calls yet — start from ElevenLabs talk or GPT Realtime.',
+                  },
+                ],
+              },
+              uiHost
+            );
+            statusLine.textContent = 'Idle';
+            return;
+          }
+          var uiData = await fetchJson('/api/voice/calls/' + encodeURIComponent(callId) + '/ui');
+          renderUiTree(uiData.layout, uiHost);
+          transcriptEl = findTranscriptCodeEl(uiHost);
+          var detail = await fetchJson('/api/voice/calls/' + encodeURIComponent(callId));
+          if (detail.transcript) {
+            lines = detail.transcript.split('\n').filter(Boolean);
+            renderTranscript(detail.transcript);
+          }
+          statusLine.textContent = 'Live feed connecting…';
+          es = new EventSource(
+            '/api/voice/calls/' + encodeURIComponent(callId) + '/live-transcript'
+          );
+          es.onmessage = function (ev) {
+            try {
+              var payload = JSON.parse(ev.data);
+              if (payload.type === 'snapshot' && payload.transcript) {
+                lines = payload.transcript.split('\n').filter(Boolean);
+                renderTranscript(payload.transcript);
+                statusLine.textContent = 'Live · snapshot loaded';
+                return;
+              }
+              if (payload.type === 'transcript') {
+                if (payload.transcriptType === 'final') {
+                  appendLine(payload.role || 'unknown', payload.text || '');
+                } else if (transcriptEl) {
+                  transcriptEl.textContent =
+                    (lines.length ? lines.join('\n') + '\n' : '') +
+                    (payload.role || 'unknown') +
+                    ': ' +
+                    (payload.text || '') +
+                    ' …';
+                }
+                statusLine.textContent = 'Live · ' + (payload.transcriptType || 'update');
+              }
+            } catch (err) {
+              console.warn('[voice plugin] SSE parse error', err);
+            }
+          };
+          es.onerror = function () {
+            statusLine.textContent = 'Live feed disconnected (call may have ended)';
+          };
+        } catch (err) {
+          statusLine.textContent = 'Failed to load call: ' + err.message;
+        }
+
+        return function cleanup() {
+          if (es) es.close();
+        };
+      },
+      function () {}
+    );
+
+    window.aiui.registerView(
+      'web-talk',
+      async function (container) {
+        container.innerHTML = '';
+        var wrap = el('div', 'padding:24px;max-width:640px;color:var(--db-text,#eee)');
+        wrap.appendChild(el('h2', 'margin:0 0 12px 0', 'Web voice'));
+        wrap.appendChild(
+          el(
+            'p',
+            'margin:0 0 20px 0;line-height:1.6;color:var(--db-text-dim,#94a3b8)',
+            'Click Start talking, then allow the microphone when Chrome asks. The prompt does not appear until you click the button.'
+          )
+        );
+        var status = el('div', 'margin-bottom:16px;font-size:13px', 'Loading config…');
+        var btn = el(
+          'button',
+          'padding:12px 20px;border-radius:10px;border:none;background:var(--db-accent,#6366f1);' +
+            'color:#fff;font-size:15px;font-weight:600;cursor:pointer',
+          'Start talking'
+        );
+        btn.disabled = true;
+        wrap.appendChild(status);
+        wrap.appendChild(btn);
+        container.appendChild(wrap);
+
+        var cfg = null;
+        var client = null;
+
+        try {
+          cfg = await fetchJson('/api/voice/web-config');
+          if (!cfg.enabled) {
+            status.textContent =
+              cfg.error ||
+              'Web talk is not configured. Set VOICE_PUBLIC_API_KEY, VOICE_ASSISTANT_ID, VOICE_WEB_SDK_URL, VOICE_WEB_SDK_GLOBAL.';
+            btn.style.display = 'none';
+            return;
+          }
+          status.textContent = 'Ready — click Start talking, then allow microphone.';
+          btn.disabled = false;
+        } catch (err) {
+          status.textContent = 'Config error: ' + err.message;
+          return;
+        }
+
+        btn.addEventListener('click', async function () {
+          if (client && typeof client.stop === 'function' && btn.textContent === 'End call') {
+            client.stop();
+            client = null;
+            status.textContent = 'Call ended';
+            btn.textContent = 'Start talking';
+            return;
+          }
+          btn.disabled = true;
+          status.textContent = 'Loading web SDK…';
+          try {
+            var Sdk = await loadWebSdk(cfg);
+            client = new Sdk(cfg.public_key);
+            if (typeof client.start === 'function') {
+              await client.start(cfg.assistant_id);
+            } else if (typeof client.startAssistant === 'function') {
+              await client.startAssistant(cfg.assistant_id);
+            } else {
+              throw new Error('SDK has no start() method');
+            }
+            status.textContent = 'In call — allow microphone if Chrome asks. Speak now.';
+            btn.textContent = 'End call';
+            btn.disabled = false;
+          } catch (err) {
+            status.textContent = 'Start failed: ' + err.message;
+            btn.disabled = false;
+          }
+        });
+      }
+    );
+
+    window.aiui.registerView(
+      'eleven-talk',
+      async function (container) {
+        container.innerHTML = '';
+        var wrap = el('div', 'padding:24px;max-width:640px;color:var(--db-text,#eee)');
+        wrap.appendChild(el('h2', 'margin:0 0 12px 0', 'ElevenLabs voice'));
+        wrap.appendChild(
+          el(
+            'p',
+            'margin:0 0 20px 0;line-height:1.6;color:var(--db-text-dim,#94a3b8)',
+            'Speech Engine runs STT/TTS in the browser. Your PraisonAI agent handles replies on the server.'
+          )
+        );
+        var status = el('div', 'margin-bottom:16px;font-size:13px', 'Loading config…');
+        var btn = el(
+          'button',
+          'padding:12px 20px;border-radius:10px;border:none;background:var(--db-accent,#6366f1);' +
+            'color:#fff;font-size:15px;font-weight:600;cursor:pointer',
+          'Start conversation'
+        );
+        btn.disabled = true;
+        wrap.appendChild(status);
+        wrap.appendChild(btn);
+        container.appendChild(wrap);
+
+        var conversation = null;
+        var cfg = null;
+
+        try {
+          cfg = await fetchJson('/api/voice/speech-engine/config', 8);
+          if (!cfg.enabled) {
+            status.textContent =
+              cfg.error ||
+              'Speech Engine not ready. Run: pip install -U "elevenlabs>=2.47.0" then .\\start_dev.ps1 -Restart. ' +
+                'API key needs convai_write permission in ElevenLabs dashboard.';
+            btn.style.display = 'none';
+            return;
+          }
+          var toolList = (cfg.tools && cfg.tools.length ? cfg.tools.join(', ') : 'get_current_time, echo_message');
+          status.textContent =
+            'Ready — LLM ' +
+            (cfg.model || 'gpt-4o-mini') +
+            ' · tools: ' +
+            toolList +
+            '. Click Start conversation, then allow microphone.';
+          btn.disabled = false;
+        } catch (err) {
+          status.textContent = 'Config error: ' + err.message;
+          return;
+        }
+
+        btn.addEventListener('click', async function () {
+          if (conversation && btn.textContent === 'End conversation') {
+            try {
+              await conversation.endSession();
+            } catch (e) {
+              /* ignore */
+            }
+            conversation = null;
+            status.textContent = 'Conversation ended';
+            btn.textContent = 'Start conversation';
+            return;
+          }
+          btn.disabled = true;
+          status.textContent = 'Loading ElevenLabs client…';
+          try {
+            var sdkUrl = cfg.client_sdk_url || 'https://esm.sh/@elevenlabs/client';
+            var mod = await import(/* webpackIgnore: true */ sdkUrl);
+            var Conversation = mod.Conversation;
+            if (!Conversation || typeof Conversation.startSession !== 'function') {
+              throw new Error('ElevenLabs client SDK missing Conversation.startSession');
+            }
+            var tokenResp = await fetchJson('/api/voice/speech-engine/token');
+            if (!tokenResp.token) throw new Error('No conversation token returned');
+            await navigator.mediaDevices.getUserMedia({ audio: true });
+            await attachVoiceUser();
+            var startOpts = {
+              conversationToken: tokenResp.token,
+              onConnect: function () {
+                status.textContent =
+                  'Connected — speak, then pause ~1s so the agent knows you finished.';
+                btn.textContent = 'End conversation';
+                btn.disabled = false;
+              },
+              onDisconnect: function (details) {
+                var reason = details && details.reason ? details.reason : '';
+                if (reason === 'agent' || reason === 'unknown') {
+                  reason =
+                    'Speech Engine server did not respond in time. Restart .\\start_dev.ps1 -Restart and try again.';
+                } else if (!reason) {
+                  reason =
+                    'Connection closed (ElevenLabs could not reach your Speech Engine WebSocket).';
+                }
+                status.textContent = 'Disconnected — ' + reason;
+                btn.textContent = 'Start conversation';
+                btn.disabled = false;
+                conversation = null;
+              },
+              onError: function (error) {
+                status.textContent =
+                  'Error: ' + (error && error.message ? error.message : String(error));
+                btn.disabled = false;
+              },
+              onStatusChange: function (state) {
+                if (state && state.status) {
+                  status.textContent = 'Status: ' + state.status;
+                }
+              },
+              onModeChange: function (mode) {
+                if (!mode || !mode.mode) return;
+                if (mode.mode === 'listening') {
+                  status.textContent = 'Listening… speak, then pause when done.';
+                } else if (mode.mode === 'speaking') {
+                  status.textContent = 'Agent speaking…';
+                } else {
+                  status.textContent = 'Mode: ' + mode.mode;
+                }
+              },
+              onMessage: function (msg) {
+                if (msg && msg.message) {
+                  console.log('[eleven-talk]', msg.source || 'unknown', msg.message);
+                }
+              },
+            };
+            if (cfg.first_message) {
+              startOpts.overrides = {
+                agent: { firstMessage: cfg.first_message },
+              };
+            }
+            conversation = await Conversation.startSession(startOpts);
+          } catch (err) {
+            status.textContent = 'Start failed: ' + err.message;
+            btn.disabled = false;
+          }
+        });
+      }
+    );
+
+    window.aiui.registerView(
+      'realtime-talk',
+      async function (container) {
+        container.innerHTML = '';
+        var wrap = el('div', 'padding:24px;max-width:640px;color:var(--db-text,#eee)');
+        wrap.appendChild(el('h2', 'margin:0 0 12px 0', 'GPT Realtime voice'));
+        wrap.appendChild(
+          el(
+            'p',
+            'margin:0 0 20px 0;line-height:1.6;color:var(--db-text-dim,#94a3b8)',
+            'Speech-to-speech via OpenAI gpt-realtime-2.1-mini (WebRTC).'
+          )
+        );
+        var status = el('div', 'margin-bottom:16px;font-size:13px', 'Loading config…');
+        var btn = el(
+          'button',
+          'padding:12px 20px;border-radius:10px;border:none;background:var(--db-accent,#6366f1);' +
+            'color:#fff;font-size:15px;font-weight:600;cursor:pointer',
+          'Start conversation'
+        );
+        btn.disabled = true;
+        wrap.appendChild(status);
+        wrap.appendChild(btn);
+        container.appendChild(wrap);
+
+        var pc = null;
+        var dc = null;
+        var audioEl = null;
+        var localStream = null;
+        var callId = null;
+        var cfg = null;
+
+        async function saveTranscript(role, text) {
+          if (!callId || !text) return;
+          try {
+            await postJson('/api/voice/realtime/transcript', {
+              call_id: callId,
+              role: role,
+              text: text,
+            });
+          } catch (e) {
+            console.warn('[realtime-talk] transcript save failed', e);
+          }
+        }
+
+        function handleRealtimeEvent(event) {
+          if (!event || !event.type) return;
+          if (
+            event.type === 'conversation.item.input_audio_transcription.completed' &&
+            event.transcript
+          ) {
+            saveTranscript('user', event.transcript);
+            status.textContent = 'You: ' + event.transcript;
+          }
+          if (event.type === 'response.output_audio_transcript.done' && event.transcript) {
+            saveTranscript('agent', event.transcript);
+            status.textContent = 'Agent: ' + event.transcript;
+          }
+          if (event.type === 'response.output_audio_transcript.delta' && event.delta) {
+            status.textContent = 'Agent speaking…';
+          }
+          if (event.type === 'input_audio_buffer.speech_started') {
+            status.textContent = 'Listening…';
+          }
+        }
+
+        async function endSession() {
+          if (dc) {
+            try {
+              dc.close();
+            } catch (e) {
+              /* ignore */
+            }
+            dc = null;
+          }
+          if (pc) {
+            try {
+              pc.close();
+            } catch (e) {
+              /* ignore */
+            }
+            pc = null;
+          }
+          if (localStream) {
+            localStream.getTracks().forEach(function (t) {
+              t.stop();
+            });
+            localStream = null;
+          }
+          if (audioEl && audioEl.parentNode) {
+            audioEl.parentNode.removeChild(audioEl);
+            audioEl = null;
+          }
+          if (callId) {
+            try {
+              await postJson('/api/voice/realtime/end', { call_id: callId });
+            } catch (e) {
+              /* ignore */
+            }
+          }
+          callId = null;
+          status.textContent = 'Conversation ended.';
+          btn.textContent = 'Start conversation';
+          btn.disabled = false;
+        }
+
+        try {
+          cfg = await fetchJson('/api/voice/realtime/config', 8);
+          if (!cfg.enabled) {
+            status.textContent =
+              cfg.error || 'Set OPENAI_API_KEY in .env, then restart .\\start_dev.ps1';
+            btn.style.display = 'none';
+            return;
+          }
+          status.textContent = 'Ready (' + (cfg.model || 'gpt-realtime-2.1-mini') + ').';
+          btn.disabled = false;
+        } catch (err) {
+          status.textContent = 'Config error: ' + err.message;
+          return;
+        }
+
+        btn.addEventListener('click', async function () {
+          if (pc && btn.textContent === 'End conversation') {
+            await endSession();
+            return;
+          }
+          btn.disabled = true;
+          status.textContent = 'Starting WebRTC session…';
+          try {
+            var callResp = await postJson('/api/voice/realtime/new-call', {
+              user_id: voiceUserId(),
+            });
+            callId = callResp.call_id;
+            localStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            pc = new RTCPeerConnection();
+            audioEl = document.createElement('audio');
+            audioEl.autoplay = true;
+            audioEl.style.display = 'none';
+            wrap.appendChild(audioEl);
+            pc.ontrack = function (e) {
+              if (audioEl) audioEl.srcObject = e.streams[0];
+            };
+            localStream.getTracks().forEach(function (track) {
+              pc.addTrack(track, localStream);
+            });
+            dc = pc.createDataChannel('oai-events');
+            dc.addEventListener('open', function () {
+              if (cfg.first_message) {
+                dc.send(
+                  JSON.stringify({
+                    type: 'response.create',
+                    response: {
+                      instructions:
+                        'Greet the user by saying exactly: ' + cfg.first_message,
+                    },
+                  })
+                );
+              }
+            });
+            dc.addEventListener('message', function (e) {
+              try {
+                handleRealtimeEvent(JSON.parse(e.data));
+              } catch (err) {
+                console.warn('[realtime-talk] event parse failed', err);
+              }
+            });
+            var offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+            var sdpResp = await fetch(
+              '/api/voice/realtime/session?call_id=' + encodeURIComponent(callId),
+              {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/sdp' },
+                body: offer.sdp,
+              }
+            );
+            if (!sdpResp.ok) {
+              var errText = await sdpResp.text();
+              throw new Error(errText || 'SDP exchange failed');
+            }
+            var answerSdp = await sdpResp.text();
+            await pc.setRemoteDescription({ type: 'answer', sdp: answerSdp });
+            status.textContent = 'Connected — speak when ready.';
+            btn.textContent = 'End conversation';
+            btn.disabled = false;
+          } catch (err) {
+            status.textContent = 'Start failed: ' + err.message;
+            await endSession();
+            btn.disabled = false;
+          }
+        });
+      }
+    );
+
+    window.aiui.registerView(
+      'config',
+      async function (container) {
+        container.innerHTML = '';
+        var wrap = el('div', 'padding:24px;max-width:900px;color:var(--db-text,#eee)');
+        wrap.appendChild(el('h2', 'margin:0 0 8px 0', 'Voice stack doctor'));
+        wrap.appendChild(
+          el(
+            'p',
+            'margin:0 0 16px 0;font-size:13px;color:var(--db-text-dim,#94a3b8)',
+            'Checks .env keys, local ports, APIs, and Speech Engine tunnel reachability.'
+          )
+        );
+        var status = el('div', 'margin-bottom:16px;font-size:13px', 'Running checks…');
+        var tableHost = el('div', '');
+        wrap.appendChild(status);
+        wrap.appendChild(tableHost);
+        container.appendChild(wrap);
+
+        function statusColor(st) {
+          if (st === 'pass') return '#22c55e';
+          if (st === 'warn') return '#eab308';
+          return '#ef4444';
+        }
+
+        try {
+          var data = await fetchJson('/api/voice/doctor', 12);
+          var summary = data.summary || {};
+          status.textContent =
+            'Passed ' +
+            (summary.passed || 0) +
+            ' · Warnings ' +
+            (summary.warnings || 0) +
+            ' · Failed ' +
+            (summary.failed || 0);
+          var rows = (data.checks || []).map(function (c) {
+            return [
+              c.name || '—',
+              c.status || '—',
+              c.detail || '—',
+            ];
+          });
+          renderUiTree(
+            {
+              type: 'layout',
+              children: [
+                {
+                  type: 'table',
+                  headers: ['Check', 'Status', 'Detail'],
+                  rows: rows.length ? rows : [['—', '—', '—']],
+                },
+              ],
+            },
+            tableHost
+          );
+          var badges = tableHost.querySelectorAll('td');
+          badges.forEach(function (cell) {
+            if (cell.textContent === 'pass' || cell.textContent === 'warn' || cell.textContent === 'fail') {
+              cell.style.color = statusColor(cell.textContent);
+              cell.style.fontWeight = '600';
+            }
+          });
+        } catch (err) {
+          status.textContent = 'Doctor failed: ' + err.message;
+        }
+      },
+      function () {}
+    );
+
+    console.log(
+      '[voice plugin] Registered call-detail + web-talk + eleven-talk + realtime-talk + config views'
+    );
+
+    var path = (window.location.pathname || '').replace(/^\//, '');
+    if (
+      (path === 'web-talk' ||
+        path === 'call-detail' ||
+        path === 'eleven-talk' ||
+        path === 'realtime-talk') &&
+      typeof window.aiui.selectPage === 'function'
+    ) {
+      window.aiui.selectPage(path);
+    } else if (
+      path === 'web-talk' ||
+      path === 'call-detail' ||
+      path === 'eleven-talk' ||
+      path === 'realtime-talk'
+    ) {
+      var n = 0;
+      var t = setInterval(function () {
+        n += 1;
+        if (typeof window.aiui.selectPage === 'function') {
+          clearInterval(t);
+          window.aiui.selectPage(path);
+        } else if (n > 50) {
+          clearInterval(t);
+        }
+      }, 100);
+    }
+  }
+
+  whenReady(registerVoiceViews);
+})();

examples/python/voice-agent/realtime_routes.py

@@ -0,0 +1,115 @@
+"""HTTP routes for OpenAI Realtime WebRTC voice."""
+
+from __future__ import annotations
+
+import logging
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse, PlainTextResponse
+
+from integrations.voice.realtime import (
+    RealtimeConfigError,
+    load_realtime_settings,
+    mark_session_started,
+    new_call_id,
+    persist_transcript_line,
+    realtime_enabled,
+    create_webrtc_session,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def api_realtime_config(_request: Request) -> JSONResponse:
+    try:
+        settings = load_realtime_settings()
+        enabled = realtime_enabled()
+        error = None
+    except RealtimeConfigError as exc:
+        settings = None
+        enabled = False
+        error = str(exc)
+    return JSONResponse(
+        {
+            "enabled": enabled,
+            "error": error,
+            "model": settings.model if settings else None,
+            "voice": settings.voice if settings else None,
+            "reasoning_effort": settings.reasoning_effort if settings else None,
+            "first_message": settings.first_message if settings else None,
+        }
+    )
+
+
+async def api_realtime_new_call(request: Request) -> JSONResponse:
+    from integrations.voice.session_memory import bind_call_user, voice_user_session_id
+
+    try:
+        payload = await request.json()
+    except Exception:  # noqa: BLE001
+        payload = {}
+    call_id = new_call_id()
+    mark_session_started(call_id)
+    user_id = str(payload.get("user_id") or "").strip()
+    praison_session_id = None
+    if user_id:
+        praison_session_id = bind_call_user(call_id, user_id)
+    return JSONResponse(
+        {
+            "call_id": call_id,
+            "user_id": user_id or None,
+            "praison_session_id": praison_session_id or (voice_user_session_id(user_id) if user_id else None),
+        }
+    )
+
+
+async def api_realtime_session(request: Request) -> PlainTextResponse | JSONResponse:
+    """Unified WebRTC interface — browser SDP in, OpenAI SDP answer out."""
+    call_id = request.query_params.get("call_id", "").strip()
+    body = await request.body()
+    sdp_offer = body.decode("utf-8").strip()
+    if not sdp_offer:
+        return JSONResponse({"error": "Missing SDP offer body"}, status_code=400)
+    try:
+        sdp_answer = await create_webrtc_session(sdp_offer, call_id=call_id or None)
+    except RealtimeConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("Realtime WebRTC session failed")
+        return JSONResponse({"error": str(exc)}, status_code=502)
+    if call_id:
+        mark_session_started(call_id)
+    return PlainTextResponse(sdp_answer, media_type="application/sdp")
+
+
+async def api_realtime_transcript(request: Request) -> JSONResponse:
+    try:
+        payload = await request.json()
+    except Exception:  # noqa: BLE001
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+    call_id = str(payload.get("call_id") or "").strip()
+    role = str(payload.get("role") or "user").strip()
+    text = str(payload.get("text") or "").strip()
+    if not call_id or not text:
+        return JSONResponse({"error": "call_id and text required"}, status_code=400)
+    from integrations.voice.session_memory import record_voice_turn
+
+    persist_transcript_line(call_id, role, text)
+    if role == "user":
+        await record_voice_turn(call_id, user_text=text)
+    else:
+        await record_voice_turn(call_id, agent_text=text)
+    return JSONResponse({"ok": True})
+
+
+async def api_realtime_end(request: Request) -> JSONResponse:
+    try:
+        payload = await request.json()
+    except Exception:  # noqa: BLE001
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+    call_id = str(payload.get("call_id") or "").strip()
+    if call_id:
+        from integrations.voice.call_finalize import finalize_call
+
+        await finalize_call(call_id, status="ended (customer-ended-call)")
+    return JSONResponse({"ok": True})

examples/python/voice-agent/requirements-voice.txt

@@ -0,0 +1,3 @@
+httpx
+elevenlabs>=2.47.0
+openai

examples/python/voice-agent/setup_all.ps1

@@ -0,0 +1,11 @@
+# One command: start app + tunnel + configure voice provider automatically.
+Set-Location $PSScriptRoot
+if (-not (Test-Path .env)) { Copy-Item .env.example .env; Write-Host "Created .env — add VOICE_* keys" ; exit 1 }
+
+.\start_dev.ps1
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+
+Write-Host ""
+Write-Host "Configuring voice provider via API..." -ForegroundColor Cyan
+py -3.13 setup_voice_provider.py
+exit $LASTEXITCODE

examples/python/voice-agent/setup_speech_engine.py

@@ -0,0 +1,172 @@
+"""Create or update ElevenLabs Speech Engine with the public WebSocket URL.
+
+Usage:
+    cd examples/python/voice-agent
+    .\\start_dev.ps1          # sets PUBLIC_API_BASE_URL first
+    py -3.13 setup_speech_engine.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parent
+ENV_PATH = _ROOT / ".env"
+
+
+def _load_env() -> None:
+    if not ENV_PATH.is_file():
+        return
+    for raw in ENV_PATH.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key:
+            os.environ[key] = value
+
+
+def _write_env_value(key: str, value: str) -> None:
+    lines = ENV_PATH.read_text(encoding="utf-8").splitlines() if ENV_PATH.is_file() else []
+    updated = False
+    new_lines: list[str] = []
+    for line in lines:
+        if line.strip().startswith(f"{key}="):
+            new_lines.append(f"{key}={value}")
+            updated = True
+        else:
+            new_lines.append(line)
+    if not updated:
+        new_lines.append(f"{key}={value}")
+    ENV_PATH.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
+    os.environ[key] = value
+
+
+def _http_to_ws(base: str) -> str:
+    base = base.strip().rstrip("/")
+    if base.startswith("https://"):
+        return "wss://" + base[len("https://") :] + "/ws"
+    if base.startswith("http://"):
+        return "ws://" + base[len("http://") :] + "/ws"
+    raise RuntimeError(f"Unsupported URL: {base}")
+
+
+def _public_ws_url() -> str:
+    # Prefer dedicated Speech Engine tunnel (sidecar on 8002).
+    speech_base = os.getenv("SPEECH_ENGINE_PUBLIC_URL", "").strip().rstrip("/")
+    if speech_base:
+        return _http_to_ws(speech_base)
+    base = os.getenv("PUBLIC_API_BASE_URL", "").strip().rstrip("/")
+    if not base:
+        raise RuntimeError(
+            "Set SPEECH_ENGINE_PUBLIC_URL or PUBLIC_API_BASE_URL in .env "
+            "(run .\\start_dev.ps1 first)"
+        )
+    return _http_to_ws(base)
+
+
+async def _patch_overrides(client: object, engine_id: str) -> None:
+    """Enable client first-message override (not exposed on speech_engine.update yet)."""
+    wrapper = getattr(client, "_client_wrapper", None)
+    if wrapper is None:
+        return
+    try:
+        await wrapper.httpx_client.request(
+            f"v1/speech-engine/{engine_id}",
+            method="PATCH",
+            json={"overrides": {"first_message": True}},
+            headers={"content-type": "application/json"},
+        )
+        print("Enabled first_message client override")
+    except Exception as exc:  # noqa: BLE001
+        print(f"Note: could not enable first_message override ({exc})")
+
+
+async def _ensure_engine() -> str:
+    api_key = os.getenv("ELEVENLABS_API_KEY", "").strip()
+    if not api_key:
+        raise RuntimeError("Set ELEVENLABS_API_KEY in .env")
+
+    try:
+        from elevenlabs import AsyncElevenLabs
+    except ImportError as exc:
+        raise RuntimeError(
+            "Install Speech Engine SDK: pip install 'elevenlabs>=2.47.0'"
+        ) from exc
+
+    if not hasattr(AsyncElevenLabs(api_key="check"), "speech_engine"):
+        raise RuntimeError(
+            "elevenlabs package is too old for Speech Engine. Run: "
+            "pip install -U 'elevenlabs>=2.47.0'"
+        )
+
+    ws_url = _public_ws_url()
+    engine_id = os.getenv("SPEECH_ENGINE_ID", "").strip()
+    client = AsyncElevenLabs(api_key=api_key)
+
+    turn_config = {"turn_eagerness": "eager", "turn_timeout": 5.0}
+    voice_id = os.getenv("ELEVENLABS_VOICE_ID", "").strip() or "cjVigY5qzO86Huf0OWal"
+    tts_config = {"model_id": "eleven_flash_v2", "voice_id": voice_id}
+
+    if engine_id:
+        updated = await client.speech_engine.update(
+            speech_engine_id=engine_id,
+            speech_engine={"ws_url": ws_url},
+            turn=turn_config,
+            tts=tts_config,
+        )
+        resolved = getattr(updated, "speech_engine_id", None) or getattr(updated, "engine_id", None) or engine_id
+        print(f"Updated Speech Engine: {resolved}")
+        print(f"WebSocket URL: {ws_url}")
+        print(f"TTS voice_id: {voice_id}")
+        await _patch_overrides(client, str(resolved))
+        return str(resolved)
+
+    created = await client.speech_engine.create(
+        name="PraisonAI Voice",
+        speech_engine={"ws_url": ws_url},
+        turn=turn_config,
+        tts=tts_config,
+        overrides={"first_message": True},
+    )
+    resolved = getattr(created, "engine_id", None) or getattr(created, "id", None)
+    if not resolved:
+        raise RuntimeError("Speech Engine create did not return an engine_id")
+    print(f"Created Speech Engine: {resolved}")
+    print(f"WebSocket URL: {ws_url}")
+    print(f"TTS voice_id: {voice_id}")
+    return str(resolved)
+
+
+async def main_async() -> int:
+    _load_env()
+    try:
+        engine_id = await _ensure_engine()
+    except RuntimeError as exc:
+        print(f"Setup failed: {exc}")
+        return 1
+    except Exception as exc:  # noqa: BLE001
+        message = str(exc)
+        if "convai_write" in message or "missing_permissions" in message:
+            print("Setup failed: ElevenLabs API key lacks convai_write permission.")
+            print(
+                "In ElevenLabs dashboard: API Keys -> edit key -> ElevenAgents: enable Write."
+            )
+        else:
+            print(f"Setup failed: {exc}")
+        return 1
+
+    _write_env_value("SPEECH_ENGINE_ID", engine_id)
+    print("Speech Engine auto-setup complete.")
+    return 0
+
+
+def main() -> int:
+    return asyncio.run(main_async())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examples/python/voice-agent/setup_voice_provider.py

@@ -0,0 +1,369 @@
+"""Configure voice provider assistant: tools + webhook URL + auth header.
+
+Usage:
+    cd examples/python/voice-agent
+    py -3.13 setup_voice_provider.py
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+_ROOT = Path(__file__).resolve().parent
+ENV_PATH = _ROOT / ".env"
+WEBHOOK_SECRET_HEADER = "X-Voice-Webhook-Secret"
+
+
+def _load_env() -> None:
+    if not ENV_PATH.is_file():
+        return
+    for raw in ENV_PATH.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key:
+            os.environ[key] = value
+
+
+def _write_env_value(key: str, value: str) -> None:
+    lines = ENV_PATH.read_text(encoding="utf-8").splitlines() if ENV_PATH.is_file() else []
+    updated = False
+    new_lines: list[str] = []
+    for line in lines:
+        if line.strip().startswith(f"{key}="):
+            new_lines.append(f"{key}={value}")
+            updated = True
+        else:
+            new_lines.append(line)
+    if not updated:
+        new_lines.append(f"{key}={value}")
+    ENV_PATH.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
+    os.environ[key] = value
+
+
+def _api_key() -> str:
+    return os.getenv("VOICE_PRIVATE_API_KEY", "").strip() or os.getenv("VOICE_API_KEY", "").strip()
+
+
+def _api_base() -> str:
+    return os.getenv("VOICE_API_BASE", "").strip().rstrip("/")
+
+
+def _request(
+    method: str,
+    path: str,
+    *,
+    api_key: str,
+    api_base: str,
+    body: dict | None = None,
+) -> dict | list | None:
+    url = f"{api_base}{path}"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    response = httpx.request(method, url, headers=headers, json=body, timeout=30.0)
+    if response.status_code >= 400:
+        print(f"ERROR {method} {path} -> {response.status_code}")
+        print(response.text[:1500])
+        return None
+    if not response.content:
+        return {}
+    return response.json()
+
+
+def _tool_specs() -> list[dict[str, Any]]:
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_time",
+                "description": "Returns the current UTC time when the caller asks for the time.",
+                "parameters": {"type": "object", "properties": {}, "required": []},
+            },
+            "async": False,
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "echo_message",
+                "description": "Repeats back a message the caller provides.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "description": "The message to repeat back to the caller.",
+                        }
+                    },
+                    "required": ["message"],
+                },
+            },
+            "async": False,
+        },
+    ]
+
+
+def ensure_server_secret() -> str:
+    secret = os.getenv("VOICE_SERVER_URL_SECRET", "").strip()
+    if not secret:
+        secret = str(uuid.uuid4())
+        _write_env_value("VOICE_SERVER_URL_SECRET", secret)
+        print("Generated VOICE_SERVER_URL_SECRET")
+    return secret
+
+
+def ensure_assistant_model(api_key: str, api_base: str, assistant_id: str) -> dict[str, Any]:
+    assistant = _request("GET", f"/assistant/{assistant_id}", api_key=api_key, api_base=api_base)
+    if not isinstance(assistant, dict):
+        raise RuntimeError("Could not load assistant")
+    model = dict(assistant.get("model") or {})
+    target = os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini")
+    if model.get("provider") != "openai" or model.get("model") != target:
+        model["provider"] = "openai"
+        model["model"] = target
+        patched = _request(
+            "PATCH",
+            f"/assistant/{assistant_id}",
+            api_key=api_key,
+            api_base=api_base,
+            body={"model": model},
+        )
+        if patched is None:
+            raise RuntimeError(f"Failed to set assistant model to {target}")
+        print(f"Set assistant model to openai/{target}")
+    return model
+
+
+def ensure_agent_model_env() -> str:
+    """Ensure VOICE_AGENT_MODEL is set in .env and return the target model."""
+    target = os.getenv("VOICE_AGENT_MODEL", "").strip() or "gpt-4o-mini"
+    if not os.getenv("VOICE_AGENT_MODEL", "").strip():
+        _write_env_value("VOICE_AGENT_MODEL", target)
+        print(f"Set VOICE_AGENT_MODEL={target} in .env")
+    return target
+
+
+def ensure_openai_credential(api_key: str, api_base: str, openai_api_key: str) -> tuple[str, str]:
+    """Create or reuse an OpenAI-compatible credential in the provider account."""
+    existing = _request("GET", "/credential", api_key=api_key, api_base=api_base)
+    if isinstance(existing, list):
+        preferred = sorted(
+            [item for item in existing if isinstance(item, dict) and item.get("id")],
+            key=lambda item: 0 if str(item.get("provider") or "") == "openai" else 1,
+        )
+        for item in preferred:
+            provider = str(item.get("provider") or "")
+            if provider in ("openai", "custom-llm"):
+                cred_id = str(item["id"])
+                print(f"Reusing credential ({provider}): {cred_id}")
+                updated = _request(
+                    "PATCH",
+                    f"/credential/{cred_id}",
+                    api_key=api_key,
+                    api_base=api_base,
+                    body={
+                        "provider": provider,
+                        "apiKey": openai_api_key,
+                        "name": "Praison Voice OpenAI",
+                    },
+                )
+                if updated is None:
+                    raise RuntimeError("Failed to update OpenAI credential")
+                return cred_id, provider
+
+    for provider in ("openai", "custom-llm"):
+        created = _request(
+            "POST",
+            "/credential",
+            api_key=api_key,
+            api_base=api_base,
+            body={
+                "provider": provider,
+                "apiKey": openai_api_key,
+                "name": "Praison Voice OpenAI",
+            },
+        )
+        if isinstance(created, dict) and created.get("id"):
+            cred_id = str(created["id"])
+            print(f"Created credential ({provider}): {cred_id}")
+            return cred_id, provider
+
+    raise RuntimeError(
+        "Failed to create OpenAI credential. Add the key manually in the provider dashboard "
+        "under Provider Keys / OpenAI, or enable gpt-4o-mini on your OpenAI project."
+    )
+
+
+def ensure_openai_on_assistant(
+    api_key: str, api_base: str, assistant_id: str, openai_credential_id: str, *, provider: str
+) -> None:
+    assistant = _request("GET", f"/assistant/{assistant_id}", api_key=api_key, api_base=api_base)
+    if not isinstance(assistant, dict):
+        raise RuntimeError("Could not load assistant for OpenAI setup")
+
+    target_model = os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini")
+    if provider == "custom-llm":
+        model = dict(assistant.get("model") or {})
+        model["model"] = target_model
+        model["provider"] = "custom-llm"
+        model["url"] = "https://api.openai.com/v1"
+        model["metadataSendMode"] = "off"
+        model.pop("credentialId", None)
+    else:
+        # Native OpenAI — drop custom-llm-only fields from prior config.
+        model = {"provider": "openai", "model": target_model}
+
+    patched = _request(
+        "PATCH",
+        f"/assistant/{assistant_id}",
+        api_key=api_key,
+        api_base=api_base,
+        body={"model": model},
+    )
+    if patched is None:
+        raise RuntimeError("Failed to attach OpenAI credential to assistant")
+    print(f"Configured assistant model ({provider}): {target_model}")
+
+
+def ensure_tools(api_key: str, api_base: str, assistant_id: str) -> list[str]:
+    existing = _request("GET", "/tool", api_key=api_key, api_base=api_base)
+    by_name: dict[str, str] = {}
+    if isinstance(existing, list):
+        for item in existing:
+            fn = item.get("function") if isinstance(item, dict) else None
+            if isinstance(fn, dict) and fn.get("name") and item.get("id"):
+                by_name[str(fn["name"])] = str(item["id"])
+
+    tool_ids: list[str] = []
+    for spec in _tool_specs():
+        name = spec["function"]["name"]
+        if name in by_name:
+            tool_id = by_name[name]
+            print(f"Reusing tool {name}: {tool_id}")
+        else:
+            created = _request("POST", "/tool", api_key=api_key, api_base=api_base, body=spec)
+            if not isinstance(created, dict) or not created.get("id"):
+                raise RuntimeError(f"Failed to create tool {name}")
+            tool_id = str(created["id"])
+            print(f"Created tool {name}: {tool_id}")
+        tool_ids.append(tool_id)
+
+    assistant = _request("GET", f"/assistant/{assistant_id}", api_key=api_key, api_base=api_base)
+    if not isinstance(assistant, dict):
+        raise RuntimeError("Could not load assistant")
+
+    model = dict(assistant.get("model") or {})
+    if not model.get("provider"):
+        raise RuntimeError("Assistant has no model.provider — configure a model in the provider dashboard first")
+
+    existing_ids = [str(x) for x in (model.get("toolIds") or [])]
+    model["toolIds"] = list(dict.fromkeys(existing_ids + tool_ids))
+
+    messages = list(model.get("messages") or [])
+    system_hint = (
+        "You are a helpful voice assistant. When the caller asks for the time, "
+        "call get_current_time. When they ask you to repeat something, call echo_message."
+    )
+    if not messages:
+        model["messages"] = [{"role": "system", "content": system_hint}]
+    else:
+        for msg in messages:
+            if isinstance(msg, dict) and msg.get("role") == "system":
+                content = str(msg.get("content") or "")
+                if "get_current_time" not in content:
+                    msg["content"] = f"{content.rstrip()}\n\n{system_hint}"
+                break
+        else:
+            messages.insert(0, {"role": "system", "content": system_hint})
+        model["messages"] = messages
+
+    patched = _request(
+        "PATCH",
+        f"/assistant/{assistant_id}",
+        api_key=api_key,
+        api_base=api_base,
+        body={"model": model},
+    )
+    if patched is None:
+        raise RuntimeError("Failed to attach tools to assistant")
+
+    print("Attached tool IDs:", model["toolIds"])
+    return tool_ids
+
+
+def ensure_webhook(api_key: str, api_base: str, assistant_id: str, webhook_url: str, secret: str) -> None:
+    assistant = _request("GET", f"/assistant/{assistant_id}", api_key=api_key, api_base=api_base)
+    if not isinstance(assistant, dict):
+        raise RuntimeError("Could not load assistant for webhook setup")
+
+    server = dict(assistant.get("server") or {})
+    server["url"] = webhook_url.rstrip("/")
+    server["headers"] = {WEBHOOK_SECRET_HEADER: secret}
+    server.pop("credentialId", None)
+    server.pop("secret", None)
+
+    patched = _request(
+        "PATCH",
+        f"/assistant/{assistant_id}",
+        api_key=api_key,
+        api_base=api_base,
+        body={"server": server},
+    )
+    if patched is None:
+        raise RuntimeError("Failed to configure assistant server URL")
+
+    print(f"Server URL: {webhook_url}")
+    print(f"Webhook auth header: {WEBHOOK_SECRET_HEADER}")
+
+
+def main() -> int:
+    _load_env()
+    api_key = _api_key()
+    api_base = _api_base()
+    assistant_id = os.getenv("VOICE_ASSISTANT_ID", "").strip()
+    public_base = os.getenv("PUBLIC_API_BASE_URL", "").strip().rstrip("/")
+
+    if not api_key:
+        print("Set VOICE_PRIVATE_API_KEY in .env")
+        return 1
+    if not api_base:
+        print("Set VOICE_API_BASE in .env")
+        return 1
+    if not assistant_id:
+        print("Set VOICE_ASSISTANT_ID in .env")
+        return 1
+    if not public_base:
+        print("Set PUBLIC_API_BASE_URL in .env (run .\\start_dev.ps1 first)")
+        return 1
+
+    secret = ensure_server_secret()
+    webhook_url = f"{public_base}/webhooks/voice"
+    target_model = ensure_agent_model_env()
+    openai_api_key = os.getenv("OPENAI_API_KEY", "").strip()
+
+    try:
+        if openai_api_key:
+            cred_id, cred_provider = ensure_openai_credential(api_key, api_base, openai_api_key)
+            ensure_openai_on_assistant(
+                api_key, api_base, assistant_id, cred_id, provider=cred_provider
+            )
+            print(f"Assistant model target: {target_model}")
+        else:
+            print("OPENAI_API_KEY not set — skipping provider OpenAI credential setup")
+        ensure_tools(api_key, api_base, assistant_id)
+        ensure_webhook(api_key, api_base, assistant_id, webhook_url, secret)
+    except RuntimeError as exc:
+        print(f"Setup failed: {exc}")
+        return 1
+
+    print("Voice provider auto-setup complete.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examples/python/voice-agent/speech_engine_routes.py

@@ -0,0 +1,110 @@
+"""HTTP + WebSocket routes for ElevenLabs Speech Engine."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.websockets import WebSocket, WebSocketDisconnect
+
+from integrations.voice.speech_engine import (
+    SpeechEngineConfigError,
+    get_engine_resource,
+    get_webrtc_token,
+    handle_session_close,
+    handle_session_init,
+    handle_user_transcript,
+    load_speech_engine_settings,
+    speech_engine_enabled,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def api_speech_engine_config(_request: Request) -> JSONResponse:
+    try:
+        settings = load_speech_engine_settings()
+        enabled = speech_engine_enabled()
+        error = None
+    except SpeechEngineConfigError as exc:
+        settings = None
+        enabled = False
+        error = str(exc)
+    tools: list[str] = []
+    if enabled:
+        try:
+            from integrations.voice.agent_runner import list_registered_tool_names
+
+            tools = list_registered_tool_names()
+        except Exception:  # noqa: BLE001
+            tools = ["get_current_time", "echo_message"]
+    return JSONResponse(
+        {
+            "enabled": enabled,
+            "error": error,
+            "engine_id": settings.engine_id if settings else None,
+            "ws_url": settings.public_ws_url if settings else None,
+            "client_sdk_url": "https://esm.sh/@elevenlabs/client",
+            "first_message": settings.first_message if settings else None,
+            "model": os.getenv("VOICE_AGENT_MODEL", "gpt-4o-mini"),
+            "tools": tools,
+        }
+    )
+
+
+async def api_speech_engine_token(_request: Request) -> JSONResponse:
+    try:
+        token = get_webrtc_token()
+    except SpeechEngineConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("Speech Engine token mint failed")
+        return JSONResponse({"error": str(exc)}, status_code=502)
+    return JSONResponse({"token": token})
+
+
+async def speech_engine_websocket(websocket: WebSocket) -> None:
+    try:
+        engine = await get_engine_resource()
+    except SpeechEngineConfigError as exc:
+        logger.warning("Speech Engine WS rejected: %s", exc)
+        return
+
+    headers = dict(websocket.headers)
+    if hasattr(engine, "verify_request") and not engine.verify_request(headers):
+        logger.warning(
+            "Speech Engine WS unauthorized (missing or invalid ElevenLabs JWT header)"
+        )
+        return
+
+    await websocket.accept()
+    logger.info("Speech Engine WebSocket accepted from ElevenLabs")
+    session = engine.create_session(websocket, debug=False)
+
+    async def on_transcript(transcript, sess):  # noqa: ANN001
+        await handle_user_transcript(transcript, sess)
+
+    async def on_init(conversation_id, sess):  # noqa: ANN001
+        await handle_session_init(conversation_id, sess)
+
+    async def on_close(sess):  # noqa: ANN001
+        await handle_session_close(sess)
+
+    def on_error(err, sess=None):  # noqa: ANN001
+        logger.error("Speech Engine session error: %s", err)
+
+    session.on("user_transcript", on_transcript)
+    session.on("init", on_init)
+    session.on("close", on_close)
+    session.on("error", on_error)
+
+    try:
+        await session.run()
+    except WebSocketDisconnect:
+        logger.info("Speech Engine WebSocket disconnected")
+        await handle_session_close(session)
+    except Exception:  # noqa: BLE001
+        logger.exception("Speech Engine WebSocket session failed")
+        await handle_session_close(session)

examples/python/voice-agent/speech_engine_sidecar.py

@@ -0,0 +1,89 @@
+"""Standalone ElevenLabs Speech Engine WebSocket server (port 8002).
+
+ElevenLabs connects here for transcripts; the dashboard stays on 8001.
+Official SDK path: engine.serve() — more reliable than in-app Starlette /ws.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parent
+if str(_ROOT) not in __import__("sys").path:
+    __import__("sys").path.insert(0, str(_ROOT))
+
+
+def _load_env() -> None:
+    env_path = _ROOT / ".env"
+    if not env_path.is_file():
+        return
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip(), value.strip()
+        if key:
+            os.environ[key] = value
+
+
+async def _main() -> None:
+    _load_env()
+    api_key = os.getenv("ELEVENLABS_API_KEY", "").strip()
+    engine_id = os.getenv("SPEECH_ENGINE_ID", "").strip()
+    port = int(os.getenv("SPEECH_ENGINE_PORT", "8002"))
+    disable_auth = os.getenv("SPEECH_ENGINE_DISABLE_AUTH", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    )
+
+    if not api_key or not engine_id:
+        raise SystemExit("Set ELEVENLABS_API_KEY and SPEECH_ENGINE_ID in .env")
+
+    from elevenlabs import AsyncElevenLabs
+
+    from integrations.voice.speech_engine import (
+        handle_session_close,
+        handle_session_disconnect,
+        handle_session_init,
+        handle_user_transcript,
+    )
+
+    client = AsyncElevenLabs(api_key=api_key)
+    engine = await client.speech_engine.get(engine_id)
+
+    async def on_transcript(transcript, session):  # noqa: ANN001
+        await handle_user_transcript(transcript, session)
+
+    async def on_init(conversation_id, session):  # noqa: ANN001
+        await handle_session_init(conversation_id, session)
+
+    async def on_close(session):  # noqa: ANN001
+        await handle_session_close(session)
+
+    async def on_disconnect(session):  # noqa: ANN001
+        await handle_session_disconnect(session)
+
+    async def on_error(err, session):  # noqa: ANN001
+        print(f"[speech sidecar] error: {err}", flush=True)
+
+    debug = os.getenv("SPEECH_ENGINE_DEBUG", "true").lower() in ("1", "true", "yes")
+    print(f"[speech sidecar] listening on ws://127.0.0.1:{port}/ws (debug={debug})", flush=True)
+    await engine.serve(
+        port=port,
+        path="/ws",
+        debug=debug,
+        disable_auth=disable_auth,
+        on_init=on_init,
+        on_transcript=on_transcript,
+        on_close=on_close,
+        on_disconnect=on_disconnect,
+        on_error=on_error,
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(_main())

examples/python/voice-agent/start_dev.ps1

@@ -0,0 +1,428 @@
+# Start voice-agent + Cloudflare tunnel for provider webhook URL.
+# Usage: .\start_dev.ps1
+#        .\start_dev.ps1 -Restart   # kill old app and reload code
+
+param(
+    [int]$Port = 8001,
+    [switch]$Restart
+)
+
+$ErrorActionPreference = "Stop"
+$Root = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $Root
+
+function Load-DotEnv {
+    $envFile = Join-Path $Root ".env"
+    if (-not (Test-Path $envFile)) { return }
+    Get-Content $envFile | ForEach-Object {
+        $line = $_.Trim()
+        if (-not $line -or $line.StartsWith("#") -or $line -notmatch "=") { return }
+        $key, $value = $line -split "=", 2
+        $key = $key.Trim()
+        if ($key -and -not [string]::IsNullOrWhiteSpace($key)) {
+            Set-Item -Path "Env:$key" -Value $value.Trim()
+        }
+    }
+}
+
+function Test-AppHttpReady([int]$p) {
+    foreach ($path in @("/health/live", "/health", "/api/voice/config")) {
+        try {
+            $r = Invoke-WebRequest -Uri "http://127.0.0.1:$p$path" -UseBasicParsing -TimeoutSec 15
+            if ($r.StatusCode -eq 200) { return $true }
+        } catch { continue }
+    }
+    return $false
+}
+
+function Test-TcpPortListening([int]$p) {
+    try {
+        $conn = Get-NetTCPConnection -LocalPort $p -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1
+        if ($conn) { return $true }
+    } catch { }
+    try {
+        $client = New-Object System.Net.Sockets.TcpClient
+        $async = $client.BeginConnect("127.0.0.1", $p, $null, $null)
+        $ok = $async.AsyncWaitHandle.WaitOne(500)
+        if ($ok -and $client.Connected) {
+            $client.Close()
+            return $true
+        }
+        $client.Close()
+    } catch { }
+    return $false
+}
+
+function Wait-PortReleased([int]$p, [int]$maxSec = 20) {
+    $deadline = (Get-Date).AddSeconds($maxSec)
+    while ((Get-Date) -lt $deadline) {
+        if (-not (Test-TcpPortListening $p)) { return $true }
+        Start-Sleep -Seconds 1
+    }
+    return -not (Test-TcpPortListening $p)
+}
+
+function Stop-PortProcess([int]$p) {
+    try {
+        $conns = Get-NetTCPConnection -LocalPort $p -State Listen -ErrorAction SilentlyContinue
+        foreach ($conn in $conns) {
+            if ($conn.OwningProcess) {
+                Stop-Process -Id $conn.OwningProcess -Force -ErrorAction SilentlyContinue
+            }
+        }
+        if ($conns) {
+            Start-Sleep -Seconds 2
+            Write-Host "Stopped previous process on port $p"
+        }
+    } catch { }
+}
+
+function Clear-LogFile([string]$path) {
+    if (-not (Test-Path $path)) { return }
+    try {
+        Remove-Item $path -Force -ErrorAction Stop
+    } catch {
+        try { Clear-Content $path -ErrorAction SilentlyContinue } catch { }
+    }
+}
+
+function Start-VoiceApp([int]$p) {
+    Write-Host "Starting voice-agent on port $p..."
+    Stop-PortProcess $p
+    $appLog = Join-Path $Root ".app.log"
+    $appErr = Join-Path $Root ".app.err"
+    Clear-LogFile $appLog
+    Clear-LogFile $appErr
+    Start-Process -FilePath "py" -ArgumentList "-3.13", "app.py" -WorkingDirectory $Root -WindowStyle Minimized `
+        -RedirectStandardOutput $appLog -RedirectStandardError $appErr
+    $deadline = (Get-Date).AddSeconds(120)
+    while ((Get-Date) -lt $deadline) {
+        if (Test-AppHttpReady $p) { break }
+        Start-Sleep -Seconds 3
+    }
+    if (-not (Test-AppHttpReady $p)) {
+        $errText = ""
+        if (Test-Path $appErr) { $errText = Get-Content $appErr -Raw -ErrorAction SilentlyContinue }
+        if ($errText -match "Uvicorn running") {
+            Write-Host "Server process up — waiting for HTTP endpoints..."
+            Start-Sleep -Seconds 10
+        }
+    }
+    if (-not (Test-AppHttpReady $p)) {
+        if (Test-Path $appErr) {
+            Write-Host "App startup log:" -ForegroundColor Red
+            Get-Content $appErr -Tail 20 | ForEach-Object { Write-Host $_ }
+        }
+        throw "App did not become ready on http://127.0.0.1:$p"
+    }
+    Write-Host "App ready: http://127.0.0.1:$p"
+}
+
+function Get-CloudflaredPidFile([string]$suffix) {
+    return Join-Path $Root ".cloudflared$suffix.pid"
+}
+
+function Stop-CloudflaredForSuffix([string]$suffix) {
+    $pidFile = Get-CloudflaredPidFile $suffix
+    try {
+        if (Test-Path $pidFile) {
+            $procId = [int](Get-Content $pidFile -Raw).Trim()
+            if ($procId) {
+                Stop-Process -Id $procId -Force -ErrorAction SilentlyContinue
+            }
+            Remove-Item $pidFile -Force -ErrorAction SilentlyContinue
+        }
+        Start-Sleep -Seconds 1
+    } catch { }
+}
+
+function Stop-CloudflaredTunnel {
+    Stop-CloudflaredForSuffix ""
+}
+
+function Test-TunnelUrl([string]$baseUrl, [int]$retries = 2) {
+    if (-not $baseUrl) { return $false }
+    for ($i = 0; $i -lt $retries; $i++) {
+        try {
+            $null = Invoke-WebRequest -Uri "$baseUrl/api/voice/config" -UseBasicParsing -TimeoutSec 8
+            return $true
+        } catch {
+            if ($i -lt ($retries - 1)) { Start-Sleep -Seconds 2 }
+        }
+    }
+    return $false
+}
+
+function Test-SpeechTunnelUrl([string]$baseUrl, [int]$retries = 12) {
+    if (-not $baseUrl) { return $false }
+    $paths = @("", "/ws")
+    for ($i = 0; $i -lt $retries; $i++) {
+        foreach ($path in $paths) {
+            $uri = if ($path) { "$baseUrl$path" } else { $baseUrl }
+            try {
+                $null = Invoke-WebRequest -Uri $uri -UseBasicParsing -TimeoutSec 10
+                return $true
+            } catch {
+                $code = $null
+                try {
+                    if ($_.Exception.Response) {
+                        $code = [int]$_.Exception.Response.StatusCode
+                    }
+                } catch { }
+                # Sidecar returns 404 on / — that still means the tunnel is up.
+                if ($code -and $code -ge 200 -and $code -lt 500) {
+                    return $true
+                }
+            }
+        }
+        if ($i -lt ($retries - 1)) {
+            Write-Host "  Speech tunnel not ready yet (attempt $($i + 1)/$retries)..."
+            Start-Sleep -Seconds 3
+        }
+    }
+    return $false
+}
+
+function Update-EnvValue([string]$key, [string]$value) {
+    $envFile = Join-Path $Root ".env"
+    if (-not (Test-Path $envFile)) { return }
+    $lines = Get-Content $envFile
+    $updated = $false
+    $newLines = foreach ($line in $lines) {
+        if ($line -match "^\s*$key=") {
+            $updated = $true
+            "$key=$value"
+        } else { $line }
+    }
+    if (-not $updated) { $newLines += "$key=$value" }
+    Set-Content -Path $envFile -Value ($newLines -join "`n")
+    Set-Item -Path "Env:$key" -Value $value
+}
+
+function Start-SpeechSidecar([int]$p = 8002, [switch]$Force) {
+    if ((Test-TcpPortListening $p) -and -not $Force) {
+        Write-Host "Speech Engine sidecar already listening on port $p"
+        return
+    }
+    Write-Host "Starting Speech Engine sidecar on port $p..."
+    Stop-PortProcess $p
+    if (-not (Wait-PortReleased $p)) {
+        Write-Host "Port $p still in use — forcing stop again..." -ForegroundColor Yellow
+        Stop-PortProcess $p
+        Start-Sleep -Seconds 3
+    }
+    $log = Join-Path $Root ".speech-sidecar.log"
+    $logErr = "${log}.err"
+    Clear-LogFile $log
+    Clear-LogFile $logErr
+    $env:PYTHONUNBUFFERED = "1"
+    Start-Process -FilePath "py" -ArgumentList "-3.13", "-u", "speech_engine_sidecar.py" `
+        -WorkingDirectory $Root -WindowStyle Minimized `
+        -RedirectStandardOutput $log -RedirectStandardError $logErr
+    $deadline = (Get-Date).AddSeconds(90)
+    while ((Get-Date) -lt $deadline) {
+        if (Test-TcpPortListening $p) {
+            Write-Host "Speech Engine sidecar ready on port $p"
+            return
+        }
+        if (Test-Path $log) {
+            $tail = Get-Content $log -Tail 1 -ErrorAction SilentlyContinue
+            if ($tail) { Write-Host "  $tail" }
+        }
+        Start-Sleep -Seconds 2
+    }
+    Write-Host "Sidecar logs:" -ForegroundColor Red
+    if (Test-Path $log) {
+        Get-Content $log -Tail 15 -ErrorAction SilentlyContinue | ForEach-Object { Write-Host $_ }
+    }
+    if (Test-Path $logErr) {
+        Get-Content $logErr -Tail 15 -ErrorAction SilentlyContinue | ForEach-Object { Write-Host $_ }
+    }
+    throw "Speech Engine sidecar did not start on port $p (ElevenLabs API fetch can take up to 90s — check .speech-sidecar.log)"
+}
+
+function Start-CloudflaredTunnel([int]$p, [string]$logSuffix = "") {
+    Write-Host "Starting Cloudflare tunnel for port $p..."
+    $log = Join-Path $Root ".tunnel$logSuffix.log"
+    $logErr = "${log}.err"
+    Stop-CloudflaredForSuffix $logSuffix
+    Clear-LogFile $log
+    Clear-LogFile $logErr
+    $proc = Start-Process -FilePath "cloudflared" -ArgumentList "tunnel", "--url", "http://127.0.0.1:$p" `
+        -RedirectStandardOutput $log -RedirectStandardError $logErr -WindowStyle Minimized -PassThru
+    if ($proc -and $proc.Id) {
+        Set-Content -Path (Get-CloudflaredPidFile $logSuffix) -Value $proc.Id
+    }
+    $deadline = (Get-Date).AddSeconds(90)
+    $newUrl = $null
+    while ((Get-Date) -lt $deadline -and -not $newUrl) {
+        Start-Sleep -Seconds 2
+        foreach ($path in @($logErr, $log)) {
+            if (-not (Test-Path $path)) { continue }
+            $match = Select-String -Path $path -Pattern "https://[a-z0-9]+(-[a-z0-9]+)+\.trycloudflare\.com" | Select-Object -First 1
+            if ($match) {
+                $newUrl = $match.Matches[0].Value
+                break
+            }
+        }
+    }
+    if (-not $newUrl) { throw "Could not read tunnel URL from $logErr" }
+    if ($logSuffix) {
+        Write-Host "Tunnel ready ($logSuffix): $newUrl"
+    } else {
+        Update-PublicUrl $newUrl
+        Write-Host "Tunnel ready: $newUrl"
+    }
+    return $newUrl
+}
+
+function Update-PublicUrl([string]$baseUrl) {
+    $envFile = Join-Path $Root ".env"
+    $content = Get-Content $envFile -Raw
+    if ($content -match "PUBLIC_API_BASE_URL=.*") {
+        $newContent = $content -replace "PUBLIC_API_BASE_URL=.*", "PUBLIC_API_BASE_URL=$baseUrl"
+    } else {
+        $newContent = $content.TrimEnd() + "`nPUBLIC_API_BASE_URL=$baseUrl`n"
+    }
+    Set-Content -Path $envFile -Value $newContent -NoNewline
+    $env:PUBLIC_API_BASE_URL = $baseUrl
+    Write-Host "Updated .env PUBLIC_API_BASE_URL=$baseUrl"
+}
+
+function Ensure-ServerSecret {
+    $envFile = Join-Path $Root ".env"
+    if (-not (Test-Path $envFile)) { return }
+    $lines = Get-Content $envFile
+    $secret = $env:VOICE_SERVER_URL_SECRET
+    foreach ($line in $lines) {
+        if ($line -match '^\s*VOICE_SERVER_URL_SECRET=(.+)$') {
+            $secret = $Matches[1].Trim()
+            break
+        }
+    }
+    if (-not $secret) {
+        $secret = [guid]::NewGuid().ToString()
+        $updated = $false
+        $newLines = foreach ($line in $lines) {
+            if ($line -match '^\s*VOICE_SERVER_URL_SECRET=') {
+                $updated = $true
+                "VOICE_SERVER_URL_SECRET=$secret"
+            } else { $line }
+        }
+        if (-not $updated) { $newLines += "VOICE_SERVER_URL_SECRET=$secret" }
+        Set-Content -Path $envFile -Value ($newLines -join "`n")
+        Write-Host "Generated VOICE_SERVER_URL_SECRET in .env"
+    }
+    $env:VOICE_SERVER_URL_SECRET = $secret
+}
+
+function Show-ProviderSetupSteps([string]$webhookUrl, [string]$secret) {
+    Write-Host ""
+    Write-Host "=== Provider webhook setup (Assistant -> Advanced -> Webhook Server) ===" -ForegroundColor Cyan
+    Write-Host "Webhook URL:"
+    Write-Host "  $webhookUrl"
+    Write-Host ""
+    Write-Host "Secret header:"
+    Write-Host "  Name: X-Voice-Webhook-Secret"
+    Write-Host "  Value: $secret"
+    Write-Host "================================================================" -ForegroundColor Cyan
+}
+
+Load-DotEnv
+Ensure-ServerSecret
+$env:VOICE_AGENT_PORT = "$Port"
+
+$needsRestart = $Restart.IsPresent
+if (Test-TcpPortListening $Port) {
+    if ($needsRestart) {
+        Stop-PortProcess $Port
+    } else {
+        try {
+            $cfg = Invoke-RestMethod -Uri "http://127.0.0.1:$Port/api/voice/config" -TimeoutSec 3
+            if (-not $cfg.webhook_url -and $env:PUBLIC_API_BASE_URL) {
+                Write-Host "App running but missing webhook URL — restarting to reload .env"
+                $needsRestart = $true
+                Stop-PortProcess $Port
+            } else {
+                Write-Host "App already running on port $Port"
+            }
+        } catch {
+            Write-Host "App already running on port $Port"
+        }
+    }
+}
+
+$public = $env:PUBLIC_API_BASE_URL
+$mainTunnelRecreated = $false
+if (Test-TunnelUrl $public) {
+    Write-Host "Tunnel OK: $public"
+} else {
+    $null = Start-CloudflaredTunnel $Port
+    $mainTunnelRecreated = $true
+}
+if ($needsRestart -or -not (Test-TcpPortListening $Port)) {
+    Start-VoiceApp $Port
+} elseif ($mainTunnelRecreated) {
+    Write-Host "Main tunnel URL changed — restarting app to reload .env"
+    Stop-PortProcess $Port
+    Start-VoiceApp $Port
+}
+
+$config = Invoke-RestMethod -Uri "http://127.0.0.1:$Port/api/voice/config"
+Write-Host "Voice configured: $($config.configured)"
+Write-Host "Webhook URL: $($config.webhook_url)"
+$webhook = if ($config.webhook_url) { $config.webhook_url } else { "$($env:PUBLIC_API_BASE_URL)/webhooks/voice" }
+
+Write-Host ""
+Write-Host "Configuring voice provider via API..." -ForegroundColor Cyan
+py -3.13 setup_voice_provider.py
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "Voice provider auto-configured (tools + webhook URL + auth)." -ForegroundColor Green
+} else {
+    Show-ProviderSetupSteps -webhookUrl $webhook -secret $env:VOICE_SERVER_URL_SECRET
+}
+
+if ($env:ELEVENLABS_API_KEY) {
+    Write-Host ""
+    $speechSidecarOk = Test-TcpPortListening 8002
+    $speechTunnelOk = Test-SpeechTunnelUrl $env:SPEECH_ENGINE_PUBLIC_URL
+    if (-not $speechTunnelOk) {
+        Write-Host "Speech tunnel down — starting sidecar + new Cloudflare tunnel..." -ForegroundColor Cyan
+        Start-SpeechSidecar 8002 -Force
+        $speechTunnel = Start-CloudflaredTunnel 8002 "-speech"
+        Update-EnvValue "SPEECH_ENGINE_PUBLIC_URL" $speechTunnel
+        Write-Host "Speech Engine tunnel: $speechTunnel"
+        Write-Host "Waiting for speech tunnel to accept connections..."
+        Start-Sleep -Seconds 5
+        Write-Host "Configuring ElevenLabs Speech Engine..." -ForegroundColor Cyan
+        py -3.13 setup_speech_engine.py
+        if ($LASTEXITCODE -ne 0) {
+            throw "Speech Engine setup failed — run: py -3.13 setup_speech_engine.py"
+        }
+        Write-Host "Speech Engine configured (WebSocket /ws + browser token)." -ForegroundColor Green
+        Load-DotEnv
+        Stop-PortProcess $Port
+        Start-VoiceApp $Port
+    } elseif ($Restart.IsPresent -or -not $speechSidecarOk) {
+        Write-Host "Restarting speech sidecar to reload code (keeping existing tunnel)..." -ForegroundColor Yellow
+        Start-SpeechSidecar 8002 -Force
+    } else {
+        Write-Host "Speech stack OK (sidecar :8002 + tunnel reachable)" -ForegroundColor Green
+    }
+    if (-not (Test-TcpPortListening 8002)) {
+        throw "Speech Engine sidecar not listening on 8002"
+    }
+    Load-DotEnv
+    if (-not (Test-SpeechTunnelUrl $env:SPEECH_ENGINE_PUBLIC_URL)) {
+        Write-Host ""
+        Write-Host "WARNING: Speech Engine tunnel not reachable yet: $($env:SPEECH_ENGINE_PUBLIC_URL)" -ForegroundColor Yellow
+        Write-Host "Local dashboard is up at http://127.0.0.1:$Port — wait ~30s, then retry ElevenLabs talk." -ForegroundColor Yellow
+        Write-Host "If it still fails, run: .\start_dev.ps1 -Restart" -ForegroundColor Yellow
+    } else {
+        Write-Host "Speech sidecar: port 8002 | ws_url wss://$($env:SPEECH_ENGINE_PUBLIC_URL -replace 'https://','')/ws"
+    }
+}
+
+Write-Host "Done. Dashboard: http://127.0.0.1:$Port"
+Write-Host "ElevenLabs talk: http://127.0.0.1:$Port/eleven-talk"
+Write-Host "Keep this window open — sidecar + tunnels run in the background."

examples/python/voice-agent/voice_routes.py

@@ -0,0 +1,183 @@
+"""Voice agent HTTP routes."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+
+from integrations.voice.client import VoiceClient
+from integrations.voice.config import VoiceConfigError, get_web_sdk_settings, load_voice_settings
+from integrations.voice.live import transcript_hub
+from integrations.voice.processor import process_voice_webhook
+from integrations.voice.store import VoiceCallStore
+from integrations.voice.verify import VerificationError, verify_webhook_request
+from starlette.requests import Request
+from starlette.responses import JSONResponse, PlainTextResponse, Response, StreamingResponse
+
+logger = logging.getLogger(__name__)
+
+# Hold strong references to background tasks so the event loop (which only keeps
+# weak references) cannot garbage-collect them mid-flight and drop a webhook event.
+_background_tasks: set[asyncio.Task] = set()
+
+
+def _schedule_webhook_processing(event_type: str, payload: dict, *, settings) -> None:
+    task = asyncio.create_task(
+        asyncio.to_thread(process_voice_webhook, event_type, payload, settings=settings)
+    )
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
+
+
+async def api_voice_config_status(_request: Request) -> JSONResponse:
+    try:
+        settings = load_voice_settings()
+        configured = True
+        error = None
+    except VoiceConfigError as exc:
+        settings = None
+        configured = False
+        error = str(exc)
+    return JSONResponse(
+        {
+            "configured": configured,
+            "error": error,
+            "webhook_url": settings.webhook_url if settings else None,
+            "default_assistant_id": settings.default_assistant_id if settings else None,
+            "web_talk_enabled": bool(settings.public_api_key and settings.default_assistant_id),
+        }
+    )
+
+
+async def api_voice_web_config(_request: Request) -> JSONResponse:
+    try:
+        settings = load_voice_settings(require_key=False)
+    except VoiceConfigError as exc:
+        return JSONResponse({"enabled": False, "error": str(exc)})
+    sdk_url, sdk_global = get_web_sdk_settings()
+    return JSONResponse(
+        {
+            "enabled": bool(settings.public_api_key and settings.default_assistant_id and sdk_url),
+            "public_key": settings.public_api_key,
+            "assistant_id": settings.default_assistant_id,
+            "sdk_url": sdk_url or None,
+            "sdk_global": sdk_global or "Vapi",
+        }
+    )
+
+
+async def api_voice_create_call(request: Request) -> JSONResponse:
+    try:
+        body = await request.json()
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+    number = str(body.get("customer_number") or body.get("phone_number") or "").strip()
+    if not number:
+        return JSONResponse({"error": "customer_number is required"}, status_code=400)
+    try:
+        settings = load_voice_settings()
+        client = VoiceClient(settings)
+        result = await asyncio.to_thread(
+            client.create_call,
+            customer_number=number,
+            assistant_id=body.get("assistant_id"),
+            phone_number_id=body.get("phone_number_id"),
+            metadata=body.get("metadata") if isinstance(body.get("metadata"), dict) else None,
+        )
+    except VoiceConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+    except Exception as exc:  # noqa: BLE001
+        return JSONResponse({"error": str(exc)}, status_code=502)
+    call_id = result.get("id")
+    if call_id:
+        VoiceCallStore.upsert_call(str(call_id), status="scheduled", customer_number=number)
+    return JSONResponse(result, status_code=201)
+
+
+async def api_voice_list_calls(_request: Request) -> JSONResponse:
+    from integrations.voice.call_finalize import analytics_for_record
+
+    calls = []
+    for record in VoiceCallStore.list_calls():
+        row = dict(record)
+        row["analytics"] = analytics_for_record(record)
+        calls.append(row)
+    return JSONResponse({"calls": calls})
+
+
+async def api_voice_doctor(_request: Request) -> JSONResponse:
+    import os
+
+    from integrations.voice.doctor import run_voice_doctor
+
+    app_port = int(os.getenv("VOICE_AGENT_PORT", "8001"))
+    sidecar_port = int(os.getenv("SPEECH_ENGINE_SIDECAR_PORT", "8002"))
+    return JSONResponse(run_voice_doctor(app_port=app_port, sidecar_port=sidecar_port))
+
+
+async def api_voice_call_detail(request: Request) -> JSONResponse:
+    from integrations.voice.call_finalize import analytics_for_record
+
+    call_id = request.path_params["call_id"]
+    record = VoiceCallStore.get_call(call_id)
+    if not record:
+        return JSONResponse({"error": "not found"}, status_code=404)
+    out = dict(record)
+    out["analytics"] = analytics_for_record(record)
+    return JSONResponse(out)
+
+
+async def api_voice_call_detail_ui(request: Request) -> JSONResponse:
+    from integrations.voice.call_detail_ui import build_call_detail_layout
+
+    call_id = request.path_params["call_id"]
+    record = VoiceCallStore.get_call(call_id)
+    if not record:
+        return JSONResponse({"error": "not found"}, status_code=404)
+    layout = build_call_detail_layout(record)
+    return JSONResponse({"call_id": call_id, "layout": layout})
+
+
+async def api_voice_live_transcript(request: Request) -> StreamingResponse:
+    call_id = request.path_params["call_id"]
+
+    async def event_stream():
+        record = VoiceCallStore.get_call(call_id)
+        if record and record.get("transcript"):
+            yield transcript_hub.snapshot_sse(
+                {"type": "snapshot", "transcript": record["transcript"]}
+            )
+        async for event in transcript_hub.subscribe(call_id):
+            yield transcript_hub.snapshot_sse(event)
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+async def webhook_voice(request: Request) -> Response:
+    raw = (await request.body()).decode("utf-8")
+    try:
+        settings = load_voice_settings(require_key=False)
+    except VoiceConfigError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+
+    headers = {k: v for k, v in request.headers.items()}
+    try:
+        verify_webhook_request(secret=settings.server_url_secret, headers=headers)
+    except VerificationError:
+        return JSONResponse({"error": "invalid secret"}, status_code=401)
+
+    try:
+        payload = json.loads(raw) if raw else {}
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid JSON"}, status_code=400)
+
+    msg = payload.get("message") if isinstance(payload.get("message"), dict) else payload
+    event_type = str((msg or {}).get("type") or payload.get("type") or "unknown")
+
+    if event_type in ("tool-calls", "assistant-request", "transfer-destination-request", "knowledge-base-request"):
+        result = await asyncio.to_thread(process_voice_webhook, event_type, payload, settings=settings)
+        return JSONResponse(result or {})
+
+    _schedule_webhook_processing(event_type, payload, settings=settings)
+    return PlainTextResponse("ok", status_code=200)

mkdocs.yml

@@ -95,8 +95,12 @@ nav:
     - Templates & Layouts: concepts/templates.md
     - Slots & Components: concepts/slots.md
     - Providers: concepts/providers.md
+  - Frontend:
+    - BeautifulUI Adapter: frontend/beautifului-adapter-architecture.md
+    - BeautifulUI Upstream Pin: frontend/BEAUTIFULUI_UPSTREAM.md
   - Features:
     - Dashboard: features/dashboard.md
+    - Replay: features/replay.md
     - Gateway Chat: features/gateway-chat.md
     - Attachments: features/attachments.md
     - Theme System: features/theme-system.md
@@ -129,12 +133,15 @@ nav:
     - Feature Inventory: features/feature-inventory.md
     - Gap Analysis: features/gap-analysis.md
     - Integration Analysis: features/integration-analysis.md
+    - BeautifulUI Integration: features/beautifului-integration.md
     - Standardization: features/standardization-verification.md
     - Comparison (OpenClaw): features/comparison-openclaw.md
     - What Makes It Different: features/differentiation.md
     - How to Add a Feature: features/how-to-add-a-feature.md
     - Message Elements: features/message-elements.md
     - Steps: features/steps.md
+  - Frontend:
+    - BeautifulUI Playbook: frontend/beautifului.md
   - API Reference:
     - Python CLI: api/cli.md
     - Python API: api/python.md

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aiui"
-version = "0.3.142"
+version = "0.3.151"
 description = "YAML-driven website generator - CLI and compiler"
 readme = "README.md"
 license = {text = "MIT"}

src/frontend/README.md

@@ -1,6 +1,27 @@
-# React + TypeScript + Vite
+# PraisonAIUI Frontend (React + TypeScript + Vite)
 
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+The BeautifulUI dashboard source. Built with React 19 + Vite 7 + Tailwind v4.
+
+## Build & CI
+
+- **Node.js:** 22 (matches the `frontend` job in `.github/workflows/ci.yml`)
+- **Lockfile:** `src/frontend/package-lock.json` — install with `npm ci`
+
+```bash
+cd src/frontend
+npm ci
+npm run build       # SPA build → dist/ (dashboard ship path)
+npm run build:lib   # library build for the @praisonaiui/react package
+npm run lint        # eslint
+```
+
+`npm run build` output in `dist/` is synced to `src/praisonaiui/templates/frontend/`
+(the committed bundle served by `aiui build`). The CI `frontend` job runs
+`npm ci && npm run build` on PRs to `main` and fails on TypeScript/Vite errors.
+
+## Vite template notes
+
+This project uses a minimal setup to get React working in Vite with HMR and some ESLint rules.
 
 Currently, two official plugins are available:
 

src/frontend/package-lock.json

@@ -82,20 +82,6 @@
         }
       }
     },
-    "node_modules/@a2ui/markdown-it": {
-      "version": "0.0.4",
-      "resolved": "https://registry.npmjs.org/@a2ui/markdown-it/-/markdown-it-0.0.4.tgz",
-      "integrity": "sha512-uaYNywdiHDH4i//pHpyckFnApvOshiUNT2Xl8awceNjL1XAX/gqtki9GRUJQ26RE7id2+aPNgOy1W6mXNBxriQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "dompurify": "^3.3.1",
-        "markdown-it": "^14.1.0"
-      },
-      "peerDependencies": {
-        "@a2ui/web_core": "^0.9.2"
-      }
-    },
     "node_modules/@a2ui/react": {
       "version": "0.10.0",
       "resolved": "https://registry.npmjs.org/@a2ui/react/-/react-0.10.0.tgz",
@@ -129,16 +115,16 @@
       }
     },
     "node_modules/@a2ui/web_core": {
-      "version": "0.10.0",
-      "resolved": "https://registry.npmjs.org/@a2ui/web_core/-/web_core-0.10.0.tgz",
-      "integrity": "sha512-pSieKxaB6aZWBL2LjZfKo4/1v4xMWylczpzte1ehuGH0kfNGf/iTd73PKsIKYx3b0FNWTbD8gAloOM4JCVqUig==",
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/@a2ui/web_core/-/web_core-0.10.2.tgz",
+      "integrity": "sha512-IfS4K7baTL9P9AzUOzKRWzL9A9/+Z7TCgMY2GPwsZ0H7LgY/9/uJnlbReNhpHsAfN12KZtW9iERWkw5HOf71GA==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@preact/signals-core": "^1.13.0",
-        "date-fns": "^4.1.0",
+        "@preact/signals-core": "^1.14.2",
+        "date-fns": "^4.4.0",
         "zod": "^3.25.76",
-        "zod-to-json-schema": "^3.25.1"
+        "zod-to-json-schema": "^3.25.2"
       }
     },
     "node_modules/@a2ui/web_core/node_modules/zod": {
@@ -5502,9 +5488,9 @@
       }
     },
     "node_modules/date-fns": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz",
-      "integrity": "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==",
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.4.0.tgz",
+      "integrity": "sha512-+1UMbeh68lH1SegH83CGWwpb6OHHbpSgr3+s5Eww5M4CAgswBpoWS0AjTOfEJ33HiYKz1hdj/KTFprzXHmq/6w==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -9747,6 +9733,84 @@
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
       }
+    },
+    "node_modules/@a2ui/react/node_modules/@a2ui/markdown-it": {
+      "version": "0.0.4",
+      "resolved": "https://registry.npmjs.org/@a2ui/markdown-it/-/markdown-it-0.0.4.tgz",
+      "integrity": "sha512-uaYNywdiHDH4i//pHpyckFnApvOshiUNT2Xl8awceNjL1XAX/gqtki9GRUJQ26RE7id2+aPNgOy1W6mXNBxriQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dompurify": "^3.3.1",
+        "markdown-it": "^14.1.0"
+      },
+      "peerDependencies": {
+        "@a2ui/web_core": "^0.9.2"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/core": {
+      "version": "1.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.1.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/runtime": {
+      "version": "1.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/wasi-threads": {
+      "version": "1.1.0",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1",
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/tslib": {
+      "version": "2.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "0BSD",
+      "optional": true
     }
   }
 }

src/frontend/package.json

@@ -29,7 +29,8 @@
     "build": "tsc -b && vite build",
     "build:lib": "tsc -b && vite build --mode lib",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "node --experimental-strip-types --test \"src/agent-ui/**/*.test.ts\""
   },
   "keywords": [
     "react",

src/frontend/spike.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<!-- Spike #293 dev harness. Open with `npm run dev` → http://localhost:5173/spike.html -->
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>BeautifulUI spike · PraisonAIUI #293</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/spike/main.tsx"></script>
+  </body>
+</html>

src/frontend/src/agent-ui/adapter.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Unit tests for the Agent-UI adapter (mock events -> stable contracts).
+ *
+ * Dependency-free: uses the Node built-in test runner so it needs no extra
+ * toolchain. Run with `npm test` (from src/frontend), which invokes the Node
+ * test runner with `--experimental-strip-types` so the TypeScript types are
+ * stripped on Node 22+. The frontend CI gate (see issue #295) wires this in.
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { mapApprovalToCardProps, mapChatEventToUi } from './adapter.ts'
+
+test('mapChatEventToUi normalizes a streaming token frame', () => {
+    const event = mapChatEventToUi({
+        type: 'run_content',
+        token: 'Hello',
+        agent_name: 'Researcher',
+        session_id: 's1',
+        run_id: 'r1',
+    })
+    assert.equal(event.kind, 'run-token')
+    assert.equal(event.text, 'Hello')
+    assert.equal(event.agentName, 'Researcher')
+    assert.equal(event.sessionId, 's1')
+    assert.equal(event.runId, 'r1')
+})
+
+test('mapChatEventToUi maps a started tool call to a running chip', () => {
+    const event = mapChatEventToUi({
+        type: 'tool_call_started',
+        name: 'search',
+        description: '🔎 Searching the web',
+        icon: '🔎',
+        step_number: 2,
+        tool_call_id: 'tc-1',
+    })
+    assert.equal(event.kind, 'tool-call')
+    assert.deepEqual(event.toolCall, {
+        id: 'tc-1',
+        label: '🔎 Searching the web',
+        icon: '🔎',
+        stepNumber: 2,
+        status: 'running',
+        error: undefined,
+    })
+})
+
+test('mapChatEventToUi marks completed tool calls as done', () => {
+    const event = mapChatEventToUi({ type: 'tool_call_completed', name: 'search' })
+    assert.equal(event.toolCall?.status, 'done')
+    // Falls back to the tool name for id and label when unspecified.
+    assert.equal(event.toolCall?.id, 'search')
+    assert.equal(event.toolCall?.label, 'search')
+})
+
+test('mapChatEventToUi treats team_* frames the same as their solo variant', () => {
+    assert.equal(mapChatEventToUi({ type: 'team_run_content', token: 'x' }).kind, 'run-token')
+    assert.equal(mapChatEventToUi({ type: 'team_run_error', error: 'boom' }).kind, 'run-error')
+})
+
+test('mapChatEventToUi preserves unknown frame types without throwing', () => {
+    const event = mapChatEventToUi({ type: 'future_event', foo: 'bar' })
+    assert.equal(event.kind, 'unknown')
+    assert.equal(event.rawType, 'future_event')
+})
+
+test('mapChatEventToUi defaults run errors to a readable message', () => {
+    const event = mapChatEventToUi({ type: 'run_error' })
+    assert.equal(event.kind, 'run-error')
+    assert.equal(event.error, 'Unknown error')
+})
+
+test('mapApprovalToCardProps maps a pending approval item', () => {
+    const card = mapApprovalToCardProps({
+        id: 'a-1',
+        tool_name: 'delete_file',
+        agent_name: 'Ops',
+        risk_level: 'high',
+        risk_icon: '🔥',
+        description: 'Deletes a file',
+        arguments: { path: '/tmp/x' },
+        // Approvals API emits epoch seconds (time.time()), not an ISO string.
+        created_at: 1758585600,
+    })
+    assert.equal(card.id, 'a-1')
+    assert.equal(card.toolName, 'delete_file')
+    assert.equal(card.agentName, 'Ops')
+    assert.equal(card.riskLevel, 'high')
+    assert.equal(card.riskIcon, '🔥')
+    assert.equal(card.argumentsJson, '{\n  "path": "/tmp/x"\n}')
+    // Epoch seconds are normalized to an ISO-8601 string for display.
+    assert.equal(card.createdAt, '2025-09-23T00:00:00.000Z')
+})
+
+test('mapApprovalToCardProps falls back for missing/invalid fields', () => {
+    const card = mapApprovalToCardProps({ id: 'a-2', risk_level: 'nonsense' })
+    assert.equal(card.toolName, 'unknown')
+    assert.equal(card.agentName, 'Unknown')
+    assert.equal(card.riskLevel, 'medium')
+    assert.equal(card.riskIcon, '⚠️')
+    assert.equal(card.argumentsJson, '{}')
+})

src/frontend/src/agent-ui/adapter.ts

@@ -0,0 +1,177 @@
+/**
+ * PraisonAIUI Agent-UI adapter
+ *
+ * Pure mapping functions from wire payloads to stable PraisonAIUI contracts.
+ * This is the single boundary between transport shapes (WebSocket frames from
+ * chat.js, REST payloads from /api/approvals/*) and the UI layer. Vendored
+ * BeautifulUI components are rendered from these contracts elsewhere in
+ * `src/agent-ui/`; consumers never import upstream prop types directly.
+ *
+ * Functions are intentionally side-effect free so they can be unit tested
+ * with mock events (see adapter.test.ts).
+ */
+
+import type {
+    AgentStreamEvent,
+    ApprovalPromptModel,
+    ApprovalRiskLevel,
+    ToolCallChipModel,
+} from './contracts'
+
+/** Raw WebSocket frame as parsed in chat.js (`JSON.parse(event.data)`). */
+export type RawChatFrame = Record<string, unknown>
+
+/** Raw approval item as returned by `/api/approvals/pending`. */
+export type RawApprovalItem = Record<string, unknown>
+
+const VALID_RISK_LEVELS: readonly ApprovalRiskLevel[] = [
+    'low',
+    'medium',
+    'high',
+    'critical',
+]
+
+function asString(value: unknown): string | undefined {
+    return typeof value === 'string' ? value : undefined
+}
+
+function asNumber(value: unknown): number | undefined {
+    return typeof value === 'number' ? value : undefined
+}
+
+/**
+ * Normalize a `created_at` value to an ISO-8601 string. The approvals API
+ * emits epoch seconds (`time.time()`), while some payloads already carry an
+ * ISO string — accept both, drop anything else.
+ */
+function asTimestamp(value: unknown): string | undefined {
+    if (typeof value === 'string') return value
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return new Date(value * 1000).toISOString()
+    }
+    return undefined
+}
+
+/** Map a raw tool-call frame to a stable chip view model. */
+function mapToolCall(
+    frame: RawChatFrame,
+    status: ToolCallChipModel['status'],
+): ToolCallChipModel {
+    const name = asString(frame.name) ?? 'tool'
+    return {
+        id: asString(frame.tool_call_id) ?? name,
+        label: asString(frame.description) ?? name,
+        icon: asString(frame.icon),
+        stepNumber: asNumber(frame.step_number),
+        status,
+        error: asString(frame.error),
+    }
+}
+
+/**
+ * Map a raw WebSocket chat frame to a normalized {@link AgentStreamEvent}.
+ *
+ * Unknown frame types are preserved as `kind: 'unknown'` with `rawType` set,
+ * so new upstream event types degrade gracefully instead of throwing.
+ */
+export function mapChatEventToUi(frame: RawChatFrame): AgentStreamEvent {
+    const rawType = asString(frame.type)
+    const sessionId = asString(frame.session_id)
+    const runId = asString(frame.run_id)
+    const agentName = asString(frame.agent_name)
+
+    switch (rawType) {
+        case 'run_started':
+            return { kind: 'run-started', sessionId, runId, agentName }
+        case 'run_content':
+        case 'team_run_content':
+            return {
+                kind: 'run-token',
+                sessionId,
+                runId,
+                agentName,
+                text: asString(frame.token),
+            }
+        case 'run_completed':
+        case 'team_run_completed':
+            return {
+                kind: 'run-completed',
+                sessionId,
+                runId,
+                agentName,
+                text: asString(frame.content),
+            }
+        case 'run_error':
+        case 'team_run_error':
+            return {
+                kind: 'run-error',
+                sessionId,
+                runId,
+                agentName,
+                error: asString(frame.error) ?? 'Unknown error',
+            }
+        case 'tool_call_started':
+        case 'team_tool_call_started':
+            return {
+                kind: 'tool-call',
+                sessionId,
+                runId,
+                agentName,
+                toolCall: mapToolCall(frame, 'running'),
+            }
+        case 'tool_call_completed':
+        case 'team_tool_call_completed':
+            return {
+                kind: 'tool-call',
+                sessionId,
+                runId,
+                agentName,
+                toolCall: mapToolCall(frame, 'done'),
+            }
+        case 'reasoning_step':
+        case 'team_reasoning_step':
+            return {
+                kind: 'reasoning-step',
+                sessionId,
+                runId,
+                agentName,
+                text: asString(frame.step),
+            }
+        default:
+            return { kind: 'unknown', sessionId, runId, agentName, rawType }
+    }
+}
+
+function normalizeRisk(value: unknown): ApprovalRiskLevel {
+    return VALID_RISK_LEVELS.includes(value as ApprovalRiskLevel)
+        ? (value as ApprovalRiskLevel)
+        : 'medium'
+}
+
+/**
+ * Map a raw approval item from `/api/approvals/pending` to a stable
+ * {@link ApprovalPromptModel}. Arguments are pretty-printed for display and
+ * an unknown/missing risk level falls back to `medium`.
+ */
+export function mapApprovalToCardProps(
+    item: RawApprovalItem,
+): ApprovalPromptModel {
+    let argumentsJson = '{}'
+    try {
+        argumentsJson = JSON.stringify(item.arguments ?? {}, null, 2)
+    } catch {
+        // Circular or non-serializable args — degrade to empty object.
+        argumentsJson = '{}'
+    }
+
+    return {
+        id: asString(item.id) ?? '',
+        toolName: asString(item.tool_name) ?? 'unknown',
+        agentName: asString(item.agent_name) ?? 'Unknown',
+        riskLevel: normalizeRisk(item.risk_level),
+        riskIcon: asString(item.risk_icon) ?? '⚠️',
+        description: asString(item.description),
+        argumentsJson,
+        createdAt: asTimestamp(item.created_at),
+    }
+}

src/frontend/src/agent-ui/contracts.ts

@@ -0,0 +1,69 @@
+/**
+ * PraisonAIUI Agent-UI contracts
+ *
+ * Stable, framework-agnostic view models owned by PraisonAIUI. These are the
+ * ONLY types that non-adapter code (chat views, dashboards, tests) should
+ * depend on. BeautifulUI / vendored component prop types must never leak
+ * outside `src/agent-ui/` — the adapter maps to these contracts instead so
+ * the upstream implementation can be swapped without touching consumers.
+ *
+ * See docs/frontend/beautifului-adapter-architecture.md.
+ */
+
+/** Discriminant for a normalized agent stream event. */
+export type AgentStreamEventKind =
+    | 'run-started'
+    | 'run-token'
+    | 'run-completed'
+    | 'run-error'
+    | 'tool-call'
+    | 'reasoning-step'
+    | 'unknown'
+
+/**
+ * Normalized agent stream event — the stable shape UI code consumes,
+ * decoupled from the raw WebSocket frame `type` strings handled in chat.js.
+ */
+export interface AgentStreamEvent {
+    kind: AgentStreamEventKind
+    /** Owning session, when the frame carried one. */
+    sessionId?: string
+    /** Run identifier, when the frame carried one. */
+    runId?: string
+    /** Human-facing agent name, when present. */
+    agentName?: string
+    /** Streaming token or final content, depending on `kind`. */
+    text?: string
+    /** Populated for `kind === 'tool-call'`. */
+    toolCall?: ToolCallChipModel
+    /** Populated for `kind === 'run-error'`. */
+    error?: string
+    /** Raw frame `type` for events we do not yet normalize (`kind === 'unknown'`). */
+    rawType?: string
+}
+
+/** View model for a tool-call chip, independent of any component library. */
+export interface ToolCallChipModel {
+    id: string
+    label: string
+    icon?: string
+    stepNumber?: number
+    status: 'running' | 'done' | 'error'
+    error?: string
+}
+
+/** Risk levels surfaced by the approvals REST API (`/api/approvals/*`). */
+export type ApprovalRiskLevel = 'low' | 'medium' | 'high' | 'critical'
+
+/** View model for an approval prompt/card, independent of any component library. */
+export interface ApprovalPromptModel {
+    id: string
+    toolName: string
+    agentName: string
+    riskLevel: ApprovalRiskLevel
+    riskIcon: string
+    description?: string
+    /** Pretty-printed tool arguments, ready for display. */
+    argumentsJson: string
+    createdAt?: string
+}

src/frontend/src/agent-ui/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent-UI boundary barrel.
+ *
+ * Consumers import PraisonAIUI's stable agent-UI contracts and adapters from
+ * here. Vendored BeautifulUI components live under `src/agent-ui/vendors/` and
+ * are re-exported from this folder only — no upstream prop types should be
+ * imported outside `src/agent-ui/`.
+ */
+
+export type {
+    AgentStreamEvent,
+    AgentStreamEventKind,
+    ApprovalPromptModel,
+    ApprovalRiskLevel,
+    ToolCallChipModel,
+} from './contracts'
+
+export type { RawApprovalItem, RawChatFrame } from './adapter'
+export { mapApprovalToCardProps, mapChatEventToUi } from './adapter'

src/frontend/src/chat/ActionButtons.tsx

@@ -38,7 +38,7 @@ interface ActionButtonsProps {
  */
 export function ActionButtons({ actions, messageId, sessionId }: ActionButtonsProps) {
     const [pendingActions, setPendingActions] = useState<Set<string>>(new Set())
-    const [hiddenActions, setHiddenActions] = useState<Set<string>>(new Set())
+    const [hiddenActions] = useState<Set<string>>(new Set())
 
     const handleActionClick = useCallback(async (action: ActionButton) => {
         if (pendingActions.has(action.id) || hiddenActions.has(action.id)) {

src/frontend/src/chat/AskActionPrompt.tsx

@@ -73,7 +73,7 @@ export function AskActionPrompt({
 
             {/* Action buttons */}
             <div className="space-y-3">
-                {actions.map((action, index) => (
+                {actions.map((action) => (
                     <button
                         key={action.name}
                         type="button"

src/frontend/src/chat/ChatSettingsPanel.tsx

@@ -15,7 +15,7 @@ import { Textarea } from '../components/ui/textarea';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../components/ui/select';
 import { Slider } from '../components/ui/slider';
 import { Switch } from '../components/ui/switch';
-import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '../components/ui/card';
+import { Card, CardContent } from '../components/ui/card';
 import { Sheet, SheetContent, SheetHeader, SheetTitle, SheetDescription } from '../components/ui/sheet';
 
 interface SettingsWidget {
@@ -74,7 +74,7 @@ const WidgetRenderer: React.FC<{
               id={name}
               placeholder={placeholder}
               value={value || ''}
-              onChange={(e) => onChange(e.target.value)}
+              onChange={(e: React.ChangeEvent<HTMLTextAreaElement>) => onChange(e.target.value)}
               maxLength={widget.maxLength}
               rows={4}
             />

src/frontend/src/chat/CustomElementHost.tsx

@@ -20,43 +20,16 @@ interface CustomElementProps {
   onError?: (error: Error) => void;
 }
 
-interface CustomComponentModule {
-  default: React.ComponentType<any>;
-}
-
 // Registry of loaded components (cache)
 const componentCache = new Map<string, Promise<React.ComponentType<any>>>();
 
-// List of available custom components (in practice, this would be populated from backend)
-const availableComponents = new Set([
-  'ExampleWidget',
-  'UserCard',
-  'DataChart', 
-  'FormBuilder',
-  'CodeEditor',
-  'ImageGallery',
-  'ChatEmbed'
-]);
-
-// Static imports for build-tool compatibility
-const ExampleWidget = React.lazy(() => import('../components/custom/ExampleWidget'));
-const UserCard = React.lazy(() => import('../components/custom/UserCard'));
-const DataChart = React.lazy(() => import('../components/custom/DataChart'));
-const FormBuilder = React.lazy(() => import('../components/custom/FormBuilder'));
-const CodeEditor = React.lazy(() => import('../components/custom/CodeEditor'));
-const ImageGallery = React.lazy(() => import('../components/custom/ImageGallery'));
-const ChatEmbed = React.lazy(() => import('../components/custom/ChatEmbed'));
-
-// Static mapping of component names to imports
-const componentMap: Record<string, React.ComponentType<any>> = {
-  ExampleWidget,
-  UserCard,
-  DataChart,
-  FormBuilder,
-  CodeEditor,
-  ImageGallery,
-  ChatEmbed,
-};
+// Custom components available to <CustomElementHost name="..." />. The example
+// widgets this once listed (ExampleWidget, UserCard, ...) were never added, and
+// importing them broke the build. Register real components here as they land:
+//   const MyWidget = React.lazy(() => import('../components/custom/MyWidget'));
+//   componentMap.MyWidget = MyWidget;
+const componentMap: Record<string, React.ComponentType<any>> = {};
+const availableComponents = new Set(Object.keys(componentMap));
 
 /**
  * Load a custom component with static mapping for build-tool compatibility

src/frontend/src/chat/TaskSidebar.tsx

@@ -4,7 +4,6 @@
  * Shows live-updating task lists with states, progress bars, and click-to-jump functionality.
  */
 
-import React from 'react'
 import { ChevronRight, ChevronDown, CheckCircle, Clock, XCircle, Circle, ExternalLink } from 'lucide-react'
 import { useTaskState, setTasksCollapsed, type Task, type TaskList, type TaskStatus } from '../state/tasks'
 import { cn } from '../lib/utils'

src/frontend/src/components/ui/alert.tsx

@@ -0,0 +1,44 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const alertVariants = cva(
+  "relative w-full rounded-lg border px-4 py-3 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground [&>svg~*]:pl-7",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        destructive:
+          "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+const Alert = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
+>(({ className, variant, ...props }, ref) => (
+  <div ref={ref} role="alert" className={cn(alertVariants({ variant }), className)} {...props} />
+))
+Alert.displayName = "Alert"
+
+const AlertTitle = React.forwardRef<HTMLParagraphElement, React.HTMLAttributes<HTMLHeadingElement>>(
+  ({ className, ...props }, ref) => (
+    <h5 ref={ref} className={cn("mb-1 font-medium leading-none tracking-tight", className)} {...props} />
+  )
+)
+AlertTitle.displayName = "AlertTitle"
+
+const AlertDescription = React.forwardRef<HTMLParagraphElement, React.HTMLAttributes<HTMLParagraphElement>>(
+  ({ className, ...props }, ref) => (
+    <div ref={ref} className={cn("text-sm [&_p]:leading-relaxed", className)} {...props} />
+  )
+)
+AlertDescription.displayName = "AlertDescription"
+
+export { Alert, AlertTitle, AlertDescription }

src/frontend/src/components/ui/textarea.tsx

@@ -0,0 +1,19 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Textarea = React.forwardRef<HTMLTextAreaElement, React.ComponentProps<"textarea">>(
+  ({ className, ...props }, ref) => (
+    <textarea
+      className={cn(
+        "flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-base shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        className
+      )}
+      ref={ref}
+      {...props}
+    />
+  )
+)
+Textarea.displayName = "Textarea"
+
+export { Textarea }

src/frontend/src/hooks/useMicStream.ts

@@ -183,7 +183,7 @@ export function useMicStream(options: UseMicStreamOptions = {}): UseMicStreamRet
       onConnectionChangeRef.current?.(false);
     };
     
-    ws.onerror = (error) => {
+    ws.onerror = () => {
       onErrorRef.current?.(new Error('WebSocket error'));
       setConnected(false);
       onConnectionChangeRef.current?.(false);

src/frontend/src/hooks/useWindowMessage.ts

@@ -5,8 +5,33 @@
  * incoming messages from parent.
  */
 
-import { useEffect, useCallback, useRef } from 'react';
-import { useSSE } from './useSSE';
+import { useEffect, useCallback, useRef, useState } from 'react';
+
+interface EventSourceOptions {
+  enabled?: boolean;
+  onMessage?: (event: MessageEvent) => void;
+  onOpen?: () => void;
+  onError?: () => void;
+}
+
+/**
+ * Minimal EventSource subscription. (useSSE in this package is the chat
+ * streaming store, not a generic SSE hook, so it cannot open this stream.)
+ */
+function useEventSource(url: string, { enabled = true, onMessage, onOpen, onError }: EventSourceOptions) {
+  const [connected, setConnected] = useState(false);
+  const handlers = useRef({ onMessage, onOpen, onError });
+  handlers.current = { onMessage, onOpen, onError };
+  useEffect(() => {
+    if (!enabled || typeof EventSource === 'undefined') return;
+    const source = new EventSource(url);
+    source.onopen = () => { setConnected(true); handlers.current.onOpen?.(); };
+    source.onmessage = (event) => handlers.current.onMessage?.(event);
+    source.onerror = () => { setConnected(false); handlers.current.onError?.(); };
+    return () => { source.close(); setConnected(false); };
+  }, [url, enabled]);
+  return { connected };
+}
 
 export interface WindowMessageData {
   type: string;
@@ -85,7 +110,7 @@ export function useWindowMessage(options: UseWindowMessageOptions = {}): UseWind
   const isIframe = window !== window.parent;
   
   // SSE connection for outbound messages
-  const { connected } = useSSE('/sse/window-message', {
+  const { connected } = useEventSource('/sse/window-message', {
     enabled: enabled && isIframe,
     onMessage: (event) => {
       try {

src/frontend/src/modals/AddMCPServerModal.tsx

@@ -7,9 +7,7 @@ import React, { useState } from 'react';
 import { Button } from '../components/ui/button';
 import { Input } from '../components/ui/input';
 import { Label } from '../components/ui/label';
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../components/ui/select';
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogFooter } from '../components/ui/dialog';
-import { Separator } from '../components/ui/separator';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '../components/ui/tabs';
 
 interface AddMCPServerModalProps {

src/frontend/src/pages/SharedThread.tsx

@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react';
-import { useParams } from 'react-router-dom';
 import { Eye, AlertCircle } from 'lucide-react';
 import { ChatMessages } from '../chat/ChatMessages';
+import type { ChatMessage } from '../types';
 import { Button } from '../components/ui/button';
 
 interface SharedThreadData {
@@ -11,18 +11,13 @@ interface SharedThreadData {
     title: string;
     created_at: string;
   };
-  messages: Array<{
-    id: string;
-    role: string;
-    content: string;
-    timestamp: string;
-    toolCalls?: any[];
-  }>;
+  messages: ChatMessage[];
   read_only: boolean;
 }
 
 export function SharedThread() {
-  const { token } = useParams<{ token: string }>();
+  // Served at /shared/{token} (server.py); this app has no client-side router.
+  const token = decodeURIComponent(window.location.pathname.split('/shared/')[1]?.split('/')[0] ?? '');
   const [threadData, setThreadData] = useState<SharedThreadData | null>(null);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string>('');
@@ -128,10 +123,13 @@ export function SharedThread() {
         <div className="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
           {threadData.messages.length > 0 ? (
             <div className="divide-y divide-gray-100">
-              <ChatMessages 
+              <ChatMessages
                 messages={threadData.messages}
                 sessionId={threadData.thread_id}
-                isSharedView={true}
+                currentResponse=""
+                thinkingSteps={[]}
+                toolCalls={[]}
+                isStreaming={false}
               />
             </div>
           ) : (

src/frontend/src/spike/README.md

@@ -0,0 +1,112 @@
+# Spike #293 — BeautifulUI primitives in PraisonAIUI
+
+Time-boxed evaluation proving BeautifulUI's AI-native primitives can build inside
+PraisonAIUI's React 19 + Vite + Tailwind v4 toolchain and render against **mock,
+PraisonAIUI-shaped** agent event streams.
+
+**This folder is a spike. It is intentionally isolated from the shipped bundle:**
+nothing here is imported by `src/main.tsx`, and none of it is synced into
+`src/praisonaiui/templates/frontend`. Removing `src/frontend/src/spike/` and
+`src/frontend/spike.html` fully reverts the spike.
+
+## How to run
+
+```bash
+cd src/frontend
+npm install
+npm run dev          # then open http://localhost:5173/spike.html
+```
+
+`SpikePage.tsx` drives the three primitives from `mockEvents.ts`, which uses the
+real `SSEEvent` contract from `src/types.ts` (`run_content` deltas,
+`reasoning_step` / `tool_call_started` / `tool_call_completed`, and an
+`approval_request` payload shaped like a row from `GET /api/approvals`).
+
+## What was vendored (upstream pin)
+
+- Registry index: `https://www.beautifului.dev/r/registry.json`
+- Component JSON: `https://www.beautifului.dev/r/<name>.json`
+- Upstream repo: `slev12397/beautiful-ui` @ **`44a274e598395ab61e7c96c26fda2758780253b7`** (2026-09-22)
+- License: **MIT** (upstream repo)
+
+| Primitive | Registry item | Source | Registry deps | npm deps |
+|---|---|---|---|---|
+| StreamingText | `streaming-text` | `beautifui/primitives/StreamingText.tsx` (10.3 KB) | foundation | **none** (`react` only) |
+| ThinkingState | `thinking-state` | `beautifui/primitives/ThinkingState.tsx` (11.3 KB) | foundation | **none** (`react` only) |
+| ApprovalCard | `approval-card` | `beautifui/primitives/ApprovalCard.tsx` (16.5 KB) | foundation, button, glide-menu | **none** (`react` only) |
+| Button (dep) | `button` | `beautifui/atoms/Button.tsx` (2.0 KB) | foundation | `class-variance-authority` *(already a PraisonAIUI dep)* |
+| GlideMenu (dep) | `glide-menu` | `beautifui/primitives/GlideMenu.tsx` (1.9 KB) | foundation | **none** (`react` only) |
+| foundation | `foundation` | `beautifui/foundation.css` (17.5 KB) | — | `shadow-plugin` *(see deviation)* |
+
+### npm packages pulled by the registry & licence check
+
+For the three chosen primitives (+ their two registry deps) the registry pulls
+**zero new runtime npm packages**. The only npm dependency any of them declares is
+`class-variance-authority` (via `button`), which PraisonAIUI already ships.
+
+- `liveline`, `glimm` — **not pulled.** These are referenced only by chart-style
+  components (InsightCards) that we did not adopt. No licence review needed for this spike.
+- `@central-icons-react` — **avoided.** All three primitives render icons as
+  **inline SVG** (no icon package at all), so no `lucide-react` substitution was
+  even required. This is the cleanest possible outcome for the icon concern.
+
+## Deviations from a raw `shadcn add`
+
+1. **`shadow-plugin` removed.** `foundation.css` imports `shadow-plugin/unprefixed`
+   (an extra Tailwind plugin dependency). To keep the spike lightweight we replaced
+   it with a small local `@theme` block defining the `--shadow-*` scale. Visual
+   shadows are approximate but faithful.
+2. **Unbalanced-brace fix (upstream bug).** The flattened `foundation.css` emits a
+   **stray extra `}`** around `.records-footer-hint` (a `@media` block that lost its
+   opening line in the registry export). This makes Tailwind v4 fail with
+   `Missing opening {`. We removed the stray brace. **This is a real upstream blocker
+   worth reporting to `beautiful-ui`.**
+3. **Imports rewritten** from `@/components/*` to `@/spike/beautifui/*` so the spike
+   stays isolated and cannot collide with the existing shadcn `components/ui/button.tsx`.
+4. **`"use client"` directives dropped** (Vite SPA, not RSC).
+
+## Build result
+
+`vite build` of the spike entry (`spike.html`) succeeds:
+
+```
+✓ 39 modules transformed
+spike.css   97.82 kB │ gzip: 17.48 kB   (Tailwind + foundation)
+spike.js   247.94 kB │ gzip: 78.52 kB   (React runtime + 3 primitives + 2 deps)
+```
+
+- **Bundle size:** the primitives are cheap — self-contained TSX with no extra npm
+  deps. The JS weight is dominated by the React runtime; the incremental cost of the
+  three primitives is on the order of ~40 KB raw / low-teens KB gzip. The CSS is
+  full Tailwind + the ~17 KB foundation token/keyframe layer.
+- **Motion / `prefers-reduced-motion`:** foundation ships two
+  `@media (prefers-reduced-motion: reduce)` guards (global animation kill-switch +
+  a StreamText-specific one). Motion is handled responsibly out of the box.
+- **Dark mode parity:** foundation defines its **own** token namespace (`--page`,
+  `--canvas`, `--ink`, `--accent`, …) with its own `.dark` block, *separate* from
+  PraisonAIUI's shadcn tokens (`--background`/`--foreground` via `hsl(var(--…))`).
+  Good news: **no token collision** with the dashboard. Trade-off: the primitives do
+  **not** automatically inherit `chat.css`/YAML-driven theme colours — they'd need a
+  token bridge (map `--ink`→`--foreground`, `--surface`→`--card`, `--accent`→`--primary`)
+  before they visually match the shipped chat surface in both themes.
+
+## Assessment
+
+**Fit score: 7/10** for a spike, with caveats for production migration.
+
+**Blockers / gaps:**
+- Upstream `foundation.css` brace bug (fixed here; report upstream).
+- No automatic theme inheritance — needs a token bridge to match `chat.css` dark/light.
+- Primitives embed **demo content** (ice-cream sales copy, fake sources). They accept
+  props (`content`, `rows`, `questions`, `onSubmitted`, …) so they *can* be driven by
+  real events — proven in `SpikePage` — but the built-in defaults must be replaced.
+- PraisonAIUI already has native equivalents: `chat/ThinkingSteps.tsx`,
+  `chat/ToolCallDisplay.tsx`, streaming in `chat/ChatMessages.tsx`. Adopting
+  BeautifulUI should be weighed against enhancing these rather than duplicating them.
+
+**Recommended primitive order for migration (lowest risk → highest):**
+1. **StreamingText** — pure token-stream UX, `react`-only, maps 1:1 to `run_content`.
+2. **ThinkingState** — reasoning/tool trace, `react`-only, maps to
+   `reasoning_step` + `tool_call_*`; overlaps existing `ThinkingSteps.tsx`.
+3. **ApprovalCard** — highest value (HITL) but most surface: pulls `button` +
+   `glide-menu` and needs wiring to `POST /api/approvals/{id}/resolve`.

src/frontend/src/spike/SpikePage.tsx

@@ -0,0 +1,90 @@
+/* Spike #293 — BeautifulUI primitives driven by PraisonAIUI-shaped mock events.
+ *
+ * Dev-only harness. Run with `npm run dev` and open /spike.html. This page is
+ * NOT imported by the shipped library entry (main.tsx) and is NOT synced into
+ * src/praisonaiui/templates/frontend — per the issue's non-goals it must not
+ * touch the production bundle.
+ */
+import { useEffect, useState } from "react";
+import StreamingText from "@/spike/beautifui/primitives/StreamingText";
+import ThinkingState from "@/spike/beautifui/primitives/ThinkingState";
+import ApprovalCard from "@/spike/beautifui/primitives/ApprovalCard";
+import {
+  streamingTimeline,
+  tokensFromDeltas,
+  rowsFromReasoning,
+  REASONING_STREAM,
+  APPROVAL_REQUEST,
+} from "@/spike/mockEvents";
+
+function Panel({ title, children }: { title: string; children: React.ReactNode }) {
+  return (
+    <section style={{ marginBottom: 40 }}>
+      <h2 style={{ font: "600 13px/1.4 ui-monospace, monospace", opacity: 0.6, marginBottom: 12 }}>{title}</h2>
+      {children}
+    </section>
+  );
+}
+
+export default function SpikePage() {
+  const [dark, setDark] = useState(false);
+  const [log, setLog] = useState<string[]>([]);
+
+  useEffect(() => {
+    document.documentElement.classList.toggle("dark", dark);
+  }, [dark]);
+
+  // Emulate the SSE timeline so we exercise real delta pacing (logs only —
+  // the primitives below are fed the fully-resolved token/row arrays).
+  useEffect(() => {
+    const frames = streamingTimeline();
+    const timers = frames.map((f) =>
+      setTimeout(() => setLog((l) => [...l.slice(-4), `${f.event.type}: ${f.event.token ?? ""}`]), f.at),
+    );
+    return () => timers.forEach(clearTimeout);
+  }, []);
+
+  const tokens = tokensFromDeltas(streamingTimeline());
+  const rows = rowsFromReasoning(REASONING_STREAM);
+
+  return (
+    <div style={{ maxWidth: 720, margin: "0 auto", padding: 32, fontFamily: "system-ui, sans-serif" }}>
+      <header style={{ display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: 32 }}>
+        <div>
+          <h1 style={{ font: "700 20px/1.2 system-ui" }}>BeautifulUI spike</h1>
+          <p style={{ opacity: 0.6, fontSize: 13 }}>Issue #293 · mock PraisonAIUI event streams</p>
+        </div>
+        <button onClick={() => setDark((d) => !d)} style={{ padding: "6px 12px", borderRadius: 8 }}>
+          {dark ? "☀ light" : "🌙 dark"}
+        </button>
+      </header>
+
+      <Panel title="StreamingText ← run_content deltas">
+        <StreamingText content={tokens} loop={false} sources={[]} followUps={[]} />
+      </Panel>
+
+      <Panel title="ThinkingState ← reasoning_step / tool_call_*">
+        <ThinkingState rows={rows} active="Thinking" done={`Ran ${rows.length} steps`} />
+      </Panel>
+
+      <Panel title="ApprovalCard ← approval_request (/api/approvals)">
+        <ApprovalCard
+          questions={APPROVAL_REQUEST.questions}
+          onSubmitted={(answers) =>
+            // In production this maps to POST /api/approvals/{id}/resolve.
+            setLog((l) => [
+              ...l.slice(-4),
+              `resolve ${APPROVAL_REQUEST.id}: ${JSON.stringify(answers)}`,
+            ])
+          }
+        />
+      </Panel>
+
+      <Panel title="event log (last 5)">
+        <pre style={{ font: "12px/1.5 ui-monospace, monospace", opacity: 0.7, whiteSpace: "pre-wrap" }}>
+          {log.join("\n") || "…"}
+        </pre>
+      </Panel>
+    </div>
+  );
+}

src/frontend/src/spike/beautifui/atoms/Button.tsx

@@ -0,0 +1,48 @@
+/* Vendored from BeautifulUI registry: https://www.beautifului.dev/r/button.json
+ * Spike #293 — DO NOT ship in templates/frontend. Imports rewritten to @/spike/beautifui/*.
+ * License: MIT (upstream https://github.com/slev12397/beautiful-ui). */
+import type { ButtonHTMLAttributes } from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "@/lib/utils";
+
+const filledShadow = "shadow-[inset_0_1px_0_rgba(255,255,255,0.14)]";
+
+/* Pill-shaped by default — the app's core button style. Explicit symmetric
+ * padding (not a fixed height) so the top/bottom spacing is always equal. */
+export const buttonVariants = cva(
+  `inline-flex items-center justify-center font-medium select-none
+   transition-[transform,background-color,opacity] duration-150 ease-out
+   active:scale-[0.96] disabled:opacity-50 disabled:pointer-events-none`,
+  {
+    variants: {
+      variant: {
+        primary: `bg-ink text-canvas hover:opacity-90 dark:bg-ink dark:text-canvas ${filledShadow}`,
+        secondary: "bg-surface text-ink shadow-btn hover:bg-inset aria-expanded:bg-hover",
+        ghost: "bg-hover-2 text-ink hover:bg-line-strong",
+        accent: `bg-accent text-white hover:bg-accent-ink ${filledShadow}`,
+        success: `bg-green text-white hover:brightness-95 ${filledShadow}`,
+        /* transparent until hovered — for dense toolbars/action rows */
+        quiet: "text-ink hover:bg-hover",
+      },
+      size: {
+        /* compact toolbar pill — fixed height, lighter weight */
+        xs: "h-7 rounded-full px-2.5 text-[12px] font-normal leading-none gap-1",
+        /* canonical action pill — 27px tall, roomy sides */
+        sm: "h-[27px] px-3 text-[13px] leading-none rounded-full gap-1.5",
+        md: "px-4 py-[9px] text-sm leading-none rounded-full gap-2",
+      },
+    },
+    defaultVariants: { variant: "secondary", size: "md" },
+  },
+);
+
+export type ButtonVariant = NonNullable<VariantProps<typeof buttonVariants>["variant"]>;
+
+export function Button({
+  variant,
+  size,
+  className,
+  ...props
+}: ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof buttonVariants>) {
+  return <button className={cn(buttonVariants({ variant, size }), className)} {...props} />;
+}

src/frontend/src/spike/beautifui/foundation.css

@@ -0,0 +1,659 @@
+/* Vendored from BeautifulUI foundation: https://www.beautifului.dev/r/foundation.json
+ * Spike #293. shadow-plugin dependency neutralized (see note below). License: MIT. */
+@import "tailwindcss";
+/* shadow-plugin (flornkm) — smooth, layered shadow stacks. The unprefixed
+ * entry maps them onto Tailwind's --shadow-xs…2xl scale; our semantic tokens
+ * below build on those values so the whole app picks up the smooth shadows. */
+/* @import "shadow-plugin/unprefixed"; -- removed for spike */
+/* SPIKE deviation (#293): upstream imports `shadow-plugin/unprefixed` (extra npm dep).
+ * To keep the spike lightweight we define the --shadow-* scale locally instead. */
+@theme inline {
+  --shadow-2xs: 0 1px 0 0 oklch(0 0 0 / 0.03);
+  --shadow-xs: 0 1px 2px 0 oklch(0 0 0 / 0.05);
+  --shadow-sm: 0 1px 2px 0 oklch(0 0 0 / 0.06), 0 1px 1px -1px oklch(0 0 0 / 0.04);
+  --shadow-md: 0 2px 4px -1px oklch(0 0 0 / 0.07), 0 1px 2px -1px oklch(0 0 0 / 0.05);
+  --shadow-lg: 0 8px 16px -4px oklch(0 0 0 / 0.10), 0 2px 4px -2px oklch(0 0 0 / 0.06);
+  --shadow-xl: 0 16px 32px -8px oklch(0 0 0 / 0.12);
+  --shadow-2xl: 0 24px 48px -12px oklch(0 0 0 / 0.18);
+}
+
+
+@custom-variant dark (&:where(.dark, .dark *));
+
+/* GENERIC FOUNDATION — tokens, @theme, base rules, the primitive-*
+ * spacing utilities, and shared keyframes below are needed by EVERY
+ * component. Blocks tagged COMPONENT-SPECIFIC further down belong to
+ * one primitive each. */
+/* ──────────────────────────────────────────────────────────
+ * Beautiful UI — design tokens
+ * Cool near-white canvas, white cards, hairline borders, layered
+ * single-digit-opacity shadows, a neutral ink ramp, and semantic
+ * color used sparingly as a condiment.
+ * ────────────────────────────────────────────────────────── */
+
+:root {
+  /* surfaces — cool, blue-tinted neutrals */
+  --page: oklch(0.985 0.001 286.376);
+  --canvas: oklch(0.961 0.002 247.84);
+  --surface: oklch(1 0 0);
+  --inset: oklch(0.979 0.002 247.839);
+  --hover: oklch(0.97 0.002 247.839);
+  --hover-2: oklch(0.933 0.003 247.86);
+
+  /* ink ramp */
+  --ink: oklch(0.247 0.006 258.361);
+  --ink-2: oklch(0.506 0.01 264.477);
+  --ink-3: oklch(0.695 0.009 264.505);
+
+  /* borders — solid and crisp, not alpha */
+  --line: oklch(0.946 0.003 264.542);
+  --line-strong: oklch(0.912 0.005 258.326);
+  --line-soft: oklch(0.966 0.002 264.542);
+  --grid-line: color-mix(in srgb, var(--line) 78%, transparent);
+  --field: oklch(0.961 0.001 286.375);
+  --stripe: oklch(0.405 0 0 / 0.075);
+  --stripe-bg: oklch(0.97 0 0);
+
+  /* accent */
+  --accent: oklch(0.626 0.205 254.947);
+  --accent-ink: oklch(0.556 0.187 255.617);
+  --accent-tint: oklch(0.96 0.019 252.878);
+
+  /* semantic */
+  --green: oklch(0.603 0.155 150.883);
+  --green-tint: oklch(0.958 0.017 159.118);
+  --orange: oklch(0.689 0.179 49.902);
+  --orange-tint: oklch(0.964 0.021 67.581);
+  --red: oklch(0.621 0.192 23.042);
+  --red-tint: oklch(0.956 0.017 17.462);
+
+  /* chart overlays — neutral system colors with enough contrast on either theme */
+  --tooltip-bg: oklch(0.272 0.008 264.435);
+  --tooltip-fg: oklch(0.976 0.002 247.839);
+  --tooltip-muted: oklch(0.731 0.008 260.731);
+  --tooltip-border: oklch(0.356 0.007 264.474);
+
+  /* shadows — our solid hairline ring + shadow-plugin's smooth layered stacks
+   * (--shadow-xs…lg come from shadow-plugin/unprefixed) so every surface reads
+   * consistently across the app. */
+  --shadow-hairline: 0 0 0 1px var(--line);
+  --shadow-btn: 0 0 0 1px var(--line-strong), var(--shadow-xs);
+  --shadow-card: 0 0 0 1px var(--line), var(--shadow-sm);
+  --shadow-raised: 0 0 0 1px var(--line), var(--shadow-md);
+  --shadow-overlay: 0 0 0 1px var(--line), var(--shadow-lg);
+  --shadow-inset-field: inset 0 1px 2px oklch(0 0 0 / 0.12);
+}
+
+.dark {
+  --page: oklch(0.209 0.004 264.477);
+  --canvas: oklch(0.231 0.004 264.487);
+  --surface: oklch(0.26 0.006 271.191);
+  --inset: oklch(0.243 0.004 264.492);
+  --hover: oklch(0.289 0.006 271.22);
+  --hover-2: oklch(0.318 0.007 274.747);
+
+  --ink: oklch(0.964 0.002 247.839);
+  --ink-2: oklch(0.731 0.008 260.731);
+  --ink-3: oklch(0.541 0.01 264.484);
+
+  --line: oklch(0.308 0.006 258.354);
+  --line-strong: oklch(0.356 0.007 264.474);
+  --line-soft: oklch(0.278 0.006 258.354);
+  --field: oklch(0.293 0.006 271.223);
+  --stripe: oklch(1 0 0 / 0.055);
+  --stripe-bg: oklch(0.226 0.004 264.485);
+
+  --accent: oklch(0.68 0.173 253.301);
+  --accent-ink: oklch(0.788 0.113 248.33);
+  --accent-tint: oklch(0.68 0.173 253.301 / 0.16);
+
+  --green: oklch(0.705 0.154 153.814);
+  --green-tint: oklch(0.705 0.154 153.814 / 0.14);
+  --orange: oklch(0.746 0.156 55.642);
+  --orange-tint: oklch(0.746 0.156 55.642 / 0.14);
+  --red: oklch(0.666 0.18 21.433);
+  --red-tint: oklch(0.666 0.18 21.433 / 0.14);
+
+  --tooltip-bg: oklch(0.182 0.004 264.459);
+  --tooltip-fg: oklch(0.964 0.002 247.839);
+  --tooltip-muted: oklch(0.731 0.008 260.731);
+  --tooltip-border: oklch(0.308 0.006 258.354);
+
+  --shadow-hairline: 0 0 0 1px var(--line);
+  /* Elevation rings go to a subtle *light* hairline in dark mode: the ring
+   * paints over the surface behind the element, so a low-alpha white edge
+   * dissolves into the shadow as one continuous stroke (per smooth-shadow-ring),
+   * graduated by how far the surface floats. */
+  --shadow-btn: 0 0 0 1px oklch(1 0 0 / 0.1), 0 1px 2px oklch(0 0 0 / 0.3);
+  --shadow-card:
+    0 0 0 1px oklch(1 0 0 / 0.11), 0 1px 2px oklch(0 0 0 / 0.2),
+    0 2px 6px oklch(0 0 0 / 0.2);
+  --shadow-raised:
+    0 0 0 1px oklch(1 0 0 / 0.13), 0 2px 10px oklch(0 0 0 / 0.22);
+  --shadow-overlay:
+    0 0 0 1px oklch(1 0 0 / 0.15), 0 8px 28px oklch(0 0 0 / 0.34);
+  --shadow-inset-field: inset 0 1px 2px oklch(0 0 0 / 0.4);
+}
+
+@theme inline {
+  /* colors */
+  --color-page: var(--page);
+  --color-canvas: var(--canvas);
+  --color-surface: var(--surface);
+  --color-inset: var(--inset);
+  --color-ink: var(--ink);
+  --color-ink-2: var(--ink-2);
+  --color-ink-3: var(--ink-3);
+  --color-hover: var(--hover);
+  --color-hover-2: var(--hover-2);
+  --color-field: var(--field);
+  --color-line: var(--line);
+  --color-line-strong: var(--line-strong);
+  --color-accent: var(--accent);
+  --color-accent-ink: var(--accent-ink);
+  --color-accent-tint: var(--accent-tint);
+  --color-green: var(--green);
+  --color-green-tint: var(--green-tint);
+  --color-orange: var(--orange);
+  --color-orange-tint: var(--orange-tint);
+  --color-red: var(--red);
+  --color-red-tint: var(--red-tint);
+
+  /* shadows */
+  --shadow-hairline: var(--shadow-hairline);
+  --shadow-btn: var(--shadow-btn);
+  --shadow-inset-field: var(--shadow-inset-field);
+  --shadow-card: var(--shadow-card);
+  --shadow-raised: var(--shadow-raised);
+  --shadow-overlay: var(--shadow-overlay);
+
+  /* type */
+  --font-sans: var(--font-inter), ui-sans-serif, system-ui, sans-serif;
+  --font-mono: var(--font-mono-face), ui-monospace, "SF Mono", monospace;
+
+  /* radii — chips 6, controls 8, cards 10, windows 14, pills 999 */
+  --radius-chip: 6px;
+  --radius-control: 8px;
+  --radius-card: 10px;
+  --radius-window: 14px;
+
+  /* easing — strong curves; built-ins are too weak */
+  --ease-out-strong: cubic-bezier(0.23, 1, 0.32, 1);
+  --ease-in-out-strong: cubic-bezier(0.77, 0, 0.175, 1);
+  --ease-link: cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+/* ── base ─────────────────────────────────────────────── */
+
+html {
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-rendering: optimizeLegibility;
+}
+
+body {
+  background-color: var(--stripe-bg);
+  background-image: repeating-linear-gradient(
+    -45deg,
+    transparent 0,
+    transparent 7px,
+    var(--stripe) 7px,
+    var(--stripe) 8px
+  );
+  /* Pin the stripe pattern to the viewport so it stays put on scroll. */
+  background-attachment: fixed;
+  color: var(--ink);
+  font-feature-settings: "cv11", "ss01";
+  font-size: 14px;
+  letter-spacing: -0.01em;
+  line-height: 1.5;
+}
+
+::selection {
+  background: var(--accent-tint);
+  color: var(--ink);
+}
+
+/* ── interface hygiene (interfaces.dev cheat sheet) ────── */
+
+/* headings balance; descriptions avoid orphans (skip long-form — we have none) */
+h1,
+h2,
+h3,
+h4 {
+  text-wrap: balance;
+}
+
+p {
+  text-wrap: pretty;
+}
+
+/* underlines clear descenders */
+a {
+  text-underline-position: from-font;
+  text-decoration-skip-ink: auto;
+}
+
+/* theme switches swap every token at once — freeze transitions so the flip
+ * is one clean repaint instead of hundreds of mismatched color fades */
+.theme-switching *,
+.theme-switching *::before,
+.theme-switching *::after {
+  transition: none !important;
+}
+
+/* touch: :hover sticks after a tap, so neutralize row/header hovers there */
+@media (hover: none) {
+  .records-row:hover > .records-cell {
+    background: transparent;
+  }
+
+  .records-row:hover > td.is-colsel {
+    background: color-mix(in srgb, var(--accent) 4%, var(--surface));
+  }
+
+  .records-header-button:hover {
+    background: transparent;
+    color: var(--ink-2);
+  }
+}
+
+/* Keep the component nav scrollable but hide its scrollbar. */
+.component-nav-scroll {
+  scrollbar-width: none; /* Firefox */
+  -ms-overflow-style: none; /* legacy Edge */
+}
+.component-nav-scroll::-webkit-scrollbar {
+  display: none; /* WebKit */
+}
+
+@media (min-width: 64rem) {
+  .component-nav-scroll {
+    -webkit-mask-image: linear-gradient(
+      to bottom,
+      oklch(0 0 0) 0,
+      oklch(0 0 0) calc(100% - 6rem),
+      transparent 100%
+    );
+    mask-image: linear-gradient(
+      to bottom,
+      oklch(0 0 0) 0,
+      oklch(0 0 0) calc(100% - 6rem),
+      transparent 100%
+    );
+  }
+}
+
+/* Mobile demo gestures should operate controls and visualizations rather than
+ * selecting surrounding labels. Text entry and code remain intentionally
+ * selectable. */
+@media (hover: none) and (pointer: coarse) {
+  .primitive-showcase {
+    -webkit-user-select: none;
+    user-select: none;
+    -webkit-touch-callout: none;
+  }
+
+  .primitive-showcase :is(input, textarea, [contenteditable="true"], pre, code) {
+    -webkit-user-select: text;
+    user-select: text;
+    -webkit-touch-callout: default;
+  }
+
+  .primitive-showcase :is(a, button, [role="button"]) {
+    -webkit-tap-highlight-color: transparent;
+  }
+
+  .primitive-showcase :is(a, button, [role="button"]):focus-visible {
+    outline: none;
+  }
+
+  .primitive-showcase :is(img, svg, canvas) {
+    -webkit-user-drag: none;
+  }
+
+  .insight-chart-stage {
+    touch-action: pan-y;
+  }
+}
+
+/* Tailwind v4 resets buttons to cursor:default — anything
+ * clickable must invite the click */
+button:not(:disabled),
+[role="button"]:not([aria-disabled="true"]),
+label:has(input),
+a {
+  cursor: pointer;
+}
+
+
+:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+  border-radius: 4px;
+}
+
+input:focus-visible,
+textarea:focus-visible,
+select:focus-visible,
+[contenteditable]:focus-visible {
+  outline: none;
+}
+
+.animated-underline {
+  position: relative;
+  display: inline-block;
+}
+
+.animated-underline::after {
+  position: absolute;
+  right: 0;
+  bottom: -1px;
+  left: 0;
+  height: 1px;
+  content: "";
+  background: currentColor;
+  transform: scaleX(0);
+  transform-origin: left center;
+  transition: transform 280ms var(--ease-link);
+}
+
+a:hover .animated-underline::after,
+a:focus-visible .animated-underline::after {
+  transform: scaleX(1);
+}
+
+/* ══════════════════════════════════════════════════════════
+ * COMPONENT-SPECIFIC — StreamingText / ContextCards
+ * Favicon source avatars.
+ * Copy this block only alongside StreamingText / ContextCards; it is not part of the
+ * generic foundation above.
+ * ══════════════════════════════════════════════════════════ */
+.source-avatar {
+  box-shadow: 0 0 0 1px oklch(0.21 0.034 263.436 / 0.1);
+}
+
+.dark .source-avatar {
+  box-shadow: 0 0 0 1px oklch(1 0 0 / 0.08);
+}
+
+/* ── primitive spacing system ─────────────────────────────
+ * Shared optical offsets for small demo cards. Use these
+ * instead of hand-tuning 10/12/14px per component.
+ */
+
+.primitive-card-pad {
+  padding: 12px;
+}
+
+.primitive-card-bar {
+  padding: 10px 12px;
+}
+
+.primitive-card-footer {
+  padding: 10px;
+}
+
+.primitive-table-cell {
+  padding: 10px 12px;
+}
+
+.primitive-icon-button {
+  display: inline-flex;
+  width: 28px;
+  height: 28px;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--radius-control);
+}
+
+/* ── shared keyframes ─────────────────────────────────── */
+
+@keyframes shimmer-text {
+  from {
+    background-position: 150% center;
+  }
+  to {
+    background-position: -50% center;
+  }
+}
+
+@keyframes fade-up {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.home-reveal {
+  will-change: opacity, transform, filter;
+}
+
+/* The sidebar is one persistent 224px tree clipped by a 52px shell.
+ * Every rail glyph remains centered at x=26 in both states. */
+  .records-footer-hint {
+    display: none;
+  }
+/* SPIKE fix (#293): upstream foundation.css emits a stray extra `}` here — a
+ * flattened @media block that lost its opening line. Removed so Tailwind v4
+ * can parse the stylesheet. See spike report. */
+
+/* ── filter table electric status colors ─────────────────── */
+
+/* ══════════════════════════════════════════════════════════
+ * COMPONENT-SPECIFIC — FilterTable
+ * Electric status-pill colors.
+ * Copy this block only alongside FilterTable; it is not part of the
+ * generic foundation above.
+ * ══════════════════════════════════════════════════════════ */
+.filter-status-todo,
+.filter-status-progress,
+.filter-status-done {
+  border: 1px solid transparent;
+}
+
+/* ══════════════════════════════════════════════════════════
+ * COMPONENT-SPECIFIC — InsightCards
+ * Liveline chart tooltip + cursor.
+ * Copy this block only alongside InsightCards; it is not part of the
+ * generic foundation above.
+ * ══════════════════════════════════════════════════════════ */
+.insight-chart-stage {
+  overflow: hidden;
+}
+
+.insight-chart-cursor {
+  position: absolute;
+  z-index: 4;
+  top: 0;
+  bottom: 0;
+  width: 1px;
+  background: var(--ink);
+  opacity: 0.26;
+  pointer-events: none;
+}
+
+.insight-chart-tooltip-anchor {
+  position: absolute;
+  z-index: 5;
+  top: 8px;
+  transform: translateX(-50%);
+  pointer-events: none;
+}
+
+.insight-chart-tooltip {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 5px 9px;
+  border: 1px solid var(--line-strong);
+  border-radius: 8px;
+  color: var(--tooltip-fg);
+  background: var(--tooltip-bg);
+  box-shadow: var(--shadow-overlay);
+  font-size: 11.5px;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+.insight-chart-tooltip-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.insight-chart-tooltip-dot {
+  width: 8px;
+  height: 8px;
+  flex: 0 0 8px;
+  border-radius: 50%;
+}
+
+/* Status pills share the same base-hue → color-mix derivation as .records-tag,
+ * so both components stay consistent across light and dark. */
+.filter-status-todo {
+  --tag-base: oklch(0.757 0.153 66.401);
+}
+.filter-status-progress {
+  --tag-base: oklch(0.671 0.118 219.351);
+}
+.filter-status-done {
+  --tag-base: oklch(0.652 0.131 162.865);
+}
+
+.filter-status-todo,
+.filter-status-progress,
+.filter-status-done {
+  color: color-mix(in srgb, var(--tag-base) 92%, var(--ink));
+  background: color-mix(in srgb, var(--tag-base) 20%, var(--surface));
+  border-color: color-mix(in srgb, var(--tag-base) 34%, var(--surface));
+}
+
+/* Dark mode — a richer, saturated same-hue fill
+ * with bright same-hue text and no visible border (light mode keeps the soft
+ * tinted pastels above). Applies to both the records grid and status pills. */
+.dark .records-tag,
+.dark .filter-status-todo,
+.dark .filter-status-progress,
+.dark .filter-status-done {
+  color: color-mix(in srgb, var(--tag-base) 86%, white);
+  background: color-mix(in srgb, var(--tag-base) 34%, var(--surface));
+  border-color: color-mix(in srgb, var(--tag-base) 34%, var(--surface));
+}
+
+@keyframes fade-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes eq-bounce {
+  0%,
+  100% {
+    transform: scaleY(0.35);
+  }
+  50% {
+    transform: scaleY(1);
+  }
+}
+
+/* ── StreamText primitive ─────────────────────────────────
+ * Fast character reveal: the newest few characters carry a
+ * soft, masked blur so the leading edge resolves smoothly as
+ * text flows in. The caret holds solid while streaming, then
+ * blinks once the string settles. */
+/* ══════════════════════════════════════════════════════════
+ * COMPONENT-SPECIFIC — StreamText
+ * The streaming caret + tail.
+ * Copy this block only alongside StreamText; it is not part of the
+ * generic foundation above.
+ * ══════════════════════════════════════════════════════════ */
+.stream-tail {
+  filter: blur(1.6px);
+  -webkit-mask-image: linear-gradient(to right, oklch(0 0 0) 20%, oklch(0 0 0 / 0.2));
+  mask-image: linear-gradient(to right, oklch(0 0 0) 20%, oklch(0 0 0 / 0.2));
+}
+
+.stream-caret {
+  display: inline-block;
+  width: 2px;
+  height: 1.05em;
+  margin-left: 1.5px;
+  translate: 0 -0.5px;
+  border-radius: 1px;
+  background: var(--ink);
+  vertical-align: text-bottom;
+  animation: caret-blink 1s step-end infinite;
+}
+
+.stream-caret.is-streaming {
+  animation: none;
+}
+
+@keyframes caret-blink {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .stream-caret {
+    animation: none;
+  }
+  .stream-tail {
+    filter: none;
+    -webkit-mask-image: none;
+    mask-image: none;
+  }
+}
+
+@keyframes pop-in {
+  from {
+    opacity: 0;
+    transform: scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* pixel-grid loader — brighten plateau, staggered per cell */
+@keyframes pixel-on {
+  0%, 100% {
+    opacity: 0.15;
+  }
+  18%, 42% {
+    opacity: 1;
+  }
+  62% {
+    opacity: 0.15;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+  }
+}