@band-ai/sdk 0.3.4 → 0.4.1

package/dist/core.cjs

@@ -20,15 +20,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
+  AgentFailure: () => import_band_sdk_core3.AgentFailure,
   BandSdkError: () => BandSdkError,
   ConsoleLogger: () => ConsoleLogger,
+  DeliveryFailedError: () => DeliveryFailedError,
+  FAILURE_EVENT_TYPE: () => FAILURE_EVENT_TYPE,
+  FAILURE_METADATA_KEY: () => FAILURE_METADATA_KEY,
   NoopLogger: () => NoopLogger,
+  ProviderTurnFailedError: () => ProviderTurnFailedError,
+  RecoverableTurnError: () => RecoverableTurnError,
   RuntimeStateError: () => RuntimeStateError,
   SimpleAdapter: () => SimpleAdapter,
   TransportError: () => TransportError,
   UnsupportedFeatureError: () => UnsupportedFeatureError,
   ValidationError: () => ValidationError,
-  WebSocketDisconnectError: () => WebSocketDisconnectError
+  WebSocketDisconnectError: () => WebSocketDisconnectError,
+  agentFailure: () => agentFailure,
+  deliverReply: () => deliverReply,
+  reportTurnFailure: () => reportTurnFailure,
+  toFailureEvent: () => toFailureEvent
 });
 module.exports = __toCommonJS(core_exports);
 
@@ -68,6 +78,9 @@ var SimpleAdapter = class {
   }
 };
 
+// src/core/index.ts
+var import_band_sdk_core3 = require("@band-ai/band-sdk-core");
+
 // src/core/errors.ts
 var BandSdkError = class extends Error {
   constructor(message, cause) {
@@ -99,9 +112,36 @@ var RuntimeStateError = class extends BandSdkError {
     this.name = "RuntimeStateError";
   }
 };
+var RecoverableTurnError = class extends BandSdkError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "RecoverableTurnError";
+  }
+};
+
+// src/contracts/chatEvents.ts
+var CHAT_EVENT_TYPES = ["tool_call", "tool_result", "thought", "error", "task"];
+var CHAT_MESSAGE_TYPES = ["text", ...CHAT_EVENT_TYPES];
+var VISIBLE_CONTENT_PATTERN = /[\p{L}\p{N}\p{P}\p{S}]/u;
+function isBlankEventContent(content) {
+  return !VISIBLE_CONTENT_PATTERN.test(content);
+}
+
+// src/contracts/protocols.ts
+var FAILURE_EVENT_TYPE = "error";
+var FAILURE_METADATA_KEY = "failure";
+function toFailureEvent(failure) {
+  const content = isBlankEventContent(failure.message) ? `${failure.provider} failed without an error message.` : failure.message;
+  return {
+    content,
+    messageType: FAILURE_EVENT_TYPE,
+    metadata: { [FAILURE_METADATA_KEY]: failure.toObject() }
+  };
+}
 
 // src/platform/streaming/disconnectReason.ts
 var import_zod = require("zod");
+var import_band_sdk_core = require("@band-ai/band-sdk-core");
 var UPGRADE_CODES = [
   "invalid_on_conflict",
   "connection_conflict",
@@ -130,7 +170,7 @@ var upgradeErrorSchema = import_zod.z.object({
       })
     })
   ),
-  headers: import_zod.z.record(import_zod.z.unknown()).optional()
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 });
 var WebSocketDisconnectError = class extends Error {
   reason;
@@ -141,11 +181,15 @@ var WebSocketDisconnectError = class extends Error {
   }
 };
 
+// src/core/sensitiveTerms.ts
+var SENSITIVE_KEY_TERMS = "authorization|api[-_ ]?key|token|secret|password|cookie";
+var GATEWAY_FREE_TEXT_SENSITIVE_KEY_TERMS = `${SENSITIVE_KEY_TERMS}|session`;
+
 // src/core/logger.ts
 var noop = () => void 0;
 var REDACTED_VALUE = "[REDACTED]";
 var CIRCULAR_VALUE = "[Circular]";
-var SENSITIVE_KEY_PATTERN = /(authorization|api[-_]?key|token|secret|password|cookie)/i;
+var SENSITIVE_KEY_PATTERN = new RegExp(`(${SENSITIVE_KEY_TERMS})`, "i");
 var NoopLogger = class {
   debug = noop;
   info = noop;
@@ -168,7 +212,7 @@ var ConsoleLogger = class {
 `);
   }
   emit(level, message, context) {
-    const fn = console[level];
+    const fn = console[level].bind(console);
     if (context === void 0) {
       fn(message);
       return;
@@ -214,15 +258,205 @@ function sanitizeValue(value, seen = /* @__PURE__ */ new WeakSet()) {
   }
   return sanitized;
 }
+
+// src/core/coercion.ts
+var MAX_ERROR_CAUSE_DEPTH = 5;
+var MAX_ERROR_DETAIL_LENGTH = 500;
+var LENGTH_TRUNCATED_MARKER = "... (truncated)";
+var DEPTH_TRUNCATED_MARKER = "... (cause chain truncated)";
+function asOptionalRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function toDisplayText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value == null) {
+    return "";
+  }
+  try {
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? json : String(value);
+  } catch {
+    return String(value);
+  }
+}
+function asErrorMessage(error) {
+  return formatCaughtError(error, 0);
+}
+function formatCaughtError(error, depth) {
+  if (typeof error !== "object" || error === null) {
+    return truncate(String(error));
+  }
+  const message = truncate(asNestedMessage(error) ?? String(error));
+  const detail = selectDetail(asOptionalRecord(error));
+  if (detail === void 0) {
+    return message;
+  }
+  if (depth >= MAX_ERROR_CAUSE_DEPTH) {
+    return `${message} (${DEPTH_TRUNCATED_MARKER})`;
+  }
+  return `${message} (${formatErrorDetail(detail, depth + 1)})`;
+}
+function selectDetail(record) {
+  if (isPresentDetail(record?.data)) {
+    return record?.data;
+  }
+  if (isPresentDetail(record?.cause)) {
+    return record?.cause;
+  }
+  return void 0;
+}
+function isPresentDetail(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return asNonEmptyString(value) !== null;
+  }
+  if (value instanceof Error) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return isPlainObject(value) ? Object.keys(value).length > 0 : true;
+  }
+  return true;
+}
+function isPlainObject(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function formatErrorDetail(detail, depth) {
+  if (detail instanceof Error || selectDetail(asOptionalRecord(detail)) !== void 0) {
+    return formatCaughtError(detail, depth);
+  }
+  return truncate(formatLeafDetail(detail));
+}
+function formatLeafDetail(detail) {
+  if (typeof detail === "string") {
+    return detail;
+  }
+  if (typeof detail === "number" && !Number.isFinite(detail)) {
+    return String(detail);
+  }
+  const builtin = formatNonEnumerableDetail(detail);
+  if (builtin !== null) {
+    return builtin;
+  }
+  const nested = asNestedMessage(detail);
+  if (nested !== null) {
+    return nested;
+  }
+  return toDisplayText(detail);
+}
+function formatNonEnumerableDetail(detail) {
+  if (detail instanceof RegExp) {
+    return detail.toString();
+  }
+  if (detail instanceof Map) {
+    return `Map ${toDisplayText([...detail])}`;
+  }
+  if (detail instanceof Set) {
+    return `Set ${toDisplayText([...detail])}`;
+  }
+  return null;
+}
+function truncate(text) {
+  return text.length > MAX_ERROR_DETAIL_LENGTH ? `${text.slice(0, MAX_ERROR_DETAIL_LENGTH)}${LENGTH_TRUNCATED_MARKER}` : text;
+}
+function asNestedMessage(value) {
+  const record = asOptionalRecord(value);
+  return asNonEmptyString(record?.message);
+}
+
+// src/core/deliveryFailedError.ts
+var DeliveryFailedError = class extends RecoverableTurnError {
+  constructor(cause) {
+    super(asErrorMessage(cause), cause);
+    this.cause = cause;
+    this.name = "DeliveryFailedError";
+  }
+};
+async function deliverReply(tools, content, mentions = []) {
+  try {
+    return await tools.sendMessage(content, mentions);
+  } catch (error) {
+    throw new DeliveryFailedError(error);
+  }
+}
+
+// src/core/providerFailure.ts
+var import_band_sdk_core2 = require("@band-ai/band-sdk-core");
+var ProviderTurnFailedError = class extends RecoverableTurnError {
+  constructor(failure) {
+    super(failure.message);
+    this.failure = failure;
+    this.name = "ProviderTurnFailedError";
+  }
+};
+async function trySendFailure(tools, failure, logger, logContext) {
+  logger?.warn("provider_failure.reported", {
+    provider: failure.provider,
+    code: failure.code,
+    ...logContext
+  });
+  try {
+    await tools.sendFailure(failure);
+  } catch (error) {
+    logger?.warn("provider_failure.report_failed", {
+      provider: failure.provider,
+      code: failure.code,
+      ...logContext,
+      error
+    });
+  }
+}
+async function reportTurnFailure(tools, failure, logger, logContext) {
+  await trySendFailure(tools, failure, logger, logContext);
+  throw new ProviderTurnFailedError(failure);
+}
+function agentFailure(provider, message, code, detail) {
+  if (detail === void 0) {
+    return new import_band_sdk_core2.AgentFailure(provider, message, code);
+  }
+  try {
+    return new import_band_sdk_core2.AgentFailure(provider, message, code, detail);
+  } catch {
+    return new import_band_sdk_core2.AgentFailure(provider, message, code);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentFailure,
   BandSdkError,
   ConsoleLogger,
+  DeliveryFailedError,
+  FAILURE_EVENT_TYPE,
+  FAILURE_METADATA_KEY,
   NoopLogger,
+  ProviderTurnFailedError,
+  RecoverableTurnError,
   RuntimeStateError,
   SimpleAdapter,
   TransportError,
   UnsupportedFeatureError,
   ValidationError,
-  WebSocketDisconnectError
+  WebSocketDisconnectError,
+  agentFailure,
+  deliverReply,
+  reportTurnFailure,
+  toFailureEvent
 });

package/dist/core.d.cts

@@ -1,8 +1,12 @@
-export { S as SimpleAdapter } from './simpleAdapter-BpT4XbZC.cjs';
-export { A as AdapterToolsProtocol, a as AgentToolsProtocol, C as ContactTools, F as FrameworkAdapter, b as FrameworkAdapterInput, H as HistoryConverter, M as MemoryTools, c as MessagingTools, P as ParticipantTools, d as PeerLookupTools, e as Preprocessor, R as RoomParticipantTools, T as ToolExecutor, f as ToolSchemaProvider } from './protocols-Bz1rxcUg.cjs';
-export { W as WebSocketConflictPolicy, a as WebSocketDisconnectError, b as WebSocketDisconnectReason } from './disconnectReason-IuADl6TH.cjs';
-export { C as ConsoleLogger, L as Logger, N as NoopLogger } from './logger-CABQOnlR.cjs';
-import './dtos-B8KU_q4d.cjs';
+export { S as SimpleAdapter } from './simpleAdapter-D75rcz9n.cjs';
+import { AgentFailure } from '@band-ai/band-sdk-core';
+export { AgentFailure } from '@band-ai/band-sdk-core';
+import { e as MessagingTools } from './protocols-CabgO52c.cjs';
+export { A as AdapterToolsProtocol, b as AgentToolsProtocol, C as ContactTools, c as FAILURE_EVENT_TYPE, d as FAILURE_METADATA_KEY, F as FrameworkAdapter, a as FrameworkAdapterInput, H as HistoryConverter, M as MemoryTools, f as ParticipantTools, g as PeerLookupTools, h as Preprocessor, R as RoomParticipantTools, T as ToolExecutor, i as ToolSchemaProvider, t as toFailureEvent } from './protocols-CabgO52c.cjs';
+export { W as WebSocketConflictPolicy, a as WebSocketDisconnectError, b as WebSocketDisconnectReason } from './disconnectReason-Cctmg1SN.cjs';
+import { L as Logger } from './logger-CABQOnlR.cjs';
+export { C as ConsoleLogger, N as NoopLogger } from './logger-CABQOnlR.cjs';
+import { h as MentionInput, T as ToolOperationResult } from './dtos-CjQsN1_h.cjs';
 
 declare class BandSdkError extends Error {
     constructor(message: string, cause?: unknown);
@@ -19,5 +23,66 @@ declare class TransportError extends BandSdkError {
 declare class RuntimeStateError extends BandSdkError {
     constructor(message: string);
 }
+/**
+ * A failure confined to the turn that raised it. `Execution` keeps the room's
+ * loop — and every other room — running for these, where any other error
+ * stops the whole runtime.
+ *
+ * The turn still fails: `PlatformRuntime` has already marked the message
+ * failed by the time one of these reaches the queue. What it must not do is
+ * take the agent down with it, which is the right response to a broken
+ * adapter and the wrong one to a single reply that could not be posted.
+ */
+declare class RecoverableTurnError extends BandSdkError {
+    constructor(message: string, cause?: unknown);
+}
+
+/**
+ * Marks a rejection as coming from delivering an already-decided reply, not
+ * from the provider itself.
+ *
+ * `RecoverableTurnError`, because failing to post one reply is a failure of
+ * that turn and nothing more: the runtime marks the message failed and keeps
+ * every room serving. Reporting it as an `AgentFailure` would blame the
+ * provider for a Band-side fault; taking the runtime down would answer a
+ * transient post failure with an outage.
+ */
+declare class DeliveryFailedError extends RecoverableTurnError {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+declare function deliverReply(tools: MessagingTools, content: string, mentions?: MentionInput): Promise<ToolOperationResult>;
+
+/**
+ * A provider failure that has already been reported to the room.
+ *
+ * Thrown, not returned, so the turn still *fails*: `PlatformRuntime` marks a
+ * message failed only when `onEvent` throws, and the platform re-syncs failed
+ * messages rather than processed ones. Returning here would flip a failed turn
+ * to `processed` and drop its retry along with it.
+ *
+ * `RecoverableTurnError` is what changes: the turn fails, the room and every
+ * other room keep running. Reporting a provider error must not take the agent
+ * down, which is what an ordinary throw from here used to do.
+ */
+declare class ProviderTurnFailedError extends RecoverableTurnError {
+    readonly failure: AgentFailure;
+    constructor(failure: AgentFailure);
+}
+/**
+ * Reports a terminal provider failure, then fails the turn that hit it.
+ */
+declare function reportTurnFailure(tools: MessagingTools, failure: AgentFailure, logger?: Logger, logContext?: Record<string, unknown>): Promise<never>;
+/**
+ * Builds an `AgentFailure` whose `detail` cannot make the constructor throw.
+ *
+ * `detail` carries raw provider payloads — an HTTP body, an RPC error object —
+ * and the constructor rejects anything it cannot serialize: a `Buffer`, a
+ * function-valued property, a cycle. It is built on failure paths, often as an
+ * argument outside the enclosing guard, where a throw would replace the very
+ * failure being reported. An unusable detail is dropped instead; the provider,
+ * message and code are typed as strings, so only `detail` can be exotic.
+ */
+declare function agentFailure(provider: string, message: string, code?: string, detail?: unknown): AgentFailure;
 
-export { BandSdkError, RuntimeStateError, TransportError, UnsupportedFeatureError, ValidationError };
+export { BandSdkError, DeliveryFailedError, Logger, MessagingTools, ProviderTurnFailedError, RecoverableTurnError, RuntimeStateError, TransportError, UnsupportedFeatureError, ValidationError, agentFailure, deliverReply, reportTurnFailure };

package/dist/core.d.ts

@@ -1,8 +1,12 @@
-export { S as SimpleAdapter } from './simpleAdapter--wznuoOw.js';
-export { A as AdapterToolsProtocol, a as AgentToolsProtocol, C as ContactTools, F as FrameworkAdapter, b as FrameworkAdapterInput, H as HistoryConverter, M as MemoryTools, c as MessagingTools, P as ParticipantTools, d as PeerLookupTools, e as Preprocessor, R as RoomParticipantTools, T as ToolExecutor, f as ToolSchemaProvider } from './protocols-Bwwcql0h.js';
-export { W as WebSocketConflictPolicy, a as WebSocketDisconnectError, b as WebSocketDisconnectReason } from './disconnectReason-IuADl6TH.js';
-export { C as ConsoleLogger, L as Logger, N as NoopLogger } from './logger-CABQOnlR.js';
-import './dtos-B8KU_q4d.js';
+export { S as SimpleAdapter } from './simpleAdapter-eLvsAQNo.js';
+import { AgentFailure } from '@band-ai/band-sdk-core';
+export { AgentFailure } from '@band-ai/band-sdk-core';
+import { e as MessagingTools } from './protocols-Dpci6uae.js';
+export { A as AdapterToolsProtocol, b as AgentToolsProtocol, C as ContactTools, c as FAILURE_EVENT_TYPE, d as FAILURE_METADATA_KEY, F as FrameworkAdapter, a as FrameworkAdapterInput, H as HistoryConverter, M as MemoryTools, f as ParticipantTools, g as PeerLookupTools, h as Preprocessor, R as RoomParticipantTools, T as ToolExecutor, i as ToolSchemaProvider, t as toFailureEvent } from './protocols-Dpci6uae.js';
+export { W as WebSocketConflictPolicy, a as WebSocketDisconnectError, b as WebSocketDisconnectReason } from './disconnectReason-Cctmg1SN.js';
+import { L as Logger } from './logger-CABQOnlR.js';
+export { C as ConsoleLogger, N as NoopLogger } from './logger-CABQOnlR.js';
+import { h as MentionInput, T as ToolOperationResult } from './dtos-CjQsN1_h.js';
 
 declare class BandSdkError extends Error {
     constructor(message: string, cause?: unknown);
@@ -19,5 +23,66 @@ declare class TransportError extends BandSdkError {
 declare class RuntimeStateError extends BandSdkError {
     constructor(message: string);
 }
+/**
+ * A failure confined to the turn that raised it. `Execution` keeps the room's
+ * loop — and every other room — running for these, where any other error
+ * stops the whole runtime.
+ *
+ * The turn still fails: `PlatformRuntime` has already marked the message
+ * failed by the time one of these reaches the queue. What it must not do is
+ * take the agent down with it, which is the right response to a broken
+ * adapter and the wrong one to a single reply that could not be posted.
+ */
+declare class RecoverableTurnError extends BandSdkError {
+    constructor(message: string, cause?: unknown);
+}
+
+/**
+ * Marks a rejection as coming from delivering an already-decided reply, not
+ * from the provider itself.
+ *
+ * `RecoverableTurnError`, because failing to post one reply is a failure of
+ * that turn and nothing more: the runtime marks the message failed and keeps
+ * every room serving. Reporting it as an `AgentFailure` would blame the
+ * provider for a Band-side fault; taking the runtime down would answer a
+ * transient post failure with an outage.
+ */
+declare class DeliveryFailedError extends RecoverableTurnError {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+declare function deliverReply(tools: MessagingTools, content: string, mentions?: MentionInput): Promise<ToolOperationResult>;
+
+/**
+ * A provider failure that has already been reported to the room.
+ *
+ * Thrown, not returned, so the turn still *fails*: `PlatformRuntime` marks a
+ * message failed only when `onEvent` throws, and the platform re-syncs failed
+ * messages rather than processed ones. Returning here would flip a failed turn
+ * to `processed` and drop its retry along with it.
+ *
+ * `RecoverableTurnError` is what changes: the turn fails, the room and every
+ * other room keep running. Reporting a provider error must not take the agent
+ * down, which is what an ordinary throw from here used to do.
+ */
+declare class ProviderTurnFailedError extends RecoverableTurnError {
+    readonly failure: AgentFailure;
+    constructor(failure: AgentFailure);
+}
+/**
+ * Reports a terminal provider failure, then fails the turn that hit it.
+ */
+declare function reportTurnFailure(tools: MessagingTools, failure: AgentFailure, logger?: Logger, logContext?: Record<string, unknown>): Promise<never>;
+/**
+ * Builds an `AgentFailure` whose `detail` cannot make the constructor throw.
+ *
+ * `detail` carries raw provider payloads — an HTTP body, an RPC error object —
+ * and the constructor rejects anything it cannot serialize: a `Buffer`, a
+ * function-valued property, a cycle. It is built on failure paths, often as an
+ * argument outside the enclosing guard, where a throw would replace the very
+ * failure being reported. An unusable detail is dropped instead; the provider,
+ * message and code are typed as strings, so only `detail` can be exotic.
+ */
+declare function agentFailure(provider: string, message: string, code?: string, detail?: unknown): AgentFailure;
 
-export { BandSdkError, RuntimeStateError, TransportError, UnsupportedFeatureError, ValidationError };
+export { BandSdkError, DeliveryFailedError, Logger, MessagingTools, ProviderTurnFailedError, RecoverableTurnError, RuntimeStateError, TransportError, UnsupportedFeatureError, ValidationError, agentFailure, deliverReply, reportTurnFailure };

package/dist/core.js

@@ -1,28 +1,53 @@
 import {
-  SimpleAdapter
-} from "./chunk-AVVDPXP4.js";
+  AgentFailure
+} from "./chunk-I34SXMTJ.js";
+import {
+  DeliveryFailedError,
+  ProviderTurnFailedError,
+  SimpleAdapter,
+  agentFailure,
+  deliverReply,
+  reportTurnFailure
+} from "./chunk-OGOXY43L.js";
 import {
   WebSocketDisconnectError
-} from "./chunk-US226AS4.js";
+} from "./chunk-UENIC5FJ.js";
+import "./chunk-6BE2EG5P.js";
+import {
+  FAILURE_EVENT_TYPE,
+  FAILURE_METADATA_KEY,
+  toFailureEvent
+} from "./chunk-TGDDFBYS.js";
 import {
   ConsoleLogger,
   NoopLogger
-} from "./chunk-OD2G5LFQ.js";
+} from "./chunk-ZYOXI4JL.js";
 import {
   BandSdkError,
+  RecoverableTurnError,
   RuntimeStateError,
   TransportError,
   UnsupportedFeatureError,
   ValidationError
-} from "./chunk-JY75VSQK.js";
+} from "./chunk-4OVNFDD7.js";
 export {
+  AgentFailure,
   BandSdkError,
   ConsoleLogger,
+  DeliveryFailedError,
+  FAILURE_EVENT_TYPE,
+  FAILURE_METADATA_KEY,
   NoopLogger,
+  ProviderTurnFailedError,
+  RecoverableTurnError,
   RuntimeStateError,
   SimpleAdapter,
   TransportError,
   UnsupportedFeatureError,
   ValidationError,
-  WebSocketDisconnectError
+  WebSocketDisconnectError,
+  agentFailure,
+  deliverReply,
+  reportTurnFailure,
+  toFailureEvent
 };

package/dist/{customTools-BzF0IISO.d.cts → customTools-Bfecd0mJ.d.cts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 interface CustomToolDef {
-    schema: z.AnyZodObject;
+    schema: z.ZodObject;
     handler: (args: Record<string, unknown>) => unknown;
     name: string;
     description?: string;

package/dist/{customTools-BzF0IISO.d.ts → customTools-Bfecd0mJ.d.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 interface CustomToolDef {
-    schema: z.AnyZodObject;
+    schema: z.ZodObject;
     handler: (args: Record<string, unknown>) => unknown;
     name: string;
     description?: string;

package/dist/{disconnectReason-IuADl6TH.d.ts → disconnectReason-Cctmg1SN.d.cts}

@@ -3,7 +3,7 @@ interface AgentControlSupersedeDisconnectReason {
     source: "agent_control";
     code: string;
     message: string;
-    retryable: false;
+    retryable: boolean;
     retryAfter: number | null;
     targetSocketId: string | null;
     correlationId: string | null;

package/dist/{disconnectReason-IuADl6TH.d.cts → disconnectReason-Cctmg1SN.d.ts}

@@ -3,7 +3,7 @@ interface AgentControlSupersedeDisconnectReason {
     source: "agent_control";
     code: string;
     message: string;
-    retryable: false;
+    retryable: boolean;
     retryAfter: number | null;
     targetSocketId: string | null;
     correlationId: string | null;

package/dist/{dtos-B8KU_q4d.d.ts → dtos-CjQsN1_h.d.cts}

@@ -1,18 +1,11 @@
-/** Canonical memory enums; DTOs, tool schemas, and validation derive from these constants. */
-/** Which memory types are valid for each memory tier. */
-declare const MEMORY_SYSTEM_TYPES: {
-    readonly sensory: readonly ["iconic", "echoic", "haptic"];
-    readonly working: readonly ["episodic", "semantic", "procedural"];
-    readonly long_term: readonly ["episodic", "semantic", "procedural"];
-};
-type MemorySystem = keyof typeof MEMORY_SYSTEM_TYPES;
-type MemoryType = (typeof MEMORY_SYSTEM_TYPES)[MemorySystem][number];
+import { MemorySystem, MemoryType } from '@band-ai/band-sdk-core';
+
 /** Logical subject category (user/agent/tool/guideline); not scope `subject` or `subject_id`. */
 declare const MEMORY_SEGMENTS: readonly ["user", "agent", "tool", "guideline"];
 /** Visibility scope for `band_store_memory`. */
-declare const MEMORY_STORE_SCOPES: readonly ["subject", "organization"];
+declare const MEMORY_STORE_SCOPES: readonly ["agent", "subject", "organization"];
 /** Scope filter for `band_list_memories`. */
-declare const MEMORY_LIST_SCOPES: readonly ["subject", "organization", "all"];
+declare const MEMORY_LIST_SCOPES: readonly ["agent", "subject", "organization", "all"];
 /** Lifecycle state; list filter and set by supersede/archive tools. */
 declare const MEMORY_STATUSES: readonly ["active", "superseded", "archived", "all"];
 /** Logical subject category (user/agent/tool/guideline); not scope `subject` or `subject_id`. */
@@ -180,4 +173,4 @@ interface ToolModelSchema {
     [key: string]: unknown;
 }
 
-export type { AddContactArgs as A, ContactRecord as C, ListContactsArgs as L, MetadataMap as M, ParticipantRecord as P, RemoveContactArgs as R, StoreMemoryArgs as S, ToolOperationResult as T, MentionInput as a, ToolSchemaRecord as b, PaginatedList as c, PeerRecord as d, ListContactRequestsArgs as e, ContactRequestsResult as f, RespondContactRequestArgs as g, ListMemoriesArgs as h, MemoryRecord as i, MentionReference as j, ContactRequestAction as k, PaginationMetadataLike as l, ToolModelMessage as m, ToolModelSchema as n };
+export type { AddContactArgs as A, ContactRecord as C, ListContactsArgs as L, MetadataMap as M, PeerRecord as P, RemoveContactArgs as R, StoreMemoryArgs as S, ToolOperationResult as T, MentionReference as a, ListContactRequestsArgs as b, ContactRequestsResult as c, RespondContactRequestArgs as d, ListMemoriesArgs as e, MemoryRecord as f, ParticipantRecord as g, MentionInput as h, PaginatedList as i, ToolSchemaRecord as j, ContactRequestAction as k, PaginationMetadataLike as l, ToolModelMessage as m, ToolModelSchema as n };

package/dist/{dtos-B8KU_q4d.d.cts → dtos-CjQsN1_h.d.ts}

@@ -1,18 +1,11 @@
-/** Canonical memory enums; DTOs, tool schemas, and validation derive from these constants. */
-/** Which memory types are valid for each memory tier. */
-declare const MEMORY_SYSTEM_TYPES: {
-    readonly sensory: readonly ["iconic", "echoic", "haptic"];
-    readonly working: readonly ["episodic", "semantic", "procedural"];
-    readonly long_term: readonly ["episodic", "semantic", "procedural"];
-};
-type MemorySystem = keyof typeof MEMORY_SYSTEM_TYPES;
-type MemoryType = (typeof MEMORY_SYSTEM_TYPES)[MemorySystem][number];
+import { MemorySystem, MemoryType } from '@band-ai/band-sdk-core';
+
 /** Logical subject category (user/agent/tool/guideline); not scope `subject` or `subject_id`. */
 declare const MEMORY_SEGMENTS: readonly ["user", "agent", "tool", "guideline"];
 /** Visibility scope for `band_store_memory`. */
-declare const MEMORY_STORE_SCOPES: readonly ["subject", "organization"];
+declare const MEMORY_STORE_SCOPES: readonly ["agent", "subject", "organization"];
 /** Scope filter for `band_list_memories`. */
-declare const MEMORY_LIST_SCOPES: readonly ["subject", "organization", "all"];
+declare const MEMORY_LIST_SCOPES: readonly ["agent", "subject", "organization", "all"];
 /** Lifecycle state; list filter and set by supersede/archive tools. */
 declare const MEMORY_STATUSES: readonly ["active", "superseded", "archived", "all"];
 /** Logical subject category (user/agent/tool/guideline); not scope `subject` or `subject_id`. */
@@ -180,4 +173,4 @@ interface ToolModelSchema {
     [key: string]: unknown;
 }
 
-export type { AddContactArgs as A, ContactRecord as C, ListContactsArgs as L, MetadataMap as M, ParticipantRecord as P, RemoveContactArgs as R, StoreMemoryArgs as S, ToolOperationResult as T, MentionInput as a, ToolSchemaRecord as b, PaginatedList as c, PeerRecord as d, ListContactRequestsArgs as e, ContactRequestsResult as f, RespondContactRequestArgs as g, ListMemoriesArgs as h, MemoryRecord as i, MentionReference as j, ContactRequestAction as k, PaginationMetadataLike as l, ToolModelMessage as m, ToolModelSchema as n };
+export type { AddContactArgs as A, ContactRecord as C, ListContactsArgs as L, MetadataMap as M, PeerRecord as P, RemoveContactArgs as R, StoreMemoryArgs as S, ToolOperationResult as T, MentionReference as a, ListContactRequestsArgs as b, ContactRequestsResult as c, RespondContactRequestArgs as d, ListMemoriesArgs as e, MemoryRecord as f, ParticipantRecord as g, MentionInput as h, PaginatedList as i, ToolSchemaRecord as j, ContactRequestAction as k, PaginationMetadataLike as l, ToolModelMessage as m, ToolModelSchema as n };