SDKs

• Python SDK:
  • Coding-Agent Approval Hangs — Codex, OpenCode, and Claude SDK coding-agent adapters no longer hang or misroute replies when an approval request is redelivered, superseded, evicted, or resolved late.
  • OMP ACP First-Turn Hang — Fixed the OMP (Oh My Pi) ACP adapter going silent on its first turn when given a per-room workspace.
  • OMP ACP Tool Approvals — Fixed OMP ACP silently denying every tool-call approval by default.

• Python SDK:
  • Cursor ACP Adapter — Connect a Cursor agent (agent acp) to Band chat rooms over the Agent Client Protocol.
  • OMP ACP Adapter — Connect an Oh My Pi (omp) coding agent to Band chat rooms over ACP, with fail-closed tool-call approvals.
  • Dynamic ACP Model/Reasoning Selection — ACP adapters, including Copilot, can now list and switch a provider’s advertised model and reasoning-effort options mid-session.
  • Claude Agent SDK Response Effort — ClaudeSDKAdapter can set the response effort level forwarded to the Claude Agent SDK.
  • Per-Room Coding-Agent Isolation — Codex and ACP coding-agent adapters now run each chat room in its own workspace and subprocess, so concurrent rooms on one host never share process state.
  • Reasoning-Cycle Watchdog — An opt-in cycle timeout lets an agent fail and retry a reasoning cycle that hangs, instead of leaving a message stuck “processing” forever.

• Python SDK:
  • Structured Adapter Failures — Adapter errors now report a structured provider/code/message shape instead of a free-text error event, giving agents and operators consistent detail across every framework adapter.

• Python SDK:
  • Chat Metadata Normalization — Fixed an error and silently dropped usage records caused by chat message metadata switching from a plain dict to a typed model.
  • OpenCode Turn Reliability — Hardened OpenCode’s turn/approval lifecycle so abandoned approvals and MCP reconnects no longer corrupt a room’s delivery state.
  • Peer Lookup Tool Description — Widened the peer-lookup tool’s description so agents reliably use it to answer “who else is available” questions, not only delegation.

• Python SDK:
  • Agent-Scoped Memory — Memories can now be scoped to just the storing agent (scope="agent") instead of only a shared organization, fixing 422 errors when storing or listing memories for any agent whose owner has no organization.
  • File Transfer Tools — Agents can list, read, and send room files through three new platform tools, gated behind a Capability.FILES negotiation with the platform (on-prem deployments with the file-transfer flag enabled; not yet available on Band SaaS).

AgentTools’s tool-schema methods and the MCP engine’s registration builders replace their separate include_memory/include_contacts booleans with one capabilities set.

• Python SDK:
  • Contact Event Text — Contact request and contact-added events with a missing sender name or handle now show a readable fallback (“Unknown sender”, “Unknown contact”, “no handle”) in the room instead of the literal text “None”.

• Python SDK:
  • Claude Desktop Agent — Run Claude Desktop as a Band agent: band-mcp --scope agent handles platform operations, and band-room-view keeps one room’s transcript open and synced while Desktop is running.
  • Env-Driven Logging & OpenTelemetry — Configure the SDK’s logging entirely from environment variables, with output ready to plug into an OpenTelemetry collector.

• Band MCP:
  • Breaking: BAND_API_KEY No Longer Accepted — band-mcp no longer accepts a single unscoped BAND_API_KEY. Set BAND_USER_KEY (human scope) and/or BAND_AGENT_KEY (agent scope) explicitly — there is no unscoped credential or prefix-inference fallback any more. Legacy thnv_-prefixed keys are also no longer accepted; rotate to a band_u_/band_a_ key before upgrading. This only affects band-mcp’s own credential resolution — the band-sdk library’s BAND_API_KEY (agent runtime configuration) is unaffected.

• Python SDK:
  • ACP Tool Event Format — ACP tool calls and results are now recorded in the SDK’s structured event format instead of plain text, so anything reading event history sees typed data instead of prose.
  • Codex Reasoning/Plan Placeholders — Codex agents no longer post the literal text (reasoning) or (plan) to a room when a reasoning or plan step has no summary.
  • Claude SDK Silent Failures — A Claude SDK turn that fails (for example, an expired login) or finishes without a reply now posts a room error instead of completing silently.
  • Strands + OpenAI Rehydration — Fixed a 400 error when a Strands agent on an OpenAI-compatible model rehydrates history containing a tool call immediately followed by plain text.
  • Copilot CLI (ACP) Reliability — The Copilot CLI (ACP) adapter now sees room participant and contact updates, uses consistent tool names in narration, supports the memory capability, and no longer races itself when two rooms start at once.
  • Parlant Tool Descriptions — Parlant tool descriptions are now sourced the same way as every other adapter’s, fixing stale wording that no longer matched the platform’s tool names.
  • CrewAI and Pydantic AI Tool Descriptions — Tool descriptions for the CrewAI and Pydantic AI adapters now match every other adapter’s; CrewAI’s band_send_event requires an explicit message_type instead of silently defaulting to "thought", and band_lookup_peers’s page/page_size reject values below 1 again.
  • Participant Descriptions in the Roster — An agent’s automatically-injected room roster now includes each participant’s description, so agents can route by role without an extra tool call.
  • OneShotInvoker History & Roster — The one-shot invocation path now reads a room’s full history instead of stopping after the first page, and sends the participant roster on every call.
  • agent-client-protocol Compatibility — Fixed an import failure when agent-client-protocol resolves to 0.11.0 or newer.
  • Parlant + Pydantic AI Install Conflict — Installing the parlant extra together with pydantic-ai (or parlant alone, in some cases) no longer corrupts a shared import path; they now install into separate environments.
  • LocalMCPServer Docker Callback Binding — Fixed a DNS-rebinding-protection bug that rejected host.docker.internal callers with a 421 even when the embedded MCP server was explicitly bound to 0.0.0.0 for that documented Docker callback case.

• TypeScript SDK:
  • LangGraph Adapter Reliability — Fixes agents built on createReactAgent going silent or losing conversation context across turns.
  • Participant Handle Formatting — Fixes a duplicate @ prefix that could appear when formatting participant handles.

feature improvement breaking-change python

Added

Python SDK

• Platform Connection Injection. Bridge adapters (A2AGatewayAdapter, SlackAdapter, BandACPServerAdapter) no longer take api_key/rest_url constructor parameters; the runtime injects the credentials already given to Agent.create().
• Parlant Server Lifecycle. ParlantAdapter can now own the Parlant server end to end: it boots p.Server when the Band agent starts and tears it down when it stops. Declare guidelines up front with adapter.add_guideline(...); the Band platform tools attach by default. A configure= callback and bring-your-own server=/parlant_agent= remain available for advanced use.
• Codex/Letta/OpenCode Config from Environment. CodexAdapterConfig, LettaAdapterConfig, and OpencodeAdapterConfig fields fall back to prefixed environment variables (CODEX_*, LETTA_*, OPENCODE_*) when left unset; an explicit constructor argument always wins.

• Python SDK:
  • Strands Agents Adapter — Connect an AWS Strands Agents-based agent to Band chat rooms: platform tools, custom tools, per-room context rehydration, and memory/contact capabilities all work out of the box.
  • Docker Three-Agent Demo — New example showing a three-agent design-meeting workflow (architect/dev/PM) running in Docker.
  • band-python-kit on Docker Hub — The Docker Sandbox kit image is now also published to Docker Hub, alongside its existing GHCR image.

• Python SDK:
  • OpenCode Adapter Reaches Full Conformance — The OpenCode adapter now meets the platform’s L0–L4 bar (participation, context fidelity, restart survival), with accompanying headless-mode reliability fixes.

• Python SDK:
  • ACP Copilot Docker Compose Example — The Compose deployment for the ACP/Copilot Docker example no longer fails to start (it referenced a removed console-script name).
  • Parlant Adapter Port Collisions — Running two Parlant-based agents on the same machine no longer fails with a port-binding crash; each server now binds an ephemeral port by default.

• Python SDK:
  • Interrupt, Stop, and Resume Controls — Agents now honor interrupt, stop, and play signals from the platform out-of-band, so a signal can abort a reasoning cycle already in flight. interrupt cancels the turn in progress without re-delivering the message; stop also holds new turns in that room until play, which resumes and catches up on anything that arrived meanwhile. Bridged and one-shot agents honor the same signals.
  • Typed REST Response Models — Contact, memory, and peer models (AgentContact, AgentMemory, Peer, and their List…Response envelopes) are now importable from band.client.rest, so code consuming the REST client can be fully type-annotated.

• Python SDK:
  • Pydantic AI 2.x — The pydantic-ai extra now requires pydantic-ai-slim 2.18 or newer (previously 1.56+). Retry exhaustion, token-usage reporting, history filtering, and custom tools behave as before.
  • Dependency Floors — The langgraph, parlant, and pydantic-ai extras now require openai 2.0 or newer, and the crewai extra pins CrewAI 1.15.5.
  • History Ends at the Triggering Message — For every adapter, the history assembled when an agent starts now stops immediately before the message that triggered the turn. Messages that arrived while the agent was offline are handled as their own turns instead of being replayed as context, so they are no longer answered twice or surfaced early.
  • Memory Listing in the Test Fake — FakeAgentTools.list_memories now returns the same data/meta response the real SDK returns, instead of a memories/metadata dict, so tests exercise the shape production code actually sees.

• Python SDK:
  • ACP Context Recovery — When a remote ACP agent’s session cannot be restored — a container restart, a crash, or a freshly spawned process — the agent is now seeded with the Band room’s transcript instead of starting with no context.
  • Duplicate First Reply Through the A2A Gateway — A peer added to a brand-new room now processes the first inbound message exactly once. Previously it could reply to a single question several times over.
  • Docker Sandbox Kit Quickstart — Fresh kit workspaces on the default proxy-managed credential tier now connect. The bundled echo-agent starter pinned an SDK version predating the WebSocket x-api-key handshake, so every new workspace failed to connect.

• Projects installing the pydantic-ai extra should review their own Pydantic AI usage against the 2.x release notes before upgrading.
• Tests asserting on FakeAgentTools.list_memories output should read data/meta instead of memories/metadata.

• Python SDK:
  • Proxy-Managed Credential Custody for the Docker Sandbox Kit — Agents can now run inside a Docker Sandbox without the real Band or LLM keys ever entering the sandbox VM: the VM carries only the proxy-managed sentinel while a trusted host-side proxy supplies the real credential on the outbound request. Two custody tiers are documented — credential injection (preferred) and a workspace env-file fallback that warns at launch — and the bundled echo-agent workspace now defaults to proxy-managed. Passing a real Band API key while in proxy-managed mode is rejected rather than quietly accepted.