Sutra

Instructions

    Args:
        claim: The headline answer or assertion to validate.
        reasoning_trace: The supporting chain-of-thought or proof steps.
        constraints: Optional guardrails (requirements, risk limits).

    Returns:
        Structured prompt that audits assumptions, inference steps, and
        evidence, then proposes patches for any defects.
    

Implementation Reference

• src/context_engineering_mcp/cognitive/thinking_models.py:115-169 (handler)

  Core handler function for the 'verify_logic' tool. Decorated with @mcp.tool(), validates input using VerifyLogicInput schema, and returns a formatted protocol template for verifying reasoning logic.

      @mcp.tool()
      def verify_logic(
          claim: str,
          reasoning_trace: str,
          constraints: Optional[str] = None,
      ) -> str:
          """Generate a verification protocol for a reasoning trace.
  
          Args:
              claim: The headline answer or assertion to validate.
              reasoning_trace: The supporting chain-of-thought or proof steps.
              constraints: Optional guardrails (requirements, risk limits).
  
          Returns:
              Structured prompt that audits assumptions, inference steps, and
              evidence, then proposes patches for any defects.
          """
          try:
              model = VerifyLogicInput(
                  claim=claim, reasoning_trace=reasoning_trace, constraints=constraints
              )
          except ValidationError as e:
              return f"Input Validation Error: {e}"
  
          normalized_constraints = model.constraints or "<none>"
  
          template = """
  /reasoning.verify_logic{{
      intent="Audit a reasoning trace for validity, completeness, and constraint alignment",
      input={{
          claim="{claim}",
          reasoning_trace="{reasoning_trace}",
          constraints="{constraints}"
      }},
      process=[
          /premise_check{{action="List premises and mark which are stated vs. assumed"}},
          /consistency{{action="Check each step for logical validity and missing links"}},
          /evidence_map{{action="Match claims to evidence or note gaps"}},
          /contra{{action="Search for contradictions or constraint violations"}},
          /repair_plan{{action="Suggest minimal edits or extra steps to fix defects"}}
      ],
      output={{
          verdict="pass|fail with one sentence rationale",
          defect_log="Numbered list of issues with locations in the trace",
          patched_plan="Revised steps or guardrails to repair the reasoning",
          confidence="0-1 score grounded in evidence coverage and consistency"
      }}
  }}
  """
          return template.format(
              claim=model.claim,
              reasoning_trace=model.reasoning_trace,
              constraints=normalized_constraints,
          )

• src/context_engineering_mcp/cognitive/thinking_models.py:21-29 (schema)

  Pydantic BaseModel defining the input schema for the verify_logic tool, with fields for claim, reasoning_trace, and optional constraints.

  class VerifyLogicInput(BaseModel):
      claim: str = Field(
          ..., min_length=3, description="The headline answer or assertion to validate."
      )
      reasoning_trace: str = Field(
          ..., min_length=10, description="The supporting chain-of-thought."
      )
      constraints: Optional[str] = Field(None, description="Optional guardrails.")

• src/context_engineering_mcp/server.py:22-22 (registration)

  Invocation of register_thinking_models(mcp) which applies @mcp.tool() decorators to register the verify_logic tool (and other thinking models) on the FastMCP server instance.

  register_thinking_models(mcp)