opencode-a2a 0.3.1__tar.gz → 0.4.0__tar.gz

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/.github/workflows/ci.yml

@@ -8,6 +8,8 @@ on:
 
 permissions:
   contents: read
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
 
 jobs:
   quality-gate:
@@ -25,7 +27,7 @@ jobs:
       - name: Setup uv
         uses: astral-sh/setup-uv@v4
         with:
-          enable-cache: true
+          enable-cache: false
 
       - name: Sync Dependencies
         run: uv sync --all-extras --frozen
@@ -73,7 +75,7 @@ jobs:
       - name: Setup uv
         uses: astral-sh/setup-uv@v4
         with:
-          enable-cache: true
+          enable-cache: false
 
       - name: Sync Dependencies
         run: uv sync --all-extras --frozen

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/.github/workflows/dependency-health.yml

@@ -8,6 +8,8 @@ on:
 
 permissions:
   contents: read
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
 
 jobs:
   dependency-health:
@@ -25,7 +27,7 @@ jobs:
       - name: Setup uv
         uses: astral-sh/setup-uv@v4
         with:
-          enable-cache: true
+          enable-cache: false
 
       - name: Run dependency health checks
         run: bash ./scripts/dependency_health.sh

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/.github/workflows/publish.yml

@@ -9,6 +9,8 @@ on:
 permissions:
   contents: write
   id-token: write
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
 
 jobs:
   publish:
@@ -28,7 +30,7 @@ jobs:
       - name: Setup uv
         uses: astral-sh/setup-uv@v4
         with:
-          enable-cache: true
+          enable-cache: false
 
       - name: Run regression baseline
         run: bash ./scripts/doctor.sh

opencode_a2a-0.4.0/AGENTS.md

@@ -0,0 +1,38 @@
+# AGENTS.md
+
+The following rules apply to coding agent collaboration in this repository. These complement the general [CONTRIBUTING.md](CONTRIBUTING.md) workflow.
+
+## 1. Core Principles
+
+- Move tasks forward under secure and traceable conditions.
+- Adhere to the existing repository structure and engineering conventions.
+
+## 2. Collaboration Workflow
+
+- Follow the Git, Issue, and PR workflow defined in [CONTRIBUTING.md](CONTRIBUTING.md).
+- Use `gh` CLI for all issue/PR operations (reading, writing, and comments). Do not edit through the web UI.
+- Create a new tracking issue for any development task that does not already have one.
+- Link the issue explicitly in PR descriptions (e.g., `Closes #xx`).
+- Keep status updates synchronized to the relevant issue/PR to avoid duplicate manual work.
+
+## 3. Tooling and Text Conventions
+
+- **Language**: Use Simplified Chinese for issues, PRs, and comments. Technical terms may remain in English.
+- **PR Body**: For multi-line bodies, write to a temporary file first and pass it via `gh pr create --body-file`.
+- **References**: Use `#123` for same-repo references; use full URLs for cross-repo links.
+
+## 4. Regression and Validation
+
+- Use the primary validation entrypoint for all changes:
+  ```bash
+  ./scripts/doctor.sh
+  ```
+- If `pre-commit` (via `doctor.sh`) auto-fixes files, review the changes before committing.
+- For documentation-only changes, you may skip tests but must self-check all commands and paths.
+- If environment limits prevent full validation, explicitly report what was skipped and why.
+
+## 5. Security and Configuration
+
+- **Secrets**: Never commit keys, tokens, or `.env` content.
+- **Logs**: Ensure debug output does not leak access tokens.
+- **Documentation**: Synchronize documentation updates for all deployment or auth-related changes.

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-a2a
-Version: 0.3.1
+Version: 0.4.0
 Summary: OpenCode A2A runtime
 Author: liujuanjuan1984@Intelligent-Internet
 License-Expression: Apache-2.0
@@ -46,22 +46,36 @@ deployment boundary.
 
 ## What This Is
 
-- An A2A adapter service for `opencode serve`.
-- Use it when you need a stable A2A endpoint for apps, gateways, or A2A
-  clients.
+- An A2A adapter service built on `opencode serve`, with inbound runtime
+  exposure plus outbound peer calling.
+- It supports both roles in one process: serving as an A2A Server and hosting an
+  embedded A2A Client for `a2a_call`.
+
+## Architecture
 
 ```mermaid
 flowchart TD
-    Client["a2a-client-hub / any A2A client"]
+    External["A2A Clients / a2a-client-hub / Gateways"]
 
-    subgraph ServerSide["Server-side"]
-        Adapter["opencode-a2a\nA2A adapter service"]
-        Runtime["opencode serve\nOpenCode runtime"]
+    subgraph Adapter["opencode-a2a Runtime"]
+        Ingress["Inbound A2A Surface\nREST + JSON-RPC"]
+        OpenCode["OpenCode Runtime"]
+        Outbound["Embedded A2A Client\na2a_call"]
+    end
 
-        Adapter <--> Runtime
+    subgraph Peers["Peer A2A services"]
+        PeerA2A["Peer A2A Agent"]
+        PeerRuntime["Peer OpenCode Runtime"]
+        PeerA2A --> PeerRuntime
     end
 
-    Client <--> Adapter
+    External -->|message/send,\nmessage:stream| Ingress
+    Ingress -->|tool call| OpenCode
+    OpenCode -->|model/tool result events| Ingress
+    Ingress -->|a2a_call| Outbound
+    Outbound -->|message/send,\nmessage:stream| PeerA2A
+    PeerA2A -->|tool result| Outbound
+    PeerRuntime -->|task session\nexecution| PeerA2A
 ```
 
 ## Quick Start
@@ -87,6 +101,11 @@ opencode models
 opencode serve --hostname 127.0.0.1 --port 4096
 ```
 
+Treat the deployed OpenCode user's HOME/XDG config directories as part of the
+runtime state. If a packaged or service-managed deployment appears to ignore
+fresh provider env vars, inspect that user's persisted OpenCode auth/config
+files before assuming the A2A adapter layer is overriding credentials.
+
 Then start `opencode-a2a` against that upstream:
 
 ```bash
@@ -95,7 +114,6 @@ OPENCODE_BASE_URL=http://127.0.0.1:4096 \
 A2A_HOST=127.0.0.1 \
 A2A_PORT=8000 \
 A2A_PUBLIC_URL=http://127.0.0.1:8000 \
-A2A_STREAM_SSE_PING_SECONDS=15 \
 OPENCODE_WORKSPACE_ROOT=/abs/path/to/workspace \
 opencode-a2a serve
 ```
@@ -106,19 +124,41 @@ Verify that the service is up:
 curl http://127.0.0.1:8000/.well-known/agent-card.json
 ```
 
-Default local address: `http://127.0.0.1:8000`
-
-## What You Get
+## Capabilities
 
 - A2A HTTP+JSON endpoints such as `/v1/message:send` and
   `/v1/message:stream`
 - A2A JSON-RPC support on `POST /`
+- Peering capabilities: can act as a client via `opencode-a2a call`
+- Autonomous tool execution: supports `a2a_call` tool for outbound agent-to-agent communication
 - SSE streaming with normalized `text`, `reasoning`, and `tool_call` blocks
-- Explicit REST SSE keepalive configurable through `A2A_STREAM_SSE_PING_SECONDS`
 - Session continuity through `metadata.shared.session.id`
 - Request-scoped model selection through `metadata.shared.model`
 - OpenCode-oriented JSON-RPC extensions for session and model/provider queries
 
+## Peering Node / Outbound Access
+
+`opencode-a2a` supports a "Peering Node" architecture where a single process handles both inbound (Server) and outbound (Client) A2A traffic.
+
+### CLI Client
+Interact with other A2A agents directly from the command line:
+
+```bash
+opencode-a2a call http://other-agent:8000 "How are you?" --token your-outbound-token
+```
+
+### Outbound Agent Calls (Tools)
+The server can autonomously execute `a2a_call(url, message)` tool calls emitted by the OpenCode runtime. Results are fetched via A2A and returned to the model as tool results, enabling multi-agent orchestration.
+
+When the target peer requires bearer auth, configure `A2A_CLIENT_BEARER_TOKEN`
+for server-side outbound calls. CLI calls can continue using `--token` or
+`A2A_CLIENT_BEARER_TOKEN`.
+
+Server-side outbound client settings are fully wired through runtime config:
+`A2A_CLIENT_TIMEOUT_SECONDS`, `A2A_CLIENT_CARD_FETCH_TIMEOUT_SECONDS`,
+`A2A_CLIENT_USE_CLIENT_PREFERENCE`, `A2A_CLIENT_BEARER_TOKEN`, and
+`A2A_CLIENT_SUPPORTED_TRANSPORTS`.
+
 Detailed protocol contracts, examples, and extension docs live in
 [`docs/guide.md`](docs/guide.md).
 
@@ -145,7 +185,11 @@ This repository improves the service boundary around OpenCode, but it does not
 turn OpenCode into a hardened multi-tenant platform.
 
 - `A2A_BEARER_TOKEN` protects the A2A surface.
-- Provider auth and default model configuration remain on the OpenCode side.
+- Provider auth and default model configuration remain on the OpenCode side; deployment-time
+  precedence details and HOME/XDG state impact are documented in
+  [docs/guide.md](docs/guide.md#troubleshooting-provider-auth-state).
+- Use `A2A_CLIENT_BEARER_TOKEN` for server-side outbound peer calls initiated by
+  `a2a_call`.
 - Deployment supervision is intentionally BYO. Use `systemd`, Docker,
   Kubernetes, or another supervisor if you need long-running operation.
 - For mutually untrusted tenants, run separate instance pairs with isolated

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/README.md

@@ -8,22 +8,36 @@ deployment boundary.
 
 ## What This Is
 
-- An A2A adapter service for `opencode serve`.
-- Use it when you need a stable A2A endpoint for apps, gateways, or A2A
-  clients.
+- An A2A adapter service built on `opencode serve`, with inbound runtime
+  exposure plus outbound peer calling.
+- It supports both roles in one process: serving as an A2A Server and hosting an
+  embedded A2A Client for `a2a_call`.
+
+## Architecture
 
 ```mermaid
 flowchart TD
-    Client["a2a-client-hub / any A2A client"]
+    External["A2A Clients / a2a-client-hub / Gateways"]
 
-    subgraph ServerSide["Server-side"]
-        Adapter["opencode-a2a\nA2A adapter service"]
-        Runtime["opencode serve\nOpenCode runtime"]
+    subgraph Adapter["opencode-a2a Runtime"]
+        Ingress["Inbound A2A Surface\nREST + JSON-RPC"]
+        OpenCode["OpenCode Runtime"]
+        Outbound["Embedded A2A Client\na2a_call"]
+    end
 
-        Adapter <--> Runtime
+    subgraph Peers["Peer A2A services"]
+        PeerA2A["Peer A2A Agent"]
+        PeerRuntime["Peer OpenCode Runtime"]
+        PeerA2A --> PeerRuntime
     end
 
-    Client <--> Adapter
+    External -->|message/send,\nmessage:stream| Ingress
+    Ingress -->|tool call| OpenCode
+    OpenCode -->|model/tool result events| Ingress
+    Ingress -->|a2a_call| Outbound
+    Outbound -->|message/send,\nmessage:stream| PeerA2A
+    PeerA2A -->|tool result| Outbound
+    PeerRuntime -->|task session\nexecution| PeerA2A
 ```
 
 ## Quick Start
@@ -49,6 +63,11 @@ opencode models
 opencode serve --hostname 127.0.0.1 --port 4096
 ```
 
+Treat the deployed OpenCode user's HOME/XDG config directories as part of the
+runtime state. If a packaged or service-managed deployment appears to ignore
+fresh provider env vars, inspect that user's persisted OpenCode auth/config
+files before assuming the A2A adapter layer is overriding credentials.
+
 Then start `opencode-a2a` against that upstream:
 
 ```bash
@@ -57,7 +76,6 @@ OPENCODE_BASE_URL=http://127.0.0.1:4096 \
 A2A_HOST=127.0.0.1 \
 A2A_PORT=8000 \
 A2A_PUBLIC_URL=http://127.0.0.1:8000 \
-A2A_STREAM_SSE_PING_SECONDS=15 \
 OPENCODE_WORKSPACE_ROOT=/abs/path/to/workspace \
 opencode-a2a serve
 ```
@@ -68,19 +86,41 @@ Verify that the service is up:
 curl http://127.0.0.1:8000/.well-known/agent-card.json
 ```
 
-Default local address: `http://127.0.0.1:8000`
-
-## What You Get
+## Capabilities
 
 - A2A HTTP+JSON endpoints such as `/v1/message:send` and
   `/v1/message:stream`
 - A2A JSON-RPC support on `POST /`
+- Peering capabilities: can act as a client via `opencode-a2a call`
+- Autonomous tool execution: supports `a2a_call` tool for outbound agent-to-agent communication
 - SSE streaming with normalized `text`, `reasoning`, and `tool_call` blocks
-- Explicit REST SSE keepalive configurable through `A2A_STREAM_SSE_PING_SECONDS`
 - Session continuity through `metadata.shared.session.id`
 - Request-scoped model selection through `metadata.shared.model`
 - OpenCode-oriented JSON-RPC extensions for session and model/provider queries
 
+## Peering Node / Outbound Access
+
+`opencode-a2a` supports a "Peering Node" architecture where a single process handles both inbound (Server) and outbound (Client) A2A traffic.
+
+### CLI Client
+Interact with other A2A agents directly from the command line:
+
+```bash
+opencode-a2a call http://other-agent:8000 "How are you?" --token your-outbound-token
+```
+
+### Outbound Agent Calls (Tools)
+The server can autonomously execute `a2a_call(url, message)` tool calls emitted by the OpenCode runtime. Results are fetched via A2A and returned to the model as tool results, enabling multi-agent orchestration.
+
+When the target peer requires bearer auth, configure `A2A_CLIENT_BEARER_TOKEN`
+for server-side outbound calls. CLI calls can continue using `--token` or
+`A2A_CLIENT_BEARER_TOKEN`.
+
+Server-side outbound client settings are fully wired through runtime config:
+`A2A_CLIENT_TIMEOUT_SECONDS`, `A2A_CLIENT_CARD_FETCH_TIMEOUT_SECONDS`,
+`A2A_CLIENT_USE_CLIENT_PREFERENCE`, `A2A_CLIENT_BEARER_TOKEN`, and
+`A2A_CLIENT_SUPPORTED_TRANSPORTS`.
+
 Detailed protocol contracts, examples, and extension docs live in
 [`docs/guide.md`](docs/guide.md).
 
@@ -107,7 +147,11 @@ This repository improves the service boundary around OpenCode, but it does not
 turn OpenCode into a hardened multi-tenant platform.
 
 - `A2A_BEARER_TOKEN` protects the A2A surface.
-- Provider auth and default model configuration remain on the OpenCode side.
+- Provider auth and default model configuration remain on the OpenCode side; deployment-time
+  precedence details and HOME/XDG state impact are documented in
+  [docs/guide.md](docs/guide.md#troubleshooting-provider-auth-state).
+- Use `A2A_CLIENT_BEARER_TOKEN` for server-side outbound peer calls initiated by
+  `a2a_call`.
 - Deployment supervision is intentionally BYO. Use `systemd`, Docker,
   Kubernetes, or another supervisor if you need long-running operation.
 - For mutually untrusted tenants, run separate instance pairs with isolated

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/docs/guide.md

@@ -69,7 +69,47 @@ Key variables to understand protocol behavior:
   `session.abort` in cancel flow.
 - `OPENCODE_TIMEOUT` / `OPENCODE_TIMEOUT_STREAM`: upstream request timeout and
   optional stream timeout override.
+- `A2A_CLIENT_TIMEOUT_SECONDS`: outbound client timeout. Default: `30` seconds.
+- `A2A_CLIENT_CARD_FETCH_TIMEOUT_SECONDS`: outbound Agent Card fetch timeout.
+  Default: `5` seconds.
+- `A2A_CLIENT_USE_CLIENT_PREFERENCE`: whether the outbound client prefers its own transport choices.
+- `A2A_CLIENT_BEARER_TOKEN`: optional bearer token attached to outbound peer
+  calls made by the embedded A2A client and `a2a_call` tool path.
+- `A2A_CLIENT_SUPPORTED_TRANSPORTS`: ordered outbound transport preference list.
 - Runtime authentication is bearer-token only via `A2A_BEARER_TOKEN`.
+- The same outbound client flags are also honored by the server-side embedded
+  A2A client used for peer calls and `a2a_call` tool execution:
+  - `A2A_CLIENT_TIMEOUT_SECONDS`
+  - `A2A_CLIENT_CARD_FETCH_TIMEOUT_SECONDS`
+  - `A2A_CLIENT_USE_CLIENT_PREFERENCE`
+  - `A2A_CLIENT_BEARER_TOKEN`
+  - `A2A_CLIENT_SUPPORTED_TRANSPORTS`
+
+## Client Initialization Facade (Preview)
+
+`opencode-a2a` now includes a minimal client bootstrap module in
+`src/opencode_a2a/client/` to support downstream consumer usage while keeping
+server and client concerns separate.
+
+Boundary separation:
+
+- Server code owns runtime request handling, transport orchestration, stream
+  behavior, and public compatibility profile exposure.
+- Client code owns peer card discovery, SDK client construction, operation call
+  helpers, and protocol error normalization.
+
+Current client facade API:
+
+- `A2AClient.get_agent_card()`
+- `A2AClient.send()` / `A2AClient.send_message()`
+- `A2AClient.get_task()`
+- `A2AClient.cancel_task()`
+- `A2AClient.resubscribe_task()`
+
+Server-side outbound peer calls use bearer auth only for now. Configure
+`A2A_CLIENT_BEARER_TOKEN` when the remote agent protects its runtime surface.
+CLI outbound calls may pass `--token` explicitly or use
+`A2A_CLIENT_BEARER_TOKEN`.
 
 Execution-boundary metadata is intentionally declarative deployment metadata:
 it is published through `RuntimeProfile`, Agent Card, OpenAPI, and `/health`,
@@ -99,6 +139,12 @@ starting that upstream process:
 If your provider uses environment variables for auth, export them before
 starting `opencode serve`.
 
+Do not assume startup-script env vars always erase previously persisted
+OpenCode auth state for the deployed user. When debugging provider-auth
+surprises, inspect the deployed user's HOME/XDG config directories and the
+OpenCode files stored there before concluding that `opencode-a2a` changed the
+credential selection.
+
 Then start `opencode-a2a` against that explicit upstream URL:
 
 ```bash
@@ -111,6 +157,23 @@ OPENCODE_WORKSPACE_ROOT=/abs/path/to/workspace \
 opencode-a2a serve
 ```
 
+## Troubleshooting Provider Auth State
+
+If one deployment works while another fails against the same upstream provider,
+check the deployed OpenCode user's local state before assuming the difference
+comes from the `opencode-a2a` package itself.
+
+- Provider auth and service-level model defaults belong to `opencode serve`.
+- The deployed user's HOME/XDG config directories are operational input.
+- Existing OpenCode auth/config files may still influence runtime behavior even
+  when you also inject provider env vars from a process manager or shell
+  wrapper.
+- Compare the deployed user's OpenCode auth/config files, HOME/XDG values, and
+  effective workspace directory before blaming the A2A adapter layer.
+- For OpenCode-specific auth/config troubleshooting, inspect files such as
+  `~/.local/share/opencode/auth.json` and `~/.config/opencode/opencode.json`
+  (or the equivalent XDG-resolved paths for that service user).
+
 ## Core Behavior
 
 - The service forwards A2A `message:send` to OpenCode session/message calls.
@@ -125,9 +188,7 @@ opencode-a2a serve
     URI.
   - `DataPart` is currently rejected explicitly; it is not silently downgraded.
 - Task state defaults to `completed` for successful turns.
-- The deployment profile is single-tenant and shared-workspace: one server
-  instance exposes one OpenCode workspace/environment to all consumers bound to
-  that instance.
+- The deployment profile is single-tenant and shared-workspace. For detailed isolation principles and security boundaries, see [SECURITY.md](../SECURITY.md).
 
 ## Streaming Contract
 

{opencode_a2a-0.3.1 → opencode_a2a-0.4.0}/scripts/README.md

@@ -12,7 +12,7 @@ remaining repository-maintenance helpers.
 
 ## Other Scripts
 
-- [`doctor.sh`](./doctor.sh): local development regression entrypoint (`sync`/`pip check` + lint + tests + coverage policy)
+- [`doctor.sh`](./doctor.sh): primary local development regression entrypoint (uv sync + lint + tests + coverage)
 - [`dependency_health.sh`](./dependency_health.sh): dependency review entrypoint (`sync`/`pip check` + outdated + audit)
 - [`check_coverage.py`](./check_coverage.py): enforces the overall coverage floor and per-file minimums for critical modules
 - [`lint.sh`](./lint.sh): lint helper

opencode_a2a-0.4.0/src/opencode_a2a/cli.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from collections.abc import Sequence
+
+from . import __version__
+from .server.application import main as serve_main
+
+
+async def run_call(agent_url: str, text: str, token: str | None = None) -> int:
+    from a2a.types import Message, TaskArtifactUpdateEvent, TaskStatusUpdateEvent
+
+    from .client import A2AClient
+
+    client = A2AClient(agent_url)
+    metadata = {}
+    if token:
+        # Use Authorization header for bearer auth.
+        metadata["authorization"] = f"Bearer {token}"
+
+    try:
+        async for event in client.send_message(text, metadata=metadata):
+            if isinstance(event, tuple):
+                _, update = event
+                if isinstance(update, TaskArtifactUpdateEvent):
+                    artifact = update.artifact
+                    if artifact and artifact.parts:
+                        for part in artifact.parts:
+                            text_val = getattr(part.root, "text", None)
+                            if isinstance(text_val, str):
+                                print(text_val, end="", flush=True)
+                elif isinstance(update, TaskStatusUpdateEvent):
+                    if update.status and update.status.state == "failed":
+                        print(f"\n[Failed] {update.status.message or ''}")
+            elif isinstance(event, Message):
+                for part in event.parts:
+                    text_val = getattr(part.root, "text", None)
+                    if isinstance(text_val, str):
+                        print(text_val, end="", flush=True)
+        print()  # New line after completion
+    except Exception as exc:
+        print(f"\n[Error] {exc}", file=sys.stderr)
+        return 1
+    finally:
+        await client.close()
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="opencode-a2a",
+        description=(
+            "OpenCode A2A runtime. Deployment supervision is intentionally left to the operator."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser(
+        "serve",
+        help="Start the OpenCode A2A runtime using environment-based settings.",
+        description="Start the OpenCode A2A runtime using environment-based settings.",
+    )
+
+    call_parser = subparsers.add_parser(
+        "call",
+        help="Call an A2A agent.",
+        description="Call an A2A agent using the A2A protocol.",
+    )
+    call_parser.add_argument("agent_url", help="URL of the agent to call.")
+    call_parser.add_argument("text", help="Text message to send.")
+    call_parser.add_argument(
+        "--token",
+        help="Bearer token for authentication (can also use A2A_CLIENT_BEARER_TOKEN env).",
+        default=os.environ.get("A2A_CLIENT_BEARER_TOKEN"),
+    )
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    parser = build_parser()
+
+    if not args:
+        serve_main()
+        return 0
+
+    namespace = parser.parse_args(args)
+    if namespace.command == "serve":
+        serve_main()
+        return 0
+
+    if namespace.command == "call":
+        return asyncio.run(run_call(namespace.agent_url, namespace.text, namespace.token))
+
+    if namespace.command is None:
+        serve_main()
+        return 0
+
+    parser.error(f"Unknown command: {namespace.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

opencode_a2a-0.4.0/src/opencode_a2a/client/__init__.py

@@ -0,0 +1,28 @@
+"""Reusable A2A client utilities and facade types."""
+
+from .client import A2AClient
+from .config import A2AClientSettings, load_settings
+from .errors import (
+    A2AAgentUnavailableError,
+    A2AClientError,
+    A2AClientResetRequiredError,
+    A2APeerProtocolError,
+    A2AUnsupportedBindingError,
+    A2AUnsupportedOperationError,
+)
+from .types import A2AClientEvent, A2AClientEventStream, A2AClientMetadata
+
+__all__ = [
+    "A2AClient",
+    "A2AClientError",
+    "A2AAgentUnavailableError",
+    "A2AClientResetRequiredError",
+    "A2APeerProtocolError",
+    "A2AUnsupportedBindingError",
+    "A2AUnsupportedOperationError",
+    "A2AClientSettings",
+    "A2AClientEvent",
+    "A2AClientEventStream",
+    "A2AClientMetadata",
+    "load_settings",
+]