@band-ai/band-sdk-core 2.1.0 → 2.3.0

package/README.md

@@ -193,6 +193,12 @@ classifies one candidate per call.
 `evaluateAdapterResult(roomId, messageId, succeeded)` maps an adapter
 outcome to `"processed"` or `"failed"`.
 
+`isSelfEcho(senderId, senderType, agentId)` is the one definition of
+"self echo" (`senderType === "Agent" && senderId === agentId`) that
+`evaluateDeliveryEvent` and `evaluateDrainCandidate` use internally,
+exposed for a host's own call sites that classify a sender without going
+through either function.
+
 The public declaration is
 [`index.d.ts`](https://github.com/band-ai/band-sdk-core/blob/main/crates/wasm/index.d.ts).
 

package/band_sdk_core.js

@@ -1,5 +1,110 @@
 /* @ts-self-types="./index.d.ts" */
 
+/**
+ * One agent-provider failure, surfaced verbatim rather than classified.
+ */
+class AgentFailure {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AgentFailureFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_agentfailure_free(ptr, 0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get code() {
+        const ret = wasm.agentfailure_code(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * `undefined` when absent, matching every other optional getter in
+     * this crate (e.g. `SessionOutcome.deadReason`) -- `toObject()` below
+     * represents the same absence as JSON `null` instead, since it mirrors
+     * the wire shape rather than idiomatic JS/TS property access.
+     * @returns {any}
+     */
+    get detail() {
+        const ret = wasm.agentfailure_detail(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.agentfailure_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Throws a plain `Error` if `provider`/`message` is not a string, or
+     * `code` is present but not a string or `null`. A `detail` that cannot
+     * be converted from JSON throws a plain `Error` too.
+     * @param {any} provider
+     * @param {any} message
+     * @param {any} code
+     * @param {any} detail
+     */
+    constructor(provider, message, code, detail) {
+        const ret = wasm.agentfailure_new(provider, message, code, detail);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        AgentFailureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    get provider() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.agentfailure_provider(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The failure as a plain JSON-shaped object: unlike the getters above,
+     * an absent `code`/`detail` serializes as `null` here, matching the
+     * core type's own `Serialize` output.
+     * @returns {any}
+     */
+    toObject() {
+        const ret = wasm.agentfailure_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) AgentFailure.prototype[Symbol.dispose] = AgentFailure.prototype.free;
+exports.AgentFailure = AgentFailure;
+
 /**
  * Ownership ledger for the inbound message-delivery lifecycle: in-flight,
  * ack-pending, and completed states, each scoped by `(roomId,
@@ -1282,6 +1387,26 @@ function evaluateNextMessage(triggeringMessageId, nextMessageId) {
 }
 exports.evaluateNextMessage = evaluateNextMessage;
 
+/**
+ * The one definition of "self echo" (`senderType === "Agent" &&
+ * senderId === agentId`), shared by `evaluateDeliveryEvent` and
+ * `evaluateDrainCandidate` internally and exposed here for a host's own
+ * call sites that don't go through either. Throws a plain `Error` if
+ * `senderId`/`senderType`/`agentId` is not a string.
+ * @param {any} senderId
+ * @param {any} senderType
+ * @param {any} agentId
+ * @returns {boolean}
+ */
+function isSelfEcho(senderId, senderType, agentId) {
+    const ret = wasm.isSelfEcho(senderId, senderType, agentId);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.isSelfEcho = isSelfEcho;
+
 /**
  * This platform's Phoenix Channels topic for a room's `room_participants`
  * channel.
@@ -1609,6 +1734,9 @@ function __wbg_get_imports() {
     };
 }
 
+const AgentFailureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_agentfailure_free(ptr, 1));
 const ClaimRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_claimregistry_free(ptr, 1));

package/index.d.ts

@@ -1,3 +1,27 @@
+/**
+ * One agent-provider failure, surfaced verbatim rather than classified.
+ * `detail` is an opaque passthrough of whatever JSON shape the provider (or
+ * the adapter, for a self-declared failure such as `code: "timeout"`)
+ * attaches -- this package never inspects it.
+ *
+ * Throws a plain `Error` if `provider`/`message` is not a string, `code` is
+ * present but not a string or `null`/`undefined`, or `detail` cannot be
+ * converted from JSON.
+ */
+export class AgentFailure {
+  constructor(provider: string, message: string, code?: string | null, detail?: unknown);
+  readonly provider: string;
+  readonly code: string | undefined;
+  readonly message: string;
+  /** `undefined` when absent; {@link toObject} represents the same absence as `null` instead. */
+  readonly detail: unknown | undefined;
+  /**
+   * The failure as a plain JSON-shaped object. Unlike the getters above, an
+   * absent `code`/`detail` serializes as `null` here, not `undefined`.
+   */
+  toObject(): Record<string, unknown>;
+}
+
 /** Canonical inbound wire-event names `validateEventPayload` accepts. */
 export type EventType =
   | "message_created"
@@ -500,3 +524,12 @@ export function evaluateAdapterResult(
   messageId: string,
   succeeded: boolean,
 ): AckDecision;
+
+/**
+ * The one definition of "self echo" (`senderType === "Agent" &&
+ * senderId === agentId`), shared by {@link evaluateDeliveryEvent} and
+ * {@link evaluateDrainCandidate} internally and exposed here for a host's
+ * own call sites that don't go through either. Throws a plain `Error` if
+ * `senderId`/`senderType`/`agentId` is not a string.
+ */
+export function isSelfEcho(senderId: string, senderType: string, agentId: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@band-ai/band-sdk-core",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Shared Band event-payload validation",
   "license": "MIT",
   "repository": {