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

package/dist/FailureDiagnostic-CaAkzGHL.d.mts

@@ -0,0 +1,223 @@
+import { Cause, Schema } from "effect";
+declare namespace FailureDiagnostic_d_exports {
+  export { Cause$1 as Cause, Context$1 as Context, Diagnostic, Failure, Value, capture, captureContext, redactText };
+}
+/** Correlation only: never include inputs, tool parameters, request bodies, or credentials. */
+declare const Context$1: Schema.declareConstructor<{
+  readonly agentId?: string | undefined;
+  readonly threadId?: string | undefined;
+  readonly runId?: string | undefined;
+  readonly submissionId?: string | undefined;
+  readonly attemptId?: string | undefined;
+  readonly turnId?: string | undefined;
+  readonly toolCallId?: string | undefined;
+  readonly toolName?: string | undefined;
+  readonly callId?: string | undefined;
+  readonly check?: string | undefined;
+  readonly operation?: string | undefined;
+}, {
+  readonly agentId?: string | undefined;
+  readonly threadId?: string | undefined;
+  readonly runId?: string | undefined;
+  readonly submissionId?: string | undefined;
+  readonly attemptId?: string | undefined;
+  readonly turnId?: string | undefined;
+  readonly toolCallId?: string | undefined;
+  readonly toolName?: string | undefined;
+  readonly callId?: string | undefined;
+  readonly check?: string | undefined;
+  readonly operation?: string | undefined;
+}, readonly [Schema.Struct<{
+  readonly agentId: Schema.optionalKey<Schema.String>;
+  readonly threadId: Schema.optionalKey<Schema.String>;
+  readonly runId: Schema.optionalKey<Schema.String>;
+  readonly submissionId: Schema.optionalKey<Schema.String>;
+  readonly attemptId: Schema.optionalKey<Schema.String>;
+  readonly turnId: Schema.optionalKey<Schema.String>;
+  readonly toolCallId: Schema.optionalKey<Schema.String>;
+  readonly toolName: Schema.optionalKey<Schema.String>;
+  readonly callId: Schema.optionalKey<Schema.String>;
+  readonly check: Schema.optionalKey<Schema.String>;
+  readonly operation: Schema.optionalKey<Schema.String>;
+}>], {
+  readonly agentId?: string | undefined;
+  readonly threadId?: string | undefined;
+  readonly runId?: string | undefined;
+  readonly submissionId?: string | undefined;
+  readonly attemptId?: string | undefined;
+  readonly turnId?: string | undefined;
+  readonly toolCallId?: string | undefined;
+  readonly toolName?: string | undefined;
+  readonly callId?: string | undefined;
+  readonly check?: string | undefined;
+  readonly operation?: string | undefined;
+}>;
+type Context$1 = typeof Context$1.Type;
+type CauseReason = {
+  readonly _tag: "Fail";
+  readonly error: Diagnostic;
+} | {
+  readonly _tag: "Die";
+  readonly defect: Diagnostic;
+} | {
+  readonly _tag: "Interrupt";
+  readonly fiberId?: number;
+};
+/** A private diagnostic projection, not a JavaScript error reconstruction or model response. */
+type Diagnostic = {
+  readonly _tag: "Error";
+  readonly errorTag?: string;
+  readonly name?: string;
+  readonly message?: string;
+  readonly stack?: string;
+  readonly reason?: Diagnostic;
+  readonly code?: string | number;
+  readonly cause?: Diagnostic;
+  readonly errors?: ReadonlyArray<Diagnostic>;
+  readonly context?: Context$1;
+  readonly omittedFields?: ReadonlyArray<string>;
+  readonly truncated?: true;
+} | {
+  readonly _tag: "Cause";
+  readonly reasons: ReadonlyArray<CauseReason>;
+  readonly truncated?: true;
+} | {
+  readonly _tag: "Value";
+  readonly value: string | number | boolean | null;
+} | {
+  readonly _tag: "Omitted";
+  readonly reason: "redacted" | "cycle" | "limit" | "unsupported";
+};
+/** Structured, allowlisted Error fields and ordered Effect Fail/Die/Interrupt reasons. */
+declare const Diagnostic: Schema.Codec<Diagnostic>;
+/** Remove common credential forms; hosts must keep arbitrary private payloads out of error text. */
+declare const redactText: (text: string) => string;
+/**
+ * Capture only diagnostic fields. Local values are never mutated. Cycles and exhausted limits
+ * are explicit, not silently dropped; capture visits at most 1,024 nodes, with 56 JSON levels
+ * and 128 KiB text. Inner causes have priority over outer stacks when the text budget is exhausted.
+ * Text remains operator-private. No generic serializer can identify secrets embedded in arbitrary
+ * prose: application error messages must exclude payloads, and hosts may supply stricter redaction.
+ */
+declare const capture: (value: unknown, options?: {
+  readonly redactText?: (text: string) => string;
+}) => Diagnostic;
+/** Bound and redact a diagnostic copy; canonical identities stay in their owning records. */
+declare const captureContext: (context: Context$1) => Context$1;
+/**
+ * Preserve the original value in-process; across JSON retain its structured diagnostic projection.
+ * Decoding returns Diagnostic data, never claims to reconstruct an application error class.
+ */
+declare const Value: Schema.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>;
+/** Original local Effect Cause; its JSON codec preserves ordered typed, defect and interrupt reasons. */
+declare const Cause$1: Schema.decodeTo<Schema.declare<Cause.Cause<unknown>, Cause.Cause<unknown>>, Schema.Cause<Schema.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>, Schema.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>>, never, never>;
+/** Safe summary plus optional operator-private causal evidence retained at a terminal boundary. */
+declare const Failure: Schema.declareConstructor<{
+  readonly errorTag: string;
+  readonly message: string;
+  readonly diagnostic?: Diagnostic | undefined;
+  readonly context?: {
+    readonly agentId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly submissionId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly turnId?: string | undefined;
+    readonly toolCallId?: string | undefined;
+    readonly toolName?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly check?: string | undefined;
+    readonly operation?: string | undefined;
+  } | undefined;
+}, {
+  readonly errorTag: string;
+  readonly message: string;
+  readonly diagnostic?: Diagnostic | undefined;
+  readonly context?: {
+    readonly agentId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly submissionId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly turnId?: string | undefined;
+    readonly toolCallId?: string | undefined;
+    readonly toolName?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly check?: string | undefined;
+    readonly operation?: string | undefined;
+  } | undefined;
+}, readonly [Schema.Struct<{
+  readonly errorTag: Schema.NonEmptyString;
+  readonly message: Schema.String;
+  readonly diagnostic: Schema.optionalKey<Schema.Codec<Diagnostic, Diagnostic, never, never>>;
+  readonly context: Schema.optionalKey<Schema.declareConstructor<{
+    readonly agentId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly submissionId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly turnId?: string | undefined;
+    readonly toolCallId?: string | undefined;
+    readonly toolName?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly check?: string | undefined;
+    readonly operation?: string | undefined;
+  }, {
+    readonly agentId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly submissionId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly turnId?: string | undefined;
+    readonly toolCallId?: string | undefined;
+    readonly toolName?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly check?: string | undefined;
+    readonly operation?: string | undefined;
+  }, readonly [Schema.Struct<{
+    readonly agentId: Schema.optionalKey<Schema.String>;
+    readonly threadId: Schema.optionalKey<Schema.String>;
+    readonly runId: Schema.optionalKey<Schema.String>;
+    readonly submissionId: Schema.optionalKey<Schema.String>;
+    readonly attemptId: Schema.optionalKey<Schema.String>;
+    readonly turnId: Schema.optionalKey<Schema.String>;
+    readonly toolCallId: Schema.optionalKey<Schema.String>;
+    readonly toolName: Schema.optionalKey<Schema.String>;
+    readonly callId: Schema.optionalKey<Schema.String>;
+    readonly check: Schema.optionalKey<Schema.String>;
+    readonly operation: Schema.optionalKey<Schema.String>;
+  }>], {
+    readonly agentId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly submissionId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly turnId?: string | undefined;
+    readonly toolCallId?: string | undefined;
+    readonly toolName?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly check?: string | undefined;
+    readonly operation?: string | undefined;
+  }>>;
+}>], {
+  readonly errorTag: string;
+  readonly message: string;
+  readonly diagnostic?: Diagnostic | undefined;
+  readonly context?: {
+    readonly agentId?: string | undefined;
+    readonly threadId?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly submissionId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly turnId?: string | undefined;
+    readonly toolCallId?: string | undefined;
+    readonly toolName?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly check?: string | undefined;
+    readonly operation?: string | undefined;
+  } | undefined;
+}>;
+type Failure = typeof Failure.Type;
+//#endregion
+export { FailureDiagnostic_d_exports as a, captureContext as c, Failure as i, redactText as l, Context$1 as n, Value as o, Diagnostic as r, capture as s, Cause$1 as t };
+//# sourceMappingURL=FailureDiagnostic-CaAkzGHL.d.mts.map

package/dist/Identifiers-CN2s30fF.d.mts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+declare namespace Identifiers_d_exports {
+  export { AgentId, AttemptId, DelegationId, EventOffset, ReceiptId, RunId, SettlementId, SubmissionId, ThreadId, ToolCallId, TurnId };
+}
+/** Stable identity of an agent definition, distinct from a display name. */
+declare const AgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+type AgentId = typeof AgentId.Type;
+/** Identity shared by runs that participate in one thread history. */
+declare const ThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+type ThreadId = typeof ThreadId.Type;
+/** Identity of one accepted input submission. */
+declare const SubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+type SubmissionId = typeof SubmissionId.Type;
+/** Durable identity returned once ledger admission and Thread readiness are committed. */
+declare const ReceiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+type ReceiptId = typeof ReceiptId.Type;
+/** Identity of the single durable terminal outcome owed to one accepted Submission. */
+declare const SettlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+type SettlementId = typeof SettlementId.Type;
+/** Identity of one execution ownership period for accepted work. */
+declare const AttemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+type AttemptId = typeof AttemptId.Type;
+/** Identity of one logical agent run. */
+declare const RunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+type RunId = typeof RunId.Type;
+/** Identity of one model turn within a run. */
+declare const TurnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+type TurnId = typeof TurnId.Type;
+/** Identity used to correlate a Tool Call with progress and its terminal outcome. */
+declare const ToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+type ToolCallId = typeof ToolCallId.Type;
+/** Stable identity of one configured Subagent capability. */
+declare const DelegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+type DelegationId = typeof DelegationId.Type;
+/** Opaque position in a semantic event sequence. */
+declare const EventOffset: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/EventOffset">;
+type EventOffset = typeof EventOffset.Type;
+//#endregion
+export { Identifiers_d_exports as a, SettlementId as c, ToolCallId as d, TurnId as f, EventOffset as i, SubmissionId as l, AttemptId as n, ReceiptId as o, DelegationId as r, RunId as s, AgentId as t, ThreadId as u };
+//# sourceMappingURL=Identifiers-CN2s30fF.d.mts.map

package/dist/InMemory.d.mts

@@ -0,0 +1,24 @@
+import { t as Store } from "./Thread-DOBQ0QUY.mjs";
+import { SubagentReservations } from "./capabilities/SubagentReservations.mjs";
+import { t as ThreadHistory } from "./ThreadHistory-tS1KwxHR.mjs";
+import { Layer } from "effect";
+declare namespace InMemory_d_exports {
+  export { layer };
+}
+/**
+ * Run agents and attached subagents with in-memory conversation history.
+ * Provide once around the parent program and all child handler Layers so siblings
+ * share history and one reservation ledger. Reuse a Thread ID to continue a conversation.
+ * Conversations can span any number of Runs within the store's capacity limits.
+ * Each independent Layer build owns fresh state; state is released when its Scope closes.
+ * Process loss loses history and active execution; this Layer provides no crash recovery.
+ *
+ * Models, tool handlers, and provider clients remain application-supplied. Default
+ * IDs need no Layer; enclosing ID and context-preparation overrides are preserved.
+ * For storage-backed history, provide PersistentHistory.layer and a shared
+ * SubagentReservationsMemoryLive instead. Durable hosts own their own assembly.
+ */
+export declare const layer: Layer.Layer<Store | SubagentReservations | ThreadHistory, never, never>;
+//#endregion
+export { InMemory_d_exports as t };
+//# sourceMappingURL=InMemory.d.mts.map

package/dist/InMemory.mjs

@@ -0,0 +1,24 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { layer as layer$1 } from "./engine/ThreadHistory.mjs";
+import { SubagentReservationsMemoryLive } from "./capabilities/SubagentReservations.mjs";
+import { Layer } from "effect";
+//#region src/InMemory.ts
+var InMemory_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+/**
+* Run agents and attached subagents with in-memory conversation history.
+* Provide once around the parent program and all child handler Layers so siblings
+* share history and one reservation ledger. Reuse a Thread ID to continue a conversation.
+* Conversations can span any number of Runs within the store's capacity limits.
+* Each independent Layer build owns fresh state; state is released when its Scope closes.
+* Process loss loses history and active execution; this Layer provides no crash recovery.
+*
+* Models, tool handlers, and provider clients remain application-supplied. Default
+* IDs need no Layer; enclosing ID and context-preparation overrides are preserved.
+* For storage-backed history, provide PersistentHistory.layer and a shared
+* SubagentReservationsMemoryLive instead. Durable hosts own their own assembly.
+*/
+const layer = Layer.merge(layer$1, SubagentReservationsMemoryLive);
+//#endregion
+export { layer, InMemory_exports as t };
+
+//# sourceMappingURL=InMemory.mjs.map

package/dist/InMemory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemory.mjs","names":["historyLayer"],"sources":["../src/InMemory.ts"],"sourcesContent":["import { Layer } from \"effect\";\n\nimport { SubagentReservationsMemoryLive } from \"./capabilities/SubagentReservations.ts\";\nimport { layer as historyLayer } from \"./engine/ThreadHistory.ts\";\n\n/**\n * Run agents and attached subagents with in-memory conversation history.\n * Provide once around the parent program and all child handler Layers so siblings\n * share history and one reservation ledger. Reuse a Thread ID to continue a conversation.\n * Conversations can span any number of Runs within the store's capacity limits.\n * Each independent Layer build owns fresh state; state is released when its Scope closes.\n * Process loss loses history and active execution; this Layer provides no crash recovery.\n *\n * Models, tool handlers, and provider clients remain application-supplied. Default\n * IDs need no Layer; enclosing ID and context-preparation overrides are preserved.\n * For storage-backed history, provide PersistentHistory.layer and a shared\n * SubagentReservationsMemoryLive instead. Durable hosts own their own assembly.\n */\nexport const layer = Layer.merge(historyLayer, SubagentReservationsMemoryLive);\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,MAAa,QAAQ,MAAM,MAAMA,SAAc,8BAA8B"}

package/dist/MemoryNamespace-BbRW5p71.d.mts

@@ -0,0 +1,36 @@
+import { Effect, Schema } from "effect";
+declare namespace MemoryNamespace_d_exports {
+  export { Any, MemoryNamespaceAddress, MemoryNamespaceError, Value, define, equals };
+}
+declare const MemoryNamespaceError_base: Schema.Class<MemoryNamespaceError, Schema.TaggedStruct<"MemoryNamespaceError", {
+  readonly reason: Schema.Literals<readonly ["invalid-identity", "invalid-address", "wrong-definition", "unsupported-format"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class MemoryNamespaceError extends MemoryNamespaceError_base {}
+declare const MemoryNamespaceAddress: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+/** Application-defined identity. No membership or authorization policy is implied. */
+/** Heterogeneous adapter representation. Restore through a definition before typed use. */
+declare const Any: Schema.Struct<{
+  readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+}>;
+type Any = typeof Any.Type;
+interface Value<Name extends string, Version extends number, Identity> extends Any {
+  readonly name: Name;
+  readonly version: Version;
+  readonly identity: Identity;
+  readonly _type: (value: readonly [Name, Version, Identity]) => readonly [Name, Version, Identity];
+}
+declare const equals: (left: Any, right: Any) => boolean;
+declare const define: <const Name extends string, const Version extends number, Identity, Encoded extends Schema.Json>(options: {
+  readonly name: Name;
+  readonly version: Version;
+  readonly identity: Schema.Codec<Identity, Encoded, never, never>;
+}) => {
+  name: Name;
+  version: Version;
+  make: (identity: Identity) => Value<Name, Version, Identity>;
+  decode: (input: unknown) => Effect.Effect<Readonly<Value<Name, Version, Identity>>, MemoryNamespaceError, never>;
+  restore: (input: unknown) => Effect.Effect<Readonly<Value<Name, Version, Identity>>, MemoryNamespaceError, never>;
+};
+//#endregion
+export { Value as a, MemoryNamespace_d_exports as i, MemoryNamespaceAddress as n, define as o, MemoryNamespaceError as r, equals as s, Any as t };
+//# sourceMappingURL=MemoryNamespace-BbRW5p71.d.mts.map

package/dist/MemoryReference-B8Q3UJoJ.d.mts

@@ -0,0 +1,79 @@
+import { Schema } from "effect";
+declare namespace MemoryReference_d_exports {
+  export { MemoryAttribution, MemoryContent, MemoryLookup, MemoryMetadata, MemoryPassage, MemoryRecallError, MemoryRecallLimits, MemorySourceReference };
+}
+/** Consumer-defined JSON metadata, bounded independently of readable content. */
+declare const MemoryMetadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+declare const MemorySourceReference_base: Schema.Class<MemorySourceReference, Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly locator: Schema.NonEmptyString;
+  readonly revision: Schema.NullOr<Schema.NonEmptyString>;
+}>, {}>;
+/** Identity in the consumer's authoritative source. `null` means revision is unknown. */
+declare class MemorySourceReference extends MemorySourceReference_base {}
+declare const MemoryAttribution_base: Schema.Class<MemoryAttribution, Schema.Struct<{
+  readonly originId: Schema.NonEmptyString;
+  readonly speaker: Schema.NonEmptyString;
+  readonly observers: Schema.$Array<Schema.NonEmptyString>;
+  readonly locator: Schema.NonEmptyString;
+  readonly activityAt: Schema.NullOr<Schema.Number>;
+  readonly interpretation: Schema.NonEmptyString;
+}>, {}>;
+/**
+ * Evidence of who said something, where, when, and who observed it. Interpretation is
+ * consumer-defined, for example "proposal" or "inference". Repeated references retain
+ * the same originId; they are not independent corroboration. Unknown activity time is null.
+ */
+declare class MemoryAttribution extends MemoryAttribution_base {}
+declare const MemoryContent_base: Schema.Class<MemoryContent, Schema.Struct<{
+  readonly text: Schema.NonEmptyString;
+  readonly attributions: Schema.$Array<typeof MemoryAttribution>;
+  readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly recordedAt: Schema.Number;
+  readonly extractedAt: Schema.optionalKey<Schema.Number>;
+}>, {}>;
+/**
+ * Readable authoritative content, independent of any index, model, or fixed memory taxonomy.
+ * Recording/extraction time never substitutes for the original source activity time.
+ */
+declare class MemoryContent extends MemoryContent_base {}
+declare const MemoryPassage_base: Schema.Class<MemoryPassage, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  /** Host-bound authority for composition, not model-visible metadata or an access grant. */
+  readonly authority: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly source: typeof MemorySourceReference;
+  readonly passageId: Schema.NonEmptyString;
+  readonly content: typeof MemoryContent;
+}>, {}>;
+/** A bounded passage supplied directly by a document reader or external retriever. */
+declare class MemoryPassage extends MemoryPassage_base {}
+/** No-match, unavailable, and insufficient freshness are distinct consumer-visible outcomes. */
+declare const MemoryLookup: Schema.Union<readonly [Schema.TaggedStruct<"Found", {
+  readonly passages: Schema.$Array<typeof MemoryPassage>;
+}>, Schema.TaggedStruct<"NoMatch", {}>, Schema.TaggedStruct<"Unavailable", {
+  readonly message: Schema.String;
+}>, Schema.TaggedStruct<"InsufficientFreshness", {
+  readonly message: Schema.String;
+}>]>;
+type MemoryLookup = typeof MemoryLookup.Type;
+declare const MemoryRecallLimits_base: Schema.Class<MemoryRecallLimits, Schema.Struct<{
+  readonly maxSources: Schema.Int;
+  readonly maxItems: Schema.Int;
+  readonly maxBytes: Schema.Int;
+  readonly maxTokens: Schema.Int;
+  /** Aggregate UTF-8 JSON passage input, including omitted/duplicate candidates. Defaults to 16 MiB. */
+  readonly maxInputBytes: Schema.optionalKey<Schema.Int>;
+  readonly timeoutMillis: Schema.Int;
+}>, {}>;
+/** Output bounds cover the complete rendered reference text, including citations and provenance. */
+declare class MemoryRecallLimits extends MemoryRecallLimits_base {}
+declare const MemoryRecallError_base: Schema.Class<MemoryRecallError, Schema.TaggedStruct<"MemoryRecallError", {
+  readonly reason: Schema.Literals<readonly ["invalid-input", "unavailable", "insufficient-freshness", "budget", "timeout"]>;
+  readonly sourceId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A recall contract or essential-source requirement could not be satisfied. */
+declare class MemoryRecallError extends MemoryRecallError_base {}
+//#endregion
+export { MemoryPassage as a, MemoryReference_d_exports as c, MemoryMetadata as i, MemorySourceReference as l, MemoryContent as n, MemoryRecallError as o, MemoryLookup as r, MemoryRecallLimits as s, MemoryAttribution as t };
+//# sourceMappingURL=MemoryReference-B8Q3UJoJ.d.mts.map

package/dist/Messaging-Dkg87ebg.d.mts

@@ -0,0 +1,221 @@
+import { s as SubagentExecutionFailure } from "./SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { Schema } from "effect";
+//#region src/core/internal/message-status.d.ts
+/** 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;
+/**
+ * Source-owned delivery evidence. Pending confirms retention only; accepted supplies the
+ * destination Receipt, and processed supplies its canonical settlement. Neither retention nor
+ * acceptance proves execution. Refused is a definite rejection; parked stops automatic retry
+ * while retaining the same identity and any acceptance evidence. Inspect instead of resending.
+ */
+declare const MessageStatus: Schema.Union<readonly [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.Literal<"pending">;
+  readonly receipt: Schema.Null;
+  readonly settlement: Schema.Null;
+  readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+}>, 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.Literal<"accepted">;
+  readonly receipt: typeof Receipt;
+  readonly settlement: Schema.Null;
+  readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+}>, 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.Literal<"processed">;
+  readonly receipt: typeof Receipt;
+  readonly settlement: Schema.Struct<{
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  }>;
+  readonly reason: Schema.Null;
+}>, 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.Literal<"refused">;
+  readonly receipt: Schema.Null;
+  readonly settlement: Schema.Null;
+  readonly reason: Schema.NonEmptyString;
+}>, 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.Literal<"parked">;
+  readonly receipt: Schema.NullOr<typeof Receipt>;
+  readonly settlement: Schema.Null;
+  readonly reason: Schema.NonEmptyString;
+}>]>;
+type MessageStatus = typeof MessageStatus.Type;
+//#endregion
+//#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;
+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;
+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;
+//#endregion
+export { MessageAdmission as a, MessageRef as c, MessageAddress as i, MessageStatus as l, InboxPage as n, MessagingError as o, InputMessage as r, PeerName as s, InboxEntry as t };
+//# sourceMappingURL=Messaging-Dkg87ebg.d.mts.map