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

package/dist/DurableFailpoint-Oinuuedm.d.mts

@@ -0,0 +1,41 @@
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace DurableFailpoint_d_exports {
+  export { DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableRuntimeFailpointLocation };
+}
+/**
+ * Coordinator-owned failpoint locations (plan §Failpoints). Locations normally sit immediately
+ * AFTER one durable mutation of the six-step coordinator flow, so a fault injected there
+ * simulates a crash between two durable steps; the matching BEFORE boundary of each mutation is
+ * owned by the storage adapters (`ledger:*:before`, `append:before`, ...), giving every durable
+ * mutation a failpoint on both sides (change discipline). Run-start append also exposes its
+ * BEFORE boundary here to distinguish a fresh clock from a committed clock in crash tests.
+ *
+ * The `subagent:*` family covers every durable mutation of the S2 establishment/join protocol
+ * including reservation, request append, child admission, child readiness,
+ * start-link append, sibling per-call settles at the suspension seam, the `waitingForChild`
+ * suspension, child abort propagation, the atomic join batch, and both reservation-release
+ * transitions.
+ */
+declare const DurableRuntimeFailpointLocation: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+type DurableRuntimeFailpointLocation = typeof DurableRuntimeFailpointLocation.Type;
+declare const DurableRuntimeFailpointError_base: Schema.Class<DurableRuntimeFailpointError, Schema.TaggedStruct<"DurableRuntimeFailpointError", {
+  readonly location: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Injected coordinator fault. Reaching the caller means the preceding durable step committed. */
+declare class DurableRuntimeFailpointError extends DurableRuntimeFailpointError_base {}
+type DurableRuntimeFailpointHandler = (location: DurableRuntimeFailpointLocation) => Effect.Effect<void, DurableRuntimeFailpointError>;
+declare const DurableRuntimeFailpoint_base: Context.ServiceClass<DurableRuntimeFailpoint, "@effect-agent/thread/DurableRuntimeFailpoint", {
+  readonly hit: DurableRuntimeFailpointHandler;
+}>;
+/**
+ * Explicit fault-injection authority used at durable coordinator step boundaries. The process
+ * crash harness (WP5) maps a hit to `process.exit`; in-process tests fail the step with the
+ * typed `DurableRuntimeFailpointError` instead.
+ */
+declare class DurableRuntimeFailpoint extends DurableRuntimeFailpoint_base {
+  /** Production default: no fault injection. */
+  static readonly layer: Layer.Layer<DurableRuntimeFailpoint, never, never>;
+}
+//#endregion
+export { DurableRuntimeFailpointLocation as a, DurableRuntimeFailpointHandler as i, DurableRuntimeFailpoint as n, DurableRuntimeFailpointError as r, DurableFailpoint_d_exports as t };
+//# sourceMappingURL=DurableFailpoint-Oinuuedm.d.mts.map

package/dist/DurableStep-Cry_iol4.d.mts

@@ -0,0 +1,103 @@
+import { d as ToolCallId } from "./Identifiers-CN2s30fF.mjs";
+import { Tool } from "effect/unstable/ai";
+import { Context, Effect, Option, Schema } from "effect";
+declare namespace DurableStep_d_exports {
+  export { DurableStep, DurableStepError, DurableStepService, PersistedStepResult, RunStepHook, RunStepKey, ToolExecutionClass, ToolExecutionClassValue, getToolExecutionClass };
+}
+/**
+ * Declared external execution class of one Tool, used by the durable runtime
+ * to decide which Tool Calls need the prepared/settled uncertainty protocol:
+ *
+ * - `"readonly"`: the handler performs no external mutation. A crash between
+ *   start and settlement is a free re-run; no prepared record is written.
+ * - `"idempotent"`: the handler declares an external idempotency contract
+ *   (it owns key derivation). Prepared/settled records are written and
+ *   recovery may re-execute without reconciliation proof.
+ * - `"uncertain"`: no external contract is declared. Prepared/settled records
+ *   are written and recovery must reconcile or record an Unknown Outcome.
+ */
+type ToolExecutionClassValue = "readonly" | "idempotent" | "uncertain";
+/**
+ * Effect AI Tool annotation key declaring a Tool's execution class, applied
+ * with `Tool.annotate(ToolExecutionClass, "...")`.
+ *
+ * Unannotated Tools default to `"uncertain"`: security and durability
+ * decisions are fail-closed, so the framework never infers a safer class
+ * from a Tool's shape.
+ */
+declare const ToolExecutionClass: Context.Reference<ToolExecutionClassValue>;
+/** Read a Tool's declared execution class, falling back to the fail-closed `"uncertain"` default. */
+declare const getToolExecutionClass: (tool: Tool.Any) => ToolExecutionClassValue;
+/** Stable identity of one Step within one Tool Call: `(toolCallId, stepName)`. */
+interface RunStepKey {
+  readonly toolCallId: ToolCallId;
+  readonly stepName: string;
+}
+/** A previously committed Step result in its canonical encoded form. */
+interface PersistedStepResult {
+  readonly encodedOutput: unknown;
+}
+/**
+ * Dependency-neutral Step persistence seam implemented by a durable
+ * coordinator and consumed by the engine-provided `DurableStep` service.
+ *
+ * `lookup` returns the committed result for a Step identity when one exists;
+ * `commit` durably records one successful encoded output. Only success is
+ * ever committed — recording failures would replay a transient failure
+ * forever. Both operations are keyed by the deterministic `RunStepKey`, so
+ * replays and racing writers dedupe on record identity in the adapter.
+ */
+interface RunStepHook<Error = never, Requirements = never> {
+  readonly lookup: (key: RunStepKey) => Effect.Effect<Option.Option<PersistedStepResult>, Error, Requirements>;
+  readonly commit: (key: RunStepKey, encodedOutput: unknown) => Effect.Effect<void, Error, Requirements>;
+}
+declare const DurableStepError_base: Schema.Class<DurableStepError, Schema.TaggedStruct<"DurableStepError", {
+  readonly stepName: Schema.String;
+  readonly reason: Schema.Literals<readonly ["duplicate-step-name", "lookup-failed", "recorded-result-invalid", "output-encoding-failed", "commit-failed", "no-active-tool-call"]>;
+  readonly message: Schema.String;
+  readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">>;
+  /** Diagnostic cause for the live Effect only; Run events retain the fixed public message. */
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed failure of one `DurableStep.do` call.
+ *
+ * `duplicate-step-name` is an identity conflict: Step names must be
+ * deterministic and unique within one Tool Call, and reuse would silently
+ * replay another Step's recorded result. `recorded-result-invalid` is the
+ * replay-with-different-content conflict: a committed result that no longer
+ * decodes through the declared output Schema is never silently accepted.
+ */
+declare class DurableStepError extends DurableStepError_base {}
+/**
+ * Service value provided locally by the engine to each Tool Call's handler.
+ *
+ * `do` runs one named Step with exactly-once-recorded, at-least-once-executed
+ * semantics: a committed result decodes through `output` and returns without
+ * executing the body; otherwise the body runs (a crash mid-body re-executes
+ * on the next Attempt), the success is encoded through `output`, and only
+ * then committed. The Schema argument is the canonical codec for the recorded
+ * result, not decoration. A Step never makes a non-idempotent external API
+ * exactly-once — the body must use the external system's idempotency key,
+ * reconciliation API, or compensating workflow.
+ */
+interface DurableStepService {
+  readonly do: <Output extends Schema.Top, BodyError, BodyServices>(name: string, output: Output, execute: Effect.Effect<Output["Type"], BodyError, BodyServices>) => Effect.Effect<Output["Type"], DurableStepError | BodyError, BodyServices | Output["DecodingServices"] | Output["EncodingServices"]>;
+}
+declare const DurableStep_base: Context.ServiceClass<DurableStep, "@effect-agent/engine/DurableStep", DurableStepService>;
+/**
+ * Engine-owned Durable Step seam.
+ *
+ * Declaring this service in `Tool.make({ dependencies: [DurableStep] })` is
+ * what makes a Tool a Durable Tool: its handler divides external effects into
+ * named Steps and may be re-entered after interruption. The engine provides
+ * the service locally to every Tool Call, bound to that call's identity; it
+ * is never satisfied from an application Layer and is excluded from the
+ * runtime's public requirements. Without a durable runtime the engine
+ * provides an ephemeral pass-through that executes each Step once and
+ * records nothing — the durable claim attaches to the runtime, not the Tool.
+ */
+declare class DurableStep extends DurableStep_base {}
+//#endregion
+export { PersistedStepResult as a, ToolExecutionClass as c, DurableStep_d_exports as i, ToolExecutionClassValue as l, DurableStepError as n, RunStepHook as o, DurableStepService as r, RunStepKey as s, DurableStep as t, getToolExecutionClass as u };
+//# sourceMappingURL=DurableStep-Cry_iol4.d.mts.map

package/dist/Ephemeral.d.mts

@@ -0,0 +1,22 @@
+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 Ephemeral_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.
+ * Each independent Layer build owns fresh state; state is released when its Scope closes.
+ *
+ * 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.
+ */
+declare const layer: Layer.Layer<Store | SubagentReservations | ThreadHistory, never, never>;
+//#endregion
+export { layer, Ephemeral_d_exports as t };
+//# sourceMappingURL=Ephemeral.d.mts.map

package/dist/Ephemeral.mjs

@@ -0,0 +1,22 @@
+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/Ephemeral.ts
+var Ephemeral_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.
+* Each independent Layer build owns fresh state; state is released when its Scope closes.
+*
+* 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, Ephemeral_exports as t };
+
+//# sourceMappingURL=Ephemeral.mjs.map

package/dist/Ephemeral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ephemeral.mjs","names":["historyLayer"],"sources":["../src/Ephemeral.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 * Each independent Layer build owns fresh state; state is released when its Scope closes.\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":";;;;;;;;;;;;;;;;;AAgBA,MAAa,QAAQ,MAAM,MAAMA,SAAc,8BAA8B"}

package/dist/EventSource-OqS_P9ug.d.mts

@@ -0,0 +1,51 @@
+import { O as PersistedJson } from "./Records-BAGkekt8.mjs";
+import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, t as AcceptedEvent } from "./Subscription-BEP8oQO5.mjs";
+import { Context, Effect, Schema, Scope } from "effect";
+declare namespace EventSource_d_exports {
+  export { EventSource, EventSources, NormalizedEvent, makeEventSource };
+}
+interface NormalizedEvent {
+  readonly eventId: string;
+  readonly occurredAtMillis?: number;
+  readonly matchingKey: string;
+  readonly payload: PersistedJson;
+}
+/** Runtime-only versioned behavior. Never persist this object or silently replace its version. */
+interface EventSource {
+  readonly source: EventSourceVersion;
+  readonly continuity: string;
+  readonly parameters: (value: unknown) => Effect.Effect<{
+    readonly parameters: PersistedJson;
+    readonly matchingKey: string;
+  }, SubscriptionSourceError>;
+  readonly normalize: (value: unknown) => Effect.Effect<NormalizedEvent, SubscriptionSourceError>;
+  readonly matches: (event: AcceptedEvent, subscription: SubscriptionRecord) => Effect.Effect<boolean, SubscriptionSourceError>;
+  readonly reconcile?: (subscription: SubscriptionRecord) => Effect.Effect<NormalizedEvent | null, SubscriptionSourceError>;
+}
+declare const EventSources_base: Context.ServiceClass<EventSources, "@effect-agent/thread/EventSources", {
+  readonly sources: ReadonlyArray<EventSource>;
+}>;
+declare class EventSources extends EventSources_base {}
+/**
+ * Capture the source's explicit Effect dependencies at host assembly. Matching and key functions
+ * must be pure and bounded under this exact semantic version.
+ * The returned source accepts Schema-encoded values at intake and management boundaries.
+ * Each operation owns a fresh Scope for its callbacks and codecs; captured host services
+ * retain their host lifetime. Operation resources finalize on success, failure, or interruption.
+ */
+declare const makeEventSource: <Event extends Schema.Top, Parameters extends Schema.Top, R = never>(options: {
+  readonly source: EventSourceVersion;
+  readonly continuity: string;
+  readonly event: Event;
+  readonly parameters: Parameters;
+  readonly identity: (event: Event["Type"]) => string;
+  /** Authenticated source time, stable across delivery retries; required for bounded retention. */
+  readonly occurredAtMillis?: (event: Event["Type"]) => number | undefined;
+  readonly eventKey: (event: Event["Type"]) => string;
+  readonly parameterKey: (parameters: Parameters["Type"]) => string;
+  readonly matches: (event: Event["Type"], parameters: Parameters["Type"]) => boolean;
+  readonly reconcile?: (parameters: Parameters["Type"]) => Effect.Effect<Event["Type"] | null, SubscriptionSourceError, R>;
+}) => Effect.Effect<EventSource, never, Exclude<R, Scope.Scope> | Exclude<Event["DecodingServices"], Scope.Scope> | Exclude<Event["EncodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope> | Exclude<Parameters["EncodingServices"], Scope.Scope>>;
+//#endregion
+export { makeEventSource as a, NormalizedEvent as i, EventSource_d_exports as n, EventSources as r, EventSource as t };
+//# sourceMappingURL=EventSource-OqS_P9ug.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/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