agent-relay 10.6.6 → 11.0.0

package/dist/index.cjs

@@ -159,14 +159,20 @@ var require_umd = __commonJS({
 // dist/index.js
 var index_exports = {};
 __export(index_exports, {
+  AGENT_ACTIVITIES: () => AGENT_ACTIVITIES,
+  AGENT_EVENT_FAMILIES: () => AGENT_EVENT_FAMILIES,
   ActionNotFoundError: () => ActionNotFoundError,
   ActionPredicate: () => ActionPredicate,
   ActionRegistrationError: () => ActionRegistrationError,
   ActionRegistry: () => ActionRegistry,
   ActionValidationError: () => ActionValidationError,
+  ActivityPredicate: () => ActivityPredicate,
   AgentRelay: () => AgentRelay,
   DeliveryRunner: () => DeliveryRunner,
   ERROR_SEARCH_HINT: () => ERROR_SEARCH_HINT,
+  EXACT_AND_INFERRED_OBSERVABILITY: () => EXACT_AND_INFERRED_OBSERVABILITY,
+  EXACT_OBSERVABILITY: () => EXACT_OBSERVABILITY,
+  INFERRED_OBSERVABILITY: () => INFERRED_OBSERVABILITY,
   INVALID_AGENT_TOKEN_CODE: () => INVALID_AGENT_TOKEN_CODE,
   INVALID_AGENT_TOKEN_MESSAGE: () => INVALID_AGENT_TOKEN_MESSAGE,
   InMemoryAgentRelayActions: () => InMemoryAgentRelayActions,
@@ -174,6 +180,7 @@ __export(index_exports, {
   MessageCreatedPredicate: () => MessageCreatedPredicate,
   MessageReactedPredicate: () => MessageReactedPredicate,
   MessageReadPredicate: () => MessageReadPredicate,
+  OBSERVABILITY_UNAVAILABLE: () => OBSERVABILITY_UNAVAILABLE,
   RELAYCAST_SDK_VERSION: () => RELAYCAST_SDK_VERSION,
   RelayCapabilityError: () => RelayCapabilityError,
   RelayError: () => RelayError,
@@ -195,8 +202,10 @@ __export(index_exports, {
   checkForUpdatesInBackground: () => checkForUpdatesInBackground,
   commandExists: () => commandExists,
   connectionLog: () => connectionLog,
+  createAgentActivityState: () => createAgentActivityState,
   createAgentClient: () => createAgentClient,
   createAgentHandle: () => createAgentHandle,
+  createAgentObservabilityCapabilities: () => createAgentObservabilityCapabilities,
   createEnrichedEvents: () => createEnrichedEvents,
   createEnrichedMessages: () => createEnrichedMessages,
   createEventFanIn: () => createEventFanIn,
@@ -264,6 +273,7 @@ __export(index_exports, {
   normalizeThread: () => normalizeThread,
   parseGitRemoteUrl: () => parseGitRemoteUrl,
   printUpdateNotification: () => printUpdateNotification,
+  reduceAgentActivity: () => reduceAgentActivity,
   registerFacadeAction: () => registerFacadeAction,
   resetPatternMetrics: () => resetPatternMetrics,
   resolveAgentName: () => resolveAgentName,
@@ -49398,6 +49408,21 @@ var RelaycastMessagingClient = class {
       return presence.map(normalizeAgentPresence);
     }
   };
+  sessionEvents = {
+    emit: async (agentName, event) => {
+      const events = this.relaycast.agents.events;
+      if (!events)
+        throw new Error("Relaycast agent session events API is unavailable.");
+      const { type, ...payload } = event;
+      return events.emit(agentName, { type, payload });
+    },
+    list: async (agentName, options) => {
+      const events = this.relaycast.agents.events;
+      if (!events)
+        throw new Error("Relaycast agent session events API is unavailable.");
+      return events.list(agentName, options);
+    }
+  };
   channels = {
     list: async (options) => {
       const channels = await this.relaycast.channels.list(definedOptions({ includeArchived: options?.includeArchived }));
@@ -50336,6 +50361,27 @@ var StatusPredicate = class {
     });
   }
 };
+var ActivityPredicate = class {
+  agentId;
+  activity;
+  constructor(agentId, activity) {
+    this.agentId = agentId;
+    this.activity = activity;
+  }
+  subscribe(context, handler) {
+    const report = makeReporter(context, {
+      source: "listener",
+      selector: `agent.activity.${this.activity}`
+    });
+    return context.onSessionEvent(({ agentId, event }) => {
+      if (agentId !== this.agentId)
+        return;
+      if (event.type !== "activity.changed" || event.activity !== this.activity)
+        return;
+      runHandler(handler, event, report);
+    });
+  }
+};
 var ToolCalledPredicate = class {
   agentId;
   tool;
@@ -50423,6 +50469,23 @@ function toPublicSessionEvent(agentId, event) {
       ..."reason" in event && event.reason ? { reason: event.reason } : {}
     };
   }
+  if (event.type === "activity.changed") {
+    const { observability } = event;
+    return {
+      type: "agent.activity.changed",
+      agentId,
+      activity: event.activity,
+      previousActivity: event.previousActivity,
+      reason: event.reason,
+      ...observability.turnId ? { turnId: observability.turnId } : {},
+      sequence: observability.sequence,
+      timestamp: observability.timestamp,
+      source: observability.source,
+      fidelity: observability.fidelity,
+      ...event.tool ? { tool: event.tool } : {},
+      ...event.approval ? { approval: event.approval } : {}
+    };
+  }
   return { type: event.type, agentId, event };
 }
 function matchesSelector(selector, type) {
@@ -50523,6 +50586,9 @@ function createAgentHandle(input) {
     status: {
       becomes: (status) => new StatusPredicate(input.id, status)
     },
+    activity: {
+      becomes: (activity) => new ActivityPredicate(input.id, activity)
+    },
     tools: {
       called: (tool) => new ToolCalledPredicate(input.id, tool)
     }
@@ -50976,6 +51042,18 @@ var AgentRelay = class _AgentRelay {
   emitSessionEvent(agentId, event) {
     this.listenerHub.emitSessionEvent(agentId, event);
   }
+  async publishSessionEvent(agentId, event) {
+    this.listenerHub.emitSessionEvent(agentId, event);
+    try {
+      await this.messaging.sessionEvents?.emit(agentId, event);
+    } catch (error151) {
+      this.reportError(error151, {
+        source: "listener",
+        selector: event.type,
+        operation: "publish_session_event"
+      });
+    }
+  }
   messagingForToken(token) {
     let client = this.clientsByToken.get(token);
     if (!client) {
@@ -51023,7 +51101,11 @@ function agentRelayAgent(messaging, actions, handlerAgent, options) {
     once: ((selector, handler) => hub.once(selector, handler)),
     action: (name) => hub.action(name),
     agent: (input) => hub.agent(input),
-    emitSessionEvent: (agentId, event) => hub.emitSessionEvent(agentId, event)
+    emitSessionEvent: (agentId, event) => hub.emitSessionEvent(agentId, event),
+    publishSessionEvent: async (agentId, event) => {
+      hub.emitSessionEvent(agentId, event);
+      await messaging.sessionEvents?.emit(agentId, event);
+    }
   };
 }
 function assembleAgentClient(messaging, actions, identity, options) {
@@ -51224,6 +51306,52 @@ function dateToString(input) {
 }
 
 // ../sdk/dist/session/types.js
+var OBSERVABILITY_UNAVAILABLE = { available: false };
+var EXACT_OBSERVABILITY = {
+  available: true,
+  fidelities: ["exact"]
+};
+var INFERRED_OBSERVABILITY = {
+  available: true,
+  fidelities: ["inferred"]
+};
+var EXACT_AND_INFERRED_OBSERVABILITY = {
+  available: true,
+  fidelities: ["exact", "inferred"]
+};
+var AGENT_ACTIVITIES = [
+  "starting",
+  "thinking",
+  "typing",
+  "using_tool",
+  "waiting",
+  "idle",
+  "error"
+];
+var AGENT_EVENT_FAMILIES = [
+  "lifecycle",
+  "turns",
+  "text",
+  "reasoning",
+  "tools",
+  "tool_approvals",
+  "files",
+  "compaction",
+  "model",
+  "warnings",
+  "usage",
+  "diagnostics",
+  "errors"
+];
+function createAgentObservabilityCapabilities(input) {
+  return {
+    activities: Object.fromEntries(AGENT_ACTIVITIES.map((activity) => [
+      activity,
+      input.activities?.[activity] ?? OBSERVABILITY_UNAVAILABLE
+    ])),
+    events: Object.fromEntries(AGENT_EVENT_FAMILIES.map((family) => [family, input.events?.[family] ?? OBSERVABILITY_UNAVAILABLE]))
+  };
+}
 var MINIMAL_AGENT_SESSION_CAPABILITIES = {
   messaging: { receive: true },
   delivery: { modes: ["immediate"] },
@@ -51231,6 +51359,206 @@ var MINIMAL_AGENT_SESSION_CAPABILITIES = {
   lifecycle: { release: true }
 };
 
+// ../sdk/dist/session/activity-reducer.js
+function createAgentActivityState(activity = "idle") {
+  return {
+    activity,
+    starting: false,
+    turnActive: false,
+    turnFinished: false,
+    failed: activity === "error",
+    lastSequence: -1,
+    activeTextBlocks: /* @__PURE__ */ new Set(),
+    activeReasoningBlocks: /* @__PURE__ */ new Set(),
+    activeTools: /* @__PURE__ */ new Map(),
+    pendingApprovals: /* @__PURE__ */ new Map()
+  };
+}
+function cloneState(state) {
+  return {
+    activity: state.activity,
+    starting: state.starting,
+    ...state.turnId ? { turnId: state.turnId } : {},
+    turnActive: state.turnActive,
+    turnFinished: state.turnFinished,
+    failed: state.failed,
+    ...state.errorReason ? { errorReason: state.errorReason } : {},
+    ...state.waitingReason ? { waitingReason: state.waitingReason } : {},
+    lastSequence: state.lastSequence,
+    activeTextBlocks: new Set(state.activeTextBlocks),
+    activeReasoningBlocks: new Set(state.activeReasoningBlocks),
+    activeTools: new Map(state.activeTools),
+    pendingApprovals: new Map(state.pendingApprovals)
+  };
+}
+function clearTurnWork(state) {
+  state.activeTextBlocks.clear();
+  state.activeReasoningBlocks.clear();
+  state.activeTools.clear();
+  state.pendingApprovals.clear();
+}
+function toolKey(event) {
+  return event.callId ?? event.run ?? event.tool;
+}
+function completedToolKey(event) {
+  return event.callId ?? event.run ?? event.tool;
+}
+function newestValue(values) {
+  let newest;
+  for (const value of values.values())
+    newest = value;
+  return newest;
+}
+function deriveActivity(state) {
+  if (state.failed)
+    return { activity: "error", reason: state.errorReason ?? "runtime_error" };
+  const approval = newestValue(state.pendingApprovals);
+  if (approval)
+    return { activity: "waiting", reason: "tool_approval", approval };
+  if (state.waitingReason)
+    return { activity: "waiting", reason: state.waitingReason };
+  const tool = newestValue(state.activeTools);
+  if (tool)
+    return { activity: "using_tool", reason: "tool_call", tool };
+  if (state.activeTextBlocks.size > 0)
+    return { activity: "typing", reason: "text_output" };
+  if (state.activeReasoningBlocks.size > 0)
+    return { activity: "thinking", reason: "reasoning" };
+  if (state.starting)
+    return { activity: "starting", reason: "session_starting" };
+  if (state.turnActive) {
+    return { activity: "thinking", reason: "turn_processing", fidelity: "inferred" };
+  }
+  return { activity: "idle", reason: "settled" };
+}
+function observed(event) {
+  return event.observability;
+}
+function reduceAgentActivity(previous, event) {
+  const observation = observed(event);
+  if (!observation || event.type === "activity.changed")
+    return { state: previous };
+  if (observation.sequence <= previous.lastSequence)
+    return { state: previous };
+  const state = cloneState(previous);
+  state.lastSequence = observation.sequence;
+  switch (event.type) {
+    case "session.starting":
+      state.starting = true;
+      state.turnActive = false;
+      state.turnFinished = false;
+      state.failed = false;
+      state.errorReason = void 0;
+      state.waitingReason = void 0;
+      clearTurnWork(state);
+      break;
+    case "session.started":
+    case "session.resumed":
+      state.starting = false;
+      state.failed = false;
+      state.errorReason = void 0;
+      state.waitingReason = void 0;
+      break;
+    case "session.suspended":
+      state.starting = false;
+      state.waitingReason = event.reason;
+      break;
+    case "session.detached":
+    case "session.stopped":
+    case "session.destroyed":
+    case "session.released":
+      state.starting = false;
+      state.turnActive = false;
+      state.turnFinished = true;
+      state.waitingReason = void 0;
+      clearTurnWork(state);
+      break;
+    case "session.failed":
+      state.starting = false;
+      state.failed = true;
+      state.errorReason = event.code ?? event.error;
+      state.waitingReason = void 0;
+      break;
+    case "error":
+      state.starting = false;
+      state.failed = true;
+      state.errorReason = event.code ?? event.error;
+      state.waitingReason = void 0;
+      break;
+    case "turn.started":
+      state.turnId = event.turnId;
+      state.turnActive = true;
+      state.turnFinished = false;
+      state.failed = false;
+      state.errorReason = void 0;
+      state.waitingReason = void 0;
+      clearTurnWork(state);
+      break;
+    case "text.started":
+    case "text.delta":
+      state.activeTextBlocks.add(event.blockId);
+      break;
+    case "text.finished":
+      state.activeTextBlocks.delete(event.blockId);
+      break;
+    case "reasoning.started":
+    case "reasoning.delta":
+      state.activeReasoningBlocks.add(event.blockId);
+      break;
+    case "reasoning.finished":
+      state.activeReasoningBlocks.delete(event.blockId);
+      break;
+    case "tool.called": {
+      const callId = toolKey(event);
+      state.activeTools.set(callId, { callId, name: event.tool });
+      break;
+    }
+    case "tool.completed":
+    case "tool.failed":
+      state.activeTools.delete(completedToolKey(event));
+      break;
+    case "tool.approval.requested":
+      state.pendingApprovals.set(event.approvalId, {
+        approvalId: event.approvalId,
+        ...event.callId ? { callId: event.callId } : {}
+      });
+      break;
+    case "tool.approval.resolved":
+      state.pendingApprovals.delete(event.approvalId);
+      break;
+    case "turn.finished":
+      state.turnFinished = true;
+      clearTurnWork(state);
+      break;
+    case "turn.settled":
+      state.turnFinished = true;
+      state.turnActive = false;
+      state.waitingReason = void 0;
+      clearTurnWork(state);
+      break;
+    default:
+      break;
+  }
+  const derived = deriveActivity(state);
+  if (derived.activity === previous.activity)
+    return { state };
+  state.activity = derived.activity;
+  const fidelity = derived.fidelity ?? observation.fidelity;
+  return {
+    state,
+    transition: {
+      type: "activity.changed",
+      activity: derived.activity,
+      previousActivity: previous.activity,
+      reason: derived.reason,
+      ...derived.tool ? { tool: derived.tool } : {},
+      ...derived.approval ? { approval: derived.approval } : {},
+      at: observation.timestamp,
+      observability: { ...observation, fidelity }
+    }
+  };
+}
+
 // ../sdk/dist/session/index.js
 var counters = /* @__PURE__ */ new Map();
 function nextHarnessName(base, explicit) {
@@ -52431,14 +52759,20 @@ function generateRequestId(prefix = "") {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AGENT_ACTIVITIES,
+  AGENT_EVENT_FAMILIES,
   ActionNotFoundError,
   ActionPredicate,
   ActionRegistrationError,
   ActionRegistry,
   ActionValidationError,
+  ActivityPredicate,
   AgentRelay,
   DeliveryRunner,
   ERROR_SEARCH_HINT,
+  EXACT_AND_INFERRED_OBSERVABILITY,
+  EXACT_OBSERVABILITY,
+  INFERRED_OBSERVABILITY,
   INVALID_AGENT_TOKEN_CODE,
   INVALID_AGENT_TOKEN_MESSAGE,
   InMemoryAgentRelayActions,
@@ -52446,6 +52780,7 @@ function generateRequestId(prefix = "") {
   MessageCreatedPredicate,
   MessageReactedPredicate,
   MessageReadPredicate,
+  OBSERVABILITY_UNAVAILABLE,
   RELAYCAST_SDK_VERSION,
   RelayCapabilityError,
   RelayError,
@@ -52467,8 +52802,10 @@ function generateRequestId(prefix = "") {
   checkForUpdatesInBackground,
   commandExists,
   connectionLog,
+  createAgentActivityState,
   createAgentClient,
   createAgentHandle,
+  createAgentObservabilityCapabilities,
   createEnrichedEvents,
   createEnrichedMessages,
   createEventFanIn,
@@ -52536,6 +52873,7 @@ function generateRequestId(prefix = "") {
   normalizeThread,
   parseGitRemoteUrl,
   printUpdateNotification,
+  reduceAgentActivity,
   registerFacadeAction,
   resetPatternMetrics,
   resolveAgentName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "10.6.6",
+  "version": "11.0.0",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.cjs",
@@ -43,12 +43,13 @@
     "pack:validate": "npm pack --dry-run"
   },
   "dependencies": {
-    "@agent-relay/cloud": "10.6.6",
-    "@agent-relay/config": "10.6.6",
-    "@agent-relay/fleet": "10.6.6",
-    "@agent-relay/harness-driver": "10.6.6",
-    "@agent-relay/sdk": "10.6.6",
-    "@agent-relay/utils": "10.6.6",
+    "@agent-relay/cloud": "11.0.0",
+    "@agent-relay/config": "11.0.0",
+    "@agent-relay/fleet": "11.0.0",
+    "@agent-relay/harness-driver": "11.0.0",
+    "@agent-relay/harnesses": "11.0.0",
+    "@agent-relay/sdk": "11.0.0",
+    "@agent-relay/utils": "11.0.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@relayfile/client": "^0.10.27",
     "@relayflows/cli": "^1.0.1",
@@ -67,7 +68,7 @@
     "esbuild": "^0.27.2"
   },
   "engines": {
-    "node": ">=20.9.0"
+    "node": ">=22.0.0"
   },
   "keywords": [
     "agent",