effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/MessagingHost-CqzpxbGz.d.mts

@@ -0,0 +1,74 @@
+import { u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { r as Principal, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { r as AnyDefinition } from "./Agent-D9cXqfF3.mjs";
+import { h as WorkerSource } from "./Worker-fwWkBg12.mjs";
+import { c as MessageRef, i as MessageAddress, l as MessageStatus, n as InboxPage, o as MessagingError } from "./Messaging-Dkg87ebg.mjs";
+import { Context, Effect } from "effect";
+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 { PeerDeliveryLifetime as a, PeerTarget as c, PeerAuthorizer as i, SendPeerMessage as l, MessagingHost_d_exports as n, PeerMessageCapacity as o, PeerAuthorizationRequest as r, PeerRoutes as s, MessagingHost as t };
+//# sourceMappingURL=MessagingHost-CqzpxbGz.d.mts.map

package/dist/MessagingHost-DfsbMPvq.mjs

@@ -0,0 +1,110 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AgentId, ThreadId } from "./core/Identifiers.mjs";
+import { S as MessageRef, r as FrameworkMessage } from "./Worker-CfwzMZEK.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));
+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));
+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, MessagingError as f, PeerDeliveryLifetime as i, InputMessage as l, MessagingHost_exports as n, PeerRoutes as o, PeerName as p, PeerAuthorizer as r, InboxEntry as s, MessagingHost as t, MessageAddress as u };
+
+//# sourceMappingURL=MessagingHost-DfsbMPvq.mjs.map

package/dist/MessagingHost-DfsbMPvq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagingHost-DfsbMPvq.mjs","names":[],"sources":["../src/core/Messaging.ts","../src/engine/MessagingHost.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { AgentId, ThreadId } from \"./Identifiers.ts\";\nimport { MessageRef } from \"./internal/message-status.ts\";\nimport { FrameworkMessage } from \"./Worker.ts\";\n\nexport { MessageRef, MessageStatus } from \"./internal/message-status.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\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\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":";;;;;;AASA,MAAa,WAAW,OAAO,eAAe,MAC5C,OAAO,YAAY,EAAE,GACrB,OAAO,UAAU,mBAAmB,CACtC;AAIA,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;AAIA,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;;;;;;;;;;;AC1C7E,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-V-6YL1_Z.d.mts

@@ -0,0 +1,25 @@
+import "./Agent-D9cXqfF3.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-V-6YL1_Z.d.mts.map