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

package/dist/capabilities/SemanticMemory.d.mts

@@ -0,0 +1,431 @@
+import { a as MemoryPassage } from "../MemoryReference-B8Q3UJoJ.mjs";
+import { t as Any } from "../MemoryNamespace-BbRW5p71.mjs";
+import { MemoryKey, MemoryReader, MemoryStorageError } from "../core/MemoryStore.mjs";
+import { MemoryAccess } from "../core/MemoryRevalidation.mjs";
+import { MemoryIndexError, SemanticMemoryIndex } from "../core/SemanticMemoryIndex.mjs";
+import { SemanticMemoryError } from "../core/SemanticMemoryRevalidation.mjs";
+import { EmbeddingModel } from "effect/unstable/ai";
+import { Crypto, Effect, Schema } from "effect";
+declare namespace SemanticMemory_d_exports {
+  export { SemanticIndexLimits, SemanticIndexResult, SemanticQueryLimits, SemanticQueryResult, indexMemorySource, querySemanticMemory };
+}
+declare const SemanticIndexLimits_base: Schema.Class<SemanticIndexLimits, Schema.Struct<{
+  readonly maxSourceBytes: Schema.Int;
+  readonly maxChunks: Schema.Int;
+  readonly timeoutMillis: Schema.Int;
+}>, {}>;
+declare class SemanticIndexLimits extends SemanticIndexLimits_base {}
+declare const SemanticQueryLimits_base: Schema.Class<SemanticQueryLimits, Schema.Struct<{
+  readonly maxQueryBytes: Schema.Int;
+  readonly maxCandidates: Schema.Int;
+  readonly maxScannedChunks: Schema.Int;
+  /** Aggregate UTF-8 JSON of current authorized candidate sources; defaults to 16 MiB. */
+  readonly maxSourceBytes: Schema.optionalKey<Schema.Int>;
+  /** Aggregate UTF-8 JSON passage bytes, including repeated provenance; defaults to 16 MiB. */
+  readonly maxOutputBytes: Schema.optionalKey<Schema.Int>;
+  readonly minScore: Schema.Finite;
+  readonly timeoutMillis: Schema.Int;
+}>, {}>;
+declare class SemanticQueryLimits extends SemanticQueryLimits_base {}
+declare const SemanticIndexResultWire_base: Schema.Class<SemanticIndexResultWire, Schema.Struct<{
+  readonly key: {
+    new (props: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions | undefined): {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    pipe<A>(this: A): A;
+    pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+    pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+    pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+    pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+    pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    readonly Rebuild: Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    readonly "~effect/Schema/Schema": "~effect/Schema/Schema";
+    readonly ast: import("effect/SchemaAST").Declaration;
+    readonly "~type.parameters": readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>];
+    readonly "~type.constructor.default": "no-default";
+    readonly "~type.mutability": "readonly";
+    readonly "~type.optionality": "required";
+    readonly "~encoded.mutability": "readonly";
+    readonly "~encoded.optionality": "required";
+    annotate(annotations: Schema.Annotations.Bottom<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>]>): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    annotateKey(annotations: Schema.Annotations.Key<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    check(checks_0: import("effect/SchemaAST").Check<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, ...checks: import("effect/SchemaAST").Check<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>[]): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    rebuild(ast: import("effect/SchemaAST").Declaration): Schema.decodeTo<Schema.declareConstructor<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    }, readonly [Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>], {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>, Schema.Struct<{
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }>, never, never>;
+    make(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    makeOption(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): import("effect/Option").Option<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }>;
+    makeEffect(input: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, options?: Schema.MakeOptions): Effect.Effect<{
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    }, import("effect/SchemaIssue").Issue, never>;
+    readonly Type: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly Encoded: {
+      readonly namespace: {
+        readonly address: string;
+      };
+      readonly id: string;
+    };
+    readonly DecodingServices: never;
+    readonly EncodingServices: never;
+    readonly "~type.make.in": {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly "~type.make": {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly Iso: {
+      readonly namespace: {
+        readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+      };
+      readonly id: string;
+    };
+    readonly identifier: string;
+    readonly fields: {
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    };
+    mapFields<To extends Schema.Struct.Fields>(f: (fields: {
+      readonly namespace: Schema.Struct<{
+        readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+      }>;
+      readonly id: Schema.NonEmptyString;
+    }) => To, options?: {
+      readonly unsafePreserveChecks?: boolean | undefined;
+    } | undefined): Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
+    extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
+      <NewFields extends Schema.Struct.Fields>(fields: NewFields, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & NewFields : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof NewFields extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & NewFields : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof NewFields> & NewFields) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof NewFields_1 extends never ? S["fields"] & NewFields_1 : Omit<S["fields"], keyof S["fields"] & keyof NewFields_1> & NewFields_1) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+      <Extension extends Schema.Struct<Schema.Struct.Fields>>(schema: Extension, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & Extension["fields"] : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>]> | undefined): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : Schema.Class<Extended, Schema.Struct<((("id" | "namespace") & keyof Extension["fields"] extends never ? {
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      } & Extension["fields"] : Omit<{
+        readonly namespace: Schema.Struct<{
+          readonly address: Schema.brand<Schema.String, "@effect-agent/core/MemoryNamespaceAddress">;
+        }>;
+        readonly id: Schema.NonEmptyString;
+      }, ("id" | "namespace") & keyof Extension["fields"]> & Extension["fields"]) extends (infer T_1) ? { [K in keyof T_1]: T_1[K]; } : never) extends (infer T) ? { [K in keyof T]: T[K]; } : never>, {
+        readonly namespace: {
+          readonly address: string & import("effect/Brand").Brand<"@effect-agent/core/MemoryNamespaceAddress">;
+        };
+        readonly id: string;
+      } & Brand> & Pick<Static, Exclude<keyof Static, keyof Schema.Class<Extended_1, Schema.Struct<((keyof S["fields"] & keyof Extension_1["fields"] extends never ? S["fields"] & Extension_1["fields"] : Omit<S["fields"], keyof S["fields"] & keyof Extension_1["fields"]> & Extension_1["fields"]) extends (infer T_3) ? { [K in keyof T_3]: T_3[K]; } : never) extends (infer T_2) ? { [K in keyof T_2]: T_2[K]; } : never>, Self & Brand_1>>>;
+    };
+  };
+  readonly status: Schema.Literals<readonly ["Missing", "Withdrawn", "Indexed"]>;
+  readonly embeddedChunks: Schema.Natural;
+  readonly embeddedBytes: Schema.Natural;
+  readonly inputTokens: Schema.NullOr<Schema.Natural>;
+  readonly startedAt: Schema.Finite;
+  readonly finishedAt: Schema.Finite;
+}>, {}>;
+declare class SemanticIndexResultWire extends SemanticIndexResultWire_base {}
+type SemanticIndexResult<Namespace extends Any = Any> = Omit<SemanticIndexResultWire, "key"> & {
+  readonly key: MemoryKey<Namespace>;
+};
+declare const SemanticIndexResult: {
+  Wire: typeof SemanticIndexResultWire;
+  make: <Namespace extends Any>(fields: SemanticIndexResult<Namespace>) => SemanticIndexResult<Namespace>;
+};
+declare const SemanticQueryResult_base: Schema.Class<SemanticQueryResult, Schema.Struct<{
+  readonly lookup: 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;
+  }>]>;
+  readonly scannedChunks: Schema.Natural;
+  readonly staleExcluded: Schema.Natural;
+  readonly unauthorizedExcluded: Schema.Natural;
+  readonly queryBytes: Schema.Natural;
+  readonly inputTokens: Schema.NullOr<Schema.Natural>;
+  readonly startedAt: Schema.Finite;
+  readonly finishedAt: Schema.Finite;
+}>, {}>;
+/** Candidates have already passed current-source checks; compose lookup with Memory.recall. */
+declare class SemanticQueryResult extends SemanticQueryResult_base {}
+/**
+ * Rebuild one selected source through the native Effect EmbeddingModel. The host binds the
+ * index profile to that provider's immutable model revision. A fresh Layer starts empty.
+ * Every invocation rebuilds; the host owns source discovery, scheduling, and freshness policy.
+ *
+ * Chunking and embedding leave the last successful index intact. A final authoritative read
+ * rejects a source changed during embedding, then replace atomically exchanges its chunks.
+ * An independent source can still change between that read and replacement;
+ * querySemanticMemory always revalidates and excludes such stale candidates.
+ * No model or source text is attached to telemetry. Errors retain native provider/index types.
+ */
+declare const indexMemorySource: <Namespace extends Any>(key: MemoryKey<Namespace>, limits: SemanticIndexLimits) => Effect.Effect<SemanticIndexResult<Namespace>, import("effect/unstable/ai/AiError").AiError | MemoryIndexError | MemoryStorageError | SemanticMemoryError, Crypto.Crypto | EmbeddingModel.EmbeddingModel | MemoryReader | SemanticMemoryIndex>;
+/**
+ * Query an optional derivative index, then read each distinct source once. Attribution and
+ * metadata always come from that current source. Revision, generation, namespace, access,
+ * locator, and exact UTF-8 excerpt checks run before returning any passage. Older candidates
+ * are omitted rather than assigning their similarity score to changed text.
+ * Process candidates in source groups, retain only passage excerpts, and restore index rank.
+ * maxSourceBytes bounds aggregate UTF-8 JSON for distinct authorized sources with matching
+ * generation/revision/locator candidates. Its default is 16 MiB; exhaustion returns no partial
+ * result. Reader allocation, decoding, and one source serialization precede this bound.
+ *
+ * Compose result.lookup through Memory.recall to enforce the final rendered item/byte/token
+ * budget and overall deadline. An empty result says nothing about undiscovered sources.
+ * Checks begun before an acknowledged correction/withdrawal may finish with their already
+ * captured source view.
+ */
+declare const querySemanticMemory: (query: string, access: MemoryAccess, limits: SemanticQueryLimits) => Effect.Effect<SemanticQueryResult, import("effect/unstable/ai/AiError").AiError | MemoryIndexError | MemoryStorageError | SemanticMemoryError, EmbeddingModel.EmbeddingModel | MemoryReader | SemanticMemoryIndex>;
+//#endregion
+export { SemanticIndexLimits, SemanticIndexResult, SemanticQueryLimits, SemanticQueryResult, indexMemorySource, querySemanticMemory, SemanticMemory_d_exports as t };
+//# sourceMappingURL=SemanticMemory.d.mts.map