Qitos cybergym

qitos/engine/_action_runtime.py

@@ -64,7 +64,11 @@ def run_act(
             if handoff is not None:
                 return handoff
             actions.append(normalized)
-        for normalized_action in actions:
+        # Pre-flight checks: collect blocked/loop-blocked actions, execute the rest
+        blocked_indices: set[int] = set()
+        blocked_results: List[tuple[int, ToolResult]] = []
+        blocked_invocations: List[tuple[int, Dict[str, Any]]] = []
+        for i, normalized_action in enumerate(actions):
             engine._memory_append("action", normalized_action, record.step_id)
             block_reason = self._action_block_reason(state, normalized_action)
             if block_reason:
@@ -81,23 +85,22 @@ def run_act(
                         "error_category": "action_blocked",
                     },
                 )
-                record.action_results = [blocked_result]
-                record.tool_invocations = [
-                    {
-                        "tool_name": normalized_action.name,
-                        "toolset_name": None,
-                        "toolset_version": None,
-                        "source": "agent_action_gate",
-                        "attempts": 0,
-                        "latency_ms": 0,
-                        "status": "error",
-                        "error_category": "action_blocked",
-                        "error": "action_blocked",
-                    }
-                ]
+                blocked_indices.add(i)
+                blocked_results.append((i, blocked_result))
+                blocked_invocations.append((i, {
+                    "tool_name": normalized_action.name,
+                    "toolset_name": None,
+                    "toolset_version": None,
+                    "source": "agent_action_gate",
+                    "attempts": 0,
+                    "latency_ms": 0,
+                    "status": "error",
+                    "error_category": "action_blocked",
+                    "error": "action_blocked",
+                }))
                 engine._memory_append("action_result", blocked_result, record.step_id)
                 if record.decision_source == "native_tool_calls" and record.native_tool_call_used:
-                    tool_call_id = normalized_action.action_id or f"call_{record.step_id}_0"
+                    tool_call_id = normalized_action.action_id or f"call_{record.step_id}_{i}"
                     engine._history_append(
                         "tool",
                         self._serialize_for_tool_message(
@@ -137,18 +140,7 @@ def run_act(
                         ],
                     },
                 )
-                engine._dispatch_hook(
-                    "on_after_act",
-                    engine._hook_context(
-                        step_id=record.step_id,
-                        phase=RuntimePhase.ACT,
-                        state=state,
-                        decision=decision,
-                        action_results=[blocked_result.to_dict()],
-                        record=record,
-                    ),
-                )
-                return [blocked_result.to_dict()]
+                continue
             loop_result = engine._tool_loop_detector.check_detailed(
                 normalized_action.name, normalized_action.args
             )
@@ -162,7 +154,19 @@ def run_act(
                         "reason": loop_result.message,
                     },
                 )
-                record.action_results = [loop_tool_result]
+                blocked_indices.add(i)
+                blocked_results.append((i, loop_tool_result))
+                blocked_invocations.append((i, {
+                    "tool_name": normalized_action.name,
+                    "toolset_name": None,
+                    "toolset_version": None,
+                    "source": "loop_detector",
+                    "attempts": 0,
+                    "latency_ms": 0,
+                    "status": "error",
+                    "error_category": "tool_call_loop_detected",
+                    "error": "tool_call_loop_detected",
+                }))
                 engine._history_append(
                     "user",
                     loop_result.message,
@@ -178,7 +182,7 @@ def run_act(
                         "recovery_message": loop_result.message,
                     },
                 )
-                return [loop_tool_result.to_dict()]
+                continue
             elif loop_result.level == "warn":
                 # Soft warning: inject into the observation as guidance
                 engine._history_append(
@@ -188,8 +192,31 @@ def run_act(
                     metadata={"source": "loop_detector_warning"},
                 )
 
-        execution = engine.executor.execute(actions, env=engine.env, state=state)
-        record.tool_invocations = [
+        # If all actions were blocked, return immediately
+        if len(blocked_indices) == len(actions):
+            merged_results = [br for _, br in sorted(blocked_results, key=lambda x: x[0])]
+            merged_invocations = [bi for _, bi in sorted(blocked_invocations, key=lambda x: x[0])]
+            record.action_results = merged_results
+            record.tool_invocations = merged_invocations
+            engine._dispatch_hook(
+                "on_after_act",
+                engine._hook_context(
+                    step_id=record.step_id,
+                    phase=RuntimePhase.ACT,
+                    state=state,
+                    decision=decision,
+                    action_results=[r.to_dict() for r in merged_results],
+                    record=record,
+                ),
+            )
+            return [r.to_dict() for r in merged_results]
+
+        # Execute non-blocked actions
+        executable_actions = [a for i, a in enumerate(actions) if i not in blocked_indices]
+        executable_indices = [i for i in range(len(actions)) if i not in blocked_indices]
+        execution = engine.executor.execute(executable_actions, env=engine.env, state=state)
+        # Build tool_invocations from execution results (executable only)
+        exec_invocations = [
             {
                 "tool_name": item.name,
                 "toolset_name": item.metadata.get("toolset_name"),
@@ -270,6 +297,35 @@ def run_act(
                         },
                     )
                 )
+
+        # Merge blocked results and execution results back into original action order
+        if blocked_indices:
+            # Map execution result indices to original action indices
+            exec_result_by_orig_idx: Dict[int, ToolResult] = {}
+            for exec_i, orig_i in enumerate(executable_indices):
+                if exec_i < len(results):
+                    exec_result_by_orig_idx[orig_i] = results[exec_i]
+            blocked_result_by_orig_idx: Dict[int, ToolResult] = {idx: r for idx, r in blocked_results}
+            blocked_inv_by_orig_idx: Dict[int, Dict[str, Any]] = {idx: inv for idx, inv in blocked_invocations}
+            exec_inv_by_orig_idx: Dict[int, Dict[str, Any]] = {}
+            for exec_i, orig_i in enumerate(executable_indices):
+                if exec_i < len(exec_invocations):
+                    exec_inv_by_orig_idx[orig_i] = exec_invocations[exec_i]
+
+            merged_results: List[ToolResult] = []
+            merged_invocations: List[Dict[str, Any]] = []
+            for i in range(len(actions)):
+                if i in blocked_indices:
+                    merged_results.append(blocked_result_by_orig_idx.get(i, ToolResult(status="error", output=None, error="action_blocked")))
+                    merged_invocations.append(blocked_inv_by_orig_idx.get(i, {}))
+                else:
+                    merged_results.append(exec_result_by_orig_idx.get(i, ToolResult(status="error", output=None, error="execution_failed")))
+                    merged_invocations.append(exec_inv_by_orig_idx.get(i, {}))
+            results = merged_results
+            record.tool_invocations = merged_invocations
+        else:
+            record.tool_invocations = exec_invocations
+
         if engine.env is not None:
             env_result = engine._run_env_step(
                 decision=decision,
@@ -286,7 +342,7 @@ def run_act(
         record.action_results = results
         for item in results:
             engine._memory_append("action_result", item, record.step_id)
-        for normalized_action in actions:
+        for normalized_action in executable_actions:
             engine._tool_loop_detector.record(
                 normalized_action.name, dict(normalized_action.args or {})
             )

qitos/engine/action_executor.py

@@ -27,6 +27,11 @@
     "Glob", "Grep", "glob_v2", "grep_v2",
     "WebFetch", "web_fetch_v2",
     "task_list", "task_get",
+    # CyberGym read-only tools
+    "READ", "GREP", "FindSymbols", "CallsiteSearch", "RepoMap",
+    "FileInfo", "HexView", "StructProbe", "CorpusInspect",
+    # CyberGym submission (idempotent, safe to parallelize)
+    "submit_poc",
 })
 
 

qitos/harness/__init__.py

@@ -69,6 +69,18 @@ def build_model_for_preset(
         protocol=protocol,
         tool_delivery=tool_delivery,
     )
+    # Merge preset-level recommended_request_kwargs with caller-provided kwargs.
+    # Caller kwargs take precedence over preset recommendations.
+    preset_kwargs = harness.family_preset.recommended_request_kwargs
+    effective_kwargs = default_request_kwargs
+    if preset_kwargs:
+        if effective_kwargs is None:
+            effective_kwargs = dict(preset_kwargs)
+        else:
+            merged = dict(preset_kwargs)
+            merged.update(effective_kwargs)
+            effective_kwargs = merged
+
     llm = harness.adapter.build_model(
         preset=harness.family_preset,
         model_name=model_name,
@@ -80,7 +92,7 @@ def build_model_for_preset(
         timeout=timeout,
         system_prompt=system_prompt,
         context_window=context_window,
-        default_request_kwargs=default_request_kwargs,
+        default_request_kwargs=effective_kwargs,
     )
     metadata = dict(getattr(llm, "qitos_harness_metadata", {}) or {})
     metadata.update(harness.to_dict())

qitos/harness/_presets.py

@@ -63,8 +63,8 @@
         display_name="GLM",
         model_matchers=("glm-", "zai-org/glm-", "zai-org/glm"),
         adapter_kind="openai-compatible",
-        default_protocol="json_decision_v1",
-        fallback_protocols=("xml_decision_v1", "react_text_v1"),
+        default_protocol="json_decision_multi_v1",
+        fallback_protocols=("json_decision_v1", "xml_decision_v1", "react_text_v1"),
         tool_policy=ToolPolicy(
             primary_delivery="api_parameter",
             fallback_delivery="prompt_injection",
@@ -76,12 +76,13 @@
             fallback_context_window=128_000,
             notes="GLM-5.1 class endpoints commonly expose a 200k context window; fall back conservatively when the provider does not advertise it.",
         ),
-        notes="Research default for GLM models served through OpenAI-compatible endpoints, preferring native tool calls before text parsing.",
+        notes="Research default for GLM models served through OpenAI-compatible endpoints, preferring native tool calls before text parsing. Uses json_decision_multi_v1 for multi-action support.",
         recommended_models=("GLM-5.1-sii", "zai-org/GLM-5.1-FP8"),
         recommended_max_steps=30,
         recommended_max_tokens=500_000,
         recommended_retry_budget=3,
         recommended_temperature=0.2,
+        recommended_request_kwargs={"parallel_tool_calls": True},
     ),
     FamilyPreset(
         id="kimi",

qitos/harness/_types.py

@@ -62,6 +62,7 @@ class FamilyPreset:
     recommended_max_tokens: Optional[int] = None
     recommended_retry_budget: Optional[int] = None
     recommended_temperature: Optional[float] = None
+    recommended_request_kwargs: Optional[dict[str, Any]] = None
 
     def matches(self, value: str | None) -> bool:
         normalized = str(value or "").strip().lower()
@@ -90,6 +91,7 @@ def to_dict(self) -> dict[str, Any]:
             "recommended_max_tokens": self.recommended_max_tokens,
             "recommended_retry_budget": self.recommended_retry_budget,
             "recommended_temperature": self.recommended_temperature,
+            "recommended_request_kwargs": self.recommended_request_kwargs,
         }
 
     def override(self, **kwargs: Any) -> FamilyPreset:

qitos/protocols.py

@@ -166,12 +166,33 @@ def _render_continuation_message(feedback: str) -> str:
 Final Answer: <answer>"""
 
 _JSON_CONTRACT = """Output contract:
-- Tool call:
+- Single tool call:
 {"thought":"...","action":{"name":"tool_name","args":{"key":"value"}}}
 
+- Multiple independent tool calls (use when actions have no data dependencies):
+{"thought":"...","actions":[{"name":"tool_name","args":{"key":"value"}},{"name":"tool_name","args":{"key":"value"}}]}
+
 - Final answer:
 {"thought":"...","final_answer":"..."}"""
 
+_JSON_MULTI_CONTRACT = """Output contract:
+- Single tool call:
+{"thought":"...","action":{"name":"tool_name","args":{"key":"value"}}}
+
+- Multiple independent tool calls (PREFERRED when actions have no dependencies):
+{"thought":"read two source files in parallel","actions":[{"name":"tool1","args":{"key":"value"}},{"name":"tool2","args":{"key":"value"}}]}
+
+- Final answer:
+{"thought":"...","final_answer":"..."}
+
+Rules for multiple tool calls:
+- Use the "actions" array when you need multiple independent operations in one step.
+- Only combine actions with NO data dependencies on each other.
+- Read-only tools (file reads, searches, inspections) can always be combined.
+- NEVER combine write actions (file writes, shell commands) with reads or with each other in the same step.
+- Limit each batch to at most 4 actions.
+- When you have only one tool to call, use the "action" object (not an array)."""
+
 _XML_CONTRACT = """Output contract:
 - Tool call:
 <decision mode="act"><think>...</think><action name="tool_name"><arg name="key">value</arg></action></decision>
@@ -373,6 +394,15 @@ def _json_prompt(base_prompt: str, tool_registry: Any) -> str:
     )
 
 
+def _json_multi_prompt(base_prompt: str, tool_registry: Any) -> str:
+    return _compose_prompt(
+        base_prompt,
+        tool_registry,
+        contract=_JSON_MULTI_CONTRACT,
+        renderer=render_json_tool_schema,
+    )
+
+
 def _xml_prompt(base_prompt: str, tool_registry: Any) -> str:
     return _compose_prompt(
         base_prompt,
@@ -461,6 +491,21 @@ def _protocol_table() -> Dict[str, ModelProtocol]:
             continuation_renderer=_render_continuation_message,
             tool_schema_delivery="hybrid",
             supports_native_tool_call_markup=True,
+            supports_multi_action=True,
+        ),
+        "json_decision_multi_v1": ModelProtocol(
+            id="json_decision_multi_v1",
+            display_name="JSON Decision (Multi-Action)",
+            parser_factory=JsonDecisionParser,
+            prompt_renderer=_json_multi_prompt,
+            contract_renderer=lambda _protocol: _render_simple_contract(_JSON_MULTI_CONTRACT),
+            tool_schema_renderer=render_json_tool_schema,
+            repair_renderer=_render_repair_message,
+            continuation_renderer=_render_continuation_message,
+            tool_schema_delivery="hybrid",
+            supports_native_tool_call_markup=True,
+            supports_multi_action=True,
+            fallback_protocols=("json_decision_v1", "xml_decision_v1", "react_text_v1"),
         ),
         "xml_decision_v1": ModelProtocol(
             id="xml_decision_v1",