@nbardy/oompa 0.3.0 → 0.4.0

package/README.md

@@ -99,7 +99,7 @@ This spawns:
 
 | Field | Required | Description |
 |-------|----------|-------------|
-| `model` | yes | `harness:model` (e.g. `claude:opus-4.5`, `codex:codex-5.2-mini`) |
+| `model` | yes | `harness:model` or `harness:model:reasoning` (e.g. `codex:o3:low`, `claude:opus-4.6`) |
 | `prompt` | no | String or array of paths — concatenated into one prompt |
 | `iterations` | no | Max iterations per worker (default: 10) |
 | `count` | no | Number of workers with this config (default: 1) |

package/agentnet/src/agentnet/cli.clj

@@ -132,34 +132,75 @@
 ;; Commands
 ;; =============================================================================
 
+(declare cmd-swarm)
+
+(defn- probe-model
+  "Send 'say ok' to a model via its harness CLI. Returns true if model responds."
+  [harness model]
+  (try
+    (let [cmd (case harness
+                :claude ["claude" "--model" model "-p" "say ok" "--max-turns" "1"]
+                :codex  ["codex" "exec" "--model" model "--" "say ok"])
+          result (process/sh cmd {:out :string :err :string :timeout 30000})]
+      (zero? (:exit result)))
+    (catch Exception _ false)))
+
+(defn- validate-models!
+  "Probe each unique harness:model pair. Prints results and exits if any fail."
+  [worker-configs review-model]
+  (let [models (cond-> (set (map (fn [wc]
+                                   (parse-model-string (:model wc)))
+                                 worker-configs))
+                 review-model (conj review-model))
+        _ (println "Validating models...")
+        results (pmap (fn [{:keys [harness model]}]
+                        (let [ok (probe-model harness model)]
+                          (println (format "  %s:%s %s"
+                                           (name harness) model
+                                           (if ok "OK" "FAIL")))
+                          {:harness harness :model model :ok ok}))
+                      models)
+        failures (filter (complement :ok) results)]
+    (when (seq failures)
+      (println)
+      (println "ERROR: The following models are not accessible:")
+      (doseq [{:keys [harness model]} failures]
+        (println (format "  %s:%s" (name harness) model)))
+      (println)
+      (println "Fix model names in oompa.json and retry.")
+      (System/exit 1))
+    (println)))
+
 (defn cmd-run
-  "Run orchestrator once"
+  "Run orchestrator — uses oompa.json if present, otherwise simple mode"
   [opts args]
-  (let [swarm-id (make-swarm-id)]
-    (if-let [specs (:worker-specs opts)]
-    ;; Mixed worker specs: --workers claude:5 codex:4
-    (let [workers (mapcat
-                    (fn [spec]
-                      (let [{:keys [harness count]} spec]
-                        (map-indexed
-                          (fn [idx _]
-                            (worker/create-worker
-                              {:id (format "%s-%d" (name harness) idx)
-                               :swarm-id swarm-id
-                               :harness harness
-                               :model (:model opts)
-                               :iterations 1}))
-                          (range count))))
-                    specs)]
-      (println (format "Running once with mixed workers (swarm %s):" swarm-id))
-      (doseq [spec specs]
-        (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
-      (println)
-      (worker/run-workers! workers))
-    ;; Simple mode
-    (do
-      (println (format "Swarm ID: %s" swarm-id))
-      (orchestrator/run-once! (assoc opts :swarm-id swarm-id))))))
+  (if (.exists (io/file "oompa.json"))
+    (cmd-swarm opts (or (seq args) ["oompa.json"]))
+    (let [swarm-id (make-swarm-id)]
+      (if-let [specs (:worker-specs opts)]
+        ;; Mixed worker specs: --workers claude:5 codex:4
+        (let [workers (mapcat
+                        (fn [spec]
+                          (let [{:keys [harness count]} spec]
+                            (map-indexed
+                              (fn [idx _]
+                                (worker/create-worker
+                                  {:id (format "%s-%d" (name harness) idx)
+                                   :swarm-id swarm-id
+                                   :harness harness
+                                   :model (:model opts)
+                                   :iterations 1}))
+                              (range count))))
+                        specs)]
+          (println (format "Running once with mixed workers (swarm %s):" swarm-id))
+          (doseq [spec specs]
+            (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
+          (println)
+          (worker/run-workers! workers))
+        ;; Simple mode
+        (do
+          (println (format "Swarm ID: %s" swarm-id))
+          (orchestrator/run-once! (assoc opts :swarm-id swarm-id)))))))
 
 (defn cmd-loop
   "Run orchestrator N times"
@@ -280,11 +321,15 @@
                        (if available? "✓ available" "✗ not found"))))))
 
 (defn- parse-model-string
-  "Parse 'harness:model' string into {:harness :model}"
+  "Parse model string into {:harness :model :reasoning}.
+   Formats: 'harness:model', 'harness:model:reasoning', or just 'model'."
   [s]
   (if (and s (str/includes? s ":"))
-    (let [[h m] (str/split s #":" 2)]
-      {:harness (keyword h) :model m})
+    (let [parts (str/split s #":" 3)]
+      (case (count parts)
+        2 {:harness (keyword (first parts)) :model (second parts)}
+        3 {:harness (keyword (first parts)) :model (second parts) :reasoning (nth parts 2)}
+        {:harness :codex :model s}))
     {:harness :codex :model s}))
 
 (defn cmd-swarm
@@ -320,12 +365,13 @@
           ;; Convert to worker format
           workers (map-indexed
                     (fn [idx wc]
-                      (let [{:keys [harness model]} (parse-model-string (:model wc))]
+                      (let [{:keys [harness model reasoning]} (parse-model-string (:model wc))]
                         (worker/create-worker
                           {:id (str "w" idx)
                            :swarm-id swarm-id
                            :harness harness
                            :model model
+                           :reasoning reasoning
                            :iterations (or (:iterations wc) 10)
                            :prompts (:prompt wc)
                            :can-plan (:can_plan wc)
@@ -348,6 +394,9 @@
                            (if (:prompt wc) (str ", " (:prompt wc)) "")))))
       (println)
 
+      ;; Preflight: probe each unique model before launching workers
+      (validate-models! worker-configs review-model)
+
       ;; Run workers using new worker module
       (worker/run-workers! workers))))
 

package/agentnet/src/agentnet/worker.clj

@@ -106,8 +106,9 @@
 (defn create-worker
   "Create a worker config.
    :prompts is a string or vector of strings — paths to prompt files.
-   :can-plan when false, worker waits for tasks before starting (backpressure)."
-  [{:keys [id swarm-id harness model iterations prompts can-plan review-harness review-model]}]
+   :can-plan when false, worker waits for tasks before starting (backpressure).
+   :reasoning reasoning effort level (e.g. \"low\", \"medium\", \"high\") — codex only."
+  [{:keys [id swarm-id harness model iterations prompts can-plan reasoning review-harness review-model]}]
   {:id id
    :swarm-id swarm-id
    :harness (or harness :codex)
@@ -118,6 +119,7 @@
               (string? prompts) [prompts]
               :else [])
    :can-plan (if (some? can-plan) can-plan true)
+   :reasoning reasoning
    :review-harness review-harness
    :review-model review-model
    :completed 0
@@ -144,7 +146,7 @@
 
 (defn- run-agent!
   "Run agent with prompt, return {:output string, :done? bool, :exit int}"
-  [{:keys [id swarm-id harness model prompts]} worktree-path context]
+  [{:keys [id swarm-id harness model prompts reasoning]} worktree-path context]
   (let [;; 1. Task header (always, from package)
         task-header (or (load-prompt "config/prompts/_task_header.md") "")
 
@@ -175,6 +177,7 @@
                               "--skip-git-repo-check"
                               "-C" abs-worktree]
                        model (into ["--model" model])
+                       reasoning (into ["-c" (str "reasoning_effort=\"" reasoning "\"")])
                        true (conj "--" full-prompt))
               :claude (cond-> ["claude" "-p" "--dangerously-skip-permissions"
                                "--session-id" session-id]

package/bin/test-models

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# test-models — probe all models in oompa.json with a hello-world check
+#
+# Usage: test-models [path/to/oompa.json]
+#
+# Sends "say ok" to each unique model via its harness CLI.
+# Reports pass/fail for each. Exits non-zero if any fail.
+
+set -euo pipefail
+
+CONFIG="${1:-oompa.json}"
+
+if [ ! -f "$CONFIG" ]; then
+  echo "Config not found: $CONFIG"
+  echo "Usage: test-models [path/to/oompa.json]"
+  exit 1
+fi
+
+# Extract unique model strings (harness:model) from workers[] and review_model
+MODELS=$(python3 -c "
+import json, sys
+with open('$CONFIG') as f:
+    cfg = json.load(f)
+models = set()
+if cfg.get('review_model'):
+    models.add(cfg['review_model'])
+for w in cfg.get('workers', []):
+    if 'model' in w:
+        models.add(w['model'])
+for m in sorted(models):
+    print(m)
+")
+
+if [ -z "$MODELS" ]; then
+  echo "No models found in $CONFIG"
+  exit 1
+fi
+
+echo "Probing models from $CONFIG"
+echo ""
+
+PASS=0
+FAIL=0
+
+while IFS= read -r model; do
+  HARNESS="${model%%:*}"
+  MODEL_NAME="${model#*:}"
+
+  printf "  %-30s " "$model"
+
+  case "$HARNESS" in
+    claude)
+      OUTPUT=$(claude --model "$MODEL_NAME" -p "say ok" --max-turns 1 2>&1) && EXIT=$? || EXIT=$?
+      ;;
+    codex)
+      OUTPUT=$(codex exec --model "$MODEL_NAME" -- "say ok" 2>&1) && EXIT=$? || EXIT=$?
+      ;;
+    *)
+      echo "SKIP (unknown harness)"
+      continue
+      ;;
+  esac
+
+  if [ $EXIT -eq 0 ]; then
+    echo "OK"
+    PASS=$((PASS + 1))
+  else
+    echo "FAIL"
+    # Print first line of error for context
+    echo "$OUTPUT" | head -3 | sed 's/^/    /'
+    FAIL=$((FAIL + 1))
+  fi
+done <<< "$MODELS"
+
+echo ""
+echo "$PASS passed, $FAIL failed"
+
+[ "$FAIL" -eq 0 ]

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@nbardy/oompa",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Git-worktree multi-agent swarm orchestrator for Codex and Claude",
   "license": "MIT",
   "type": "commonjs",
   "bin": {
-    "oompa": "bin/oompa.js"
+    "oompa": "bin/oompa.js",
+    "oompa-test-models": "bin/test-models"
   },
   "files": [
     "bin/",