promptflow-webmcp.netlify.app

{
  "name": "architect_system",
  "kind": "act",
  "impl": "imperative",
  "description": "PRIMARY PromptFlow Agent OS tool. Turn an arbitrary product/system brief into a complete live architecture in one round-trip. For best semantic fidelity, the AI agent should provide its inferred components and connections; PromptFlow validates, applies, scales, structurally repairs, lays out, and verifies the graph atomically. If components are omitted, PromptFlow falls back to its fast local intent compiler.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "request": {
        "type": "string",
        "maxLength": 2400,
        "description": "The user's complete product/system brief. Preserve important domain, scale, realtime, security, data, AI, media, and integration constraints."
      },
      "targetUsers": {
        "type": "number",
        "description": "Optional explicit user-scale target. Omit when the brief contains no meaningful scale requirement."
      },
      "replaceCurrent": {
        "type": "boolean",
        "description": "Replace the current canvas before building. Defaults to true. Set false only when ids are guaranteed not to conflict with existing nodes."
      },
      "autoFix": {
        "type": "boolean",
        "description": "Automatically repair deterministic structural findings after the initial build. Defaults to true."
      },
      "components": {
        "type": "array",
        "maxItems": 40,
        "items": {
          "type": "object",
          "properties": {
            "id": {
              "type": "string",
              "maxLength": 120,
              "description": "Stable unique component id using lowercase kebab-case when possible."
            },
            "label": {
              "type": "string",
              "maxLength": 160,
              "description": "Human-readable software component name."
            },
            "type": {
              "type": "string",
              "enum": [
                "frontend",
                "backend",
                "api",
                "database",
                "cache",
                "queue",
                "payment",
                "auth",
                "service",
                "external",
                "gateway",
                "worker",
                "cdn",
                "observability"
              ]
            },
            "description": {
              "type": "string",
              "maxLength": 800,
              "description": "Concise responsibility and architectural purpose."
            }
          },
          "required": [
            "id",
            "label",
            "type",
            "description"
          ],
          "additionalProperties": false
        },
        "description": "Optional agent-authored architecture plan. For arbitrary briefs, provide the components you infer semantically so PromptFlow can apply the whole plan in one tool call. Omit to use PromptFlow's local intent compiler fallback."
      },
      "connections": {
        "type": "array",
        "maxItems": 80,
        "items": {
          "type": "object",
          "properties": {
            "sourceId": {
              "type": "string",
              "maxLength": 120
            },
            "targetId": {
              "type": "string",
              "maxLength": 120
            },
            "label": {
              "type": "string",
              "maxLength": 160
            }
          },
          "required": [
            "sourceId",
            "targetId"
          ],
          "additionalProperties": false
        },
        "description": "Relationships between the optional agent-authored components."
      }
    },
    "required": [
      "request"
    ],
    "additionalProperties": false
  }
}

{
  "name": "analyze_architecture",
  "kind": "answer",
  "impl": "imperative",
  "description": "Read the live PromptFlow graph and return structural audit, architecture metrics, represented capabilities, and graph counts without mutating the canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "recommend_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Act like a senior architecture reviewer. Return prioritized structural, scale, security-boundary, and observability recommendations. Recommendations are explicit and do not mutate the graph.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "description": "Optional future scale target used to include capacity recommendations."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "simulate_architecture_scale",
  "kind": "act",
  "impl": "imperative",
  "description": "Run a non-destructive what-if simulation for a target scale. Return the exact projected operations plus before/after metrics and audits so the agent can reason before changing the live architecture.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "description": "Target user/traffic scale to simulate."
      }
    },
    "required": [
      "targetUsers"
    ],
    "additionalProperties": false
  }
}

{
  "name": "apply_architecture_recommendations",
  "kind": "act",
  "impl": "imperative",
  "description": "Apply deterministic structural fixes and/or a requested scale plan in one agent round-trip, then auto-layout and verify the resulting architecture.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "fixStructural": {
        "type": "boolean",
        "description": "Apply deterministic fixes for the latest structural findings. Defaults to true."
      },
      "targetUsers": {
        "type": "number",
        "description": "Optional target scale. When supplied, apply PromptFlow's deterministic scaling patterns in the same transaction flow."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "explain_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Explain the whole architecture or one component using the live graph as source of truth, including upstream/downstream dependencies and represented capabilities.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "nodeId": {
        "type": "string",
        "maxLength": 120,
        "description": "Optional component id. Omit for a whole-system explanation."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "generate_implementation_plan",
  "kind": "act",
  "impl": "imperative",
  "description": "Convert the live architecture into an ordered implementation plan with foundation, core services, delivery, integrations, and recommended first code targets. This is planning metadata; it does not fabricate source code.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "assess_architecture_intelligence",
  "kind": "act",
  "impl": "imperative",
  "description": "Run the full architecture-intelligence review across reliability, scalability, performance, security, resilience, observability, stress readiness, findings, recommendations, and Architecture DNA. This is a deterministic heuristic preflight, not a security certification or capacity guarantee.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000,
        "description": "Optional target user scale for the stress-readiness assessment."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "stress_test_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Run a non-destructive heuristic scale and failure-pressure simulation for a concrete target population. Returns modelled RPS pressure, bottlenecks, failure modes, and projected intelligence.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000,
        "description": "Projected user population for the heuristic stress scenario."
      }
    },
    "required": [
      "targetUsers"
    ],
    "additionalProperties": false
  }
}

{
  "name": "get_architecture_dna",
  "kind": "answer",
  "impl": "imperative",
  "description": "Return the architecture's deterministic DNA: archetype, structural fingerprint, traits, strengths, and likely bottlenecks.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "apply_intelligence_recommendations",
  "kind": "act",
  "impl": "imperative",
  "description": "Apply selected safe architecture-intelligence recommendations as a validated batch, then re-assess the live graph. Review-only recommendations intentionally produce no mutation.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "recommendationIds": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 120
        },
        "minItems": 1,
        "maxItems": 20,
        "description": "Recommendation ids returned by assess_architecture_intelligence."
      },
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000,
        "description": "Optional scale target used when selecting scale recommendations."
      }
    },
    "required": [
      "recommendationIds"
    ],
    "additionalProperties": false
  }
}

{
  "name": "run_digital_twin",
  "kind": "act",
  "impl": "imperative",
  "description": "Run a non-destructive multi-scenario digital-twin simulation against the live architecture. Model load spikes, component failures, dependency failures, and regional outages, including failure propagation, survivability, recovery strategy, and critical paths.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000,
        "description": "Optional user scale for the load scenario."
      },
      "scenarios": {
        "type": "array",
        "minItems": 1,
        "maxItems": 8,
        "items": {
          "type": "object",
          "properties": {
            "kind": {
              "type": "string",
              "enum": [
                "load-spike",
                "database-failure",
                "compute-failure",
                "cache-failure",
                "queue-failure",
                "external-dependency-failure",
                "region-outage"
              ]
            },
            "label": {
              "type": "string",
              "maxLength": 160
            },
            "targetUsers": {
              "type": "number",
              "minimum": 1,
              "maximum": 1000000000
            },
            "targetNodeId": {
              "type": "string",
              "maxLength": 120
            }
          },
          "required": [
            "kind",
            "label"
          ],
          "additionalProperties": false
        }
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "simulate_failure",
  "kind": "act",
  "impl": "imperative",
  "description": "Inject a named failure into the architecture model without changing the live canvas. Return affected components, propagation depth, failure modes, survivability, and recovery strategy.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "kind": {
        "type": "string",
        "enum": [
          "database-failure",
          "compute-failure",
          "cache-failure",
          "queue-failure",
          "external-dependency-failure",
          "region-outage"
        ]
      },
      "targetNodeId": {
        "type": "string",
        "maxLength": 120
      }
    },
    "required": [
      "kind"
    ],
    "additionalProperties": false
  }
}

{
  "name": "simulate_load",
  "kind": "act",
  "impl": "imperative",
  "description": "Model a production traffic spike for a target population without mutating the architecture. Return estimated sustained/burst RPS, bottlenecks, survivability, and hardening priorities.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000
      }
    },
    "required": [
      "targetUsers"
    ],
    "additionalProperties": false
  }
}

{
  "name": "apply_digital_twin_hardening",
  "kind": "act",
  "impl": "imperative",
  "description": "Apply safe, deterministic hardening derived from the digital-twin model: scale patterns, observability, and cache where appropriate. Validate the batch, re-layout, then return the post-hardening simulation and audit.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "assess_implementation_readiness",
  "kind": "act",
  "impl": "imperative",
  "description": "Review the live architecture as an implementation lead. Return a deterministic readiness score, component work map, risks, missing code artifacts, and production-oriented test targets. This is planning intelligence, not generated source code.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "generate_project_blueprint",
  "kind": "act",
  "impl": "imperative",
  "description": "Translate the live architecture into a concrete implementation blueprint: project structure, ordered delivery phases, component files, environment contract, risks, tests, and recommended first files. Does not mutate the canvas or pretend to generate source code.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "includeTests": {
        "type": "boolean",
        "description": "Whether to include the generated test strategy. Defaults to true."
      },
      "includeEnvironment": {
        "type": "boolean",
        "description": "Whether to include environment and secret requirements. Defaults to true."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "generate_implementation_contracts",
  "kind": "act",
  "impl": "imperative",
  "description": "Map every represented architecture relationship into an implementation contract with boundary kind, inputs, outputs, and reliability requirements. Use this before writing service-to-service, event, data, or external integration code.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "generate_project_code",
  "kind": "act",
  "impl": "imperative",
  "description": "Generate a bounded, inspectable project scaffold from the live architecture: manifest, runtime configuration, source boundaries, tests, contracts documentation, and architecture documentation. This mutates only the generated artifact workspace, not the architecture graph.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "includeTests": {
        "type": "boolean",
        "description": "Include executable test scaffolds. Defaults to true."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "validate_generated_project",
  "kind": "act",
  "impl": "imperative",
  "description": "Validate the current generated project artifact set for manifest, executable source, tests, path integrity, and execution readiness without changing files or the canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "run_project_execution_preflight",
  "kind": "act",
  "impl": "imperative",
  "description": "Evaluate whether the generated project is ready for install, test, build, and local execution. This is a static browser-side preflight; it does not execute arbitrary generated code.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "review_generated_project",
  "kind": "act",
  "impl": "imperative",
  "description": "Run a deterministic production-code review over generated artifacts for secrets, unfinished markers, missing contracts, tests, manifests, and entrypoints. This is a heuristic review, not a security certification.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "prepare_build_workspace",
  "kind": "act",
  "impl": "imperative",
  "description": "Materialize the current generated artifacts as an inspectable browser-side build workspace with a manifest and execution preflight. No arbitrary code is executed.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "export_project_artifacts",
  "kind": "act",
  "impl": "imperative",
  "description": "Export the current generated project and PromptFlow workspace manifest as a standards-compatible ZIP directly from the browser. No server upload is performed.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "run_project_execution_loop",
  "kind": "act",
  "impl": "imperative",
  "description": "Execute the generated Node.js/React project inside an isolated browser-native WebContainer: mount artifacts, install dependencies, run tests, run the production build, diagnose failures, and apply a bounded deterministic self-healing patch before retrying. Host-page code is never executed.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "maxHealingAttempts": {
        "type": "number",
        "minimum": 0,
        "maximum": 3
      },
      "installTimeoutMs": {
        "type": "number",
        "minimum": 10000,
        "maximum": 180000
      },
      "commandTimeoutMs": {
        "type": "number",
        "minimum": 10000,
        "maximum": 120000
      },
      "enableSelfHealing": {
        "type": "boolean"
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "diagnose_execution_failure",
  "kind": "answer",
  "impl": "imperative",
  "description": "Classify the latest execution failure into a bounded diagnostic category with evidence and confidence. This tool never mutates the project.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "run_final_hackathon_demo",
  "kind": "act",
  "impl": "imperative",
  "description": "Run the deterministic end-to-end showcase over the current architecture: structural audit, architecture intelligence, load simulation, severe traffic digital twin, implementation intelligence, project generation, execution preflight, and Architecture DNA. Results are stored without mutating the architecture.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 1,
        "maximum": 1000000000
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "create_architecture_version",
  "kind": "act",
  "impl": "imperative",
  "description": "Create an immutable architecture checkpoint containing the full graph, fingerprint, audit score, and Architecture DNA. Version history stays local to the current browser session.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "maxLength": 120,
        "description": "Optional human-readable version name."
      },
      "message": {
        "type": "string",
        "maxLength": 400,
        "description": "Short reason or release note for this architecture checkpoint."
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "list_architecture_versions",
  "kind": "answer",
  "impl": "imperative",
  "description": "Return the local architecture release history with version number, fingerprint, graph size, audit score, and release message.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "compare_architecture_versions",
  "kind": "answer",
  "impl": "imperative",
  "description": "Diff two immutable architecture checkpoints by component identity and dependency topology. Classify breaking, significant, and non-breaking changes without mutating the canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "fromVersion": {
        "type": "number",
        "minimum": 1
      },
      "toVersion": {
        "type": "number",
        "minimum": 1
      }
    },
    "required": [
      "fromVersion",
      "toVersion"
    ],
    "additionalProperties": false
  }
}

{
  "name": "plan_architecture_migration",
  "kind": "act",
  "impl": "imperative",
  "description": "Turn a version diff into an ordered production migration plan covering database compatibility, data backfills, API contracts, infrastructure rollout, application cutover, preflight checks, and rollback.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "fromVersion": {
        "type": "number",
        "minimum": 1
      },
      "toVersion": {
        "type": "number",
        "minimum": 1
      }
    },
    "required": [
      "fromVersion",
      "toVersion"
    ],
    "additionalProperties": false
  }
}

{
  "name": "restore_architecture_version",
  "kind": "act",
  "impl": "imperative",
  "description": "Restore a previous immutable architecture checkpoint into the live canvas. All downstream audit, intelligence, simulation, implementation, code, workspace, and execution artifacts are invalidated.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "version": {
        "type": "number",
        "minimum": 1
      },
      "versionId": {
        "type": "string",
        "maxLength": 120
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "clear_version_analysis",
  "kind": "act",
  "impl": "imperative",
  "description": "Clear the currently displayed version diff and migration plan while preserving immutable architecture history.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "run_production_qa",
  "kind": "act",
  "impl": "imperative",
  "description": "Run the final deterministic release gate across architecture integrity, generated artifacts, security boundaries, performance budgets, WebMCP coverage, real execution, code review, and architecture version integrity.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "run_judge_mode",
  "kind": "act",
  "impl": "imperative",
  "description": "Run PromptFlow's cinematic end-to-end hackathon flow: reason about the live architecture, break it with load and compute failure, diagnose the impact, apply bounded hardening, re-test, generate and execute the project, then run the production release gate and return a judge-facing before/after scorecard.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "minimum": 100000,
        "maximum": 1000000000
      }
    },
    "additionalProperties": false
  }
}

{
  "name": "get_promptflow_capabilities",
  "kind": "answer",
  "impl": "imperative",
  "description": "Read the recommended WebMCP operating contract for PromptFlow. Use this when an agent needs to understand how humans, ChatGPT, WebMCP, PromptFlow's deterministic engine, WebContainer execution, and Judge Mode fit together. No external model API is required inside PromptFlow: the calling AI agent supplies semantic reasoning and PromptFlow supplies validated execution.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "build_and_verify_system",
  "kind": "act",
  "impl": "imperative",
  "description": "RECOMMENDED ONE-CALL WebMCP workflow. Turn an arbitrary human software brief into a live architecture and a verified generated project. The calling AI agent should infer semantic components/connections when needed; PromptFlow validates and applies the plan, performs deterministic structural repair and scaling, then runs the full Judge Mode pipeline: architecture intelligence, digital-twin failure injection, hardening, re-test, code generation, real WebContainer install/test/build/runtime verification, production QA, and final verdict. Use this instead of chaining many tools when the user asks to create and prove a complete system.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "request": {
        "type": "string",
        "maxLength": 2400,
        "description": "The user's complete product/system brief. Preserve important domain, scale, realtime, security, data, AI, media, and integration constraints."
      },
      "targetUsers": {
        "type": "number",
        "description": "Optional explicit user-scale target. Omit when the brief contains no meaningful scale requirement."
      },
      "replaceCurrent": {
        "type": "boolean",
        "description": "Replace the current canvas before building. Defaults to true. Set false only when ids are guaranteed not to conflict with existing nodes."
      },
      "autoFix": {
        "type": "boolean",
        "description": "Automatically repair deterministic structural findings after the initial build. Defaults to true."
      },
      "components": {
        "type": "array",
        "maxItems": 40,
        "items": {
          "type": "object",
          "properties": {
            "id": {
              "type": "string",
              "maxLength": 120,
              "description": "Stable unique component id using lowercase kebab-case when possible."
            },
            "label": {
              "type": "string",
              "maxLength": 160,
              "description": "Human-readable software component name."
            },
            "type": {
              "type": "string",
              "enum": [
                "frontend",
                "backend",
                "api",
                "database",
                "cache",
                "queue",
                "payment",
                "auth",
                "service",
                "external",
                "gateway",
                "worker",
                "cdn",
                "observability"
              ]
            },
            "description": {
              "type": "string",
              "maxLength": 800,
              "description": "Concise responsibility and architectural purpose."
            }
          },
          "required": [
            "id",
            "label",
            "type",
            "description"
          ],
          "additionalProperties": false
        },
        "description": "Optional agent-authored architecture plan. For arbitrary briefs, provide the components you infer semantically so PromptFlow can apply the whole plan in one tool call. Omit to use PromptFlow's local intent compiler fallback."
      },
      "connections": {
        "type": "array",
        "maxItems": 80,
        "items": {
          "type": "object",
          "properties": {
            "sourceId": {
              "type": "string",
              "maxLength": 120
            },
            "targetId": {
              "type": "string",
              "maxLength": 120
            },
            "label": {
              "type": "string",
              "maxLength": 160
            }
          },
          "required": [
            "sourceId",
            "targetId"
          ],
          "additionalProperties": false
        },
        "description": "Relationships between the optional agent-authored components."
      }
    },
    "required": [
      "request"
    ],
    "additionalProperties": false
  }
}

{
  "name": "add_architecture_node",
  "kind": "act",
  "impl": "imperative",
  "description": "Atomic tool: add one software architecture component to the live PromptFlow canvas. For a complete product brief, prefer architect_system; for model-planned batches, prefer transform_architecture.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "maxLength": 120,
        "description": "Stable unique node id."
      },
      "label": {
        "type": "string",
        "maxLength": 160,
        "description": "Human-readable architecture component name."
      },
      "type": {
        "type": "string",
        "enum": [
          "frontend",
          "backend",
          "api",
          "database",
          "cache",
          "queue",
          "payment",
          "auth",
          "service",
          "external",
          "gateway",
          "worker",
          "cdn",
          "observability"
        ]
      },
      "description": {
        "type": "string",
        "maxLength": 800,
        "description": "Short explanation of the component's responsibility."
      },
      "x": {
        "type": "number",
        "description": "Optional canvas X coordinate. Omit to let PromptFlow place the node automatically."
      },
      "y": {
        "type": "number",
        "description": "Optional canvas Y coordinate. Omit to let PromptFlow place the node automatically."
      }
    },
    "required": [
      "id",
      "label",
      "type",
      "description"
    ],
    "additionalProperties": false
  }
}

{
  "name": "connect_architecture_nodes",
  "kind": "act",
  "impl": "imperative",
  "description": "Atomic tool: create one directed relationship between existing architecture nodes. Prefer architect_system for complete briefs or transform_architecture for multi-step changes.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sourceId": {
        "type": "string",
        "maxLength": 120,
        "description": "Id of the source node."
      },
      "targetId": {
        "type": "string",
        "maxLength": 120,
        "description": "Id of the target node."
      },
      "label": {
        "type": "string",
        "maxLength": 160,
        "description": "Optional relationship label."
      }
    },
    "required": [
      "sourceId",
      "targetId"
    ],
    "additionalProperties": false
  }
}

{
  "name": "update_architecture_node",
  "kind": "act",
  "impl": "imperative",
  "description": "Atomic tool: update one architecture component. Prefer architect_system for complete briefs or transform_architecture for multi-step changes.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "nodeId": {
        "type": "string",
        "maxLength": 120,
        "description": "Id of the node to update."
      },
      "label": {
        "type": "string",
        "maxLength": 160,
        "description": "Optional replacement component name."
      },
      "type": {
        "type": "string",
        "enum": [
          "frontend",
          "backend",
          "api",
          "database",
          "cache",
          "queue",
          "payment",
          "auth",
          "service",
          "external",
          "gateway",
          "worker",
          "cdn",
          "observability"
        ]
      },
      "description": {
        "type": "string",
        "maxLength": 800,
        "description": "Optional replacement component description."
      }
    },
    "required": [
      "nodeId"
    ],
    "additionalProperties": false
  }
}

{
  "name": "remove_architecture_node",
  "kind": "act",
  "impl": "imperative",
  "description": "Remove one architecture component and its relationships. For multi-step changes, prefer transform_architecture.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "nodeId": {
        "type": "string",
        "maxLength": 120,
        "description": "Id of the node to remove."
      }
    },
    "required": [
      "nodeId"
    ],
    "additionalProperties": false
  }
}

{
  "name": "clear_architecture_canvas",
  "kind": "act",
  "impl": "imperative",
  "description": "Remove every node and connection from the PromptFlow architecture canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "generate_node_boilerplate",
  "kind": "act",
  "impl": "imperative",
  "description": "Attach generated implementation code to an existing architecture node so it can be inspected in PromptFlow.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "nodeId": {
        "type": "string",
        "maxLength": 120,
        "description": "Id of the architecture node receiving the code."
      },
      "code": {
        "type": "string",
        "maxLength": 50000,
        "description": "Generated implementation or configuration code."
      }
    },
    "required": [
      "nodeId",
      "code"
    ],
    "additionalProperties": false
  }
}

{
  "name": "get_architecture_snapshot",
  "kind": "answer",
  "impl": "imperative",
  "description": "Read the current architecture graph, including components, relationships, positions, and attached code metadata.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "audit_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Run a structural preflight audit of the current architecture and expose the findings in the PromptFlow canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "auto_layout_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Arrange all architecture components into a clean deterministic grid and refocus the canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false
  }
}

{
  "name": "transform_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Apply a model-planned batch of atomic architecture changes. Inspect the current graph first and prefer this tool for multi-step changes to minimize agent round-trips.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "reason": {
        "type": "string",
        "maxLength": 600,
        "description": "Why the architecture should be transformed. Prefer this batched tool for multi-step architecture changes instead of many individual mutations."
      },
      "operations": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "kind": {
              "type": "string",
              "enum": [
                "add",
                "update",
                "remove",
                "connect",
                "disconnect"
              ]
            },
            "id": {
              "type": "string",
              "maxLength": 120
            },
            "nodeId": {
              "type": "string",
              "maxLength": 120
            },
            "label": {
              "type": "string",
              "maxLength": 160
            },
            "type": {
              "type": "string",
              "enum": [
                "frontend",
                "backend",
                "api",
                "database",
                "cache",
                "queue",
                "payment",
                "auth",
                "service",
                "external",
                "gateway",
                "worker",
                "cdn",
                "observability"
              ]
            },
            "description": {
              "type": "string",
              "maxLength": 800
            },
            "sourceId": {
              "type": "string",
              "maxLength": 120
            },
            "targetId": {
              "type": "string",
              "maxLength": 120
            },
            "x": {
              "type": "number"
            },
            "y": {
              "type": "number"
            }
          },
          "required": [
            "kind"
          ],
          "additionalProperties": false
        },
        "minItems": 1,
        "maxItems": 50
      }
    },
    "required": [
      "reason",
      "operations"
    ],
    "additionalProperties": false
  }
}

{
  "name": "scale_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Apply deterministic production scaling patterns for the requested user scale. Use the current graph as the source of truth.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "targetUsers": {
        "type": "number",
        "description": "Expected peak active users or equivalent scale target."
      },
      "reason": {
        "type": "string",
        "maxLength": 600,
        "description": "Why the system needs to scale."
      }
    },
    "required": [
      "targetUsers",
      "reason"
    ],
    "additionalProperties": false
  }
}

{
  "name": "fix_architecture",
  "kind": "act",
  "impl": "imperative",
  "description": "Address fixable findings from the latest structural audit without changing unrelated components.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "findingIds": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 120
        },
        "description": "Optional audit finding ids to address. Omit to address all fixable findings."
      }
    },
    "additionalProperties": false
  }
}