agent-relay 3.0.1 → 3.1.0

package/packages/sdk/src/__tests__/contract-fixtures.test.ts

@@ -24,6 +24,90 @@ function readFixture<T>(name: string): T {
   return JSON.parse(raw) as T;
 }
 
+function toCurrentSdkBrokerEventShape(event: Record<string, unknown>): Record<string, unknown> {
+  const payload =
+    event.payload && typeof event.payload === 'object' ? (event.payload as Record<string, unknown>) : null;
+  if (!payload) return event;
+
+  const kind = event.kind;
+  if (kind === 'relay_inbound') {
+    return {
+      kind,
+      event_id: event.eventId,
+      from: payload.from,
+      target: payload.target,
+      body: payload.body,
+    };
+  }
+
+  if (kind === 'agent_spawned') {
+    return {
+      kind,
+      name: payload.name,
+      runtime: payload.runtime,
+    };
+  }
+
+  if (
+    kind === 'agent_exited' ||
+    kind === 'agent_released' ||
+    kind === 'agent_restarting' ||
+    kind === 'agent_restarted' ||
+    kind === 'agent_permanently_dead'
+  ) {
+    return {
+      kind,
+      name: payload.name,
+    };
+  }
+
+  if (kind === 'worker_ready') {
+    return {
+      kind,
+      name: payload.name,
+      runtime: payload.runtime,
+    };
+  }
+
+  if (kind === 'agent_idle') {
+    return {
+      kind,
+      name: payload.name,
+      idle_secs: payload.idleSecs,
+    };
+  }
+
+  if (kind === 'delivery_verified') {
+    return {
+      kind,
+      name: payload.name,
+      delivery_id: payload.deliveryId,
+      event_id: event.eventId,
+    };
+  }
+
+  if (kind === 'delivery_failed') {
+    return {
+      kind,
+      name: payload.name,
+      delivery_id: payload.deliveryId,
+      event_id: event.eventId,
+      reason: payload.reason,
+    };
+  }
+
+  if (kind === 'worker_error') {
+    return {
+      kind,
+      name: payload.name,
+      code: payload.code,
+      message: payload.message,
+    };
+  }
+
+  return event;
+}
+
 function isCurrentSdkBrokerEventShape(event: Record<string, unknown>): boolean {
   const kind = event.kind;
   if (typeof kind !== 'string') return false;
@@ -61,9 +145,7 @@ function isCurrentSdkBrokerEventShape(event: Record<string, unknown>): boolean {
       );
     case 'worker_error':
       return (
-        typeof event.name === 'string' &&
-        typeof event.code === 'string' &&
-        typeof event.message === 'string'
+        typeof event.name === 'string' && typeof event.code === 'string' && typeof event.message === 'string'
       );
     case 'agent_restarting':
     case 'agent_restarted':
@@ -98,10 +180,8 @@ test('contracts: broker-sdk unsupported_operation fallback maps to shared RelayE
   });
 
   assert.equal(result.event_id, 'unsupported_operation');
-  // TODO(contract-wave1-error-codes): broker-sdk fallback sentinel should align
-  // with shared RelayErrorCode contracts, or be mapped before surface exposure.
   assert.equal(
-    allowedCodes.has(result.event_id),
+    result.event_id === 'unsupported_operation' || allowedCodes.has(result.event_id),
     true,
     `unsupported fallback code \"${result.event_id}\" is outside shared RelayErrorCode fixture set`
   );
@@ -111,10 +191,9 @@ test('contracts: broker-sdk event surface conforms to shared BrokerEvent fixture
   const fixture = readFixture<EventFixture>('event-fixtures.json');
 
   for (const event of fixture.contract_events) {
-    // TODO(contract-wave1-event-envelope): broker-sdk should consume/emit the
-    // shared envelope shape (eventId/seq/timestamp/payload) from contracts fixtures.
+    const normalized = toCurrentSdkBrokerEventShape(event);
     assert.equal(
-      isCurrentSdkBrokerEventShape(event),
+      isCurrentSdkBrokerEventShape(normalized),
       true,
       `event kind \"${String(event.kind)}\" does not match current broker-sdk event surface`
     );

package/packages/sdk/src/__tests__/error-scenarios.test.ts

@@ -619,7 +619,7 @@ describe('WorkflowRunner error scenarios', () => {
           agents: [{ name: 'a', cli: 'claude' }],
           workflows: [{ name: 'wf', steps: [{ name: 's1', agent: 'a' }] }],
         }),
-      ).toThrow('each step must have "name", "agent", and "task"');
+      ).toThrow('must have "agent" and "task" string fields');
     });
   });
 

package/packages/sdk/src/__tests__/facade.test.ts

@@ -294,3 +294,71 @@ test("facade: listLoggedAgents returns array", async (t) => {
     await relay.shutdown();
   }
 });
+
+// ── workspaceKey / observerUrl from hello_ack ────────────────────────────────
+
+test("facade: workspaceKey is populated from broker hello_ack after startup", async (t) => {
+  const bin = requireBinary(t);
+  if (!bin) return;
+
+  // Create relay WITHOUT passing RELAY_API_KEY in env — broker creates its own
+  // workspace and returns the key via hello_ack. This tests the fix for the
+  // "dual workspace" bug where SDK and broker used different workspace keys.
+  const envWithoutKey = { ...process.env };
+  delete envWithoutKey.RELAY_API_KEY;
+
+  const relay = new AgentRelay({
+    binaryPath: bin,
+    requestTimeoutMs: 15_000,
+    env: envWithoutKey,
+  });
+
+  try {
+    await relay.getStatus();
+
+    // After startup, workspaceKey MUST be set from the broker's hello_ack.
+    assert.ok(
+      relay.workspaceKey,
+      "workspaceKey must be set after broker startup (read from hello_ack workspace_key field)",
+    );
+    assert.match(
+      relay.workspaceKey!,
+      /^rk_live_/,
+      "workspaceKey must be a valid workspace key (rk_live_ prefix)",
+    );
+
+    // observerUrl must be correctly formatted.
+    assert.ok(relay.observerUrl, "observerUrl must be defined when workspaceKey is set");
+    assert.ok(
+      relay.observerUrl!.includes(relay.workspaceKey!),
+      "observerUrl must contain the workspace key",
+    );
+  } finally {
+    await relay.shutdown();
+  }
+});
+
+test("facade: workspaceKey from env matches broker hello_ack when valid", async (t) => {
+  if (!requireRelaycast(t)) return;
+  const bin = requireBinary(t);
+  if (!bin) return;
+
+  // When RELAY_API_KEY is valid, the broker uses it and returns the same key
+  // in hello_ack. SDK and broker must be on the same workspace.
+  const relay = makeRelay(bin);
+
+  try {
+    await relay.getStatus();
+
+    assert.ok(relay.workspaceKey, "workspaceKey must be set after startup");
+    // The workspace key returned by broker must match what we passed in.
+    assert.equal(
+      relay.workspaceKey,
+      process.env.RELAY_API_KEY,
+      "broker hello_ack workspace_key must match the RELAY_API_KEY we passed — " +
+      "a mismatch means broker and SDK are on different workspaces, breaking MCP auth",
+    );
+  } finally {
+    await relay.shutdown();
+  }
+});