dv-pipecat-flows 0.0.0.dev2393__tar.gz → 0.0.0.dev2572__tar.gz

{dv_pipecat_flows-0.0.0.dev2393 → dv_pipecat_flows-0.0.0.dev2572}/.gitignore

@@ -187,3 +187,5 @@ MANIFEST
 
 # Asterisk configs
 remote-asterisk-code/pjsip.conf
+.venvringg1
+.venvringg2

{dv_pipecat_flows-0.0.0.dev2393/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.0.dev2572}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2393
+Version: 0.0.0.dev2572
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows
@@ -309,4 +309,3 @@ We aim to review all contributions promptly and provide constructive feedback to
 ➡️ [Reach us on X](https://x.com/pipecat_ai)
 
 
-

{dv_pipecat_flows-0.0.0.dev2393 → dv_pipecat_flows-0.0.0.dev2572}/README.md

@@ -284,4 +284,3 @@ We aim to review all contributions promptly and provide constructive feedback to
 ➡️ [Reach us on X](https://x.com/pipecat_ai)
 
 
-

{dv_pipecat_flows-0.0.0.dev2393 → dv_pipecat_flows-0.0.0.dev2572}/browser_copilot/docs/CODE_MAP.md

@@ -81,7 +81,7 @@ CHAT TEXT  bot ──► widget: send_chat_text (topic "lk.chat", scrub_handles)
 - `perception.ts:buildDomSummary()` ↔ `dom_context_injector.py:_render_summary()` —
   the DomSummary v2 shape. All v2 keys optional; legacy `headings` kept for old injectors.
 - `copilot_support.py:BROWSER_COPILOT_ACTION_TOOLS` ↔
-  `browser_actions.py:BROWSER_ACTION_SCHEMAS` — the 8 tool names the backend injects
+  `browser_actions.py:BROWSER_ACTION_SCHEMAS` — the 9 tool names the backend injects
   must resolve to schemas the bot registers.
 - Timeouts: widget `AUTO_DENY_MS=15s` (use-copilot.ts) must stay under the bot's
   `send_dom_action` 20s RPC timeout (livekit_rpc_bridge.py) — a stuck confirm bar
@@ -205,22 +205,25 @@ CHAT TEXT  bot ──► widget: send_chat_text (topic "lk.chat", scrub_handles)
 - Legacy (pre-v2) summaries render byte-identical to before (`_action_flags` is empty for them); a raw input `value` key is never rendered on the summary path.
 - `_build_message_text()` = marker + URL/Title + summary + "User is currently: …"; hard tail-truncate at 12,000 chars (hostile summaries can't blow the context). `_sync_to_context()` filters old `[Browser context]` messages and appends the fresh one.
 - Also holds `_url` — read by `browser_actions._current_url` for the mutating-action origin guardrail.
+- Auto-continue chain: `arm_continue` (mutating action) → next LLM step fires when the fresh summary lands (`_maybe_continue`, capped `MAX_CHAIN`). Stale-summary watchdog (`CONTINUE_FALLBACK_S=3.5`): if no summary lands (a DOM change the digest can't see, e.g. an option toggle), fire the continue anyway with a `[Browser context]` re-check note (`_stale_note`) so the chain can't starve. `_action_flags` renders `[checked]`/`[unchecked]` (selection state) alongside `[filled]`/`[sensitive]`; long `— options: …` lists truncate with `…`.
 
 ### `utils/flow_tools/browser_actions.py`
-- The LLM-callable hands: 8 handlers (`read_dom`, `find_elements`, `read_region`, `click_element`, `type_text`, `select_option`, `scroll_page`, `highlight_element`) + their `FlowsFunctionSchema`s in `BROWSER_ACTION_SCHEMAS`. Targeting: `cp` handle is the advertised, preferred key (`ref` deliberately NOT advertised — one handle namespace; strays still forwarded); `selector`/`text`/`role` fallbacks. Mutating schemas take an optional `say` ack.
-- `_run(flow_manager, action, params, say)` — shared guardrails, in order: bridge present (`state["livekit_rpc"]`) → kill-switch `copilot_config.disabled` → for `MUTATING_ACTIONS`, `_origin_allowed(injector._url, cfg.allowed_origins)` (empty allowlist = allow all) → confirm policy → `bridge.send_dom_action`.
+- The LLM-callable hands: 9 handlers (`read_dom`, `find_elements`, `read_region`, `click_element`, `type_text`, `select_option`, `scroll_page`, `highlight_element`, `execute_plan`) + their `FlowsFunctionSchema`s in `BROWSER_ACTION_SCHEMAS`. Targeting: `cp` handle is the advertised, preferred key (`ref` deliberately NOT advertised — one handle namespace; strays still forwarded); `selector`/`text`/`role` fallbacks. Mutating schemas take an optional `say` ack.
+- `_run_step(flow_manager, action, params) -> (ok, body)` — the shared guardrails, in order: bridge present (`state["livekit_rpc"]`) → kill-switch `copilot_config.disabled` → for `MUTATING_ACTIONS`, `_origin_allowed(injector._url, cfg.allowed_origins)` (empty allowlist = allow all) → confirm policy → `bridge.send_dom_action`. `_run(...)` is the single-action wrapper (adds `say`, suppression, `arm_continue`).
+- `execute_plan({steps, say})` — one LLM call runs an ordered batch of steps on the CURRENT view via `_run_step` each (`MAX_PLAN_STEPS=8`, `PLAN_BATCH_BUDGET_S=60`), stops at the first failure/denial, then issues one `read_dom` and folds the fresh page into `[Browser context]` (`injector.absorb(CT_DOM_SUMMARY, …)`), returning ActionResult-v1-shaped `results` + a compact `page` digest. NO suppression sentinel / no `arm_continue` → the follow-up LLM runs and plans the next batch off the real page. `disarm_continue()`s at start (a batch supersedes the passive chain). Confirm-eligible steps use the blocking confirm bar mid-batch.
 - Confirm policy: `_CONFIRM_EXEMPT_ACTIONS = {click, scroll, select}` ALWAYS auto-run (product decision), even destructive-named, even under `high_risk_confirm`. Only `type` can confirm: `require_confirm=True` when `high_risk_confirm` OR `_is_destructive`.
 - `_is_destructive`: `_target_name` from `target.text`, else the cp handle looked up in the injector's live summary (actions/content/form fields); matched against the `_DESTRUCTIVE` lexicon (submit/pay/delete/cancel subscription/publish/…); fail-open when no name resolves (destructive intents are named explicitly).
 - Act-then-wait: successful MUTATING actions return `_suppress_followup_llm: True` (flows manager → `run_llm=False`; single-node adapter translates) — the fresh `[Browser context]` arrives async, so an immediate completion could only act on the STALE page. The optional `say` ack is spoken out-of-band via `_speak` (scrubbed; `state["_speak"]` shim or `task.queue_frame(TTSSpeakFrame)`) so the bot isn't silent. Failures never suppress.
-- Single-node adapter: `resolve_copilot_config(call_config)` (env fallbacks `COPILOT_ALLOWED_ORIGINS` / `COPILOT_HIGH_RISK_CONFIRM` / `COPILOT_DISABLED`); `register_single_node_browser_tools(...)` registers the same 8 schemas on bot.py when `copilot_config.enabled`, wrapping each flows handler in a `SimpleNamespace(state=…)` shim — same `_run` guardrails, zero duplication; suppression becomes `FunctionCallResultProperties(run_llm=False)`.
+- Single-node adapter: `resolve_copilot_config(call_config)` (env fallbacks `COPILOT_ALLOWED_ORIGINS` / `COPILOT_HIGH_RISK_CONFIRM` / `COPILOT_DISABLED`); `register_single_node_browser_tools(...)` registers the same 9 schemas on bot.py when `copilot_config.enabled`, wrapping each flows handler in a `SimpleNamespace(state=…)` shim — same `_run` guardrails, zero duplication; suppression becomes `FunctionCallResultProperties(run_llm=False)`.
 
 ### bot wiring (copilot-relevant only)
 - `bot_with_flows.py` — LiveKit channel, `on_connected`: builds `DomContextInjector` (+`set_flow_manager`), resolves `copilot_cfg` from `call_config.copilot_config` with the same env fallbacks, then `LiveKitRPCBridge(room, task, …, copilot_sink=dom_injector.absorb)` + `register_handlers()`; stores `dom_injector` / `copilot_config` / `livekit_rpc` in `flow_manager.state` (read by `_run`). Tools arrive pre-injected in the flow nodes (backend's `enable_browser_copilot_tools_in_flow`) and resolve to the `BROWSER_ACTION_SCHEMAS` handlers. Text mode: `transcript_handler.on_message_added = _relay_chat_reply` → `bridge.send_chat_text` (the widget's chat rendering path).
 - `bot.py` — single-node: `copilot_state_ref: dict` created before tool build; `register_single_node_browser_tools(call_config=…, state_ref=copilot_state_ref, …)` at tool-registration time (LiveKit channel only); `on_connected` fills the ref with `livekit_rpc` + `dom_injector` (`DomContextInjector.set_context_aggregator(context_aggregator.user())`) — handlers read them lazily through the shim.
 
 ### tests
-- `tests/test_browser_action_suppression.py` — act-then-wait (mutating success suppresses; reads/highlight/failures never), kill-switch, origin allowlist, click/scroll/select NEVER confirm, destructive `type` confirms by default, `high_risk_confirm` forwarding, `scrub_handles` + say-ack scrubbing, destructive-name lookup via the injector summary, single-node registration (8 tools; skipped when disabled) and adapter `run_llm` translation.
-- `tests/test_dom_context_injector.py` — legacy summary renders golden-identical, v2 flags/content/focused/viewport, dropdown options line, hostile `value` key never rendered, content/message caps, activity line.
+- `tests/test_browser_action_suppression.py` — act-then-wait (mutating success suppresses; reads/highlight/failures never), kill-switch, origin allowlist, click/scroll/select NEVER confirm, destructive `type` confirms by default, `high_risk_confirm` forwarding, `scrub_handles` + say-ack scrubbing, destructive-name lookup via the injector summary, single-node registration (9 tools; skipped when disabled) and adapter `run_llm` translation.
+- `tests/test_execute_plan.py` — ordered batch runs then re-perceives, stop-on-failure / denied-confirm / invalid-step, per-step origin & confirm guardrails, kill-switch skips read_dom, `MAX_PLAN_STEPS` truncation, one scrubbed `say`, read_dom-failure `page_error`, single-node adapter runs the LLM (no suppression), `_step_to_action` mapping.
+- `tests/test_dom_context_injector.py` — legacy summary renders golden-identical, v2 flags/content/focused/viewport, dropdown options line + long-list truncation, `[checked]`/`[unchecked]` state, hostile `value` key never rendered, content/message caps, activity line, auto-continue chain + stale-summary watchdog (fires on no-summary, cancelled by summary/disarm, one-shot, respects `MAX_CHAIN`).
 
 ## E. Ops
 

{dv_pipecat_flows-0.0.0.dev2393 → dv_pipecat_flows-0.0.0.dev2572}/browser_copilot/docs/CONTRACTS.md

@@ -111,6 +111,17 @@ bot sets `require_confirm` on the `cp_action` when its target is
 when `copilot_config.high_risk_confirm=true`; the widget shows its confirm bar
 when that flag is present.
 
+### execute_plan — bot-side batching (no new wire action)
+
+`execute_plan` is an LLM tool that takes an ordered list of steps and runs them as
+**individual `cp_action`s** in sequence (same wire, same per-step guardrails), then
+issues one `read_dom` and folds the fresh page into `[Browser context]` — the model
+plans the next batch off the real page instead of waiting for the async summary.
+There is NO new `cp_action` verb; the widget is unchanged. Per-step outcomes are
+ActionResult-v1-shaped; confirm-eligible steps use the existing blocking confirm bar
+mid-batch (a `user denied` stops the batch). This revives the retired chat_http
+`one_shot_plan` batching, with active re-perception replacing the `last_results` ack.
+
 ## cp_action ↔ PlannedAction mapping (chat column RETIRED — voice/chat now share cp_action)
 
 | voice `cp_action` | chat `PlannedAction.action` (retired) | notes |

dv_pipecat_flows-0.0.0.dev2572/browser_copilot/docs/COPILOT_TODO.md

@@ -0,0 +1,79 @@
+# Browser Copilot — intelligence backlog
+
+Ideas for making the copilot smarter. Guiding principle:
+
+> **Prompt** for judgment/planning the LLM is good at (when to reassure, how to
+> decompose a vague ask, which page to open). **Code** for deterministic guarantees
+> the LLM is unreliable at (a filler that MUST fire on slow loads; the multi-step
+> loop that carries a plan across turns).
+
+Status legend: **SHIPPED** · **DEFERRED** · **IDEA**.
+
+---
+
+## 1. Optional on-demand screenshots (html2canvas) — DEFERRED
+
+An optional per-agent toggle; when on, the agent can call a `read_screen` tool to
+capture a visual of the page (charts, images, exact layout the text DOM view can't
+convey). Chosen approach: **html2canvas, on-demand** — no browser permission prompt,
+page-scoped, captured only when asked.
+
+Current state is mostly unbuilt: `ScreenAutoInjector`
+(`ringg_processors/screen_auto_injector.py`) exists but is Daily-only; the LiveKit
+`CT_SCREENSHOT` path is a stub; the widget has no capture and sends data only via
+`performRpc` (~15 KB cap). Build outline:
+
+- **Config:** `screenshot: bool` on `CopilotConfig` (`new_calling_agent_backend/calling/schema.py`); rides the existing `copilot_config` threading.
+- **Widget:** add `html2canvas`; implement the `screenshot` cp_action (executor
+  renders the page → JPEG data-URL, excluding `[data-copilot-ui]`); `use-copilot.ts`
+  sends it over a LiveKit **text stream** (bypasses the RPC size cap).
+- **Bot:** inbound text-stream handler (mirror `utils/participant_handler.py`'s
+  `register_text_stream_handler`) → feed a `ScreenAutoInjector` (add an `inject_b64`
+  method reusing `_sync_to_context`), wired on the copilot path when the flag is on;
+  reinject after node transitions.
+- **Tool:** `read_screen` schema/handler in `browser_actions.py`, registered only
+  when the flag is on (single-node + multi-node paths).
+
+Caveats: async (the image lands on the agent's next turn); html2canvas can't render
+cross-origin iframes / some CSS / DRM `<video>` / tainted `<canvas>`; keep JPEG
+quality ~0.6 and cap dimensions to bound tokens.
+
+---
+
+## 2. Spoken "waiting / fetching data" filler — PROMPT shipped, code watchdog DEFERRED
+
+When the agent triggers something that loads data, the user shouldn't sit in silence.
+
+- **Prompt (SHIPPED via the operating-guidance block):** the agent is told to add a
+  short spoken `say` ("one moment, pulling that up") when it clicks/submits something
+  that loads. `say` is already a param on every action tool.
+- **Code watchdog (DEFERRED):** the LLM is silent during the act-then-wait gap, so
+  for genuinely slow loads add a watchdog in
+  `ringg_processors/dom_context_injector.py::_maybe_continue` — if the fresh
+  perception hasn't arrived within ~N s, queue a `TTSSpeakFrame` filler. The injector
+  already holds the task + wait loop. Only worth it if slow loads are common.
+
+---
+
+## 3. Vague ask → navigate → explore → act — PROMPT (SHIPPED)
+
+Pure prompt discipline; no new code. The tools (`navigate`/`scroll`,
+`read_dom`/`find_elements`, `click`/`type`/`select`) and the multi-step chaining loop
+already let the LLM do navigate→settle→perceive→act across turns.
+
+- **SHIPPED via the operating-guidance block:** "if the target isn't on the current
+  screen, navigate first; then read_dom/find_elements to locate it before acting;
+  never act on a handle you haven't seen."
+- **IDEA:** give each agent a small site-map (page → what's there) so a vague intent
+  resolves to a page. This is knowledge for the LLM, NOT a hard-coded intent→page
+  branch (code can't infer "vague ask → which page" without app-specific mapping).
+
+---
+
+## Where shared prompt content lives
+
+Behaviors #2 (ack) and #3 (explore-first) ship as a single **operating-guidance
+block injected by code** when copilot is active — the `_COPILOT_GUIDANCE` message in
+`dom_context_injector.py`, kept present once per turn and across RESET* transitions
+via the sticky-context mechanism. Prompt content, delivered by code, once, for every
+copilot agent — no per-agent prompt edits.

dv_pipecat_flows-0.0.0.dev2572/scripts/azure_latency_probe.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""Azure OpenAI latency probe — run it FROM Azure to isolate the GCP->Azure network hop.
+
+We currently call Azure OpenAI from GCP pods, so every LLM request eats a
+cross-cloud round-trip. Run this same script (a) from a GCP pod and (b) from an
+Azure VM in the SAME region as the deployment, then diff the numbers. The
+network-layer stats (DNS/TCP/TLS) show the raw hop cost; the streaming chat
+stats (TTFT/total) show what actually reaches the voice pipeline.
+
+Zero repo dependencies — the only third-party import is `openai` (already in our
+images). Config comes entirely from env vars whose names match env_config.py, so
+you can drop this one file on any box and run it.
+
+Usage:
+    # Point it at whichever deployment you want to test. Defaults to the
+    # AZURE_CHATGPT_* (eastus gpt-4.1) deployment.
+    export AZURE_CHATGPT_ENDPOINT="https://<resource>.openai.azure.com"
+    export AZURE_CHATGPT_API_KEY="..."
+    python3 azure_latency_probe.py --model gpt-4.1 --runs 20
+
+    # Test a different deployment by pointing at its env-var pair:
+    python3 azure_latency_probe.py --endpoint-var AZURE_GPT_5 --model gpt-5-mini
+
+    # Or override endpoint/key directly:
+    python3 azure_latency_probe.py --endpoint https://x.openai.azure.com --api-key ... --model gpt-4.1
+"""
+
+import argparse
+import os
+import socket
+import ssl
+import statistics
+import sys
+import time
+from urllib.parse import urlparse
+
+API_VERSION = "2025-04-01-preview"
+
+# Small, fixed prompt so inter-environment differences reflect network, not
+# prompt-processing variance. Ask for a bit of output so TTFT is meaningful.
+PROMPT = "Reply with a single sentence describing what a load balancer does."
+
+
+def _p(name: str, values: list[float]) -> str:
+    if not values:
+        return f"{name}: (no samples)"
+    values = sorted(values)
+    mean = statistics.mean(values)
+    p50 = statistics.median(values)
+    p95 = values[min(len(values) - 1, int(round(0.95 * (len(values) - 1))))]
+    return (
+        f"{name:<28} n={len(values):<3} "
+        f"min={min(values):7.1f}  p50={p50:7.1f}  mean={mean:7.1f}  "
+        f"p95={p95:7.1f}  max={max(values):7.1f}  (ms)"
+    )
+
+
+def measure_network(host: str, port: int, runs: int) -> dict[str, list[float]]:
+    """Raw network cost to the endpoint: DNS resolve, TCP connect, TLS handshake.
+
+    Each run opens a fresh connection (no keep-alive) so we see the full
+    cold-path cost every time — this is the part a same-region Azure VM should
+    slash relative to a GCP pod.
+    """
+    stats: dict[str, list[float]] = {"dns": [], "tcp": [], "tls": []}
+    ctx = ssl.create_default_context()
+    for _ in range(runs):
+        try:
+            t0 = time.perf_counter()
+            infos = socket.getaddrinfo(host, port, proto=socket.IPPROTO_TCP)
+            t_dns = time.perf_counter()
+            stats["dns"].append((t_dns - t0) * 1000)
+
+            family, socktype, proto, _, sockaddr = infos[0]
+            sock = socket.socket(family, socktype, proto)
+            sock.settimeout(10)
+            t1 = time.perf_counter()
+            sock.connect(sockaddr)
+            t_tcp = time.perf_counter()
+            stats["tcp"].append((t_tcp - t1) * 1000)
+
+            t2 = time.perf_counter()
+            ssock = ctx.wrap_socket(sock, server_hostname=host)
+            t_tls = time.perf_counter()
+            stats["tls"].append((t_tls - t2) * 1000)
+            ssock.close()
+        except Exception as exc:  # noqa: BLE001 — probe should never abort the run
+            print(f"  network probe error: {exc}", file=sys.stderr)
+    return stats
+
+
+def measure_chat(
+    endpoint: str, api_key: str, model: str, runs: int
+) -> dict[str, list[float]]:
+    """Real streaming chat completion: time-to-first-token and total time.
+
+    Uses the same Azure OpenAI surface the bot uses (dated api_version on the
+    /openai/deployments path). Streaming so TTFT is the latency the voice
+    pipeline actually feels before it can start speaking.
+    """
+    try:
+        from openai import AzureOpenAI
+    except ImportError:
+        print(
+            "openai package not installed. `pip install openai` and re-run.",
+            file=sys.stderr,
+        )
+        return {"ttft": [], "total": []}
+
+    client = AzureOpenAI(
+        azure_endpoint=endpoint,
+        api_key=api_key,
+        api_version=API_VERSION,
+        max_retries=0,
+    )
+    stats: dict[str, list[float]] = {"ttft": [], "total": []}
+    for i in range(runs):
+        try:
+            t0 = time.perf_counter()
+            stream = client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": PROMPT}],
+                stream=True,
+                max_tokens=64,
+                temperature=1,
+            )
+            first = None
+            for chunk in stream:
+                # Match pipecat's TTFB semantics exactly (see
+                # dv-pipecat base_llm.py::_process_context): TTFB stops on the
+                # FIRST chunk that carries a non-empty `choices` list — the
+                # opening role delta — NOT the first chunk with `delta.content`.
+                # usage-only / empty-choices chunks are skipped, same as pipecat.
+                if chunk.choices is None or len(chunk.choices) == 0:
+                    continue
+                if first is None:
+                    first = time.perf_counter()
+            t_end = time.perf_counter()
+            if first is not None:
+                stats["ttft"].append((first - t0) * 1000)
+            stats["total"].append((t_end - t0) * 1000)
+        except Exception as exc:  # noqa: BLE001
+            print(f"  chat request {i} error: {exc}", file=sys.stderr)
+    return stats
+
+
+def resolve_config(args) -> tuple[str, str]:
+    """Return (endpoint, api_key) from --endpoint/--api-key or the env-var pair."""
+    if args.endpoint and args.api_key:
+        return args.endpoint.rstrip("/"), args.api_key
+    prefix = args.endpoint_var  # e.g. "AZURE_CHATGPT"
+    endpoint = args.endpoint or os.environ.get(f"{prefix}_ENDPOINT")
+    api_key = args.api_key or os.environ.get(f"{prefix}_API_KEY")
+    if not endpoint or not api_key:
+        print(
+            f"Missing config. Set {prefix}_ENDPOINT and {prefix}_API_KEY "
+            f"(or pass --endpoint/--api-key).",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    return endpoint.rstrip("/"), api_key
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument(
+        "--endpoint-var",
+        default="AZURE_CHATGPT",
+        help="Env-var prefix to read <PREFIX>_ENDPOINT/<PREFIX>_API_KEY from "
+        "(default: AZURE_CHATGPT). e.g. AZURE_GPT_5, AZURE_INDIA, AZURE_SECONDARY.",
+    )
+    parser.add_argument("--endpoint", help="Override endpoint directly")
+    parser.add_argument("--api-key", help="Override API key directly")
+    parser.add_argument("--model", default="gpt-4.1", help="Deployment / model name")
+    parser.add_argument("--runs", type=int, default=20, help="Iterations per test")
+    parser.add_argument(
+        "--skip-chat",
+        action="store_true",
+        help="Only run the network-layer probe (no billed LLM calls)",
+    )
+    args = parser.parse_args()
+
+    endpoint, api_key = resolve_config(args)
+    host = urlparse(endpoint).hostname or endpoint
+    port = urlparse(endpoint).port or 443
+
+    print(f"Target endpoint : {endpoint}")
+    print(f"Host            : {host}:{port}")
+    print(f"Model           : {args.model}")
+    print(f"Runs            : {args.runs}")
+    print(f"api_version     : {API_VERSION}")
+    print("-" * 78)
+
+    print("Network layer (fresh connection each run):")
+    net = measure_network(host, port, args.runs)
+    print("  " + _p("DNS resolve", net["dns"]))
+    print("  " + _p("TCP connect", net["tcp"]))
+    print("  " + _p("TLS handshake", net["tls"]))
+    conn = [d + t + s for d, t, s in zip(net["dns"], net["tcp"], net["tls"])]
+    print("  " + _p("connect total (D+T+T)", conn))
+    print("-" * 78)
+
+    if args.skip_chat:
+        print("Chat probe skipped (--skip-chat).")
+        return
+
+    print("Streaming chat completion (real LLM request):")
+    chat = measure_chat(endpoint, api_key, args.model, args.runs)
+    print("  " + _p("TTFT (first token)", chat["ttft"]))
+    print("  " + _p("total (full response)", chat["total"]))
+    print("-" * 78)
+    print(
+        "Interpretation: run this from a GCP pod and from a same-region Azure VM.\n"
+        "The delta in 'connect total' and 'TTFT' is the cross-cloud network cost\n"
+        "you'd eliminate by co-locating the caller with the Azure deployment."
+    )
+
+
+if __name__ == "__main__":
+    main()