# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

from . import loomcycle_pb2 as loomcycle__pb2

GRPC_GENERATED_VERSION = '1.80.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + ' but the generated code in loomcycle_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


class LoomcycleStub(object):
    """========================
    Service
    ========================

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.Run = channel.unary_stream(
                '/loomcycle.v1.Loomcycle/Run',
                request_serializer=loomcycle__pb2.RunRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.Event.FromString,
                _registered_method=True)
        self.Continue = channel.unary_stream(
                '/loomcycle.v1.Loomcycle/Continue',
                request_serializer=loomcycle__pb2.ContinueRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.Event.FromString,
                _registered_method=True)
        self.SpawnRunBatch = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/SpawnRunBatch',
                request_serializer=loomcycle__pb2.BatchSpawnRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.BatchSpawnResult.FromString,
                _registered_method=True)
        self.CompactRun = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/CompactRun',
                request_serializer=loomcycle__pb2.CompactRunRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.CompactRunResult.FromString,
                _registered_method=True)
        self.DirectoryUsers = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/DirectoryUsers',
                request_serializer=loomcycle__pb2.DirectoryUsersRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.DirectoryUsersResponse.FromString,
                _registered_method=True)
        self.DirectoryInspect = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/DirectoryInspect',
                request_serializer=loomcycle__pb2.DirectoryInspectRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.DirectoryInspectResponse.FromString,
                _registered_method=True)
        self.DirectoryTenants = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/DirectoryTenants',
                request_serializer=loomcycle__pb2.DirectoryTenantsRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.DirectoryTenantsResponse.FromString,
                _registered_method=True)
        self.ErasureReport = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ErasureReport',
                request_serializer=loomcycle__pb2.ErasureReportRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ErasureReportResponse.FromString,
                _registered_method=True)
        self.ErasureExecute = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ErasureExecute',
                request_serializer=loomcycle__pb2.ErasureExecuteRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ErasureExecuteResponse.FromString,
                _registered_method=True)
        self.ReplaySession = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ReplaySession',
                request_serializer=loomcycle__pb2.ReplaySessionRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ReplaySessionResult.FromString,
                _registered_method=True)
        self.RunInput = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/RunInput',
                request_serializer=loomcycle__pb2.RunInputRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.RunInputResponse.FromString,
                _registered_method=True)
        self.CancelTurn = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/CancelTurn',
                request_serializer=loomcycle__pb2.CancelTurnRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.CancelTurnResponse.FromString,
                _registered_method=True)
        self.ResolveInterrupt = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ResolveInterrupt',
                request_serializer=loomcycle__pb2.ResolveInterruptRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ResolveInterruptResponse.FromString,
                _registered_method=True)
        self.StreamRun = channel.unary_stream(
                '/loomcycle.v1.Loomcycle/StreamRun',
                request_serializer=loomcycle__pb2.StreamRunRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.Event.FromString,
                _registered_method=True)
        self.GetTranscript = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/GetTranscript',
                request_serializer=loomcycle__pb2.GetTranscriptRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.Transcript.FromString,
                _registered_method=True)
        self.GetAgent = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/GetAgent',
                request_serializer=loomcycle__pb2.GetAgentRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.Agent.FromString,
                _registered_method=True)
        self.CancelAgent = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/CancelAgent',
                request_serializer=loomcycle__pb2.CancelAgentRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.CancelAgentResponse.FromString,
                _registered_method=True)
        self.ListUserAgents = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ListUserAgents',
                request_serializer=loomcycle__pb2.ListUserAgentsRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ListUserAgentsResponse.FromString,
                _registered_method=True)
        self.UsageReport = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/UsageReport',
                request_serializer=loomcycle__pb2.UsageReportRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.UsageReportResponse.FromString,
                _registered_method=True)
        self.TokenLimit = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/TokenLimit',
                request_serializer=loomcycle__pb2.TokenLimitRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.TokenLimitResponse.FromString,
                _registered_method=True)
        self.Health = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/Health',
                request_serializer=loomcycle__pb2.HealthRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.HealthResponse.FromString,
                _registered_method=True)
        self.Config = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/Config',
                request_serializer=loomcycle__pb2.ConfigRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ConfigResponse.FromString,
                _registered_method=True)
        self.RegisterHook = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/RegisterHook',
                request_serializer=loomcycle__pb2.RegisterHookRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.RegisterHookResponse.FromString,
                _registered_method=True)
        self.ListHooks = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ListHooks',
                request_serializer=loomcycle__pb2.ListHooksRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ListHooksResponse.FromString,
                _registered_method=True)
        self.DeleteHook = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/DeleteHook',
                request_serializer=loomcycle__pb2.DeleteHookRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.DeleteHookResponse.FromString,
                _registered_method=True)
        self.PauseRuntime = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/PauseRuntime',
                request_serializer=loomcycle__pb2.PauseRuntimeRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.PauseRuntimeResponse.FromString,
                _registered_method=True)
        self.ResumeRuntime = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ResumeRuntime',
                request_serializer=loomcycle__pb2.ResumeRuntimeRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ResumeRuntimeResponse.FromString,
                _registered_method=True)
        self.GetRuntimeState = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/GetRuntimeState',
                request_serializer=loomcycle__pb2.GetRuntimeStateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.RuntimeStateResponse.FromString,
                _registered_method=True)
        self.ResolveProbe = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ResolveProbe',
                request_serializer=loomcycle__pb2.ResolveProbeRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ResolverMatrixResponse.FromString,
                _registered_method=True)
        self.CreateSnapshot = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/CreateSnapshot',
                request_serializer=loomcycle__pb2.CreateSnapshotRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SnapshotDescriptor.FromString,
                _registered_method=True)
        self.ListSnapshots = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ListSnapshots',
                request_serializer=loomcycle__pb2.ListSnapshotsRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ListSnapshotsResponse.FromString,
                _registered_method=True)
        self.GetSnapshot = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/GetSnapshot',
                request_serializer=loomcycle__pb2.GetSnapshotRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SnapshotEnvelope.FromString,
                _registered_method=True)
        self.ExportSnapshot = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ExportSnapshot',
                request_serializer=loomcycle__pb2.ExportSnapshotRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ExportSnapshotResponse.FromString,
                _registered_method=True)
        self.RestoreSnapshot = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/RestoreSnapshot',
                request_serializer=loomcycle__pb2.RestoreSnapshotRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.RestoreSnapshotResponse.FromString,
                _registered_method=True)
        self.DeleteSnapshot = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/DeleteSnapshot',
                request_serializer=loomcycle__pb2.DeleteSnapshotRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.DeleteSnapshotResponse.FromString,
                _registered_method=True)
        self.AgentDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/AgentDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.SkillDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/SkillDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.MCPServerDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/MCPServerDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.ScheduleDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ScheduleDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.A2AServerCardDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/A2AServerCardDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.A2AAgentDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/A2AAgentDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.WebhookDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/WebhookDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.MemoryBackendDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/MemoryBackendDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.OperatorTokenDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/OperatorTokenDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.VolumeDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/VolumeDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.TeamDef = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/TeamDef',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.Path = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/Path',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.Document = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/Document',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.History = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/History',
                request_serializer=loomcycle__pb2.SubstrateRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubstrateResponse.FromString,
                _registered_method=True)
        self.ListChannels = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/ListChannels',
                request_serializer=loomcycle__pb2.ListChannelsRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.ListChannelsResponse.FromString,
                _registered_method=True)
        self.StreamUserRunStates = channel.unary_stream(
                '/loomcycle.v1.Loomcycle/StreamUserRunStates',
                request_serializer=loomcycle__pb2.StreamUserRunStatesRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.RunStateEvent.FromString,
                _registered_method=True)
        self.PublishChannel = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/PublishChannel',
                request_serializer=loomcycle__pb2.PublishChannelRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.PublishChannelResponse.FromString,
                _registered_method=True)
        self.SubscribeChannel = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/SubscribeChannel',
                request_serializer=loomcycle__pb2.SubscribeChannelRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.SubscribeChannelResponse.FromString,
                _registered_method=True)
        self.PeekChannel = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/PeekChannel',
                request_serializer=loomcycle__pb2.PeekChannelRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.PeekChannelResponse.FromString,
                _registered_method=True)
        self.AckChannel = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/AckChannel',
                request_serializer=loomcycle__pb2.AckChannelRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.AckChannelResponse.FromString,
                _registered_method=True)
        self.AwaitChannels = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/AwaitChannels',
                request_serializer=loomcycle__pb2.AwaitChannelsRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.AwaitChannelsResponse.FromString,
                _registered_method=True)
        self.BroadcastChannels = channel.unary_unary(
                '/loomcycle.v1.Loomcycle/BroadcastChannels',
                request_serializer=loomcycle__pb2.BroadcastChannelsRequest.SerializeToString,
                response_deserializer=loomcycle__pb2.BroadcastChannelsResponse.FromString,
                _registered_method=True)


class LoomcycleServicer(object):
    """========================
    Service
    ========================

    """

    def Run(self, request, context):
        """Run starts a fresh agent run and server-streams its events. One
        request → many Event responses. The stream terminates on EOF when
        the loop reaches its terminal state (done, failed, or cancelled).

        Mirrors POST /v1/runs.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Continue(self, request, context):
        """Continue extends an existing session with a new run. The session's
        prior transcript is replayed into the loop's context; the response
        stream covers only the NEW events from this continuation.

        Mirrors POST /v1/sessions/{id}/messages.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SpawnRunBatch(self, request, context):
        """SpawnRunBatch spawns N fresh runs concurrently in one call (RFC Y
        external fan-out, mode "join"), bounded by the per-user admission
        gate, returning a combined index-aligned envelope once all settle. A
        per-child failure is captured in that child's result and never fails
        the batch. mode "detach" (async run handles) is reserved for a future
        release and rejected today.

        Mirrors POST /v1/runs:batch + the spawn_runs MCP tool.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CompactRun(self, request, context):
        """CompactRun summarizes a run's conversation to free context and
        continue from the summary. A live run must be PARKED (awaiting input);
        a mid-turn run returns FailedPrecondition. Keyed by run_id.

        Mirrors POST /v1/runs/{run_id}/compact + the compact_run MCP tool.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DirectoryUsers(self, request, context):
        """ErasureReport enumerates what this deployment holds about one subject, in
        three tiers separated by what they guarantee. Read-only.

        The tenant is taken from the caller's credentials and is NOT a field: a
        subject id is only unique within one tenant, so a wire tenant would let a
        caller enumerate another tenant's subject.
        DirectoryUsers lists the subjects with activity in the caller's tenant, and
        DirectoryInspect aggregates one subject's activity, chats, memory, documents,
        budget and usage in a single call. READ-ONLY and derived — a "user" is a
        GROUP BY over runs.user_id, not a stored row, so there is no create or update
        here; removing a subject's footprint is ErasureExecute.

        No tenant field on either, deliberately: a subject id is only unique within
        one tenant, so accepting one would let a caller inspect somebody else's.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DirectoryInspect(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DirectoryTenants(self, request, context):
        """DirectoryTenants enumerates tenants with derived counts. ADMIN ONLY: the
        counts are unremarkable, but the LIST is cross-tenant information a confined
        principal must not learn — so a non-admin is REFUSED rather than given a
        filtered list, which would still confirm its own tenant's existence.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ErasureReport(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ErasureExecute(self, request, context):
        """ErasureExecute removes tiers 1 and 2 and reports what it could not reach.
        DEFAULTS TO A DRY RUN: dry_run is `optional` so an unset field means true,
        matching HTTP — a client that forgets it deletes nothing.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReplaySession(self, request, context):
        """ReplaySession copies a source session's transcript into a new session bound
        to a (possibly different) target agent (RFC BJ Phase 4). Mirrors
        POST /v1/sessions/{id}/replay.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunInput(self, request, context):
        """RunInput pushes an operator steering message into a LIVE interactive
        run (one parked at end_turn awaiting input, or mid-turn — the message
        is drained at the next iteration boundary). delivered=false +
        NotFound when no in-flight run holds run_id; ResourceExhausted when
        the run's steer queue is full. The injected `source` is server-stamped
        (never wire-trusted). Cross-replica routing is inherited from the
        steer registry. Mirrors POST /v1/runs/{run_id}/input. (RFC AI)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CancelTurn(self, request, context):
        """CancelTurn stops the CURRENT turn of a LIVE interactive run (its in-flight
        model generation + the tool calls it started) and parks it at
        awaiting_input — session + transcript intact. This is NOT whole-run cancel
        (CancelAgent), which terminates the run. FailedPrecondition when the run
        isn't mid-turn (not_mid_turn) or isn't interactive (not_interactive);
        NotFound (opaque) for an unknown / cross-tenant / not-reachable run.
        Owner-routed cross-replica by runs.replica_id.

        Mirrors POST /v1/runs/{run_id}/cancel. (RFC BH)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResolveInterrupt(self, request, context):
        """ResolveInterrupt resolves a pending interruption — either an answer
        (disposition "" / "answer", validated against the declared options) or a
        decline (disposition "declined": no answer, skips option validation) so the
        waiting Question tool proceeds. InvalidArgument on a bad kind / disposition
        / answer; NotFound (opaque) for an unknown / cross-tenant interrupt;
        FailedPrecondition when already terminal or expired.

        Mirrors POST /v1/runs/{run_id}/interrupts/{interrupt_id}/resolve. (RFC BH)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StreamRun(self, request, context):
        """StreamRun re-attaches to a run's event stream by run_id, replaying
        from from_seq and then live-tailing — the gRPC twin of
        GET /v1/runs/{run_id}/stream. For a PARKED interactive run (non-
        terminal) the stream stays open until the run ends or ctx fires; a
        disconnect does NOT stop the run. The first frame is a synthetic
        type="agent" Event carrying run metadata. (RFC AI)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetTranscript(self, request, context):
        """GetTranscript returns the full event history for a session,
        ordered by seq. Used by adapters that re-attach to a previously
        started session (e.g. cross-tab sync).

        Mirrors GET /v1/sessions/{id}/transcript.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAgent(self, request, context):
        """GetAgent returns one agent's current status + usage stats. Used
        by adapters polling for completion when the SSE/gRPC stream was
        interrupted (browser tab closed, network blip).

        Mirrors GET /v1/agents/{agent_id}.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CancelAgent(self, request, context):
        """CancelAgent sets the agent's terminal status to "cancelled" and
        cascades the cancellation to every child via parent_agent_id.

        Mirrors POST /v1/agents/{agent_id}/cancel.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListUserAgents(self, request, context):
        """ListUserAgents enumerates a user's recent agent runs, optionally
        filtered by status.

        Mirrors GET /v1/users/{user_id}/agents.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UsageReport(self, request, context):
        """UsageReport aggregates the token-usage + cost ledger (RFC AV): summed
        tokens + cost grouped by the requested dimensions over an optional tenant +
        time window. Tenant-scoped like the HTTP twin (a substrate:tenant caller is
        confined to its own tenant; admin sees all + an optional tenant focus).

        Mirrors GET /v1/_usage.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TokenLimit(self, request, context):
        """TokenLimit manages per-scope token budgets (RFC AW): one op-based RPC
        (op ∈ list|set|delete) mirroring GET/PUT/DELETE /v1/_limits. Tenant-scoped
        like the HTTP twin — a substrate:tenant caller may only see/set/delete its
        own tenant's budgets; the operator-global cap + cross-tenant rows are
        admin-only.

        Mirrors GET/PUT/DELETE /v1/_limits.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Health(self, request, context):
        """Health is the liveness probe. Returns build identifier + uptime.

        Mirrors GET /healthz (which is unauthenticated on the HTTP side;
        the gRPC equivalent stays unauthenticated for parity).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Config(self, request, context):
        """Config returns the instance-configuration report: build identity, the
        feature matrix, and the live provider/model/search cascade with coarse
        active/inactive status.

        Mirrors GET /v1/config at the CALLER's disclosure level. The HTTP side has a
        third, narrower `public` level reachable with no bearer under
        LOOMCYCLE_PUBLIC_CONFIG; that level does NOT exist here, because gRPC
        authenticates before dispatch — so a caller gets `authenticated` or `admin`
        from its own scopes. `view` in the payload names which.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterHook(self, request, context):
        """RegisterHook registers a pre- or post-tool webhook. The
        callback_url must be an http:// or https:// endpoint the consumer
        runs. Returns the loomcycle-assigned id. Re-registering the same
        (owner, name) replaces the prior entry in-place (idempotent on
        app restart).

        Mirrors POST /v1/hooks.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListHooks(self, request, context):
        """ListHooks returns every currently-registered hook. Useful for
        debug; no pagination — the registry is intentionally small
        (operator-curated set).

        Mirrors GET /v1/hooks.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteHook(self, request, context):
        """DeleteHook removes a registered hook by id. Returns
        codes.NotFound when no hook has that id.

        Mirrors DELETE /v1/hooks/{id}.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PauseRuntime(self, request, context):
        """----- v0.8.17 Pause / Resume / Snapshot (real impls in v0.8.18) -----

        Runtime-wide quiesce + cross-version-portable JSON snapshot. Wire
        shapes mirror the connector.Connector method signatures. Typed
        errors from internal/connector/errors.go map to gRPC codes:
        ErrPauseNotConfigured     → Unavailable (503-equivalent)
        ErrAlreadyPausing         → FailedPrecondition (409-equivalent)
        ErrNotPaused              → FailedPrecondition (409-equivalent)
        ErrSnapshotNotFound       → NotFound (404-equivalent)
        ErrSnapshotTooLarge       → ResourceExhausted (413-equivalent)
        ErrSnapshotVersionTooNew  → FailedPrecondition (422-equivalent)
        ErrSnapshotVersionUnknown → FailedPrecondition (422-equivalent)

        PauseRuntime quiesces the runtime. Idempotent tools cancel
        immediately; non-idempotent + external tools get a grace window
        (default 30 s; max 5 min) then force-cancel. Returns 409-equivalent
        when the runtime is already pausing or paused.

        Mirrors POST /v1/_pause.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResumeRuntime(self, request, context):
        """ResumeRuntime releases the quiesce. Paused runs re-enter their
        loops. Returns 409-equivalent when the runtime is not paused.

        Mirrors POST /v1/_resume.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetRuntimeState(self, request, context):
        """GetRuntimeState returns the current quiesce state for dashboards.

        Mirrors GET /v1/_state.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResolveProbe(self, request, context):
        """ResolveProbe triggers an immediate, synchronous re-probe of every
        configured provider and returns the refreshed availability matrix
        — the operator escape hatch when a transient outage stalls every
        provider. Unavailable when no resolver / no probe loop is wired.

        Mirrors POST /v1/_resolve/probe.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateSnapshot(self, request, context):
        """CreateSnapshot captures running-state into a per-section-semver
        JSON envelope (agent_defs, agent_def_active, memory, channels,
        evaluations, paused_runs, optional interaction_history). Returns
        413-equivalent when the serialised envelope exceeds the configured
        cap (LOOMCYCLE_SNAPSHOT_MAX_BYTES; default 512 MiB).

        Mirrors POST /v1/_snapshots.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListSnapshots(self, request, context):
        """ListSnapshots returns metadata for the most-recent snapshots
        (capped at 200). The JSON envelope itself is not included; use
        GetSnapshot / ExportSnapshot to fetch.

        Mirrors GET /v1/_snapshots.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSnapshot(self, request, context):
        """GetSnapshot returns the full envelope including JSON content.
        Distinct from ExportSnapshot, which is operator-facing "where did
        this land on the host" semantics.

        Mirrors GET /v1/_snapshots/{id}.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExportSnapshot(self, request, context):
        """ExportSnapshot returns canonical envelope bytes (raw_json) for a
        snapshot id. Transports that stream large exports use raw_json
        directly; file_path / checksum stay empty unless materialised.

        Mirrors GET /v1/_snapshots/{id}/export.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RestoreSnapshot(self, request, context):
        """RestoreSnapshot restores from a same-instance snapshot_id OR
        cross-instance raw_json. Idempotent: ON CONFLICT DO NOTHING per
        row. Counters in the response reflect rows actually written.
        Returns 422-equivalent on snapshot version newer than reader
        supports.

        Mirrors POST /v1/_snapshots/{id}/restore.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteSnapshot(self, request, context):
        """DeleteSnapshot removes a snapshot. Idempotent — succeeds whether
        or not the row existed.

        Mirrors DELETE /v1/_snapshots/{id}.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AgentDef(self, request, context):
        """----- v0.8.22 substrate admin RPCs -----

        Two op-discriminated RPCs expose the AgentDef + SkillDef
        substrate tools to gRPC callers (and through the gRPC adapter
        path to Python clients). Same connector dispatch as the MCP
        meta-tools and the HTTP /v1/_agentdef + /v1/_skilldef
        endpoints — different transport, identical semantics.

        Request body is the substrate tool's input JSON (op + name +
        def_id + overlay + ...); response carries the tool's output
        JSON + an is_error flag. Errors that aren't tool refusals
        (transport, auth, malformed body) come back as gRPC status
        codes per the existing convention.

        AgentDef dispatches to the in-process AgentDef tool. Mirrors
        POST /v1/_agentdef.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SkillDef(self, request, context):
        """SkillDef dispatches to the in-process SkillDef tool. Mirrors
        POST /v1/_skilldef.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MCPServerDef(self, request, context):
        """MCPServerDef dispatches to the v0.9.x dynamic MCP server
        registration substrate. Mirrors POST /v1/_mcpserverdef.
        Operator-admin-only — same SubstrateRequest body shape as
        AgentDef + SkillDef (op-discriminated input_json + is_error
        tool refusals in the response).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ScheduleDef(self, request, context):
        """ScheduleDef dispatches to the v1.x RFC E scheduled-runs
        substrate. Mirrors POST /v1/_scheduledef. Operator-admin-only.
        Same SubstrateRequest body shape — op-discriminated input_json
        (create / fork / get / list / retire) + is_error tool refusals
        in the response.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def A2AServerCardDef(self, request, context):
        """A2AServerCardDef dispatches to the v1.x RFC G A2A-server-card
        substrate. Mirrors POST /v1/_a2aservercarddef. Operator-admin-only.
        Same SubstrateRequest body shape — op-discriminated input_json
        (create / fork / get / list / retire) + is_error tool refusals
        in the response.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def A2AAgentDef(self, request, context):
        """A2AAgentDef dispatches to the v1.x RFC G A2A-agent substrate.
        Mirrors POST /v1/_a2aagentdef. Operator-admin-only. Same
        SubstrateRequest body shape — op-discriminated input_json
        (create / fork / get / list / retire) + is_error tool refusals
        in the response.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WebhookDef(self, request, context):
        """WebhookDef dispatches to the v1.x RFC H inbound-webhook substrate.
        Mirrors POST /v1/_webhookdef. Operator-admin-only. Same
        SubstrateRequest body shape — op-discriminated input_json
        (create / fork / get / list / retire) + is_error tool refusals
        in the response. (RFC H WH-3 / mirrors A2AAgentDef.)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MemoryBackendDef(self, request, context):
        """MemoryBackendDef dispatches to the RFC I MR-3a memory-backend
        substrate. Mirrors POST /v1/_memorybackenddef. Operator-admin-only.
        Same SubstrateRequest body shape — op-discriminated input_json
        (create / fork / get / list / retire) + is_error tool refusals
        in the response. (RFC I MR-3a / mirrors WebhookDef.)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OperatorTokenDef(self, request, context):
        """OperatorTokenDef dispatches to the RFC L OSS multi-tenant
        authorization substrate (auth-token minting/rotation/retirement).
        Mirrors POST /v1/_operatortokendef. Operator-admin-only. Same
        SubstrateRequest body shape — op-discriminated input_json
        (create / rotate / retire / get / list).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def VolumeDef(self, request, context):
        """VolumeDef dispatches to the RFC AH dynamic filesystem-volume
        substrate. Mirrors POST /v1/_volumedef. TENANT-CONFINED (ScopeTenant,
        like AgentDef/SkillDef — NOT operator-admin-only): the tool stamps the
        caller's authoritative tenant + opaque-404s cross-tenant reads. A
        VolumeDef is flat (a pointer to mutable on-disk state, not a versioned
        definition), so the op set is create / get / list / delete / purge —
        NOT the content-addressed retire/promote/fork of the families above.
        Same SubstrateRequest body shape (op-discriminated input_json +
        is_error tool refusals in the response).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TeamDef(self, request, context):
        """TeamDef dispatches to the RFC AP team-workflow substrate. Mirrors
        POST /v1/_teamdef. TENANT-CONFINED (ScopeTenant, like AgentDef/SkillDef):
        the tool stamps the caller's authoritative tenant + opaque-404s
        cross-tenant reads. Op-discriminated input_json (create / fork / get /
        list / retire / delete / promote / verify / render_diagram / run — a
        versioned def family; `run` walks the team's state graph, spawning each
        state's agent under the same admission a run would get). Same
        SubstrateRequest/Response body shape (is_error carries tool refusals).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Path(self, request, context):
        """Path dispatches to the RFC AL Unix-like VFS tool. Mirrors POST /v1/_path.
        TENANT-CONFINED (ScopeTenant): scope (agent/user/tenant) is resolved from
        the operator-trust ctx + the caller's authoritative tenant, never the
        wire. Op-discriminated input_json (resolve / ls / stat / mkdir / mv / rm);
        same SubstrateRequest/Response body shape (is_error carries tool refusals).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Document(self, request, context):
        """Document dispatches to the RFC AK chunked-graph Document tool. Mirrors
        POST /v1/_document. TENANT-CONFINED (ScopeTenant); requires SQL Memory.
        Op-discriminated input_json (13 ops: document/chunk lifecycle, edges,
        query_chunks, type defs); same SubstrateRequest/Response body shape.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def History(self, request, context):
        """History dispatches to the RFC BE History tool (browse/search/annotate
        past chats; a chat = a session). Mirrors POST /v1/_history. TENANT-CONFINED
        (ScopeTenant): the owner is resolved from the operator-trust ctx +
        caller's authoritative tenant, NEVER the wire — a scope:"user" op keys on
        the principal's own subject, scope:"tenant" on its tenant; the cross-tenant
        scope:"global" is admin-only. Op-discriminated input_json (list / get /
        search / rename / annotate / pin / archive / recap / resume); same
        SubstrateRequest/Response body shape (is_error carries tool refusals).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListChannels(self, request, context):
        """----- v0.9.x n8n RFC Phase 0 -----

        ListChannels mirrors GET /v1/_channels — operator-declared
        channels joined with runtime stats.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StreamUserRunStates(self, request, context):
        """StreamUserRunStates mirrors GET /v1/users/{user_id}/agents/stream.
        Server-streams one RunStateEvent per matching state transition
        until ctx cancels or the client closes the stream.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PublishChannel(self, request, context):
        """----- v0.9.x Channel CRUD (admin + per-user) -----

        Mirrors the four HTTP routes:
        PublishChannel   → POST /v1/_channels/{name}/publish (and the
        /v1/users/{user_id}/channels/... variant)
        SubscribeChannel → POST /v1/_channels/{name}/subscribe (single-
        round-trip long-poll; not streaming)
        PeekChannel      → GET  /v1/_channels/{name}/peek (non-destructive)
        AckChannel       → POST /v1/_channels/{name}/ack

        Scope + scope_id select the cursor namespace: scope="global" with
        empty scope_id addresses the admin surface; scope="user" with a
        non-empty scope_id addresses a per-end-user channel.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubscribeChannel(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PeekChannel(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AckChannel(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AwaitChannels(self, request, context):
        """RFC S client twins (mirror POST /v1/_channels/_await and
        /v1/_channels/_broadcast). AwaitChannels fans IN across a set of
        channels (any/all/at_least N, or a timeout — a timeout is
        satisfied=false / timed_out=true, NOT an error); BroadcastChannels
        fans OUT one payload to a set of channels (atomic at the declare
        pre-flight). Scope + scope_id apply to every channel in the set.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def BroadcastChannels(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_LoomcycleServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Run': grpc.unary_stream_rpc_method_handler(
                    servicer.Run,
                    request_deserializer=loomcycle__pb2.RunRequest.FromString,
                    response_serializer=loomcycle__pb2.Event.SerializeToString,
            ),
            'Continue': grpc.unary_stream_rpc_method_handler(
                    servicer.Continue,
                    request_deserializer=loomcycle__pb2.ContinueRequest.FromString,
                    response_serializer=loomcycle__pb2.Event.SerializeToString,
            ),
            'SpawnRunBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.SpawnRunBatch,
                    request_deserializer=loomcycle__pb2.BatchSpawnRequest.FromString,
                    response_serializer=loomcycle__pb2.BatchSpawnResult.SerializeToString,
            ),
            'CompactRun': grpc.unary_unary_rpc_method_handler(
                    servicer.CompactRun,
                    request_deserializer=loomcycle__pb2.CompactRunRequest.FromString,
                    response_serializer=loomcycle__pb2.CompactRunResult.SerializeToString,
            ),
            'DirectoryUsers': grpc.unary_unary_rpc_method_handler(
                    servicer.DirectoryUsers,
                    request_deserializer=loomcycle__pb2.DirectoryUsersRequest.FromString,
                    response_serializer=loomcycle__pb2.DirectoryUsersResponse.SerializeToString,
            ),
            'DirectoryInspect': grpc.unary_unary_rpc_method_handler(
                    servicer.DirectoryInspect,
                    request_deserializer=loomcycle__pb2.DirectoryInspectRequest.FromString,
                    response_serializer=loomcycle__pb2.DirectoryInspectResponse.SerializeToString,
            ),
            'DirectoryTenants': grpc.unary_unary_rpc_method_handler(
                    servicer.DirectoryTenants,
                    request_deserializer=loomcycle__pb2.DirectoryTenantsRequest.FromString,
                    response_serializer=loomcycle__pb2.DirectoryTenantsResponse.SerializeToString,
            ),
            'ErasureReport': grpc.unary_unary_rpc_method_handler(
                    servicer.ErasureReport,
                    request_deserializer=loomcycle__pb2.ErasureReportRequest.FromString,
                    response_serializer=loomcycle__pb2.ErasureReportResponse.SerializeToString,
            ),
            'ErasureExecute': grpc.unary_unary_rpc_method_handler(
                    servicer.ErasureExecute,
                    request_deserializer=loomcycle__pb2.ErasureExecuteRequest.FromString,
                    response_serializer=loomcycle__pb2.ErasureExecuteResponse.SerializeToString,
            ),
            'ReplaySession': grpc.unary_unary_rpc_method_handler(
                    servicer.ReplaySession,
                    request_deserializer=loomcycle__pb2.ReplaySessionRequest.FromString,
                    response_serializer=loomcycle__pb2.ReplaySessionResult.SerializeToString,
            ),
            'RunInput': grpc.unary_unary_rpc_method_handler(
                    servicer.RunInput,
                    request_deserializer=loomcycle__pb2.RunInputRequest.FromString,
                    response_serializer=loomcycle__pb2.RunInputResponse.SerializeToString,
            ),
            'CancelTurn': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelTurn,
                    request_deserializer=loomcycle__pb2.CancelTurnRequest.FromString,
                    response_serializer=loomcycle__pb2.CancelTurnResponse.SerializeToString,
            ),
            'ResolveInterrupt': grpc.unary_unary_rpc_method_handler(
                    servicer.ResolveInterrupt,
                    request_deserializer=loomcycle__pb2.ResolveInterruptRequest.FromString,
                    response_serializer=loomcycle__pb2.ResolveInterruptResponse.SerializeToString,
            ),
            'StreamRun': grpc.unary_stream_rpc_method_handler(
                    servicer.StreamRun,
                    request_deserializer=loomcycle__pb2.StreamRunRequest.FromString,
                    response_serializer=loomcycle__pb2.Event.SerializeToString,
            ),
            'GetTranscript': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTranscript,
                    request_deserializer=loomcycle__pb2.GetTranscriptRequest.FromString,
                    response_serializer=loomcycle__pb2.Transcript.SerializeToString,
            ),
            'GetAgent': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAgent,
                    request_deserializer=loomcycle__pb2.GetAgentRequest.FromString,
                    response_serializer=loomcycle__pb2.Agent.SerializeToString,
            ),
            'CancelAgent': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelAgent,
                    request_deserializer=loomcycle__pb2.CancelAgentRequest.FromString,
                    response_serializer=loomcycle__pb2.CancelAgentResponse.SerializeToString,
            ),
            'ListUserAgents': grpc.unary_unary_rpc_method_handler(
                    servicer.ListUserAgents,
                    request_deserializer=loomcycle__pb2.ListUserAgentsRequest.FromString,
                    response_serializer=loomcycle__pb2.ListUserAgentsResponse.SerializeToString,
            ),
            'UsageReport': grpc.unary_unary_rpc_method_handler(
                    servicer.UsageReport,
                    request_deserializer=loomcycle__pb2.UsageReportRequest.FromString,
                    response_serializer=loomcycle__pb2.UsageReportResponse.SerializeToString,
            ),
            'TokenLimit': grpc.unary_unary_rpc_method_handler(
                    servicer.TokenLimit,
                    request_deserializer=loomcycle__pb2.TokenLimitRequest.FromString,
                    response_serializer=loomcycle__pb2.TokenLimitResponse.SerializeToString,
            ),
            'Health': grpc.unary_unary_rpc_method_handler(
                    servicer.Health,
                    request_deserializer=loomcycle__pb2.HealthRequest.FromString,
                    response_serializer=loomcycle__pb2.HealthResponse.SerializeToString,
            ),
            'Config': grpc.unary_unary_rpc_method_handler(
                    servicer.Config,
                    request_deserializer=loomcycle__pb2.ConfigRequest.FromString,
                    response_serializer=loomcycle__pb2.ConfigResponse.SerializeToString,
            ),
            'RegisterHook': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterHook,
                    request_deserializer=loomcycle__pb2.RegisterHookRequest.FromString,
                    response_serializer=loomcycle__pb2.RegisterHookResponse.SerializeToString,
            ),
            'ListHooks': grpc.unary_unary_rpc_method_handler(
                    servicer.ListHooks,
                    request_deserializer=loomcycle__pb2.ListHooksRequest.FromString,
                    response_serializer=loomcycle__pb2.ListHooksResponse.SerializeToString,
            ),
            'DeleteHook': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteHook,
                    request_deserializer=loomcycle__pb2.DeleteHookRequest.FromString,
                    response_serializer=loomcycle__pb2.DeleteHookResponse.SerializeToString,
            ),
            'PauseRuntime': grpc.unary_unary_rpc_method_handler(
                    servicer.PauseRuntime,
                    request_deserializer=loomcycle__pb2.PauseRuntimeRequest.FromString,
                    response_serializer=loomcycle__pb2.PauseRuntimeResponse.SerializeToString,
            ),
            'ResumeRuntime': grpc.unary_unary_rpc_method_handler(
                    servicer.ResumeRuntime,
                    request_deserializer=loomcycle__pb2.ResumeRuntimeRequest.FromString,
                    response_serializer=loomcycle__pb2.ResumeRuntimeResponse.SerializeToString,
            ),
            'GetRuntimeState': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRuntimeState,
                    request_deserializer=loomcycle__pb2.GetRuntimeStateRequest.FromString,
                    response_serializer=loomcycle__pb2.RuntimeStateResponse.SerializeToString,
            ),
            'ResolveProbe': grpc.unary_unary_rpc_method_handler(
                    servicer.ResolveProbe,
                    request_deserializer=loomcycle__pb2.ResolveProbeRequest.FromString,
                    response_serializer=loomcycle__pb2.ResolverMatrixResponse.SerializeToString,
            ),
            'CreateSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSnapshot,
                    request_deserializer=loomcycle__pb2.CreateSnapshotRequest.FromString,
                    response_serializer=loomcycle__pb2.SnapshotDescriptor.SerializeToString,
            ),
            'ListSnapshots': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSnapshots,
                    request_deserializer=loomcycle__pb2.ListSnapshotsRequest.FromString,
                    response_serializer=loomcycle__pb2.ListSnapshotsResponse.SerializeToString,
            ),
            'GetSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSnapshot,
                    request_deserializer=loomcycle__pb2.GetSnapshotRequest.FromString,
                    response_serializer=loomcycle__pb2.SnapshotEnvelope.SerializeToString,
            ),
            'ExportSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.ExportSnapshot,
                    request_deserializer=loomcycle__pb2.ExportSnapshotRequest.FromString,
                    response_serializer=loomcycle__pb2.ExportSnapshotResponse.SerializeToString,
            ),
            'RestoreSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.RestoreSnapshot,
                    request_deserializer=loomcycle__pb2.RestoreSnapshotRequest.FromString,
                    response_serializer=loomcycle__pb2.RestoreSnapshotResponse.SerializeToString,
            ),
            'DeleteSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSnapshot,
                    request_deserializer=loomcycle__pb2.DeleteSnapshotRequest.FromString,
                    response_serializer=loomcycle__pb2.DeleteSnapshotResponse.SerializeToString,
            ),
            'AgentDef': grpc.unary_unary_rpc_method_handler(
                    servicer.AgentDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'SkillDef': grpc.unary_unary_rpc_method_handler(
                    servicer.SkillDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'MCPServerDef': grpc.unary_unary_rpc_method_handler(
                    servicer.MCPServerDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'ScheduleDef': grpc.unary_unary_rpc_method_handler(
                    servicer.ScheduleDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'A2AServerCardDef': grpc.unary_unary_rpc_method_handler(
                    servicer.A2AServerCardDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'A2AAgentDef': grpc.unary_unary_rpc_method_handler(
                    servicer.A2AAgentDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'WebhookDef': grpc.unary_unary_rpc_method_handler(
                    servicer.WebhookDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'MemoryBackendDef': grpc.unary_unary_rpc_method_handler(
                    servicer.MemoryBackendDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'OperatorTokenDef': grpc.unary_unary_rpc_method_handler(
                    servicer.OperatorTokenDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'VolumeDef': grpc.unary_unary_rpc_method_handler(
                    servicer.VolumeDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'TeamDef': grpc.unary_unary_rpc_method_handler(
                    servicer.TeamDef,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'Path': grpc.unary_unary_rpc_method_handler(
                    servicer.Path,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'Document': grpc.unary_unary_rpc_method_handler(
                    servicer.Document,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'History': grpc.unary_unary_rpc_method_handler(
                    servicer.History,
                    request_deserializer=loomcycle__pb2.SubstrateRequest.FromString,
                    response_serializer=loomcycle__pb2.SubstrateResponse.SerializeToString,
            ),
            'ListChannels': grpc.unary_unary_rpc_method_handler(
                    servicer.ListChannels,
                    request_deserializer=loomcycle__pb2.ListChannelsRequest.FromString,
                    response_serializer=loomcycle__pb2.ListChannelsResponse.SerializeToString,
            ),
            'StreamUserRunStates': grpc.unary_stream_rpc_method_handler(
                    servicer.StreamUserRunStates,
                    request_deserializer=loomcycle__pb2.StreamUserRunStatesRequest.FromString,
                    response_serializer=loomcycle__pb2.RunStateEvent.SerializeToString,
            ),
            'PublishChannel': grpc.unary_unary_rpc_method_handler(
                    servicer.PublishChannel,
                    request_deserializer=loomcycle__pb2.PublishChannelRequest.FromString,
                    response_serializer=loomcycle__pb2.PublishChannelResponse.SerializeToString,
            ),
            'SubscribeChannel': grpc.unary_unary_rpc_method_handler(
                    servicer.SubscribeChannel,
                    request_deserializer=loomcycle__pb2.SubscribeChannelRequest.FromString,
                    response_serializer=loomcycle__pb2.SubscribeChannelResponse.SerializeToString,
            ),
            'PeekChannel': grpc.unary_unary_rpc_method_handler(
                    servicer.PeekChannel,
                    request_deserializer=loomcycle__pb2.PeekChannelRequest.FromString,
                    response_serializer=loomcycle__pb2.PeekChannelResponse.SerializeToString,
            ),
            'AckChannel': grpc.unary_unary_rpc_method_handler(
                    servicer.AckChannel,
                    request_deserializer=loomcycle__pb2.AckChannelRequest.FromString,
                    response_serializer=loomcycle__pb2.AckChannelResponse.SerializeToString,
            ),
            'AwaitChannels': grpc.unary_unary_rpc_method_handler(
                    servicer.AwaitChannels,
                    request_deserializer=loomcycle__pb2.AwaitChannelsRequest.FromString,
                    response_serializer=loomcycle__pb2.AwaitChannelsResponse.SerializeToString,
            ),
            'BroadcastChannels': grpc.unary_unary_rpc_method_handler(
                    servicer.BroadcastChannels,
                    request_deserializer=loomcycle__pb2.BroadcastChannelsRequest.FromString,
                    response_serializer=loomcycle__pb2.BroadcastChannelsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'loomcycle.v1.Loomcycle', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('loomcycle.v1.Loomcycle', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Loomcycle(object):
    """========================
    Service
    ========================

    """

    @staticmethod
    def Run(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/loomcycle.v1.Loomcycle/Run',
            loomcycle__pb2.RunRequest.SerializeToString,
            loomcycle__pb2.Event.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Continue(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/loomcycle.v1.Loomcycle/Continue',
            loomcycle__pb2.ContinueRequest.SerializeToString,
            loomcycle__pb2.Event.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SpawnRunBatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/SpawnRunBatch',
            loomcycle__pb2.BatchSpawnRequest.SerializeToString,
            loomcycle__pb2.BatchSpawnResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CompactRun(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/CompactRun',
            loomcycle__pb2.CompactRunRequest.SerializeToString,
            loomcycle__pb2.CompactRunResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DirectoryUsers(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/DirectoryUsers',
            loomcycle__pb2.DirectoryUsersRequest.SerializeToString,
            loomcycle__pb2.DirectoryUsersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DirectoryInspect(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/DirectoryInspect',
            loomcycle__pb2.DirectoryInspectRequest.SerializeToString,
            loomcycle__pb2.DirectoryInspectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DirectoryTenants(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/DirectoryTenants',
            loomcycle__pb2.DirectoryTenantsRequest.SerializeToString,
            loomcycle__pb2.DirectoryTenantsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ErasureReport(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ErasureReport',
            loomcycle__pb2.ErasureReportRequest.SerializeToString,
            loomcycle__pb2.ErasureReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ErasureExecute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ErasureExecute',
            loomcycle__pb2.ErasureExecuteRequest.SerializeToString,
            loomcycle__pb2.ErasureExecuteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReplaySession(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ReplaySession',
            loomcycle__pb2.ReplaySessionRequest.SerializeToString,
            loomcycle__pb2.ReplaySessionResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunInput(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/RunInput',
            loomcycle__pb2.RunInputRequest.SerializeToString,
            loomcycle__pb2.RunInputResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelTurn(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/CancelTurn',
            loomcycle__pb2.CancelTurnRequest.SerializeToString,
            loomcycle__pb2.CancelTurnResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResolveInterrupt(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ResolveInterrupt',
            loomcycle__pb2.ResolveInterruptRequest.SerializeToString,
            loomcycle__pb2.ResolveInterruptResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamRun(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/loomcycle.v1.Loomcycle/StreamRun',
            loomcycle__pb2.StreamRunRequest.SerializeToString,
            loomcycle__pb2.Event.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTranscript(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/GetTranscript',
            loomcycle__pb2.GetTranscriptRequest.SerializeToString,
            loomcycle__pb2.Transcript.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAgent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/GetAgent',
            loomcycle__pb2.GetAgentRequest.SerializeToString,
            loomcycle__pb2.Agent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelAgent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/CancelAgent',
            loomcycle__pb2.CancelAgentRequest.SerializeToString,
            loomcycle__pb2.CancelAgentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListUserAgents(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ListUserAgents',
            loomcycle__pb2.ListUserAgentsRequest.SerializeToString,
            loomcycle__pb2.ListUserAgentsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UsageReport(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/UsageReport',
            loomcycle__pb2.UsageReportRequest.SerializeToString,
            loomcycle__pb2.UsageReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TokenLimit(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/TokenLimit',
            loomcycle__pb2.TokenLimitRequest.SerializeToString,
            loomcycle__pb2.TokenLimitResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Health(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/Health',
            loomcycle__pb2.HealthRequest.SerializeToString,
            loomcycle__pb2.HealthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Config(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/Config',
            loomcycle__pb2.ConfigRequest.SerializeToString,
            loomcycle__pb2.ConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterHook(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/RegisterHook',
            loomcycle__pb2.RegisterHookRequest.SerializeToString,
            loomcycle__pb2.RegisterHookResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListHooks(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ListHooks',
            loomcycle__pb2.ListHooksRequest.SerializeToString,
            loomcycle__pb2.ListHooksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteHook(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/DeleteHook',
            loomcycle__pb2.DeleteHookRequest.SerializeToString,
            loomcycle__pb2.DeleteHookResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PauseRuntime(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/PauseRuntime',
            loomcycle__pb2.PauseRuntimeRequest.SerializeToString,
            loomcycle__pb2.PauseRuntimeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResumeRuntime(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ResumeRuntime',
            loomcycle__pb2.ResumeRuntimeRequest.SerializeToString,
            loomcycle__pb2.ResumeRuntimeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRuntimeState(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/GetRuntimeState',
            loomcycle__pb2.GetRuntimeStateRequest.SerializeToString,
            loomcycle__pb2.RuntimeStateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResolveProbe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ResolveProbe',
            loomcycle__pb2.ResolveProbeRequest.SerializeToString,
            loomcycle__pb2.ResolverMatrixResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/CreateSnapshot',
            loomcycle__pb2.CreateSnapshotRequest.SerializeToString,
            loomcycle__pb2.SnapshotDescriptor.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSnapshots(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ListSnapshots',
            loomcycle__pb2.ListSnapshotsRequest.SerializeToString,
            loomcycle__pb2.ListSnapshotsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/GetSnapshot',
            loomcycle__pb2.GetSnapshotRequest.SerializeToString,
            loomcycle__pb2.SnapshotEnvelope.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExportSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ExportSnapshot',
            loomcycle__pb2.ExportSnapshotRequest.SerializeToString,
            loomcycle__pb2.ExportSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RestoreSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/RestoreSnapshot',
            loomcycle__pb2.RestoreSnapshotRequest.SerializeToString,
            loomcycle__pb2.RestoreSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteSnapshot(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/DeleteSnapshot',
            loomcycle__pb2.DeleteSnapshotRequest.SerializeToString,
            loomcycle__pb2.DeleteSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AgentDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/AgentDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SkillDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/SkillDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MCPServerDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/MCPServerDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ScheduleDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ScheduleDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def A2AServerCardDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/A2AServerCardDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def A2AAgentDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/A2AAgentDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WebhookDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/WebhookDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MemoryBackendDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/MemoryBackendDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def OperatorTokenDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/OperatorTokenDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VolumeDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/VolumeDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TeamDef(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/TeamDef',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Path(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/Path',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Document(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/Document',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def History(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/History',
            loomcycle__pb2.SubstrateRequest.SerializeToString,
            loomcycle__pb2.SubstrateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListChannels(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/ListChannels',
            loomcycle__pb2.ListChannelsRequest.SerializeToString,
            loomcycle__pb2.ListChannelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamUserRunStates(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/loomcycle.v1.Loomcycle/StreamUserRunStates',
            loomcycle__pb2.StreamUserRunStatesRequest.SerializeToString,
            loomcycle__pb2.RunStateEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PublishChannel(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/PublishChannel',
            loomcycle__pb2.PublishChannelRequest.SerializeToString,
            loomcycle__pb2.PublishChannelResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SubscribeChannel(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/SubscribeChannel',
            loomcycle__pb2.SubscribeChannelRequest.SerializeToString,
            loomcycle__pb2.SubscribeChannelResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PeekChannel(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/PeekChannel',
            loomcycle__pb2.PeekChannelRequest.SerializeToString,
            loomcycle__pb2.PeekChannelResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AckChannel(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/AckChannel',
            loomcycle__pb2.AckChannelRequest.SerializeToString,
            loomcycle__pb2.AckChannelResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AwaitChannels(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/AwaitChannels',
            loomcycle__pb2.AwaitChannelsRequest.SerializeToString,
            loomcycle__pb2.AwaitChannelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def BroadcastChannels(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/loomcycle.v1.Loomcycle/BroadcastChannels',
            loomcycle__pb2.BroadcastChannelsRequest.SerializeToString,
            loomcycle__pb2.BroadcastChannelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
