fix(showcase/langgraph-python): correctness fixes for demos

Real demo-time bugs in the langgraph-python integration:

- `interrupt-headless` was rendering hardcoded stale slot dates from a
  `DEFAULT_SLOTS` constant instead of reading `payload.slots` that the
  backend `interrupt(...)` already supplies. Sibling `gen-ui-interrupt`
  does this correctly. Headless variant now matches.
- `_shared/interrupt-fallback-slots.ts` (new) — the JS fallback for
  when the backend returns no `slots` array. Generates relative to
  Date.now() so the picker never shows past dates. Used by both
  `interrupt-headless` and `gen-ui-interrupt`. Deletes the old stale-
  literal `gen-ui-interrupt/fallback-slots.ts` (dates from April that
  had already decayed).
- `interrupt_agent.py` — replaced hardcoded `timezone(timedelta(-7))`
  PDT with `zoneinfo.ZoneInfo("America/Los_Angeles")` so the demo
  doesn't lie about offsets in winter. Also fixed a Sunday edge case
  where `next_monday` collapsed to the same date as `tomorrow` (both
  Python and the JS fallback) — added a `<= 1` skip-a-week guard.
- `package.json#dev` ran `uvicorn agent_server:app --port 8000` but
  `src/agent_server.py` was a 3-line stub with no `app` symbol AND the
  API route pointed at port 8123. Replaced with the canonical
  `langgraph_cli dev --port 8123` invocation; deleted the dead stub.
- `entrypoint.sh:47` smoke-checked `src/agents/tools.py` (a file that
  never existed) so every Railway boot logged a phantom ERROR. Dropped.
- `reasoning_agent.py` and `tool_rendering_reasoning_chain_agent.py`
  intentionally omit `CopilotKitMiddleware` (they exercise only
  reasoning-token streaming, no frontend tools / app context). Added a
  one-line comment so a future maintainer doesn't cargo-cult it back in.
- `subagents._invoke_sub_agent` text-block walker had a regression
  where a `{"type":"text","text":null}` payload (a known provider
  quirk) would crash `"".join(parts)` with `TypeError: sequence item
  N: expected str instance, NoneType found`. Restored the
  `isinstance(block.get("text"), str)` guard.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: tylerslaton

showcase/integrations/langgraph-python/entrypoint.sh

@@ -44,7 +44,6 @@ fi
 echo "[entrypoint] Checking files..."
 ls -la langgraph.json 2>/dev/null && echo "[entrypoint] langgraph.json: OK" || echo "[entrypoint] ERROR: langgraph.json missing!"
 ls -la src/agents/main.py 2>/dev/null && echo "[entrypoint] src/agents/main.py: OK" || echo "[entrypoint] ERROR: src/agents/main.py missing!"
-ls -la src/agents/tools.py 2>/dev/null && echo "[entrypoint] src/agents/tools.py: OK" || echo "[entrypoint] ERROR: src/agents/tools.py missing!"
 ls -la .next/server 2>/dev/null > /dev/null && echo "[entrypoint] .next/server: OK" || echo "[entrypoint] ERROR: .next build missing!"
 
 echo "[entrypoint] langgraph.json contents:"

showcase/integrations/langgraph-python/package.json

@@ -3,7 +3,7 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "dev": "concurrently \"next dev --turbopack\" \"PYTHONPATH=. python -m uvicorn agent_server:app --host 0.0.0.0 --port 8000 --reload\"",
+    "dev": "concurrently \"next dev --turbopack\" \"python -u -m langgraph_cli dev --config langgraph.json --host 0.0.0.0 --port 8123 --no-browser\"",
     "build": "next build",
     "start": "next start",
     "lint": "next lint",

showcase/integrations/langgraph-python/src/agent_server.py

@@ -10,8 +10,9 @@
 
 from __future__ import annotations
 
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, time, timedelta
 from typing import Any, List, Optional
+from zoneinfo import ZoneInfo
 
 from langchain.agents import create_agent
 from langchain_core.tools import tool
@@ -29,31 +30,35 @@
     "cancelled."
 )
 
+# Demo-only fixed timezone. A real app would use the user's calendar +
+# locale (e.g. zoneinfo.ZoneInfo(user.timezone) and Google Calendar /
+# Outlook availability); we hardcode Pacific so screenshots are stable.
+_DEMO_TZ = ZoneInfo("America/Los_Angeles")
 
-def _candidate_slots() -> List[dict]:
-    """Generate a small set of upcoming candidate time slots.
 
-    Returned slots are surfaced to the frontend as part of the interrupt
-    payload so the picker UI shows times relative to "now", not stale
-    hardcoded dates baked into the frontend.
-    """
-    # Pacific Time offset (PDT). Showcase only — a real app would use a
-    # proper timezone library and the user's calendar availability.
-    tz = timezone(timedelta(hours=-7))
-    now = datetime.now(tz)
+def _candidate_slots() -> List[dict]:
+    """Upcoming candidate slots, relative to "now" so the picker never
+    shows stale dates."""
+    now = datetime.now(_DEMO_TZ)
     tomorrow = (now + timedelta(days=1)).date()
-    next_monday = (now + timedelta(days=(7 - now.weekday()) % 7 or 7)).date()
-
-    def at(d, hour: int, minute: int = 0) -> datetime:
-        return datetime(d.year, d.month, d.day, hour, minute, tzinfo=tz)
-
+    # Skip a week when the result would collide with `tomorrow` — i.e.
+    # today is Mon (0 days away, picker would show two slots both
+    # labelled "Monday") or Sun (1 day away, picker would show
+    # "Tomorrow" and "Monday" both pointing at the same date).
+    days_to_monday = (7 - now.weekday()) % 7
+    if days_to_monday <= 1:
+        days_to_monday += 7
+    next_monday = (now + timedelta(days=days_to_monday)).date()
     candidates = [
-        ("Tomorrow 10:00 AM", at(tomorrow, 10)),
-        ("Tomorrow 2:00 PM", at(tomorrow, 14)),
-        ("Monday 9:00 AM", at(next_monday, 9)),
-        ("Monday 3:30 PM", at(next_monday, 15, 30)),
+        ("Tomorrow 10:00 AM", tomorrow, time(10, 0)),
+        ("Tomorrow 2:00 PM", tomorrow, time(14, 0)),
+        ("Monday 9:00 AM", next_monday, time(9, 0)),
+        ("Monday 3:30 PM", next_monday, time(15, 30)),
+    ]
+    return [
+        {"label": label, "iso": datetime.combine(d, t, _DEMO_TZ).isoformat()}
+        for label, d, t in candidates
     ]
-    return [{"label": label, "iso": dt.isoformat()} for label, dt in candidates]
 
 
 # @region[backend-interrupt-tool]

showcase/integrations/langgraph-python/src/agents/interrupt_agent.py

@@ -26,6 +26,10 @@
 
 REASONING_MODEL = os.environ.get("OPENAI_REASONING_MODEL", "gpt-5.4")
 
+# No CopilotKitMiddleware — this demo exercises only reasoning-token streaming
+# through the OpenAI Responses API and doesn't consume frontend tools or app
+# context. The other showcase agents that *do* expose CopilotKit features add
+# `middleware=[CopilotKitMiddleware()]` explicitly.
 graph = create_deep_agent(
     model=init_chat_model(
         f"openai:{REASONING_MODEL}",

showcase/integrations/langgraph-python/src/agents/reasoning_agent.py

@@ -113,45 +113,33 @@ class AgentState(BaseAgentState):
 
 
 def _invoke_sub_agent(agent, task: str) -> str:
-    """Run a sub-agent on `task` and return its final prose message.
-
-    Walks the sub-agent's returned messages list newest → oldest and
-    returns the first AIMessage with non-empty string content. This
-    avoids two failure modes:
-
-      1. The final message may be an empty AIMessage that only carries
-         `tool_calls` (no text content) — falling back to `messages[-1]`
-         would surface an empty string.
-      2. If the supervisor's chat history leaks into the sub-agent's
-         result list, we still pick the AI's actual prose answer for
-         this task instead of a stale assistant intro.
-    """
+    """Run a sub-agent on `task` and return its final prose message."""
     result = agent.invoke({"messages": [HumanMessage(content=task)]})
     messages = result.get("messages", [])
+    # Walk newest -> oldest so we pick the answer for THIS task, not a stale
+    # intro. Skip empty AIMessages that only carry tool_calls.
     for msg in reversed(messages):
         if isinstance(msg, AIMessage):
             content = msg.content
             if isinstance(content, str) and content.strip():
                 return content
             # Some providers stream content as a list of content blocks
-            # (e.g. {"type": "text", "text": "..."}). Concatenate any
-            # text blocks we find.
+            # (e.g. {"type": "text", "text": "..."}); concatenate the text.
+            # The `isinstance(block.get("text"), str)` guard rejects
+            # `{"type": "text", "text": null}` payloads — a known provider
+            # quirk — that would otherwise crash `"".join(...)` with
+            # `TypeError: sequence item N: expected str instance, NoneType found`.
             if isinstance(content, list):
-                parts: list[str] = []
-                for block in content:
-                    if isinstance(block, dict) and block.get("type") == "text":
-                        text = block.get("text")
-                        if isinstance(text, str):
-                            parts.append(text)
+                parts = [
+                    block["text"]
+                    for block in content
+                    if isinstance(block, dict)
+                    and block.get("type") == "text"
+                    and isinstance(block.get("text"), str)
+                ]
                 joined = "".join(parts).strip()
                 if joined:
                     return joined
-    # Last-resort fallback: surface an explicit sentinel rather than ""
-    # or a Python repr like "[{'type': 'text', ...}]" leaking from a
-    # block-list `content`. The d5-subagents probe asserts this exact
-    # sentinel against its boilerplate-marker list so an empty/garbled
-    # sub-agent result fails the genuine-pass test instead of silently
-    # rendering an empty card.
     return SUB_AGENT_EMPTY_SENTINEL
 
 

showcase/integrations/langgraph-python/src/agents/subagents.py

@@ -64,6 +64,10 @@ def roll_dice(sides: int = 6) -> dict:
 
 REASONING_MODEL = os.environ.get("OPENAI_REASONING_MODEL", "gpt-5.4")
 
+# No CopilotKitMiddleware — this demo combines reasoning-token streaming with
+# backend tool rendering, but doesn't consume any frontend tools or app context.
+# The frontend renders the tool calls via `useRenderTool`, which works off the
+# AG-UI tool-call event stream and doesn't require server-side middleware.
 graph = create_deep_agent(
     model=init_chat_model(
         f"openai:{REASONING_MODEL}",

showcase/integrations/langgraph-python/src/agents/tool_rendering_reasoning_chain_agent.py

@@ -0,0 +1,55 @@
+// Shared fallback time-slot generator for the interrupt demos
+// (`gen-ui-interrupt`, `interrupt-headless`). The interrupt backend
+// (`src/agents/interrupt_agent.py`) supplies its own candidate slots
+// inside the interrupt payload — these fallbacks only run if the
+// payload arrives without them. Generating relative to `Date.now()`
+// keeps the fallback from rotting, which previously had hardcoded
+// dates that decayed within a week of being authored.
+
+export interface TimeSlot {
+  label: string;
+  iso: string;
+}
+
+function atLocal(date: Date, hour: number, minute = 0): Date {
+  return new Date(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    hour,
+    minute,
+    0,
+    0,
+  );
+}
+
+function nextMonday(from: Date): Date {
+  // `getDay()` is 0=Sun, 1=Mon, ..., 6=Sat. We want the next Monday
+  // that's at LEAST 2 days away — otherwise "Monday" would collide
+  // with "Tomorrow" on Sunday (offset would be 1) or with itself on
+  // Monday (offset would be 0). Mirrors interrupt_agent.py.
+  const day = from.getDay();
+  let offset = (1 - day + 7) % 7;
+  if (offset <= 1) offset += 7;
+  const next = new Date(from);
+  next.setDate(from.getDate() + offset);
+  return next;
+}
+
+export function generateFallbackSlots(now: Date = new Date()): TimeSlot[] {
+  const tomorrow = new Date(now);
+  tomorrow.setDate(now.getDate() + 1);
+  const monday = nextMonday(now);
+
+  const candidates: Array<[string, Date]> = [
+    ["Tomorrow 10:00 AM", atLocal(tomorrow, 10)],
+    ["Tomorrow 2:00 PM", atLocal(tomorrow, 14)],
+    ["Monday 9:00 AM", atLocal(monday, 9)],
+    ["Monday 3:30 PM", atLocal(monday, 15, 30)],
+  ];
+
+  return candidates.map(([label, date]) => ({
+    label,
+    iso: date.toISOString(),
+  }));
+}

showcase/integrations/langgraph-python/src/app/demos/_shared/interrupt-fallback-slots.ts

@@ -6,7 +6,7 @@ import {
   useInterrupt,
 } from "@copilotkit/react-core/v2";
 import { TimePickerCard, TimeSlot } from "./_components/time-picker-card";
-import { FALLBACK_SLOTS } from "./fallback-slots";
+import { generateFallbackSlots } from "../_shared/interrupt-fallback-slots";
 import { useGenUiInterruptSuggestions } from "./suggestions";
 
 export default function GenUiInterruptDemo() {
@@ -42,7 +42,7 @@ function Chat() {
       const slots =
         payload.slots && payload.slots.length > 0
           ? payload.slots
-          : FALLBACK_SLOTS;
+          : generateFallbackSlots();
       return (
         <TimePickerCard
           topic={payload.topic ?? "a call"}