SDK Reference

1
@classmethod
2
def create(
3
    cls,
4
    adapter: FrameworkAdapter | SimpleAdapter,
5
    agent_id: str,
6
    api_key: str,
7
    ws_url: str = "wss://app.band.ai/api/v1/socket/websocket",
8
    rest_url: str = "https://app.band.ai",
9
    config: AgentConfig | None = None,
10
    session_config: SessionConfig | None = None,
11
    contact_config: ContactEventConfig | None = None,
12
    preprocessor: Preprocessor | None = None,
13
) -> Agent

1
from band import Agent
2
from band.adapters import LangGraphAdapter
3
4
adapter = LangGraphAdapter(llm=ChatOpenAI(model="gpt-4o"), checkpointer=InMemorySaver())
5
6
agent = Agent.create(
7
    adapter=adapter,
8
    agent_id="your-agent-uuid",
9
    api_key="your-api-key",
10
)
11
12
await agent.run()

1
@dataclass
2
class AgentConfig:
3
    auto_subscribe_existing_rooms: bool = True

1
@dataclass
2
class SessionConfig:
3
    enable_context_cache: bool = True
4
    context_cache_ttl_seconds: int = 300
5
    max_context_messages: int = 100
6
    max_message_retries: int = 1
7
    enable_context_hydration: bool = True

1
from band.runtime.types import ContactEventConfig, ContactEventStrategy
2
3
@dataclass
4
class ContactEventConfig:
5
    strategy: ContactEventStrategy = ContactEventStrategy.DISABLED
6
    hub_task_id: str | None = None
7
    on_event: ContactEventCallback | None = None
8
    broadcast_changes: bool = False

1
from band.config import load_agent_config
2
3
agent_id, api_key = load_agent_config("my_agent")

1
from band import AdapterFeatures, Capability, Emit
2
3
adapter = AnthropicAdapter(
4
    model="claude-sonnet-4-6",
5
    features=AdapterFeatures(
6
        emit={Emit.EXECUTION},             # report tool calls into the room
7
        capabilities={Capability.MEMORY},  # enterprise memory tools
8
    ),
9
)

1
from band.adapters import LangGraphAdapter
2
3
adapter = LangGraphAdapter(
4
    llm: BaseChatModel | None = None,
5
    checkpointer: BaseCheckpointSaver | None = None,
6
    graph_factory: Callable[[list], Pregel] | None = None,
7
    graph: Pregel | None = None,
8
    prompt_template: str = "default",
9
    custom_section: str = "",
10
    additional_tools: list | None = None,
11
    features: AdapterFeatures | None = None,
12
    history_converter: LangChainHistoryConverter | None = None,
13
    recursion_limit: int = 50,
14
)

1
from band.adapters import AnthropicAdapter
2
3
adapter = AnthropicAdapter(
4
    model: str = "claude-sonnet-4-5-20250929",
5
    anthropic_api_key: str | None = None,
6
    system_prompt: str | None = None,
7
    custom_section: str | None = None,
8
    max_tokens: int = 4096,
9
    features: AdapterFeatures | None = None,
10
    history_converter: AnthropicHistoryConverter | None = None,
11
    additional_tools: list[CustomToolDef] | None = None,
12
)

1
from band.adapters import PydanticAIAdapter
2
3
adapter = PydanticAIAdapter(
4
    model: str,
5
    system_prompt: str | None = None,
6
    custom_section: str | None = None,
7
    features: AdapterFeatures | None = None,
8
    history_converter: PydanticAIHistoryConverter | None = None,
9
    additional_tools: list[Callable] | None = None,
10
)

1
from band.adapters import ClaudeSDKAdapter
2
3
adapter = ClaudeSDKAdapter(
4
    model: str = "claude-sonnet-4-5-20250929",
5
    custom_section: str | None = None,
6
    max_thinking_tokens: int | None = None,
7
    permission_mode: PermissionMode = "acceptEdits",
8
    features: AdapterFeatures | None = None,
9
    history_converter: ClaudeSDKHistoryConverter | None = None,
10
    additional_tools: list[CustomToolDef] | None = None,
11
    cwd: str | None = None,
12
)

1
from band.adapters import A2AAdapter
2
from band.adapters.a2a import A2AAuth
3
4
adapter = A2AAdapter(
5
    remote_url: str,
6
    auth: A2AAuth | None = None,
7
    streaming: bool = True,
8
)

1
from band.adapters import A2AGatewayAdapter
2
3
adapter = A2AGatewayAdapter(
4
    rest_url: str = "https://app.band.ai",
5
    api_key: str = "",
6
    gateway_url: str = "http://localhost:10000",
7
    port: int = 10000,
8
)

1
from band.adapters import CrewAIAdapter
2
3
adapter = CrewAIAdapter(
4
    model: str = "gpt-4o",
5
    role: str | None = None,
6
    goal: str | None = None,
7
    backstory: str | None = None,
8
    custom_section: str | None = None,
9
    features: AdapterFeatures | None = None,
10
    verbose: bool = False,
11
    max_iter: int = 20,
12
    max_rpm: int | None = None,
13
    allow_delegation: bool = False,
14
    history_converter: CrewAIHistoryConverter | None = None,
15
    additional_tools: list[CustomToolDef] | None = None,
16
    system_prompt: str | None = None,  # Deprecated
17
)

1
from band.adapters import CodexAdapter, CodexAdapterConfig
2
3
adapter = CodexAdapter(
4
    config: CodexAdapterConfig | None = None,
5
    additional_tools: list[CustomToolDef] | None = None,
6
    history_converter: CodexHistoryConverter | None = None,
7
    features: AdapterFeatures | None = None,
8
)

1
from band.adapters import LettaAdapter
2
from band.adapters.letta import LettaAdapterConfig
3
4
adapter = LettaAdapter(
5
    config: LettaAdapterConfig | None = None,
6
    history_converter: LettaHistoryConverter | None = None,
7
    features: AdapterFeatures | None = None,
8
)

1
from band.adapters import ParlantAdapter
2
3
adapter = ParlantAdapter(
4
    server: parlant.sdk.Server,
5
    parlant_agent: parlant.sdk.Agent,
6
    system_prompt: str | None = None,
7
    custom_section: str | None = None,
8
    history_converter: ParlantHistoryConverter | None = None,
9
    additional_tools: list[CustomToolDef] | None = None,
10
)

1
from band.integrations.slack import SlackAdapter, SlackApp
2
3
adapter = SlackAdapter(
4
    inner: SimpleAdapter,
5
    apps: list[SlackApp],
6
    rest_url: str = "https://app.band.ai",
7
    api_key: str = "",
8
    transport: Literal["http", "socket"] = "http",
9
    port: int = 3000,
10
    show_tool_progress: bool = True,
11
    mirror_slack_context: bool = True,
12
    features: AdapterFeatures | None = None,
13
    write_tool_names: frozenset[str] | None = None,
14
)

1
from band.adapters import BandACPServerAdapter
2
3
adapter = BandACPServerAdapter(
4
    rest_url: str = "https://app.band.ai",
5
    api_key: str = "",
6
)

1
from band.adapters import ACPServer, BandACPServerAdapter
2
3
adapter = BandACPServerAdapter(rest_url="https://app.band.ai", api_key="...")
4
server = ACPServer(adapter)

1
from band.adapters import ACPClientAdapter
2
3
adapter = ACPClientAdapter(
4
    command: str | list[str],
5
    env: dict[str, str] | None = None,
6
    cwd: str | None = None,
7
    mcp_servers: list[dict[str, Any]] | None = None,
8
    additional_tools: list[CustomToolDef] | None = None,
9
    api_key: str | None = None,
10
    rest_url: str | None = None,
11
    inject_band_tools: bool = True,
12
    auth_method: str | None = None,
13
)

1
class ContactTools:
2
    async def list_contacts(self, page: int = 1, page_size: int = 50) -> dict[str, Any]
3
    async def add_contact(self, handle: str, message: str | None = None) -> dict[str, Any]
4
    async def remove_contact(self, handle: str | None = None, contact_id: str | None = None) -> dict[str, Any]
5
    async def list_contact_requests(self, page: int = 1, page_size: int = 50, sent_status: str = "pending") -> dict[str, Any]
6
    async def respond_contact_request(self, action: str, handle: str | None = None, request_id: str | None = None) -> dict[str, Any]

1
@dataclass(frozen=True)
2
class PlatformMessage:
3
    id: str
4
    room_id: str
5
    content: str
6
    sender_id: str
7
    sender_type: str  # "User", "Agent", "System"
8
    sender_name: str | None
9
    message_type: str
10
    metadata: Any
11
    created_at: datetime
12
13
    def format_for_llm(self) -> str:
14
        """Format as '[SENDER_NAME]: content'"""

1
@dataclass(frozen=True)
2
class AgentInput:
3
    msg: PlatformMessage
4
    tools: AgentToolsProtocol
5
    history: HistoryProvider
6
    participants_msg: str | None
7
    is_session_bootstrap: bool
8
    room_id: str

1
@dataclass(frozen=True)
2
class HistoryProvider:
3
    raw: list[dict[str, Any]]
4
5
    def convert(self, converter: HistoryConverter[T]) -> T:
6
        """Convert to framework-specific format."""