@tomradex/plugin-sdk 0.0.0-stage → 0.2.16

package/dist/exports.js

@@ -0,0 +1,73 @@
+import { SDK_CONTRACT } from "./manifest.js";
+import { compareVersions, parseVersion, satisfies } from "./semver.js";
+/**
+ * The contract each value the SDK exports first shipped in. A plugin imports
+ * the SDK from the Tomrade it runs in, not from its own bundle, so a name the
+ * oldest Tomrade its `engines.sdk` accepts does not have fails the plugin as it
+ * loads. A new export is listed here under the contract it ships in.
+ */
+export const SDK_EXPORTS = {
+    ContributesSchema: "0.2.0",
+    MANIFEST_FILE: "0.2.0",
+    ManifestSchema: "0.2.0",
+    NAMESPACE: "0.2.0",
+    OFFICIAL_PUBLISHER: "0.2.0",
+    OSI_LICENSES: "0.2.0",
+    PLUGIN_ID: "0.2.0",
+    PermissionsSchema: "0.2.0",
+    RESERVED_NAMESPACES: "0.2.0",
+    SDK_CONTRACT: "0.2.0",
+    SDK_PLUGIN: "0.2.0",
+    ToolInputError: "0.2.0",
+    assertOwned: "0.2.0",
+    compareVersions: "0.2.0",
+    definePlugin: "0.2.0",
+    defineTool: "0.2.0",
+    isOpenSource: "0.2.0",
+    isSdkPlugin: "0.2.0",
+    isVersion: "0.2.0",
+    nameOf: "0.2.0",
+    namespaceOf: "0.2.0",
+    ownsId: "0.2.0",
+    parseManifest: "0.2.0",
+    parseVersion: "0.2.0",
+    publisherOf: "0.2.0",
+    requireProjectId: "0.2.0",
+    riskOf: "0.2.0",
+    satisfies: "0.2.0",
+    ImDeliveryError: "0.2.1",
+    IM_CAPABILITIES_V2: "0.2.5",
+    IM_MARKDOWN_DIALECTS: "0.2.5",
+    ImCapabilitiesSchema: "0.2.5",
+    resolveImCapabilities: "0.2.5",
+    splitImText: "0.2.5",
+    toImDialect: "0.2.5",
+    isRange: "0.2.7",
+    LANGUAGE_PACK_LIMITS: "0.2.8",
+    LanguageEntrySchema: "0.2.8",
+    LanguagePackFileSchema: "0.2.8",
+    languageCoverage: "0.2.8",
+    parseLanguagePack: "0.2.8",
+    slotsOf: "0.2.8",
+    SDK_EXPORTS: "0.2.9",
+    lowestContract: "0.2.9",
+    pickLanguage: "0.2.9",
+    wordsFor: "0.2.9",
+    RowSchema: "0.2.13",
+    CLI_HOOK_COVERAGE: "0.2.15",
+    CLI_HOOK_EVENTS: "0.2.15"
+};
+/** The oldest contract `range` accepts, up to this SDK's own; null when it accepts none of them. */
+export function lowestContract(range) {
+    const known = [...Object.values(SDK_EXPORTS), SDK_CONTRACT];
+    // Every patch of each minor the SDK has shipped, since a contract that added no export is still one a Tomrade may run.
+    const lines = new Map();
+    for (const v of known) {
+        const p = parseVersion(v);
+        if (p)
+            lines.set(`${p[0]}.${p[1]}`, Math.max(lines.get(`${p[0]}.${p[1]}`) ?? 0, p[2]));
+    }
+    const candidates = [...lines].flatMap(([line, last]) => Array.from({ length: last + 1 }, (_, patch) => `${line}.${patch}`)).sort(compareVersions);
+    return candidates.find((v) => compareVersions(v, SDK_CONTRACT) <= 0 && satisfies(v, range)) ?? null;
+}
+//# sourceMappingURL=exports.js.map

package/dist/im-markdown.d.ts

@@ -0,0 +1,10 @@
+import type { ImMarkdownDialect } from "./im.js";
+/** Converts the common layer's Markdown into an adapter's dialect. */
+export declare function toImDialect(markdown: string, dialect: ImMarkdownDialect): string;
+/**
+ * Splits Markdown into messages that each fit `max` once converted, breaking
+ * between lines. A code block stays whole when it fits a message; a longer one
+ * is closed and reopened with its language rather than cut mid-fence.
+ */
+export declare function splitImText(markdown: string, max: number, dialect?: ImMarkdownDialect): string[];
+//# sourceMappingURL=im-markdown.d.ts.map

package/dist/im-markdown.js

@@ -0,0 +1,257 @@
+const ESCAPABLE = /[\\`*_~[\]()#>+\-.!|{}]/;
+function inline(src) {
+    const out = [];
+    let v = "", raw = "", i = 0;
+    const flush = () => { if (raw)
+        out.push({ t: "text", v, raw }); v = raw = ""; };
+    const span = (open, close = open) => {
+        if (!src.startsWith(open, i) || /\s/.test(src[i + open.length] ?? " "))
+            return -1;
+        if (open === "_" && /[\p{L}\p{N}]/u.test(src[i - 1] ?? ""))
+            return -1;
+        for (let j = src.indexOf(close, i + open.length + 1); j > 0; j = src.indexOf(close, j + 1)) {
+            if (/\s/.test(src[j - 1]))
+                continue;
+            // A single delimiter must not be half of a double one.
+            if (close.length === 1 && (src[j + 1] === close || src[j - 1] === close))
+                continue;
+            if (close === "_" && /[\p{L}\p{N}]/u.test(src[j + 1] ?? ""))
+                continue;
+            return j;
+        }
+        return -1;
+    };
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === "\\" && ESCAPABLE.test(src[i + 1] ?? "")) {
+            v += src[i + 1];
+            raw += src.slice(i, i + 2);
+            i += 2;
+            continue;
+        }
+        if (ch === "`") {
+            const run = /^`+/.exec(src.slice(i))[0];
+            const end = src.indexOf(run, i + run.length);
+            if (end > 0) {
+                flush();
+                out.push({ t: "code", v: src.slice(i + run.length, end).replace(/^ ([\s\S]*) $/, "$1") });
+                i = end + run.length;
+                continue;
+            }
+            v += run;
+            raw += run;
+            i += run.length;
+            continue;
+        }
+        if (ch === "[") {
+            const m = /^\[([^\]\n]+)\]\(([^)\s]+)\)/.exec(src.slice(i));
+            if (m) {
+                flush();
+                out.push({ t: "link", label: inline(m[1]), url: m[2] });
+                i += m[0].length;
+                continue;
+            }
+        }
+        if (ch === "<") {
+            const m = /^<(https?:\/\/[^>\s]+)>/.exec(src.slice(i));
+            if (m) {
+                flush();
+                out.push({ t: "link", label: [{ t: "text", v: m[1], raw: m[1] }], url: m[1] });
+                i += m[0].length;
+                continue;
+            }
+        }
+        let matched = false;
+        for (const [d, t] of [["**", "b"], ["__", "b"], ["~~", "s"], ["*", "i"], ["_", "i"]]) {
+            const j = span(d);
+            if (j < 0)
+                continue;
+            flush();
+            out.push({ t, c: inline(src.slice(i + d.length, j)) });
+            i = j + d.length;
+            matched = true;
+            break;
+        }
+        if (matched)
+            continue;
+        v += ch;
+        raw += ch;
+        i++;
+    }
+    flush();
+    return out;
+}
+const tick = (v) => { const fence = v.includes("`") ? "``" : "`"; return `${fence}${fence.length > 1 ? " " : ""}${v}${fence.length > 1 ? " " : ""}${fence}`; };
+const fence = (lang, body) => `\`\`\`${lang}\n${body}\n\`\`\``;
+const html = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const plainText = (nodes) => nodes.map(n => n.t === "text" || n.t === "code" ? n.v : n.t === "link" ? plainText(n.label) : plainText(n.c)).join("");
+/** Markdown-family platforms; each drops what it does not render. */
+const markdownish = (o) => ({
+    text: t => t.raw, code: tick, pre: fence, link: (l, u) => `[${l}](${u})`,
+    b: s => `**${s}**`, i: s => o.italic ? `*${s}*` : s, s: s => o.strike ? `~~${s}~~` : s,
+    heading: (n, s) => n <= o.headings ? `${"#".repeat(n)} ${s}` : `**${s}**`,
+    bullet: (ind, s) => `${ind}- ${s}`, ordered: (ind, n, s) => `${ind}${n}. ${s}`, quote: s => `> ${s}`, hr: o.hr
+});
+const WRITERS = {
+    plain: {
+        text: t => t.v, code: v => v, pre: (_l, b) => b, link: (l, u) => l === u ? u : `${l} (${u})`,
+        b: s => s, i: s => s, s: s => s, heading: (_n, s) => s,
+        bullet: (ind, s) => `${ind}• ${s}`, ordered: (ind, n, s) => `${ind}${n}. ${s}`, quote: s => `> ${s}`, hr: "———"
+    },
+    slack: {
+        text: t => html(t.v), code: v => tick(html(v)), pre: (_l, b) => fence("", html(b)),
+        link: (_l, u, plain) => `<${u.replace(/[|>]/g, encodeURIComponent)}|${html(plain).replace(/\|/g, "¦")}>`,
+        b: s => `*${s}*`, i: s => `_${s}_`, s: s => `~${s}~`, heading: (_n, s) => `*${s}*`,
+        bullet: (ind, s) => `${ind}• ${s}`, ordered: (ind, n, s) => `${ind}${n}. ${s}`, quote: s => `> ${s}`, hr: "———"
+    },
+    "telegram-html": {
+        text: t => html(t.v), code: v => `<code>${html(v)}</code>`,
+        pre: (l, b) => l ? `<pre><code class="language-${html(l)}">${html(b)}</code></pre>` : `<pre>${html(b)}</pre>`,
+        link: (l, u) => `<a href="${html(u).replace(/"/g, "&quot;")}">${l}</a>`,
+        b: s => `<b>${s}</b>`, i: s => `<i>${s}</i>`, s: s => `<s>${s}</s>`, heading: (_n, s) => `<b>${s}</b>`,
+        bullet: (ind, s) => `${ind}• ${s}`, ordered: (ind, n, s) => `${ind}${n}. ${s}`, quote: s => `<blockquote>${s}</blockquote>`, hr: "———",
+        finish: out => out.replace(/<\/blockquote>\n<blockquote>/g, "\n")
+    },
+    discord: markdownish({ headings: 3, italic: true, strike: true, hr: "———" }),
+    lark: markdownish({ headings: 0, italic: true, strike: true, hr: "---" }),
+    dingtalk: markdownish({ headings: 6, italic: true, strike: false, hr: "---" }),
+    wecom: markdownish({ headings: 6, italic: false, strike: false, hr: "———" })
+};
+function renderInline(nodes, w) {
+    return nodes.map(n => {
+        switch (n.t) {
+            case "text": return w.text(n);
+            case "code": return w.code(n.v);
+            case "link": return w.link(renderInline(n.label, w), n.url, plainText(n.label));
+            default: return w[n.t](renderInline(n.c, w));
+        }
+    }).join("");
+}
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([\w+#.-]*)\s*$/;
+function units(md) {
+    const out = [];
+    const lines = md.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const open = FENCE.exec(lines[i]);
+        if (!open) {
+            out.push({ t: "line", v: lines[i] });
+            continue;
+        }
+        const body = [];
+        let j = i + 1;
+        for (; j < lines.length; j++) {
+            const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(lines[j]);
+            if (close && close[1][0] === open[1][0] && close[1].length >= open[1].length)
+                break;
+            body.push(lines[j]);
+        }
+        out.push({ t: "code", lang: open[2], lines: body });
+        i = j;
+    }
+    return out;
+}
+function renderLine(line, w) {
+    let m;
+    if ((m = /^(#{1,6})\s+(.*?)\s*#*\s*$/.exec(line)))
+        return w.heading(m[1].length, renderInline(inline(m[2]), w));
+    if (/^ {0,3}([-*_])( *\1){2,} *$/.test(line))
+        return w.hr;
+    if ((m = /^(\s*)[-*+]\s+(.*)$/.exec(line)))
+        return w.bullet(m[1], renderInline(inline(m[2]), w));
+    if ((m = /^(\s*)(\d{1,9})[.)]\s+(.*)$/.exec(line)))
+        return w.ordered(m[1], m[2], renderInline(inline(m[3]), w));
+    if ((m = /^ {0,3}>\s?(.*)$/.exec(line)))
+        return w.quote(renderLine(m[1], w));
+    return renderInline(inline(line), w);
+}
+/** Converts the common layer's Markdown into an adapter's dialect. */
+export function toImDialect(markdown, dialect) {
+    if (dialect === "markdown")
+        return markdown;
+    const w = WRITERS[dialect];
+    const out = units(markdown).map(u => u.t === "code" ? w.pre(u.lang, u.lines.join("\n")) : renderLine(u.v, w)).join("\n");
+    return w.finish ? w.finish(out) : out;
+}
+/** The longest prefix that still fits, never cutting a surrogate pair, preferring a space. */
+function hardSplit(s, fits) {
+    const pieces = [];
+    let rest = s;
+    while (rest && !fits(rest)) {
+        let lo = 1, hi = rest.length - 1;
+        while (lo < hi) {
+            const mid = Math.ceil((lo + hi) / 2);
+            if (fits(rest.slice(0, mid)))
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        let n = lo;
+        if (/[\uD800-\uDBFF]/.test(rest[n - 1]) && n > 1)
+            n--;
+        const space = rest.lastIndexOf(" ", n - 1);
+        if (space > n / 2)
+            n = space + 1;
+        pieces.push(rest.slice(0, n));
+        rest = rest.slice(n);
+    }
+    if (rest)
+        pieces.push(rest);
+    return pieces;
+}
+/**
+ * Splits Markdown into messages that each fit `max` once converted, breaking
+ * between lines. A code block stays whole when it fits a message; a longer one
+ * is closed and reopened with its language rather than cut mid-fence.
+ */
+export function splitImText(markdown, max, dialect = "markdown") {
+    const render = (s) => toImDialect(s, dialect);
+    const fits = (s) => render(s).length <= max;
+    if (fits(markdown))
+        return [render(markdown)];
+    const pieces = [];
+    for (const u of units(markdown)) {
+        if (u.t === "line") {
+            pieces.push(...hardSplit(u.v, fits));
+            continue;
+        }
+        const whole = fence(u.lang, u.lines.join("\n"));
+        if (fits(whole)) {
+            pieces.push(whole);
+            continue;
+        }
+        let group = [];
+        const wrapped = (lines) => fence(u.lang, lines.join("\n"));
+        for (const line of u.lines) {
+            if (fits(wrapped([...group, line]))) {
+                group.push(line);
+                continue;
+            }
+            if (group.length)
+                pieces.push(wrapped(group));
+            group = [];
+            for (const part of hardSplit(line, p => fits(wrapped([p])))) {
+                if (fits(wrapped([...group, part])))
+                    group.push(part);
+                else {
+                    pieces.push(wrapped(group));
+                    group = [part];
+                }
+            }
+        }
+        if (group.length)
+            pieces.push(wrapped(group));
+    }
+    const chunks = [];
+    let current = [];
+    for (const piece of pieces) {
+        if (current.length && !fits([...current, piece].join("\n"))) {
+            chunks.push(current.join("\n"));
+            current = [];
+        }
+        current.push(piece);
+    }
+    if (current.length)
+        chunks.push(current.join("\n"));
+    return chunks.map(c => c.replace(/^\n+|\n+$/g, "")).filter(Boolean).map(render);
+}
+//# sourceMappingURL=im-markdown.js.map

package/dist/im.d.ts

@@ -0,0 +1,319 @@
+import { z } from "zod";
+import type { Localized } from "./contract.js";
+/** Provider-neutral transport contract. Adapters never receive Agent or project access. */
+export interface ImAddress {
+    tenantId: string;
+    conversationId: string;
+    topicId?: string;
+}
+export interface ImAttachmentRef {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+}
+/** SDK 0.2.5. An earlier message the adapter read beside an inbound one: the one it quotes, or its thread's first message. */
+export interface ImContextMessage {
+    role: "quoted" | "root";
+    messageId: string;
+    author: {
+        id: string;
+        name?: string;
+        isBot: boolean;
+    };
+    text: string;
+}
+/**
+ * A native slash command or menu entry arrives as a message whose text is the
+ * plain command (`/stop`), so plain-text commands keep working everywhere.
+ */
+export type ImInbound = {
+    eventId: string;
+    address: ImAddress;
+    actor: {
+        id: string;
+        name?: string;
+        isBot: boolean;
+    };
+} & (
+/** `ambient` (SDK 0.2.5): a group message that neither mentions nor replies to the bot, sent only by adapters that receive every group message. */
+{
+    kind: "message";
+    messageId: string;
+    text: string;
+    activation: "dm" | "mention" | "reply" | "ambient";
+    attachments?: ImAttachmentRef[];
+    permalink?: string;
+    /** SDK 0.2.5. The message this one quotes or replies to; replying to the progress message steers the running turn. */
+    replyTo?: string;
+    /** SDK 0.2.5. What the adapter already holds of the quoted message and the thread's first message, so the Agent sees what is being discussed. */
+    context?: ImContextMessage[];
+}
+/** SDK 0.2.5. The person withdrew or edited a message they sent; a queued one that was withdrawn never runs, an edit never reruns. */
+ | {
+    kind: "retract";
+    messageId: string;
+} | {
+    kind: "edit";
+    messageId: string;
+}
+/** An adapter acknowledges the platform within its callback deadline before awaiting `receive`; the outcome updates the card later. */
+ | {
+    kind: "action";
+    token: string;
+    value?: string | string[];
+});
+/** How an adapter writes formatted text. `markdown` passes the common layer's Markdown through unchanged. */
+export type ImMarkdownDialect = "plain" | "markdown" | "slack" | "telegram-html" | "discord" | "lark" | "dingtalk" | "wecom";
+export interface ImButton {
+    label: string;
+    token: string;
+    /** SDK 0.2.5. A hint; adapters without styled buttons ignore it. */
+    style?: "default" | "primary" | "danger";
+}
+/** SDK 0.2.5. Structured parts beside the text; the common layer folds what an adapter cannot show into `text`. */
+export type ImElement = {
+    type: "section";
+    title?: string;
+    text?: string;
+    fields?: {
+        label: string;
+        value: string;
+    }[];
+} | {
+    type: "links";
+    links: {
+        label: string;
+        url: string;
+    }[];
+}
+/** Answered with an action carrying the chosen value, or the list of values when `multiple`. */
+ | {
+    type: "select";
+    token: string;
+    placeholder?: string;
+    multiple?: boolean;
+    options: {
+        label: string;
+        value: string;
+    }[];
+}
+/** A free-text answer entry, answered with an action whose value is the text. */
+ | {
+    type: "input";
+    token: string;
+    label: string;
+    placeholder?: string;
+};
+export interface ImContent {
+    /** Already written in the adapter's declared Markdown dialect, and within its length limit. */
+    text: string;
+    actions?: ImButton[];
+    elements?: ImElement[];
+    files?: {
+        id: string;
+        name: string;
+        mimeType: string;
+        size: number;
+    }[];
+}
+export interface ImDelivery {
+    /** Stable across retries. A provider should use its native deduplication where available. */
+    operationId: string;
+    address: ImAddress;
+    replaceMessageId?: string;
+    /** SDK 0.2.5. Post inside this thread: the address's topic, or the triggering message on platforms with `threads`. */
+    threadId?: string;
+    /** SDK 0.2.5. Quote-reply to this message, on platforms without threads. */
+    replyTo?: string;
+    /** SDK 0.2.5. Show only to this actor; set only for adapters declaring `ephemeral`. */
+    visibleTo?: string;
+    content: ImContent;
+}
+export type ImConnectionState = "connecting" | "connected" | "offline" | "error";
+/** The common layer's commands, for registering as native slash commands or menu entries. */
+export interface ImCommand {
+    name: string;
+    description: string;
+    /** Shown as the argument hint, e.g. `token answer`. */
+    args?: string;
+}
+/** A reaction's meaning; the adapter picks the emoji (👀 / ✅ / ❌) and replaces the previous one. */
+export type ImReaction = "received" | "done" | "failed";
+export interface ImAdapterSession {
+    deliver(command: ImDelivery): Promise<{
+        messageId: string;
+    }>;
+    download?(ref: ImAttachmentRef): Promise<Uint8Array>;
+    /** SDK 0.2.5. Typing or the platform's "thinking" status; `idle` clears it. Best effort. */
+    indicate?(command: {
+        address: ImAddress;
+        threadId?: string;
+        state: "typing" | "thinking" | "idle";
+    }): Promise<void>;
+    /** SDK 0.2.5. Reacts to a message the person sent. Best effort. */
+    react?(command: {
+        address: ImAddress;
+        messageId: string;
+        reaction: ImReaction;
+    }): Promise<void>;
+    /** SDK 0.2.5. A native streaming message, used when `stream` is `native`. */
+    stream?: {
+        start(command: ImDelivery): Promise<{
+            messageId: string;
+        }>;
+        append(command: {
+            operationId: string;
+            address: ImAddress;
+            messageId: string;
+            delta: string;
+        }): Promise<void>;
+        /** Settles the message with its final content, which may differ from what was appended. */
+        stop(command: {
+            operationId: string;
+            address: ImAddress;
+            messageId: string;
+            content: ImContent;
+        }): Promise<{
+            messageId: string;
+        }>;
+    };
+    /** SDK 0.2.5. Registers the commands natively, when `nativeCommands`. Called after every connect. */
+    commands?(commands: ImCommand[]): Promise<void>;
+    /** SDK 0.2.5. The bot the credentials signed in as, checked against the platform; shown so the person sees setup worked. */
+    identity?: {
+        id: string;
+        name?: string;
+    };
+    close(): void | Promise<void>;
+}
+/** SDK 0.2.5. One value a person copies from the platform's developer console. */
+export interface ImCredentialField {
+    key: string;
+    label: Localized;
+    /** Drawn as a password field. Every value is sealed by the OS keychain either way. */
+    secret?: boolean;
+    optional?: boolean;
+    placeholder?: string;
+    help?: Localized;
+}
+/** SDK 0.2.5. What connecting one bot takes, for the settings wizard. */
+export interface ImAdapterSetup {
+    fields: ImCredentialField[];
+    /** What to do in the platform's console, in order; Markdown. */
+    steps: Localized[];
+    /** Scopes or permissions the app needs. */
+    permissions?: string[];
+    /** An app manifest to paste, e.g. Slack's. */
+    manifest?: {
+        format: "json" | "yaml";
+        text: string;
+    };
+    docsUrl?: string;
+}
+/** What the platform can do. Fields marked 0.2.5 are optional; leaving them out declares the 0.2.2 behaviour. */
+export interface ImCapabilities {
+    edit: boolean;
+    buttons: boolean;
+    inboundFiles: boolean;
+    outboundFiles: boolean;
+    maxTextLength: number;
+    maxFileBytes: number;
+    /** SDK 0.2.5. Replies can go into a thread under the triggering message. */
+    threads?: boolean;
+    reactions?: boolean;
+    typing?: boolean;
+    /** `native`: session.stream. `edit`: throttled edits of one message. `none`: only the final message. */
+    stream?: "native" | "edit" | "none";
+    select?: boolean;
+    multiSelect?: boolean;
+    /** Free-text answer entries (`input` elements). */
+    textInput?: boolean;
+    /** Sections, fields and links render natively. */
+    cards?: boolean;
+    /** A message with buttons or selects can be updated in place; defaults to `edit`. */
+    cardUpdate?: boolean;
+    nativeCommands?: boolean;
+    ephemeral?: boolean;
+    /** Defaults to `markdown`: the text arrives as the common layer wrote it. */
+    markdown?: ImMarkdownDialect;
+    /** Messages and edits allowed per conversation in a window, e.g. WeCom's 30 a minute. */
+    rateLimit?: {
+        messages: number;
+        windowMs: number;
+    };
+}
+export declare const IM_MARKDOWN_DIALECTS: readonly ["plain", "markdown", "slack", "telegram-html", "discord", "lark", "dingtalk", "wecom"];
+/** The capability fields only SDK 0.2.5 understands; declaring one needs `engines.sdk` of at least that. */
+export declare const IM_CAPABILITIES_V2: readonly ["threads", "reactions", "typing", "stream", "select", "multiSelect", "textInput", "cards", "cardUpdate", "nativeCommands", "ephemeral", "markdown", "rateLimit"];
+export declare const ImCapabilitiesSchema: z.ZodObject<{
+    edit: z.ZodBoolean;
+    buttons: z.ZodBoolean;
+    inboundFiles: z.ZodBoolean;
+    outboundFiles: z.ZodBoolean;
+    maxTextLength: z.ZodNumber;
+    maxFileBytes: z.ZodNumber;
+    threads: z.ZodOptional<z.ZodBoolean>;
+    reactions: z.ZodOptional<z.ZodBoolean>;
+    typing: z.ZodOptional<z.ZodBoolean>;
+    stream: z.ZodOptional<z.ZodEnum<{
+        edit: "edit";
+        native: "native";
+        none: "none";
+    }>>;
+    select: z.ZodOptional<z.ZodBoolean>;
+    multiSelect: z.ZodOptional<z.ZodBoolean>;
+    textInput: z.ZodOptional<z.ZodBoolean>;
+    cards: z.ZodOptional<z.ZodBoolean>;
+    cardUpdate: z.ZodOptional<z.ZodBoolean>;
+    nativeCommands: z.ZodOptional<z.ZodBoolean>;
+    ephemeral: z.ZodOptional<z.ZodBoolean>;
+    markdown: z.ZodOptional<z.ZodEnum<{
+        plain: "plain";
+        markdown: "markdown";
+        slack: "slack";
+        "telegram-html": "telegram-html";
+        discord: "discord";
+        lark: "lark";
+        dingtalk: "dingtalk";
+        wecom: "wecom";
+    }>>;
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        messages: z.ZodNumber;
+        windowMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Every capability spelled out, with the 0.2.2 behaviour where an adapter is silent. */
+export type ResolvedImCapabilities = Required<Omit<ImCapabilities, "rateLimit">> & Pick<ImCapabilities, "rateLimit">;
+export declare function resolveImCapabilities(caps: ImCapabilities): ResolvedImCapabilities;
+export interface ImAdapter {
+    /** Carries the plugin's namespace. */
+    id: string;
+    title: string;
+    capabilities: ImCapabilities;
+    /** SDK 0.2.5. Without it, connections take no credentials in settings and the adapter keeps its own. */
+    setup?: ImAdapterSetup;
+    /** Credentials never go into events, routes, Agent context or logs. */
+    open(connectionId: string, io: {
+        signal: AbortSignal;
+        /** SDK 0.2.5. The connection's values for `setup.fields`, decrypted. */
+        credentials: Record<string, string>;
+        /** Resolves after local persistence, not after the Agent finishes. */
+        receive(event: ImInbound): Promise<{
+            receiptId: string;
+        }>;
+        status(state: ImConnectionState, detail?: string): void;
+        /** Reads only handles explicitly included in a delivery for this connection. */
+        readOutboundFile(id: string): Promise<Uint8Array>;
+    }): Promise<ImAdapterSession>;
+}
+export interface ImApi {
+    register(adapter: ImAdapter): Promise<() => void>;
+}
+/** Only a known-unsent operation is safe to retry; unknown failures remain uncertain. */
+export declare class ImDeliveryError extends Error {
+    readonly disposition: "retryable" | "uncertain" | "permanent";
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, disposition: "retryable" | "uncertain" | "permanent", retryAfterMs?: number | undefined);
+}
+//# sourceMappingURL=im.d.ts.map