refactor: group rpc transport client and methods

2026-06-08 21:44:41 +07:00
parent 7582c1d6fb
commit c39d361873
25 changed files with 104 additions and 114 deletions
@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import (
+    AdminEmptyParams,
+    DeleteAuthParams,
+    InspectAuthParams,
+    SaveAuthParams,
+)
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register read-only admin/config JSON-RPC methods."""
+
+    @entrypoint.method(
+        name="workflow.admin.connections.list",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_connections_list(
+        params: AdminEmptyParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.list_connections()
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.connection_statuses.list",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_connection_statuses_list(
+        params: AdminEmptyParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.get_connection_statuses()
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.events.list",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_events_list(
+        params: AdminEmptyParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.list_events()
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.auth.list",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_auth_list(
+        params: AdminEmptyParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.list_auth_records()
+        except (
+            ValueError,
+            KeyError,
+            LookupError,
+            FileNotFoundError,
+            RuntimeError,
+        ) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.auth.inspect",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_auth_inspect(
+        params: InspectAuthParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.inspect_auth_record(params.auth_ref)
+        except (
+            ValueError,
+            KeyError,
+            LookupError,
+            FileNotFoundError,
+            RuntimeError,
+        ) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.auth.save",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_auth_save(
+        params: SaveAuthParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.save_auth_record(
+                auth_ref=params.auth_ref,
+                scheme=params.scheme,
+                payload=params.payload,
+                metadata=params.metadata,
+            )
+        except (
+            ValueError,
+            KeyError,
+            LookupError,
+            FileNotFoundError,
+            RuntimeError,
+        ) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.auth.delete",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_auth_delete(
+        params: DeleteAuthParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.admin.delete_auth_record(params.auth_ref)
+        except (
+            ValueError,
+            KeyError,
+            LookupError,
+            FileNotFoundError,
+            RuntimeError,
+        ) as exc:
+            raise_workflow_rpc_error(exc)
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import InspectArtifactParams, ListArtifactsParams, SaveArtifactParams
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register artifact JSON-RPC methods."""
+
+    @entrypoint.method(name="workflow.artifacts.save", errors=[WorkflowRpcError])
+    async def workflow_artifacts_save(
+        params: SaveArtifactParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.save_artifact(params.artifact)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.artifacts.list", errors=[WorkflowRpcError])
+    async def workflow_artifacts_list(
+        params: ListArtifactsParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.list_artifacts(
+                query=params.query,
+                kind=params.kind,
+                cursor=params.cursor,
+                limit=params.limit,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.artifacts.inspect", errors=[WorkflowRpcError])
+    async def workflow_artifacts_inspect(
+        params: InspectArtifactParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.inspect_artifact(
+                artifact_id=params.artifact_id,
+                version=params.version,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import InspectCapabilityParams, ListCapabilitiesParams
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register capability discovery JSON-RPC methods."""
+
+    @entrypoint.method(name="workflow.capabilities.list", errors=[WorkflowRpcError])
+    async def workflow_capabilities_list(
+        params: ListCapabilitiesParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.list_capabilities(
+                query=params.query,
+                source_id=params.source_id,
+                cursor=params.cursor,
+                limit=params.limit,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.capabilities.inspect", errors=[WorkflowRpcError])
+    async def workflow_capabilities_inspect(
+        params: InspectCapabilityParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.inspect_capability(
+                qualified_name=params.qualified_name,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import (
+    DeleteDeploymentParams,
+    InspectDeploymentParams,
+    ListDeploymentsParams,
+    SaveDeploymentParams,
+    ValidateDeploymentParams,
+)
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register deployment JSON-RPC methods."""
+
+    @entrypoint.method(name="workflow.deployments.save", errors=[WorkflowRpcError])
+    async def workflow_deployments_save(
+        params: SaveDeploymentParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.save_deployment(params.deployment)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.deployments.validate", errors=[WorkflowRpcError])
+    async def workflow_deployments_validate(
+        params: ValidateDeploymentParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.validate_deployment(
+                deployment_id=params.deployment_id,
+                live_check=params.live_check,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.deployments.list", errors=[WorkflowRpcError])
+    async def workflow_deployments_list(
+        params: ListDeploymentsParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.list_deployments()
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.deployments.inspect", errors=[WorkflowRpcError])
+    async def workflow_deployments_inspect(
+        params: InspectDeploymentParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.inspect_deployment(
+                deployment_id=params.deployment_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.deployments.delete", errors=[WorkflowRpcError])
+    async def workflow_deployments_delete(
+        params: DeleteDeploymentParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.delete_deployment(
+                deployment_id=params.deployment_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import (
+    CreateArtifactFromWorkspaceParams,
+    CreateDraftFromCapabilityParams,
+    CreateWrapperFromWorkspaceParams,
+    GetDraftWorkspaceParams,
+    ListDraftWorkspacesParams,
+    PatchDraftParams,
+    PatchDraftWorkspaceParams,
+    ValidateDraftParams,
+    ValidateDraftWorkspaceParams,
+)
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register draft and draft-workspace JSON-RPC methods."""
+
+    @entrypoint.method(
+        name="workflow.drafts.create_from_capability", errors=[WorkflowRpcError]
+    )
+    async def workflow_drafts_create_from_capability(
+        params: CreateDraftFromCapabilityParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await _create_from_capability(server, params)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.drafts.patch", errors=[WorkflowRpcError])
+    async def workflow_drafts_patch(
+        params: PatchDraftParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.patch_draft(draft=params.draft, patch=params.patch)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.drafts.validate", errors=[WorkflowRpcError])
+    async def workflow_drafts_validate(
+        params: ValidateDraftParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.validate_draft(draft=params.draft)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.draft_workspaces.list", errors=[WorkflowRpcError])
+    async def workflow_draft_workspaces_list(
+        params: ListDraftWorkspacesParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.list_draft_workspaces()
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.draft_workspaces.get", errors=[WorkflowRpcError])
+    async def workflow_draft_workspaces_get(
+        params: GetDraftWorkspaceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.get_draft_workspace(
+                workspace_id=params.workspace_id,
+                include_draft=params.include_draft,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.draft_workspaces.create_from_capability",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_draft_workspaces_create_from_capability(
+        params: CreateDraftFromCapabilityParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await _create_from_capability(server, params)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.draft_workspaces.patch", errors=[WorkflowRpcError]
+    )
+    async def workflow_draft_workspaces_patch(
+        params: PatchDraftWorkspaceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.patch_draft_workspace(
+                workspace_id=params.workspace_id,
+                revision=params.revision,
+                patch=params.patch,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.draft_workspaces.validate", errors=[WorkflowRpcError]
+    )
+    async def workflow_draft_workspaces_validate(
+        params: ValidateDraftWorkspaceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.validate_draft_workspace(
+                workspace_id=params.workspace_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.draft_workspaces.create_artifact", errors=[WorkflowRpcError]
+    )
+    async def workflow_draft_workspaces_create_artifact(
+        params: CreateArtifactFromWorkspaceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.create_artifact_from_workspace(
+                workspace_id=params.workspace_id,
+                artifact_id=params.artifact_id,
+                version=params.version,
+                title=params.title,
+                outcomes=tuple(params.outcomes),
+                kind=params.kind,
+                description=params.description,
+                required_capabilities=params.required_capabilities,
+                source_bindings=params.source_bindings,
+                created_from_catalog_version=params.created_from_catalog_version,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.draft_workspaces.create_wrapper", errors=[WorkflowRpcError]
+    )
+    async def workflow_draft_workspaces_create_wrapper(
+        params: CreateWrapperFromWorkspaceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.create_wrapper_from_workspace(
+                workspace_id=params.workspace_id,
+                artifact_id=params.artifact_id,
+                version=params.version,
+                title=params.title,
+                outcomes=tuple(params.outcomes),
+                description=params.description,
+                required_capabilities=params.required_capabilities,
+                source_bindings=params.source_bindings,
+                created_from_catalog_version=params.created_from_catalog_version,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+
+async def _create_from_capability(
+    server: WorkflowServer,
+    params: CreateDraftFromCapabilityParams,
+) -> dict[str, Any]:
+    return await server.api.create_draft_workspace_from_capability(
+        workspace_id=params.workspace_id,
+        capability_name=params.capability_name,
+        name=params.name,
+        title=params.title,
+        input_schema=params.input_schema,
+        state_schema=params.state_schema,
+        output_schema=params.output_schema,
+        input=params.input,
+        output=params.output,
+        input_map=params.input_map,
+        output_map=params.output_map,
+        error_message_source=params.error_message_source,
+    )
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import (
+    InspectRunParams,
+    ReadRunTraceParams,
+    ResumeRunParams,
+    StartRunParams,
+)
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register run lifecycle JSON-RPC methods."""
+
+    @entrypoint.method(name="workflow.runs.start", errors=[WorkflowRpcError])
+    async def workflow_runs_start(
+        params: StartRunParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.run_deployment(
+                deployment_id=params.deployment_id,
+                workflow_input=params.workflow_input,
+                trace_range=(
+                    params.trace_range.to_api_trace_range()
+                    if params.trace_range is not None
+                    else None
+                ),
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.runs.inspect", errors=[WorkflowRpcError])
+    async def workflow_runs_inspect(
+        params: InspectRunParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.inspect_run(run_id=params.run_id)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.runs.trace", errors=[WorkflowRpcError])
+    async def workflow_runs_trace(
+        params: ReadRunTraceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.read_run_trace(
+                run_id=params.run_id,
+                trace_range=params.trace_range.to_api_trace_range(),
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.runs.resume", errors=[WorkflowRpcError])
+    async def workflow_runs_resume(
+        params: ResumeRunParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.api.resume_run(
+                run_id=params.run_id,
+                resume_payload=params.resume_payload,
+                resume_outcome=params.resume_outcome,
+                trace_range=(
+                    params.trace_range.to_api_trace_range()
+                    if params.trace_range is not None
+                    else None
+                ),
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_api import WorkflowSourceRegistrySurface
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import (
+    AddRegistryEntryParams,
+    ApplyRegistryChangesParams,
+    InspectRegistryEntryParams,
+    ListRegistryEntriesParams,
+    RegistryEntryIdParams,
+    UpdateRegistryEntryParams,
+)
+from ..params import RpcParams
+
+
+def _require_source_registry_admin(
+    server: WorkflowServer,
+    *,
+    operation: str,
+) -> WorkflowSourceRegistrySurface:
+    admin = server.source_registry_admin
+    if admin is None:
+        raise WorkflowRpcError(
+            data={
+                "code": "source_registry_unavailable",
+                "message": (
+                    f"source registry admin {operation} are not available "
+                    "for this server"
+                ),
+            }
+        )
+    return admin
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register source registry JSON-RPC methods."""
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.list",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_list(
+        params: ListRegistryEntriesParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="reads")
+        try:
+            return await admin.list_registry_entries(
+                cursor=params.cursor,
+                limit=params.limit,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.inspect",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_inspect(
+        params: InspectRegistryEntryParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="reads")
+        try:
+            return await admin.inspect_registry_entry(
+                source_id=params.source_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.add",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_add(
+        params: AddRegistryEntryParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="mutations")
+        try:
+            return await admin.add_registry_entry(
+                entry=params.entry,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.update",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_update(
+        params: UpdateRegistryEntryParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="mutations")
+        try:
+            return await admin.update_registry_entry(
+                source_id=params.source_id,
+                patch=params.patch,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.enable",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_enable(
+        params: RegistryEntryIdParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="mutations")
+        try:
+            return await admin.enable_registry_entry(
+                source_id=params.source_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.disable",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_disable(
+        params: RegistryEntryIdParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="mutations")
+        try:
+            return await admin.disable_registry_entry(
+                source_id=params.source_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.remove",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_remove(
+        params: RegistryEntryIdParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="mutations")
+        try:
+            return await admin.remove_registry_entry(
+                source_id=params.source_id,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(
+        name="workflow.admin.source_registry.apply",
+        errors=[WorkflowRpcError],
+    )
+    async def workflow_admin_source_registry_apply(
+        params: ApplyRegistryChangesParams = RpcParams(),
+    ) -> dict[str, Any]:
+        admin = _require_source_registry_admin(server, operation="apply")
+        try:
+            return await admin.apply_registry_changes()
+        except (
+            ValueError,
+            KeyError,
+            LookupError,
+            FileNotFoundError,
+            RuntimeError,
+        ) as exc:
+            raise_workflow_rpc_error(exc)
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+import fastapi_jsonrpc as jsonrpc
+
+from wf_server import WorkflowServer
+
+from ..errors import WorkflowRpcError, raise_workflow_rpc_error
+from ..models import InspectSourceParams, ListSourcesParams
+from ..params import RpcParams
+
+
+def register_methods(
+    entrypoint: jsonrpc.Entrypoint,
+    server: WorkflowServer,
+) -> None:
+    """Register read-only source/admin JSON-RPC methods."""
+
+    @entrypoint.method(name="workflow.sources.list", errors=[WorkflowRpcError])
+    async def workflow_sources_list(
+        params: ListSourcesParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.source_admin.list_sources(
+                cursor=params.cursor,
+                limit=params.limit,
+            )
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)
+
+    @entrypoint.method(name="workflow.sources.inspect", errors=[WorkflowRpcError])
+    async def workflow_sources_inspect(
+        params: InspectSourceParams = RpcParams(),
+    ) -> dict[str, Any]:
+        try:
+            return await server.source_admin.inspect_source(source_id=params.source_id)
+        except (ValueError, KeyError, LookupError, FileNotFoundError) as exc:
+            raise_workflow_rpc_error(exc)