agent-relay 8.3.7 → 8.5.0

package/dist/index.cjs

@@ -175,11 +175,13 @@ __export(index_exports, {
   MessageReactedPredicate: () => MessageReactedPredicate,
   MessageReadPredicate: () => MessageReadPredicate,
   RelayCapabilityError: () => RelayCapabilityError,
+  RelayError: () => RelayError,
   RelaycastMessagingClient: () => RelaycastMessagingClient,
   StaticPatterns: () => StaticPatterns,
   StatusPredicate: () => StatusPredicate,
   ToolCalledPredicate: () => ToolCalledPredicate,
   TracedError: () => TracedError,
+  TypedActionPredicate: () => TypedActionPredicate,
   actionSchemaToJsonSchema: () => actionSchemaToJsonSchema,
   agentRelayAgent: () => agentRelayAgent,
   agentTokenRecoveryMessage: () => agentTokenRecoveryMessage,
@@ -201,6 +203,7 @@ __export(index_exports, {
   createRequestEnvelope: () => createRequestEnvelope,
   createRequestHandler: () => createRequestHandler,
   createTraceableError: () => createTraceableError,
+  createTypedActionHandle: () => createTypedActionHandle,
   createWorkspaceFacade: () => createWorkspaceFacade,
   defineHarness: () => defineHarness,
   findGitRoot: () => findGitRoot,
@@ -233,6 +236,7 @@ __export(index_exports, {
   isSpawnOrReleaseCommandFast: () => isSpawnOrReleaseCommandFast,
   isValidAgentName: () => isValidAgentName,
   logAndTraceError: () => logAndTraceError,
+  logRelayHandlerError: () => logRelayHandlerError,
   mapModelToCli: () => mapModelToCli,
   matchesSelector: () => matchesSelector,
   nextHarnessName: () => nextHarnessName,
@@ -246,8 +250,11 @@ __export(index_exports, {
   normalizeChannelMember: () => normalizeChannelMember,
   normalizeChannelName: () => normalizeChannelName,
   normalizeChannelReadStatus: () => normalizeChannelReadStatus,
+  normalizeDeliveryTransition: () => normalizeDeliveryTransition,
   normalizeGroupDirectConversation: () => normalizeGroupDirectConversation,
   normalizeInbox: () => normalizeInbox,
+  normalizeInboxItem: () => normalizeInboxItem,
+  normalizeInboxItemState: () => normalizeInboxItemState,
   normalizeMessage: () => normalizeMessage,
   normalizeMessagingEvent: () => normalizeMessagingEvent,
   normalizeReaction: () => normalizeReaction,
@@ -33211,6 +33218,74 @@ function normalizeChannelReadStatus(input) {
     ...lastReadAt ? { lastReadAt } : {}
   };
 }
+var INBOX_STATE_BY_DELIVERY_STATUS = {
+  accepted: "queued",
+  delivered: "delivered",
+  deferred: "deferred",
+  failed: "failed"
+};
+function normalizeInboxItemState(value) {
+  return (value !== void 0 ? INBOX_STATE_BY_DELIVERY_STATUS[value] : void 0) ?? "queued";
+}
+function normalizeDeliveryMetadata(record3) {
+  const metadata = {};
+  const mode = readString(record3, "mode");
+  const reason = readNullableString(record3, "reason");
+  const priority = readString(record3, "priority");
+  const retryable = readBoolean(record3, "retryable");
+  const error101 = readNullableString(record3, "error");
+  const deadline = readNullableString(record3, "deadline");
+  if (mode)
+    metadata.mode = mode;
+  if (reason)
+    metadata.reason = reason;
+  if (priority)
+    metadata.priority = priority;
+  if (retryable !== void 0)
+    metadata.retryable = retryable;
+  if (error101)
+    metadata.error = error101;
+  if (deadline)
+    metadata.deadline = deadline;
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function normalizeInboxItem(input, context = {}) {
+  const record3 = isRecord(input) ? input : {};
+  const messageId = readString(record3, "messageId", "message_id");
+  const channelId = readString(record3, "channelId", "channel_id");
+  const agentId = readString(record3, "agentId", "agent_id");
+  const availableAt = readNullableString(record3, "availableAt", "available_at");
+  const messageRecord = readRecord(record3, "message");
+  const metadata = normalizeDeliveryMetadata(record3);
+  return {
+    id: readString(record3, "id", "deliveryId", "delivery_id") ?? "",
+    recipient: {
+      name: context.recipientName ?? agentId ?? "",
+      ...agentId ? { id: agentId } : {}
+    },
+    state: normalizeInboxItemState(readString(record3, "status")),
+    // The relaycast ledger does not expose attempt counts.
+    attempts: 0,
+    ...availableAt ? { availableAt } : {},
+    message: normalizeMessage(messageRecord ?? {
+      ...messageId ? { id: messageId } : {},
+      ...channelId ? { channel_id: channelId } : {}
+    }),
+    ...metadata ? { metadata } : {}
+  };
+}
+function normalizeDeliveryTransition(action, input) {
+  const record3 = isRecord(input) ? input : {};
+  const availableAt = readNullableString(record3, "availableAt", "available_at");
+  return {
+    supported: true,
+    action,
+    deliveryId: readString(record3, "id", "deliveryId", "delivery_id") ?? "",
+    messageId: readString(record3, "messageId", "message_id") ?? "",
+    state: normalizeInboxItemState(readString(record3, "status")),
+    ...action === "defer" && availableAt ? { deferUntil: availableAt } : {}
+  };
+}
 function normalizeSearchResult(input) {
   const record3 = isRecord(input) ? input : {};
   const createdAt = readString(record3, "createdAt", "created_at");
@@ -33528,13 +33603,7 @@ function createRelaycastClient(options) {
   }));
 }
 var RelaycastMessagingClient = class {
-  capabilities = {
-    serverDeliveryState: false,
-    durableDelivery: false,
-    durableAck: false,
-    durableFail: false,
-    durableDefer: false
-  };
+  capabilities;
   relaycast;
   agentClient;
   eventHandlers = /* @__PURE__ */ new Map();
@@ -33542,6 +33611,14 @@ var RelaycastMessagingClient = class {
   constructor(options) {
     this.relaycast = createRelaycastClient(options);
     this.agentClient = options.agentClient ?? (options.agentToken ? this.relaycast.as?.(options.agentToken, options.agentClientOptions) : void 0);
+    const durable = this.deliverySurface() !== void 0;
+    this.capabilities = {
+      serverDeliveryState: durable,
+      durableDelivery: durable,
+      durableAck: durable,
+      durableFail: durable,
+      durableDefer: durable
+    };
   }
   agents = {
     list: async (options) => {
@@ -33550,6 +33627,7 @@ var RelaycastMessagingClient = class {
     },
     get: async (name) => normalizeAgent(await this.relaycast.agents.get(name)),
     register: async (input) => normalizeAgentRegistration(await this.relaycast.agents.register(input)),
+    registerOrRotate: async (input) => normalizeAgentRegistration(this.relaycast.agents.registerOrRotate ? await this.relaycast.agents.registerOrRotate(input) : await this.relaycast.agents.register(input)),
     me: async () => normalizeAgent(await this.requireAgentClient("agents.me").me()),
     update: async (name, input) => normalizeAgent(await this.relaycast.agents.update(name, input)),
     delete: async (name) => {
@@ -33676,12 +33754,55 @@ var RelaycastMessagingClient = class {
   };
   inbox = {
     get: async (options) => normalizeInbox(await this.requireAgentClient("inbox.get").inbox(definedOptions({ limit: options?.limit }))),
-    list: async (_input) => ({ items: [] }),
-    subscribe: (_input) => this.emptyInboxSubscription(),
-    ack: async (input) => this.unsupportedInboxDelivery("ack", input.inboxItemId),
-    fail: async (input) => this.unsupportedInboxDelivery("fail", input.inboxItemId, input.error),
-    defer: async (input) => this.unsupportedInboxDelivery("defer", input.inboxItemId, input.reason, input.availableAt),
-    markRead: async (input) => this.unsupportedInboxDelivery("ack", input.inboxItemId, "Inbox read state updates require server delivery state.")
+    /**
+     * List durable deliveries queued for the authenticated agent. The
+     * relaycast ledger replays non-terminal items (accepted + deferred) in
+     * FIFO order with the message payload embedded. The underlying API has no
+     * cursor, so `nextCursor` is never set and `before`/`after` are ignored.
+     */
+    list: async (input) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return { items: [] };
+      const deliveries = await surface.deliveries(definedOptions({ limit: input?.limit }));
+      return {
+        items: deliveries.map((delivery) => normalizeInboxItem(delivery, definedOptions({ recipientName: input?.agentName })))
+      };
+    },
+    /**
+     * Stream durable deliveries: seed from the non-terminal queue, then push
+     * items announced by `delivery.accepted` WebSocket events, deduplicated by
+     * delivery id. Falls back to an empty stream without an agent client.
+     */
+    subscribe: (input) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return this.emptyInboxSubscription();
+      return this.createInboxSubscription(surface, input);
+    },
+    ack: async (input) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return this.unsupportedInboxDelivery("ack", input.inboxItemId);
+      return normalizeDeliveryTransition("ack", await surface.ackDelivery(input.inboxItemId));
+    },
+    fail: async (input) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return this.unsupportedInboxDelivery("fail", input.inboxItemId, input.error);
+      return normalizeDeliveryTransition("fail", await surface.failDelivery(input.inboxItemId, definedOptions({ error: input.error, retryable: input.retry })));
+    },
+    defer: async (input) => {
+      const surface = this.deliverySurface();
+      if (!surface) {
+        return this.unsupportedInboxDelivery("defer", input.inboxItemId, input.reason, input.availableAt);
+      }
+      return normalizeDeliveryTransition("defer", await surface.deferDelivery(input.inboxItemId, {
+        availableAt: input.availableAt,
+        ...input.reason === void 0 ? {} : { reason: input.reason }
+      }));
+    },
+    markRead: async (input) => this.unsupportedInboxDelivery("ack", input.inboxItemId, "The Relaycast delivery ledger has no read state; use inbox.ack to mark a delivery handled.")
   };
   events = {
     connect: () => {
@@ -33717,26 +33838,34 @@ var RelaycastMessagingClient = class {
     },
     on: (event, handler) => this.addEventListener(event, handler)
   };
+  /**
+   * Durable delivery transitions keyed by the relaycast delivery id (the
+   * `InboxItem.id` returned by `inbox.list`/`inbox.subscribe`). Transitions
+   * are idempotent on the server.
+   */
   deliveries = {
-    ack: async (messageId) => ({
-      supported: false,
-      action: "ack",
-      messageId,
-      reason: "Durable acknowledgements are not supported by the Relaycast messaging backend yet."
-    }),
-    fail: async (messageId, reason) => ({
-      supported: false,
-      action: "fail",
-      messageId,
-      ...reason ? { reason } : { reason: "Durable failure reporting is not supported by the Relaycast messaging backend yet." }
-    }),
-    defer: async (messageId, deferUntil) => ({
-      supported: false,
-      action: "defer",
-      messageId,
-      ...deferUntil ? { deferUntil } : {},
-      reason: "Durable deferral is not supported by the Relaycast messaging backend yet."
-    })
+    ack: async (deliveryId) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return this.unsupportedInboxDelivery("ack", deliveryId);
+      return normalizeDeliveryTransition("ack", await surface.ackDelivery(deliveryId));
+    },
+    fail: async (deliveryId, reason) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return this.unsupportedInboxDelivery("fail", deliveryId, reason);
+      return normalizeDeliveryTransition("fail", await surface.failDelivery(deliveryId, definedOptions({ error: reason })));
+    },
+    defer: async (deliveryId, deferUntil) => {
+      const surface = this.deliverySurface();
+      if (!surface)
+        return this.unsupportedInboxDelivery("defer", deliveryId, void 0, deferUntil);
+      return normalizeDeliveryTransition("defer", await surface.deferDelivery(deliveryId, {
+        // The relaycast defer transition requires an explicit availability
+        // time; default to a short retry window when none is given.
+        availableAt: deferUntil ?? new Date(Date.now() + 3e4).toISOString()
+      }));
+    }
   };
   integrations = {
     webhooks: {
@@ -33833,6 +33962,83 @@ var RelaycastMessagingClient = class {
     }
     return this.relaycast.dmMessages;
   }
+  /**
+   * The durable delivery API of the agent client, when present. Requires an
+   * agent-scoped client built from `@relaycast/sdk` 2.5+ (or a compatible
+   * injected `agentClient`).
+   */
+  deliverySurface() {
+    const agent = this.agentClient;
+    if (!agent || typeof agent.deliveries !== "function" || typeof agent.ackDelivery !== "function" || typeof agent.failDelivery !== "function" || typeof agent.deferDelivery !== "function") {
+      return void 0;
+    }
+    return agent;
+  }
+  async *createInboxSubscription(agent, input) {
+    const signal = input?.signal;
+    if (signal?.aborted)
+      return;
+    const recipient = definedOptions({ recipientName: input?.agentName });
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [];
+    let stopped = false;
+    let notify;
+    const wake = () => {
+      const resolve2 = notify;
+      notify = void 0;
+      resolve2?.();
+    };
+    const push = (item) => {
+      if (!item.id || seen.has(item.id))
+        return;
+      seen.add(item.id);
+      queue.push(item);
+      wake();
+    };
+    const stop = () => {
+      stopped = true;
+      wake();
+    };
+    const inFlight = /* @__PURE__ */ new Set();
+    agent.connect();
+    const unsubscribe = agent.on.any((event) => {
+      const record3 = asRecord(event);
+      if (record3.type !== "delivery.accepted")
+        return;
+      const deliveryId = readStr(record3, "deliveryId", "delivery_id");
+      if (!deliveryId || seen.has(deliveryId) || inFlight.has(deliveryId))
+        return;
+      inFlight.add(deliveryId);
+      void agent.deliveries().then((deliveries) => {
+        const match = deliveries.find((raw) => readStr(asRecord(raw), "id") === deliveryId);
+        if (match)
+          push(normalizeInboxItem(match, recipient));
+      }).catch(() => {
+      }).finally(() => {
+        inFlight.delete(deliveryId);
+      });
+    });
+    signal?.addEventListener("abort", stop, { once: true });
+    try {
+      for (const raw of await agent.deliveries()) {
+        push(normalizeInboxItem(raw, recipient));
+      }
+      while (!stopped) {
+        const next = queue.shift();
+        if (next) {
+          yield next;
+          continue;
+        }
+        await new Promise((resolve2) => {
+          notify = resolve2;
+        });
+      }
+    } finally {
+      stopped = true;
+      unsubscribe();
+      signal?.removeEventListener("abort", stop);
+    }
+  }
   async *emptyInboxSubscription() {
     return;
   }
@@ -33842,7 +34048,7 @@ var RelaycastMessagingClient = class {
       action,
       messageId,
       ...reason ? { reason } : {
-        reason: "Relaycast messaging does not expose durable inbox delivery state in this SDK surface yet."
+        reason: "Durable delivery transitions require an agent-scoped client with the Relaycast delivery API."
       },
       ...deferUntil ? { deferUntil } : {}
     };
@@ -33895,270 +34101,38 @@ var RelaycastMessagingClient = class {
   }
 };
 
-// ../sdk/dist/facade.js
-function resolveAgentName(ref) {
-  if (typeof ref === "string")
-    return stripSigil(ref);
-  const value = ref.handle ?? ref.name ?? ref.id;
-  if (!value) {
-    throw new Error("Unable to resolve agent name: reference has no name, handle, or id.");
-  }
-  return stripSigil(value);
-}
-function resolveAgentToken(ref) {
-  return ref && typeof ref !== "string" ? ref.token : void 0;
+// ../sdk/dist/listeners.js
+function logRelayHandlerError(error101, context) {
+  const where = context.action ? `action "${context.action}"` : `"${context.selector ?? "unknown"}"`;
+  console.warn(`[agent-relay] ${context.source} handler for ${where} threw:`, error101);
 }
 function stripSigil(value) {
   return value.startsWith("@") || value.startsWith("#") ? value.slice(1) : value;
 }
-function isChannelTarget(to) {
-  return to.startsWith("#");
-}
-function deliveryToMode(delivery) {
-  if (!delivery)
-    return void 0;
-  return delivery === "immediate" || delivery === "next-tool-call" ? "steer" : "wait";
-}
-function buildText(text, mentions) {
-  let body = text ?? "";
-  if (mentions?.length) {
-    const handles = mentions.map((mention) => `@${resolveAgentName(mention)}`);
-    const missing = handles.filter((handle) => !body.includes(handle));
-    if (missing.length) {
-      body = body ? `${missing.join(" ")} ${body}` : missing.join(" ");
-    }
-  }
-  return body;
-}
-function resolveMessageId(ref) {
-  if (!ref) {
-    throw new Error("reply requires a `messageId` or `thread`.");
-  }
-  if (typeof ref === "string")
-    return ref;
-  const value = ref.id ?? ref.threadId;
-  if (!value) {
-    throw new Error("Unable to resolve a message id from the provided thread reference.");
-  }
-  return value;
-}
-function createEnrichedMessages(base, resolveFrom) {
-  const enriched = Object.create(base);
-  enriched.send = async (input) => {
-    if ("channel" in input && input.channel) {
-      return base.send(input);
-    }
-    const sendInput = input;
-    const messages = resolveFrom(sendInput.from);
-    const text = buildText(sendInput.text ?? sendInput.msg, sendInput.mentions);
-    if (Array.isArray(sendInput.to)) {
-      return messages.groupDirect({
-        participants: sendInput.to.map(resolveAgentName),
-        text,
-        attachments: sendInput.attachments,
-        mode: sendInput.mode,
-        idempotencyKey: sendInput.idempotencyKey
-      });
-    }
-    if (isChannelTarget(sendInput.to)) {
-      return messages.send({
-        channel: stripSigil(sendInput.to),
-        text,
-        blocks: sendInput.blocks,
-        attachments: sendInput.attachments,
-        mode: sendInput.mode,
-        idempotencyKey: sendInput.idempotencyKey
-      });
-    }
-    return messages.direct({
-      to: resolveAgentName(sendInput.to),
-      text,
-      attachments: sendInput.attachments,
-      mode: sendInput.mode,
-      idempotencyKey: sendInput.idempotencyKey
-    });
-  };
-  enriched.reply = async (input) => {
-    const messages = resolveFrom(input.from);
-    return messages.reply({
-      messageId: resolveMessageId(input.messageId ?? input.thread),
-      text: input.text,
-      blocks: input.blocks,
-      idempotencyKey: input.idempotencyKey
-    });
-  };
-  enriched.react = (async (arg1, arg2) => {
-    if (typeof arg1 === "string") {
-      return base.react(arg1, arg2);
-    }
-    const messageId = typeof arg1.message === "string" ? arg1.message : arg1.message.id;
-    const messages = resolveFrom(arg1.agent);
-    return messages.react(messageId, arg1.emoji);
-  });
-  enriched.dm = async (input) => {
-    const messages = resolveFrom(input.from);
-    return messages.direct({
-      to: resolveAgentName(input.to),
-      text: input.text ?? input.msg ?? "",
-      attachments: input.attachments,
-      mode: input.mode,
-      idempotencyKey: input.idempotencyKey
-    });
-  };
-  return enriched;
-}
-function createWorkspaceFacade(messaging, deps) {
-  const register = async (agents) => {
-    if (!deps) {
-      throw new Error("register() is only available on the workspace client.");
-    }
-    const list = Array.isArray(agents) ? agents : [agents];
-    const inputs = list.map((agent) => typeof agent === "string" ? { name: stripSigil(agent) } : {
-      name: resolveAgentName(agent),
-      type: agent.type,
-      persona: agent.persona,
-      metadata: agent.metadata
-    });
-    const seen = /* @__PURE__ */ new Set();
-    for (const { name } of inputs) {
-      if (seen.has(name)) {
-        throw new Error(`Duplicate agent name in register(): "${name}".`);
-      }
-      seen.add(name);
-    }
-    const clients = [];
-    for (const input of inputs) {
-      clients.push(deps.buildAgentClient(await messaging.agents.register(input)));
-    }
-    return Array.isArray(agents) ? clients : clients[0];
-  };
-  return {
-    info: () => messaging.workspace.info(),
-    register,
-    reconnect: async ({ apiToken }) => {
-      if (!deps) {
-        throw new Error("reconnect() is only available on the workspace client.");
-      }
-      return deps.reconnectAgent(apiToken);
-    }
-  };
-}
-function registerFacadeAction(actions, def, wiring) {
-  const allowed = def.availableTo?.map(resolveAgentName);
-  const policy = allowed || def.policy ? async (input, ctx) => {
-    if (allowed && !allowed.includes(ctx.caller.name)) {
-      return {
-        allowed: false,
-        reason: `${ctx.caller.name} is not permitted to call ${def.name}.`
-      };
-    }
-    return def.policy ? def.policy(input, ctx) : { allowed: true };
-  } : void 0;
-  const localHandle = actions.register({
-    name: def.name,
-    description: def.description,
-    input: def.input,
-    inputSchema: def.inputSchema,
-    output: def.output,
-    outputSchema: def.outputSchema,
-    visibility: def.visibility,
-    policy,
-    handler: (input, ctx) => def.handler({ input, agent: ctx.caller, ctx })
-  });
-  const relayUnsubscribe = wireRelayAction(actions, def, wiring, allowed);
-  if (!relayUnsubscribe) {
-    return localHandle;
-  }
-  return {
-    unregister: () => {
-      relayUnsubscribe();
-      localHandle.unregister();
-    }
-  };
-}
-function wireRelayAction(actions, def, wiring, allowed) {
-  const commands = wiring?.messaging.commands;
-  if (!wiring || !commands?.agentScoped?.() || !commands.available?.()) {
-    return void 0;
-  }
-  const handlerAgent = wiring.handlerAgent;
-  if (!handlerAgent) {
-    return void 0;
-  }
-  void commands.register({
-    command: def.name,
-    description: def.description ?? def.name,
-    handlerAgent,
-    inputSchema: actionSchemaToJsonSchema(def.inputSchema ?? def.input),
-    outputSchema: actionSchemaToJsonSchema(def.outputSchema ?? def.output),
-    ...allowed ? { availableTo: allowed } : {}
-  }).catch((error101) => {
-    console.error(`[agent-relay] failed to register action descriptor "${def.name}":`, error101);
-  });
-  const unsubscribe = wiring.messaging.events.on("actionInvoked", async (event) => {
-    if (event.actionName !== def.name) {
-      return;
-    }
-    await handleActionInvoked(actions, commands, def.name, event);
-  });
-  try {
-    wiring.messaging.events.connect();
-  } catch (error101) {
-    console.error(`[agent-relay] failed to open the event stream for action "${def.name}":`, error101);
-  }
-  return unsubscribe;
-}
-async function handleActionInvoked(actions, commands, actionName, event) {
-  let input = {};
-  try {
-    const invocation = await commands.getInvocation(actionName, event.invocationId);
-    input = invocation.input ?? {};
-  } catch (error101) {
-    console.error(`[agent-relay] failed to load invocation "${event.invocationId}":`, error101);
-  }
-  const result = await actions.invoke({
-    name: actionName,
-    input,
-    caller: { name: event.callerName, type: "agent" }
-  });
+function runHandler(handler, event, report) {
   try {
-    await commands.completeInvocation(actionName, event.invocationId, result.ok ? { output: toOutputRecord(result.output) } : { error: result.error?.message ?? "handler failed" });
+    void Promise.resolve(handler(event)).catch(report);
   } catch (error101) {
-    console.error(`[agent-relay] failed to complete invocation "${event.invocationId}":`, error101);
+    report(error101);
   }
 }
-function toOutputRecord(output) {
-  if (output !== null && typeof output === "object" && !Array.isArray(output)) {
-    return output;
-  }
-  return { value: output };
-}
-function createNotifyHandler(messages, target, options) {
-  return async () => {
-    const subject = options.subject ? `@${resolveAgentName(options.subject)}` : void 0;
-    const label = options.type ?? options.action ?? "notification";
-    const text = options.text ?? [`[${label}]`, subject].filter(Boolean).join(" ");
-    await messages.dm({
-      to: resolveAgentName(target),
-      text,
-      mode: deliveryToMode(options.delivery)
-    });
+function makeReporter(context, info) {
+  return (error101) => {
+    if (!context.onError) {
+      logRelayHandlerError(error101, info);
+      return;
+    }
+    try {
+      context.onError(error101, info);
+    } catch {
+    }
   };
 }
-
-// ../sdk/dist/listeners.js
-function stripSigil2(value) {
-  return value.startsWith("@") || value.startsWith("#") ? value.slice(1) : value;
-}
-function runHandler(handler, event) {
-  void Promise.resolve(handler(event)).catch(() => {
-  });
-}
 var MessageCreatedPredicate = class {
   channel;
   mentioned;
   in(channel) {
-    this.channel = stripSigil2(channel);
+    this.channel = stripSigil(channel);
     return this;
   }
   mentions(agent) {
@@ -34166,30 +34140,33 @@ var MessageCreatedPredicate = class {
     return this;
   }
   subscribe(context, handler) {
+    const report = makeReporter(context, { source: "listener", selector: "message.created" });
     return context.events.on("messageCreated", (event) => {
-      if (this.channel && stripSigil2(event.channel) !== this.channel)
+      if (this.channel && stripSigil(event.channel) !== this.channel)
         return;
       if (this.mentioned && !messageMentions(event, this.mentioned))
         return;
-      runHandler(handler, event);
+      runHandler(handler, event, report);
     });
   }
 };
 function messageMentions(event, name) {
   const mentions = event.message.mentions ?? [];
-  if (mentions.some((mention) => stripSigil2(mention) === name))
+  if (mentions.some((mention) => stripSigil(mention) === name))
     return true;
   return event.message.text?.includes(`@${name}`) ?? false;
 }
 var MessageReadPredicate = class {
   subscribe(context, handler) {
-    return context.events.on("messageRead", (event) => runHandler(handler, event));
+    const report = makeReporter(context, { source: "listener", selector: "message.read" });
+    return context.events.on("messageRead", (event) => runHandler(handler, event, report));
   }
 };
 var MessageReactedPredicate = class {
   subscribe(context, handler) {
-    const off1 = context.events.on("reactionAdded", (event) => runHandler(handler, event));
-    const off2 = context.events.on("reactionRemoved", (event) => runHandler(handler, event));
+    const report = makeReporter(context, { source: "listener", selector: "message.reacted" });
+    const off1 = context.events.on("reactionAdded", (event) => runHandler(handler, event, report));
+    const off2 = context.events.on("reactionRemoved", (event) => runHandler(handler, event, report));
     return () => {
       off1();
       off2();
@@ -34229,6 +34206,11 @@ var ActionPredicate = class {
     return this;
   }
   subscribe(context, handler) {
+    const report = makeReporter(context, {
+      source: "listener",
+      selector: this.phase,
+      action: this.action
+    });
     return context.onActionEvent((event) => {
       if (event.action !== this.action)
         return;
@@ -34236,10 +34218,61 @@ var ActionPredicate = class {
         return;
       if (this.caller && event.caller.name !== this.caller)
         return;
-      runHandler(handler, event);
+      runHandler(handler, event, report);
     });
   }
 };
+var TypedActionPredicate = class {
+  action;
+  phase;
+  caller;
+  constructor(action, phase) {
+    this.action = action;
+    this.phase = phase;
+  }
+  calledBy(agent) {
+    this.caller = resolveAgentName(agent);
+    return this;
+  }
+  subscribe(context, handler) {
+    const report = makeReporter(context, {
+      source: "listener",
+      selector: this.phase,
+      action: this.action
+    });
+    return context.onActionEvent((event) => {
+      if (event.action !== this.action)
+        return;
+      if (event.type !== this.phase)
+        return;
+      if (this.caller && event.caller.name !== this.caller)
+        return;
+      runHandler(handler, toTypedActionEvent(event), report);
+    });
+  }
+};
+function toTypedActionEvent(raw) {
+  return {
+    type: raw.type,
+    action: raw.action,
+    agent: raw.caller,
+    ...raw.input !== void 0 ? { input: raw.input } : {},
+    ...raw.output !== void 0 ? { output: raw.output } : {},
+    ...raw.error !== void 0 ? { error: raw.error } : {},
+    ...raw.reason !== void 0 ? { reason: raw.reason } : {},
+    at: raw.at
+  };
+}
+function createTypedActionHandle(name, unregister) {
+  return {
+    name,
+    unregister,
+    invoked: () => new TypedActionPredicate(name, "action.invoked"),
+    completed: () => new TypedActionPredicate(name, "action.completed"),
+    failed: () => new TypedActionPredicate(name, "action.failed"),
+    denied: () => new TypedActionPredicate(name, "action.denied")
+  };
+}
 var StatusPredicate = class {
   agentId;
   status;
@@ -34248,12 +34281,16 @@ var StatusPredicate = class {
     this.status = status;
   }
   subscribe(context, handler) {
+    const report = makeReporter(context, {
+      source: "listener",
+      selector: `agent.status.${this.status}`
+    });
     return context.onSessionEvent(({ agentId, event }) => {
       if (agentId !== this.agentId)
         return;
       const matches = event.type === "status.changed" && event.status === this.status || event.type === `status.${this.status}`;
       if (matches)
-        runHandler(handler, event);
+        runHandler(handler, event, report);
     });
   }
 };
@@ -34270,6 +34307,7 @@ var ToolCalledPredicate = class {
     return this;
   }
   subscribe(context, handler) {
+    const report = makeReporter(context, { source: "listener", selector: `tool.called:${this.tool}` });
     return context.onSessionEvent(({ agentId, event }) => {
       if (agentId !== this.agentId)
         return;
@@ -34277,7 +34315,7 @@ var ToolCalledPredicate = class {
         return;
       if (this.filter && !this.filter(event))
         return;
-      runHandler(handler, event);
+      runHandler(handler, event, report);
     });
   }
 };
@@ -34289,7 +34327,7 @@ var PUBLIC_MESSAGE_TYPE = {
   groupDmReceived: "group_dm.received"
 };
 function buildEnvelope(message, channelName) {
-  const channel = message.channel ?? (channelName ? { name: stripSigil2(channelName) } : void 0);
+  const channel = message.channel ?? (channelName ? { name: stripSigil(channelName) } : void 0);
   return {
     ...message.from ? { from: message.from } : {},
     ...message.target ? { to: message.target } : {},
@@ -34352,7 +34390,7 @@ function matchesSelector(selector, type) {
     return type.startsWith(selector.slice(0, -1));
   return selector === type;
 }
-function createListenerHub(baseEvents, actions) {
+function createListenerHub(baseEvents, actions, options) {
   const sessionHandlers = /* @__PURE__ */ new Set();
   const events = createEnrichedEvents(baseEvents);
   const context = {
@@ -34362,7 +34400,8 @@ function createListenerHub(baseEvents, actions) {
     onSessionEvent: (handler) => {
       sessionHandlers.add(handler);
       return () => sessionHandlers.delete(handler);
-    }
+    },
+    ...options?.onError ? { onError: options.onError } : {}
   };
   const addListener = (selector, handler) => {
     try {
@@ -34372,29 +34411,49 @@ function createListenerHub(baseEvents, actions) {
     if (typeof selector !== "string") {
       return selector.subscribe(context, handler);
     }
+    const report = makeReporter(context, { source: "listener", selector });
     const offs = [
       context.events.on("any", (raw) => {
         const evt = toPublicMessagingEvent(raw);
         if (evt && matchesSelector(selector, evt.type))
-          runHandler(handler, evt);
+          runHandler(handler, evt, report);
       }),
       context.onActionEvent((raw) => {
         const evt = toPublicActionEvent(raw);
         if (matchesSelector(selector, evt.type))
-          runHandler(handler, evt);
+          runHandler(handler, evt, report);
       }),
       context.onSessionEvent(({ agentId, event }) => {
         const evt = toPublicSessionEvent(agentId, event);
         if (matchesSelector(selector, evt.type))
-          runHandler(handler, evt);
+          runHandler(handler, evt, report);
       })
     ];
     return () => offs.forEach((off) => off());
   };
+  const once = (selector, handler) => {
+    let done = false;
+    let off;
+    const wrapped = (event) => {
+      if (done)
+        return;
+      done = true;
+      off?.();
+      return handler(event);
+    };
+    off = addListener(selector, wrapped);
+    if (done)
+      off();
+    return () => {
+      done = true;
+      off?.();
+    };
+  };
   return {
     events,
     on: (predicate, handler) => predicate.subscribe(context, handler),
     addListener,
+    once,
     action: (name) => new ActionPredicate(name),
     agent: (input) => createAgentHandle(input),
     emitSessionEvent: (agentId, event) => {
@@ -34423,6 +34482,263 @@ function createAgentHandle(input) {
   };
 }
 
+// ../sdk/dist/facade.js
+function resolveAgentName(ref) {
+  if (typeof ref === "string")
+    return stripSigil2(ref);
+  const value = ref.handle ?? ref.name ?? ref.id;
+  if (!value) {
+    throw new Error("Unable to resolve agent name: reference has no name, handle, or id.");
+  }
+  return stripSigil2(value);
+}
+function resolveAgentToken(ref) {
+  return ref && typeof ref !== "string" ? ref.token : void 0;
+}
+function stripSigil2(value) {
+  return value.startsWith("@") || value.startsWith("#") ? value.slice(1) : value;
+}
+function isChannelTarget(to) {
+  return to.startsWith("#");
+}
+function deliveryToMode(delivery) {
+  if (!delivery)
+    return void 0;
+  return delivery === "immediate" || delivery === "next-tool-call" ? "steer" : "wait";
+}
+function buildText(text, mentions) {
+  let body = text ?? "";
+  if (mentions?.length) {
+    const handles = mentions.map((mention) => `@${resolveAgentName(mention)}`);
+    const missing = handles.filter((handle) => !body.includes(handle));
+    if (missing.length) {
+      body = body ? `${missing.join(" ")} ${body}` : missing.join(" ");
+    }
+  }
+  return body;
+}
+function resolveMessageId(ref) {
+  if (!ref) {
+    throw new Error("reply requires a `messageId` or `thread`.");
+  }
+  if (typeof ref === "string")
+    return ref;
+  const value = ref.id ?? ref.threadId;
+  if (!value) {
+    throw new Error("Unable to resolve a message id from the provided thread reference.");
+  }
+  return value;
+}
+function createEnrichedMessages(base, resolveFrom) {
+  const enriched = Object.create(base);
+  enriched.send = async (input) => {
+    if ("channel" in input && input.channel) {
+      return base.send(input);
+    }
+    const sendInput = input;
+    const messages = resolveFrom(sendInput.from);
+    const text = buildText(sendInput.text ?? sendInput.msg, sendInput.mentions);
+    if (Array.isArray(sendInput.to)) {
+      return messages.groupDirect({
+        participants: sendInput.to.map(resolveAgentName),
+        text,
+        attachments: sendInput.attachments,
+        mode: sendInput.mode,
+        idempotencyKey: sendInput.idempotencyKey
+      });
+    }
+    if (isChannelTarget(sendInput.to)) {
+      return messages.send({
+        channel: stripSigil2(sendInput.to),
+        text,
+        blocks: sendInput.blocks,
+        attachments: sendInput.attachments,
+        mode: sendInput.mode,
+        idempotencyKey: sendInput.idempotencyKey
+      });
+    }
+    return messages.direct({
+      to: resolveAgentName(sendInput.to),
+      text,
+      attachments: sendInput.attachments,
+      mode: sendInput.mode,
+      idempotencyKey: sendInput.idempotencyKey
+    });
+  };
+  enriched.reply = async (input) => {
+    const messages = resolveFrom(input.from);
+    return messages.reply({
+      messageId: resolveMessageId(input.messageId ?? input.thread),
+      text: input.text,
+      blocks: input.blocks,
+      idempotencyKey: input.idempotencyKey
+    });
+  };
+  enriched.react = (async (arg1, arg2) => {
+    if (typeof arg1 === "string") {
+      return base.react(arg1, arg2);
+    }
+    const messageId = typeof arg1.message === "string" ? arg1.message : arg1.message.id;
+    const messages = resolveFrom(arg1.agent);
+    return messages.react(messageId, arg1.emoji);
+  });
+  enriched.dm = async (input) => {
+    const messages = resolveFrom(input.from);
+    return messages.direct({
+      to: resolveAgentName(input.to),
+      text: input.text ?? input.msg ?? "",
+      attachments: input.attachments,
+      mode: input.mode,
+      idempotencyKey: input.idempotencyKey
+    });
+  };
+  return enriched;
+}
+function createWorkspaceFacade(messaging, deps) {
+  const register = async (agents, options) => {
+    if (!deps) {
+      throw new Error("register() is only available on the workspace client.");
+    }
+    const list = Array.isArray(agents) ? agents : [agents];
+    const inputs = list.map((agent) => typeof agent === "string" ? { name: stripSigil2(agent) } : {
+      name: resolveAgentName(agent),
+      type: agent.type,
+      persona: agent.persona,
+      metadata: agent.metadata
+    });
+    const seen = /* @__PURE__ */ new Set();
+    for (const { name } of inputs) {
+      if (seen.has(name)) {
+        throw new RelayError("name_conflict", `Duplicate agent name in register(): "${name}".`);
+      }
+      seen.add(name);
+    }
+    const registerOne = !options?.strict && messaging.agents.registerOrRotate ? messaging.agents.registerOrRotate.bind(messaging.agents) : messaging.agents.register.bind(messaging.agents);
+    const clients = [];
+    for (const input of inputs) {
+      clients.push(deps.buildAgentClient(await registerOne(input)));
+    }
+    return Array.isArray(agents) ? clients : clients[0];
+  };
+  return {
+    info: () => messaging.workspace.info(),
+    register,
+    reconnect: async ({ apiToken }) => {
+      if (!deps) {
+        throw new Error("reconnect() is only available on the workspace client.");
+      }
+      return deps.reconnectAgent(apiToken);
+    }
+  };
+}
+function reportActionError(wiring, action, operation, message, error101) {
+  if (wiring.onError) {
+    try {
+      wiring.onError(error101, { source: "action", action, operation });
+    } catch {
+    }
+    return;
+  }
+  console.error(`[agent-relay] ${message}`, error101);
+}
+function registerFacadeAction(actions, def, wiring) {
+  const allowed = def.availableTo?.map(resolveAgentName);
+  const policy = allowed || def.policy ? async (input, ctx) => {
+    if (allowed && !allowed.includes(ctx.caller.name)) {
+      return {
+        allowed: false,
+        reason: `${ctx.caller.name} is not permitted to call ${def.name}.`
+      };
+    }
+    return def.policy ? def.policy(input, ctx) : { allowed: true };
+  } : void 0;
+  const localHandle = actions.register({
+    name: def.name,
+    description: def.description,
+    input: def.input,
+    inputSchema: def.inputSchema,
+    output: def.output,
+    outputSchema: def.outputSchema,
+    visibility: def.visibility,
+    policy,
+    handler: (input, ctx) => def.handler({ input, agent: ctx.caller, ctx })
+  });
+  const relayUnsubscribe = wireRelayAction(actions, def, wiring, allowed);
+  return createTypedActionHandle(def.name, () => {
+    relayUnsubscribe?.();
+    localHandle.unregister();
+  });
+}
+function wireRelayAction(actions, def, wiring, allowed) {
+  const commands = wiring?.messaging.commands;
+  if (!wiring || !commands?.agentScoped?.() || !commands.available?.()) {
+    return void 0;
+  }
+  const handlerAgent = wiring.handlerAgent;
+  if (!handlerAgent) {
+    return void 0;
+  }
+  void commands.register({
+    command: def.name,
+    description: def.description ?? def.name,
+    handlerAgent,
+    inputSchema: actionSchemaToJsonSchema(def.inputSchema ?? def.input),
+    outputSchema: actionSchemaToJsonSchema(def.outputSchema ?? def.output),
+    ...allowed ? { availableTo: allowed } : {}
+  }).catch((error101) => {
+    reportActionError(wiring, def.name, "register", `failed to register action descriptor "${def.name}":`, error101);
+  });
+  const unsubscribe = wiring.messaging.events.on("actionInvoked", async (event) => {
+    if (event.actionName !== def.name) {
+      return;
+    }
+    await handleActionInvoked(actions, commands, def.name, event, wiring);
+  });
+  try {
+    wiring.messaging.events.connect();
+  } catch (error101) {
+    reportActionError(wiring, def.name, "connect", `failed to open the event stream for action "${def.name}":`, error101);
+  }
+  return unsubscribe;
+}
+async function handleActionInvoked(actions, commands, actionName, event, wiring) {
+  let input = {};
+  try {
+    const invocation = await commands.getInvocation(actionName, event.invocationId);
+    input = invocation.input ?? {};
+  } catch (error101) {
+    reportActionError(wiring, actionName, "load_invocation", `failed to load invocation "${event.invocationId}":`, error101);
+  }
+  const result = await actions.invoke({
+    name: actionName,
+    input,
+    caller: { name: event.callerName, type: "agent" }
+  });
+  try {
+    await commands.completeInvocation(actionName, event.invocationId, result.ok ? { output: toOutputRecord(result.output) } : { error: result.error?.message ?? "handler failed" });
+  } catch (error101) {
+    reportActionError(wiring, actionName, "complete_invocation", `failed to complete invocation "${event.invocationId}":`, error101);
+  }
+}
+function toOutputRecord(output) {
+  if (output !== null && typeof output === "object" && !Array.isArray(output)) {
+    return output;
+  }
+  return { value: output };
+}
+function createNotifyHandler(messages, target, options) {
+  return async () => {
+    const subject = options.subject ? `@${resolveAgentName(options.subject)}` : void 0;
+    const label = options.type ?? options.action ?? "notification";
+    const text = options.text ?? [`[${label}]`, subject].filter(Boolean).join(" ");
+    await messages.dm({
+      to: resolveAgentName(target),
+      text,
+      mode: deliveryToMode(options.delivery)
+    });
+  };
+}
+
 // ../sdk/dist/agent-relay.js
 var AgentRelay = class _AgentRelay {
   messaging;
@@ -34434,14 +34750,18 @@ var AgentRelay = class _AgentRelay {
   enrichedMessages;
   workspaceFacade;
   hub;
+  errorHooks = /* @__PURE__ */ new Set();
   constructor(options = {}) {
-    const { messaging, actions, workspaceKey, createAgentMessaging, ...messagingOptions } = options;
+    const { messaging, actions, workspaceKey, createAgentMessaging, onError, ...messagingOptions } = options;
     const resolvedWorkspaceKey = workspaceKey ?? messagingOptions.apiKey;
     this.workspaceKey = resolvedWorkspaceKey;
     this.messagingOptions = { ...messagingOptions, workspaceKey: resolvedWorkspaceKey };
     this.messaging = messaging ?? new RelaycastMessagingClient(this.messagingOptions);
     this.actions = actions ?? new ActionRegistry();
     this.createAgentMessaging = createAgentMessaging ?? ((token) => new RelaycastMessagingClient({ ...this.messagingOptions, agentToken: token }));
+    if (onError) {
+      this.errorHooks.add(onError);
+    }
   }
   static async createWorkspace(input) {
     const options = typeof input === "string" ? { name: input } : input;
@@ -34452,7 +34772,7 @@ var AgentRelay = class _AgentRelay {
     });
     const workspaceKey = extractWorkspaceKey(workspace);
     if (!workspaceKey) {
-      throw new Error("Workspace created, but the response did not include a workspace key.");
+      throw new RelayError("transport_error", "Workspace created, but the response did not include a workspace key.", { retryable: false });
     }
     return new _AgentRelay({
       workspaceKey,
@@ -34485,7 +34805,9 @@ var AgentRelay = class _AgentRelay {
   }
   get listenerHub() {
     if (!this.hub) {
-      this.hub = createListenerHub(this.messaging.events, this.actions);
+      this.hub = createListenerHub(this.messaging.events, this.actions, {
+        onError: (error101, context) => this.reportError(error101, context)
+      });
     }
     return this.hub;
   }
@@ -34516,7 +34838,7 @@ var AgentRelay = class _AgentRelay {
       id: registration.id,
       name: registration.name,
       token: registration.token
-    });
+    }, { onError: (error101, context) => this.reportError(error101, context) });
   }
   /** Rehydrate a live client from a persisted agent token, resolving identity from the relay. */
   async reconnectAgent(apiToken) {
@@ -34526,15 +34848,43 @@ var AgentRelay = class _AgentRelay {
       id: identity.id,
       name: identity.name,
       token: apiToken
-    });
+    }, { onError: (error101, context) => this.reportError(error101, context) });
   }
   registerAction(def) {
-    return registerFacadeAction(this.actions, def, { messaging: this.messaging });
+    return registerFacadeAction(this.actions, def, {
+      messaging: this.messaging,
+      onError: (error101, context) => this.reportError(error101, context)
+    });
   }
-  /** Subscribe by dotted event name, `'*'`/prefix wildcard, or a predicate. */
   addListener(selector, handler) {
     return this.listenerHub.addListener(selector, handler);
   }
+  once(selector, handler) {
+    return this.listenerHub.once(selector, handler);
+  }
+  /**
+   * Register a hook that receives listener and action handler errors. Returns
+   * an unsubscribe callback. When no hook is registered, errors are logged as
+   * console warnings.
+   */
+  onError(hook) {
+    this.errorHooks.add(hook);
+    return () => {
+      this.errorHooks.delete(hook);
+    };
+  }
+  reportError(error101, context) {
+    if (this.errorHooks.size === 0) {
+      logRelayHandlerError(error101, context);
+      return;
+    }
+    for (const hook of this.errorHooks) {
+      try {
+        hook(error101, context);
+      } catch {
+      }
+    }
+  }
   action(name) {
     return this.listenerHub.action(name);
   }
@@ -34564,9 +34914,9 @@ function extractWorkspaceKey(payload) {
   const value = payload.workspaceKey ?? payload.workspace_key ?? payload.apiKey ?? payload.api_key ?? data.workspaceKey ?? data.workspace_key ?? data.apiKey ?? data.api_key;
   return typeof value === "string" && value.trim() ? value : void 0;
 }
-function agentRelayAgent(messaging, actions, handlerAgent) {
+function agentRelayAgent(messaging, actions, handlerAgent, options) {
   const messages = createEnrichedMessages(messaging.messages, () => messaging.messages);
-  const hub = createListenerHub(messaging.events, actions);
+  const hub = createListenerHub(messaging.events, actions, { onError: options?.onError });
   return {
     messaging,
     agents: messaging.agents,
@@ -34580,15 +34930,16 @@ function agentRelayAgent(messaging, actions, handlerAgent) {
     webhooks: messaging.webhooks,
     capabilities: messaging.commands,
     workspace: createWorkspaceFacade(messaging),
-    registerAction: (def) => registerFacadeAction(actions, def, { messaging, handlerAgent }),
-    addListener: (selector, handler) => hub.addListener(selector, handler),
+    registerAction: (def) => registerFacadeAction(actions, def, { messaging, handlerAgent, onError: options?.onError }),
+    addListener: ((selector, handler) => hub.addListener(selector, handler)),
+    once: ((selector, handler) => hub.once(selector, handler)),
     action: (name) => hub.action(name),
     agent: (input) => hub.agent(input),
     emitSessionEvent: (agentId, event) => hub.emitSessionEvent(agentId, event)
   };
 }
-function assembleAgentClient(messaging, actions, identity) {
-  const base = agentRelayAgent(messaging, actions, identity.name);
+function assembleAgentClient(messaging, actions, identity, options) {
+  const base = agentRelayAgent(messaging, actions, identity.name, options);
   const handle = createAgentHandle(identity);
   return {
     ...base,
@@ -36163,11 +36514,13 @@ function generateRequestId(prefix = "") {
   MessageReactedPredicate,
   MessageReadPredicate,
   RelayCapabilityError,
+  RelayError,
   RelaycastMessagingClient,
   StaticPatterns,
   StatusPredicate,
   ToolCalledPredicate,
   TracedError,
+  TypedActionPredicate,
   actionSchemaToJsonSchema,
   agentRelayAgent,
   agentTokenRecoveryMessage,
@@ -36189,6 +36542,7 @@ function generateRequestId(prefix = "") {
   createRequestEnvelope,
   createRequestHandler,
   createTraceableError,
+  createTypedActionHandle,
   createWorkspaceFacade,
   defineHarness,
   findGitRoot,
@@ -36221,6 +36575,7 @@ function generateRequestId(prefix = "") {
   isSpawnOrReleaseCommandFast,
   isValidAgentName,
   logAndTraceError,
+  logRelayHandlerError,
   mapModelToCli,
   matchesSelector,
   nextHarnessName,
@@ -36234,8 +36589,11 @@ function generateRequestId(prefix = "") {
   normalizeChannelMember,
   normalizeChannelName,
   normalizeChannelReadStatus,
+  normalizeDeliveryTransition,
   normalizeGroupDirectConversation,
   normalizeInbox,
+  normalizeInboxItem,
+  normalizeInboxItemState,
   normalizeMessage,
   normalizeMessagingEvent,
   normalizeReaction,