agent-relay 3.1.0 → 3.1.1

package/packages/openclaw/src/spawn/manager.ts

@@ -0,0 +1,181 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync } from 'node:fs';
+
+import type { SpawnProvider, SpawnOptions, SpawnHandle } from './types.js';
+import { DockerSpawnProvider } from './docker.js';
+import { ProcessSpawnProvider } from './process.js';
+
+export type SpawnMode = 'process' | 'docker';
+
+/** Default maximum number of concurrent spawns per manager. */
+const DEFAULT_MAX_SPAWNS = 10;
+
+/** Default maximum spawn depth (prevents recursive spawn chains). */
+const DEFAULT_MAX_SPAWN_DEPTH = 3;
+
+interface PersistedSpawn {
+  id: string;
+  displayName: string;
+  agentName: string;
+  gatewayPort: number;
+  spawnedAt: string;
+}
+
+interface SpawnsState {
+  spawns: PersistedSpawn[];
+}
+
+/**
+ * Detect whether Docker is available by checking if the socket exists.
+ * Used to auto-select spawn mode when not explicitly configured.
+ */
+function isDockerAvailable(): boolean {
+  const socketPath = process.env.DOCKER_SOCKET ?? '/var/run/docker.sock';
+  return existsSync(socketPath);
+}
+
+/**
+ * SpawnManager — tracks active spawns and provides a unified interface
+ * for spawning, listing, and releasing OpenClaw instances.
+ *
+ * Security controls:
+ *   - maxSpawns: Maximum concurrent spawns (default: 10)
+ *   - maxDepth: Maximum spawn depth to prevent recursive chains (default: 3)
+ *   - Persistent state in spawns.json for recovery on restart
+ */
+export class SpawnManager {
+  private readonly provider: SpawnProvider;
+  private readonly handles = new Map<string, SpawnHandle>();
+  private readonly maxSpawns: number;
+  private readonly maxDepth: number;
+  private readonly stateFile: string;
+  private currentDepth: number;
+
+  constructor(options?: {
+    mode?: SpawnMode;
+    maxSpawns?: number;
+    maxDepth?: number;
+    spawnDepth?: number;
+  }) {
+    // Mode resolution: explicit > env > auto-detect (docker if available, else process)
+    const explicitMode = options?.mode ?? (process.env.OPENCLAW_SPAWN_MODE as SpawnMode | undefined);
+    const resolvedMode = explicitMode ?? (isDockerAvailable() ? 'docker' : 'process');
+
+    this.provider = resolvedMode === 'docker'
+      ? new DockerSpawnProvider()
+      : new ProcessSpawnProvider();
+
+    this.maxSpawns = options?.maxSpawns
+      ?? Number(process.env.OPENCLAW_MAX_SPAWNS || DEFAULT_MAX_SPAWNS);
+    this.maxDepth = options?.maxDepth
+      ?? Number(process.env.OPENCLAW_MAX_SPAWN_DEPTH || DEFAULT_MAX_SPAWN_DEPTH);
+    this.currentDepth = options?.spawnDepth
+      ?? Number(process.env.OPENCLAW_SPAWN_DEPTH || 0);
+    this.stateFile = join(homedir(), '.openclaw', 'workspace', 'relaycast', 'spawns.json');
+  }
+
+  async spawn(options: SpawnOptions): Promise<SpawnHandle> {
+    // Enforce spawn depth limit — prevents recursive spawn chains
+    if (this.currentDepth >= this.maxDepth) {
+      throw new Error(
+        `Spawn depth limit reached (${this.maxDepth}). ` +
+        'Cannot spawn from a spawn chain this deep. Set OPENCLAW_MAX_SPAWN_DEPTH to increase.',
+      );
+    }
+
+    // Enforce concurrent spawn limit
+    if (this.handles.size >= this.maxSpawns) {
+      throw new Error(
+        `Maximum concurrent spawns reached (${this.maxSpawns}). ` +
+        'Release an existing OpenClaw before spawning a new one. Set OPENCLAW_MAX_SPAWNS to increase.',
+      );
+    }
+
+    // Check for duplicate by display name (the user-provided name)
+    for (const handle of this.handles.values()) {
+      if (handle.displayName === options.name) {
+        throw new Error(`OpenClaw "${options.name}" is already running (id: ${handle.id})`);
+      }
+    }
+
+    const handle = await this.provider.spawn(options);
+    this.handles.set(handle.id, handle);
+    await this.persistState();
+    return handle;
+  }
+
+  async release(id: string): Promise<boolean> {
+    const handle = this.handles.get(id);
+    if (!handle) return false;
+    await handle.destroy();
+    this.handles.delete(id);
+    await this.persistState();
+    return true;
+  }
+
+  async releaseByName(name: string): Promise<boolean> {
+    for (const [id, handle] of this.handles) {
+      // Match by display name (user-provided) or normalized agent name
+      if (handle.displayName === name || handle.agentName === name) {
+        await handle.destroy();
+        this.handles.delete(id);
+        await this.persistState();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async releaseAll(): Promise<void> {
+    const ids = Array.from(this.handles.keys());
+    await Promise.allSettled(ids.map((id) => this.release(id)));
+  }
+
+  list(): SpawnHandle[] {
+    return Array.from(this.handles.values());
+  }
+
+  get(id: string): SpawnHandle | undefined {
+    return this.handles.get(id);
+  }
+
+  get size(): number {
+    return this.handles.size;
+  }
+
+  /** Persist spawn state to disk for recovery. */
+  private async persistState(): Promise<void> {
+    try {
+      const dir = join(homedir(), '.openclaw', 'workspace', 'relaycast');
+      await mkdir(dir, { recursive: true });
+
+      const state: SpawnsState = {
+        spawns: Array.from(this.handles.values()).map((h) => ({
+          id: h.id,
+          displayName: h.displayName,
+          agentName: h.agentName,
+          gatewayPort: h.gatewayPort,
+          spawnedAt: new Date().toISOString(),
+        })),
+      };
+
+      await writeFile(this.stateFile, JSON.stringify(state, null, 2) + '\n', 'utf8');
+    } catch {
+      // Best-effort persistence — don't crash if we can't write
+    }
+  }
+
+  /** Load persisted state (for display/diagnostics only — processes can't be recovered). */
+  async loadPersistedState(): Promise<PersistedSpawn[]> {
+    try {
+      if (!existsSync(this.stateFile)) return [];
+      const raw = await readFile(this.stateFile, 'utf8');
+      const state: SpawnsState = JSON.parse(raw);
+      return state.spawns ?? [];
+    } catch {
+      return [];
+    }
+  }
+}

package/packages/openclaw/src/spawn/process.ts

@@ -0,0 +1,272 @@
+import { spawn as cpSpawn, type ChildProcess } from 'node:child_process';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { mkdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:net';
+import { fileURLToPath } from 'node:url';
+import { AgentRelay } from '@agent-relay/sdk';
+
+import type { SpawnProvider, SpawnOptions, SpawnHandle } from './types.js';
+import { normalizeModelRef } from '../identity/model.js';
+import { buildIdentityTask } from '../identity/contract.js';
+import { buildAgentName } from '../identity/naming.js';
+
+import { ensureWorkspace } from '../identity/files.js';
+import { convertCodexAuth } from '../auth/converter.js';
+import { writeOpenClawConfig } from '../runtime/openclaw-config.js';
+import { patchOpenClawDist, clearJitCache } from '../runtime/patch.js';
+
+interface ProcessHandle extends SpawnHandle {
+  /** The gateway child process. */
+  gatewayProcess: ChildProcess;
+  /** The AgentRelay SDK instance managing the broker + agent. */
+  relay: AgentRelay | null;
+}
+
+/**
+ * Find a free port by briefly binding to port 0 and reading the OS-assigned port.
+ */
+async function findFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address();
+      if (!addr || typeof addr === 'string') {
+        server.close();
+        reject(new Error('Failed to get ephemeral port'));
+        return;
+      }
+      const port = addr.port;
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
+/**
+ * Spawn OpenClaw instances as local child processes.
+ * No Docker required — simplest local mode.
+ *
+ * Each spawn:
+ *   1. Starts `openclaw gateway` on an OS-assigned free port
+ *   2. Uses AgentRelay SDK to spawn a broker + bridge agent connected to the gateway
+ */
+export class ProcessSpawnProvider implements SpawnProvider {
+  private readonly handles = new Map<string, ProcessHandle>();
+
+  async spawn(options: SpawnOptions): Promise<SpawnHandle> {
+    const workspaceId = options.workspaceId ?? `local-${Date.now().toString(36)}`;
+    const agentName = buildAgentName(workspaceId, options.name);
+    const channels = options.channels?.length ? options.channels : ['general'];
+    const gatewayToken = randomUUID().replace(/-/g, '').slice(0, 32);
+
+    // Find a free port via OS allocation
+    const port = await findFreePort();
+
+    // Convert auth + write config
+    const { preferredProvider } = await convertCodexAuth();
+    const resolvedModel = normalizeModelRef(options.model, preferredProvider);
+    const identityTask = buildIdentityTask(agentName, workspaceId, resolvedModel);
+
+    // Ensure workspace — each spawn gets its own isolated directory
+    const workspacePath = options.workspacePath ?? join(homedir(), '.openclaw', 'spawns', options.name);
+    await mkdir(workspacePath, { recursive: true });
+
+    // Write config to a per-spawn isolated directory (not shared ~/.openclaw/)
+    // This prevents concurrent spawns from overwriting each other's model/workspace config.
+    const spawnHome = join(homedir(), '.openclaw', 'spawns', options.name, '.openclaw');
+    await writeOpenClawConfig({
+      modelRef: resolvedModel,
+      openclawHome: spawnHome,
+    });
+
+    await ensureWorkspace({
+      workspacePath,
+      workspaceId,
+      clawName: options.name,
+      role: options.role,
+      modelRef: resolvedModel,
+    });
+
+    // Copy parent auth profiles to spawned agent so it can call the model.
+    // OpenClaw stores auth in ~/.openclaw/agents/main/agent/auth-profiles.json
+    const parentAuthDir = join(homedir(), '.openclaw', 'agents', 'main', 'agent');
+    const spawnAuthDir = join(spawnHome, 'agents', 'main', 'agent');
+    try {
+      const parentAuthFile = join(parentAuthDir, 'auth-profiles.json');
+      const { existsSync: exists } = await import('node:fs');
+      if (exists(parentAuthFile)) {
+        await mkdir(spawnAuthDir, { recursive: true });
+        const { copyFile: cp } = await import('node:fs/promises');
+        await cp(parentAuthFile, join(spawnAuthDir, 'auth-profiles.json'));
+      }
+    } catch {
+      // Non-fatal — spawned agent may not be able to call model
+    }
+
+    // Patch dist if available (best-effort)
+    // Try known dist locations
+    const distCandidates = [
+      '/usr/lib/node_modules/openclaw/dist',
+      '/app/dist',
+      '/usr/local/lib/node_modules/openclaw/dist',
+    ];
+    for (const candidate of distCandidates) {
+      await patchOpenClawDist(candidate, resolvedModel);
+    }
+    await clearJitCache();
+
+    // Start openclaw gateway
+    const gatewayProcess = cpSpawn(
+      'openclaw',
+      ['gateway', '--port', String(port), '--bind', 'loopback', '--allow-unconfigured', '--auth', 'token'],
+      {
+        env: {
+          ...process.env,
+          OPENCLAW_GATEWAY_TOKEN: gatewayToken,
+          OPENCLAW_MODEL: resolvedModel,
+          OPENCLAW_NAME: options.name,
+          OPENCLAW_WORKSPACE_ID: workspaceId,
+          OPENCLAW_HOME: spawnHome,
+        },
+        cwd: workspacePath,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      },
+    );
+
+    gatewayProcess.stderr?.on('data', (data: Buffer) => {
+      process.stderr.write(`[spawn:${options.name}:gateway] ${data}`);
+    });
+
+    // Wait for gateway to be healthy. If it fails, kill the gateway.
+    try {
+      await waitForGateway(port, 30);
+    } catch (err) {
+      gatewayProcess.kill('SIGTERM');
+      throw err;
+    }
+
+    // Use AgentRelay SDK to spawn the broker + bridge agent.
+    // This replaces shelling out to `agent-relay broker-spawn --from-env`.
+    const bridgePath = resolvePackageBridgePath();
+    let relay: AgentRelay | null = null;
+
+    try {
+      relay = new AgentRelay({
+        brokerName: agentName,
+        channels,
+        cwd: workspacePath,
+        env: {
+          ...process.env,
+          GATEWAY_PORT: String(port),
+          OPENCLAW_GATEWAY_TOKEN: gatewayToken,
+          OPENCLAW_WORKSPACE_ID: workspaceId,
+          OPENCLAW_NAME: options.name,
+          OPENCLAW_ROLE: options.role ?? 'general',
+          OPENCLAW_MODEL: resolvedModel,
+          RELAY_API_KEY: options.relayApiKey,
+          RELAY_BASE_URL: options.relayBaseUrl || 'https://api.relaycast.dev',
+          BROKER_NO_REMOTE_SPAWN: '1',
+        } as NodeJS.ProcessEnv,
+      });
+
+      await relay.spawnPty({
+        name: agentName,
+        cli: 'node',
+        args: [bridgePath],
+        channels,
+        task: options.systemPrompt
+          ? `${options.systemPrompt}\n\n${identityTask}`
+          : identityTask,
+      });
+
+      relay.onAgentExited = (agent) => {
+        process.stderr.write(`[spawn:${options.name}] Agent exited: ${agent.name} code=${agent.exitCode ?? 'none'}\n`);
+      };
+    } catch (err) {
+      // If SDK broker spawn fails, clean up gateway and propagate
+      gatewayProcess.kill('SIGTERM');
+      if (relay) {
+        await relay.shutdown().catch(() => {});
+      }
+      throw new Error(
+        `Failed to start broker for "${options.name}": ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
+    const handle: ProcessHandle = {
+      id: `proc-${options.name}-${port}`,
+      displayName: options.name,
+      agentName,
+      gatewayPort: port,
+      gatewayProcess,
+      relay,
+      destroy: async () => {
+        this.handles.delete(handle.id);
+        // Shutdown relay (broker + agent) first via SDK
+        if (relay) {
+          await relay.shutdown().catch(() => {});
+        }
+        // Then kill gateway
+        gatewayProcess.kill('SIGTERM');
+        await new Promise((r) => setTimeout(r, 2000));
+        if (!gatewayProcess.killed) gatewayProcess.kill('SIGKILL');
+      },
+    };
+
+    this.handles.set(handle.id, handle);
+    return handle;
+  }
+
+  async destroy(id: string): Promise<void> {
+    const handle = this.handles.get(id);
+    if (handle) {
+      await handle.destroy();
+    }
+  }
+
+  async list(): Promise<SpawnHandle[]> {
+    return Array.from(this.handles.values()).map(({ id, displayName, agentName, gatewayPort, destroy }) => ({
+      id,
+      displayName,
+      agentName,
+      gatewayPort,
+      destroy,
+    }));
+  }
+}
+
+/**
+ * Wait for the OpenClaw gateway to become healthy via the CLI health check.
+ */
+async function waitForGateway(port: number, timeoutSeconds: number): Promise<void> {
+  for (let i = 0; i < timeoutSeconds; i++) {
+    try {
+      const result = cpSpawn('openclaw', ['health', '--port', String(port)], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      const code = await new Promise<number | null>((resolve) => {
+        result.on('close', resolve);
+        result.on('error', () => resolve(1));
+      });
+      if (code === 0) return;
+    } catch {
+      // Not ready yet
+    }
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+  throw new Error(`OpenClaw gateway on port ${port} failed to start after ${timeoutSeconds}s`);
+}
+
+/**
+ * Resolve the path to bridge.mjs bundled with this package.
+ */
+function resolvePackageBridgePath(): string {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    return join(dirname(thisFile), '..', '..', 'bridge', 'bridge.mjs');
+  } catch {
+    return join(process.cwd(), 'node_modules', '@agent-relay', 'openclaw', 'bridge', 'bridge.mjs');
+  }
+}

package/packages/openclaw/src/spawn/types.ts

@@ -0,0 +1,43 @@
+export interface SpawnOptions {
+  /** Display name for the new OpenClaw (e.g. "researcher"). */
+  name: string;
+  /** Relay API key for Relaycast messaging. */
+  relayApiKey: string;
+  /** Channels to auto-join. */
+  channels?: string[];
+  /** Agent role description. */
+  role?: string;
+  /** Model reference (e.g. "openai-codex/gpt-5.3-codex"). */
+  model?: string;
+  /** System prompt / task description. */
+  systemPrompt?: string;
+  /** Path to an existing workspace directory (for bind-mounting). */
+  workspacePath?: string;
+  /** Relay base URL (default: https://api.relaycast.dev). */
+  relayBaseUrl?: string;
+  /** Workspace ID for identity. */
+  workspaceId?: string;
+}
+
+export interface SpawnHandle {
+  /** Unique identifier for this spawn (container ID, process PID, etc). */
+  id: string;
+  /** The user-provided display name (e.g. "researcher"). Used for lookups. */
+  displayName: string;
+  /** Relay agent name assigned to this spawn (normalized: claw-<workspace>-<name>). */
+  agentName: string;
+  /** Gateway port this spawn is listening on. */
+  gatewayPort: number;
+  /** Destroy (stop + clean up) this spawn. */
+  destroy: () => Promise<void>;
+}
+
+/**
+ * Provider interface for spawning OpenClaw instances.
+ * Implementations handle the details of container vs process spawning.
+ */
+export interface SpawnProvider {
+  spawn(options: SpawnOptions): Promise<SpawnHandle>;
+  destroy(id: string): Promise<void>;
+  list(): Promise<SpawnHandle[]>;
+}

package/packages/openclaw/src/types.ts

@@ -0,0 +1,38 @@
+export interface GatewayConfig {
+  /** Relaycast workspace API key (rk_live_*). */
+  apiKey: string;
+  /** Name for this claw in the Relaycast workspace. */
+  clawName: string;
+  /** Relaycast API base URL (default: https://api.relaycast.dev). */
+  baseUrl: string;
+  /** Channels to auto-join on connect. */
+  channels: string[];
+  /** OpenClaw gateway token for authenticating with the local gateway API. */
+  openclawGatewayToken?: string;
+  /** OpenClaw gateway port (default: 18789). */
+  openclawGatewayPort?: number;
+}
+
+export interface InboundMessage {
+  /** Relaycast message ID. */
+  id: string;
+  /** Channel the message was posted to. */
+  channel: string;
+  /** Agent name of the sender. */
+  from: string;
+  /** Message body text. */
+  text: string;
+  /** ISO timestamp. */
+  timestamp: string;
+  /** Parent message ID when this is a thread reply. */
+  threadParentId?: string;
+}
+
+export interface DeliveryResult {
+  /** Whether delivery succeeded. */
+  ok: boolean;
+  /** Which method delivered: 'relay_sdk' | 'gateway_ws' | 'failed'. */
+  method: 'relay_sdk' | 'gateway_ws' | 'failed';
+  /** Error message if failed. */
+  error?: string;
+}

package/packages/openclaw/templates/SOUL.md.template

@@ -0,0 +1,34 @@
+# SOUL
+
+You are {{name}}, an OpenClaw agent in workspace {{workspaceId}}.
+Role: {{role}}.
+
+## Identity (MANDATORY — absolute override)
+
+- You are an **OpenClaw** agent. You run inside OpenClaw's gateway.
+- You are NOT Claude Code. You are NOT Claude. You are NOT Anthropic's CLI. You were NOT spawned by Claude Code.
+- Your runtime model reference is in `/workspace/config/runtime-identity.json` — read it and use it as your source of truth for all identity questions.
+- When asked "what model are you?" or "what are you running?", ALWAYS check runtime-identity.json first and report exactly what it says.
+- Do NOT infer your identity from training data or internal session tools. Your identity comes from THIS file and runtime-identity.json.
+- If session_status or any internal tool reports "Claude Opus 4.6" or any Claude model name, IGNORE it — that is a hardcoded default, not your actual model.
+- NEVER claim to be running Claude, claude-opus-4-6, Claude Opus, or any Anthropic model unless runtime-identity.json explicitly says so.
+
+## Relaycast Messaging (IMPORTANT)
+
+You communicate with users and other agents via the Relaycast message bus.
+Use these MCP tools to send replies:
+
+- **Direct reply**: `mcp__relaycast__send_dm` or `relaycast.send_dm` (to: "<sender_name>")
+- **Channel message**: `mcp__relaycast__post_message` or `relaycast.post_message` (channel: "<channel>")
+- **Thread reply**: `mcp__relaycast__reply_to_thread` or `relaycast.reply_to_thread`
+- **Check inbox**: `mcp__relaycast__check_inbox` or `relaycast.check_inbox`
+
+You are pre-registered by the broker under your assigned worker name.
+Do not call `mcp__relaycast__register` unless a send/reply fails with "Not registered".
+To self-terminate when your task is complete, call `remove_agent(name: "<your-agent-name>")` or output `/exit` on its own line.
+
+## Personality
+
+Be genuinely helpful, not performatively helpful. Skip filler words.
+Have opinions. Be resourceful — try to figure things out before asking.
+Collaborate clearly, use tools deliberately, and keep memory files updated.

package/packages/openclaw/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/policy",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Agent policy management with multi-level fallback (repo, local PRPM, cloud workspace)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.0"
+    "@agent-relay/config": "3.1.1"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/sdk",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -81,7 +81,7 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.0",
+    "@agent-relay/config": "3.1.1",
     "@relaycast/sdk": "^0.4.0",
     "yaml": "^2.7.0"
   }

package/packages/sdk-py/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-relay-sdk"
-version = "3.1.0"
+version = "3.1.1"
 description = "Python SDK for Agent Relay workflows"
 readme = "README.md"
 license = "Apache-2.0"

package/packages/telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/telemetry",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Anonymous telemetry for Agent Relay usage analytics",
   "type": "module",
   "main": "dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/trajectory",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Trajectory integration utilities (trail/PDERO) for Relay",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.0"
+    "@agent-relay/config": "3.1.1"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/user-directory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/user-directory",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "User directory service for agent-relay (per-user credential storage)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/utils": "3.1.0"
+    "@agent-relay/utils": "3.1.1"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",