fix(sdk-core): remove @atproto/xrpc import to eliminate build warning

Define FetchHandler type locally instead of importing from @atproto/xrpc
to avoid TypeScript warning about missing type declarations during build.
The type definition is simple and stable, so local definition is preferred.

Author: bitbeckers

.changeset/configurable-agent-routing.md

@@ -0,0 +1,31 @@
+---
+"@hypercerts-org/sdk-core": minor
+---
+
+Implement ConfigurableAgent for proper multi-server routing
+
+This release introduces the `ConfigurableAgent` class that enables proper routing of AT Protocol requests to different servers (PDS, SDS, or custom instances) while maintaining OAuth authentication from a single session.
+
+**Breaking Changes:**
+- Repository now uses `ConfigurableAgent` internally instead of standard `Agent`
+- This fixes the issue where invalid `agent.service` and `agent.api.xrpc.uri` property assignments were causing TypeScript errors
+
+**New Features:**
+- `ConfigurableAgent` class exported from `@hypercerts-org/sdk-core`
+- Support for simultaneous connections to multiple SDS instances with one OAuth session
+- Proper request routing based on configured service URL rather than session defaults
+
+**Bug Fixes:**
+- Remove invalid Agent property assignments that caused TypeScript compilation errors (TS2339)
+- Replace all `any` types in test files with proper type annotations
+- Eliminate build warnings from missing type declarations
+
+**Architecture:**
+The new routing system wraps the OAuth session's fetch handler to prepend the target server URL, ensuring requests go to the intended destination while maintaining full authentication (DPoP, access tokens, etc.). This enables use cases like:
+- Routing to SDS while authenticated via PDS
+- Accessing multiple organization SDS instances simultaneously
+- Testing against different server environments
+- Dynamic switching between PDS and SDS operations
+
+**Migration:**
+No action required - the change is transparent to existing code. The Repository API remains unchanged.

packages/sdk-core/README.md

@@ -77,7 +77,7 @@ await orgRepo.hypercerts.list(); // Queries organization's hypercerts on SDS
 
 #### How Repository Routing Works
 
-When you create or switch repositories, the SDK ensures requests are routed to the correct server:
+The SDK uses a `ConfigurableAgent` to route requests to different servers while maintaining your OAuth authentication:
 
 1. **Initial Repository Creation**
    ```typescript
@@ -105,10 +105,11 @@ When you create or switch repositories, the SDK ensures requests are routed to t
    ```
 
 3. **Key Implementation Details**
-   - The SDK configures the AT Protocol Agent's service URL when creating repositories
-   - When you call `.repo(did)`, a new Repository instance is created that maintains the same server URL
-   - This ensures that even when querying different DIDs, requests go to the intended server
-   - User's OAuth session provides authentication, but doesn't determine routing
+   - Each Repository uses a `ConfigurableAgent` that wraps your OAuth session's fetch handler
+   - The agent routes all requests to the specified server URL (PDS, SDS, or custom)
+   - When you call `.repo(did)`, a new Repository is created with the same server configuration
+   - Your OAuth session provides authentication (DPoP, access tokens), while the agent handles routing
+   - This enables simultaneous connections to multiple servers with one authentication session
 
 #### Common Patterns
 
@@ -549,6 +550,35 @@ try {
 
 ## Advanced Usage
 
+### Multi-Server Routing with ConfigurableAgent
+
+The `ConfigurableAgent` allows you to create custom agents that route to specific servers:
+
+```typescript
+import { ConfigurableAgent } from "@hypercerts-org/sdk-core";
+
+// Authenticate once with your PDS
+const session = await sdk.callback(params);
+
+// Create agents for different servers using the same session
+const pdsAgent = new ConfigurableAgent(session, "https://bsky.social");
+const sdsAgent = new ConfigurableAgent(session, "https://sds.hypercerts.org");
+const orgAgent = new ConfigurableAgent(session, "https://sds-org-a.example.com");
+
+// Use agents directly with AT Protocol APIs
+await pdsAgent.com.atproto.repo.createRecord({...});
+await sdsAgent.com.atproto.repo.listRecords({...});
+
+// Or pass to Repository for high-level operations
+// (Repository internally uses ConfigurableAgent)
+```
+
+This is useful for:
+- Connecting to multiple SDS instances simultaneously
+- Testing against different server environments
+- Building tools that work across multiple organizations
+- Direct AT Protocol API access with custom routing
+
 ### Custom Session Storage
 
 ```typescript

packages/sdk-core/src/agent/ConfigurableAgent.ts

@@ -8,9 +8,14 @@
  */
 
 import { Agent } from "@atproto/api";
-import type { FetchHandler } from "@atproto/xrpc";
 import type { Session } from "../core/types.js";
 
+/**
+ * FetchHandler type - function that makes HTTP requests with authentication.
+ * Takes a pathname and request init, returns a Response promise.
+ */
+type FetchHandler = (pathname: string, init: RequestInit) => Promise<Response>;
+
 /**
  * Agent subclass that routes requests to a configurable service URL.
  *