//! Workbench M00–M06 contract gate (offline). //! Spec: doc/design/qdagent-workbench-runtime-and-view-2026-10-25.md use serde_json::Value; use std::path::PathBuf; fn fixture(name: &str) -> Value { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let path = root.join("tests/workbench/fixtures").join(name); let raw = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display())); serde_json::from_str(&raw).expect("fixture json") } fn schema(name: &str) -> Value { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let path = root.join("tests/workbench/schemas").join(name); let raw = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display())); serde_json::from_str(&raw).expect("schema json") } /// Lightweight required-field check against our JSON Schema documents (no jsonschema crate). fn assert_required(instance: &Value, schema_doc: &Value, label: &str) { let required = schema_doc["required"].as_array().expect("schema.required"); for key in required { let k = key.as_str().unwrap(); assert!( instance.get(k).is_some(), "{label}: missing required field {k} in {instance}" ); } } fn mlsp(method: &str, params: Value) -> Value { let req = serde_json::json!({"id": 1, "method": method, "params": params}); let line = marqdo::mlsp::handle_line(&req.to_string()); serde_json::from_str(&line).expect("mlsp response json") } #[test] fn m00_fixtures_consume_and_capabilities() { let sel = fixture("model_selection_ok.json"); assert_required(&sel, &schema("ModelSelectionV1.schema.json"), "selection"); assert_eq!(sel["schema"], "ModelSelectionV1"); let parsed = marqdo::workbench::parse_model_selection(&sel, true).expect("strict ok"); assert_eq!(parsed.selection_id, "sel-1"); let snap = parsed.public_snapshot(); assert!(snap.get("api_key").is_none()); let usage = fixture("model_call_usage_unknown.json"); assert_required(&usage, &schema("ModelCallUsageV1.schema.json"), "usage"); assert!(usage["input_tokens"].is_null()); assert_ne!(usage["input_tokens"], 0); assert_eq!(usage["usage_state"], "unknown"); let cancelled = fixture("model_call_usage_cancelled.json"); assert_eq!(cancelled["status"], "cancelled"); assert_eq!(cancelled["usage_state"], "partial"); let doc = fixture("document_view_partial.json"); assert_required(&doc, &schema("DocumentViewV1.schema.json"), "document_view"); assert_eq!(doc["execution"]["state"], "not_run"); let stale = fixture("locator_stale.json"); assert_eq!(stale["resolution"], "stale"); let loc = &stale["locator"]; assert_required(loc, &schema("KnowledgeLocatorV1.schema.json"), "locator"); let unavail = fixture("locator_version_unavailable.json"); assert_eq!(unavail["resolution"], "version_unavailable"); let ev = fixture("runtime_event_cancelled.json"); assert_required(&ev, &schema("RuntimeEventV1.schema.json"), "runtime_event"); assert_eq!(ev["type"], "run.cancelled"); let _ = fixture("model_selection_error.json"); let _ = fixture("document_view_unsupported.json"); let caps = mlsp("capabilities", serde_json::json!({})); assert_eq!(caps["ok"], true, "{caps}"); let features = &caps["result"]["features"]; assert_eq!(features["view.document"], 1); assert_eq!(features["view.reference_resolve"], 1); assert!(caps["result"]["contracts"] .as_array() .unwrap() .iter() .any(|c| c.as_str() == Some("DocumentViewV1"))); // F16 honesty: unloaded plugins + forced-off stream/cancel → 0 let down = mlsp( "capabilities", serde_json::json!({ "force_unloaded": true, "force_stream_off": true, "force_cancel_off": true }), ); assert_eq!(down["result"]["features"]["llm.messages"], 0); assert_eq!(down["result"]["features"]["runtime.event_stream"], 0); assert_eq!(down["result"]["features"]["runtime.cancel"], 0); } /// M-A0: freeze Agent reliability protocol fixtures; capability bits stay 0. #[test] fn ma0_agent_reliability_protocol_freeze() { let err = fixture("agent_error_v1.json"); assert_required(&err, &schema("AgentErrorV1.schema.json"), "agent_error"); assert_eq!(err["schema"], "AgentErrorV1"); assert_eq!(err["schema_version"], 1); let degrade = fixture("agent_error_v1_unknown_version.json"); assert_eq!(degrade["schema"], "AgentErrorV1"); assert_eq!(degrade["schema_version"], 99); assert_eq!(degrade["future_field"], true); let tool = fixture("tool_spec_v1.json"); assert_required(&tool, &schema("ToolSpecV1.schema.json"), "tool_spec"); assert_required( &fixture("tool_call_v1.json"), &schema("ToolCallV1.schema.json"), "tool_call", ); assert_required( &fixture("tool_result_v1.json"), &schema("ToolResultV1.schema.json"), "tool_result", ); let ckpt = fixture("checkpoint_v2.json"); assert_required(&ckpt, &schema("CheckpointV2.schema.json"), "checkpoint"); assert_eq!(ckpt["schema_version"], 2); let legacy = fixture("checkpoint_legacy_resume.json"); assert!(legacy.get("schema").is_none()); assert!(legacy.get("effect_class").is_none()); assert_eq!(legacy["id"], "legacy_resume_01"); let ledger = fixture("effect_ledger_v1.json"); assert_required( &ledger, &schema("EffectLedgerRecordV1.schema.json"), "effect_ledger", ); assert_eq!(ledger["schema"], "EffectLedgerRecordV1"); assert_eq!(ledger["state"], "prepared"); assert_eq!(ledger["effect_class"], "write"); let out_ok = fixture("agent_output_v1_succeeded.json"); assert_required(&out_ok, &schema("AgentOutputV1.schema.json"), "agent_output_ok"); assert_eq!(out_ok["status"], "succeeded"); let out_fail = fixture("agent_output_v1_failed.json"); assert_required( &out_fail, &schema("AgentOutputV1.schema.json"), "agent_output_fail", ); assert_eq!(out_fail["status"], "failed"); let pack = fixture("context_pack_v2.json"); assert_required(&pack, &schema("ContextPackV2.schema.json"), "context_pack"); assert_eq!(pack["schema_version"], 2); let item = &pack["items"][0]; for key in [ "origin", "trust", "resource_ref", "revision", "token_estimate", "priority", ] { assert!(item.get(key).is_some(), "context item missing {key}"); } assert_required( &fixture("resource_ref_v1.json"), &schema("ResourceRefV1.schema.json"), "resource_ref", ); let view = fixture("resource_view_v1.json"); assert_required(&view, &schema("ResourceViewV1.schema.json"), "resource_view"); assert_eq!(view["no_exec"], true); let tev = fixture("runtime_event_tool_failed.json"); assert_eq!(tev["schema"], "RuntimeEventV2"); assert_eq!(tev["type"], "tool.failed"); assert_eq!(tev["payload"]["schema"], "AgentErrorV1"); let caps = mlsp("capabilities", serde_json::json!({})); assert_eq!(caps["ok"], true, "{caps}"); let features = &caps["result"]["features"]; // M-A1–M-A4: agent reliability emitters are live. assert_eq!(features["agent.error_v1"], 1); assert_eq!(features["agent.checkpoint_v2"], 1); assert_eq!(features["agent.tool_schema_v1"], 1); assert_eq!(features["agent.output_channels_v1"], 1); assert_eq!(features["agent.context_pack_v2"], 1); assert_eq!(features["resource.view_v1"], 1); let formats = caps["result"]["extract_formats"] .as_array() .expect("extract_formats"); let pdf = formats .iter() .find(|f| f["format"] == "pdf") .expect("pdf row"); assert_eq!(pdf["available"], false); let json_fmt = formats .iter() .find(|f| f["format"] == "json") .expect("json row"); assert_eq!(json_fmt["available"], true); let csv_fmt = formats .iter() .find(|f| f["format"] == "csv") .expect("csv row"); assert_eq!(csv_fmt["available"], true); // Live contracts list still excludes unimplemented agent schemas. let contracts = caps["result"]["contracts"].as_array().unwrap(); assert!(!contracts.iter().any(|c| c.as_str() == Some("AgentErrorV1"))); let down = mlsp( "capabilities", serde_json::json!({ "force_unloaded": true, "force_stream_off": true, "force_cancel_off": true }), ); assert_eq!(down["result"]["features"]["agent.error_v1"], 1); assert_eq!(down["result"]["features"]["agent.checkpoint_v2"], 1); assert_eq!(down["result"]["features"]["agent.tool_schema_v1"], 1); assert_eq!(down["result"]["features"]["agent.output_channels_v1"], 1); assert_eq!(down["result"]["features"]["agent.context_pack_v2"], 1); assert_eq!(down["result"]["features"]["resource.view_v1"], 1); } #[test] fn ma3_resource_view_static_no_exec() { use std::io::Write; use std::time::{SystemTime, UNIX_EPOCH}; let nanos = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap() .as_nanos(); let dir = std::env::temp_dir().join(format!("marqdo-ma3-rv-{nanos}")); std::fs::create_dir_all(&dir).unwrap(); let md = dir.join("readme.md"); { let mut f = std::fs::File::create(&md).unwrap(); writeln!(f, "# Hello\n\n").unwrap(); } let resp = mlsp( "resource.view", serde_json::json!({ "workspace_root": dir.to_string_lossy(), "path": "readme.md", "mode": "read" }), ); assert_eq!(resp["ok"], true, "{resp}"); let view = &resp["result"]; assert_required(view, &schema("ResourceViewV1.schema.json"), "resource_view_live"); assert_eq!(view["no_exec"], true); assert_eq!(view["schema"], "ResourceViewV1"); let frag = view["render"]["fragment"].as_str().unwrap(); assert!(frag.contains("Hello")); assert!(frag.contains("<script>") || !frag.contains("