@nimiplatform/sdk 0.5.14

package/dist/runtime/generated/runtime/v1/memory.js

@@ -0,0 +1,3564 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Ack } from "./common.js";
+import { Timestamp } from "../../google/protobuf/timestamp.js";
+import { Struct } from "../../google/protobuf/struct.js";
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryBankScope
+ */
+export var MemoryBankScope;
+(function (MemoryBankScope) {
+    /**
+     * @generated from protobuf enum value: MEMORY_BANK_SCOPE_UNSPECIFIED = 0;
+     */
+    MemoryBankScope[MemoryBankScope["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_BANK_SCOPE_AGENT_CORE = 1;
+     */
+    MemoryBankScope[MemoryBankScope["AGENT_CORE"] = 1] = "AGENT_CORE";
+    /**
+     * @generated from protobuf enum value: MEMORY_BANK_SCOPE_AGENT_DYADIC = 2;
+     */
+    MemoryBankScope[MemoryBankScope["AGENT_DYADIC"] = 2] = "AGENT_DYADIC";
+    /**
+     * @generated from protobuf enum value: MEMORY_BANK_SCOPE_WORLD_SHARED = 3;
+     */
+    MemoryBankScope[MemoryBankScope["WORLD_SHARED"] = 3] = "WORLD_SHARED";
+    /**
+     * @generated from protobuf enum value: MEMORY_BANK_SCOPE_APP_PRIVATE = 4;
+     */
+    MemoryBankScope[MemoryBankScope["APP_PRIVATE"] = 4] = "APP_PRIVATE";
+    /**
+     * @generated from protobuf enum value: MEMORY_BANK_SCOPE_WORKSPACE_PRIVATE = 5;
+     */
+    MemoryBankScope[MemoryBankScope["WORKSPACE_PRIVATE"] = 5] = "WORKSPACE_PRIVATE";
+})(MemoryBankScope || (MemoryBankScope = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryRecordKind
+ */
+export var MemoryRecordKind;
+(function (MemoryRecordKind) {
+    /**
+     * @generated from protobuf enum value: MEMORY_RECORD_KIND_UNSPECIFIED = 0;
+     */
+    MemoryRecordKind[MemoryRecordKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_RECORD_KIND_EPISODIC = 1;
+     */
+    MemoryRecordKind[MemoryRecordKind["EPISODIC"] = 1] = "EPISODIC";
+    /**
+     * @generated from protobuf enum value: MEMORY_RECORD_KIND_SEMANTIC = 2;
+     */
+    MemoryRecordKind[MemoryRecordKind["SEMANTIC"] = 2] = "SEMANTIC";
+    /**
+     * @generated from protobuf enum value: MEMORY_RECORD_KIND_OBSERVATIONAL = 3;
+     */
+    MemoryRecordKind[MemoryRecordKind["OBSERVATIONAL"] = 3] = "OBSERVATIONAL";
+})(MemoryRecordKind || (MemoryRecordKind = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryCanonicalClass
+ */
+export var MemoryCanonicalClass;
+(function (MemoryCanonicalClass) {
+    /**
+     * @generated from protobuf enum value: MEMORY_CANONICAL_CLASS_UNSPECIFIED = 0;
+     */
+    MemoryCanonicalClass[MemoryCanonicalClass["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_CANONICAL_CLASS_NONE = 1;
+     */
+    MemoryCanonicalClass[MemoryCanonicalClass["NONE"] = 1] = "NONE";
+    /**
+     * @generated from protobuf enum value: MEMORY_CANONICAL_CLASS_PUBLIC_SHARED = 2;
+     */
+    MemoryCanonicalClass[MemoryCanonicalClass["PUBLIC_SHARED"] = 2] = "PUBLIC_SHARED";
+    /**
+     * @generated from protobuf enum value: MEMORY_CANONICAL_CLASS_WORLD_SHARED = 3;
+     */
+    MemoryCanonicalClass[MemoryCanonicalClass["WORLD_SHARED"] = 3] = "WORLD_SHARED";
+    /**
+     * @generated from protobuf enum value: MEMORY_CANONICAL_CLASS_DYADIC = 4;
+     */
+    MemoryCanonicalClass[MemoryCanonicalClass["DYADIC"] = 4] = "DYADIC";
+})(MemoryCanonicalClass || (MemoryCanonicalClass = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryDistanceMetric
+ */
+export var MemoryDistanceMetric;
+(function (MemoryDistanceMetric) {
+    /**
+     * @generated from protobuf enum value: MEMORY_DISTANCE_METRIC_UNSPECIFIED = 0;
+     */
+    MemoryDistanceMetric[MemoryDistanceMetric["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_DISTANCE_METRIC_COSINE = 1;
+     */
+    MemoryDistanceMetric[MemoryDistanceMetric["COSINE"] = 1] = "COSINE";
+    /**
+     * @generated from protobuf enum value: MEMORY_DISTANCE_METRIC_EUCLIDEAN = 2;
+     */
+    MemoryDistanceMetric[MemoryDistanceMetric["EUCLIDEAN"] = 2] = "EUCLIDEAN";
+})(MemoryDistanceMetric || (MemoryDistanceMetric = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryMigrationPolicy
+ */
+export var MemoryMigrationPolicy;
+(function (MemoryMigrationPolicy) {
+    /**
+     * @generated from protobuf enum value: MEMORY_MIGRATION_POLICY_UNSPECIFIED = 0;
+     */
+    MemoryMigrationPolicy[MemoryMigrationPolicy["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_MIGRATION_POLICY_REINDEX = 1;
+     */
+    MemoryMigrationPolicy[MemoryMigrationPolicy["REINDEX"] = 1] = "REINDEX";
+    /**
+     * @generated from protobuf enum value: MEMORY_MIGRATION_POLICY_FREEZE = 2;
+     */
+    MemoryMigrationPolicy[MemoryMigrationPolicy["FREEZE"] = 2] = "FREEZE";
+})(MemoryMigrationPolicy || (MemoryMigrationPolicy = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryReplicationOutcome
+ */
+export var MemoryReplicationOutcome;
+(function (MemoryReplicationOutcome) {
+    /**
+     * @generated from protobuf enum value: MEMORY_REPLICATION_OUTCOME_UNSPECIFIED = 0;
+     */
+    MemoryReplicationOutcome[MemoryReplicationOutcome["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_REPLICATION_OUTCOME_PENDING = 1;
+     */
+    MemoryReplicationOutcome[MemoryReplicationOutcome["PENDING"] = 1] = "PENDING";
+    /**
+     * @generated from protobuf enum value: MEMORY_REPLICATION_OUTCOME_SYNCED = 2;
+     */
+    MemoryReplicationOutcome[MemoryReplicationOutcome["SYNCED"] = 2] = "SYNCED";
+    /**
+     * @generated from protobuf enum value: MEMORY_REPLICATION_OUTCOME_CONFLICT = 3;
+     */
+    MemoryReplicationOutcome[MemoryReplicationOutcome["CONFLICT"] = 3] = "CONFLICT";
+    /**
+     * @generated from protobuf enum value: MEMORY_REPLICATION_OUTCOME_INVALIDATED = 4;
+     */
+    MemoryReplicationOutcome[MemoryReplicationOutcome["INVALIDATED"] = 4] = "INVALIDATED";
+})(MemoryReplicationOutcome || (MemoryReplicationOutcome = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.MemoryEventType
+ */
+export var MemoryEventType;
+(function (MemoryEventType) {
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_UNSPECIFIED = 0;
+     */
+    MemoryEventType[MemoryEventType["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_BANK_CREATED = 1;
+     */
+    MemoryEventType[MemoryEventType["BANK_CREATED"] = 1] = "BANK_CREATED";
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_BANK_DELETED = 2;
+     */
+    MemoryEventType[MemoryEventType["BANK_DELETED"] = 2] = "BANK_DELETED";
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_RECORD_RETAINED = 3;
+     */
+    MemoryEventType[MemoryEventType["RECORD_RETAINED"] = 3] = "RECORD_RETAINED";
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_RECORD_DELETED = 4;
+     */
+    MemoryEventType[MemoryEventType["RECORD_DELETED"] = 4] = "RECORD_DELETED";
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_REFLECTION_COMPLETED = 5;
+     */
+    MemoryEventType[MemoryEventType["REFLECTION_COMPLETED"] = 5] = "REFLECTION_COMPLETED";
+    /**
+     * @generated from protobuf enum value: MEMORY_EVENT_TYPE_REPLICATION_UPDATED = 6;
+     */
+    MemoryEventType[MemoryEventType["REPLICATION_UPDATED"] = 6] = "REPLICATION_UPDATED";
+})(MemoryEventType || (MemoryEventType = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryRequestContext$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryRequestContext", [
+            { no: 1, name: "app_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "subject_user_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.appId = "";
+        message.subjectUserId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string app_id */ 1:
+                    message.appId = reader.string();
+                    break;
+                case /* string subject_user_id */ 2:
+                    message.subjectUserId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string app_id = 1; */
+        if (message.appId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.appId);
+        /* string subject_user_id = 2; */
+        if (message.subjectUserId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.subjectUserId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryRequestContext
+ */
+export const MemoryRequestContext = new MemoryRequestContext$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AgentCoreBankOwner$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.AgentCoreBankOwner", [
+            { no: 1, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string agent_id */ 1:
+                    message.agentId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string agent_id = 1; */
+        if (message.agentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.agentId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.AgentCoreBankOwner
+ */
+export const AgentCoreBankOwner = new AgentCoreBankOwner$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AgentDyadicBankOwner$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.AgentDyadicBankOwner", [
+            { no: 1, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.userId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string agent_id */ 1:
+                    message.agentId = reader.string();
+                    break;
+                case /* string user_id */ 2:
+                    message.userId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string agent_id = 1; */
+        if (message.agentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.agentId);
+        /* string user_id = 2; */
+        if (message.userId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.AgentDyadicBankOwner
+ */
+export const AgentDyadicBankOwner = new AgentDyadicBankOwner$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WorldSharedBankOwner$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.WorldSharedBankOwner", [
+            { no: 1, name: "world_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.worldId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string world_id */ 1:
+                    message.worldId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string world_id = 1; */
+        if (message.worldId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.worldId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.WorldSharedBankOwner
+ */
+export const WorldSharedBankOwner = new WorldSharedBankOwner$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AppPrivateBankOwner$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.AppPrivateBankOwner", [
+            { no: 1, name: "account_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "app_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.accountId = "";
+        message.appId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string account_id */ 1:
+                    message.accountId = reader.string();
+                    break;
+                case /* string app_id */ 2:
+                    message.appId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string account_id = 1; */
+        if (message.accountId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.accountId);
+        /* string app_id = 2; */
+        if (message.appId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.appId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.AppPrivateBankOwner
+ */
+export const AppPrivateBankOwner = new AppPrivateBankOwner$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WorkspacePrivateBankOwner$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.WorkspacePrivateBankOwner", [
+            { no: 1, name: "account_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "workspace_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.accountId = "";
+        message.workspaceId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string account_id */ 1:
+                    message.accountId = reader.string();
+                    break;
+                case /* string workspace_id */ 2:
+                    message.workspaceId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string account_id = 1; */
+        if (message.accountId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.accountId);
+        /* string workspace_id = 2; */
+        if (message.workspaceId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.workspaceId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.WorkspacePrivateBankOwner
+ */
+export const WorkspacePrivateBankOwner = new WorkspacePrivateBankOwner$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryBankLocator$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryBankLocator", [
+            { no: 1, name: "scope", kind: "enum", T: () => ["nimi.runtime.v1.MemoryBankScope", MemoryBankScope, "MEMORY_BANK_SCOPE_"] },
+            { no: 2, name: "agent_core", kind: "message", oneof: "owner", T: () => AgentCoreBankOwner },
+            { no: 3, name: "agent_dyadic", kind: "message", oneof: "owner", T: () => AgentDyadicBankOwner },
+            { no: 4, name: "world_shared", kind: "message", oneof: "owner", T: () => WorldSharedBankOwner },
+            { no: 5, name: "app_private", kind: "message", oneof: "owner", T: () => AppPrivateBankOwner },
+            { no: 6, name: "workspace_private", kind: "message", oneof: "owner", T: () => WorkspacePrivateBankOwner }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.scope = 0;
+        message.owner = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryBankScope scope */ 1:
+                    message.scope = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.AgentCoreBankOwner agent_core */ 2:
+                    message.owner = {
+                        oneofKind: "agentCore",
+                        agentCore: AgentCoreBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.agentCore)
+                    };
+                    break;
+                case /* nimi.runtime.v1.AgentDyadicBankOwner agent_dyadic */ 3:
+                    message.owner = {
+                        oneofKind: "agentDyadic",
+                        agentDyadic: AgentDyadicBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.agentDyadic)
+                    };
+                    break;
+                case /* nimi.runtime.v1.WorldSharedBankOwner world_shared */ 4:
+                    message.owner = {
+                        oneofKind: "worldShared",
+                        worldShared: WorldSharedBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.worldShared)
+                    };
+                    break;
+                case /* nimi.runtime.v1.AppPrivateBankOwner app_private */ 5:
+                    message.owner = {
+                        oneofKind: "appPrivate",
+                        appPrivate: AppPrivateBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.appPrivate)
+                    };
+                    break;
+                case /* nimi.runtime.v1.WorkspacePrivateBankOwner workspace_private */ 6:
+                    message.owner = {
+                        oneofKind: "workspacePrivate",
+                        workspacePrivate: WorkspacePrivateBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.workspacePrivate)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryBankScope scope = 1; */
+        if (message.scope !== 0)
+            writer.tag(1, WireType.Varint).int32(message.scope);
+        /* nimi.runtime.v1.AgentCoreBankOwner agent_core = 2; */
+        if (message.owner.oneofKind === "agentCore")
+            AgentCoreBankOwner.internalBinaryWrite(message.owner.agentCore, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.AgentDyadicBankOwner agent_dyadic = 3; */
+        if (message.owner.oneofKind === "agentDyadic")
+            AgentDyadicBankOwner.internalBinaryWrite(message.owner.agentDyadic, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.WorldSharedBankOwner world_shared = 4; */
+        if (message.owner.oneofKind === "worldShared")
+            WorldSharedBankOwner.internalBinaryWrite(message.owner.worldShared, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.AppPrivateBankOwner app_private = 5; */
+        if (message.owner.oneofKind === "appPrivate")
+            AppPrivateBankOwner.internalBinaryWrite(message.owner.appPrivate, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.WorkspacePrivateBankOwner workspace_private = 6; */
+        if (message.owner.oneofKind === "workspacePrivate")
+            WorkspacePrivateBankOwner.internalBinaryWrite(message.owner.workspacePrivate, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryBankLocator
+ */
+export const MemoryBankLocator = new MemoryBankLocator$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PublicMemoryBankLocator$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.PublicMemoryBankLocator", [
+            { no: 1, name: "app_private", kind: "message", oneof: "locator", T: () => AppPrivateBankOwner },
+            { no: 2, name: "workspace_private", kind: "message", oneof: "locator", T: () => WorkspacePrivateBankOwner }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.locator = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.AppPrivateBankOwner app_private */ 1:
+                    message.locator = {
+                        oneofKind: "appPrivate",
+                        appPrivate: AppPrivateBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.locator.appPrivate)
+                    };
+                    break;
+                case /* nimi.runtime.v1.WorkspacePrivateBankOwner workspace_private */ 2:
+                    message.locator = {
+                        oneofKind: "workspacePrivate",
+                        workspacePrivate: WorkspacePrivateBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.locator.workspacePrivate)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.AppPrivateBankOwner app_private = 1; */
+        if (message.locator.oneofKind === "appPrivate")
+            AppPrivateBankOwner.internalBinaryWrite(message.locator.appPrivate, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.WorkspacePrivateBankOwner workspace_private = 2; */
+        if (message.locator.oneofKind === "workspacePrivate")
+            WorkspacePrivateBankOwner.internalBinaryWrite(message.locator.workspacePrivate, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.PublicMemoryBankLocator
+ */
+export const PublicMemoryBankLocator = new PublicMemoryBankLocator$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryBankOwnerFilter$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryBankOwnerFilter", [
+            { no: 1, name: "agent_core", kind: "message", oneof: "owner", T: () => AgentCoreBankOwner },
+            { no: 2, name: "agent_dyadic", kind: "message", oneof: "owner", T: () => AgentDyadicBankOwner },
+            { no: 3, name: "world_shared", kind: "message", oneof: "owner", T: () => WorldSharedBankOwner },
+            { no: 4, name: "app_private", kind: "message", oneof: "owner", T: () => AppPrivateBankOwner },
+            { no: 5, name: "workspace_private", kind: "message", oneof: "owner", T: () => WorkspacePrivateBankOwner }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.owner = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.AgentCoreBankOwner agent_core */ 1:
+                    message.owner = {
+                        oneofKind: "agentCore",
+                        agentCore: AgentCoreBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.agentCore)
+                    };
+                    break;
+                case /* nimi.runtime.v1.AgentDyadicBankOwner agent_dyadic */ 2:
+                    message.owner = {
+                        oneofKind: "agentDyadic",
+                        agentDyadic: AgentDyadicBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.agentDyadic)
+                    };
+                    break;
+                case /* nimi.runtime.v1.WorldSharedBankOwner world_shared */ 3:
+                    message.owner = {
+                        oneofKind: "worldShared",
+                        worldShared: WorldSharedBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.worldShared)
+                    };
+                    break;
+                case /* nimi.runtime.v1.AppPrivateBankOwner app_private */ 4:
+                    message.owner = {
+                        oneofKind: "appPrivate",
+                        appPrivate: AppPrivateBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.appPrivate)
+                    };
+                    break;
+                case /* nimi.runtime.v1.WorkspacePrivateBankOwner workspace_private */ 5:
+                    message.owner = {
+                        oneofKind: "workspacePrivate",
+                        workspacePrivate: WorkspacePrivateBankOwner.internalBinaryRead(reader, reader.uint32(), options, message.owner.workspacePrivate)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.AgentCoreBankOwner agent_core = 1; */
+        if (message.owner.oneofKind === "agentCore")
+            AgentCoreBankOwner.internalBinaryWrite(message.owner.agentCore, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.AgentDyadicBankOwner agent_dyadic = 2; */
+        if (message.owner.oneofKind === "agentDyadic")
+            AgentDyadicBankOwner.internalBinaryWrite(message.owner.agentDyadic, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.WorldSharedBankOwner world_shared = 3; */
+        if (message.owner.oneofKind === "worldShared")
+            WorldSharedBankOwner.internalBinaryWrite(message.owner.worldShared, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.AppPrivateBankOwner app_private = 4; */
+        if (message.owner.oneofKind === "appPrivate")
+            AppPrivateBankOwner.internalBinaryWrite(message.owner.appPrivate, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.WorkspacePrivateBankOwner workspace_private = 5; */
+        if (message.owner.oneofKind === "workspacePrivate")
+            WorkspacePrivateBankOwner.internalBinaryWrite(message.owner.workspacePrivate, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryBankOwnerFilter
+ */
+export const MemoryBankOwnerFilter = new MemoryBankOwnerFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryEmbeddingProfile$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryEmbeddingProfile", [
+            { no: 1, name: "provider", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "model_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "dimension", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "distance_metric", kind: "enum", T: () => ["nimi.runtime.v1.MemoryDistanceMetric", MemoryDistanceMetric, "MEMORY_DISTANCE_METRIC_"] },
+            { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "migration_policy", kind: "enum", T: () => ["nimi.runtime.v1.MemoryMigrationPolicy", MemoryMigrationPolicy, "MEMORY_MIGRATION_POLICY_"] }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.provider = "";
+        message.modelId = "";
+        message.dimension = 0;
+        message.distanceMetric = 0;
+        message.version = "";
+        message.migrationPolicy = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string provider */ 1:
+                    message.provider = reader.string();
+                    break;
+                case /* string model_id */ 2:
+                    message.modelId = reader.string();
+                    break;
+                case /* int32 dimension */ 3:
+                    message.dimension = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.MemoryDistanceMetric distance_metric */ 4:
+                    message.distanceMetric = reader.int32();
+                    break;
+                case /* string version */ 5:
+                    message.version = reader.string();
+                    break;
+                case /* nimi.runtime.v1.MemoryMigrationPolicy migration_policy */ 6:
+                    message.migrationPolicy = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string provider = 1; */
+        if (message.provider !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.provider);
+        /* string model_id = 2; */
+        if (message.modelId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.modelId);
+        /* int32 dimension = 3; */
+        if (message.dimension !== 0)
+            writer.tag(3, WireType.Varint).int32(message.dimension);
+        /* nimi.runtime.v1.MemoryDistanceMetric distance_metric = 4; */
+        if (message.distanceMetric !== 0)
+            writer.tag(4, WireType.Varint).int32(message.distanceMetric);
+        /* string version = 5; */
+        if (message.version !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.version);
+        /* nimi.runtime.v1.MemoryMigrationPolicy migration_policy = 6; */
+        if (message.migrationPolicy !== 0)
+            writer.tag(6, WireType.Varint).int32(message.migrationPolicy);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryEmbeddingProfile
+ */
+export const MemoryEmbeddingProfile = new MemoryEmbeddingProfile$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryBank$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryBank", [
+            { no: 1, name: "bank_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "locator", kind: "message", T: () => MemoryBankLocator },
+            { no: 3, name: "embedding_profile", kind: "message", T: () => MemoryEmbeddingProfile },
+            { no: 4, name: "display_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "canonical_agent_scope", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "public_api_writable", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 7, name: "metadata", kind: "message", T: () => Struct },
+            { no: 8, name: "created_at", kind: "message", T: () => Timestamp },
+            { no: 9, name: "updated_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.bankId = "";
+        message.displayName = "";
+        message.canonicalAgentScope = false;
+        message.publicApiWritable = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string bank_id */ 1:
+                    message.bankId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator locator */ 2:
+                    message.locator = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.locator);
+                    break;
+                case /* nimi.runtime.v1.MemoryEmbeddingProfile embedding_profile */ 3:
+                    message.embeddingProfile = MemoryEmbeddingProfile.internalBinaryRead(reader, reader.uint32(), options, message.embeddingProfile);
+                    break;
+                case /* string display_name */ 4:
+                    message.displayName = reader.string();
+                    break;
+                case /* bool canonical_agent_scope */ 5:
+                    message.canonicalAgentScope = reader.bool();
+                    break;
+                case /* bool public_api_writable */ 6:
+                    message.publicApiWritable = reader.bool();
+                    break;
+                case /* google.protobuf.Struct metadata */ 7:
+                    message.metadata = Struct.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                case /* google.protobuf.Timestamp created_at */ 8:
+                    message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
+                    break;
+                case /* google.protobuf.Timestamp updated_at */ 9:
+                    message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string bank_id = 1; */
+        if (message.bankId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.bankId);
+        /* nimi.runtime.v1.MemoryBankLocator locator = 2; */
+        if (message.locator)
+            MemoryBankLocator.internalBinaryWrite(message.locator, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryEmbeddingProfile embedding_profile = 3; */
+        if (message.embeddingProfile)
+            MemoryEmbeddingProfile.internalBinaryWrite(message.embeddingProfile, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* string display_name = 4; */
+        if (message.displayName !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.displayName);
+        /* bool canonical_agent_scope = 5; */
+        if (message.canonicalAgentScope !== false)
+            writer.tag(5, WireType.Varint).bool(message.canonicalAgentScope);
+        /* bool public_api_writable = 6; */
+        if (message.publicApiWritable !== false)
+            writer.tag(6, WireType.Varint).bool(message.publicApiWritable);
+        /* google.protobuf.Struct metadata = 7; */
+        if (message.metadata)
+            Struct.internalBinaryWrite(message.metadata, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp created_at = 8; */
+        if (message.createdAt)
+            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp updated_at = 9; */
+        if (message.updatedAt)
+            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryBank
+ */
+export const MemoryBank = new MemoryBank$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryProvenance$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryProvenance", [
+            { no: 1, name: "source_system", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "source_event_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "author_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "trace_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "committed_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.sourceSystem = "";
+        message.sourceEventId = "";
+        message.authorId = "";
+        message.traceId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string source_system */ 1:
+                    message.sourceSystem = reader.string();
+                    break;
+                case /* string source_event_id */ 2:
+                    message.sourceEventId = reader.string();
+                    break;
+                case /* string author_id */ 3:
+                    message.authorId = reader.string();
+                    break;
+                case /* string trace_id */ 4:
+                    message.traceId = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp committed_at */ 5:
+                    message.committedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.committedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string source_system = 1; */
+        if (message.sourceSystem !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.sourceSystem);
+        /* string source_event_id = 2; */
+        if (message.sourceEventId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.sourceEventId);
+        /* string author_id = 3; */
+        if (message.authorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.authorId);
+        /* string trace_id = 4; */
+        if (message.traceId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.traceId);
+        /* google.protobuf.Timestamp committed_at = 5; */
+        if (message.committedAt)
+            Timestamp.internalBinaryWrite(message.committedAt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryProvenance
+ */
+export const MemoryProvenance = new MemoryProvenance$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EpisodicMemoryRecord$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.EpisodicMemoryRecord", [
+            { no: 1, name: "summary", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "occurred_at", kind: "message", T: () => Timestamp },
+            { no: 3, name: "participants", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.summary = "";
+        message.participants = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string summary */ 1:
+                    message.summary = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp occurred_at */ 2:
+                    message.occurredAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.occurredAt);
+                    break;
+                case /* repeated string participants */ 3:
+                    message.participants.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string summary = 1; */
+        if (message.summary !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.summary);
+        /* google.protobuf.Timestamp occurred_at = 2; */
+        if (message.occurredAt)
+            Timestamp.internalBinaryWrite(message.occurredAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string participants = 3; */
+        for (let i = 0; i < message.participants.length; i++)
+            writer.tag(3, WireType.LengthDelimited).string(message.participants[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.EpisodicMemoryRecord
+ */
+export const EpisodicMemoryRecord = new EpisodicMemoryRecord$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SemanticMemoryRecord$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.SemanticMemoryRecord", [
+            { no: 1, name: "subject", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "predicate", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "object", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "confidence", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.subject = "";
+        message.predicate = "";
+        message.object = "";
+        message.confidence = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string subject */ 1:
+                    message.subject = reader.string();
+                    break;
+                case /* string predicate */ 2:
+                    message.predicate = reader.string();
+                    break;
+                case /* string object */ 3:
+                    message.object = reader.string();
+                    break;
+                case /* double confidence */ 4:
+                    message.confidence = reader.double();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string subject = 1; */
+        if (message.subject !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.subject);
+        /* string predicate = 2; */
+        if (message.predicate !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.predicate);
+        /* string object = 3; */
+        if (message.object !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.object);
+        /* double confidence = 4; */
+        if (message.confidence !== 0)
+            writer.tag(4, WireType.Bit64).double(message.confidence);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.SemanticMemoryRecord
+ */
+export const SemanticMemoryRecord = new SemanticMemoryRecord$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ObservationalMemoryRecord$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ObservationalMemoryRecord", [
+            { no: 1, name: "observation", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "observed_at", kind: "message", T: () => Timestamp },
+            { no: 3, name: "source_ref", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.observation = "";
+        message.sourceRef = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string observation */ 1:
+                    message.observation = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp observed_at */ 2:
+                    message.observedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.observedAt);
+                    break;
+                case /* string source_ref */ 3:
+                    message.sourceRef = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string observation = 1; */
+        if (message.observation !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.observation);
+        /* google.protobuf.Timestamp observed_at = 2; */
+        if (message.observedAt)
+            Timestamp.internalBinaryWrite(message.observedAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* string source_ref = 3; */
+        if (message.sourceRef !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.sourceRef);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.ObservationalMemoryRecord
+ */
+export const ObservationalMemoryRecord = new ObservationalMemoryRecord$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryRecordInput$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryRecordInput", [
+            { no: 1, name: "kind", kind: "enum", T: () => ["nimi.runtime.v1.MemoryRecordKind", MemoryRecordKind, "MEMORY_RECORD_KIND_"] },
+            { no: 2, name: "canonical_class", kind: "enum", T: () => ["nimi.runtime.v1.MemoryCanonicalClass", MemoryCanonicalClass, "MEMORY_CANONICAL_CLASS_"] },
+            { no: 3, name: "provenance", kind: "message", T: () => MemoryProvenance },
+            { no: 4, name: "metadata", kind: "message", T: () => Struct },
+            { no: 5, name: "extensions", kind: "message", T: () => Struct },
+            { no: 10, name: "episodic", kind: "message", oneof: "payload", T: () => EpisodicMemoryRecord },
+            { no: 11, name: "semantic", kind: "message", oneof: "payload", T: () => SemanticMemoryRecord },
+            { no: 12, name: "observational", kind: "message", oneof: "payload", T: () => ObservationalMemoryRecord }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.canonicalClass = 0;
+        message.payload = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRecordKind kind */ 1:
+                    message.kind = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.MemoryCanonicalClass canonical_class */ 2:
+                    message.canonicalClass = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.MemoryProvenance provenance */ 3:
+                    message.provenance = MemoryProvenance.internalBinaryRead(reader, reader.uint32(), options, message.provenance);
+                    break;
+                case /* google.protobuf.Struct metadata */ 4:
+                    message.metadata = Struct.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                case /* google.protobuf.Struct extensions */ 5:
+                    message.extensions = Struct.internalBinaryRead(reader, reader.uint32(), options, message.extensions);
+                    break;
+                case /* nimi.runtime.v1.EpisodicMemoryRecord episodic */ 10:
+                    message.payload = {
+                        oneofKind: "episodic",
+                        episodic: EpisodicMemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.payload.episodic)
+                    };
+                    break;
+                case /* nimi.runtime.v1.SemanticMemoryRecord semantic */ 11:
+                    message.payload = {
+                        oneofKind: "semantic",
+                        semantic: SemanticMemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.payload.semantic)
+                    };
+                    break;
+                case /* nimi.runtime.v1.ObservationalMemoryRecord observational */ 12:
+                    message.payload = {
+                        oneofKind: "observational",
+                        observational: ObservationalMemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.payload.observational)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRecordKind kind = 1; */
+        if (message.kind !== 0)
+            writer.tag(1, WireType.Varint).int32(message.kind);
+        /* nimi.runtime.v1.MemoryCanonicalClass canonical_class = 2; */
+        if (message.canonicalClass !== 0)
+            writer.tag(2, WireType.Varint).int32(message.canonicalClass);
+        /* nimi.runtime.v1.MemoryProvenance provenance = 3; */
+        if (message.provenance)
+            MemoryProvenance.internalBinaryWrite(message.provenance, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Struct metadata = 4; */
+        if (message.metadata)
+            Struct.internalBinaryWrite(message.metadata, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Struct extensions = 5; */
+        if (message.extensions)
+            Struct.internalBinaryWrite(message.extensions, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.EpisodicMemoryRecord episodic = 10; */
+        if (message.payload.oneofKind === "episodic")
+            EpisodicMemoryRecord.internalBinaryWrite(message.payload.episodic, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.SemanticMemoryRecord semantic = 11; */
+        if (message.payload.oneofKind === "semantic")
+            SemanticMemoryRecord.internalBinaryWrite(message.payload.semantic, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.ObservationalMemoryRecord observational = 12; */
+        if (message.payload.oneofKind === "observational")
+            ObservationalMemoryRecord.internalBinaryWrite(message.payload.observational, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryRecordInput
+ */
+export const MemoryRecordInput = new MemoryRecordInput$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReplicationPending$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReplicationPending", [
+            { no: 1, name: "basis_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "enqueued_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.basisVersion = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string basis_version */ 1:
+                    message.basisVersion = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp enqueued_at */ 2:
+                    message.enqueuedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.enqueuedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string basis_version = 1; */
+        if (message.basisVersion !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.basisVersion);
+        /* google.protobuf.Timestamp enqueued_at = 2; */
+        if (message.enqueuedAt)
+            Timestamp.internalBinaryWrite(message.enqueuedAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReplicationPending
+ */
+export const MemoryReplicationPending = new MemoryReplicationPending$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReplicationSynced$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReplicationSynced", [
+            { no: 1, name: "realm_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "synced_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.realmVersion = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string realm_version */ 1:
+                    message.realmVersion = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp synced_at */ 2:
+                    message.syncedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.syncedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string realm_version = 1; */
+        if (message.realmVersion !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.realmVersion);
+        /* google.protobuf.Timestamp synced_at = 2; */
+        if (message.syncedAt)
+            Timestamp.internalBinaryWrite(message.syncedAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReplicationSynced
+ */
+export const MemoryReplicationSynced = new MemoryReplicationSynced$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReplicationConflict$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReplicationConflict", [
+            { no: 1, name: "conflict_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "local_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "remote_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "conflict_reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "detected_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.conflictId = "";
+        message.localVersion = "";
+        message.remoteVersion = "";
+        message.conflictReason = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string conflict_id */ 1:
+                    message.conflictId = reader.string();
+                    break;
+                case /* string local_version */ 2:
+                    message.localVersion = reader.string();
+                    break;
+                case /* string remote_version */ 3:
+                    message.remoteVersion = reader.string();
+                    break;
+                case /* string conflict_reason */ 4:
+                    message.conflictReason = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp detected_at */ 5:
+                    message.detectedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.detectedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string conflict_id = 1; */
+        if (message.conflictId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.conflictId);
+        /* string local_version = 2; */
+        if (message.localVersion !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.localVersion);
+        /* string remote_version = 3; */
+        if (message.remoteVersion !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.remoteVersion);
+        /* string conflict_reason = 4; */
+        if (message.conflictReason !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.conflictReason);
+        /* google.protobuf.Timestamp detected_at = 5; */
+        if (message.detectedAt)
+            Timestamp.internalBinaryWrite(message.detectedAt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReplicationConflict
+ */
+export const MemoryReplicationConflict = new MemoryReplicationConflict$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryInvalidation$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryInvalidation", [
+            { no: 1, name: "invalidation_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "invalidated_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "authority", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "invalidation_reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "invalidated_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.invalidationId = "";
+        message.invalidatedVersion = "";
+        message.authority = "";
+        message.invalidationReason = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string invalidation_id */ 1:
+                    message.invalidationId = reader.string();
+                    break;
+                case /* string invalidated_version */ 2:
+                    message.invalidatedVersion = reader.string();
+                    break;
+                case /* string authority */ 3:
+                    message.authority = reader.string();
+                    break;
+                case /* string invalidation_reason */ 4:
+                    message.invalidationReason = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp invalidated_at */ 5:
+                    message.invalidatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.invalidatedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string invalidation_id = 1; */
+        if (message.invalidationId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.invalidationId);
+        /* string invalidated_version = 2; */
+        if (message.invalidatedVersion !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.invalidatedVersion);
+        /* string authority = 3; */
+        if (message.authority !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.authority);
+        /* string invalidation_reason = 4; */
+        if (message.invalidationReason !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.invalidationReason);
+        /* google.protobuf.Timestamp invalidated_at = 5; */
+        if (message.invalidatedAt)
+            Timestamp.internalBinaryWrite(message.invalidatedAt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryInvalidation
+ */
+export const MemoryInvalidation = new MemoryInvalidation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReplicationState$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReplicationState", [
+            { no: 1, name: "outcome", kind: "enum", T: () => ["nimi.runtime.v1.MemoryReplicationOutcome", MemoryReplicationOutcome, "MEMORY_REPLICATION_OUTCOME_"] },
+            { no: 2, name: "local_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "basis_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "pending", kind: "message", oneof: "detail", T: () => MemoryReplicationPending },
+            { no: 11, name: "synced", kind: "message", oneof: "detail", T: () => MemoryReplicationSynced },
+            { no: 12, name: "conflict", kind: "message", oneof: "detail", T: () => MemoryReplicationConflict },
+            { no: 13, name: "invalidation", kind: "message", oneof: "detail", T: () => MemoryInvalidation }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.outcome = 0;
+        message.localVersion = "";
+        message.basisVersion = "";
+        message.detail = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryReplicationOutcome outcome */ 1:
+                    message.outcome = reader.int32();
+                    break;
+                case /* string local_version */ 2:
+                    message.localVersion = reader.string();
+                    break;
+                case /* string basis_version */ 3:
+                    message.basisVersion = reader.string();
+                    break;
+                case /* nimi.runtime.v1.MemoryReplicationPending pending */ 10:
+                    message.detail = {
+                        oneofKind: "pending",
+                        pending: MemoryReplicationPending.internalBinaryRead(reader, reader.uint32(), options, message.detail.pending)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryReplicationSynced synced */ 11:
+                    message.detail = {
+                        oneofKind: "synced",
+                        synced: MemoryReplicationSynced.internalBinaryRead(reader, reader.uint32(), options, message.detail.synced)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryReplicationConflict conflict */ 12:
+                    message.detail = {
+                        oneofKind: "conflict",
+                        conflict: MemoryReplicationConflict.internalBinaryRead(reader, reader.uint32(), options, message.detail.conflict)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryInvalidation invalidation */ 13:
+                    message.detail = {
+                        oneofKind: "invalidation",
+                        invalidation: MemoryInvalidation.internalBinaryRead(reader, reader.uint32(), options, message.detail.invalidation)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryReplicationOutcome outcome = 1; */
+        if (message.outcome !== 0)
+            writer.tag(1, WireType.Varint).int32(message.outcome);
+        /* string local_version = 2; */
+        if (message.localVersion !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.localVersion);
+        /* string basis_version = 3; */
+        if (message.basisVersion !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.basisVersion);
+        /* nimi.runtime.v1.MemoryReplicationPending pending = 10; */
+        if (message.detail.oneofKind === "pending")
+            MemoryReplicationPending.internalBinaryWrite(message.detail.pending, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryReplicationSynced synced = 11; */
+        if (message.detail.oneofKind === "synced")
+            MemoryReplicationSynced.internalBinaryWrite(message.detail.synced, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryReplicationConflict conflict = 12; */
+        if (message.detail.oneofKind === "conflict")
+            MemoryReplicationConflict.internalBinaryWrite(message.detail.conflict, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryInvalidation invalidation = 13; */
+        if (message.detail.oneofKind === "invalidation")
+            MemoryInvalidation.internalBinaryWrite(message.detail.invalidation, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReplicationState
+ */
+export const MemoryReplicationState = new MemoryReplicationState$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryRecord$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryRecord", [
+            { no: 1, name: "memory_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "bank", kind: "message", T: () => MemoryBankLocator },
+            { no: 3, name: "kind", kind: "enum", T: () => ["nimi.runtime.v1.MemoryRecordKind", MemoryRecordKind, "MEMORY_RECORD_KIND_"] },
+            { no: 4, name: "canonical_class", kind: "enum", T: () => ["nimi.runtime.v1.MemoryCanonicalClass", MemoryCanonicalClass, "MEMORY_CANONICAL_CLASS_"] },
+            { no: 5, name: "provenance", kind: "message", T: () => MemoryProvenance },
+            { no: 6, name: "replication", kind: "message", T: () => MemoryReplicationState },
+            { no: 7, name: "metadata", kind: "message", T: () => Struct },
+            { no: 8, name: "extensions", kind: "message", T: () => Struct },
+            { no: 10, name: "episodic", kind: "message", oneof: "payload", T: () => EpisodicMemoryRecord },
+            { no: 11, name: "semantic", kind: "message", oneof: "payload", T: () => SemanticMemoryRecord },
+            { no: 12, name: "observational", kind: "message", oneof: "payload", T: () => ObservationalMemoryRecord },
+            { no: 20, name: "created_at", kind: "message", T: () => Timestamp },
+            { no: 21, name: "updated_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.memoryId = "";
+        message.kind = 0;
+        message.canonicalClass = 0;
+        message.payload = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string memory_id */ 1:
+                    message.memoryId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator bank */ 2:
+                    message.bank = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                case /* nimi.runtime.v1.MemoryRecordKind kind */ 3:
+                    message.kind = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.MemoryCanonicalClass canonical_class */ 4:
+                    message.canonicalClass = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.MemoryProvenance provenance */ 5:
+                    message.provenance = MemoryProvenance.internalBinaryRead(reader, reader.uint32(), options, message.provenance);
+                    break;
+                case /* nimi.runtime.v1.MemoryReplicationState replication */ 6:
+                    message.replication = MemoryReplicationState.internalBinaryRead(reader, reader.uint32(), options, message.replication);
+                    break;
+                case /* google.protobuf.Struct metadata */ 7:
+                    message.metadata = Struct.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                case /* google.protobuf.Struct extensions */ 8:
+                    message.extensions = Struct.internalBinaryRead(reader, reader.uint32(), options, message.extensions);
+                    break;
+                case /* nimi.runtime.v1.EpisodicMemoryRecord episodic */ 10:
+                    message.payload = {
+                        oneofKind: "episodic",
+                        episodic: EpisodicMemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.payload.episodic)
+                    };
+                    break;
+                case /* nimi.runtime.v1.SemanticMemoryRecord semantic */ 11:
+                    message.payload = {
+                        oneofKind: "semantic",
+                        semantic: SemanticMemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.payload.semantic)
+                    };
+                    break;
+                case /* nimi.runtime.v1.ObservationalMemoryRecord observational */ 12:
+                    message.payload = {
+                        oneofKind: "observational",
+                        observational: ObservationalMemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.payload.observational)
+                    };
+                    break;
+                case /* google.protobuf.Timestamp created_at */ 20:
+                    message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
+                    break;
+                case /* google.protobuf.Timestamp updated_at */ 21:
+                    message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string memory_id = 1; */
+        if (message.memoryId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.memoryId);
+        /* nimi.runtime.v1.MemoryBankLocator bank = 2; */
+        if (message.bank)
+            MemoryBankLocator.internalBinaryWrite(message.bank, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryRecordKind kind = 3; */
+        if (message.kind !== 0)
+            writer.tag(3, WireType.Varint).int32(message.kind);
+        /* nimi.runtime.v1.MemoryCanonicalClass canonical_class = 4; */
+        if (message.canonicalClass !== 0)
+            writer.tag(4, WireType.Varint).int32(message.canonicalClass);
+        /* nimi.runtime.v1.MemoryProvenance provenance = 5; */
+        if (message.provenance)
+            MemoryProvenance.internalBinaryWrite(message.provenance, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryReplicationState replication = 6; */
+        if (message.replication)
+            MemoryReplicationState.internalBinaryWrite(message.replication, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Struct metadata = 7; */
+        if (message.metadata)
+            Struct.internalBinaryWrite(message.metadata, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Struct extensions = 8; */
+        if (message.extensions)
+            Struct.internalBinaryWrite(message.extensions, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.EpisodicMemoryRecord episodic = 10; */
+        if (message.payload.oneofKind === "episodic")
+            EpisodicMemoryRecord.internalBinaryWrite(message.payload.episodic, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.SemanticMemoryRecord semantic = 11; */
+        if (message.payload.oneofKind === "semantic")
+            SemanticMemoryRecord.internalBinaryWrite(message.payload.semantic, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.ObservationalMemoryRecord observational = 12; */
+        if (message.payload.oneofKind === "observational")
+            ObservationalMemoryRecord.internalBinaryWrite(message.payload.observational, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp created_at = 20; */
+        if (message.createdAt)
+            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp updated_at = 21; */
+        if (message.updatedAt)
+            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryRecord
+ */
+export const MemoryRecord = new MemoryRecord$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryRecallQuery$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryRecallQuery", [
+            { no: 1, name: "query", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "kinds", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["nimi.runtime.v1.MemoryRecordKind", MemoryRecordKind, "MEMORY_RECORD_KIND_"] },
+            { no: 3, name: "limit", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "start_time", kind: "message", T: () => Timestamp },
+            { no: 5, name: "end_time", kind: "message", T: () => Timestamp },
+            { no: 6, name: "canonical_classes", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["nimi.runtime.v1.MemoryCanonicalClass", MemoryCanonicalClass, "MEMORY_CANONICAL_CLASS_"] },
+            { no: 7, name: "include_invalidated", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.query = "";
+        message.kinds = [];
+        message.limit = 0;
+        message.canonicalClasses = [];
+        message.includeInvalidated = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string query */ 1:
+                    message.query = reader.string();
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryRecordKind kinds */ 2:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.kinds.push(reader.int32());
+                    else
+                        message.kinds.push(reader.int32());
+                    break;
+                case /* int32 limit */ 3:
+                    message.limit = reader.int32();
+                    break;
+                case /* google.protobuf.Timestamp start_time */ 4:
+                    message.startTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startTime);
+                    break;
+                case /* google.protobuf.Timestamp end_time */ 5:
+                    message.endTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.endTime);
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryCanonicalClass canonical_classes */ 6:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.canonicalClasses.push(reader.int32());
+                    else
+                        message.canonicalClasses.push(reader.int32());
+                    break;
+                case /* bool include_invalidated */ 7:
+                    message.includeInvalidated = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string query = 1; */
+        if (message.query !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.query);
+        /* repeated nimi.runtime.v1.MemoryRecordKind kinds = 2; */
+        if (message.kinds.length) {
+            writer.tag(2, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.kinds.length; i++)
+                writer.int32(message.kinds[i]);
+            writer.join();
+        }
+        /* int32 limit = 3; */
+        if (message.limit !== 0)
+            writer.tag(3, WireType.Varint).int32(message.limit);
+        /* google.protobuf.Timestamp start_time = 4; */
+        if (message.startTime)
+            Timestamp.internalBinaryWrite(message.startTime, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp end_time = 5; */
+        if (message.endTime)
+            Timestamp.internalBinaryWrite(message.endTime, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.MemoryCanonicalClass canonical_classes = 6; */
+        if (message.canonicalClasses.length) {
+            writer.tag(6, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.canonicalClasses.length; i++)
+                writer.int32(message.canonicalClasses[i]);
+            writer.join();
+        }
+        /* bool include_invalidated = 7; */
+        if (message.includeInvalidated !== false)
+            writer.tag(7, WireType.Varint).bool(message.includeInvalidated);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryRecallQuery
+ */
+export const MemoryRecallQuery = new MemoryRecallQuery$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryHistoryQuery$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryHistoryQuery", [
+            { no: 1, name: "kinds", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["nimi.runtime.v1.MemoryRecordKind", MemoryRecordKind, "MEMORY_RECORD_KIND_"] },
+            { no: 2, name: "start_time", kind: "message", T: () => Timestamp },
+            { no: 3, name: "end_time", kind: "message", T: () => Timestamp },
+            { no: 4, name: "page_size", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 5, name: "page_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "include_invalidated", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kinds = [];
+        message.pageSize = 0;
+        message.pageToken = "";
+        message.includeInvalidated = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryRecordKind kinds */ 1:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.kinds.push(reader.int32());
+                    else
+                        message.kinds.push(reader.int32());
+                    break;
+                case /* google.protobuf.Timestamp start_time */ 2:
+                    message.startTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startTime);
+                    break;
+                case /* google.protobuf.Timestamp end_time */ 3:
+                    message.endTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.endTime);
+                    break;
+                case /* int32 page_size */ 4:
+                    message.pageSize = reader.int32();
+                    break;
+                case /* string page_token */ 5:
+                    message.pageToken = reader.string();
+                    break;
+                case /* bool include_invalidated */ 6:
+                    message.includeInvalidated = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryRecordKind kinds = 1; */
+        if (message.kinds.length) {
+            writer.tag(1, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.kinds.length; i++)
+                writer.int32(message.kinds[i]);
+            writer.join();
+        }
+        /* google.protobuf.Timestamp start_time = 2; */
+        if (message.startTime)
+            Timestamp.internalBinaryWrite(message.startTime, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp end_time = 3; */
+        if (message.endTime)
+            Timestamp.internalBinaryWrite(message.endTime, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* int32 page_size = 4; */
+        if (message.pageSize !== 0)
+            writer.tag(4, WireType.Varint).int32(message.pageSize);
+        /* string page_token = 5; */
+        if (message.pageToken !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.pageToken);
+        /* bool include_invalidated = 6; */
+        if (message.includeInvalidated !== false)
+            writer.tag(6, WireType.Varint).bool(message.includeInvalidated);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryHistoryQuery
+ */
+export const MemoryHistoryQuery = new MemoryHistoryQuery$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryRecallHit$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryRecallHit", [
+            { no: 1, name: "record", kind: "message", T: () => MemoryRecord },
+            { no: 2, name: "relevance_score", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 3, name: "match_reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.relevanceScore = 0;
+        message.matchReason = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRecord record */ 1:
+                    message.record = MemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.record);
+                    break;
+                case /* double relevance_score */ 2:
+                    message.relevanceScore = reader.double();
+                    break;
+                case /* string match_reason */ 3:
+                    message.matchReason = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRecord record = 1; */
+        if (message.record)
+            MemoryRecord.internalBinaryWrite(message.record, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* double relevance_score = 2; */
+        if (message.relevanceScore !== 0)
+            writer.tag(2, WireType.Bit64).double(message.relevanceScore);
+        /* string match_reason = 3; */
+        if (message.matchReason !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.matchReason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryRecallHit
+ */
+export const MemoryRecallHit = new MemoryRecallHit$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NarrativeRecallHit$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.NarrativeRecallHit", [
+            { no: 1, name: "narrative_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "topic", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "content", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "source_memory_ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "is_stale", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "relevance_score", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.narrativeId = "";
+        message.topic = "";
+        message.content = "";
+        message.sourceMemoryIds = [];
+        message.isStale = false;
+        message.relevanceScore = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string narrative_id */ 1:
+                    message.narrativeId = reader.string();
+                    break;
+                case /* string topic */ 2:
+                    message.topic = reader.string();
+                    break;
+                case /* string content */ 3:
+                    message.content = reader.string();
+                    break;
+                case /* repeated string source_memory_ids */ 4:
+                    message.sourceMemoryIds.push(reader.string());
+                    break;
+                case /* bool is_stale */ 5:
+                    message.isStale = reader.bool();
+                    break;
+                case /* double relevance_score */ 6:
+                    message.relevanceScore = reader.double();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string narrative_id = 1; */
+        if (message.narrativeId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.narrativeId);
+        /* string topic = 2; */
+        if (message.topic !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.topic);
+        /* string content = 3; */
+        if (message.content !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.content);
+        /* repeated string source_memory_ids = 4; */
+        for (let i = 0; i < message.sourceMemoryIds.length; i++)
+            writer.tag(4, WireType.LengthDelimited).string(message.sourceMemoryIds[i]);
+        /* bool is_stale = 5; */
+        if (message.isStale !== false)
+            writer.tag(5, WireType.Varint).bool(message.isStale);
+        /* double relevance_score = 6; */
+        if (message.relevanceScore !== 0)
+            writer.tag(6, WireType.Bit64).double(message.relevanceScore);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.NarrativeRecallHit
+ */
+export const NarrativeRecallHit = new NarrativeRecallHit$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReflectionRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReflectionRequest", [
+            { no: 1, name: "source_kinds", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["nimi.runtime.v1.MemoryRecordKind", MemoryRecordKind, "MEMORY_RECORD_KIND_"] },
+            { no: 2, name: "start_time", kind: "message", T: () => Timestamp },
+            { no: 3, name: "end_time", kind: "message", T: () => Timestamp },
+            { no: 4, name: "target_record_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 5, name: "reflection_reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.sourceKinds = [];
+        message.targetRecordCount = 0;
+        message.reflectionReason = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryRecordKind source_kinds */ 1:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.sourceKinds.push(reader.int32());
+                    else
+                        message.sourceKinds.push(reader.int32());
+                    break;
+                case /* google.protobuf.Timestamp start_time */ 2:
+                    message.startTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startTime);
+                    break;
+                case /* google.protobuf.Timestamp end_time */ 3:
+                    message.endTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.endTime);
+                    break;
+                case /* int32 target_record_count */ 4:
+                    message.targetRecordCount = reader.int32();
+                    break;
+                case /* string reflection_reason */ 5:
+                    message.reflectionReason = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryRecordKind source_kinds = 1; */
+        if (message.sourceKinds.length) {
+            writer.tag(1, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.sourceKinds.length; i++)
+                writer.int32(message.sourceKinds[i]);
+            writer.join();
+        }
+        /* google.protobuf.Timestamp start_time = 2; */
+        if (message.startTime)
+            Timestamp.internalBinaryWrite(message.startTime, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp end_time = 3; */
+        if (message.endTime)
+            Timestamp.internalBinaryWrite(message.endTime, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* int32 target_record_count = 4; */
+        if (message.targetRecordCount !== 0)
+            writer.tag(4, WireType.Varint).int32(message.targetRecordCount);
+        /* string reflection_reason = 5; */
+        if (message.reflectionReason !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.reflectionReason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReflectionRequest
+ */
+export const MemoryReflectionRequest = new MemoryReflectionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReflectionResult$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReflectionResult", [
+            { no: 1, name: "created_records", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryRecord },
+            { no: 2, name: "source_record_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "completed_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.createdRecords = [];
+        message.sourceRecordCount = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryRecord created_records */ 1:
+                    message.createdRecords.push(MemoryRecord.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* int32 source_record_count */ 2:
+                    message.sourceRecordCount = reader.int32();
+                    break;
+                case /* google.protobuf.Timestamp completed_at */ 3:
+                    message.completedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.completedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryRecord created_records = 1; */
+        for (let i = 0; i < message.createdRecords.length; i++)
+            MemoryRecord.internalBinaryWrite(message.createdRecords[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int32 source_record_count = 2; */
+        if (message.sourceRecordCount !== 0)
+            writer.tag(2, WireType.Varint).int32(message.sourceRecordCount);
+        /* google.protobuf.Timestamp completed_at = 3; */
+        if (message.completedAt)
+            Timestamp.internalBinaryWrite(message.completedAt, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReflectionResult
+ */
+export const MemoryReflectionResult = new MemoryReflectionResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryDeletedDetail$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryDeletedDetail", [
+            { no: 1, name: "memory_ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.memoryIds = [];
+        message.reason = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string memory_ids */ 1:
+                    message.memoryIds.push(reader.string());
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated string memory_ids = 1; */
+        for (let i = 0; i < message.memoryIds.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.memoryIds[i]);
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryDeletedDetail
+ */
+export const MemoryDeletedDetail = new MemoryDeletedDetail$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryReplicationObservedDetail$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryReplicationObservedDetail", [
+            { no: 1, name: "memory_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "replication", kind: "message", T: () => MemoryReplicationState }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.memoryId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string memory_id */ 1:
+                    message.memoryId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.MemoryReplicationState replication */ 2:
+                    message.replication = MemoryReplicationState.internalBinaryRead(reader, reader.uint32(), options, message.replication);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string memory_id = 1; */
+        if (message.memoryId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.memoryId);
+        /* nimi.runtime.v1.MemoryReplicationState replication = 2; */
+        if (message.replication)
+            MemoryReplicationState.internalBinaryWrite(message.replication, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryReplicationObservedDetail
+ */
+export const MemoryReplicationObservedDetail = new MemoryReplicationObservedDetail$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MemoryEvent$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.MemoryEvent", [
+            { no: 1, name: "event_type", kind: "enum", T: () => ["nimi.runtime.v1.MemoryEventType", MemoryEventType, "MEMORY_EVENT_TYPE_"] },
+            { no: 2, name: "sequence", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 3, name: "bank", kind: "message", T: () => MemoryBankLocator },
+            { no: 4, name: "timestamp", kind: "message", T: () => Timestamp },
+            { no: 10, name: "bank_created", kind: "message", oneof: "detail", T: () => MemoryBank },
+            { no: 11, name: "bank_deleted", kind: "message", oneof: "detail", T: () => MemoryBank },
+            { no: 12, name: "record_retained", kind: "message", oneof: "detail", T: () => MemoryRecord },
+            { no: 13, name: "record_deleted", kind: "message", oneof: "detail", T: () => MemoryDeletedDetail },
+            { no: 14, name: "reflection_completed", kind: "message", oneof: "detail", T: () => MemoryReflectionResult },
+            { no: 15, name: "replication_updated", kind: "message", oneof: "detail", T: () => MemoryReplicationObservedDetail }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.eventType = 0;
+        message.sequence = "0";
+        message.detail = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryEventType event_type */ 1:
+                    message.eventType = reader.int32();
+                    break;
+                case /* uint64 sequence */ 2:
+                    message.sequence = reader.uint64().toString();
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator bank */ 3:
+                    message.bank = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                case /* google.protobuf.Timestamp timestamp */ 4:
+                    message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+                    break;
+                case /* nimi.runtime.v1.MemoryBank bank_created */ 10:
+                    message.detail = {
+                        oneofKind: "bankCreated",
+                        bankCreated: MemoryBank.internalBinaryRead(reader, reader.uint32(), options, message.detail.bankCreated)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryBank bank_deleted */ 11:
+                    message.detail = {
+                        oneofKind: "bankDeleted",
+                        bankDeleted: MemoryBank.internalBinaryRead(reader, reader.uint32(), options, message.detail.bankDeleted)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryRecord record_retained */ 12:
+                    message.detail = {
+                        oneofKind: "recordRetained",
+                        recordRetained: MemoryRecord.internalBinaryRead(reader, reader.uint32(), options, message.detail.recordRetained)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryDeletedDetail record_deleted */ 13:
+                    message.detail = {
+                        oneofKind: "recordDeleted",
+                        recordDeleted: MemoryDeletedDetail.internalBinaryRead(reader, reader.uint32(), options, message.detail.recordDeleted)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryReflectionResult reflection_completed */ 14:
+                    message.detail = {
+                        oneofKind: "reflectionCompleted",
+                        reflectionCompleted: MemoryReflectionResult.internalBinaryRead(reader, reader.uint32(), options, message.detail.reflectionCompleted)
+                    };
+                    break;
+                case /* nimi.runtime.v1.MemoryReplicationObservedDetail replication_updated */ 15:
+                    message.detail = {
+                        oneofKind: "replicationUpdated",
+                        replicationUpdated: MemoryReplicationObservedDetail.internalBinaryRead(reader, reader.uint32(), options, message.detail.replicationUpdated)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryEventType event_type = 1; */
+        if (message.eventType !== 0)
+            writer.tag(1, WireType.Varint).int32(message.eventType);
+        /* uint64 sequence = 2; */
+        if (message.sequence !== "0")
+            writer.tag(2, WireType.Varint).uint64(message.sequence);
+        /* nimi.runtime.v1.MemoryBankLocator bank = 3; */
+        if (message.bank)
+            MemoryBankLocator.internalBinaryWrite(message.bank, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp timestamp = 4; */
+        if (message.timestamp)
+            Timestamp.internalBinaryWrite(message.timestamp, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBank bank_created = 10; */
+        if (message.detail.oneofKind === "bankCreated")
+            MemoryBank.internalBinaryWrite(message.detail.bankCreated, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBank bank_deleted = 11; */
+        if (message.detail.oneofKind === "bankDeleted")
+            MemoryBank.internalBinaryWrite(message.detail.bankDeleted, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryRecord record_retained = 12; */
+        if (message.detail.oneofKind === "recordRetained")
+            MemoryRecord.internalBinaryWrite(message.detail.recordRetained, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryDeletedDetail record_deleted = 13; */
+        if (message.detail.oneofKind === "recordDeleted")
+            MemoryDeletedDetail.internalBinaryWrite(message.detail.recordDeleted, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryReflectionResult reflection_completed = 14; */
+        if (message.detail.oneofKind === "reflectionCompleted")
+            MemoryReflectionResult.internalBinaryWrite(message.detail.reflectionCompleted, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryReplicationObservedDetail replication_updated = 15; */
+        if (message.detail.oneofKind === "replicationUpdated")
+            MemoryReplicationObservedDetail.internalBinaryWrite(message.detail.replicationUpdated, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.MemoryEvent
+ */
+export const MemoryEvent = new MemoryEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateBankRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.CreateBankRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "locator", kind: "message", T: () => PublicMemoryBankLocator },
+            { no: 3, name: "embedding_profile", kind: "message", T: () => MemoryEmbeddingProfile },
+            { no: 4, name: "display_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "metadata", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.displayName = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.PublicMemoryBankLocator locator */ 2:
+                    message.locator = PublicMemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.locator);
+                    break;
+                case /* nimi.runtime.v1.MemoryEmbeddingProfile embedding_profile */ 3:
+                    message.embeddingProfile = MemoryEmbeddingProfile.internalBinaryRead(reader, reader.uint32(), options, message.embeddingProfile);
+                    break;
+                case /* string display_name */ 4:
+                    message.displayName = reader.string();
+                    break;
+                case /* google.protobuf.Struct metadata */ 5:
+                    message.metadata = Struct.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.PublicMemoryBankLocator locator = 2; */
+        if (message.locator)
+            PublicMemoryBankLocator.internalBinaryWrite(message.locator, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryEmbeddingProfile embedding_profile = 3; */
+        if (message.embeddingProfile)
+            MemoryEmbeddingProfile.internalBinaryWrite(message.embeddingProfile, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* string display_name = 4; */
+        if (message.displayName !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.displayName);
+        /* google.protobuf.Struct metadata = 5; */
+        if (message.metadata)
+            Struct.internalBinaryWrite(message.metadata, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.CreateBankRequest
+ */
+export const CreateBankRequest = new CreateBankRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateBankResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.CreateBankResponse", [
+            { no: 1, name: "bank", kind: "message", T: () => MemoryBank }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryBank bank */ 1:
+                    message.bank = MemoryBank.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryBank bank = 1; */
+        if (message.bank)
+            MemoryBank.internalBinaryWrite(message.bank, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.CreateBankResponse
+ */
+export const CreateBankResponse = new CreateBankResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetBankRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.GetBankRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "locator", kind: "message", T: () => MemoryBankLocator }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator locator */ 2:
+                    message.locator = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.locator);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBankLocator locator = 2; */
+        if (message.locator)
+            MemoryBankLocator.internalBinaryWrite(message.locator, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.GetBankRequest
+ */
+export const GetBankRequest = new GetBankRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetBankResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.GetBankResponse", [
+            { no: 1, name: "bank", kind: "message", T: () => MemoryBank }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryBank bank */ 1:
+                    message.bank = MemoryBank.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryBank bank = 1; */
+        if (message.bank)
+            MemoryBank.internalBinaryWrite(message.bank, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.GetBankResponse
+ */
+export const GetBankResponse = new GetBankResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListBanksRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListBanksRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "scope_filters", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["nimi.runtime.v1.MemoryBankScope", MemoryBankScope, "MEMORY_BANK_SCOPE_"] },
+            { no: 3, name: "owner_filters", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryBankOwnerFilter },
+            { no: 4, name: "page_size", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 5, name: "page_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.scopeFilters = [];
+        message.ownerFilters = [];
+        message.pageSize = 0;
+        message.pageToken = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryBankScope scope_filters */ 2:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.scopeFilters.push(reader.int32());
+                    else
+                        message.scopeFilters.push(reader.int32());
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryBankOwnerFilter owner_filters */ 3:
+                    message.ownerFilters.push(MemoryBankOwnerFilter.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* int32 page_size */ 4:
+                    message.pageSize = reader.int32();
+                    break;
+                case /* string page_token */ 5:
+                    message.pageToken = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.MemoryBankScope scope_filters = 2; */
+        if (message.scopeFilters.length) {
+            writer.tag(2, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.scopeFilters.length; i++)
+                writer.int32(message.scopeFilters[i]);
+            writer.join();
+        }
+        /* repeated nimi.runtime.v1.MemoryBankOwnerFilter owner_filters = 3; */
+        for (let i = 0; i < message.ownerFilters.length; i++)
+            MemoryBankOwnerFilter.internalBinaryWrite(message.ownerFilters[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* int32 page_size = 4; */
+        if (message.pageSize !== 0)
+            writer.tag(4, WireType.Varint).int32(message.pageSize);
+        /* string page_token = 5; */
+        if (message.pageToken !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.pageToken);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.ListBanksRequest
+ */
+export const ListBanksRequest = new ListBanksRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListBanksResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListBanksResponse", [
+            { no: 1, name: "banks", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryBank },
+            { no: 2, name: "next_page_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.banks = [];
+        message.nextPageToken = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryBank banks */ 1:
+                    message.banks.push(MemoryBank.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* string next_page_token */ 2:
+                    message.nextPageToken = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryBank banks = 1; */
+        for (let i = 0; i < message.banks.length; i++)
+            MemoryBank.internalBinaryWrite(message.banks[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string next_page_token = 2; */
+        if (message.nextPageToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.nextPageToken);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.ListBanksResponse
+ */
+export const ListBanksResponse = new ListBanksResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteBankRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DeleteBankRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "locator", kind: "message", T: () => PublicMemoryBankLocator }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.PublicMemoryBankLocator locator */ 2:
+                    message.locator = PublicMemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.locator);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.PublicMemoryBankLocator locator = 2; */
+        if (message.locator)
+            PublicMemoryBankLocator.internalBinaryWrite(message.locator, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.DeleteBankRequest
+ */
+export const DeleteBankRequest = new DeleteBankRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteBankResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DeleteBankResponse", [
+            { no: 1, name: "ack", kind: "message", T: () => Ack }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.Ack ack */ 1:
+                    message.ack = Ack.internalBinaryRead(reader, reader.uint32(), options, message.ack);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.Ack ack = 1; */
+        if (message.ack)
+            Ack.internalBinaryWrite(message.ack, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.DeleteBankResponse
+ */
+export const DeleteBankResponse = new DeleteBankResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RetainRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.RetainRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "bank", kind: "message", T: () => MemoryBankLocator },
+            { no: 3, name: "records", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryRecordInput }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.records = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator bank */ 2:
+                    message.bank = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryRecordInput records */ 3:
+                    message.records.push(MemoryRecordInput.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBankLocator bank = 2; */
+        if (message.bank)
+            MemoryBankLocator.internalBinaryWrite(message.bank, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.MemoryRecordInput records = 3; */
+        for (let i = 0; i < message.records.length; i++)
+            MemoryRecordInput.internalBinaryWrite(message.records[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.RetainRequest
+ */
+export const RetainRequest = new RetainRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RetainResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.RetainResponse", [
+            { no: 1, name: "records", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryRecord }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.records = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryRecord records */ 1:
+                    message.records.push(MemoryRecord.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryRecord records = 1; */
+        for (let i = 0; i < message.records.length; i++)
+            MemoryRecord.internalBinaryWrite(message.records[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.RetainResponse
+ */
+export const RetainResponse = new RetainResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RecallRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.RecallRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "bank", kind: "message", T: () => MemoryBankLocator },
+            { no: 3, name: "query", kind: "message", T: () => MemoryRecallQuery }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator bank */ 2:
+                    message.bank = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                case /* nimi.runtime.v1.MemoryRecallQuery query */ 3:
+                    message.query = MemoryRecallQuery.internalBinaryRead(reader, reader.uint32(), options, message.query);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBankLocator bank = 2; */
+        if (message.bank)
+            MemoryBankLocator.internalBinaryWrite(message.bank, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryRecallQuery query = 3; */
+        if (message.query)
+            MemoryRecallQuery.internalBinaryWrite(message.query, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.RecallRequest
+ */
+export const RecallRequest = new RecallRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RecallResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.RecallResponse", [
+            { no: 1, name: "hits", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryRecallHit },
+            { no: 2, name: "narrative_hits", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => NarrativeRecallHit }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.hits = [];
+        message.narrativeHits = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryRecallHit hits */ 1:
+                    message.hits.push(MemoryRecallHit.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated nimi.runtime.v1.NarrativeRecallHit narrative_hits */ 2:
+                    message.narrativeHits.push(NarrativeRecallHit.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryRecallHit hits = 1; */
+        for (let i = 0; i < message.hits.length; i++)
+            MemoryRecallHit.internalBinaryWrite(message.hits[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.NarrativeRecallHit narrative_hits = 2; */
+        for (let i = 0; i < message.narrativeHits.length; i++)
+            NarrativeRecallHit.internalBinaryWrite(message.narrativeHits[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.RecallResponse
+ */
+export const RecallResponse = new RecallResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HistoryRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.HistoryRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "bank", kind: "message", T: () => MemoryBankLocator },
+            { no: 3, name: "query", kind: "message", T: () => MemoryHistoryQuery }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator bank */ 2:
+                    message.bank = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                case /* nimi.runtime.v1.MemoryHistoryQuery query */ 3:
+                    message.query = MemoryHistoryQuery.internalBinaryRead(reader, reader.uint32(), options, message.query);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBankLocator bank = 2; */
+        if (message.bank)
+            MemoryBankLocator.internalBinaryWrite(message.bank, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryHistoryQuery query = 3; */
+        if (message.query)
+            MemoryHistoryQuery.internalBinaryWrite(message.query, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.HistoryRequest
+ */
+export const HistoryRequest = new HistoryRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HistoryResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.HistoryResponse", [
+            { no: 1, name: "records", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryRecord },
+            { no: 2, name: "next_page_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.records = [];
+        message.nextPageToken = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated nimi.runtime.v1.MemoryRecord records */ 1:
+                    message.records.push(MemoryRecord.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* string next_page_token */ 2:
+                    message.nextPageToken = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated nimi.runtime.v1.MemoryRecord records = 1; */
+        for (let i = 0; i < message.records.length; i++)
+            MemoryRecord.internalBinaryWrite(message.records[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string next_page_token = 2; */
+        if (message.nextPageToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.nextPageToken);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.HistoryResponse
+ */
+export const HistoryResponse = new HistoryResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteMemoryRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DeleteMemoryRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "bank", kind: "message", T: () => MemoryBankLocator },
+            { no: 3, name: "memory_ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.memoryIds = [];
+        message.reason = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* nimi.runtime.v1.MemoryBankLocator bank */ 2:
+                    message.bank = MemoryBankLocator.internalBinaryRead(reader, reader.uint32(), options, message.bank);
+                    break;
+                case /* repeated string memory_ids */ 3:
+                    message.memoryIds.push(reader.string());
+                    break;
+                case /* string reason */ 4:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.MemoryBankLocator bank = 2; */
+        if (message.bank)
+            MemoryBankLocator.internalBinaryWrite(message.bank, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string memory_ids = 3; */
+        for (let i = 0; i < message.memoryIds.length; i++)
+            writer.tag(3, WireType.LengthDelimited).string(message.memoryIds[i]);
+        /* string reason = 4; */
+        if (message.reason !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.DeleteMemoryRequest
+ */
+export const DeleteMemoryRequest = new DeleteMemoryRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteMemoryResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DeleteMemoryResponse", [
+            { no: 1, name: "ack", kind: "message", T: () => Ack },
+            { no: 2, name: "deleted_memory_ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.deletedMemoryIds = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.Ack ack */ 1:
+                    message.ack = Ack.internalBinaryRead(reader, reader.uint32(), options, message.ack);
+                    break;
+                case /* repeated string deleted_memory_ids */ 2:
+                    message.deletedMemoryIds.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.Ack ack = 1; */
+        if (message.ack)
+            Ack.internalBinaryWrite(message.ack, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string deleted_memory_ids = 2; */
+        for (let i = 0; i < message.deletedMemoryIds.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.deletedMemoryIds[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.DeleteMemoryResponse
+ */
+export const DeleteMemoryResponse = new DeleteMemoryResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubscribeMemoryEventsRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.SubscribeMemoryEventsRequest", [
+            { no: 1, name: "context", kind: "message", T: () => MemoryRequestContext },
+            { no: 2, name: "scope_filters", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["nimi.runtime.v1.MemoryBankScope", MemoryBankScope, "MEMORY_BANK_SCOPE_"] },
+            { no: 3, name: "owner_filters", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MemoryBankOwnerFilter },
+            { no: 4, name: "cursor", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.scopeFilters = [];
+        message.ownerFilters = [];
+        message.cursor = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* nimi.runtime.v1.MemoryRequestContext context */ 1:
+                    message.context = MemoryRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryBankScope scope_filters */ 2:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.scopeFilters.push(reader.int32());
+                    else
+                        message.scopeFilters.push(reader.int32());
+                    break;
+                case /* repeated nimi.runtime.v1.MemoryBankOwnerFilter owner_filters */ 3:
+                    message.ownerFilters.push(MemoryBankOwnerFilter.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* string cursor */ 4:
+                    message.cursor = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* nimi.runtime.v1.MemoryRequestContext context = 1; */
+        if (message.context)
+            MemoryRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.MemoryBankScope scope_filters = 2; */
+        if (message.scopeFilters.length) {
+            writer.tag(2, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.scopeFilters.length; i++)
+                writer.int32(message.scopeFilters[i]);
+            writer.join();
+        }
+        /* repeated nimi.runtime.v1.MemoryBankOwnerFilter owner_filters = 3; */
+        for (let i = 0; i < message.ownerFilters.length; i++)
+            MemoryBankOwnerFilter.internalBinaryWrite(message.ownerFilters[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* string cursor = 4; */
+        if (message.cursor !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.cursor);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message nimi.runtime.v1.SubscribeMemoryEventsRequest
+ */
+export const SubscribeMemoryEventsRequest = new SubscribeMemoryEventsRequest$Type();
+//# sourceMappingURL=memory.js.map