open-research-protocol 0.4.24 → 0.4.26

package/scripts/orp-mcp

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import subprocess
+import sys
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+CLI = ROOT / "cli" / "orp.py"
+
+
+TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "orp_research_ask",
+        "description": "Create an ORP OpenAI research-loop run with high-reasoning, web-synthesis, and deep-research call moments. Dry-run by default; set execute=true for live provider lanes.",
+        "inputSchema": {
+            "type": "object",
+            "required": ["question"],
+            "properties": {
+                "question": {"type": "string", "minLength": 1},
+                "repo_root": {"type": "string", "description": "Repository root. Defaults to current directory."},
+                "run_id": {"type": "string"},
+                "profile": {"type": "string", "default": "openai-council"},
+                "profile_file": {"type": "string"},
+                "execute": {"type": "boolean", "default": False},
+                "lane_fixtures": {
+                    "type": "object",
+                    "description": "Mapping of lane_id to fixture path.",
+                    "additionalProperties": {"type": "string"},
+                },
+                "chimera_bin": {"type": "string", "default": "chimera"},
+                "timeout_sec": {"type": "integer", "minimum": 1, "default": 120},
+            },
+        },
+    },
+    {
+        "name": "orp_research_status",
+        "description": "Show status and lane summary for an ORP research council run.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "repo_root": {"type": "string", "description": "Repository root. Defaults to current directory."},
+                "run_id": {"type": "string", "default": "latest"},
+            },
+        },
+    },
+    {
+        "name": "orp_research_show",
+        "description": "Show an ORP research council answer payload.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "repo_root": {"type": "string", "description": "Repository root. Defaults to current directory."},
+                "run_id": {"type": "string", "default": "latest"},
+            },
+        },
+    },
+]
+
+
+def _json_response(request_id: Any, result: Any | None = None, error: Any | None = None) -> dict[str, Any]:
+    response: dict[str, Any] = {"jsonrpc": "2.0", "id": request_id}
+    if error is not None:
+        response["error"] = error
+    else:
+        response["result"] = result if result is not None else {}
+    return response
+
+
+def _write(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload, separators=(",", ":")) + "\n")
+    sys.stdout.flush()
+
+
+def _text_result(text: str, *, is_error: bool = False) -> dict[str, Any]:
+    return {
+        "content": [{"type": "text", "text": text}],
+        "isError": is_error,
+    }
+
+
+def _repo_root(args: dict[str, Any]) -> str:
+    raw = str(args.get("repo_root", "") or "").strip()
+    return raw or "."
+
+
+def _run_orp(args: list[str]) -> tuple[int, str, str]:
+    proc = subprocess.run(
+        [sys.executable, str(CLI), *args],
+        capture_output=True,
+        text=True,
+        cwd=str(ROOT),
+    )
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+def _call_research_ask(args: dict[str, Any]) -> dict[str, Any]:
+    question = str(args.get("question", "") or "").strip()
+    if not question:
+        return _text_result("question is required", is_error=True)
+    cmd = ["--repo-root", _repo_root(args), "research", "ask", question]
+    profile = str(args.get("profile", "") or "").strip()
+    if profile:
+        cmd.extend(["--profile", profile])
+    profile_file = str(args.get("profile_file", "") or "").strip()
+    if profile_file:
+        cmd.extend(["--profile-file", profile_file])
+    run_id = str(args.get("run_id", "") or "").strip()
+    if run_id:
+        cmd.extend(["--run-id", run_id])
+    if bool(args.get("execute", False)):
+        cmd.append("--execute")
+    lane_fixtures = args.get("lane_fixtures")
+    if isinstance(lane_fixtures, dict):
+        for lane_id, path in lane_fixtures.items():
+            cmd.extend(["--lane-fixture", f"{lane_id}={path}"])
+    chimera_bin = str(args.get("chimera_bin", "") or "").strip()
+    if chimera_bin:
+        cmd.extend(["--chimera-bin", chimera_bin])
+    timeout_sec = args.get("timeout_sec")
+    if timeout_sec is not None:
+        cmd.extend(["--timeout-sec", str(timeout_sec)])
+    cmd.append("--json")
+    code, stdout, stderr = _run_orp(cmd)
+    if code != 0:
+        return _text_result((stderr or stdout or f"orp exited {code}").strip(), is_error=True)
+    return _text_result(stdout.strip())
+
+
+def _call_research_status(args: dict[str, Any]) -> dict[str, Any]:
+    run_id = str(args.get("run_id", "") or "latest").strip() or "latest"
+    cmd = ["--repo-root", _repo_root(args), "research", "status", run_id, "--json"]
+    code, stdout, stderr = _run_orp(cmd)
+    if code != 0:
+        return _text_result((stderr or stdout or f"orp exited {code}").strip(), is_error=True)
+    return _text_result(stdout.strip())
+
+
+def _call_research_show(args: dict[str, Any]) -> dict[str, Any]:
+    run_id = str(args.get("run_id", "") or "latest").strip() or "latest"
+    cmd = ["--repo-root", _repo_root(args), "research", "show", run_id, "--json"]
+    code, stdout, stderr = _run_orp(cmd)
+    if code != 0:
+        return _text_result((stderr or stdout or f"orp exited {code}").strip(), is_error=True)
+    return _text_result(stdout.strip())
+
+
+def _handle(request: dict[str, Any]) -> dict[str, Any] | None:
+    request_id = request.get("id")
+    method = str(request.get("method", "") or "")
+    if method.startswith("notifications/"):
+        return None
+    if method == "initialize":
+        return _json_response(
+            request_id,
+            {
+                "protocolVersion": str(request.get("params", {}).get("protocolVersion", "2024-11-05")),
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "orp-research", "version": "0.1.0"},
+            },
+        )
+    if method == "tools/list":
+        return _json_response(request_id, {"tools": TOOLS})
+    if method == "tools/call":
+        params = request.get("params")
+        if not isinstance(params, dict):
+            return _json_response(request_id, error={"code": -32602, "message": "params must be an object"})
+        name = str(params.get("name", "") or "")
+        arguments = params.get("arguments")
+        if not isinstance(arguments, dict):
+            arguments = {}
+        if name == "orp_research_ask":
+            return _json_response(request_id, _call_research_ask(arguments))
+        if name == "orp_research_status":
+            return _json_response(request_id, _call_research_status(arguments))
+        if name == "orp_research_show":
+            return _json_response(request_id, _call_research_show(arguments))
+        return _json_response(request_id, error={"code": -32601, "message": f"unknown tool: {name}"})
+    return _json_response(request_id, error={"code": -32601, "message": f"unknown method: {method}"})
+
+
+def main() -> int:
+    for line in sys.stdin:
+        text = line.strip()
+        if not text:
+            continue
+        try:
+            request = json.loads(text)
+        except Exception as exc:
+            _write(_json_response(None, error={"code": -32700, "message": str(exc)}))
+            continue
+        if not isinstance(request, dict):
+            _write(_json_response(None, error={"code": -32600, "message": "request must be an object"}))
+            continue
+        response = _handle(request)
+        if response is not None:
+            _write(response)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/spec/v1/project-context.schema.json

@@ -0,0 +1,223 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openresearchprotocol.com/spec/v1/project-context.schema.json",
+  "title": "ORP Project Context",
+  "description": "Machine-readable ORP process artifact describing a local directory's authority surfaces, directory signals, research timing policy, and evolution policy.",
+  "type": "object",
+  "additionalProperties": true,
+  "required": [
+    "schema_version",
+    "kind",
+    "project",
+    "initialized_at_utc",
+    "refreshed_at_utc",
+    "refresh_source",
+    "authority_surfaces",
+    "directory_signals",
+    "research_policy",
+    "evolution_policy",
+    "next_actions",
+    "notes"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "1.0.0"
+    },
+    "kind": {
+      "const": "orp_project_context"
+    },
+    "project": {
+      "type": "object",
+      "required": [
+        "name",
+        "root"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "root": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "initialized_at_utc": {
+      "type": "string",
+      "minLength": 1
+    },
+    "refreshed_at_utc": {
+      "type": "string",
+      "minLength": 1
+    },
+    "refresh_source": {
+      "type": "string",
+      "minLength": 1
+    },
+    "authority_surfaces": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "path",
+          "kind",
+          "role",
+          "exists",
+          "size_bytes"
+        ],
+        "properties": {
+          "path": {
+            "type": "string",
+            "minLength": 1
+          },
+          "kind": {
+            "type": "string",
+            "minLength": 1
+          },
+          "role": {
+            "type": "string",
+            "minLength": 1
+          },
+          "exists": {
+            "type": "boolean"
+          },
+          "size_bytes": {
+            "type": "integer",
+            "minimum": 0
+          }
+        }
+      }
+    },
+    "directory_signals": {
+      "type": "object",
+      "required": [
+        "source_dirs",
+        "languages_or_stacks",
+        "has_tests",
+        "has_docs",
+        "has_orp_config",
+        "authority_surface_count"
+      ],
+      "properties": {
+        "source_dirs": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "languages_or_stacks": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "has_tests": {
+          "type": "boolean"
+        },
+        "has_docs": {
+          "type": "boolean"
+        },
+        "has_orp_config": {
+          "type": "boolean"
+        },
+        "authority_surface_count": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "research_policy": {
+      "type": "object",
+      "required": [
+        "default_timing",
+        "provider_calls_are_explicit",
+        "live_calls_require_execute",
+        "call_moments"
+      ],
+      "properties": {
+        "default_timing": {
+          "type": "string",
+          "minLength": 1
+        },
+        "provider_calls_are_explicit": {
+          "type": "boolean"
+        },
+        "live_calls_require_execute": {
+          "type": "boolean"
+        },
+        "secret_alias": {
+          "type": "string"
+        },
+        "env_var": {
+          "type": "string"
+        },
+        "call_moments": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": [
+              "moment_id",
+              "calls_api",
+              "when"
+            ],
+            "properties": {
+              "moment_id": {
+                "type": "string",
+                "minLength": 1
+              },
+              "calls_api": {
+                "type": "boolean"
+              },
+              "lane": {
+                "type": "string"
+              },
+              "model": {
+                "type": "string"
+              },
+              "when": {
+                "type": "string",
+                "minLength": 1
+              },
+              "capability_note": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "skip_research_when": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "escalate_to_deep_research_when": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "evolution_policy": {
+      "type": "object",
+      "required": [
+        "refresh_surfaces",
+        "evolution_loop",
+        "boundary"
+      ]
+    },
+    "next_actions": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "notes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}

package/spec/v1/research-run.schema.json

@@ -0,0 +1,245 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openresearchprotocol.com/spec/v1/research-run.schema.json",
+  "title": "ORP Research Run",
+  "description": "Machine-readable ORP artifact for a durable multi-lane research council run.",
+  "type": "object",
+  "additionalProperties": true,
+  "required": [
+    "schema_version",
+    "kind",
+    "run_id",
+    "status",
+    "question",
+    "execute",
+    "generated_at_utc",
+    "profile",
+    "breakdown",
+    "lanes",
+    "synthesis",
+    "artifacts",
+    "notes"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "1.0.0"
+    },
+    "kind": {
+      "const": "research_run"
+    },
+    "run_id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "planned",
+        "in_progress",
+        "partial",
+        "complete"
+      ]
+    },
+    "question": {
+      "type": "string",
+      "minLength": 1
+    },
+    "execute": {
+      "type": "boolean"
+    },
+    "generated_at_utc": {
+      "type": "string",
+      "minLength": 1
+    },
+    "profile": {
+      "type": "object",
+      "required": [
+        "profile_id",
+        "lane_count"
+      ],
+      "properties": {
+        "profile_id": {
+          "type": "string",
+          "minLength": 1
+        },
+        "label": {
+          "type": "string"
+        },
+        "lane_count": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "call_moments": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "moment_id",
+          "calls_api"
+        ],
+        "properties": {
+          "moment_id": {
+            "type": "string",
+            "minLength": 1
+          },
+          "label": {
+            "type": "string"
+          },
+          "calls_api": {
+            "type": "boolean"
+          },
+          "secret_alias": {
+            "type": "string"
+          },
+          "env_var": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "breakdown": {
+      "type": "object",
+      "required": [
+        "question",
+        "sequence",
+        "output_contract",
+        "lanes"
+      ]
+    },
+    "lanes": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "lane_id",
+          "provider",
+          "model",
+          "adapter",
+          "status",
+          "started_at_utc",
+          "finished_at_utc",
+          "text"
+        ],
+        "properties": {
+          "lane_id": {
+            "type": "string",
+            "minLength": 1
+          },
+          "label": {
+            "type": "string"
+          },
+          "provider": {
+            "type": "string"
+          },
+          "model": {
+            "type": "string"
+          },
+          "adapter": {
+            "type": "string"
+          },
+          "call_moment": {
+            "type": "string"
+          },
+          "api_call": {
+            "type": "object",
+            "properties": {
+              "call_moment": {
+                "type": "string"
+              },
+              "called": {
+                "type": "boolean"
+              },
+              "secret_alias": {
+                "type": "string"
+              },
+              "env_var": {
+                "type": "string"
+              },
+              "secret_source": {
+                "type": "string"
+              },
+              "secret_value_persisted": {
+                "type": "boolean"
+              }
+            }
+          },
+          "status": {
+            "type": "string"
+          },
+          "text": {
+            "type": "string"
+          },
+          "citations": {
+            "type": "array"
+          },
+          "notes": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "synthesis": {
+      "type": "object",
+      "required": [
+        "answer",
+        "completed_lane_count",
+        "confidence",
+        "next_actions"
+      ],
+      "properties": {
+        "answer": {
+          "type": "string"
+        },
+        "completed_lane_count": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "planned_or_skipped_lane_count": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "failed_lane_count": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "confidence": {
+          "type": "string"
+        },
+        "citations": {
+          "type": "array"
+        },
+        "next_actions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "artifacts": {
+      "type": "object",
+      "required": [
+        "request_json",
+        "breakdown_json",
+        "profile_json",
+        "answer_json",
+        "summary_md",
+        "lanes_root"
+      ]
+    },
+    "notes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}