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

package/dist/MessagingHost-CRk0kXzT.d.mts

@@ -0,0 +1,246 @@
+import { u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { s as SubagentExecutionFailure } from "./SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt, r as Principal, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { r as AnyDefinition } from "./Agent-CN0EWRsR.mjs";
+import { u as WorkerSource } from "./Worker-CaPYykpe.mjs";
+import { Context, Effect, Schema } from "effect";
+//#region src/core/Messaging.d.ts
+/** Application-chosen fixed route name; it never authorizes a destination by itself. */
+declare const PeerName: Schema.NonEmptyString;
+type PeerName = typeof PeerName.Type;
+/** A retained outbound delivery identity, not a destination Receipt or access grant. */
+declare const MessageRef: Schema.Struct<{
+  readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+}>;
+type MessageRef = typeof MessageRef.Type;
+declare const MessageAddress: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+}>;
+type MessageAddress = typeof MessageAddress.Type;
+/** Host-authenticated provenance stored separately from destination-owned application input. */
+declare const MessageAdmission: 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">;
+  }>>;
+}>;
+type MessageAdmission = typeof MessageAdmission.Type;
+/** Bounded public projection of delivery state; the frozen envelope remains host-private. */
+declare const MessageStatus: 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>;
+}>;
+type MessageStatus = typeof MessageStatus.Type;
+declare const InboxEntry: 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">;
+    }>>;
+  }>;
+}>;
+type InboxEntry = typeof InboxEntry.Type;
+declare const InboxPage: 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>;
+}>;
+type InboxPage = typeof InboxPage.Type;
+declare const MessagingError_base: Schema.Class<MessagingError, Schema.TaggedStruct<"MessagingError", {
+  readonly operation: Schema.Literals<readonly ["context", "send", "reply", "inbox", "inspect", "retry"]>;
+  readonly reason: Schema.Literals<readonly ["denied", "unavailable", "route-unavailable", "binding-mismatch", "invalid-input", "invalid-reference", "conflict", "capacity", "not-found", "storage", "corrupt"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class MessagingError extends MessagingError_base {}
+/** Canonical input provenance: peer input or a framework-owned completion message. */
+declare const InputMessage: Schema.Union<readonly [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">;
+  }>>;
+}>, Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerCompletion">;
+  readonly budgetExhausted: Schema.Boolean;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly report: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literal<"completed">;
+    readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+    readonly failure: typeof SubagentExecutionFailure;
+  }>]>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerUpdate">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly update: typeof Update;
+}>]>]>;
+type InputMessage = typeof InputMessage.Type;
+declare namespace MessagingHost_d_exports {
+  export { MessagingHost, PeerAuthorizationRequest, PeerAuthorizer, PeerDeliveryLifetime, PeerMessageCapacity, PeerRoutes, PeerTarget, SendPeerMessage };
+}
+interface PeerTarget {
+  readonly name: string;
+  readonly target: AnyDefinition;
+}
+/** A fixed declaration chooses the route. Caller input never selects a destination Thread. */
+interface SendPeerMessage extends PeerTarget {
+  readonly encodedInput: unknown;
+  readonly idempotencyKey: IdempotencyKey;
+  /** Correlation on sends; replies additionally resolve and authorize the recorded return address. */
+  readonly inReplyTo?: MessageRef;
+}
+declare const MessagingHost_base: Context.ServiceClass<MessagingHost, "@effect-agent/engine/MessagingHost", {
+  readonly context: Effect.Effect<WorkerSource, MessagingError>;
+  readonly send: (request: SendPeerMessage) => Effect.Effect<MessageStatus, MessagingError>;
+  readonly reply: (request: SendPeerMessage & {
+    readonly inReplyTo: MessageRef;
+  }) => Effect.Effect<MessageStatus, MessagingError>;
+  readonly inbox: (request: PeerTarget & {
+    readonly after?: number;
+    readonly limit: number;
+  }) => Effect.Effect<InboxPage, MessagingError>;
+  readonly inspect: (request: PeerTarget & {
+    readonly message: MessageRef;
+  }) => Effect.Effect<MessageStatus, MessagingError>;
+  readonly retry: (request: PeerTarget & {
+    readonly message: MessageRef;
+  }) => Effect.Effect<MessageStatus, MessagingError>;
+}>;
+/** Trusted per-invocation facet. It carries caller authority without exposing it in Tool schemas. */
+declare class MessagingHost extends MessagingHost_base {
+  static readonly unavailable: MessagingHost["Service"];
+  /** Runtime-owned per-call binding. Unconfigured Runs deny peer operations. */
+  static readonly forTool: Context.Reference<(source: Extract<WorkerSource, {
+    readonly _tag: "tool";
+  }>) => MessagingHost["Service"]>;
+}
+/** Separate context, history, send and management grants; incoming messages grant none of them. */
+interface PeerAuthorizationRequest {
+  readonly source: MessageAddress;
+  readonly principal: Principal;
+  readonly operation: MessagingError["operation"];
+  readonly access: "context" | "read" | "send" | "control";
+  readonly peerName?: string;
+  readonly destination?: MessageAddress;
+}
+declare const PeerAuthorizer: Context.Reference<{
+  /** Return the stable delivery principal for sends. It is retained with the frozen envelope. */
+  readonly authorize: (request: PeerAuthorizationRequest) => Effect.Effect<Principal, MessagingError>;
+}>;
+/** Application-owned routing; the target Agent is resolved from the existing exact registrations. */
+declare const PeerRoutes: Context.Reference<{
+  readonly resolve: (request: {
+    readonly source: MessageAddress;
+    readonly principal: Principal;
+    readonly peerName: string;
+    readonly targetAgentId: MessageAddress["agentId"];
+  }) => Effect.Effect<ThreadId, MessagingError>;
+}>;
+/** Retry windows are finite; exhaustion parks the retained envelope for explicit authorized retry. */
+declare const PeerDeliveryLifetime: Context.Reference<number>;
+/** Bound canonical send intents across all peers and principals in one source Thread. */
+declare const PeerMessageCapacity: Context.Reference<number>;
+//#endregion
+export { MessagingError as _, PeerDeliveryLifetime as a, PeerTarget as c, InboxPage as d, InputMessage as f, MessageStatus as g, MessageRef as h, PeerAuthorizer as i, SendPeerMessage as l, MessageAdmission as m, MessagingHost_d_exports as n, PeerMessageCapacity as o, MessageAddress as p, PeerAuthorizationRequest as r, PeerRoutes as s, MessagingHost as t, InboxEntry as u, PeerName as v };
+//# sourceMappingURL=MessagingHost-CRk0kXzT.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":";;;;;;;AAOA,MAAa,WAAW,OAAO,eAAe,MAC5C,OAAO,YAAY,EAAE,GACrB,OAAO,UAAU,mBAAmB,CACtC;;AAKA,MAAa,aAAa,OAAO,OAAO;CAAE,eAAe;CAAU,WAAW;AAAe,CAAC;AAG9F,MAAa,iBAAiB,OAAO,OAAO;CAAE,UAAU;CAAU,SAAS;AAAQ,CAAC;;AAIpF,MAAa,mBAAmB,OAAO,OAAO;CAC5C,eAAe,OAAO,QAAQ,CAAC;CAC/B,SAAS;CACT,UAAU;CACV,QAAQ;CACR,eAAe;CACf,WAAW,OAAO,YAAY,UAAU;AAC1C,CAAC,CAAC,CAAC,MACD,OAAO,YACJ,UACC,MAAM,QAAQ,kBAAkB,MAAM,OAAO,YAC7C,MAAM,OAAO,aAAa,MAAM,cAAc,YAC9C,MAAM,OAAO,YAAY,MAAM,cAAc,OACjD,CACF;;AAKA,MAAa,gBAAgB,OAAO,OAAO;CACzC,SAAS;CACT,QAAQ,OAAO,SAAS;EAAC;EAAW;EAAY;EAAa;EAAW;CAAQ,CAAC;CACjF,SAAS,OAAO,OAAO,OAAO;CAC9B,YAAY,OAAO,OACjB,OAAO,OAAO;EACZ,cAAc;EACd,SAAS,OAAO,SAAS;GAAC;GAAa;GAAU;EAAS,CAAC;CAC7D,CAAC,CACH;CACA,QAAQ,OAAO,OAAO,OAAO,OAAO,MAAM,OAAO,YAAY,GAAG,CAAC,CAAC;AACpE,CAAC;AAID,MAAa,aAAa,OAAO,OAAO;CACtC,UAAU,OAAO,QAAQ,MAAM,OAAO,cAAc,CAAC,CAAC;CACtD,WAAW;AACb,CAAC;AAID,MAAa,YAAY,OAAO,OAAO;CACrC,OAAO,OAAO,MAAM,UAAU,CAAC,CAAC,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,MAAM,OAAO,OAAO,OAAO,OAAO;AACpC,CAAC;AAID,IAAa,iBAAb,cAAoC,OAAO,YAA4B,CAAC,CAAC,kBAAkB;CACzF,WAAW,OAAO,SAAS;EAAC;EAAW;EAAQ;EAAS;EAAS;EAAW;CAAO,CAAC;CACpF,QAAQ,OAAO,SAAS;EACtB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;AACH,CAAC,CAAC,CAAC,CAAC;;AAGJ,MAAa,eAAe,OAAO,MAAM,CAAC,kBAAkB,gBAAgB,CAAC;;;;;;;;;;;AC5D7E,IAAa,gBAAb,MAAa,sBAAsB,QAAQ,QAkBzC,CAAC,CAAC,oCAAoC,CAAC,CAAC;CACxC,OAAgB,cAAwC;EACtD,SAAS,eAAe,KAAK;GAAE,WAAW;GAAW,QAAQ;EAAc,CAAC;EAC5E,YAAY,eAAe,KAAK;GAAE,WAAW;GAAQ,QAAQ;EAAc,CAAC;EAC5E,aAAa,eAAe,KAAK;GAAE,WAAW;GAAS,QAAQ;EAAc,CAAC;EAC9E,aAAa,eAAe,KAAK;GAAE,WAAW;GAAS,QAAQ;EAAc,CAAC;EAC9E,eAAe,eAAe,KAAK;GAAE,WAAW;GAAW,QAAQ;EAAc,CAAC;EAClF,aAAa,eAAe,KAAK;GAAE,WAAW;GAAS,QAAQ;EAAc,CAAC;CAChF;;CAGA,OAAgB,UAAU,QAAQ,UAEhC,8CAA8C,EAC9C,0BAA0B,cAAc,YAC1C,CAAC;AACH;AAYA,MAAa,iBAAiB,QAAQ,UAKnC,uCAAuC,EACxC,qBAAqB,EACnB,YAAY,YAAY,eAAe,KAAK;CAAE,WAAW,QAAQ;CAAW,QAAQ;AAAS,CAAC,EAChG,GACF,CAAC;;AAGD,MAAa,aAAa,QAAQ,UAO/B,mCAAmC,EACpC,qBAAqB,EACnB,eAAe,eAAe,KAAK;CAAE,WAAW;CAAQ,QAAQ;AAAoB,CAAC,EACvF,GACF,CAAC;;AAGD,MAAa,uBAAuB,QAAQ,UAC1C,6CACA,EAAE,oBAAoB,MAAW,CACnC;;AAGA,MAAa,sBAAsB,QAAQ,UACzC,4CACA,EAAE,oBAAoB,IAAI,CAC5B"}

package/dist/OperationAuthorizer-TzcQtpX5.d.mts

@@ -0,0 +1,61 @@
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace OperationAuthorizer_d_exports {
+  export { AuthorizedOperation, OperationAuthorizationRequest, OperationAuthorizer, OperationAuthorizerService, OperationDenied, operationAuthorizerLayer, possessionOperationAuthorizer };
+}
+/**
+ * Administrative/observation operations submitted to authorization (P7 WP1; SEC-003/SEC-011,
+ * DUR-017 "authenticated per-read authorization"). The union covers every operation the durable
+ * runtime consults the authorizer for: canonical observation, settlement waits, aborts,
+ * administration, and the two durable resolution paths.
+ */
+declare const AuthorizedOperation: Schema.Literals<readonly ["observe", "awaitSettlement", "abort", "explain", "verify", "retry", "wake", "scanObligations", "resolveUnknown", "resolveApproval"]>;
+type AuthorizedOperation = typeof AuthorizedOperation.Type;
+declare const OperationAuthorizationRequest_base: Schema.Class<OperationAuthorizationRequest, Schema.Struct<{
+  readonly operation: Schema.Literals<readonly ["observe", "awaitSettlement", "abort", "explain", "verify", "retry", "wake", "scanObligations", "resolveUnknown", "resolveApproval"]>;
+  readonly threadId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+  readonly submissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly principal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+}>, {}>;
+/**
+ * One authorization question. `principal` is present only when the host authenticated a caller
+ * identity and threaded it through — the framework never parses bearer tokens (SEC-001); absent
+ * identity under the default authorizer keeps the pre-P7 service-possession behavior.
+ */
+declare class OperationAuthorizationRequest extends OperationAuthorizationRequest_base {}
+declare const OperationDenied_base: Schema.Class<OperationDenied, Schema.TaggedStruct<"OperationDenied", {
+  readonly operation: Schema.Literals<readonly ["observe", "awaitSettlement", "abort", "explain", "verify", "retry", "wake", "scanObligations", "resolveUnknown", "resolveApproval"]>;
+  readonly reason: Schema.String;
+  readonly threadId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+  readonly submissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+}>, import("effect/Cause").YieldableError>;
+/** A typed, fail-closed authorization denial (never a defect, never silent). */
+declare class OperationDenied extends OperationDenied_base {}
+/**
+ * The minimal authorization port consulted by `observe`, `awaitSettlement`, `abort`, administration, and the
+ * `resolveUnknown`/`resolveApproval` resolution paths. `authorize` either succeeds (allow) or
+ * fails with the typed `OperationDenied` (deny) — the runtime propagates the denial fail-closed
+ * and performs no reads or writes for the denied operation.
+ */
+interface OperationAuthorizerService {
+  readonly authorize: (request: OperationAuthorizationRequest) => Effect.Effect<void, OperationDenied>;
+}
+/**
+ * The default possession-behavior authorizer: possession of the `DurableAgentRuntime` service
+ * (plus each mutating command's mandatory author/reason audit fields) IS the authorization —
+ * exactly the pre-P7 boundary, unchanged. Hosts that authenticate callers substitute a real
+ * decision procedure through `operationAuthorizerLayer`; the framework enforces the decision
+ * fail-closed without inventing an identity system (D10/DUR-017 stance, plan §3).
+ */
+declare const possessionOperationAuthorizer: OperationAuthorizerService;
+/**
+ * Context reference with the possession default, mirroring `DurableApprovalResolver`: the
+ * coordinator consults it unconditionally, and only a host-supplied non-default Layer changes
+ * the answer. References resolve at Layer construction, so provide the override when building
+ * `DurableAgentRuntime.layer` (e.g. `Layer.provide(operationAuthorizerLayer(...))`).
+ */
+declare const OperationAuthorizer: Context.Reference<OperationAuthorizerService>;
+/** Layer carrying a host-supplied authorization decision procedure. */
+declare const operationAuthorizerLayer: (service: OperationAuthorizerService) => Layer.Layer<never>;
+//#endregion
+export { OperationAuthorizer_d_exports as a, possessionOperationAuthorizer as c, OperationAuthorizerService as i, OperationAuthorizationRequest as n, OperationDenied as o, OperationAuthorizer as r, operationAuthorizerLayer as s, AuthorizedOperation as t };
+//# sourceMappingURL=OperationAuthorizer-TzcQtpX5.d.mts.map

package/dist/Output-D6SkedVx.d.mts

@@ -0,0 +1,25 @@
+import "./Agent-CN0EWRsR.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Schema } from "effect";
+//#region src/engine/internal/output-contract.d.ts
+/**
+ * Declare ordinary assistant text as an Agent's final-output wire format. Apply this to the
+ * complete output Schema after composing transformations. Its encoded type must be string;
+ * decoding, checks, transformations, and service requirements remain owned by that Schema.
+ * Text is preserved verbatim, including whitespace, quotes, and an empty reply when allowed.
+ * Required completion Tools still take precedence. Unmarked Schemas use JSON final output.
+ *
+ * @example
+ * ```ts
+ * output: Output.text(Schema.String.check(Schema.isMaxLength(20_000)))
+ * ```
+ */
+declare const textOutput: <S extends Schema.Top & {
+  readonly Encoded: string;
+}>(schema: S) => S["Rebuild"];
+declare namespace Output_d_exports {
+  export { textOutput as text };
+}
+//#endregion
+export { textOutput as n, Output_d_exports as t };
+//# sourceMappingURL=Output-D6SkedVx.d.mts.map