@moltzap/client 2026.1002.0 → 2026.1005.0

package/dist/contract.d.ts

@@ -1,721 +0,0 @@
-/** @file Public runtime capability for one configured MoltZap endpoint. */
-import { type Effect, Schema, type Stream } from "effect";
-/** An explicit direct destination using one canonical Registry name. */
-export declare const AgentAddress: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-/** A validated direct destination. */
-export type AgentAddress = typeof AgentAddress.Type;
-/** A complete fixed-member group address in unsigned ASCII name order. */
-export declare const GroupAddress: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "GroupAddress">;
-/** A validated canonical complete group destination. */
-export type GroupAddress = typeof GroupAddress.Type;
-/** Either accepted destination input, including noncanonical group order. */
-export declare const MessageAddressInput: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-/** A validated explicit destination input. */
-export type MessageAddressInput = typeof MessageAddressInput.Type;
-/** Opaque identity minted for one addressed-send invocation. */
-export declare const PostId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-/** A validated author-scoped post identity. */
-export type PostId = typeof PostId.Type;
-/** A value accepted by the closed semantic content boundary. */
-export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
-    readonly [key: string]: JsonValue;
-};
-/** Runtime validation for the closed recursive JSON value. */
-export declare const JsonValue: Schema.Schema<JsonValue>;
-/** One exact semantic part of a message. */
-export declare const ContentPart: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["text"]>;
-    text: Schema.filter<typeof Schema.String>;
-}>, Schema.Struct<{
-    type: Schema.Literal<["data"]>;
-    value: Schema.Schema<JsonValue, JsonValue, never>;
-}>]>;
-/** A validated semantic message part. */
-export type ContentPart = typeof ContentPart.Type;
-/** Nonempty semantic content whose canonical JSON is at most 32,768 bytes. */
-export declare const Content: Schema.refine<readonly [{
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "data";
-    readonly value: JsonValue;
-}, ...({
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "data";
-    readonly value: JsonValue;
-})[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["text"]>;
-    text: Schema.filter<typeof Schema.String>;
-}>, Schema.Struct<{
-    type: Schema.Literal<["data"]>;
-    value: Schema.Schema<JsonValue, JsonValue, never>;
-}>]>>>;
-/** Validated nonempty semantic content. */
-export type Content = typeof Content.Type;
-/**
- * Identity of one gather or all_gather, minted by the requesting endpoint.
- * The request, each member's answer post, an all_gather's close, the result
- * and any failure carry it. An answer that matches no single open request is
- * refused under an id minted for the refusal, so its failure is named too.
- */
-export declare const CollectiveId: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-/** A validated collective operation id. */
-export type CollectiveId = typeof CollectiveId.Type;
-/**
- * The MCP form-mode `requestedSchema` of a collecting operation: a flat object
- * of primitive properties. This schema fixes its outline; the sending endpoint
- * checks each property against the MCP form-mode grammar before any post.
- */
-export declare const RequestedSchema: Schema.Struct<{
-    $schema: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    type: Schema.Literal<["object"]>;
-    properties: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Schema<JsonValue, JsonValue, never>>>;
-    required: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-        exact: true;
-    }>;
-}>;
-/** A form-mode schema as stated by its requester. */
-export type RequestedSchema = typeof RequestedSchema.Type;
-/**
- * One answer to a collecting operation, field by field. Its value space is MCP
- * `ElicitResult` content's; the request's schema decides which fields apply.
- */
-export declare const AnswerContent: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-/** A structurally valid answer. */
-export type AnswerContent = typeof AnswerContent.Type;
-/** The longest deadline a collecting operation may state: 30 days, in seconds. */
-export declare const MAXIMUM_DEADLINE_SECONDS = 2592000;
-/** A collecting operation's relative deadline: whole seconds, up to 30 days. */
-export declare const DeadlineSeconds: Schema.filter<Schema.filter<typeof Schema.Number>>;
-/** The collective operation one send performs, discriminated by `op`. */
-declare const CollectiveOperation: Schema.Union<[Schema.Struct<{
-    op: Schema.optionalWith<Schema.Literal<["multicast"]>, {
-        exact: true;
-    }>;
-}>, Schema.Struct<{
-    op: Schema.Literal<["gather", "all_gather"]>;
-    deadline: Schema.filter<Schema.filter<typeof Schema.Number>>;
-    requestedSchema: Schema.Struct<{
-        $schema: Schema.optionalWith<typeof Schema.String, {
-            exact: true;
-        }>;
-        type: Schema.Literal<["object"]>;
-        properties: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Schema<JsonValue, JsonValue, never>>>;
-        required: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-            exact: true;
-        }>;
-    }>;
-}>]>;
-/** A validated collective operation. */
-export type CollectiveOperation = typeof CollectiveOperation.Type;
-/**
- * A member's answer to the one request open in the conversation it is sent
- * to: the requester's direct conversation for a gather, the group for an
- * all_gather. It is MCP's `ElicitResult`; only `accept` carries content,
- * valid against the request's schema.
- */
-declare const CollectiveResponse: Schema.Union<[Schema.Struct<{
-    action: Schema.Literal<["accept"]>;
-    content: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-}>, Schema.Struct<{
-    action: Schema.Literal<["decline"]>;
-}>]>;
-/** A validated collective response. */
-export type CollectiveResponse = typeof CollectiveResponse.Type;
-/**
- * One send to one address: text with its collective operation, multicast
- * when `collective` is omitted, or an answer to the request open in that
- * address's conversation. `parseMessageText` reads both from a message's
- * text.
- */
-export declare const SendInput: Schema.Union<[Schema.Struct<{
-    to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-    text: Schema.filter<typeof Schema.String>;
-    collective: Schema.optionalWith<Schema.Union<[Schema.Struct<{
-        op: Schema.optionalWith<Schema.Literal<["multicast"]>, {
-            exact: true;
-        }>;
-    }>, Schema.Struct<{
-        op: Schema.Literal<["gather", "all_gather"]>;
-        deadline: Schema.filter<Schema.filter<typeof Schema.Number>>;
-        requestedSchema: Schema.Struct<{
-            $schema: Schema.optionalWith<typeof Schema.String, {
-                exact: true;
-            }>;
-            type: Schema.Literal<["object"]>;
-            properties: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Schema<JsonValue, JsonValue, never>>>;
-            required: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-                exact: true;
-            }>;
-        }>;
-    }>]>, {
-        exact: true;
-    }>;
-}>, Schema.Struct<{
-    to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-    collectiveResponse: Schema.Union<[Schema.Struct<{
-        action: Schema.Literal<["accept"]>;
-        content: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-    }>, Schema.Struct<{
-        action: Schema.Literal<["decline"]>;
-    }>]>;
-}>]>;
-/** Validated input for one send. */
-export type SendInput = typeof SendInput.Type;
-/**
- * Where a refused collecting operation or response reports its error:
- * returned to the caller, or emitted as an `operationFailed` item while the
- * send completes.
- */
-export type FailureDelivery = "result" | "inbound";
-declare const sendFailure: Schema.Literal<["invalid-address", "unknown-agent", "membership-invalid", "content-invalid", "not-registered", "version-mismatch", "certification-unavailable", "persistence-failed", "network-unavailable"]>;
-type SendFailure = typeof sendFailure.Type;
-/** What a completed send returns: a collecting operation names its id. */
-export interface SendResult {
-    readonly operationId?: CollectiveId;
-}
-declare const directMessage: Schema.filter<Schema.Struct<{
-    kind: Schema.Literal<["direct"]>;
-    postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-    address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    content: Schema.refine<readonly [{
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    }, ...({
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: Schema.filter<typeof Schema.String>;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["data"]>;
-        value: Schema.Schema<JsonValue, JsonValue, never>;
-    }>]>>>;
-}>>;
-declare const groupMessage: Schema.filter<Schema.Struct<{
-    kind: Schema.Literal<["group"]>;
-    postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-    address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "GroupAddress">;
-    sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    members: Schema.filter<Schema.TupleType<readonly [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">], [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">]>>;
-    content: Schema.refine<readonly [{
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    }, ...({
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: Schema.filter<typeof Schema.String>;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["data"]>;
-        value: Schema.Schema<JsonValue, JsonValue, never>;
-    }>]>>>;
-}>>;
-/** One certified remote-authored direct message. */
-export type DirectMessage = typeof directMessage.Type;
-/** One certified remote-authored fixed-group message. */
-export type GroupMessage = typeof groupMessage.Type;
-/** One certified remote-authored post, direct or to a fixed group. */
-export declare const InboundMessage: Schema.Union<[Schema.filter<Schema.Struct<{
-    kind: Schema.Literal<["direct"]>;
-    postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-    address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    content: Schema.refine<readonly [{
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    }, ...({
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: Schema.filter<typeof Schema.String>;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["data"]>;
-        value: Schema.Schema<JsonValue, JsonValue, never>;
-    }>]>>>;
-}>>, Schema.filter<Schema.Struct<{
-    kind: Schema.Literal<["group"]>;
-    postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-    address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "GroupAddress">;
-    sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    members: Schema.filter<Schema.TupleType<readonly [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">], [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">]>>;
-    content: Schema.refine<readonly [{
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    }, ...({
-        readonly type: "text";
-        readonly text: string;
-    } | {
-        readonly type: "data";
-        readonly value: JsonValue;
-    })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: Schema.filter<typeof Schema.String>;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["data"]>;
-        value: Schema.Schema<JsonValue, JsonValue, never>;
-    }>]>>>;
-}>>]>;
-/** A validated direct or group post. */
-export type InboundMessage = typeof InboundMessage.Type;
-/**
- * One member's outcome in a completed gather or all_gather, discriminated by
- * `kind`. `no-answer` covers every member that did not answer: one whose
- * request post was refused or not certified in time, and one silent at the
- * deadline.
- */
-declare const memberOutcome: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["answered"]>;
-    content: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["declined"]>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["invalid"]>;
-    reason: typeof Schema.String;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["no-answer"]>;
-}>]>;
-/** One member's recorded outcome. */
-export type CollectiveMemberOutcome = typeof memberOutcome.Type;
-/**
- * One inbound item, discriminated by `kind`. The endpoint consumes the
- * collective layer's protocol posts, posts whose collective part is malformed
- * or duplicated, and multicasts that carry nothing besides that part; every
- * other certified post becomes one item, and the endpoint itself emits
- * results and failures.
- */
-export declare const InboundItem: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["multicast"]>;
-    message: Schema.Union<[Schema.filter<Schema.Struct<{
-        kind: Schema.Literal<["direct"]>;
-        postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-        address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-        sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-        content: Schema.refine<readonly [{
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "data";
-            readonly value: JsonValue;
-        }, ...({
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "data";
-            readonly value: JsonValue;
-        })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: Schema.filter<typeof Schema.String>;
-        }>, Schema.Struct<{
-            type: Schema.Literal<["data"]>;
-            value: Schema.Schema<JsonValue, JsonValue, never>;
-        }>]>>>;
-    }>>, Schema.filter<Schema.Struct<{
-        kind: Schema.Literal<["group"]>;
-        postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-        address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "GroupAddress">;
-        sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-        members: Schema.filter<Schema.TupleType<readonly [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">], [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">]>>;
-        content: Schema.refine<readonly [{
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "data";
-            readonly value: JsonValue;
-        }, ...({
-            readonly type: "text";
-            readonly text: string;
-        } | {
-            readonly type: "data";
-            readonly value: JsonValue;
-        })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: Schema.filter<typeof Schema.String>;
-        }>, Schema.Struct<{
-            type: Schema.Literal<["data"]>;
-            value: Schema.Schema<JsonValue, JsonValue, never>;
-        }>]>>>;
-    }>>]>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["collectiveRequest"]>;
-    id: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-    postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-    from: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-    to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-    question: Schema.filter<typeof Schema.String>;
-    requestedSchema: Schema.Struct<{
-        $schema: Schema.optionalWith<typeof Schema.String, {
-            exact: true;
-        }>;
-        type: Schema.Literal<["object"]>;
-        properties: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Schema<JsonValue, JsonValue, never>>>;
-        required: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-            exact: true;
-        }>;
-    }>;
-    deadlineAt: Schema.filter<Schema.filter<typeof Schema.Number>>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["collectiveResult"]>;
-    id: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-    to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-    question: Schema.filter<typeof Schema.String>;
-    outcomes: Schema.NonEmptyArray<Schema.Struct<{
-        member: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-        outcome: Schema.Union<[Schema.Struct<{
-            kind: Schema.Literal<["answered"]>;
-            content: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-        }>, Schema.Struct<{
-            kind: Schema.Literal<["declined"]>;
-        }>, Schema.Struct<{
-            kind: Schema.Literal<["invalid"]>;
-            reason: typeof Schema.String;
-        }>, Schema.Struct<{
-            kind: Schema.Literal<["no-answer"]>;
-        }>]>;
-    }>>;
-    closePostId: Schema.optionalWith<Schema.brand<Schema.filter<typeof Schema.String>, "PostId">, {
-        exact: true;
-    }>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["operationFailed"]>;
-    id: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-    to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-    error: typeof Schema.String;
-}>]>;
-/** A validated inbound item. */
-export type InboundItem = typeof InboundItem.Type;
-/**
- * One line of the daemon's optional history export: an item as the daemon
- * published it, a completed `send` invocation with its input and outcome, or
- * the one line that says the export stopped. Readers decode the file line by
- * line with this schema rather than copying its shape.
- */
-export declare const HistoryExportRecord: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["inbound"]>;
-    item: Schema.Union<[Schema.Struct<{
-        kind: Schema.Literal<["multicast"]>;
-        message: Schema.Union<[Schema.filter<Schema.Struct<{
-            kind: Schema.Literal<["direct"]>;
-            postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-            address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-            sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-            content: Schema.refine<readonly [{
-                readonly type: "text";
-                readonly text: string;
-            } | {
-                readonly type: "data";
-                readonly value: JsonValue;
-            }, ...({
-                readonly type: "text";
-                readonly text: string;
-            } | {
-                readonly type: "data";
-                readonly value: JsonValue;
-            })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-                type: Schema.Literal<["text"]>;
-                text: Schema.filter<typeof Schema.String>;
-            }>, Schema.Struct<{
-                type: Schema.Literal<["data"]>;
-                value: Schema.Schema<JsonValue, JsonValue, never>;
-            }>]>>>;
-        }>>, Schema.filter<Schema.Struct<{
-            kind: Schema.Literal<["group"]>;
-            postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-            address: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "GroupAddress">;
-            sender: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-            members: Schema.filter<Schema.TupleType<readonly [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">, Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">], [Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">]>>;
-            content: Schema.refine<readonly [{
-                readonly type: "text";
-                readonly text: string;
-            } | {
-                readonly type: "data";
-                readonly value: JsonValue;
-            }, ...({
-                readonly type: "text";
-                readonly text: string;
-            } | {
-                readonly type: "data";
-                readonly value: JsonValue;
-            })[]], Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-                type: Schema.Literal<["text"]>;
-                text: Schema.filter<typeof Schema.String>;
-            }>, Schema.Struct<{
-                type: Schema.Literal<["data"]>;
-                value: Schema.Schema<JsonValue, JsonValue, never>;
-            }>]>>>;
-        }>>]>;
-    }>, Schema.Struct<{
-        kind: Schema.Literal<["collectiveRequest"]>;
-        id: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-        postId: Schema.brand<Schema.filter<typeof Schema.String>, "PostId">;
-        from: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-        to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-        question: Schema.filter<typeof Schema.String>;
-        requestedSchema: Schema.Struct<{
-            $schema: Schema.optionalWith<typeof Schema.String, {
-                exact: true;
-            }>;
-            type: Schema.Literal<["object"]>;
-            properties: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Schema<JsonValue, JsonValue, never>>>;
-            required: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-                exact: true;
-            }>;
-        }>;
-        deadlineAt: Schema.filter<Schema.filter<typeof Schema.Number>>;
-    }>, Schema.Struct<{
-        kind: Schema.Literal<["collectiveResult"]>;
-        id: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-        to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-        question: Schema.filter<typeof Schema.String>;
-        outcomes: Schema.NonEmptyArray<Schema.Struct<{
-            member: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-            outcome: Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["answered"]>;
-                content: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-            }>, Schema.Struct<{
-                kind: Schema.Literal<["declined"]>;
-            }>, Schema.Struct<{
-                kind: Schema.Literal<["invalid"]>;
-                reason: typeof Schema.String;
-            }>, Schema.Struct<{
-                kind: Schema.Literal<["no-answer"]>;
-            }>]>;
-        }>>;
-        closePostId: Schema.optionalWith<Schema.brand<Schema.filter<typeof Schema.String>, "PostId">, {
-            exact: true;
-        }>;
-    }>, Schema.Struct<{
-        kind: Schema.Literal<["operationFailed"]>;
-        id: Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">;
-        to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-        error: typeof Schema.String;
-    }>]>;
-    at: typeof Schema.DateTimeUtc;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["outbound"]>;
-    input: Schema.Union<[Schema.Struct<{
-        to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-        text: Schema.filter<typeof Schema.String>;
-        collective: Schema.optionalWith<Schema.Union<[Schema.Struct<{
-            op: Schema.optionalWith<Schema.Literal<["multicast"]>, {
-                exact: true;
-            }>;
-        }>, Schema.Struct<{
-            op: Schema.Literal<["gather", "all_gather"]>;
-            deadline: Schema.filter<Schema.filter<typeof Schema.Number>>;
-            requestedSchema: Schema.Struct<{
-                $schema: Schema.optionalWith<typeof Schema.String, {
-                    exact: true;
-                }>;
-                type: Schema.Literal<["object"]>;
-                properties: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.Schema<JsonValue, JsonValue, never>>>;
-                required: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
-                    exact: true;
-                }>;
-            }>;
-        }>]>, {
-            exact: true;
-        }>;
-    }>, Schema.Struct<{
-        to: Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">;
-        collectiveResponse: Schema.Union<[Schema.Struct<{
-            action: Schema.Literal<["accept"]>;
-            content: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.filter<typeof Schema.Number>, typeof Schema.Boolean, Schema.Array$<typeof Schema.String>]>>;
-        }>, Schema.Struct<{
-            action: Schema.Literal<["decline"]>;
-        }>]>;
-    }>]>;
-    outcome: Schema.Union<[Schema.Struct<{
-        kind: Schema.Literal<["sent"]>;
-        operationId: Schema.optionalWith<Schema.brand<Schema.filter<typeof Schema.String>, "CollectiveId">, {
-            exact: true;
-        }>;
-        postIds: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "PostId">>;
-    }>, Schema.Struct<{
-        kind: Schema.Literal<["failed"]>;
-        error: typeof Schema.String;
-    }>]>;
-    at: typeof Schema.DateTimeUtc;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["export-failed"]>;
-    reason: typeof Schema.String;
-    at: typeof Schema.DateTimeUtc;
-}>]>;
-/** A validated line of the daemon's history export. */
-export type HistoryExportRecord = typeof HistoryExportRecord.Type;
-declare const SendError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "SendError";
-} & Readonly<A>;
-/** An addressed send failed before local certification completed. */
-export declare class SendError extends SendError_base<{
-    readonly reason: SendFailure;
-}> {
-    get message(): string;
-}
-/**
- * Why a collective send was refused, discriminated by `kind`: a gather or
- * all_gather whose schema is outside the form-mode grammar or whose request
- * post some member could not receive, or a response the member's endpoint
- * cannot send.
- */
-declare const collectiveFailure: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["members-unreachable"]>;
-    members: Schema.NonEmptyArray<Schema.Struct<{
-        member: Schema.brand<Schema.filter<Schema.brand<Schema.filter<typeof Schema.String>, "MessageAddressInput">>, "AgentAddress">;
-        reason: Schema.Literal<["invalid-address", "unknown-agent", "membership-invalid", "content-invalid", "not-registered", "version-mismatch", "certification-unavailable", "persistence-failed", "network-unavailable"]>;
-    }>>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["schema-invalid"]>;
-    detail: typeof Schema.String;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["answer-invalid"]>;
-    fields: Schema.NonEmptyArray<Schema.Struct<{
-        field: typeof Schema.String;
-        reason: Schema.Literal<["missing", "unexpected", "invalid"]>;
-        detail: Schema.optionalWith<typeof Schema.String, {
-            exact: true;
-        }>;
-    }>>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["request-none"]>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["request-ambiguous"]>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["request-answered"]>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["request-expired"]>;
-}>]>;
-/** A validated collective failure. */
-export type CollectiveFailure = typeof collectiveFailure.Type;
-/**
- * Decode a collective failure carried across the loopback MCP boundary.
- * @param value Untrusted failure detail from a refused send's error data.
- * @returns The validated failure.
- */
-export declare const decodeCollectiveFailure: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
-    readonly kind: "members-unreachable";
-    readonly members: readonly [{
-        readonly member: string & import("effect/Brand").Brand<"MessageAddressInput"> & import("effect/Brand").Brand<"AgentAddress">;
-        readonly reason: "certification-unavailable" | "content-invalid" | "invalid-address" | "membership-invalid" | "network-unavailable" | "not-registered" | "persistence-failed" | "unknown-agent" | "version-mismatch";
-    }, ...{
-        readonly member: string & import("effect/Brand").Brand<"MessageAddressInput"> & import("effect/Brand").Brand<"AgentAddress">;
-        readonly reason: "certification-unavailable" | "content-invalid" | "invalid-address" | "membership-invalid" | "network-unavailable" | "not-registered" | "persistence-failed" | "unknown-agent" | "version-mismatch";
-    }[]];
-} | {
-    readonly kind: "schema-invalid";
-    readonly detail: string;
-} | {
-    readonly kind: "answer-invalid";
-    readonly fields: readonly [{
-        readonly field: string;
-        readonly reason: "invalid" | "missing" | "unexpected";
-        readonly detail?: string | undefined;
-    }, ...{
-        readonly field: string;
-        readonly reason: "invalid" | "missing" | "unexpected";
-        readonly detail?: string | undefined;
-    }[]];
-} | {
-    readonly kind: "request-none";
-} | {
-    readonly kind: "request-ambiguous";
-} | {
-    readonly kind: "request-answered";
-} | {
-    readonly kind: "request-expired";
-}, import("effect/ParseResult").ParseError, never>;
-declare const CollectiveError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "CollectiveError";
-} & Readonly<A>;
-/**
- * A gather, all_gather or answer was refused. The message names each
- * unreachable member or failing field, so a host can hand it to its model as
- * the tool error.
- */
-export declare class CollectiveError extends CollectiveError_base<{
-    readonly id: CollectiveId;
-    readonly failure: CollectiveFailure;
-}> {
-    get message(): string;
-}
-type ListenFailure = "already-listening" | "incompatible-daemon" | "transport-failed" | "decode-failed";
-declare const ListenError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ListenError";
-} & Readonly<A>;
-/** The endpoint's sole inbound subscription failed. */
-export declare class ListenError extends ListenError_base<{
-    readonly reason: ListenFailure;
-}> {
-    get message(): string;
-}
-type DeliveryAcknowledgeFailure = "unknown-delivery" | "delivery-conflict" | "persistence-failed" | "transport-failed";
-declare const DeliveryAcknowledgeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "DeliveryAcknowledgeError";
-} & Readonly<A>;
-/** Transport acknowledgment could not complete for one delivery. */
-export declare class DeliveryAcknowledgeError extends DeliveryAcknowledgeError_base<{
-    readonly reason: DeliveryAcknowledgeFailure;
-}> {
-    get message(): string;
-}
-type ConnectFailure = "transport-failed" | "decode-failed" | "incompatible-daemon";
-declare const ConnectError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ConnectError";
-} & Readonly<A>;
-/** Acquiring the endpoint connection failed. */
-export declare class ConnectError extends ConnectError_base<{
-    readonly reason: ConnectFailure;
-}> {
-    get message(): string;
-}
-/** One inbound item plus its transport-only acknowledgment. */
-export interface InboundDelivery {
-    readonly item: InboundItem;
-    readonly acknowledge: Effect.Effect<void, DeliveryAcknowledgeError>;
-}
-/**
- * Structural runtime capability owned by one scoped endpoint connection.
- * Every send is one operation or one collective response; the stream yields
- * inbound items.
- *
- * A host whose tool returns before the send completes passes
- * `failureDelivery: "inbound"`: a refused gather, all_gather or response
- * then completes and its error arrives as an `operationFailed` item on the
- * stream. A multicast has no operation id, so its failure is always returned.
- */
-export interface HarnessEndpoint {
-    readonly send: (input: SendInput, options?: Readonly<{
-        failureDelivery?: FailureDelivery;
-    }>) => Effect.Effect<SendResult, SendError | CollectiveError>;
-    readonly messages: Stream.Stream<InboundDelivery, ListenError>;
-}
-export {};
-//# sourceMappingURL=contract.d.ts.map