workspace draft from a capability

src/wf_mcp/workflow_surface/handlers.py

@@ -678,6 +678,37 @@ class WorkflowSurfaceHandlers:
             draft=draft,
         )
 
+    async def create_draft_workspace_from_capability(
+        self,
+        *,
+        workspace_id: str,
+        capability_name: str,
+        name: str | None = None,
+        title: str | None = None,
+        input_schema: dict[str, Any] | None = None,
+        state_schema: dict[str, Any] | None = None,
+        output_schema: dict[str, Any] | None = None,
+        input_map: dict[str, str] | None = None,
+        output_map: dict[str, str] | None = None,
+        error_message_source: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a patchable draft workspace from inspect_capability hints."""
+        capability = await self.inspect_capability(qualified_name=capability_name)
+        hints = capability["wrapper_hints"]
+        result = await self.create_minimal_draft_workspace(
+            workspace_id=workspace_id,
+            name=name or _draft_name_from_capability(capability_name),
+            capability_name=capability_name,
+            input_schema=input_schema or hints["input_schema"],
+            state_schema=state_schema or hints["state_schema"],
+            output_schema=output_schema or hints["output_schema"],
+            input_map=input_map or hints["input_map"],
+            output_map=output_map or hints["output_map"],
+            error_message_source=error_message_source,
+            title=title,
+        )
+        return {**result, "wrapper_hints": hints}
+
     async def create_artifact_from_workspace(
         self,
         *,
@@ -993,6 +1024,11 @@ def _escape_json_pointer(value: str) -> str:
     return value.replace("~", "~0").replace("/", "~1")
 
 
+def _draft_name_from_capability(capability_name: str) -> str:
+    """Return a stable draft name when caller does not provide one."""
+    return capability_name.replace(".", "_").replace("-", "_")
+
+
 def _source_id_for_capability(
     sources: dict[str, CapabilitySource],
     qualified_name: str,

src/wf_mcp/workflow_surface/models.py

@@ -233,6 +233,61 @@ class CreateMinimalDraftWorkspaceRequest(BaseModel):
     title: str | None = Field(default=None, description="Optional workspace title.")
 
 
+class CreateDraftWorkspaceFromCapabilityRequest(BaseModel):
+    """Typed MCP request for bootstrapping a draft from wrapper hints."""
+
+    workspace_id: WorkspaceId
+    capability_name: str = Field(
+        description=(
+            "Workflow capability to inspect and call, such as "
+            "demo.default.echo_tool or workflow.echo_wrapper.v1."
+        )
+    )
+    name: str | None = Field(
+        default=None,
+        description="Optional workflow draft name. Defaults to a safe capability name.",
+    )
+    title: str | None = Field(default=None, description="Optional workspace title.")
+    input_schema: JsonSchemaObject | None = Field(
+        default=None,
+        description="Optional override for the hinted public input schema.",
+    )
+    state_schema: JsonSchemaObject | None = Field(
+        default=None,
+        description="Optional override for the hinted workflow state schema.",
+    )
+    output_schema: JsonSchemaObject | None = Field(
+        default=None,
+        description="Optional override for the hinted public output schema.",
+    )
+    input_map: DraftPathMap | None = Field(
+        default=None,
+        description="Optional override for the hinted workflow input map.",
+    )
+    output_map: DraftPathMap | None = Field(
+        default=None,
+        description="Optional override for the hinted capability output map.",
+    )
+    error_message_source: str | None = Field(
+        default=None,
+        description=(
+            "Optional state path used as runtime_error.message when the capability "
+            "has an error outcome, for example state.error_message."
+        ),
+    )
+
+
+class CreateDraftWorkspaceFromCapabilityResult(DraftWorkspaceResult):
+    """Draft workspace result plus the wrapper hints used to bootstrap it."""
+
+    wrapper_hints: dict[str, Any] = Field(
+        description=(
+            "The wrapper_hints payload used before applying request overrides. "
+            "Use this to patch uncertain maps or schemas by revision."
+        )
+    )
+
+
 class CreateArtifactFromWorkspaceRequest(BaseModel):
     """Typed MCP request payload for saving a draft workspace as an artifact."""
 

src/wf_mcp/workflow_surface/tools.py

@@ -12,6 +12,8 @@ from .handlers import WorkflowSurfaceHandlers
 from .models import (
     CallCapabilityResult,
     CreateArtifactFromWorkspaceRequest,
+    CreateDraftWorkspaceFromCapabilityRequest,
+    CreateDraftWorkspaceFromCapabilityResult,
     CreateDraftWorkspaceRequest,
     CreateMinimalDraftWorkspaceRequest,
     CreateWrapperFromWorkspaceRequest,
@@ -395,6 +397,32 @@ def register_workflow_tools(server: FastMCP[Any], service: WfMcpService) -> None
             )
         )
 
+    @server.tool(
+        name="wf.workflow.create_draft_workspace_from_capability",
+        title="Create Draft Workspace From Capability",
+        description=(
+            "Inspect one capability, use its wrapper_hints to bootstrap a "
+            "patchable draft workspace, and return the hints used."
+        ),
+    )
+    async def create_draft_workspace_from_capability(
+        request: CreateDraftWorkspaceFromCapabilityRequest,
+    ) -> CreateDraftWorkspaceFromCapabilityResult:
+        return CreateDraftWorkspaceFromCapabilityResult.model_validate(
+            await handlers.create_draft_workspace_from_capability(
+                workspace_id=request.workspace_id,
+                capability_name=request.capability_name,
+                name=request.name,
+                title=request.title,
+                input_schema=request.input_schema,
+                state_schema=request.state_schema,
+                output_schema=request.output_schema,
+                input_map=request.input_map,
+                output_map=request.output_map,
+                error_message_source=request.error_message_source,
+            )
+        )
+
     @server.tool(
         name="wf.workflow.create_artifact_from_workspace",
         title="Create Workflow Artifact From Workspace",