@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/adapter/context-builder.d.ts

@@ -0,0 +1,35 @@
+/**
+ * createAdapterContext — builds an AdapterContext for an adapter instance.
+ *
+ * M1: respondSync uses AsyncLocalStorage to bind the current HTTP response.
+ * When called inside a registerRoute handler (sync window), respondSync writes
+ * to the HTTP res. When called outside the sync window, it performs graceful
+ * degradation: logs a warning instead of throwing (PoC correction #3).
+ */
+import { AsyncLocalStorage } from 'async_hooks';
+import type { AdapterContext, AdapterCapability, AdapterStore, AgentRunner, AuditSink, BlobStorage, EventResolution, HttpRouter, InboundEvent, InboundMessage, Logger, OutboundMessage, RawResponse, ResolvedUser, RouteResolution } from './types';
+export interface SyncWindow {
+    res: RawResponse;
+    timeoutMs: number;
+}
+export declare function getSyncWindowStore(): AsyncLocalStorage<SyncWindow>;
+export declare function runInSyncWindow<T>(window: SyncWindow, fn: () => Promise<T>): Promise<T>;
+export interface AdapterContextOptions<TConfig = unknown> {
+    instanceId: string;
+    config: TConfig;
+    capabilities: ReadonlySet<AdapterCapability>;
+    log?: Logger;
+    agentRunner?: AgentRunner;
+    db?: AdapterStore;
+    storage?: BlobStorage;
+    audit?: AuditSink;
+    abortSignal?: AbortSignal;
+    onInbound?: (msg: InboundMessage) => Promise<RouteResolution>;
+    onEmitEvent?: (event: InboundEvent) => Promise<EventResolution>;
+    onUpdateMessage?: (messageId: string, patch: Partial<OutboundMessage>) => Promise<void>;
+    onResolveUser?: (userId: string) => Promise<ResolvedUser>;
+    httpRouter?: HttpRouter;
+    logger?: Logger;
+}
+export declare function createAdapterContext<TConfig = unknown>(opts: AdapterContextOptions<TConfig>): AdapterContext<TConfig>;
+//# sourceMappingURL=context-builder.d.ts.map

package/dist/adapter/context-builder.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * createAdapterContext — builds an AdapterContext for an adapter instance.
+ *
+ * M1: respondSync uses AsyncLocalStorage to bind the current HTTP response.
+ * When called inside a registerRoute handler (sync window), respondSync writes
+ * to the HTTP res. When called outside the sync window, it performs graceful
+ * degradation: logs a warning instead of throwing (PoC correction #3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSyncWindowStore = getSyncWindowStore;
+exports.runInSyncWindow = runInSyncWindow;
+exports.createAdapterContext = createAdapterContext;
+const async_hooks_1 = require("async_hooks");
+const syncWindowStore = new async_hooks_1.AsyncLocalStorage();
+function getSyncWindowStore() {
+    return syncWindowStore;
+}
+function runInSyncWindow(window, fn) {
+    return syncWindowStore.run(window, fn);
+}
+function createAdapterContext(opts) {
+    const log = opts.log ?? opts.logger ?? {
+        debug: () => { },
+        info: () => { },
+        warn: () => { },
+        error: () => { },
+    };
+    const agentRunner = opts.agentRunner ?? {
+        run: async () => ({ output: '' }),
+    };
+    const db = opts.db ?? {
+        get: async () => undefined,
+        set: async () => { },
+        delete: async () => false,
+        list: async () => [],
+    };
+    const storage = opts.storage ?? {
+        put: async () => '',
+        get: async () => undefined,
+        delete: async () => false,
+    };
+    const audit = opts.audit ?? {
+        log: async () => { },
+    };
+    const inbound = opts.onInbound ?? (async () => ({ accepted: true }));
+    const emitEventFn = opts.onEmitEvent ?? (async () => ({ accepted: true }));
+    const updateMessage = opts.onUpdateMessage ?? (async () => { });
+    const resolveUser = opts.onResolveUser ?? (async (userId) => ({
+        userId,
+        displayName: userId,
+    }));
+    const respondSync = async (payload) => {
+        const window = syncWindowStore.getStore();
+        if (!window) {
+            log.warn('respondSync called outside sync window — graceful degradation (no-op)', {
+                textPreview: typeof payload === 'object' && 'text' in payload ? payload.text.slice(0, 80) : undefined,
+            });
+            return;
+        }
+        const text = 'text' in payload ? payload.text : '';
+        window.res.status(200).json({ text });
+    };
+    const httpRouter = opts.httpRouter ?? {
+        registerRoute: () => {
+            log.warn('httpRouter not configured — registerRoute is a no-op');
+        },
+    };
+    return {
+        instanceId: opts.instanceId,
+        config: opts.config,
+        capabilities: opts.capabilities,
+        log,
+        agentRunner,
+        db,
+        storage,
+        audit,
+        abortSignal: opts.abortSignal ?? new AbortController().signal,
+        httpRouter,
+        inbound,
+        emitEvent: emitEventFn,
+        updateMessage,
+        resolveUser,
+        respondSync,
+    };
+}
+//# sourceMappingURL=context-builder.js.map

package/dist/adapter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './plugin-helper';
+export * from './scoped-store';
+export * from './context-builder';
+//# sourceMappingURL=index.d.ts.map

package/dist/{core/remote → adapter}/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
-__exportStar(require("./remote-transport"), exports);
-__exportStar(require("./remote-agent-manager"), exports);
+__exportStar(require("./plugin-helper"), exports);
+__exportStar(require("./scoped-store"), exports);
+__exportStar(require("./context-builder"), exports);
 //# sourceMappingURL=index.js.map

package/dist/adapter/plugin-helper.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Plugin helpers for defining channel adapters.
+ *
+ * defineChannelAdapter — type-safe identity function for IChannelAdapter.
+ * defineChannelAdapterPlugin — wraps an adapter as a CrewxPlugin (§3.3).
+ */
+import type { IChannelAdapter } from './types';
+import type { CrewxPlugin } from '../plugin';
+export declare function defineChannelAdapter<TConfig = unknown>(spec: IChannelAdapter<TConfig>): IChannelAdapter<TConfig>;
+export interface ChannelAdapterPluginSpec<TConfig = unknown> {
+    readonly name: string;
+    readonly adapter: IChannelAdapter<TConfig>;
+    readonly configFactory: (crewx: unknown) => TConfig | Promise<TConfig>;
+    readonly instanceId?: string;
+    readonly onAttach?: (crewx: unknown) => void | Promise<void>;
+    readonly onDetach?: (crewx: unknown) => void | Promise<void>;
+}
+export declare function defineChannelAdapterPlugin<TConfig = unknown>(spec: ChannelAdapterPluginSpec<TConfig>): CrewxPlugin;
+//# sourceMappingURL=plugin-helper.d.ts.map

package/dist/adapter/plugin-helper.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Plugin helpers for defining channel adapters.
+ *
+ * defineChannelAdapter — type-safe identity function for IChannelAdapter.
+ * defineChannelAdapterPlugin — wraps an adapter as a CrewxPlugin (§3.3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineChannelAdapter = defineChannelAdapter;
+exports.defineChannelAdapterPlugin = defineChannelAdapterPlugin;
+function defineChannelAdapter(spec) {
+    return spec;
+}
+function defineChannelAdapterPlugin(spec) {
+    return {
+        name: spec.name,
+        async attach(crewx) {
+            const config = await spec.configFactory(crewx);
+            const anyCrewx = crewx;
+            const registerFn = anyCrewx['registerChannelAdapter'];
+            const instanceId = spec.instanceId ?? spec.name;
+            if (registerFn) {
+                await registerFn({
+                    adapter: spec.adapter,
+                    instanceId,
+                    config,
+                });
+            }
+            if (spec.onAttach) {
+                await spec.onAttach(crewx);
+            }
+        },
+        async detach(crewx) {
+            const anyCrewx = crewx;
+            const unregisterFn = anyCrewx['unregisterChannelAdapter'];
+            if (unregisterFn) {
+                await unregisterFn(spec.instanceId ?? spec.name);
+            }
+            if (spec.onDetach) {
+                await spec.onDetach(crewx);
+            }
+        },
+    };
+}
+//# sourceMappingURL=plugin-helper.js.map

package/dist/adapter/scoped-store.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ScopedAdapterStore — adapter key-value store with mandatory instanceId prefix.
+ *
+ * Security: Uses Map closure pattern (RT-1 defense).
+ * The internal Map is captured in a function closure — no public or private
+ * property on the returned AdapterStore object holds the raw Map reference.
+ * Reflect / Object.getPrototypeOf / (ctx.db as any)['_rawStore'] all fail
+ * because the Map only exists in the createScopedAdapterStore function scope.
+ */
+import type { AdapterStore } from './types';
+export declare function createScopedAdapterStore(instanceId: string): AdapterStore;
+//# sourceMappingURL=scoped-store.d.ts.map

package/dist/adapter/scoped-store.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * ScopedAdapterStore — adapter key-value store with mandatory instanceId prefix.
+ *
+ * Security: Uses Map closure pattern (RT-1 defense).
+ * The internal Map is captured in a function closure — no public or private
+ * property on the returned AdapterStore object holds the raw Map reference.
+ * Reflect / Object.getPrototypeOf / (ctx.db as any)['_rawStore'] all fail
+ * because the Map only exists in the createScopedAdapterStore function scope.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScopedAdapterStore = createScopedAdapterStore;
+function createScopedAdapterStore(instanceId) {
+    const store = new Map();
+    const prefixKey = (key) => {
+        if (key.startsWith(`${instanceId}::`))
+            return key;
+        return `${instanceId}::${key}`;
+    };
+    return {
+        async get(key) {
+            const entry = store.get(prefixKey(key));
+            return entry ? entry.value : undefined;
+        },
+        async set(key, value) {
+            store.set(prefixKey(key), { value });
+        },
+        async delete(key) {
+            return store.delete(prefixKey(key));
+        },
+        async list(prefix) {
+            const fullPrefix = prefix ? prefixKey(prefix) : `${instanceId}::`;
+            const keys = [];
+            for (const k of store.keys()) {
+                if (k.startsWith(fullPrefix)) {
+                    keys.push(k.slice(instanceId.length + 2));
+                }
+            }
+            return keys;
+        },
+    };
+}
+//# sourceMappingURL=scoped-store.js.map

package/dist/adapter/types.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Adapter Platform v0.4 — core types.
+ * PoC corrections applied:
+ *   1. AdapterError: class only (interface removed)
+ *   2. kind: added 'config' for configuration errors
+ */
+export type AdapterCapability = 'send' | 'receive' | 'threads' | 'attachments' | 'interactive' | 'markdown' | 'edit' | 'delete' | 'reaction' | 'mention' | 'rich_cards' | 'sync_reply' | 'typing' | 'ephemeral' | 'proactive' | 'commands' | 'presence';
+export interface AdapterManifest {
+    readonly id: string;
+    readonly name: string;
+    readonly version: string;
+    readonly capabilities: readonly AdapterCapability[];
+    readonly description?: string;
+    readonly configSchema?: object | string;
+    readonly envVars?: readonly string[];
+    readonly homepage?: string;
+    readonly sdkVersion?: string;
+    readonly platform?: string;
+}
+export interface IChannelAdapter<TConfig = unknown> {
+    readonly manifest: AdapterManifest;
+    start(ctx: AdapterContext<TConfig>): Promise<void>;
+    stop(ctx: AdapterContext<TConfig>): Promise<void>;
+    send(ctx: AdapterContext<TConfig>, msg: OutboundMessage): Promise<SendResult>;
+    healthcheck?(ctx: AdapterContext<TConfig>): Promise<HealthStatus>;
+    validateConfig?(raw: unknown): TConfig;
+    describe?(): AdapterManifest;
+    handleUninstall?(ctx: AdapterContext<TConfig>): Promise<void>;
+    getInstallUrl?(state: InstallState): Promise<string>;
+    completeInstall?(callback: InstallCallback): Promise<TConfig>;
+}
+export interface InstallState {
+    readonly instanceId: string;
+    readonly nonce: string;
+    readonly redirectUri: string;
+    readonly scopes?: readonly string[];
+}
+export interface InstallCallback {
+    readonly query: Readonly<Record<string, string>>;
+    readonly nonce: string;
+}
+export interface AdapterContext<TConfig = unknown> {
+    readonly instanceId: string;
+    readonly installationId?: string;
+    readonly config: TConfig;
+    readonly capabilities: ReadonlySet<AdapterCapability>;
+    readonly log: Logger;
+    readonly agentRunner: AgentRunner;
+    readonly db: AdapterStore;
+    readonly storage: BlobStorage;
+    readonly audit: AuditSink;
+    readonly abortSignal: AbortSignal;
+    readonly httpRouter: HttpRouter;
+    inbound(msg: InboundMessage): Promise<RouteResolution>;
+    emitEvent(event: InboundEvent): Promise<EventResolution>;
+    updateMessage(messageId: string, patch: Partial<OutboundMessage>): Promise<void>;
+    resolveUser(userId: string): Promise<ResolvedUser>;
+    respondSync(payload: OutboundMessage | {
+        text: string;
+        raw?: unknown;
+    }): Promise<void>;
+    proactive?(threadId: string, msg: OutboundMessage): Promise<SendResult>;
+}
+export interface ResolvedUser {
+    readonly userId: string;
+    readonly displayName: string;
+    readonly email?: string;
+    readonly raw?: unknown;
+}
+export interface RouteResolution {
+    readonly accepted: boolean;
+    readonly reason?: string;
+    readonly output?: string;
+}
+export interface EventResolution {
+    readonly accepted: boolean;
+    readonly reason?: string;
+}
+export interface HttpRouter {
+    registerRoute(path: string, handler: (req: RawRequest, res: RawResponse) => Promise<void>, opts?: RouteOptions): void;
+}
+export interface RouteOptions {
+    readonly requireSignature?: {
+        readonly headerName: string;
+        readonly verify: (rawBody: Buffer, signature: string) => boolean;
+    };
+    readonly rateLimit?: {
+        readonly requestsPerMin: number;
+    };
+    readonly timeoutMs?: number;
+}
+export interface RawRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string | string[] | undefined>>;
+    readonly body: Buffer;
+    readonly params: Readonly<Record<string, string>>;
+    readonly query: Readonly<Record<string, string | string[] | undefined>>;
+}
+export interface RawResponse {
+    status(code: number): RawResponse;
+    set(field: string, value: string): RawResponse;
+    send(body: Buffer | string): RawResponse;
+    json(body: unknown): RawResponse;
+    end(): RawResponse;
+}
+export interface InboundMessage {
+    readonly id: string;
+    readonly threadId: string;
+    readonly userId: string;
+    readonly text: string;
+    readonly receivedAt: number;
+    readonly attachments?: readonly {
+        readonly url: string;
+        readonly mimeType?: string;
+        readonly name?: string;
+    }[];
+    readonly mentions?: readonly {
+        readonly userId: string;
+        readonly displayName: string;
+    }[];
+    readonly routingHints?: {
+        readonly agentId?: string;
+        readonly policyTags?: readonly string[];
+    };
+    readonly raw?: unknown;
+}
+export interface OutboundMessage {
+    readonly threadId: string;
+    readonly text: string;
+    readonly markdown?: boolean;
+    readonly actions?: readonly {
+        readonly id: string;
+        readonly label: string;
+        readonly value?: string;
+        readonly blockId?: string;
+    }[];
+    readonly attachments?: readonly {
+        readonly url: string;
+        readonly mimeType?: string;
+        readonly name?: string;
+    }[];
+    readonly cards?: readonly RichCard[];
+    readonly ephemeralFor?: string;
+    readonly replyToId?: string;
+    readonly editOf?: string;
+    readonly raw?: unknown;
+}
+export interface RichCard {
+    readonly id: string;
+    readonly title?: string;
+    readonly body?: string;
+    readonly elements?: readonly RichCardElement[];
+    readonly raw?: unknown;
+}
+export type RichCardElement = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'button';
+    readonly id: string;
+    readonly label: string;
+    readonly value?: string;
+    readonly blockId?: string;
+} | {
+    readonly type: 'image';
+    readonly url: string;
+    readonly alt?: string;
+};
+export type InboundEvent = {
+    readonly type: 'action';
+    readonly actionId: string;
+    readonly blockId?: string;
+    readonly threadId: string;
+    readonly userId: string;
+    readonly value?: string;
+    readonly raw?: unknown;
+} | {
+    readonly type: 'edit';
+    readonly messageId: string;
+    readonly threadId: string;
+    readonly text: string;
+} | {
+    readonly type: 'delete';
+    readonly messageId: string;
+    readonly threadId: string;
+} | {
+    readonly type: 'reaction';
+    readonly messageId: string;
+    readonly threadId: string;
+    readonly userId: string;
+    readonly emoji: string;
+    readonly added: boolean;
+} | {
+    readonly type: 'space_joined' | 'space_left';
+    readonly threadId: string;
+    readonly userId?: string;
+    readonly raw?: unknown;
+} | {
+    readonly type: 'member_joined' | 'member_left';
+    readonly threadId: string;
+    readonly userId: string;
+    readonly raw?: unknown;
+} | {
+    readonly type: 'command';
+    readonly commandId: string;
+    readonly threadId: string;
+    readonly userId: string;
+    readonly text: string;
+    readonly raw?: unknown;
+};
+export interface SendResult {
+    readonly messageId: string;
+    readonly sentAt: number;
+}
+export interface HealthStatus {
+    readonly ok: boolean;
+    readonly details?: Record<string, unknown>;
+}
+export declare class AdapterError extends Error {
+    readonly code: string;
+    readonly kind: 'transient' | 'permanent' | 'config';
+    readonly retryAfterMs?: number;
+    constructor(code: string, kind: 'transient' | 'permanent' | 'config', retryAfterMs?: number);
+}
+export interface Logger {
+    debug(msg: string, meta?: Record<string, unknown>): void;
+    info(msg: string, meta?: Record<string, unknown>): void;
+    warn(msg: string, meta?: Record<string, unknown>): void;
+    error(msg: string, meta?: Record<string, unknown>): void;
+}
+export interface AgentRunner {
+    run(agentId: string, message: string, opts?: {
+        readonly threadId?: string;
+    }): Promise<{
+        readonly output: string;
+    }>;
+}
+export interface AdapterStore {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set<T = unknown>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    list(prefix?: string): Promise<readonly string[]>;
+}
+export interface BlobStorage {
+    put(key: string, data: Buffer, contentType?: string): Promise<string>;
+    get(key: string): Promise<Buffer | undefined>;
+    delete(key: string): Promise<boolean>;
+}
+export interface AuditSink {
+    log(event: string, payload: Record<string, unknown>): Promise<void>;
+}
+export interface ChannelAdapterRegistration<TConfig = unknown> {
+    readonly adapter: IChannelAdapter<TConfig>;
+    readonly instanceId: string;
+    readonly config: TConfig;
+    readonly installationId?: string;
+    readonly store?: AdapterStore;
+    readonly agentRunner?: AgentRunner;
+    readonly defaultMode?: 'query' | 'execute';
+    readonly defaultAgent?: string;
+    readonly onInbound?: (msg: InboundMessage) => Promise<RouteResolution>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapter/types.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Adapter Platform v0.4 — core types.
+ * PoC corrections applied:
+ *   1. AdapterError: class only (interface removed)
+ *   2. kind: added 'config' for configuration errors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterError = void 0;
+class AdapterError extends Error {
+    code;
+    kind;
+    retryAfterMs;
+    constructor(code, kind, retryAfterMs) {
+        super(`AdapterError: ${code}`);
+        this.name = 'AdapterError';
+        this.code = code;
+        this.kind = kind;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.AdapterError = AdapterError;
+//# sourceMappingURL=types.js.map

package/dist/agent/resolver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Agent resolver: looks up an agent from a list by ref.
+ * Supports both bare id ('claude') and @mention format ('@claude').
+ * Falls back to built-in provider shorthands (claude, gemini, copilot, codex).
+ */
+import type { AgentConfig } from '../types';
+export declare class AgentNotFoundError extends Error {
+    constructor(agentRef: string, availableIds: string[]);
+}
+/**
+ * Resolve an agent by reference.
+ * @param agentRef - Agent reference: '@claude', 'claude', '@my_agent', etc.
+ * @param agents   - List of available agent configs.
+ * @returns The matching AgentConfig.
+ * @throws AgentNotFoundError when no match is found.
+ */
+export declare function resolveAgent(agentRef: string, agents: AgentConfig[]): AgentConfig;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/agent/resolver.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Agent resolver: looks up an agent from a list by ref.
+ * Supports both bare id ('claude') and @mention format ('@claude').
+ * Falls back to built-in provider shorthands (claude, gemini, copilot, codex).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentNotFoundError = void 0;
+exports.resolveAgent = resolveAgent;
+class AgentNotFoundError extends Error {
+    constructor(agentRef, availableIds) {
+        const available = availableIds.length > 0
+            ? ` Available: ${availableIds.join(', ')}`
+            : '';
+        super(`Agent not found: "${agentRef}".${available}`);
+        this.name = 'AgentNotFoundError';
+    }
+}
+exports.AgentNotFoundError = AgentNotFoundError;
+/** Built-in provider shorthands that can be used without a crewx.yaml entry. */
+const BUILTIN_PROVIDERS = {
+    claude: { id: 'claude', provider: 'cli/claude' },
+    gemini: { id: 'gemini', provider: 'cli/gemini' },
+    copilot: { id: 'copilot', provider: 'cli/copilot' },
+    codex: { id: 'codex', provider: 'cli/codex' },
+};
+/**
+ * Resolve an agent by reference.
+ * @param agentRef - Agent reference: '@claude', 'claude', '@my_agent', etc.
+ * @param agents   - List of available agent configs.
+ * @returns The matching AgentConfig.
+ * @throws AgentNotFoundError when no match is found.
+ */
+function resolveAgent(agentRef, agents) {
+    const agentId = agentRef.startsWith('@') ? agentRef.slice(1) : agentRef;
+    // 1. Look in YAML-defined agents first
+    const agent = agents.find(a => a.id === agentId);
+    if (agent)
+        return agent;
+    // 2. Fall back to built-in provider shorthands
+    const builtin = BUILTIN_PROVIDERS[agentId];
+    if (builtin)
+        return builtin;
+    throw new AgentNotFoundError(agentRef, agents.map(a => a.id));
+}
+//# sourceMappingURL=resolver.js.map

package/dist/boxing/box-storage.interface.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Box storage interfaces — used by SdkBoxService and buildContext.
+ */
 import type { BoxRow, InsertBoxData, ThreadMessage } from './box.types';
 export interface IBoxStorage {
     listBoxes(threadId: string): BoxRow[];
@@ -11,3 +14,12 @@ export interface ITaskReader {
 export interface ITokenizer {
     countTokens(text: string): number;
 }
+import type { BoxResponse } from './box.types';
+export interface IBoxServiceReader {
+    listBoxes(threadId: string): {
+        boxes: BoxResponse[];
+        total: number;
+    };
+    getBox(threadId: string, boxId: string): BoxResponse | null;
+}
+//# sourceMappingURL=box-storage.interface.d.ts.map

package/dist/boxing/box-storage.interface.js

@@ -1,3 +1,6 @@
 "use strict";
+/**
+ * Box storage interfaces — used by SdkBoxService and buildContext.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=box-storage.interface.js.map

package/dist/boxing/box.service.d.ts

@@ -1,3 +1,6 @@
+/**
+ * SdkBoxService — manages box creation, retrieval, and listing.
+ */
 import type { IBoxStorage } from './box-storage.interface';
 import type { BoxResponse, CreateBoxParams } from './box.types';
 export declare class SdkBoxService {
@@ -13,3 +16,4 @@ export declare class SdkBoxService {
     private validateId;
     private generateBoxId;
 }
+//# sourceMappingURL=box.service.d.ts.map

package/dist/boxing/box.service.js

@@ -1,9 +1,13 @@
 "use strict";
+/**
+ * SdkBoxService — manages box creation, retrieval, and listing.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SdkBoxService = void 0;
-const id_1 = require("../core/id");
+const id_1 = require("../utils/id");
 const ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
 class SdkBoxService {
+    storage;
     constructor(storage) {
         this.storage = storage;
     }