agent-relay-server 0.18.0 → 0.19.0

package/src/mcp.ts

@@ -3,6 +3,9 @@ import { getArtifactStorage, maxArtifactBytes, normalizeDigest } from "./artifac
 import { createCommand } from "./commands-db";
 import { buildSpawnCommand, generateSpawnRequestId, resolveSpawnModelParams, type SpawnModelParams } from "./spawn-command";
 import { isPathWithinBase } from "./utils";
+import { optionalEnum } from "./validation";
+import { listManagedOrchestratorsForAgent } from "./orchestrator-lookup";
+import { bytesToStream, readBodyBytes } from "./http-body";
 import { MAX_BODY_BYTES, VERSION } from "./config";
 import { getManagedAgentState, getSpawnPolicy, listSpawnPolicies } from "./config-store";
 import {
@@ -34,7 +37,7 @@ import {
 } from "./security";
 import type { ActivityKind, AgentCard, ArtifactKind, ArtifactSensitivity, AttachmentRef, Command, SendMessageInput, Message, SpawnApprovalMode, SpawnProvider } from "./types";
 import { type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { isRecord, SPAWN_PROVIDERS, APPROVAL_MODES, VALID_EFFORTS } from "agent-relay-sdk";
+import { errMessage, isRecord, SPAWN_PROVIDERS, APPROVAL_MODES, VALID_EFFORTS } from "agent-relay-sdk";
 import { childRunnerRuntimeTokenEnv, runnerRuntimeTokenEnv } from "./runtime-tokens";
 
 type JsonRpcId = string | number | null;
@@ -272,7 +275,7 @@ export async function postMcp(req: Request): Promise<Response> {
     }
     return Response.json(jsonRpcError(id, -32601, `unknown MCP method: ${method}`));
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     const status = error instanceof McpAuthError ? 403 : error instanceof McpNotFoundError ? 404 : 400;
     const code = error instanceof McpAuthError ? -32001 : error instanceof McpNotFoundError ? -32004 : -32602;
     return Response.json(jsonRpcError(id, code, message, { status }));
@@ -284,23 +287,11 @@ async function parseJsonRpcRequest(req: Request): Promise<
   | { ok: false; status: number; error: string }
 > {
   if (!req.body) return { ok: false, status: 400, error: "JSON-RPC body required" };
-  const reader = req.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    if (!value) continue;
-    total += value.byteLength;
-    const maxBodyBytes = Math.max(MAX_BODY_BYTES, maxArtifactBytes() + MCP_BODY_OVERHEAD_BYTES);
-    if (total > maxBodyBytes) {
-      await reader.cancel().catch(() => {});
-      return { ok: false, status: 413, error: `request body exceeds ${maxBodyBytes} bytes` };
-    }
-    chunks.push(value);
-  }
+  const maxBodyBytes = Math.max(MAX_BODY_BYTES, maxArtifactBytes() + MCP_BODY_OVERHEAD_BYTES);
+  const read = await readBodyBytes(req.body, maxBodyBytes);
+  if (!read.ok) return read;
   try {
-    const body = JSON.parse(new TextDecoder().decode(concatBytes(chunks))) as unknown;
+    const body = JSON.parse(new TextDecoder().decode(read.bytes)) as unknown;
     if (!isRecord(body)) return { ok: false, status: 400, error: "JSON-RPC body must be an object" };
     return { ok: true, request: body as JsonRpcRequest };
   } catch {
@@ -308,17 +299,6 @@ async function parseJsonRpcRequest(req: Request): Promise<
   }
 }
 
-function concatBytes(chunks: Uint8Array[]): Uint8Array {
-  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
-  const output = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    output.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return output;
-}
-
 function mcpAuthContext(req: Request): McpAuthContext {
   const component = getComponentAuth(req);
   if (component) return { actor: component.sub, kind: "component", scopes: component.scope, component };
@@ -354,7 +334,7 @@ async function callTool(auth: McpAuthContext, params: unknown): Promise<Record<s
     auditToolCall(auth, name, "ok", result);
     return toolResult(result);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     auditToolCall(auth, name, error instanceof McpAuthError ? "denied" : "error", undefined, message);
     throw error;
   }
@@ -732,7 +712,7 @@ function selectControlOrchestrator(input: {
     return orchestrator;
   }
   const agent = input.agentId ? getAgent(input.agentId) : null;
-  const orchestrator = agent ? managedControlOrchestrator(agent, input) : findManagedOrchestrator(input);
+  const orchestrator = agent ? managedControlOrchestrator(agent, input) : (listManagedOrchestratorsForAgent(input)[0] ?? null);
   if (!orchestrator) throw new McpNotFoundError("no orchestrator found for agent control target");
   if (orchestrator.status !== "online") throw new ValidationError("orchestrator is offline");
   return orchestrator;
@@ -742,29 +722,13 @@ function managedControlOrchestrator(
   agent: AgentCard,
   input: { policyName?: string; spawnRequestId?: string; tmuxSession?: string },
 ): NonNullable<ReturnType<typeof getOrchestrator>> | null {
-  const metaTmuxSession = typeof agent.meta?.tmuxSession === "string" ? agent.meta.tmuxSession : "";
-  const metaPolicyName = input.policyName ?? (typeof agent.meta?.policyName === "string" ? agent.meta.policyName : "");
-  const metaSpawnRequestId = input.spawnRequestId ?? (typeof agent.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : "");
-  return findManagedOrchestrator({
+  const str = (v: unknown): string | undefined => (typeof v === "string" ? v : undefined);
+  return listManagedOrchestratorsForAgent({
     agentId: agent.id,
-    policyName: metaPolicyName,
-    spawnRequestId: metaSpawnRequestId,
-    tmuxSession: input.tmuxSession ?? metaTmuxSession,
-  }) ?? (agent.machine ? getOrchestrator(agent.machine) : null);
-}
-
-function findManagedOrchestrator(input: {
-  agentId?: string;
-  policyName?: string;
-  spawnRequestId?: string;
-  tmuxSession?: string;
-}): NonNullable<ReturnType<typeof getOrchestrator>> | null {
-  return listOrchestrators().find((orchestrator) => orchestrator.managedAgents.some((managed) =>
-    (!!input.agentId && managed.agentId === input.agentId) ||
-    (!!input.tmuxSession && managed.tmuxSession === input.tmuxSession) ||
-    (!!input.policyName && managed.policyName === input.policyName) ||
-    (!!input.spawnRequestId && managed.spawnRequestId === input.spawnRequestId)
-  )) ?? null;
+    policyName: input.policyName ?? str(agent.meta?.policyName),
+    spawnRequestId: input.spawnRequestId ?? str(agent.meta?.spawnRequestId),
+    tmuxSession: input.tmuxSession ?? str(agent.meta?.tmuxSession),
+  })[0] ?? (agent.machine ? getOrchestrator(agent.machine) : null);
 }
 
 function providerSelection(provider: SpawnProvider, args: Record<string, unknown>): SpawnModelParams {
@@ -773,15 +737,6 @@ function providerSelection(provider: SpawnProvider, args: Record<string, unknown
   return resolveSpawnModelParams(provider, model, effort);
 }
 
-function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      controller.enqueue(bytes);
-      controller.close();
-    },
-  });
-}
-
 function artifactBytes(args: Record<string, unknown>): Uint8Array {
   const hasContent = args.content !== undefined && args.content !== null;
   const hasBase64 = args.base64 !== undefined && args.base64 !== null;
@@ -956,12 +911,6 @@ function optionalBoolean(value: unknown, field: string): boolean | undefined {
   return value;
 }
 
-function optionalEnum<T extends readonly string[]>(value: unknown, field: string, valid: T): T[number] | undefined {
-  if (value === undefined || value === null) return undefined;
-  if (typeof value !== "string" || !valid.includes(value as T[number])) throw new ValidationError(`${field} must be one of: ${valid.join(", ")}`);
-  return value as T[number];
-}
-
 function enumField<T extends readonly string[]>(value: unknown, field: string, valid: T): T[number] {
   const cleaned = optionalEnum(value, field, valid);
   if (!cleaned) throw new ValidationError(`${field} required`);

package/src/memory-broker-smoke.ts

@@ -1,4 +1,4 @@
-import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 
 interface MemoryBrokerSmokeOptions {
   baseUrl?: string;
@@ -137,7 +137,7 @@ async function step<T>(steps: MemoryBrokerSmokeStep[], name: string, detail: str
     steps.push({ name, ok: true, detail });
     return result;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     steps.push({ name, ok: false, detail: message });
     throw error;
   }

package/src/memory-command-broker.ts

@@ -20,7 +20,7 @@ import {
   normalizeMemorySearchResult,
 } from "./memory-broker-contract";
 import { normalizeContextPackage } from "./memory-http-broker";
-import { isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
 
 const DEFAULT_TIMEOUT_MS = 10_000;
 
@@ -105,7 +105,7 @@ export class CommandMemoryBroker implements MemoryBroker {
       return unwrapResult(parseJson(stdout, operation));
     } catch (error) {
       if (error instanceof MemoryBrokerContractError) throw error;
-      throw new MemoryBrokerContractError(`command memory broker ${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new MemoryBrokerContractError(`command memory broker ${operation} failed: ${errMessage(error)}`);
     } finally {
       clearTimeout(timer);
     }

package/src/memory-http-broker.ts

@@ -19,7 +19,7 @@ import {
   normalizeMemoryBrokerCapabilities,
   normalizeMemorySearchResult,
 } from "./memory-broker-contract";
-import { isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
 
 const DEFAULT_TIMEOUT_MS = 10_000;
 
@@ -99,7 +99,7 @@ export class HttpMemoryBroker implements MemoryBroker {
       if (error instanceof DOMException && error.name === "AbortError") {
         throw new MemoryBrokerContractError(`http memory broker ${operation} timed out after ${this.timeoutMs}ms`);
       }
-      throw new MemoryBrokerContractError(`http memory broker ${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new MemoryBrokerContractError(`http memory broker ${operation} failed: ${errMessage(error)}`);
     } finally {
       clearTimeout(timer);
     }

package/src/orchestrator-lookup.ts

@@ -0,0 +1,29 @@
+import { listOrchestrators } from "./db";
+
+export interface ManagedAgentMatch {
+  agentId?: string;
+  sessionName?: string;
+  tmuxSession?: string;
+  policyName?: string;
+  spawnRequestId?: string;
+}
+
+/**
+ * Every orchestrator that owns a managed agent matching ANY provided identity
+ * key. Single home for the managed-agent→orchestrator lookup that routes.ts and
+ * mcp.ts each open-coded. routes also matches `sessionName`; mcp never passed it,
+ * so leaving the key undefined reproduces mcp's behavior exactly. Callers layer
+ * their own online / runner-managed / machine-fallback policy on top — routes
+ * picks the first online candidate, mcp takes the first match.
+ */
+export function listManagedOrchestratorsForAgent(match: ManagedAgentMatch): ReturnType<typeof listOrchestrators> {
+  return listOrchestrators().filter((orch) =>
+    orch.managedAgents.some((managed) =>
+      (!!match.agentId && managed.agentId === match.agentId) ||
+      (!!match.sessionName && managed.sessionName === match.sessionName) ||
+      (!!match.tmuxSession && managed.tmuxSession === match.tmuxSession) ||
+      (!!match.policyName && managed.policyName === match.policyName) ||
+      (!!match.spawnRequestId && managed.spawnRequestId === match.spawnRequestId),
+    ),
+  );
+}

package/src/recipe-validator.ts

@@ -1,6 +1,6 @@
 import type { MemoryType, Recipe, RecipeAgent, RecipeMemoryPolicy } from "./types";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
 
 class RecipeValidationError extends Error {}
 
@@ -52,7 +52,7 @@ function validateAgent(value: unknown): RecipeAgent {
   try {
     resolveProviderSelection({ provider, model, effort });
   } catch (error) {
-    throw new RecipeValidationError(error instanceof Error ? error.message : String(error));
+    throw new RecipeValidationError(errMessage(error));
   }
   return {
     role: requiredString(value.role, "agent.role"),