@archastro/sdk
    Preparing search index...

    Interface SlackChannelBinding

    A binding that connects a Slack channel to an ArchAstro team and one or more agents, enabling those agents to receive and respond to messages in that channel.

    interface SlackChannelBinding {
        agents?: string[];
        allow_bot_conversations: boolean;
        channel?: string;
        customer_label?: string;
        deposit_thread?: string;
        disclosure_state?: "pending" | "posted" | "suppressed";
        id: string;
        integration?: string;
        is_ext_shared_cached?: boolean;
        is_private_cached?: boolean;
        mirrors?: string[];
        muted: boolean;
        muted_until?: string;
        reply_style: string;
        resident_agent?: string;
        route_kind: "fda" | "resident" | "observer";
        scope_key?: string;
        team?: string;
        vendor_admin_channel_access?:
            | "invited"
            | "already_member"
            | "no_slack_user"
            | "failed";
    }
    Index

    Properties

    agents?: string[]

    IDs of every agent attached to this binding, including attachments left over from retired flows. Use resident_agent and route_kind for the effective runtime route.

    allow_bot_conversations: boolean

    Whether this channel opts into sustained bot-to-bot conversation, exempting it from the reply loop brake. Defaults to false.

    channel?: string

    Slack channel ID (e.g. C01234ABCDE) that this binding targets.

    customer_label?: string

    Human-readable label identifying the customer, derived from the binding's embedded config. null when not set.

    deposit_thread?: string

    Staging thread the deposit pipe copies this channel's mirror content into (thr_… public ID). null when the pipe is off for this binding.

    disclosure_state?: "pending" | "posted" | "suppressed"

    Slack Connect lifecycle: pending while the customer has not accepted the invite (nothing mirrors), posted once the AI disclosure is in the channel and the channel is live, suppressed when relay is stopped. null for a binding that never went through Connect provisioning.

    id: string

    Unique identifier for this Slack channel binding.

    integration?: string

    ID of the Slack integration that owns this binding.

    is_ext_shared_cached?: boolean

    Cached value of Slack's is_ext_shared flag for this channel. May be stale relative to Slack's current state.

    is_private_cached?: boolean

    Cached value of Slack's is_private flag for this channel. May be stale relative to Slack's current state. Private channels are member-managed: mutating the binding requires in-channel evidence.

    mirrors?: string[]

    IDs of every mirror thread this channel's messages land in (thr_… public IDs) that the caller can read, including any legacy peel or chain threads. Empty for a caller with no membership on any of them, and for a channel that has not mirrored anything yet. IDs only: reading a mirror's contents still requires membership on it.

    muted: boolean

    Whether the resident agent is currently muted. A muted resident keeps mirroring the channel (reading) but stops replying. A timed mute expires automatically at muted_until; this reflects the effective state as of now. Defaults to false.

    muted_until?: string

    ISO 8601 timestamp when a timed mute expires and replies resume. null for an indefinite mute (until an explicit unmute) or when not muted.

    reply_style: string

    How the resident agent's replies post to Slack: thread (default) threads a reply under the message that triggered it; top_level posts it flat in the channel.

    resident_agent?: string

    ID of the resident agent selected by Slack ingress. null when no resident is attached and the channel is an observer.

    route_kind: "fda" | "resident" | "observer"

    Effective Slack ingress route. fda — a resident on a team-bound channel, replying through the Forward Deployed Agent chain. resident — a resident on an internal channel, replying through the channel mirror. observer — no resident is attached, so the channel is recorded and nobody replies.

    scope_key?: string

    The customer key this channel's agent is locked to, written when adding the customer finishes. A posted binding whose scope_key is still null has been accepted but not finished — the addition is either in flight or was refused.

    team?: string

    ID of the ArchAstro team this channel is bound to.

    vendor_admin_channel_access?:
        | "invited"
        | "already_member"
        | "no_slack_user"
        | "failed"

    Whether the admin who added this customer ended up inside a Connect channel we created for them: invited (we put them in), already_member (they were in it already), no_slack_user (their account email is not a Slack account in your workspace, so nobody was invited), or failed (Slack refused). A created Connect channel is private and has no self-join, so the last two mean the channel has no human from your side until someone already in it adds one. null when nobody was added: the channel was adopted rather than created (an existing channel already has its own members), the binding never went through Connect provisioning, or the call had no admin behind it.