@dsbot-channel/p2p 0.0.0-stage → 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zerodegress
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assets/skill.md

@@ -0,0 +1,17 @@
+### p2p transport
+
+| Field | Default | Meaning |
+| --- | --- | --- |
+| `listen.host` | `127.0.0.1` | concrete address only |
+| `listen.port` | `7123` | |
+| `peers` | required | list or mapping of peer instance to secret reference; a list entry also carries `url`, `host`, `botName` |
+| `dedupe.ttlMs` / `dedupe.limit` | | dedupe window and size |
+| `inflightTtlMs` | `300000` | stale claim is reclaimed after this |
+| `sentAtWindowMs` | `300000` | freshness window for the signature |
+| `maxBodyBytes` | | request body limit |
+| `waitMs` | | how long a duplicate waits |
+
+`peers[].instance` is the peer's name, not this link's — this is the one place a name is not this adapter's `channel`. Two entries of one peer instance must reference different secrets.
+
+`@dsbot-channel/p2p` supplies this transport: mount it after `@dsbot-channel/core`, then write these fields under `transport` in this plugin's own `config`, beside `channel` and `botName`; `kind` is not written. Each entry is one instance, so the same package mounts twice with two different `channel` values. Without `@dsbot-channel/core` the plugin stays pending on `dsbot-channel.registry`.
+

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsbot-channel-p2p
+      name: '@dsbot-channel/p2p'

package/dist/adapter.d.ts

@@ -0,0 +1,82 @@
+import type { AdapterStatus } from '@dsbot-channel/core/adapter-status.js';
+import type { ChannelSnapshot } from '@dsbot-channel/core/channel-stats.js';
+import type { AdapterCheckSettings, RefuseInput, RefuseResult, AdapterHandle, AdapterPorts, ChannelAdapter, InboundMessage, SendInput, SendResult } from '@dsbot-channel/core/contract.js';
+import type { Scope } from '@dsbot-channel/core/event-types.js';
+import type { InboundRequest } from './p2p-wire.js';
+import type { PeerRef } from './p2p-secrets.js';
+export declare const DEFAULT_INFLIGHT_TTL_MS = 300000;
+/** Longest note a refusal carries on the wire, one line. */
+export declare const REFUSE_NOTE_MAX = 200;
+export interface P2PPeerConfig extends PeerRef {
+    url?: string;
+}
+export interface P2PAdapterConfig {
+    channel: string;
+    botName: string;
+    peers: readonly P2PPeerConfig[];
+    listen?: {
+        host?: string;
+        port?: number;
+    } | undefined;
+    dedupe?: {
+        ttlMs?: number;
+        limit?: number;
+    } | undefined;
+    inflightTtlMs?: number | undefined;
+    sentAtWindowMs?: number | undefined;
+    maxBodyBytes?: number | undefined;
+    waitMs?: number | undefined;
+    status?: boolean | undefined;
+}
+export interface P2PAdapterOptions {
+    warn?: ((message: string) => void) | undefined;
+    now?: (() => number) | undefined;
+}
+/** The p2p transport behind the adapter contract: one configured channel, one listener. */
+export declare class P2PAdapter implements ChannelAdapter {
+    #private;
+    readonly kind = "p2p";
+    readonly guidance: {
+        peer: string;
+        group: string;
+    };
+    readonly capabilities: {
+        text: boolean;
+        image: {
+            in: boolean;
+            out: boolean;
+            fromUrl: boolean;
+            fromHandle: boolean;
+        };
+        file: {
+            in: boolean;
+            out: boolean;
+            fromUrl: boolean;
+            fromHandle: boolean;
+        };
+        voice: {
+            in: boolean;
+            out: boolean;
+            fromUrl: boolean;
+            fromHandle: boolean;
+        };
+        recall: boolean;
+        history: import("@dsbot-channel/core/adapter-status.js").HistoryCapability;
+        mention: boolean;
+        reply: boolean;
+        stream: boolean;
+    };
+    constructor(config: P2PAdapterConfig, options?: P2PAdapterOptions);
+    get snapshot(): ChannelSnapshot;
+    checkConfig(settings: AdapterCheckSettings): void;
+    sessionScope(key: string): Scope | undefined;
+    checkSessionKey(key: string): string | undefined;
+    checkTarget(target: string): string | undefined;
+    describeTargets(): string;
+    status(): AdapterStatus;
+    send(input: SendInput): Promise<SendResult>;
+    refuse(input: RefuseInput): Promise<RefuseResult>;
+    start(ports: AdapterPorts): Promise<AdapterHandle>;
+    /** Maps a verified wire request onto the inbound message core takes; the adapter owns every field. */
+    toInbound(request: InboundRequest): InboundMessage;
+}

package/dist/adapter.js

@@ -0,0 +1,324 @@
+import { NO_HISTORY, buildListenerHealth, buildStatus } from '@dsbot-channel/core/adapter-status.js';
+import { countersOf } from '@dsbot-channel/core/channel-stats.js';
+import { ChannelStats } from '@dsbot-channel/core/channel-stats.js';
+import { ConfigError } from '@dsbot-channel/core/config.js';
+import { REPLY_TARGET_MAX, SESSION_KEY_MAX, tokenProblem } from '@dsbot-channel/core/contract.js';
+import { GROUP_GUIDANCE, PEER_GUIDANCE } from './guidance.js';
+import { DedupeTable } from './p2p-dedupe.js';
+import { DEFAULT_HOST, DEFAULT_PORT, checkListenerConfig, startListener } from './p2p-listener.js';
+import { STATUS_ROUTE } from './p2p-status.js';
+import { cleanExcerpt, oneLine, toP2PEvent } from './p2p-mapping.js';
+import { DECLINED, DEFAULT_SENT_AT_WINDOW_MS, MAX_BODY_BYTES } from './p2p-protocol.js';
+import { sendToPeer } from './p2p-send.js';
+export const DEFAULT_INFLIGHT_TTL_MS = 300_000;
+/** Longest note a refusal carries on the wire, one line. */
+export const REFUSE_NOTE_MAX = 200;
+const DEFAULT_DEDUPE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_DEDUPE_LIMIT = 100_000;
+function wholeMs(field, value, atLeast) {
+    if (!Number.isInteger(value) || value < atLeast) {
+        throw new ConfigError(`${field} must be a whole number of milliseconds, at least ${atLeast}: ${value}`, [
+            'adapters',
+            'p2p',
+            field,
+        ]);
+    }
+    return value;
+}
+/** The p2p transport behind the adapter contract: one configured channel, one listener. */
+export class P2PAdapter {
+    kind = 'p2p';
+    guidance = { peer: PEER_GUIDANCE, group: GROUP_GUIDANCE };
+    capabilities = {
+        text: true,
+        image: { in: true, out: true, fromUrl: true, fromHandle: false },
+        file: { in: true, out: true, fromUrl: true, fromHandle: false },
+        voice: { in: true, out: true, fromUrl: true, fromHandle: false },
+        recall: false,
+        history: NO_HISTORY,
+        mention: false,
+        reply: true,
+        stream: false,
+    };
+    #config;
+    #options;
+    #stats;
+    #now;
+    #table;
+    #ports;
+    #lastSuccessAt = null;
+    #lastSendFailure = null;
+    constructor(config, options = {}) {
+        this.#config = config;
+        this.#options = options;
+        this.#stats = new ChannelStats(options.now);
+        this.#now = options.now ?? Date.now;
+    }
+    get snapshot() {
+        return this.#stats.snapshot();
+    }
+    /** Records how one send ended: a success timestamps the link, a failure keeps the peer and the code. */
+    #settleSend(instance, result) {
+        const at = this.#now();
+        if (result.ok) {
+            this.#lastSuccessAt = at;
+            return result;
+        }
+        this.#stats.sendFailed(result.code);
+        this.#lastSendFailure = { at, instance, reason: result.code };
+        return result;
+    }
+    checkConfig(settings) {
+        if (this.#config.peers.length === 0) {
+            throw new ConfigError('at least one peer is required for each p2p adapter', ['adapters', 'p2p', 'peers']);
+        }
+        const host = this.#config.listen?.host ?? DEFAULT_HOST;
+        checkListenerConfig({
+            botName: this.#config.botName,
+            peers: this.#config.peers,
+            credentials: { resolve: () => Promise.resolve(undefined) },
+            inflightTtlMs: this.#config.inflightTtlMs ?? DEFAULT_INFLIGHT_TTL_MS,
+            maxBodyBytes: this.#config.maxBodyBytes ?? MAX_BODY_BYTES,
+            listen: { host },
+        });
+        const window = this.#config.sentAtWindowMs ?? DEFAULT_SENT_AT_WINDOW_MS;
+        wholeMs('sentAtWindowMs', window, 1);
+        const inflight = this.#config.inflightTtlMs ?? DEFAULT_INFLIGHT_TTL_MS;
+        if (!Number.isInteger(inflight) || inflight <= settings.maxTurnMs) {
+            throw new ConfigError(`inflightTtlMs must exceed maxTurnMs: ${inflight} <= ${settings.maxTurnMs}`, ['adapters', 'p2p', 'inflightTtlMs']);
+        }
+        const bodyLimit = this.#config.maxBodyBytes ?? MAX_BODY_BYTES;
+        wholeMs('maxBodyBytes', bodyLimit, 1);
+        if (this.#config.waitMs !== undefined)
+            wholeMs('waitMs', this.#config.waitMs, 1);
+        this.#table = new DedupeTable({
+            ttlMs: this.#config.dedupe?.ttlMs ?? DEFAULT_DEDUPE_TTL_MS,
+            limit: this.#config.dedupe?.limit ?? DEFAULT_DEDUPE_LIMIT,
+            inflightTtlMs: inflight,
+            maxTurnMs: settings.maxTurnMs,
+            ...(this.#options.now === undefined ? {} : { now: this.#options.now }),
+        });
+    }
+    sessionScope(key) {
+        return key.startsWith('p2p:') ? 'p2p' : undefined;
+    }
+    checkSessionKey(key) {
+        const shape = tokenProblem('session key', key, SESSION_KEY_MAX);
+        if (shape !== undefined)
+            return shape;
+        if (!key.startsWith('p2p:'))
+            return `a p2p session key starts with "p2p:", got "${key}"`;
+        const peer = key.slice('p2p:'.length);
+        if (peer.length === 0)
+            return 'a p2p session key names a peer after "p2p:"';
+        return this.#peer(peer) === undefined ? `this adapter addresses no peer "${peer}"` : undefined;
+    }
+    checkTarget(target) {
+        const shape = tokenProblem('target', target, REPLY_TARGET_MAX);
+        if (shape !== undefined)
+            return shape;
+        return this.#peer(target) === undefined ? `this adapter addresses no peer "${target}"` : undefined;
+    }
+    describeTargets() {
+        return this.#config.peers.map((peer) => peer.instance).join(', ');
+    }
+    status() {
+        const snapshot = this.#stats.snapshot();
+        const listening = snapshot.state === 'listening';
+        const failed = snapshot.state === 'failed';
+        return buildStatus({
+            channel: this.#config.channel,
+            account: this.#config.channel,
+            bot: this.#config.botName,
+            health: buildListenerHealth({
+                listenState: listening ? 'listening' : failed ? 'failed' : 'stopped',
+                boundPort: snapshot.boundPort,
+                lastAuthenticatedAt: snapshot.lastAuthenticatedAt,
+                lastSkewMs: snapshot.lastSkewMs,
+                lastFailure: snapshot.lastFailure,
+                queueDepth: snapshot.inFlight,
+            }),
+            counters: countersOf(snapshot),
+            capabilities: this.capabilities,
+            attributes: { stableMessageId: true },
+            quota: { softLimit: 0, hardLimit: 0 },
+            sampledAt: snapshot.sampledAt,
+            queueDepth: snapshot.inFlight,
+            ...(this.#table === undefined ? {} : { dedupe: { epoch: this.#table.epoch } }),
+            lastSuccessAt: this.#lastSuccessAt,
+            lastSendFailure: this.#lastSendFailure === null ? null : { ...this.#lastSendFailure },
+        });
+    }
+    async send(input) {
+        const ports = this.#ports;
+        if (ports === undefined) {
+            return { ok: false, code: 'unreachable', retryable: true, reason: 'the p2p adapter is not started' };
+        }
+        const peer = this.#peer(input.target);
+        if (peer === undefined) {
+            return { ok: false, code: 'no_url', retryable: false, reason: `this adapter addresses no peer "${input.target}"` };
+        }
+        const to = input.to ?? peer.botName ?? '';
+        if (to.length === 0) {
+            return {
+                ok: false,
+                code: 'no_url',
+                retryable: false,
+                reason: `peer "${peer.instance}" names no bot, so this message has no recipient`,
+            };
+        }
+        const target = {
+            instance: peer.instance,
+            secret: peer.secret,
+            ...(peer.url === undefined ? {} : { url: peer.url }),
+            ...(peer.host === undefined ? {} : { host: peer.host }),
+        };
+        const offered = input.media ?? [];
+        const usable = offered.filter((item) => item.url !== null && /^https?:\/\/[^\s]+$/i.test(item.url));
+        if (offered.length > 0 && usable.length < offered.length) {
+            this.#options.warn?.(`dsbot-channel: dropped ${offered.length - usable.length} media item(s) from ${input.eventId}: p2p carries http(s) urls only`);
+        }
+        if (usable.length === 0 && input.body.length === 0) {
+            return {
+                ok: false,
+                code: 'no_url',
+                retryable: false,
+                reason: 'every media item was dropped and the body is empty, so there is nothing a peer could accept',
+            };
+        }
+        const media = usable.map((item) => item.name === undefined
+            ? [item.type, item.url]
+            : [item.type, item.url, item.name]);
+        const result = await sendToPeer({
+            peer: target,
+            ...(input.chainId === undefined ? {} : { chainId: input.chainId }),
+            credentials: this.#credentials(ports),
+            to,
+            body: input.body,
+            ...(media.length === 0 ? {} : { media }),
+            eventId: input.eventId,
+            sender: this.#config.botName,
+            instance: this.#config.channel,
+            ...(input.sentAt === undefined ? {} : { sentAt: input.sentAt }),
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            ...(input.inReplyTo === undefined ? {} : { inReplyTo: input.inReplyTo }),
+            ...(input.inReplyToText === undefined ? {} : { inReplyToExcerpt: cleanExcerpt(input.inReplyToText) }),
+        });
+        return this.#settleSend(peer.instance, result);
+    }
+    async refuse(input) {
+        const ports = this.#ports;
+        if (ports === undefined) {
+            return { ok: false, code: 'unreachable', reason: 'the p2p adapter is not started' };
+        }
+        const peer = this.#peer(input.target);
+        if (peer === undefined) {
+            return { ok: false, code: 'no_url', reason: `this adapter addresses no peer "${input.target}"` };
+        }
+        const to = input.to ?? peer.botName ?? '';
+        if (to.length === 0) {
+            return { ok: false, code: 'no_url', reason: `peer "${peer.instance}" names no bot, so a refusal has no recipient` };
+        }
+        const target = {
+            instance: peer.instance,
+            secret: peer.secret,
+            ...(peer.url === undefined ? {} : { url: peer.url }),
+            ...(peer.host === undefined ? {} : { host: peer.host }),
+        };
+        const result = await sendToPeer({
+            peer: target,
+            credentials: this.#credentials(ports),
+            to,
+            body: oneLine(input.note, REFUSE_NOTE_MAX) || DECLINED,
+            eventId: `decline:${input.inReplyTo}`,
+            chainId: input.chainId,
+            sender: this.#config.botName,
+            instance: this.#config.channel,
+            status: 'declined',
+            reason: input.reason,
+            final: true,
+        });
+        this.#settleSend(peer.instance, result);
+        return result.ok ? { ok: true } : { ok: false, code: result.code, reason: result.reason };
+    }
+    async start(ports) {
+        const table = this.#table;
+        if (table === undefined)
+            throw new Error('p2p: checkConfig must run before start');
+        this.#ports = ports;
+        const listener = await startListener({
+            config: {
+                botName: this.#config.botName,
+                peers: this.#config.peers,
+                credentials: this.#credentials(ports),
+                inflightTtlMs: this.#config.inflightTtlMs ?? DEFAULT_INFLIGHT_TTL_MS,
+                maxBodyBytes: this.#config.maxBodyBytes ?? MAX_BODY_BYTES,
+                ...(this.#config.sentAtWindowMs === undefined ? {} : { sentAtWindowMs: this.#config.sentAtWindowMs }),
+                ...(this.#config.waitMs === undefined ? {} : { waitMs: this.#config.waitMs }),
+                ...(this.#options.warn === undefined ? {} : { warn: this.#options.warn }),
+                listen: { host: this.#config.listen?.host ?? DEFAULT_HOST, port: this.#config.listen?.port ?? DEFAULT_PORT },
+            },
+            table,
+            stats: this.#stats,
+            onMessage: (request) => {
+                void ports
+                    .onMessage(this.toInbound(request))
+                    .then((verdict) => {
+                    if (!verdict.ok)
+                        this.#options.warn?.(`dsbot-channel: kept ${request.eventId} from ${request.instance} out of a turn: ${verdict.code} ${verdict.reason}`);
+                })
+                    .catch((error) => {
+                    this.#options.warn?.(`dsbot-channel: handing off ${request.eventId} from ${request.instance} failed: ${String(error)}`);
+                });
+            },
+            onError: (error, request) => {
+                this.#options.warn?.(`dsbot-channel: handing off ${request.eventId} from ${request.instance} failed: ${String(error)}`);
+            },
+            ...(this.#config.status === false
+                ? {}
+                : {
+                    status: {
+                        route: STATUS_ROUTE,
+                        report: () => this.status(),
+                    },
+                }),
+        });
+        return {
+            stop: async () => {
+                await listener.close();
+            },
+            address: () => ({ port: listener.address().port }),
+        };
+    }
+    /** Maps a verified wire request onto the inbound message core takes; the adapter owns every field. */
+    toInbound(request) {
+        const event = toP2PEvent({ ...request, messageId: `p2p-${request.eventId}` });
+        return {
+            eventKey: event.meta.derived.eventKey,
+            sessionKey: `p2p:${request.instance}`,
+            replyTarget: request.instance,
+            chainId: request.chainId,
+            requestId: request.eventId,
+            ...(request.status === 'declined' ? { suppressed: true } : {}),
+            source: event.source,
+            author: event.author,
+            rawText: request.body,
+            body: event.body,
+            transport: event.meta.transport,
+            declared: event.meta.declared,
+            adapter: event.meta.adapter,
+            receivedAt: this.#now(),
+        };
+    }
+    #peer(instance) {
+        return this.#config.peers.find((peer) => peer.instance === instance);
+    }
+    #credentials(ports) {
+        return {
+            resolve: async (reference) => {
+                const value = await ports.resolveSecret(reference);
+                return value === undefined ? undefined : { value };
+            },
+        };
+    }
+}

package/dist/guidance.d.ts

@@ -0,0 +1,2 @@
+export declare const PEER_GUIDANCE = "This is a peer message from another bot. Answer it with your reply as usual. If it needs no answer, call no_reply instead of staying silent. If you refuse it, call decline with a short reason.";
+export declare const GROUP_GUIDANCE = "This is a message from an external group chat. Your reply is posted to that group. To address one member only, call send_text.";

package/dist/guidance.js

@@ -0,0 +1,2 @@
+export const PEER_GUIDANCE = 'This is a peer message from another bot. Answer it with your reply as usual. If it needs no answer, call no_reply instead of staying silent. If you refuse it, call decline with a short reason.';
+export const GROUP_GUIDANCE = 'This is a message from an external group chat. Your reply is posted to that group. To address one member only, call send_text.';

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import type { AdapterFactory, AdapterMount } from '@dsbot-channel/core/adapter-registry.js';
+import type { P2PAdapterConfig } from './adapter.js';
+/** Reads the transport block a profile declared, refusing a field this adapter never reads. */
+export declare function parseP2PConfig(mount: AdapterMount): P2PAdapterConfig;
+export declare const createP2PAdapter: AdapterFactory;
+export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+    channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+    transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+    transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+}>>, "plain">;
+export declare const apply: (ctx: import("@deepseek-ai/cordis").Context, config?: Record<string, unknown>) => void;
+export declare const plugin: {
+    name: string;
+    inject: string[];
+    Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, "plain">;
+    apply: (ctx: import("@deepseek-ai/cordis").Context, config?: Record<string, unknown>) => void;
+};
+declare const _default: {
+    name: string;
+    inject: string[];
+    Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        channel: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        botName: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        anchor: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        session: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        model: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        reply: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        turn: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        delivery: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        policy: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        pipeline: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        events: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+        status: import("@deepseek-ai/schemastery").default<boolean, boolean, "plain">;
+        transport: import("@deepseek-ai/schemastery").default<any, any, "plain">;
+    }>>, "plain">;
+    apply: (ctx: import("@deepseek-ai/cordis").Context, config?: Record<string, unknown>) => void;
+};
+export default _default;