@nimiplatform/sdk 0.5.14

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

@@ -0,0 +1,2181 @@
+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 { Struct } from "../../google/protobuf/struct.js";
+import { AgentRequestContext } from "./agent_common.js";
+import { Timestamp } from "../../google/protobuf/timestamp.js";
+import { Duration } from "../../google/protobuf/duration.js";
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedProviderKind
+ */
+export var DelegatedProviderKind;
+(function (DelegatedProviderKind) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_KIND_UNSPECIFIED = 0;
+     */
+    DelegatedProviderKind[DelegatedProviderKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_KIND_MCP_TOOL_PROVIDER = 1;
+     */
+    DelegatedProviderKind[DelegatedProviderKind["MCP_TOOL_PROVIDER"] = 1] = "MCP_TOOL_PROVIDER";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_KIND_REMOTE_AGENT_SEAM = 2;
+     */
+    DelegatedProviderKind[DelegatedProviderKind["REMOTE_AGENT_SEAM"] = 2] = "REMOTE_AGENT_SEAM";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_KIND_RUNTIME_NATIVE_PROVIDER = 3;
+     */
+    DelegatedProviderKind[DelegatedProviderKind["RUNTIME_NATIVE_PROVIDER"] = 3] = "RUNTIME_NATIVE_PROVIDER";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_KIND_CONTROLLED_TEST_PROVIDER = 4;
+     */
+    DelegatedProviderKind[DelegatedProviderKind["CONTROLLED_TEST_PROVIDER"] = 4] = "CONTROLLED_TEST_PROVIDER";
+})(DelegatedProviderKind || (DelegatedProviderKind = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedProviderTrustTier
+ */
+export var DelegatedProviderTrustTier;
+(function (DelegatedProviderTrustTier) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_TRUST_TIER_UNSPECIFIED = 0;
+     */
+    DelegatedProviderTrustTier[DelegatedProviderTrustTier["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_TRUST_TIER_CONTROLLED_LOCAL = 1;
+     */
+    DelegatedProviderTrustTier[DelegatedProviderTrustTier["CONTROLLED_LOCAL"] = 1] = "CONTROLLED_LOCAL";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_TRUST_TIER_USER_ADDED_REVIEWED = 2;
+     */
+    DelegatedProviderTrustTier[DelegatedProviderTrustTier["USER_ADDED_REVIEWED"] = 2] = "USER_ADDED_REVIEWED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_TRUST_TIER_ORG_MANAGED = 3;
+     */
+    DelegatedProviderTrustTier[DelegatedProviderTrustTier["ORG_MANAGED"] = 3] = "ORG_MANAGED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_TRUST_TIER_BLOCKED = 4;
+     */
+    DelegatedProviderTrustTier[DelegatedProviderTrustTier["BLOCKED"] = 4] = "BLOCKED";
+})(DelegatedProviderTrustTier || (DelegatedProviderTrustTier = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedProviderState
+ */
+export var DelegatedProviderState;
+(function (DelegatedProviderState) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_UNSPECIFIED = 0;
+     */
+    DelegatedProviderState[DelegatedProviderState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_REGISTERED = 1;
+     */
+    DelegatedProviderState[DelegatedProviderState["REGISTERED"] = 1] = "REGISTERED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_DISCOVERING = 2;
+     */
+    DelegatedProviderState[DelegatedProviderState["DISCOVERING"] = 2] = "DISCOVERING";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_READY = 3;
+     */
+    DelegatedProviderState[DelegatedProviderState["READY"] = 3] = "READY";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_DEGRADED = 4;
+     */
+    DelegatedProviderState[DelegatedProviderState["DEGRADED"] = 4] = "DEGRADED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_DISABLED = 5;
+     */
+    DelegatedProviderState[DelegatedProviderState["DISABLED"] = 5] = "DISABLED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_QUARANTINED = 6;
+     */
+    DelegatedProviderState[DelegatedProviderState["QUARANTINED"] = 6] = "QUARANTINED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_PROVIDER_STATE_REMOVED = 7;
+     */
+    DelegatedProviderState[DelegatedProviderState["REMOVED"] = 7] = "REMOVED";
+})(DelegatedProviderState || (DelegatedProviderState = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedTransportKind
+ */
+export var DelegatedTransportKind;
+(function (DelegatedTransportKind) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRANSPORT_KIND_UNSPECIFIED = 0;
+     */
+    DelegatedTransportKind[DelegatedTransportKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRANSPORT_KIND_STDIO_COMMAND = 1;
+     */
+    DelegatedTransportKind[DelegatedTransportKind["STDIO_COMMAND"] = 1] = "STDIO_COMMAND";
+})(DelegatedTransportKind || (DelegatedTransportKind = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedApprovalMode
+ */
+export var DelegatedApprovalMode;
+(function (DelegatedApprovalMode) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_MODE_UNSPECIFIED = 0;
+     */
+    DelegatedApprovalMode[DelegatedApprovalMode["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_MODE_RUNTIME_POLICY = 1;
+     */
+    DelegatedApprovalMode[DelegatedApprovalMode["RUNTIME_POLICY"] = 1] = "RUNTIME_POLICY";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_MODE_REQUIRE_USER = 2;
+     */
+    DelegatedApprovalMode[DelegatedApprovalMode["REQUIRE_USER"] = 2] = "REQUIRE_USER";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_MODE_DISABLED = 3;
+     */
+    DelegatedApprovalMode[DelegatedApprovalMode["DISABLED"] = 3] = "DISABLED";
+})(DelegatedApprovalMode || (DelegatedApprovalMode = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedApprovalRequestState
+ */
+export var DelegatedApprovalRequestState;
+(function (DelegatedApprovalRequestState) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_REQUEST_STATE_UNSPECIFIED = 0;
+     */
+    DelegatedApprovalRequestState[DelegatedApprovalRequestState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_REQUEST_STATE_PENDING = 1;
+     */
+    DelegatedApprovalRequestState[DelegatedApprovalRequestState["PENDING"] = 1] = "PENDING";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_REQUEST_STATE_APPROVED = 2;
+     */
+    DelegatedApprovalRequestState[DelegatedApprovalRequestState["APPROVED"] = 2] = "APPROVED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_REQUEST_STATE_REJECTED = 3;
+     */
+    DelegatedApprovalRequestState[DelegatedApprovalRequestState["REJECTED"] = 3] = "REJECTED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_REQUEST_STATE_EXPIRED = 4;
+     */
+    DelegatedApprovalRequestState[DelegatedApprovalRequestState["EXPIRED"] = 4] = "EXPIRED";
+})(DelegatedApprovalRequestState || (DelegatedApprovalRequestState = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedApprovalDecision
+ */
+export var DelegatedApprovalDecision;
+(function (DelegatedApprovalDecision) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_DECISION_UNSPECIFIED = 0;
+     */
+    DelegatedApprovalDecision[DelegatedApprovalDecision["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_DECISION_APPROVE = 1;
+     */
+    DelegatedApprovalDecision[DelegatedApprovalDecision["APPROVE"] = 1] = "APPROVE";
+    /**
+     * @generated from protobuf enum value: DELEGATED_APPROVAL_DECISION_REJECT = 2;
+     */
+    DelegatedApprovalDecision[DelegatedApprovalDecision["REJECT"] = 2] = "REJECT";
+})(DelegatedApprovalDecision || (DelegatedApprovalDecision = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedReplayOutcome
+ */
+export var DelegatedReplayOutcome;
+(function (DelegatedReplayOutcome) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_REPLAY_OUTCOME_UNSPECIFIED = 0;
+     */
+    DelegatedReplayOutcome[DelegatedReplayOutcome["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_REPLAY_OUTCOME_RECONSTRUCTED = 1;
+     */
+    DelegatedReplayOutcome[DelegatedReplayOutcome["RECONSTRUCTED"] = 1] = "RECONSTRUCTED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_REPLAY_OUTCOME_PARTIAL_REDACTED = 2;
+     */
+    DelegatedReplayOutcome[DelegatedReplayOutcome["PARTIAL_REDACTED"] = 2] = "PARTIAL_REDACTED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_REPLAY_OUTCOME_PARTIAL_MISSING_EVIDENCE = 3;
+     */
+    DelegatedReplayOutcome[DelegatedReplayOutcome["PARTIAL_MISSING_EVIDENCE"] = 3] = "PARTIAL_MISSING_EVIDENCE";
+    /**
+     * @generated from protobuf enum value: DELEGATED_REPLAY_OUTCOME_BLOCKED_BY_POLICY = 4;
+     */
+    DelegatedReplayOutcome[DelegatedReplayOutcome["BLOCKED_BY_POLICY"] = 4] = "BLOCKED_BY_POLICY";
+    /**
+     * @generated from protobuf enum value: DELEGATED_REPLAY_OUTCOME_INVALID_LINEAGE = 5;
+     */
+    DelegatedReplayOutcome[DelegatedReplayOutcome["INVALID_LINEAGE"] = 5] = "INVALID_LINEAGE";
+})(DelegatedReplayOutcome || (DelegatedReplayOutcome = {}));
+/**
+ * @generated from protobuf enum nimi.runtime.v1.DelegatedTraceStageKind
+ */
+export var DelegatedTraceStageKind;
+(function (DelegatedTraceStageKind) {
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_UNSPECIFIED = 0;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_REQUEST = 1;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["REQUEST"] = 1] = "REQUEST";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_GATEWAY_EVIDENCE = 2;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["GATEWAY_EVIDENCE"] = 2] = "GATEWAY_EVIDENCE";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_FIREWALL_VERDICT = 3;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["FIREWALL_VERDICT"] = 3] = "FIREWALL_VERDICT";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_APPROVAL_DECISION = 4;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["APPROVAL_DECISION"] = 4] = "APPROVAL_DECISION";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_RUNTIME_DECISION = 5;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["RUNTIME_DECISION"] = 5] = "RUNTIME_DECISION";
+    /**
+     * @generated from protobuf enum value: DELEGATED_TRACE_STAGE_KIND_PROJECTION_DISPOSITION = 6;
+     */
+    DelegatedTraceStageKind[DelegatedTraceStageKind["PROJECTION_DISPOSITION"] = 6] = "PROJECTION_DISPOSITION";
+})(DelegatedTraceStageKind || (DelegatedTraceStageKind = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedToolAllowlistEntry$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedToolAllowlistEntry", [
+            { no: 1, name: "tool_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "input_schema_digest", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.toolName = "";
+        message.inputSchemaDigest = "";
+        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 tool_name */ 1:
+                    message.toolName = reader.string();
+                    break;
+                case /* string input_schema_digest */ 2:
+                    message.inputSchemaDigest = 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 tool_name = 1; */
+        if (message.toolName !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.toolName);
+        /* string input_schema_digest = 2; */
+        if (message.inputSchemaDigest !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.inputSchemaDigest);
+        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.DelegatedToolAllowlistEntry
+ */
+export const DelegatedToolAllowlistEntry = new DelegatedToolAllowlistEntry$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedProviderProfile$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedProviderProfile", [
+            { no: 1, name: "provider_profile_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "display_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "provider_kind", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedProviderKind", DelegatedProviderKind, "DELEGATED_PROVIDER_KIND_"] },
+            { no: 4, name: "transport_kind", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedTransportKind", DelegatedTransportKind, "DELEGATED_TRANSPORT_KIND_"] },
+            { no: 5, name: "state", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedProviderState", DelegatedProviderState, "DELEGATED_PROVIDER_STATE_"] },
+            { no: 6, name: "allowed_tools", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedToolAllowlistEntry },
+            { no: 7, name: "credential_ref", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "timeout", kind: "message", T: () => Duration },
+            { no: 9, name: "created_at", kind: "message", T: () => Timestamp },
+            { no: 10, name: "updated_at", kind: "message", T: () => Timestamp },
+            { no: 11, name: "transport_ref", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 12, name: "trust_tier", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedProviderTrustTier", DelegatedProviderTrustTier, "DELEGATED_PROVIDER_TRUST_TIER_"] },
+            { no: 13, name: "lifecycle_reason_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 14, name: "command", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 15, name: "args", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.providerProfileId = "";
+        message.displayName = "";
+        message.providerKind = 0;
+        message.transportKind = 0;
+        message.state = 0;
+        message.allowedTools = [];
+        message.credentialRef = "";
+        message.transportRef = "";
+        message.trustTier = 0;
+        message.lifecycleReasonCode = "";
+        message.command = "";
+        message.args = [];
+        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_profile_id */ 1:
+                    message.providerProfileId = reader.string();
+                    break;
+                case /* string display_name */ 2:
+                    message.displayName = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedProviderKind provider_kind */ 3:
+                    message.providerKind = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.DelegatedTransportKind transport_kind */ 4:
+                    message.transportKind = reader.int32();
+                    break;
+                case /* nimi.runtime.v1.DelegatedProviderState state */ 5:
+                    message.state = reader.int32();
+                    break;
+                case /* repeated nimi.runtime.v1.DelegatedToolAllowlistEntry allowed_tools */ 6:
+                    message.allowedTools.push(DelegatedToolAllowlistEntry.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* string credential_ref */ 7:
+                    message.credentialRef = reader.string();
+                    break;
+                case /* google.protobuf.Duration timeout */ 8:
+                    message.timeout = Duration.internalBinaryRead(reader, reader.uint32(), options, message.timeout);
+                    break;
+                case /* google.protobuf.Timestamp created_at */ 9:
+                    message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
+                    break;
+                case /* google.protobuf.Timestamp updated_at */ 10:
+                    message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
+                    break;
+                case /* string transport_ref */ 11:
+                    message.transportRef = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedProviderTrustTier trust_tier */ 12:
+                    message.trustTier = reader.int32();
+                    break;
+                case /* string lifecycle_reason_code */ 13:
+                    message.lifecycleReasonCode = reader.string();
+                    break;
+                case /* string command */ 14:
+                    message.command = reader.string();
+                    break;
+                case /* repeated string args */ 15:
+                    message.args.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 provider_profile_id = 1; */
+        if (message.providerProfileId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.providerProfileId);
+        /* string display_name = 2; */
+        if (message.displayName !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.displayName);
+        /* nimi.runtime.v1.DelegatedProviderKind provider_kind = 3; */
+        if (message.providerKind !== 0)
+            writer.tag(3, WireType.Varint).int32(message.providerKind);
+        /* nimi.runtime.v1.DelegatedTransportKind transport_kind = 4; */
+        if (message.transportKind !== 0)
+            writer.tag(4, WireType.Varint).int32(message.transportKind);
+        /* nimi.runtime.v1.DelegatedProviderState state = 5; */
+        if (message.state !== 0)
+            writer.tag(5, WireType.Varint).int32(message.state);
+        /* repeated nimi.runtime.v1.DelegatedToolAllowlistEntry allowed_tools = 6; */
+        for (let i = 0; i < message.allowedTools.length; i++)
+            DelegatedToolAllowlistEntry.internalBinaryWrite(message.allowedTools[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* string credential_ref = 7; */
+        if (message.credentialRef !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.credentialRef);
+        /* google.protobuf.Duration timeout = 8; */
+        if (message.timeout)
+            Duration.internalBinaryWrite(message.timeout, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp created_at = 9; */
+        if (message.createdAt)
+            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp updated_at = 10; */
+        if (message.updatedAt)
+            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* string transport_ref = 11; */
+        if (message.transportRef !== "")
+            writer.tag(11, WireType.LengthDelimited).string(message.transportRef);
+        /* nimi.runtime.v1.DelegatedProviderTrustTier trust_tier = 12; */
+        if (message.trustTier !== 0)
+            writer.tag(12, WireType.Varint).int32(message.trustTier);
+        /* string lifecycle_reason_code = 13; */
+        if (message.lifecycleReasonCode !== "")
+            writer.tag(13, WireType.LengthDelimited).string(message.lifecycleReasonCode);
+        /* string command = 14; */
+        if (message.command !== "")
+            writer.tag(14, WireType.LengthDelimited).string(message.command);
+        /* repeated string args = 15; */
+        for (let i = 0; i < message.args.length; i++)
+            writer.tag(15, WireType.LengthDelimited).string(message.args[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.DelegatedProviderProfile
+ */
+export const DelegatedProviderProfile = new DelegatedProviderProfile$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedControlSurfaceSnapshot$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedControlSurfaceSnapshot", [
+            { no: 1, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "approval_mode", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedApprovalMode", DelegatedApprovalMode, "DELEGATED_APPROVAL_MODE_"] },
+            { no: 4, name: "provider_profiles", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedProviderProfile },
+            { no: 5, name: "approval_requests", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedApprovalRequest },
+            { no: 6, name: "diagnostics", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedDiagnostic },
+            { no: 7, name: "observed_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        message.approvalMode = 0;
+        message.providerProfiles = [];
+        message.approvalRequests = [];
+        message.diagnostics = [];
+        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 conversation_anchor_id */ 2:
+                    message.conversationAnchorId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedApprovalMode approval_mode */ 3:
+                    message.approvalMode = reader.int32();
+                    break;
+                case /* repeated nimi.runtime.v1.DelegatedProviderProfile provider_profiles */ 4:
+                    message.providerProfiles.push(DelegatedProviderProfile.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated nimi.runtime.v1.DelegatedApprovalRequest approval_requests */ 5:
+                    message.approvalRequests.push(DelegatedApprovalRequest.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated nimi.runtime.v1.DelegatedDiagnostic diagnostics */ 6:
+                    message.diagnostics.push(DelegatedDiagnostic.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* google.protobuf.Timestamp observed_at */ 7:
+                    message.observedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.observedAt);
+                    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 conversation_anchor_id = 2; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.conversationAnchorId);
+        /* nimi.runtime.v1.DelegatedApprovalMode approval_mode = 3; */
+        if (message.approvalMode !== 0)
+            writer.tag(3, WireType.Varint).int32(message.approvalMode);
+        /* repeated nimi.runtime.v1.DelegatedProviderProfile provider_profiles = 4; */
+        for (let i = 0; i < message.providerProfiles.length; i++)
+            DelegatedProviderProfile.internalBinaryWrite(message.providerProfiles[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.DelegatedApprovalRequest approval_requests = 5; */
+        for (let i = 0; i < message.approvalRequests.length; i++)
+            DelegatedApprovalRequest.internalBinaryWrite(message.approvalRequests[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated nimi.runtime.v1.DelegatedDiagnostic diagnostics = 6; */
+        for (let i = 0; i < message.diagnostics.length; i++)
+            DelegatedDiagnostic.internalBinaryWrite(message.diagnostics[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp observed_at = 7; */
+        if (message.observedAt)
+            Timestamp.internalBinaryWrite(message.observedAt, writer.tag(7, 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.DelegatedControlSurfaceSnapshot
+ */
+export const DelegatedControlSurfaceSnapshot = new DelegatedControlSurfaceSnapshot$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListDelegatedProviderProfilesRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListDelegatedProviderProfilesRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, 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 /* nimi.runtime.v1.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    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) {
+        /* nimi.runtime.v1.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, 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.ListDelegatedProviderProfilesRequest
+ */
+export const ListDelegatedProviderProfilesRequest = new ListDelegatedProviderProfilesRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListDelegatedProviderProfilesResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListDelegatedProviderProfilesResponse", [
+            { no: 1, name: "provider_profiles", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedProviderProfile }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.providerProfiles = [];
+        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.DelegatedProviderProfile provider_profiles */ 1:
+                    message.providerProfiles.push(DelegatedProviderProfile.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.DelegatedProviderProfile provider_profiles = 1; */
+        for (let i = 0; i < message.providerProfiles.length; i++)
+            DelegatedProviderProfile.internalBinaryWrite(message.providerProfiles[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.ListDelegatedProviderProfilesResponse
+ */
+export const ListDelegatedProviderProfilesResponse = new ListDelegatedProviderProfilesResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpsertDelegatedProviderProfileRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.UpsertDelegatedProviderProfileRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "provider_profile", kind: "message", T: () => DelegatedProviderProfile }
+        ]);
+    }
+    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 /* nimi.runtime.v1.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedProviderProfile provider_profile */ 3:
+                    message.providerProfile = DelegatedProviderProfile.internalBinaryRead(reader, reader.uint32(), options, message.providerProfile);
+                    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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* nimi.runtime.v1.DelegatedProviderProfile provider_profile = 3; */
+        if (message.providerProfile)
+            DelegatedProviderProfile.internalBinaryWrite(message.providerProfile, 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.UpsertDelegatedProviderProfileRequest
+ */
+export const UpsertDelegatedProviderProfileRequest = new UpsertDelegatedProviderProfileRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpsertDelegatedProviderProfileResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.UpsertDelegatedProviderProfileResponse", [
+            { no: 1, name: "provider_profile", kind: "message", T: () => DelegatedProviderProfile }
+        ]);
+    }
+    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.DelegatedProviderProfile provider_profile */ 1:
+                    message.providerProfile = DelegatedProviderProfile.internalBinaryRead(reader, reader.uint32(), options, message.providerProfile);
+                    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.DelegatedProviderProfile provider_profile = 1; */
+        if (message.providerProfile)
+            DelegatedProviderProfile.internalBinaryWrite(message.providerProfile, 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.UpsertDelegatedProviderProfileResponse
+ */
+export const UpsertDelegatedProviderProfileResponse = new UpsertDelegatedProviderProfileResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SetDelegatedProviderStateRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.SetDelegatedProviderStateRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "provider_profile_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "state", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedProviderState", DelegatedProviderState, "DELEGATED_PROVIDER_STATE_"] },
+            { no: 5, name: "lifecycle_reason_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.providerProfileId = "";
+        message.state = 0;
+        message.lifecycleReasonCode = "";
+        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.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string provider_profile_id */ 3:
+                    message.providerProfileId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedProviderState state */ 4:
+                    message.state = reader.int32();
+                    break;
+                case /* string lifecycle_reason_code */ 5:
+                    message.lifecycleReasonCode = 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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string provider_profile_id = 3; */
+        if (message.providerProfileId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.providerProfileId);
+        /* nimi.runtime.v1.DelegatedProviderState state = 4; */
+        if (message.state !== 0)
+            writer.tag(4, WireType.Varint).int32(message.state);
+        /* string lifecycle_reason_code = 5; */
+        if (message.lifecycleReasonCode !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.lifecycleReasonCode);
+        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.SetDelegatedProviderStateRequest
+ */
+export const SetDelegatedProviderStateRequest = new SetDelegatedProviderStateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SetDelegatedProviderStateResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.SetDelegatedProviderStateResponse", [
+            { no: 1, name: "provider_profile", kind: "message", T: () => DelegatedProviderProfile }
+        ]);
+    }
+    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.DelegatedProviderProfile provider_profile */ 1:
+                    message.providerProfile = DelegatedProviderProfile.internalBinaryRead(reader, reader.uint32(), options, message.providerProfile);
+                    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.DelegatedProviderProfile provider_profile = 1; */
+        if (message.providerProfile)
+            DelegatedProviderProfile.internalBinaryWrite(message.providerProfile, 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.SetDelegatedProviderStateResponse
+ */
+export const SetDelegatedProviderStateResponse = new SetDelegatedProviderStateResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedApprovalRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedApprovalRequest", [
+            { no: 1, name: "approval_request_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "turn_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "provider_profile_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "capability_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "tool_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "firewall_verdict", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "reason_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "state", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedApprovalRequestState", DelegatedApprovalRequestState, "DELEGATED_APPROVAL_REQUEST_STATE_"] },
+            { no: 11, name: "detail", kind: "message", T: () => Struct },
+            { no: 12, name: "created_at", kind: "message", T: () => Timestamp },
+            { no: 13, name: "updated_at", kind: "message", T: () => Timestamp },
+            { no: 14, name: "expires_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.approvalRequestId = "";
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        message.turnId = "";
+        message.providerProfileId = "";
+        message.capabilityId = "";
+        message.toolName = "";
+        message.firewallVerdict = "";
+        message.reasonCode = "";
+        message.state = 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 approval_request_id */ 1:
+                    message.approvalRequestId = reader.string();
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = reader.string();
+                    break;
+                case /* string turn_id */ 4:
+                    message.turnId = reader.string();
+                    break;
+                case /* string provider_profile_id */ 5:
+                    message.providerProfileId = reader.string();
+                    break;
+                case /* string capability_id */ 6:
+                    message.capabilityId = reader.string();
+                    break;
+                case /* string tool_name */ 7:
+                    message.toolName = reader.string();
+                    break;
+                case /* string firewall_verdict */ 8:
+                    message.firewallVerdict = reader.string();
+                    break;
+                case /* string reason_code */ 9:
+                    message.reasonCode = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedApprovalRequestState state */ 10:
+                    message.state = reader.int32();
+                    break;
+                case /* google.protobuf.Struct detail */ 11:
+                    message.detail = Struct.internalBinaryRead(reader, reader.uint32(), options, message.detail);
+                    break;
+                case /* google.protobuf.Timestamp created_at */ 12:
+                    message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
+                    break;
+                case /* google.protobuf.Timestamp updated_at */ 13:
+                    message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
+                    break;
+                case /* google.protobuf.Timestamp expires_at */ 14:
+                    message.expiresAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.expiresAt);
+                    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 approval_request_id = 1; */
+        if (message.approvalRequestId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.approvalRequestId);
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        /* string turn_id = 4; */
+        if (message.turnId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.turnId);
+        /* string provider_profile_id = 5; */
+        if (message.providerProfileId !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.providerProfileId);
+        /* string capability_id = 6; */
+        if (message.capabilityId !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.capabilityId);
+        /* string tool_name = 7; */
+        if (message.toolName !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.toolName);
+        /* string firewall_verdict = 8; */
+        if (message.firewallVerdict !== "")
+            writer.tag(8, WireType.LengthDelimited).string(message.firewallVerdict);
+        /* string reason_code = 9; */
+        if (message.reasonCode !== "")
+            writer.tag(9, WireType.LengthDelimited).string(message.reasonCode);
+        /* nimi.runtime.v1.DelegatedApprovalRequestState state = 10; */
+        if (message.state !== 0)
+            writer.tag(10, WireType.Varint).int32(message.state);
+        /* google.protobuf.Struct detail = 11; */
+        if (message.detail)
+            Struct.internalBinaryWrite(message.detail, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp created_at = 12; */
+        if (message.createdAt)
+            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp updated_at = 13; */
+        if (message.updatedAt)
+            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp expires_at = 14; */
+        if (message.expiresAt)
+            Timestamp.internalBinaryWrite(message.expiresAt, writer.tag(14, 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.DelegatedApprovalRequest
+ */
+export const DelegatedApprovalRequest = new DelegatedApprovalRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListDelegatedApprovalRequestsRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListDelegatedApprovalRequestsRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        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.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = 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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        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.ListDelegatedApprovalRequestsRequest
+ */
+export const ListDelegatedApprovalRequestsRequest = new ListDelegatedApprovalRequestsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListDelegatedApprovalRequestsResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListDelegatedApprovalRequestsResponse", [
+            { no: 1, name: "approval_requests", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedApprovalRequest }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.approvalRequests = [];
+        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.DelegatedApprovalRequest approval_requests */ 1:
+                    message.approvalRequests.push(DelegatedApprovalRequest.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.DelegatedApprovalRequest approval_requests = 1; */
+        for (let i = 0; i < message.approvalRequests.length; i++)
+            DelegatedApprovalRequest.internalBinaryWrite(message.approvalRequests[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.ListDelegatedApprovalRequestsResponse
+ */
+export const ListDelegatedApprovalRequestsResponse = new ListDelegatedApprovalRequestsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubmitDelegatedApprovalDecisionRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.SubmitDelegatedApprovalDecisionRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "approval_request_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "decision", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedApprovalDecision", DelegatedApprovalDecision, "DELEGATED_APPROVAL_DECISION_"] },
+            { no: 5, name: "decision_reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.approvalRequestId = "";
+        message.decision = 0;
+        message.decisionReason = "";
+        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.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string approval_request_id */ 3:
+                    message.approvalRequestId = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedApprovalDecision decision */ 4:
+                    message.decision = reader.int32();
+                    break;
+                case /* string decision_reason */ 5:
+                    message.decisionReason = 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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string approval_request_id = 3; */
+        if (message.approvalRequestId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.approvalRequestId);
+        /* nimi.runtime.v1.DelegatedApprovalDecision decision = 4; */
+        if (message.decision !== 0)
+            writer.tag(4, WireType.Varint).int32(message.decision);
+        /* string decision_reason = 5; */
+        if (message.decisionReason !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.decisionReason);
+        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.SubmitDelegatedApprovalDecisionRequest
+ */
+export const SubmitDelegatedApprovalDecisionRequest = new SubmitDelegatedApprovalDecisionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubmitDelegatedApprovalDecisionResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.SubmitDelegatedApprovalDecisionResponse", [
+            { no: 1, name: "approval_request", kind: "message", T: () => DelegatedApprovalRequest }
+        ]);
+    }
+    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.DelegatedApprovalRequest approval_request */ 1:
+                    message.approvalRequest = DelegatedApprovalRequest.internalBinaryRead(reader, reader.uint32(), options, message.approvalRequest);
+                    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.DelegatedApprovalRequest approval_request = 1; */
+        if (message.approvalRequest)
+            DelegatedApprovalRequest.internalBinaryWrite(message.approvalRequest, 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.SubmitDelegatedApprovalDecisionResponse
+ */
+export const SubmitDelegatedApprovalDecisionResponse = new SubmitDelegatedApprovalDecisionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedDiagnostic$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedDiagnostic", [
+            { no: 1, name: "diagnostic_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "turn_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "provider_profile_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "capability_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "tool_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "gateway_evidence_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "firewall_input_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "firewall_verdict", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 11, name: "runtime_decision", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 12, name: "reason_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 13, name: "observed_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.diagnosticId = "";
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        message.turnId = "";
+        message.providerProfileId = "";
+        message.capabilityId = "";
+        message.toolName = "";
+        message.gatewayEvidenceId = "";
+        message.firewallInputId = "";
+        message.firewallVerdict = "";
+        message.runtimeDecision = "";
+        message.reasonCode = "";
+        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 diagnostic_id */ 1:
+                    message.diagnosticId = reader.string();
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = reader.string();
+                    break;
+                case /* string turn_id */ 4:
+                    message.turnId = reader.string();
+                    break;
+                case /* string provider_profile_id */ 5:
+                    message.providerProfileId = reader.string();
+                    break;
+                case /* string capability_id */ 6:
+                    message.capabilityId = reader.string();
+                    break;
+                case /* string tool_name */ 7:
+                    message.toolName = reader.string();
+                    break;
+                case /* string gateway_evidence_id */ 8:
+                    message.gatewayEvidenceId = reader.string();
+                    break;
+                case /* string firewall_input_id */ 9:
+                    message.firewallInputId = reader.string();
+                    break;
+                case /* string firewall_verdict */ 10:
+                    message.firewallVerdict = reader.string();
+                    break;
+                case /* string runtime_decision */ 11:
+                    message.runtimeDecision = reader.string();
+                    break;
+                case /* string reason_code */ 12:
+                    message.reasonCode = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp observed_at */ 13:
+                    message.observedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.observedAt);
+                    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 diagnostic_id = 1; */
+        if (message.diagnosticId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.diagnosticId);
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        /* string turn_id = 4; */
+        if (message.turnId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.turnId);
+        /* string provider_profile_id = 5; */
+        if (message.providerProfileId !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.providerProfileId);
+        /* string capability_id = 6; */
+        if (message.capabilityId !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.capabilityId);
+        /* string tool_name = 7; */
+        if (message.toolName !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.toolName);
+        /* string gateway_evidence_id = 8; */
+        if (message.gatewayEvidenceId !== "")
+            writer.tag(8, WireType.LengthDelimited).string(message.gatewayEvidenceId);
+        /* string firewall_input_id = 9; */
+        if (message.firewallInputId !== "")
+            writer.tag(9, WireType.LengthDelimited).string(message.firewallInputId);
+        /* string firewall_verdict = 10; */
+        if (message.firewallVerdict !== "")
+            writer.tag(10, WireType.LengthDelimited).string(message.firewallVerdict);
+        /* string runtime_decision = 11; */
+        if (message.runtimeDecision !== "")
+            writer.tag(11, WireType.LengthDelimited).string(message.runtimeDecision);
+        /* string reason_code = 12; */
+        if (message.reasonCode !== "")
+            writer.tag(12, WireType.LengthDelimited).string(message.reasonCode);
+        /* google.protobuf.Timestamp observed_at = 13; */
+        if (message.observedAt)
+            Timestamp.internalBinaryWrite(message.observedAt, 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.DelegatedDiagnostic
+ */
+export const DelegatedDiagnostic = new DelegatedDiagnostic$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedReplayTraceStage$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedReplayTraceStage", [
+            { no: 1, name: "kind", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedTraceStageKind", DelegatedTraceStageKind, "DELEGATED_TRACE_STAGE_KIND_"] },
+            { no: 2, name: "stage_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "state", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "reason_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "redacted_summary", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "observed_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.stageId = "";
+        message.state = "";
+        message.reasonCode = "";
+        message.redactedSummary = "";
+        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.DelegatedTraceStageKind kind */ 1:
+                    message.kind = reader.int32();
+                    break;
+                case /* string stage_id */ 2:
+                    message.stageId = reader.string();
+                    break;
+                case /* string state */ 3:
+                    message.state = reader.string();
+                    break;
+                case /* string reason_code */ 4:
+                    message.reasonCode = reader.string();
+                    break;
+                case /* string redacted_summary */ 5:
+                    message.redactedSummary = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp observed_at */ 6:
+                    message.observedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.observedAt);
+                    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.DelegatedTraceStageKind kind = 1; */
+        if (message.kind !== 0)
+            writer.tag(1, WireType.Varint).int32(message.kind);
+        /* string stage_id = 2; */
+        if (message.stageId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.stageId);
+        /* string state = 3; */
+        if (message.state !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.state);
+        /* string reason_code = 4; */
+        if (message.reasonCode !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.reasonCode);
+        /* string redacted_summary = 5; */
+        if (message.redactedSummary !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.redactedSummary);
+        /* google.protobuf.Timestamp observed_at = 6; */
+        if (message.observedAt)
+            Timestamp.internalBinaryWrite(message.observedAt, 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.DelegatedReplayTraceStage
+ */
+export const DelegatedReplayTraceStage = new DelegatedReplayTraceStage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DelegatedReplayTrace$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.DelegatedReplayTrace", [
+            { no: 1, name: "replay_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "turn_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "provider_profile_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "capability_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "tool_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "outcome", kind: "enum", T: () => ["nimi.runtime.v1.DelegatedReplayOutcome", DelegatedReplayOutcome, "DELEGATED_REPLAY_OUTCOME_"] },
+            { no: 9, name: "reason_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "stages", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedReplayTraceStage },
+            { no: 11, name: "projection_disposition", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 12, name: "action_disposition", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 13, name: "redacted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 14, name: "observed_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replayId = "";
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        message.turnId = "";
+        message.providerProfileId = "";
+        message.capabilityId = "";
+        message.toolName = "";
+        message.outcome = 0;
+        message.reasonCode = "";
+        message.stages = [];
+        message.projectionDisposition = "";
+        message.actionDisposition = "";
+        message.redacted = 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 replay_id */ 1:
+                    message.replayId = reader.string();
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = reader.string();
+                    break;
+                case /* string turn_id */ 4:
+                    message.turnId = reader.string();
+                    break;
+                case /* string provider_profile_id */ 5:
+                    message.providerProfileId = reader.string();
+                    break;
+                case /* string capability_id */ 6:
+                    message.capabilityId = reader.string();
+                    break;
+                case /* string tool_name */ 7:
+                    message.toolName = reader.string();
+                    break;
+                case /* nimi.runtime.v1.DelegatedReplayOutcome outcome */ 8:
+                    message.outcome = reader.int32();
+                    break;
+                case /* string reason_code */ 9:
+                    message.reasonCode = reader.string();
+                    break;
+                case /* repeated nimi.runtime.v1.DelegatedReplayTraceStage stages */ 10:
+                    message.stages.push(DelegatedReplayTraceStage.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* string projection_disposition */ 11:
+                    message.projectionDisposition = reader.string();
+                    break;
+                case /* string action_disposition */ 12:
+                    message.actionDisposition = reader.string();
+                    break;
+                case /* bool redacted */ 13:
+                    message.redacted = reader.bool();
+                    break;
+                case /* google.protobuf.Timestamp observed_at */ 14:
+                    message.observedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.observedAt);
+                    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 replay_id = 1; */
+        if (message.replayId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replayId);
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        /* string turn_id = 4; */
+        if (message.turnId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.turnId);
+        /* string provider_profile_id = 5; */
+        if (message.providerProfileId !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.providerProfileId);
+        /* string capability_id = 6; */
+        if (message.capabilityId !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.capabilityId);
+        /* string tool_name = 7; */
+        if (message.toolName !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.toolName);
+        /* nimi.runtime.v1.DelegatedReplayOutcome outcome = 8; */
+        if (message.outcome !== 0)
+            writer.tag(8, WireType.Varint).int32(message.outcome);
+        /* string reason_code = 9; */
+        if (message.reasonCode !== "")
+            writer.tag(9, WireType.LengthDelimited).string(message.reasonCode);
+        /* repeated nimi.runtime.v1.DelegatedReplayTraceStage stages = 10; */
+        for (let i = 0; i < message.stages.length; i++)
+            DelegatedReplayTraceStage.internalBinaryWrite(message.stages[i], writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* string projection_disposition = 11; */
+        if (message.projectionDisposition !== "")
+            writer.tag(11, WireType.LengthDelimited).string(message.projectionDisposition);
+        /* string action_disposition = 12; */
+        if (message.actionDisposition !== "")
+            writer.tag(12, WireType.LengthDelimited).string(message.actionDisposition);
+        /* bool redacted = 13; */
+        if (message.redacted !== false)
+            writer.tag(13, WireType.Varint).bool(message.redacted);
+        /* google.protobuf.Timestamp observed_at = 14; */
+        if (message.observedAt)
+            Timestamp.internalBinaryWrite(message.observedAt, writer.tag(14, 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.DelegatedReplayTrace
+ */
+export const DelegatedReplayTrace = new DelegatedReplayTrace$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListDelegatedDiagnosticsRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListDelegatedDiagnosticsRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        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.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = 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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        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.ListDelegatedDiagnosticsRequest
+ */
+export const ListDelegatedDiagnosticsRequest = new ListDelegatedDiagnosticsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListDelegatedDiagnosticsResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ListDelegatedDiagnosticsResponse", [
+            { no: 1, name: "diagnostics", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DelegatedDiagnostic }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.diagnostics = [];
+        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.DelegatedDiagnostic diagnostics */ 1:
+                    message.diagnostics.push(DelegatedDiagnostic.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.DelegatedDiagnostic diagnostics = 1; */
+        for (let i = 0; i < message.diagnostics.length; i++)
+            DelegatedDiagnostic.internalBinaryWrite(message.diagnostics[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.ListDelegatedDiagnosticsResponse
+ */
+export const ListDelegatedDiagnosticsResponse = new ListDelegatedDiagnosticsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetDelegatedReplayTraceRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.GetDelegatedReplayTraceRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "decision_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "turn_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.decisionId = "";
+        message.conversationAnchorId = "";
+        message.turnId = "";
+        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.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string decision_id */ 3:
+                    message.decisionId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 4:
+                    message.conversationAnchorId = reader.string();
+                    break;
+                case /* string turn_id */ 5:
+                    message.turnId = 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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string decision_id = 3; */
+        if (message.decisionId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.decisionId);
+        /* string conversation_anchor_id = 4; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.conversationAnchorId);
+        /* string turn_id = 5; */
+        if (message.turnId !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.turnId);
+        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.GetDelegatedReplayTraceRequest
+ */
+export const GetDelegatedReplayTraceRequest = new GetDelegatedReplayTraceRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetDelegatedReplayTraceResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.GetDelegatedReplayTraceResponse", [
+            { no: 1, name: "trace", kind: "message", T: () => DelegatedReplayTrace }
+        ]);
+    }
+    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.DelegatedReplayTrace trace */ 1:
+                    message.trace = DelegatedReplayTrace.internalBinaryRead(reader, reader.uint32(), options, message.trace);
+                    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.DelegatedReplayTrace trace = 1; */
+        if (message.trace)
+            DelegatedReplayTrace.internalBinaryWrite(message.trace, 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.GetDelegatedReplayTraceResponse
+ */
+export const GetDelegatedReplayTraceResponse = new GetDelegatedReplayTraceResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetDelegatedControlSurfaceSnapshotRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.GetDelegatedControlSurfaceSnapshotRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        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.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = 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.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        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.GetDelegatedControlSurfaceSnapshotRequest
+ */
+export const GetDelegatedControlSurfaceSnapshotRequest = new GetDelegatedControlSurfaceSnapshotRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetDelegatedControlSurfaceSnapshotResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.GetDelegatedControlSurfaceSnapshotResponse", [
+            { no: 1, name: "snapshot", kind: "message", T: () => DelegatedControlSurfaceSnapshot }
+        ]);
+    }
+    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.DelegatedControlSurfaceSnapshot snapshot */ 1:
+                    message.snapshot = DelegatedControlSurfaceSnapshot.internalBinaryRead(reader, reader.uint32(), options, message.snapshot);
+                    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.DelegatedControlSurfaceSnapshot snapshot = 1; */
+        if (message.snapshot)
+            DelegatedControlSurfaceSnapshot.internalBinaryWrite(message.snapshot, 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.GetDelegatedControlSurfaceSnapshotResponse
+ */
+export const GetDelegatedControlSurfaceSnapshotResponse = new GetDelegatedControlSurfaceSnapshotResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecuteDelegatedCapabilityRequest$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ExecuteDelegatedCapabilityRequest", [
+            { no: 1, name: "context", kind: "message", T: () => AgentRequestContext },
+            { no: 2, name: "agent_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "conversation_anchor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "turn_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "stream_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "request_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "provider_profile_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "capability_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "tool_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "arguments", kind: "message", T: () => Struct },
+            { no: 11, name: "descriptor_hash", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 12, name: "protocol_revision", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 13, name: "output_kind", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 14, name: "requires_approval", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.agentId = "";
+        message.conversationAnchorId = "";
+        message.turnId = "";
+        message.streamId = "";
+        message.requestId = "";
+        message.providerProfileId = "";
+        message.capabilityId = "";
+        message.toolName = "";
+        message.descriptorHash = "";
+        message.protocolRevision = "";
+        message.outputKind = "";
+        message.requiresApproval = 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 /* nimi.runtime.v1.AgentRequestContext context */ 1:
+                    message.context = AgentRequestContext.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                case /* string agent_id */ 2:
+                    message.agentId = reader.string();
+                    break;
+                case /* string conversation_anchor_id */ 3:
+                    message.conversationAnchorId = reader.string();
+                    break;
+                case /* string turn_id */ 4:
+                    message.turnId = reader.string();
+                    break;
+                case /* string stream_id */ 5:
+                    message.streamId = reader.string();
+                    break;
+                case /* string request_id */ 6:
+                    message.requestId = reader.string();
+                    break;
+                case /* string provider_profile_id */ 7:
+                    message.providerProfileId = reader.string();
+                    break;
+                case /* string capability_id */ 8:
+                    message.capabilityId = reader.string();
+                    break;
+                case /* string tool_name */ 9:
+                    message.toolName = reader.string();
+                    break;
+                case /* google.protobuf.Struct arguments */ 10:
+                    message.arguments = Struct.internalBinaryRead(reader, reader.uint32(), options, message.arguments);
+                    break;
+                case /* string descriptor_hash */ 11:
+                    message.descriptorHash = reader.string();
+                    break;
+                case /* string protocol_revision */ 12:
+                    message.protocolRevision = reader.string();
+                    break;
+                case /* string output_kind */ 13:
+                    message.outputKind = reader.string();
+                    break;
+                case /* bool requires_approval */ 14:
+                    message.requiresApproval = 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) {
+        /* nimi.runtime.v1.AgentRequestContext context = 1; */
+        if (message.context)
+            AgentRequestContext.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string agent_id = 2; */
+        if (message.agentId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.agentId);
+        /* string conversation_anchor_id = 3; */
+        if (message.conversationAnchorId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.conversationAnchorId);
+        /* string turn_id = 4; */
+        if (message.turnId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.turnId);
+        /* string stream_id = 5; */
+        if (message.streamId !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.streamId);
+        /* string request_id = 6; */
+        if (message.requestId !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.requestId);
+        /* string provider_profile_id = 7; */
+        if (message.providerProfileId !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.providerProfileId);
+        /* string capability_id = 8; */
+        if (message.capabilityId !== "")
+            writer.tag(8, WireType.LengthDelimited).string(message.capabilityId);
+        /* string tool_name = 9; */
+        if (message.toolName !== "")
+            writer.tag(9, WireType.LengthDelimited).string(message.toolName);
+        /* google.protobuf.Struct arguments = 10; */
+        if (message.arguments)
+            Struct.internalBinaryWrite(message.arguments, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* string descriptor_hash = 11; */
+        if (message.descriptorHash !== "")
+            writer.tag(11, WireType.LengthDelimited).string(message.descriptorHash);
+        /* string protocol_revision = 12; */
+        if (message.protocolRevision !== "")
+            writer.tag(12, WireType.LengthDelimited).string(message.protocolRevision);
+        /* string output_kind = 13; */
+        if (message.outputKind !== "")
+            writer.tag(13, WireType.LengthDelimited).string(message.outputKind);
+        /* bool requires_approval = 14; */
+        if (message.requiresApproval !== false)
+            writer.tag(14, WireType.Varint).bool(message.requiresApproval);
+        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.ExecuteDelegatedCapabilityRequest
+ */
+export const ExecuteDelegatedCapabilityRequest = new ExecuteDelegatedCapabilityRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecuteDelegatedCapabilityResponse$Type extends MessageType {
+    constructor() {
+        super("nimi.runtime.v1.ExecuteDelegatedCapabilityResponse", [
+            { no: 1, name: "diagnostic", kind: "message", T: () => DelegatedDiagnostic },
+            { no: 2, name: "replay_trace", kind: "message", T: () => DelegatedReplayTrace }
+        ]);
+    }
+    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.DelegatedDiagnostic diagnostic */ 1:
+                    message.diagnostic = DelegatedDiagnostic.internalBinaryRead(reader, reader.uint32(), options, message.diagnostic);
+                    break;
+                case /* nimi.runtime.v1.DelegatedReplayTrace replay_trace */ 2:
+                    message.replayTrace = DelegatedReplayTrace.internalBinaryRead(reader, reader.uint32(), options, message.replayTrace);
+                    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.DelegatedDiagnostic diagnostic = 1; */
+        if (message.diagnostic)
+            DelegatedDiagnostic.internalBinaryWrite(message.diagnostic, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* nimi.runtime.v1.DelegatedReplayTrace replay_trace = 2; */
+        if (message.replayTrace)
+            DelegatedReplayTrace.internalBinaryWrite(message.replayTrace, 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.ExecuteDelegatedCapabilityResponse
+ */
+export const ExecuteDelegatedCapabilityResponse = new ExecuteDelegatedCapabilityResponse$Type();
+//# sourceMappingURL=delegated_control.js.map