manus_project_create

Instructions

Implementation Reference

• manus_mcp/tools/projects.py:23-30 (handler)

  Handler function for the manus_project_create tool. Sends a POST request to /v2/project.create with the input schema body and returns a ProjectCreateResponse.

  async def project_create(req: ProjectCreateRequest, ctx: ToolCtx) -> ProjectCreateResponse:
      return await ctx.client.call(
          "POST",
          "/v2/project.create",
          json_body=req,
          response_model=ProjectCreateResponse,
          rate_limit_key="project.create",
      )

• manus_mcp/schemas/projects.py:18-20 (schema)

  Input schema for project creation: requires a name and optionally an instruction.

  class ProjectCreateRequest(ManusModel):
      name: str
      instruction: str | None = None

• manus_mcp/schemas/projects.py:23-24 (schema)

  Output schema wrapping a ProjectRecord in the standard response envelope.

  class ProjectCreateResponse(ResponseEnvelope):
      project: ProjectRecord

• manus_mcp/tools/projects.py:14-22 (registration)

  Registration of the tool via the @manus_tool decorator. This stores the ToolDef in the global _REGISTRY dict with name, description, and schemas.

  @manus_tool(
      name="manus_project_create",
      description=(
          "Create a new project with an optional default instruction that will be applied to "
          "every task created with this project_id."
      ),
      input_schema=ProjectCreateRequest,
      output_schema=ProjectCreateResponse,
  )

• manus_mcp/tools/registry.py:28-80 (helper)

  The @manus_tool decorator and ToolDef data class that power tool registration. The decorator stores the tool's metadata and handler into the _REGISTRY dictionary.

  class ToolDef(Generic[TIn, TOut]):
      """Metadata + handler for a single MCP tool."""
  
      name: str
      description: str
      input_schema: type[TIn]
      output_schema: type[TOut]
      handler: Callable[[TIn, ToolCtx], Awaitable[TOut]]
      rate_limit_key: str | None = None
  
  
  _REGISTRY: dict[str, ToolDef[Any, Any]] = {}
  
  
  def manus_tool(
      *,
      name: str,
      description: str,
      input_schema: type[TIn],
      output_schema: type[TOut],
      rate_limit_key: str | None = None,
  ) -> Callable[
      [Callable[[TIn, ToolCtx], Awaitable[TOut]]], Callable[[TIn, ToolCtx], Awaitable[TOut]]
  ]:
      """Decorator registering `handler` as a tool with the given metadata."""
  
      def wrap(
          handler: Callable[[TIn, ToolCtx], Awaitable[TOut]],
      ) -> Callable[[TIn, ToolCtx], Awaitable[TOut]]:
          if name in _REGISTRY:
              raise RuntimeError(f"Duplicate tool name: {name}")
          _REGISTRY[name] = ToolDef(
              name=name,
              description=description,
              input_schema=input_schema,
              output_schema=output_schema,
              handler=handler,
              rate_limit_key=rate_limit_key,
          )
          return handler
  
      return wrap
  
  
  def all_tools() -> list[ToolDef[Any, Any]]:
      """Return a stable-ordered copy of every registered tool."""
      return sorted(_REGISTRY.values(), key=lambda t: t.name)
  
  
  def clear_registry() -> None:
      """Test helper."""
      _REGISTRY.clear()