effect-agent 0.0.1-beta.6 → 0.1.0-beta.100

package/dist/Messaging-QMYhp297.d.mts

@@ -0,0 +1,490 @@
+import { a as Receipt, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { r as AnyDefinition } from "./Agent-CM6JubNX.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-gAxs5gme.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-QMYhp297.d.mts.map

package/dist/MessagingHost-CWi_PP3g.mjs

@@ -0,0 +1,137 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AgentId, SettlementId, ThreadId } from "./core/Identifiers.mjs";
+import { IdempotencyKey, Receipt } from "./core/Receipt.mjs";
+import { FrameworkMessage } from "./core/Worker.mjs";
+import { Context, Schema } from "effect";
+//#region src/core/Messaging.ts
+/** Application-chosen fixed route name; it never authorizes a destination by itself. */
+const PeerName = Schema.NonEmptyString.check(Schema.isMaxLength(64), Schema.isPattern(/^[a-zA-Z0-9_-]+$/u));
+/** A retained outbound delivery identity, not a destination Receipt or access grant. */
+const MessageRef = Schema.Struct({
+	ownerThreadId: ThreadId,
+	messageId: IdempotencyKey
+});
+const MessageAddress = Schema.Struct({
+	threadId: ThreadId,
+	agentId: AgentId
+});
+/** Host-authenticated provenance stored separately from destination-owned application input. */
+const MessageAdmission = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	message: MessageRef,
+	peerName: PeerName,
+	sender: MessageAddress,
+	returnAddress: MessageAddress,
+	inReplyTo: Schema.optionalKey(MessageRef)
+}).check(Schema.makeFilter((value) => value.message.ownerThreadId === value.sender.threadId && value.sender.threadId === value.returnAddress.threadId && value.sender.agentId === value.returnAddress.agentId));
+/** Bounded public projection of delivery state; the frozen envelope remains host-private. */
+const MessageStatus = Schema.Struct({
+	message: MessageRef,
+	status: Schema.Literals([
+		"pending",
+		"accepted",
+		"processed",
+		"refused",
+		"parked"
+	]),
+	receipt: Schema.NullOr(Receipt),
+	settlement: Schema.NullOr(Schema.Struct({
+		settlementId: SettlementId,
+		outcome: Schema.Literals([
+			"completed",
+			"failed",
+			"aborted"
+		])
+	})),
+	reason: Schema.NullOr(Schema.String.check(Schema.isMaxLength(256)))
+});
+const InboxEntry = Schema.Struct({
+	sequence: Schema.Natural.check(Schema.isGreaterThan(0)),
+	admission: MessageAdmission
+});
+const InboxPage = Schema.Struct({
+	items: Schema.Array(InboxEntry).check(Schema.isMaxLength(100)),
+	next: Schema.NullOr(Schema.Natural)
+});
+var MessagingError = class extends Schema.TaggedError()("MessagingError", {
+	operation: Schema.Literals([
+		"context",
+		"send",
+		"reply",
+		"inbox",
+		"inspect",
+		"retry"
+	]),
+	reason: Schema.Literals([
+		"denied",
+		"unavailable",
+		"route-unavailable",
+		"binding-mismatch",
+		"invalid-input",
+		"invalid-reference",
+		"conflict",
+		"capacity",
+		"not-found",
+		"storage",
+		"corrupt"
+	])
+}) {};
+/** Canonical input provenance: peer input or a framework-owned completion message. */
+const InputMessage = Schema.Union([MessageAdmission, FrameworkMessage]);
+//#endregion
+//#region src/engine/MessagingHost.ts
+var MessagingHost_exports = /* @__PURE__ */ __exportAll({
+	MessagingHost: () => MessagingHost,
+	PeerAuthorizer: () => PeerAuthorizer,
+	PeerDeliveryLifetime: () => PeerDeliveryLifetime,
+	PeerMessageCapacity: () => PeerMessageCapacity,
+	PeerRoutes: () => PeerRoutes
+});
+/** Trusted per-invocation facet. It carries caller authority without exposing it in Tool schemas. */
+var MessagingHost = class MessagingHost extends Context.Service()("@effect-agent/engine/MessagingHost") {
+	static unavailable = {
+		context: MessagingError.make({
+			operation: "context",
+			reason: "unavailable"
+		}),
+		send: () => MessagingError.make({
+			operation: "send",
+			reason: "unavailable"
+		}),
+		reply: () => MessagingError.make({
+			operation: "reply",
+			reason: "unavailable"
+		}),
+		inbox: () => MessagingError.make({
+			operation: "inbox",
+			reason: "unavailable"
+		}),
+		inspect: () => MessagingError.make({
+			operation: "inspect",
+			reason: "unavailable"
+		}),
+		retry: () => MessagingError.make({
+			operation: "retry",
+			reason: "unavailable"
+		})
+	};
+	/** Runtime-owned per-call binding. Unconfigured Runs deny peer operations. */
+	static forTool = Context.Reference("@effect-agent/engine/MessagingHost/forTool", { defaultValue: () => () => MessagingHost.unavailable });
+};
+const PeerAuthorizer = Context.Reference("@effect-agent/thread/PeerAuthorizer", { defaultValue: () => ({ authorize: (request) => MessagingError.make({
+	operation: request.operation,
+	reason: "denied"
+}) }) });
+/** Application-owned routing; the target Agent is resolved from the existing exact registrations. */
+const PeerRoutes = Context.Reference("@effect-agent/thread/PeerRoutes", { defaultValue: () => ({ resolve: () => MessagingError.make({
+	operation: "send",
+	reason: "route-unavailable"
+}) }) });
+/** Retry windows are finite; exhaustion parks the retained envelope for explicit authorized retry. */
+const PeerDeliveryLifetime = Context.Reference("@effect-agent/thread/PeerDeliveryLifetime", { defaultValue: () => 864e5 });
+/** Bound canonical send intents across all peers and principals in one source Thread. */
+const PeerMessageCapacity = Context.Reference("@effect-agent/thread/PeerMessageCapacity", { defaultValue: () => 256 });
+//#endregion
+export { PeerMessageCapacity as a, InboxPage as c, MessageAdmission as d, MessageRef as f, PeerName as h, PeerDeliveryLifetime as i, InputMessage as l, MessagingError as m, MessagingHost_exports as n, PeerRoutes as o, MessageStatus as p, PeerAuthorizer as r, InboxEntry as s, MessagingHost as t, MessageAddress as u };
+
+//# sourceMappingURL=MessagingHost-CWi_PP3g.mjs.map

package/dist/MessagingHost-CWi_PP3g.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagingHost-CWi_PP3g.mjs","names":[],"sources":["../src/core/Messaging.ts","../src/engine/MessagingHost.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { AgentId, SettlementId, ThreadId } from \"./Identifiers.ts\";\nimport { IdempotencyKey, Receipt } from \"./Receipt.ts\";\nimport { FrameworkMessage } from \"./Worker.ts\";\n\n/** Application-chosen fixed route name; it never authorizes a destination by itself. */\nexport const PeerName = Schema.NonEmptyString.check(\n  Schema.isMaxLength(64),\n  Schema.isPattern(/^[a-zA-Z0-9_-]+$/u),\n);\n\nexport type PeerName = typeof PeerName.Type;\n\n/** A retained outbound delivery identity, not a destination Receipt or access grant. */\nexport const MessageRef = Schema.Struct({ ownerThreadId: ThreadId, messageId: IdempotencyKey });\nexport type MessageRef = typeof MessageRef.Type;\n\nexport const MessageAddress = Schema.Struct({ threadId: ThreadId, agentId: AgentId });\nexport type MessageAddress = typeof MessageAddress.Type;\n\n/** Host-authenticated provenance stored separately from destination-owned application input. */\nexport const MessageAdmission = Schema.Struct({\n  schemaVersion: Schema.Literal(1),\n  message: MessageRef,\n  peerName: PeerName,\n  sender: MessageAddress,\n  returnAddress: MessageAddress,\n  inReplyTo: Schema.optionalKey(MessageRef),\n}).check(\n  Schema.makeFilter(\n    (value) =>\n      value.message.ownerThreadId === value.sender.threadId &&\n      value.sender.threadId === value.returnAddress.threadId &&\n      value.sender.agentId === value.returnAddress.agentId,\n  ),\n);\n\nexport type MessageAdmission = typeof MessageAdmission.Type;\n\n/** Bounded public projection of delivery state; the frozen envelope remains host-private. */\nexport const MessageStatus = Schema.Struct({\n  message: MessageRef,\n  status: Schema.Literals([\"pending\", \"accepted\", \"processed\", \"refused\", \"parked\"]),\n  receipt: Schema.NullOr(Receipt),\n  settlement: Schema.NullOr(\n    Schema.Struct({\n      settlementId: SettlementId,\n      outcome: Schema.Literals([\"completed\", \"failed\", \"aborted\"]),\n    }),\n  ),\n  reason: Schema.NullOr(Schema.String.check(Schema.isMaxLength(256))),\n});\n\nexport type MessageStatus = typeof MessageStatus.Type;\n\nexport const InboxEntry = Schema.Struct({\n  sequence: Schema.Natural.check(Schema.isGreaterThan(0)),\n  admission: MessageAdmission,\n});\n\nexport type InboxEntry = typeof InboxEntry.Type;\n\nexport const InboxPage = Schema.Struct({\n  items: Schema.Array(InboxEntry).check(Schema.isMaxLength(100)),\n  next: Schema.NullOr(Schema.Natural),\n});\n\nexport type InboxPage = typeof InboxPage.Type;\n\nexport class MessagingError extends Schema.TaggedError<MessagingError>()(\"MessagingError\", {\n  operation: Schema.Literals([\"context\", \"send\", \"reply\", \"inbox\", \"inspect\", \"retry\"]),\n  reason: Schema.Literals([\n    \"denied\",\n    \"unavailable\",\n    \"route-unavailable\",\n    \"binding-mismatch\",\n    \"invalid-input\",\n    \"invalid-reference\",\n    \"conflict\",\n    \"capacity\",\n    \"not-found\",\n    \"storage\",\n    \"corrupt\",\n  ]),\n}) {}\n\n/** Canonical input provenance: peer input or a framework-owned completion message. */\nexport const InputMessage = Schema.Union([MessageAdmission, FrameworkMessage]);\nexport type InputMessage = typeof InputMessage.Type;\n","import { Context, type Effect } from \"effect\";\n\nimport type { AnyDefinition } from \"../core/Agent.ts\";\nimport type { ThreadId } from \"../core/Identifiers.ts\";\nimport {\n  type InboxPage,\n  type MessageAddress,\n  type MessageRef,\n  type MessageStatus,\n  MessagingError,\n} from \"../core/Messaging.ts\";\nimport type { IdempotencyKey, Principal } from \"../core/Receipt.ts\";\nimport type { WorkerSource } from \"../core/Worker.ts\";\n\nexport interface PeerTarget {\n  readonly name: string;\n  readonly target: AnyDefinition;\n}\n\n/** A fixed declaration chooses the route. Caller input never selects a destination Thread. */\nexport interface SendPeerMessage extends PeerTarget {\n  readonly encodedInput: unknown;\n  readonly idempotencyKey: IdempotencyKey;\n  /** Correlation on sends; replies additionally resolve and authorize the recorded return address. */\n  readonly inReplyTo?: MessageRef;\n}\n\n/** Trusted per-invocation facet. It carries caller authority without exposing it in Tool schemas. */\nexport class MessagingHost extends Context.Service<\n  MessagingHost,\n  {\n    readonly context: Effect.Effect<WorkerSource, MessagingError>;\n    readonly send: (request: SendPeerMessage) => Effect.Effect<MessageStatus, MessagingError>;\n    readonly reply: (\n      request: SendPeerMessage & { readonly inReplyTo: MessageRef },\n    ) => Effect.Effect<MessageStatus, MessagingError>;\n    readonly inbox: (\n      request: PeerTarget & { readonly after?: number; readonly limit: number },\n    ) => Effect.Effect<InboxPage, MessagingError>;\n    readonly inspect: (\n      request: PeerTarget & { readonly message: MessageRef },\n    ) => Effect.Effect<MessageStatus, MessagingError>;\n    readonly retry: (\n      request: PeerTarget & { readonly message: MessageRef },\n    ) => Effect.Effect<MessageStatus, MessagingError>;\n  }\n>()(\"@effect-agent/engine/MessagingHost\") {\n  static readonly unavailable: MessagingHost[\"Service\"] = {\n    context: MessagingError.make({ operation: \"context\", reason: \"unavailable\" }),\n    send: () => MessagingError.make({ operation: \"send\", reason: \"unavailable\" }),\n    reply: () => MessagingError.make({ operation: \"reply\", reason: \"unavailable\" }),\n    inbox: () => MessagingError.make({ operation: \"inbox\", reason: \"unavailable\" }),\n    inspect: () => MessagingError.make({ operation: \"inspect\", reason: \"unavailable\" }),\n    retry: () => MessagingError.make({ operation: \"retry\", reason: \"unavailable\" }),\n  };\n\n  /** Runtime-owned per-call binding. Unconfigured Runs deny peer operations. */\n  static readonly forTool = Context.Reference<\n    (source: Extract<WorkerSource, { readonly _tag: \"tool\" }>) => MessagingHost[\"Service\"]\n  >(\"@effect-agent/engine/MessagingHost/forTool\", {\n    defaultValue: () => () => MessagingHost.unavailable,\n  });\n}\n\n/** Separate context, history, send and management grants; incoming messages grant none of them. */\nexport interface PeerAuthorizationRequest {\n  readonly source: MessageAddress;\n  readonly principal: Principal;\n  readonly operation: MessagingError[\"operation\"];\n  readonly access: \"context\" | \"read\" | \"send\" | \"control\";\n  readonly peerName?: string;\n  readonly destination?: MessageAddress;\n}\n\nexport const PeerAuthorizer = Context.Reference<{\n  /** Return the stable delivery principal for sends. It is retained with the frozen envelope. */\n  readonly authorize: (\n    request: PeerAuthorizationRequest,\n  ) => Effect.Effect<Principal, MessagingError>;\n}>(\"@effect-agent/thread/PeerAuthorizer\", {\n  defaultValue: () => ({\n    authorize: (request) => MessagingError.make({ operation: request.operation, reason: \"denied\" }),\n  }),\n});\n\n/** Application-owned routing; the target Agent is resolved from the existing exact registrations. */\nexport const PeerRoutes = Context.Reference<{\n  readonly resolve: (request: {\n    readonly source: MessageAddress;\n    readonly principal: Principal;\n    readonly peerName: string;\n    readonly targetAgentId: MessageAddress[\"agentId\"];\n  }) => Effect.Effect<ThreadId, MessagingError>;\n}>(\"@effect-agent/thread/PeerRoutes\", {\n  defaultValue: () => ({\n    resolve: () => MessagingError.make({ operation: \"send\", reason: \"route-unavailable\" }),\n  }),\n});\n\n/** Retry windows are finite; exhaustion parks the retained envelope for explicit authorized retry. */\nexport const PeerDeliveryLifetime = Context.Reference<number>(\n  \"@effect-agent/thread/PeerDeliveryLifetime\",\n  { defaultValue: () => 86_400_000 },\n);\n\n/** Bound canonical send intents across all peers and principals in one source Thread. */\nexport const PeerMessageCapacity = Context.Reference<number>(\n  \"@effect-agent/thread/PeerMessageCapacity\",\n  { defaultValue: () => 256 },\n);\n"],"mappings":"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"}