starpc 0.52.0 → 0.52.1

package/integration/cross-language/python-client.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+# The checkout supplies generated message packages outside the installed wheel.
+import asyncio
+import sys
+from collections.abc import AsyncIterator
+from pathlib import Path
+
+from google.protobuf import empty_pb2
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from echo import echo_pb2
+from echo.echo_srpc import EchoerClient
+from starpc.call import CallCancelledError, RemoteCallError
+from starpc.client import Client
+from starpc.stream import open_tcp_stream
+
+
+async def main() -> None:
+    args = sys.argv[1:]
+    nested = args[:1] in (["--nested"], ["--nested-release"])
+    strict_nested = args[:1] == ["--nested-release"]
+    if nested:
+        args = args[1:]
+    if len(args) != 1 or ":" not in args[0]:
+        raise ValueError("usage: python-client.py [--nested] host:port")
+    host, port_text = args[0].rsplit(":", 1)
+    port = int(port_text)
+    raw_client = Client(lambda: open_tcp_stream(host, port))
+    client = EchoerClient(raw_client)
+    body = "hello world via python"
+    response = await client.echo(echo_pb2.EchoMsg(body=body))
+    if response.body != body:
+        raise RuntimeError(f"unexpected unary response: {response.body!r}")
+    empty_response = await client.echo(echo_pb2.EchoMsg())
+    if empty_response.body:
+        raise RuntimeError(f"unexpected empty unary response: {empty_response.body!r}")
+    received = [
+        message
+        async for message in client.echo_server_stream(echo_pb2.EchoMsg(body=body))
+    ]
+    if len(received) != 5 or any(message.body != body for message in received):
+        raise RuntimeError("unexpected server-stream response")
+    client_stream = await client.echo_client_stream(_one_request(body))
+    if client_stream.body != body:
+        raise RuntimeError("unexpected client-stream response")
+    bidi = client.echo_bidi_stream(_one_request(body))
+    initial = await bidi.__anext__()
+    if initial.body != "hello from server":
+        raise RuntimeError("unexpected bidi initial response")
+    echoed = await bidi.__anext__()
+    if echoed.body != body:
+        raise RuntimeError("unexpected bidi echo")
+    try:
+        await bidi.__anext__()
+    except StopAsyncIteration:
+        pass
+    else:
+        raise RuntimeError("bidi stream did not terminate")
+    empty = await client.do_nothing(empty_pb2.Empty())
+    if empty.ByteSize() != 0:
+        raise RuntimeError("unexpected DoNothing response")
+
+    unknown = await raw_client.open_call("missing.Service", "Missing")
+    try:
+        await unknown.finish()
+        try:
+            await unknown.receive()
+        except RemoteCallError:
+            pass
+        else:
+            raise RuntimeError("unknown method did not return a remote error")
+    finally:
+        await unknown.aclose()
+
+    cancelled = await raw_client.open_call("echo.Echoer", "EchoBidiStream")
+    await cancelled.cancel()
+    try:
+        await cancelled.wait_closed()
+    except CallCancelledError:
+        pass
+    await cancelled.aclose()
+    if nested:
+        await run_nested_test(client, strict_nested)
+    print("All tests passed.")
+
+
+async def run_nested_test(client: EchoerClient, strict: bool = False) -> None:
+    from starpc.rpcstream import (
+        RpcStreamRemoteError,
+        build_rpc_stream_open_stream,
+    )
+
+    nested_client = Client(build_rpc_stream_open_stream("test", client.rpc_stream))
+    nested_echo = EchoerClient(nested_client)
+    body = "hello world via nested python"
+    response = await nested_echo.echo(echo_pb2.EchoMsg(body=body))
+    if response.body != body:
+        raise RuntimeError(f"unexpected nested unary response: {response.body!r}")
+
+    if strict:
+        try:
+            await nested_echo.echo(echo_pb2.EchoMsg(body="__nested_error__"))
+        except RemoteCallError:
+            pass
+        else:
+            raise RuntimeError("terminal nested error unexpectedly succeeded")
+
+    if strict:
+        missing = Client(build_rpc_stream_open_stream("missing", client.rpc_stream))
+        try:
+            await missing.open_call("echo.Echoer", "Echo")
+        except RpcStreamRemoteError:
+            pass
+        else:
+            raise RuntimeError("unknown component unexpectedly succeeded")
+
+    terminal = await nested_client.open_call("missing.Service", "Missing")
+    try:
+        await terminal.receive()
+    except RemoteCallError:
+        pass
+    else:
+        raise RuntimeError("unknown nested method unexpectedly succeeded")
+    finally:
+        await terminal.aclose()
+
+    cancelled = await nested_client.open_call("echo.Echoer", "EchoBidiStream")
+    await cancelled.send(
+        echo_pb2.EchoMsg(body="nested later data").SerializeToString(deterministic=True)
+    )
+    await cancelled.cancel()
+    try:
+        await cancelled.wait_closed()
+    except CallCancelledError:
+        pass
+    await cancelled.aclose()
+
+
+async def _one_request(body: str) -> AsyncIterator[echo_pb2.EchoMsg]:
+    yield echo_pb2.EchoMsg(body=body)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/integration/cross-language/python-server.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+# The checkout supplies generated message packages outside the installed wheel.
+import asyncio
+import signal
+import sys
+from collections.abc import AsyncIterator
+from pathlib import Path
+
+from google.protobuf import empty_pb2
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from echo import echo_pb2
+from echo.echo_srpc import register_echoer
+from rpcstream import rpcstream_pb2
+from starpc.rpcstream import ComponentRegistry, handle_rpc_stream
+from starpc.server import Server, ServiceRegistry
+from starpc.stream import TCPStreamServer
+
+
+class Implementation:
+    def __init__(self, components: ComponentRegistry) -> None:
+        self._components = components
+        self._release_task: asyncio.Task[None] | None = None
+        self._release_complete = asyncio.Event()
+
+    async def _release_component(self) -> None:
+        try:
+            await self._components.unregister("release")
+        finally:
+            self._release_complete.set()
+
+    async def wait_for_release(self) -> None:
+        task = self._release_task
+        if task is not None:
+            await task
+
+    async def echo(self, request: echo_pb2.EchoMsg) -> echo_pb2.EchoMsg:
+        if request.body == "__nested_error__":
+            raise RuntimeError("nested terminal error")
+        if request.body == "__nested_release__":
+            if self._release_task is None:
+                self._release_task = asyncio.create_task(self._release_component())
+            await asyncio.Future()
+        if request.body == "__nested_release_status__":
+            await self._release_complete.wait()
+            await self.wait_for_release()
+            return echo_pb2.EchoMsg(body="released")
+        return echo_pb2.EchoMsg(body=request.body)
+
+    async def echo_server_stream(
+        self, request: echo_pb2.EchoMsg
+    ) -> AsyncIterator[echo_pb2.EchoMsg]:
+        for _ in range(5):
+            yield echo_pb2.EchoMsg(body=request.body)
+            await asyncio.sleep(0.2)
+
+    async def echo_client_stream(
+        self, requests: AsyncIterator[echo_pb2.EchoMsg]
+    ) -> echo_pb2.EchoMsg:
+        async for request in requests:
+            return request
+        return echo_pb2.EchoMsg()
+
+    async def echo_bidi_stream(
+        self, requests: AsyncIterator[echo_pb2.EchoMsg]
+    ) -> AsyncIterator[echo_pb2.EchoMsg]:
+        yield echo_pb2.EchoMsg(body="hello from server")
+        async for request in requests:
+            yield request
+
+    def rpc_stream(
+        self, requests: AsyncIterator[rpcstream_pb2.RpcStreamPacket]
+    ) -> AsyncIterator[rpcstream_pb2.RpcStreamPacket]:
+        return handle_rpc_stream(requests, self._components)
+
+    async def do_nothing(self, request: empty_pb2.Empty) -> empty_pb2.Empty:
+        return request
+
+
+async def main() -> None:
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 0
+    registry = ServiceRegistry()
+    components = ComponentRegistry()
+    await components.register("test", Server(registry))
+    await components.register("release", Server(registry))
+    implementation = Implementation(components)
+    register_echoer(registry, implementation)
+    server = TCPStreamServer()
+    await server.start("127.0.0.1", port)
+    host, bound_port = server.address
+    print(f"LISTENING {host}:{bound_port}", flush=True)
+    rpc_server = Server(registry)
+    tasks: set[asyncio.Task[None]] = set()
+    errors: list[BaseException] = []
+    stopping = asyncio.Event()
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, stopping.set)
+
+    def observe_task(task: asyncio.Task[None]) -> None:
+        tasks.discard(task)
+        if not task.cancelled() and (error := task.exception()) is not None:
+            errors.append(error)
+
+    try:
+        while not stopping.is_set():
+            accepting = asyncio.create_task(server.accept())
+            stopped = asyncio.create_task(stopping.wait())
+            done, _ = await asyncio.wait(
+                {accepting, stopped}, return_when=asyncio.FIRST_COMPLETED
+            )
+            if stopped in done:
+                accepting.cancel()
+                await asyncio.gather(accepting, return_exceptions=True)
+                break
+            stopped.cancel()
+            await asyncio.gather(stopped, return_exceptions=True)
+            stream = accepting.result()
+            task = asyncio.create_task(rpc_server.serve(stream))
+            tasks.add(task)
+            task.add_done_callback(observe_task)
+    finally:
+        await server.aclose()
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        await implementation.wait_for_release()
+        await components.unregister("test")
+        await components.unregister("release")
+        if errors:
+            raise ExceptionGroup("cross-language server tasks failed", errors)
+        if components._components or components._retired:
+            raise RuntimeError("nested component cleanup is incomplete")
+        print("NESTED_CLEAN", flush=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/integration/cross-language/run.bash

@@ -1,11 +1,13 @@
 #!/bin/bash
 # Cross-language integration tests for starpc.
-# Runs all 12 server/client combinations across Go, TypeScript, Rust, and C++.
+# Runs all 21 server/client combinations across Go, TypeScript, Rust, C++, and Python.
 #
 # Usage:
-#   ./run.bash              # Run all pairs
-#   ./run.bash go:ts        # Run go-server+ts-client and ts-server+go-client
-#   ./run.bash go:ts go:rust # Run multiple pair filters
+#   ./run.bash                         # Run all pairs
+#   ./run.bash go:ts                   # Run go-server+ts-client and ts-server+go-client
+#   ./run.bash python:go               # Run python-server+go-client and go-server+python-client
+#   ./run.bash --nested ts:python      # Run nested TypeScript/Python pairs
+#   ./run.bash --nested go:ts go:python ts:python # Run nested Go/TypeScript/Python pairs
 set -eo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
@@ -14,25 +16,79 @@ REPO_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
 # Fixes errors with the generated esm using require()
 ESM_BANNER='import{fileURLToPath}from"node:url";import{dirname}from"node:path";import{createRequire as topLevelCreateRequire}from"node:module";const require=topLevelCreateRequire(import.meta.url);const __filename=fileURLToPath(import.meta.url);const __dirname=dirname(__filename);'
 
-FILTERS=("$@")
+NESTED=false
+FILTERS=()
+for arg in "$@"; do
+    if [ "$arg" = "--nested" ]; then
+        NESTED=true
+    else
+        FILTERS+=("$arg")
+    fi
+done
+
+needs_language() {
+    local language="$1"
+    if [ ${#FILTERS[@]} -eq 0 ]; then
+        return 0
+    fi
+    for filter in "${FILTERS[@]}"; do
+        if [[ ":${filter}:" == *":${language}:"* ]]; then
+            return 0
+        fi
+    done
+    return 1
+}
 
 PASSED=0
 FAILED=0
 ERRORS=""
 
+SERVER_PID=""
 SERVER_LOG=""
+SERVER_EXIT_STATUS=0
+CLIENT_PID=""
+CLIENT_OUT=""
 
-# should_run checks if a test name matches the active filters.
+cleanup() {
+    if [ -n "${CLIENT_PID:-}" ]; then
+        kill "$CLIENT_PID" 2>/dev/null || true
+        wait "$CLIENT_PID" 2>/dev/null || true
+        CLIENT_PID=""
+    fi
+    if [ -n "${SERVER_PID:-}" ]; then
+        kill "$SERVER_PID" 2>/dev/null || true
+        wait "$SERVER_PID" 2>/dev/null || true
+        SERVER_PID=""
+    fi
+    if [ -n "${SERVER_LOG:-}" ]; then
+        rm -f "$SERVER_LOG"
+        SERVER_LOG=""
+    fi
+    if [ -n "${CLIENT_OUT:-}" ]; then
+        rm -f "$CLIENT_OUT"
+        CLIENT_OUT=""
+    fi
+}
+
+trap cleanup EXIT
+trap 'exit 130' INT
+trap 'exit 143' TERM
+
+# should_run checks if a server/client pair matches the active filters.
 # Returns 0 (true) if the test should run, 1 (false) otherwise.
 should_run() {
     local test_name="$1"
     if [ ${#FILTERS[@]} -eq 0 ]; then
         return 0
     fi
+    local server_language="${test_name%%-server*}"
+    local client_language="${test_name#*+ }"
+    client_language="${client_language%%-client*}"
     for filter in "${FILTERS[@]}"; do
         local lang1="${filter%%:*}"
         local lang2="${filter##*:}"
-        if [[ "$test_name" == *"${lang1}-"* && "$test_name" == *"${lang2}-"* ]]; then
+        if { [ "$server_language" = "$lang1" ] && [ "$client_language" = "$lang2" ]; } ||
+            { [ "$server_language" = "$lang2" ] && [ "$client_language" = "$lang1" ]; }; then
             return 0
         fi
     done
@@ -42,32 +98,39 @@ should_run() {
 # Build all binaries.
 echo "=== Building all integration binaries ==="
 
-echo "Building Go server/client..."
-go build -o "$SCRIPT_DIR/go-server/go-server" "$SCRIPT_DIR/go-server/"
-go build -o "$SCRIPT_DIR/go-client/go-client" "$SCRIPT_DIR/go-client/"
-
-echo "Building TypeScript server/client..."
-"$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-server.ts" \
-    --bundle --sourcemap --platform=node --format=esm \
-    --banner:js="$ESM_BANNER" \
-    --outfile="$SCRIPT_DIR/ts-server.mjs"
-"$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-client.ts" \
-    --bundle --sourcemap --platform=node --format=esm \
-    --banner:js="$ESM_BANNER" \
-    --outfile="$SCRIPT_DIR/ts-client.mjs"
-
-echo "Building Rust server/client..."
-cargo build --release -p echo-example --bin integration-server --bin integration-client
-
-echo "Vendoring Go dependencies (needed for C++ build)..."
-go mod vendor
-
-echo "Building C++ server/client..."
-mkdir -p "$REPO_DIR/build"
-pushd "$REPO_DIR/build" > /dev/null
-cmake "$REPO_DIR" -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1
-cmake --build . --target cpp-integration-server cpp-integration-client --parallel > /dev/null 2>&1
-popd > /dev/null
+if needs_language go; then
+    echo "Building Go server/client..."
+    go build -o "$SCRIPT_DIR/go-server/go-server" "$SCRIPT_DIR/go-server/"
+    go build -o "$SCRIPT_DIR/go-client/go-client" "$SCRIPT_DIR/go-client/"
+fi
+
+if needs_language ts; then
+    echo "Building TypeScript server/client..."
+    "$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-server.ts" \
+        --bundle --sourcemap --platform=node --format=esm \
+        --banner:js="$ESM_BANNER" \
+        --outfile="$SCRIPT_DIR/ts-server.mjs"
+    "$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-client.ts" \
+        --bundle --sourcemap --platform=node --format=esm \
+        --banner:js="$ESM_BANNER" \
+        --outfile="$SCRIPT_DIR/ts-client.mjs"
+fi
+
+if needs_language rust; then
+    echo "Building Rust server/client..."
+    cargo build --release -p echo-example --bin integration-server --bin integration-client
+fi
+
+if needs_language cpp; then
+    echo "Vendoring Go dependencies (needed for C++ build)..."
+    go mod vendor
+    echo "Building C++ server/client..."
+    mkdir -p "$REPO_DIR/build"
+    pushd "$REPO_DIR/build" > /dev/null
+    cmake "$REPO_DIR" -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1
+    cmake --build . --target cpp-integration-server cpp-integration-client --parallel > /dev/null 2>&1
+    popd > /dev/null
+fi
 
 # Binary paths.
 GO_SERVER="$SCRIPT_DIR/go-server/go-server"
@@ -78,6 +141,7 @@ RUST_SERVER="$REPO_DIR/target/release/integration-server"
 RUST_CLIENT="$REPO_DIR/target/release/integration-client"
 CPP_SERVER="$REPO_DIR/build/cpp-integration-server"
 CPP_CLIENT="$REPO_DIR/build/cpp-integration-client"
+PYTHON=(uv run --project "$REPO_DIR" python)
 
 start_server() {
     SERVER_LOG=$(mktemp)
@@ -95,8 +159,9 @@ start_server() {
     SERVER_ADDR=$(grep 'LISTENING' "$SERVER_LOG" 2>/dev/null | awk '{print $2}')
     if [ -z "$SERVER_ADDR" ]; then
         echo "FAILED: server did not start"
-        kill $SERVER_PID 2>/dev/null || true
-        wait $SERVER_PID 2>/dev/null || true
+        kill "$SERVER_PID" 2>/dev/null || true
+        wait "$SERVER_PID" 2>/dev/null || true
+        SERVER_PID=""
         rm -f "$SERVER_LOG"
         SERVER_LOG=""
         return 1
@@ -105,8 +170,36 @@ start_server() {
 }
 
 stop_server() {
-    kill $SERVER_PID 2>/dev/null || true
-    wait $SERVER_PID 2>/dev/null || true
+    kill "$SERVER_PID" 2>/dev/null || true
+    if wait "$SERVER_PID" 2>/dev/null; then
+        SERVER_EXIT_STATUS=0
+    else
+        SERVER_EXIT_STATUS=$?
+    fi
+    SERVER_PID=""
+}
+
+python_server_passed() {
+    local status="$1"
+    local log="$2"
+    [ "$status" -eq 0 ] && grep -qx "NESTED_CLEAN" "$log"
+}
+
+verify_python_server_guard() {
+    local log
+    log="$(mktemp)"
+    printf '%s\n' "NESTED_CLEAN" >"$log"
+    if python_server_passed 1 "$log"; then
+        rm -f "$log"
+        echo "runner guard accepted a nonzero Python server" >&2
+        return 1
+    fi
+    if ! python_server_passed 0 "$log"; then
+        rm -f "$log"
+        echo "runner guard rejected a clean Python server" >&2
+        return 1
+    fi
+    rm -f "$log"
 }
 
 # run_pair <test_name> <server_args...> -- <client_args...>
@@ -142,13 +235,25 @@ run_pair() {
         return
     fi
 
-    local client_out
-    client_out=$(mktemp)
+    CLIENT_OUT=$(mktemp)
     local client_ok=false
-    if "${cli_args[@]}" "$SERVER_ADDR" > "$client_out" 2>&1; then
+    timeout 60 "${cli_args[@]}" "$SERVER_ADDR" > "$CLIENT_OUT" 2>&1 &
+    CLIENT_PID=$!
+    if wait "$CLIENT_PID"; then
         client_ok=true
     fi
+    CLIENT_PID=""
     stop_server
+    if $NESTED && [[ "$test_name" == python-server* ]]; then
+        if ! verify_python_server_guard; then
+            client_ok=false
+            echo "    Python server result guard regression failed"
+        elif ! python_server_passed "$SERVER_EXIT_STATUS" "$SERVER_LOG"; then
+            client_ok=false
+            echo "    Python server failed nested shutdown (status $SERVER_EXIT_STATUS):"
+            sed 's/^/    /' "$SERVER_LOG"
+        fi
+    fi
 
     if $client_ok; then
         echo "PASSED"
@@ -158,9 +263,10 @@ run_pair() {
         FAILED=$((FAILED + 1))
         ERRORS="${ERRORS}\n  ${test_name}"
         echo "    client output:"
-        sed 's/^/    /' "$client_out"
+        sed 's/^/    /' "$CLIENT_OUT"
     fi
-    rm -f "$client_out" "$SERVER_LOG"
+    rm -f "$CLIENT_OUT" "$SERVER_LOG"
+    CLIENT_OUT=""
     SERVER_LOG=""
 }
 
@@ -168,29 +274,48 @@ echo ""
 echo "=== Running cross-language integration tests ==="
 echo ""
 
-# Go server combinations
-run_pair "go-server + go-client"   "$GO_SERVER" -- "$GO_CLIENT"
-run_pair "go-server + rust-client" "$GO_SERVER" -- "$RUST_CLIENT"
-run_pair "go-server + ts-client"   "$GO_SERVER" -- node "$TS_CLIENT"
-run_pair "go-server + cpp-client"  "$GO_SERVER" -- "$CPP_CLIENT"
-
-# Rust server combinations
-run_pair "rust-server + go-client"   "$RUST_SERVER" -- "$GO_CLIENT"
-run_pair "rust-server + rust-client" "$RUST_SERVER" -- "$RUST_CLIENT"
-run_pair "rust-server + ts-client"   "$RUST_SERVER" -- node "$TS_CLIENT"
-run_pair "rust-server + cpp-client"  "$RUST_SERVER" -- "$CPP_CLIENT"
-
-# TypeScript server combinations
-run_pair "ts-server + go-client"   node "$TS_SERVER" -- "$GO_CLIENT"
-run_pair "ts-server + rust-client" node "$TS_SERVER" -- "$RUST_CLIENT"
-run_pair "ts-server + ts-client"   node "$TS_SERVER" -- node "$TS_CLIENT"
-run_pair "ts-server + cpp-client"  node "$TS_SERVER" -- "$CPP_CLIENT"
-
-# C++ server combinations
-run_pair "cpp-server + go-client"   "$CPP_SERVER" -- "$GO_CLIENT"
-run_pair "cpp-server + rust-client" "$CPP_SERVER" -- "$RUST_CLIENT"
-run_pair "cpp-server + ts-client"   "$CPP_SERVER" -- node "$TS_CLIENT"
-run_pair "cpp-server + cpp-client"  "$CPP_SERVER" -- "$CPP_CLIENT"
+if $NESTED; then
+    # Nested streams have maintained Go, TypeScript, and Python endpoints.
+    run_pair "go-server + ts-client" "$GO_SERVER" -- node "$TS_CLIENT" --nested
+    run_pair "go-server + python-client" "$GO_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py" --nested
+
+    run_pair "ts-server + go-client" node "$TS_SERVER" -- "$GO_CLIENT" --nested
+    run_pair "ts-server + python-client" node "$TS_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py" --nested
+
+    run_pair "python-server + go-client" "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- "$GO_CLIENT" --nested-release
+    run_pair "python-server + ts-client" "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- node "$TS_CLIENT" --nested-release
+else
+    # Go server combinations
+    run_pair "go-server + go-client"   "$GO_SERVER" -- "$GO_CLIENT"
+    run_pair "go-server + rust-client" "$GO_SERVER" -- "$RUST_CLIENT"
+    run_pair "go-server + ts-client"   "$GO_SERVER" -- node "$TS_CLIENT"
+    run_pair "go-server + cpp-client"    "$GO_SERVER" -- "$CPP_CLIENT"
+    run_pair "go-server + python-client" "$GO_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py"
+
+    # Rust server combinations
+    run_pair "rust-server + go-client"   "$RUST_SERVER" -- "$GO_CLIENT"
+    run_pair "rust-server + rust-client" "$RUST_SERVER" -- "$RUST_CLIENT"
+    run_pair "rust-server + ts-client"   "$RUST_SERVER" -- node "$TS_CLIENT"
+    run_pair "rust-server + cpp-client"  "$RUST_SERVER" -- "$CPP_CLIENT"
+
+    # TypeScript server combinations
+    run_pair "ts-server + go-client"   node "$TS_SERVER" -- "$GO_CLIENT"
+    run_pair "ts-server + rust-client" node "$TS_SERVER" -- "$RUST_CLIENT"
+    run_pair "ts-server + ts-client"   node "$TS_SERVER" -- node "$TS_CLIENT"
+    run_pair "ts-server + cpp-client"    node "$TS_SERVER" -- "$CPP_CLIENT"
+    run_pair "ts-server + python-client" node "$TS_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py"
+
+    # Python server combinations
+    run_pair "python-server + go-client"     "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- "$GO_CLIENT"
+    run_pair "python-server + ts-client"     "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- node "$TS_CLIENT" lifecycle
+    run_pair "python-server + python-client" "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py"
+
+    # C++ server combinations
+    run_pair "cpp-server + go-client"   "$CPP_SERVER" -- "$GO_CLIENT"
+    run_pair "cpp-server + rust-client" "$CPP_SERVER" -- "$RUST_CLIENT"
+    run_pair "cpp-server + ts-client"   "$CPP_SERVER" -- node "$TS_CLIENT"
+    run_pair "cpp-server + cpp-client"  "$CPP_SERVER" -- "$CPP_CLIENT"
+fi
 
 echo ""
 echo "=== Results: ${PASSED} passed, ${FAILED} failed ==="