effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/Messaging-CkcIdt4I.d.mts

@@ -0,0 +1,490 @@
+import { a as Receipt, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { r as AnyDefinition } from "./Agent-CN0EWRsR.mjs";
+import { _ as MessagingError, d as InboxPage, f as InputMessage, g as MessageStatus, h as MessageRef, m as MessageAdmission, p as MessageAddress, t as MessagingHost, u as InboxEntry, v as PeerName } from "./MessagingHost-CRk0kXzT.mjs";
+import { Tool, Toolkit } from "effect/unstable/ai";
+import { Crypto, Effect, Schema } from "effect";
+declare namespace Messaging_d_exports {
+  export { InboxEntry, InboxPage, InputMessage, MessageAddress, MessageAdmission, MessageRef, MessageStatus, MessagingError, Peer, PeerName, inbox, inboxTool, inspect, inspectTool, peer, reply, replyTool, retry, retryTool, send, sendTool };
+}
+/** A fixed host route and its destination-owned input Schema. Construction acquires no resources. */
+interface Peer<Name extends string, Input extends Schema.Top> {
+  readonly name: Name;
+  readonly target: AnyDefinition & {
+    readonly input: Input;
+  };
+}
+declare const peer: <const Name extends string, Input extends Schema.Top>(name: Name, options: {
+  readonly target: AnyDefinition & {
+    readonly input: Input;
+  };
+}) => Peer<Name, Input>;
+/** Retain a durable message. Its status distinguishes outbound retention from destination acceptance. */
+declare const send: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, input: Input["Type"], options: {
+  readonly idempotencyKey: IdempotencyKey;
+  readonly inReplyTo?: MessageRef;
+}) => Effect.Effect<{
+  readonly message: {
+    readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+  };
+  readonly status: "accepted" | "parked" | "pending" | "processed" | "refused";
+  readonly receipt: Receipt | null;
+  readonly settlement: {
+    readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+    readonly outcome: "aborted" | "completed" | "failed";
+  } | null;
+  readonly reason: string | null;
+}, MessagingError, MessagingHost | (Schema.Top & Input)["EncodingServices"]>;
+/** Reply to an authenticated inbound message; return routing still requires independent send authority. */
+declare const reply: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, inReplyTo: MessageRef, input: Input["Type"], options: {
+  readonly idempotencyKey: IdempotencyKey;
+}) => Effect.Effect<{
+  readonly message: {
+    readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+  };
+  readonly status: "accepted" | "parked" | "pending" | "processed" | "refused";
+  readonly receipt: Receipt | null;
+  readonly settlement: {
+    readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+    readonly outcome: "aborted" | "completed" | "failed";
+  } | null;
+  readonly reason: string | null;
+}, MessagingError, MessagingHost | (Schema.Top & Input)["EncodingServices"]>;
+/** Return bounded provenance for messages from this peer, without granting permission to reply. */
+declare const inbox: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, options?: {
+  readonly after?: number;
+  readonly limit?: number;
+}) => Effect.Effect<{
+  readonly items: readonly {
+    readonly sequence: number;
+    readonly admission: {
+      readonly schemaVersion: 1;
+      readonly message: {
+        readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      };
+      readonly peerName: string;
+      readonly sender: {
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      };
+      readonly returnAddress: {
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly agentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      };
+      readonly inReplyTo?: {
+        readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+        readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+      } | undefined;
+    };
+  }[];
+  readonly next: number | null;
+}, MessagingError, MessagingHost>;
+declare const inspect: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, message: MessageRef) => Effect.Effect<{
+  readonly message: {
+    readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+  };
+  readonly status: "accepted" | "parked" | "pending" | "processed" | "refused";
+  readonly receipt: Receipt | null;
+  readonly settlement: {
+    readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+    readonly outcome: "aborted" | "completed" | "failed";
+  } | null;
+  readonly reason: string | null;
+}, MessagingError, MessagingHost>;
+/** Explicitly renew a parked delivery's bounded retry budget, retaining its complete frozen envelope. */
+declare const retry: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, message: MessageRef) => Effect.Effect<{
+  readonly message: {
+    readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+  };
+  readonly status: "accepted" | "parked" | "pending" | "processed" | "refused";
+  readonly receipt: Receipt | null;
+  readonly settlement: {
+    readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+    readonly outcome: "aborted" | "completed" | "failed";
+  } | null;
+  readonly reason: string | null;
+}, MessagingError, MessagingHost>;
+/** Install only the native operations chosen by the host; schemas come from the Peer declaration. */
+declare const sendTool: <const Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>) => {
+  tool: Tool.Tool<`${Name}_send`, {
+    readonly parameters: Schema.Top & Input;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost>;
+  toolkit: Toolkit.Toolkit<{ readonly [Tool in Tool.Tool<`${Name}_send`, {
+    readonly parameters: Schema.Top & Input;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>;
+  layer: import("effect/Layer").Layer<Tool.HandlersFor<{ readonly [Tool in Tool.Tool<`${Name}_send`, {
+    readonly parameters: Schema.Top & Input;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>, never, Exclude<Exclude<(Schema.Top & Input)["EncodingServices"], Crypto.Crypto | MessagingHost>, import("effect/Scope").Scope>>;
+};
+declare const replyTool: <const Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>) => {
+  tool: Tool.Tool<`${Name}_reply`, {
+    readonly parameters: Schema.Struct<{
+      readonly inReplyTo: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly input: Schema.Codec<Input["Type"], Input["Encoded"], Input["DecodingServices"], Input["EncodingServices"]>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost>;
+  toolkit: Toolkit.Toolkit<{ readonly [Tool in Tool.Tool<`${Name}_reply`, {
+    readonly parameters: Schema.Struct<{
+      readonly inReplyTo: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly input: Schema.Codec<Input["Type"], Input["Encoded"], Input["DecodingServices"], Input["EncodingServices"]>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>;
+  layer: import("effect/Layer").Layer<Tool.HandlersFor<{ readonly [Tool in Tool.Tool<`${Name}_reply`, {
+    readonly parameters: Schema.Struct<{
+      readonly inReplyTo: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly input: Schema.Codec<Input["Type"], Input["Encoded"], Input["DecodingServices"], Input["EncodingServices"]>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>, never, Exclude<Exclude<(Schema.Top & Input)["EncodingServices"], Crypto.Crypto | MessagingHost>, import("effect/Scope").Scope>>;
+};
+declare const inboxTool: <const Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>) => {
+  tool: Tool.Tool<`${Name}_inbox`, {
+    readonly parameters: Schema.Struct<{
+      readonly after: Schema.optionalKey<Schema.Natural>;
+      readonly limit: Schema.optionalKey<Schema.Int>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly items: Schema.$Array<Schema.Struct<{
+        readonly sequence: Schema.Natural;
+        readonly admission: Schema.Struct<{
+          readonly schemaVersion: Schema.Literal<1>;
+          readonly message: Schema.Struct<{
+            readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+          }>;
+          readonly peerName: Schema.NonEmptyString;
+          readonly sender: Schema.Struct<{
+            readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          }>;
+          readonly returnAddress: Schema.Struct<{
+            readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          }>;
+          readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+            readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+          }>>;
+        }>;
+      }>>;
+      readonly next: Schema.NullOr<Schema.Natural>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost>;
+  toolkit: Toolkit.Toolkit<{ readonly [Tool in Tool.Tool<`${Name}_inbox`, {
+    readonly parameters: Schema.Struct<{
+      readonly after: Schema.optionalKey<Schema.Natural>;
+      readonly limit: Schema.optionalKey<Schema.Int>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly items: Schema.$Array<Schema.Struct<{
+        readonly sequence: Schema.Natural;
+        readonly admission: Schema.Struct<{
+          readonly schemaVersion: Schema.Literal<1>;
+          readonly message: Schema.Struct<{
+            readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+          }>;
+          readonly peerName: Schema.NonEmptyString;
+          readonly sender: Schema.Struct<{
+            readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          }>;
+          readonly returnAddress: Schema.Struct<{
+            readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          }>;
+          readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+            readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+          }>>;
+        }>;
+      }>>;
+      readonly next: Schema.NullOr<Schema.Natural>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>;
+  layer: import("effect/Layer").Layer<Tool.HandlersFor<{ readonly [Tool in Tool.Tool<`${Name}_inbox`, {
+    readonly parameters: Schema.Struct<{
+      readonly after: Schema.optionalKey<Schema.Natural>;
+      readonly limit: Schema.optionalKey<Schema.Int>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly items: Schema.$Array<Schema.Struct<{
+        readonly sequence: Schema.Natural;
+        readonly admission: Schema.Struct<{
+          readonly schemaVersion: Schema.Literal<1>;
+          readonly message: Schema.Struct<{
+            readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+          }>;
+          readonly peerName: Schema.NonEmptyString;
+          readonly sender: Schema.Struct<{
+            readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          }>;
+          readonly returnAddress: Schema.Struct<{
+            readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          }>;
+          readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+            readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+            readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+          }>>;
+        }>;
+      }>>;
+      readonly next: Schema.NullOr<Schema.Natural>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>, never, never>;
+};
+declare const inspectTool: <const Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>) => {
+  tool: Tool.Tool<`${Name}_message_status`, {
+    readonly parameters: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost>;
+  toolkit: Toolkit.Toolkit<{ readonly [Tool in Tool.Tool<`${Name}_message_status`, {
+    readonly parameters: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>;
+  layer: import("effect/Layer").Layer<Tool.HandlersFor<{ readonly [Tool in Tool.Tool<`${Name}_message_status`, {
+    readonly parameters: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>, never, never>;
+};
+declare const retryTool: <const Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>) => {
+  tool: Tool.Tool<`${Name}_retry_message`, {
+    readonly parameters: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost>;
+  toolkit: Toolkit.Toolkit<{ readonly [Tool in Tool.Tool<`${Name}_retry_message`, {
+    readonly parameters: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>;
+  layer: import("effect/Layer").Layer<Tool.HandlersFor<{ readonly [Tool in Tool.Tool<`${Name}_retry_message`, {
+    readonly parameters: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+    }>;
+    readonly success: Schema.Struct<{
+      readonly message: Schema.Struct<{
+        readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      }>;
+      readonly status: Schema.Literals<readonly ["pending", "accepted", "processed", "refused", "parked"]>;
+      readonly receipt: Schema.NullOr<typeof Receipt>;
+      readonly settlement: Schema.NullOr<Schema.Struct<{
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+      }>>;
+      readonly reason: Schema.NullOr<Schema.String>;
+    }>;
+    readonly failure: typeof MessagingError;
+    readonly failureMode: "error";
+  }, Crypto.Crypto | MessagingHost> as Tool["name"]]: Tool; }>, never, never>;
+};
+//#endregion
+export { inspect as a, reply as c, retryTool as d, send as f, inboxTool as i, replyTool as l, Peer as n, inspectTool as o, sendTool as p, inbox as r, peer as s, Messaging_d_exports as t, retry as u };
+//# sourceMappingURL=Messaging-CkcIdt4I.d.mts.map