@comate/zulu 1.4.0-beta.4 → 1.4.0-beta.6

package/comate-engine/assets/skills/create-image/scripts/generate-image.ps1

@@ -0,0 +1,213 @@
+# generate-image.ps1 — Nano Banana Pro (Gemini 3 Pro Image) wrapper for Windows
+#
+# Design goals:
+#   - Idempotent: re-running is safe; existing `images\` dir is reused.
+#   - Agent-friendly errors: every failure writes a single-line tagged message
+#     to stderr: `[generate-image:<stage>] <msg>`.
+#
+# Exit codes mirror the bash script:
+#    0  success (absolute output path on stdout)
+#    2  bad args         3  missing dep        4  missing env
+#    5  input file error 10 HTTP/network       11 API error payload
+#   12  no image data    13 local I/O error
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory=$true)] [string] $Prompt,
+    [Parameter(Mandatory=$true)] [string] $Output,
+    [string] $InputPath = "",
+    [ValidateSet("1K","2K","4K","")] [string] $Resolution = "",
+    [ValidateSet("1:1","16:9","9:16","4:3","3:4","3:2","2:3","21:9")] [string] $AspectRatio = "1:1"
+)
+
+$ErrorActionPreference = "Stop"
+
+function Write-Err([string]$Stage, [string]$Msg) {
+    [Console]::Error.WriteLine("[generate-image:{0}] {1}" -f $Stage, $Msg)
+}
+function Die([string]$Stage, [string]$Msg, [int]$Code) {
+    Write-Err $Stage $Msg
+    exit $Code
+}
+
+$ApiUrl = "https://comate.baidu-int.com/api/aidevops/autocomate/rest/autowork/v1/generate-image"
+$OutDir = "images"
+
+# ---- arg validation ---------------------------------------------------------
+if ($Output -match '[\\/]') { Die "args" "-Output must be a filename only, not a path: $Output" 2 }
+
+# ---- dependency / env check -------------------------------------------------
+if (-not (Get-Command curl.exe -ErrorAction SilentlyContinue)) {
+    Die "deps" "curl.exe not found (requires Windows 10 1803+)" 3
+}
+
+function Resolve-LoginName {
+    if ($env:COMATE_USERNAME_ENCRYPTED) { return $env:COMATE_USERNAME_ENCRYPTED }
+    $homeDir = if ($env:USERPROFILE) { $env:USERPROFILE } else { $HOME }
+    $f = Join-Path $homeDir ".comate/login"
+    if (-not (Test-Path -LiteralPath $f)) { return $null }
+    try {
+        $token = ((Get-Content -Raw -LiteralPath $f).Trim()) -replace '^Bearer-',''
+        $parts = $token.Split('.')
+        if ($parts.Count -lt 2) { return $null }
+        $p = $parts[1].Replace('-','+').Replace('_','/')
+        switch ($p.Length % 4) { 2 { $p += '==' } 3 { $p += '=' } }
+        $json = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($p))
+        return ($json | ConvertFrom-Json).content.identity
+    } catch { return $null }
+}
+
+$LoginName = Resolve-LoginName
+if (-not $LoginName) {
+    Die "env" "COMATE_USERNAME_ENCRYPTED not set and ~/.comate/login unavailable/unparseable" 4
+}
+
+# ---- input file check -------------------------------------------------------
+if ($InputPath) {
+    if (-not (Test-Path -LiteralPath $InputPath -PathType Leaf)) {
+        Die "input" "input image not found: $InputPath" 5
+    }
+    $inItem = Get-Item -LiteralPath $InputPath
+    if ($inItem.Length -le 0) { Die "input" "input image is empty: $InputPath" 5 }
+}
+
+# ---- output dir (idempotent) ------------------------------------------------
+if (Test-Path -LiteralPath $OutDir) {
+    if (-not (Test-Path -LiteralPath $OutDir -PathType Container)) {
+        Die "output" "'$OutDir' exists but is not a directory" 13
+    }
+} else {
+    try { New-Item -ItemType Directory -Path $OutDir -ErrorAction Stop | Out-Null }
+    catch { Die "output" "failed to create dir '$OutDir': $($_.Exception.Message)" 13 }
+}
+
+# ---- resolution auto-detect (image-to-image only) ---------------------------
+if ($InputPath -and -not $Resolution) {
+    try {
+        Add-Type -AssemblyName System.Drawing
+        $img = [System.Drawing.Image]::FromFile((Resolve-Path -LiteralPath $InputPath))
+        $maxDim = [Math]::Max($img.Width, $img.Height)
+        $img.Dispose()
+        $Resolution = if ($maxDim -ge 3000) { "4K" } elseif ($maxDim -ge 1500) { "2K" } else { "1K" }
+    } catch {
+        Write-Err "input" "resolution auto-detect failed ($($_.Exception.Message)); falling back to 1K"
+        $Resolution = "1K"
+    }
+}
+if (-not $Resolution) { $Resolution = "1K" }
+
+# ---- build payload ----------------------------------------------------------
+$tmpFile  = Join-Path $env:TEMP ("genimg-"  + [guid]::NewGuid().ToString() + ".json")
+$tmpResp  = Join-Path $env:TEMP ("genimg-r-" + [guid]::NewGuid().ToString() + ".json")
+
+try {
+    if ($InputPath) {
+        try {
+            $bytes = [IO.File]::ReadAllBytes((Resolve-Path -LiteralPath $InputPath))
+            $b64   = [Convert]::ToBase64String($bytes)
+        } catch {
+            Die "input" "base64 encoding failed: $($_.Exception.Message)" 5
+        }
+        $mime = switch -Regex ($InputPath) {
+            '\.jpe?g$' { 'image/jpeg'; break }
+            '\.webp$'  { 'image/webp'; break }
+            default    { 'image/png' }
+        }
+        $payload = @{
+            contents = @(@{
+                role = "USER"
+                parts = @(
+                    @{ inline_data = @{ mime_type = $mime; data = $b64 } },
+                    @{ text = $Prompt }
+                )
+            })
+            resolution  = $Resolution
+            aspectRatio = $AspectRatio
+        }
+    } else {
+        $payload = @{
+            contents = @(@{
+                role  = "USER"
+                parts = @(@{ text = $Prompt })
+            })
+            resolution  = $Resolution
+            aspectRatio = $AspectRatio
+        }
+    }
+
+    try {
+        $payload | ConvertTo-Json -Depth 10 -Compress |
+            Set-Content -Path $tmpFile -Encoding UTF8 -NoNewline -ErrorAction Stop
+    } catch {
+        Die "payload" "failed to write request JSON: $($_.Exception.Message)" 13
+    }
+
+    # ---- HTTP call (capture status + body separately) -----------------------
+    $httpCode = ""
+    try {
+        $httpCode = & curl.exe -sS -o "$tmpResp" -w "%{http_code}" -X POST $ApiUrl `
+            -H "Content-Type: application/json" `
+            -H "login-name: $LoginName" `
+            -d "@$tmpFile" 2>&1
+    } catch {
+        Die "http" "curl invocation failed: $($_.Exception.Message)" 10
+    }
+    if ($LASTEXITCODE -ne 0) {
+        Die "http" "curl exit=$LASTEXITCODE output=$httpCode" 10
+    }
+    if ($httpCode -notmatch '^2\d\d$') {
+        $snippet = ""
+        if (Test-Path -LiteralPath $tmpResp) {
+            $snippet = (Get-Content -LiteralPath $tmpResp -Raw -ErrorAction SilentlyContinue)
+            if ($snippet.Length -gt 2000) { $snippet = $snippet.Substring(0,2000) }
+            $snippet = $snippet -replace "\r?\n"," "
+        }
+        Write-Err "http" "HTTP $httpCode from API"
+        Write-Err "http" "body: $snippet"
+        exit 10
+    }
+
+    # ---- parse response -----------------------------------------------------
+    $raw = Get-Content -LiteralPath $tmpResp -Raw
+    try {
+        $response = $raw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        $snip = if ($raw.Length -gt 2000) { $raw.Substring(0,2000) } else { $raw }
+        Write-Err "api" "response is not valid JSON"
+        Write-Err "api" "body: $($snip -replace '\r?\n',' ')"
+        exit 11
+    }
+
+    if ($response.error) {
+        $msg = if ($response.error.message) { $response.error.message } else { ($response.error | ConvertTo-Json -Compress) }
+        Die "api" "server returned error: $msg" 11
+    }
+
+    $imgPart = $response.candidates[0].content.parts |
+        Where-Object { $_.inlineData } | Select-Object -First 1
+    if (-not $imgPart) {
+        $text = ($response.candidates[0].content.parts |
+            Where-Object { $_.text } | Select-Object -ExpandProperty text) -join " "
+        if ($text) { Write-Err "api" "no image returned; model said: $text" }
+        $snip = if ($raw.Length -gt 2000) { $raw.Substring(0,2000) } else { $raw }
+        Write-Err "api" "no inlineData in response. body: $($snip -replace '\r?\n',' ')"
+        exit 12
+    }
+
+    # ---- write output -------------------------------------------------------
+    $outPath = Join-Path (Get-Location) (Join-Path $OutDir $Output)
+    try {
+        [IO.File]::WriteAllBytes($outPath, [Convert]::FromBase64String($imgPart.inlineData.data))
+    } catch {
+        Die "write" "failed to write output file: $($_.Exception.Message)" 13
+    }
+
+    if (-not (Test-Path -LiteralPath $outPath) -or (Get-Item -LiteralPath $outPath).Length -le 0) {
+        Die "write" "output file empty after decode: $outPath" 13
+    }
+
+    Write-Output $outPath
+}
+finally {
+    Remove-Item -Force -ErrorAction SilentlyContinue $tmpFile, $tmpResp
+}

package/comate-engine/assets/skills/create-image/scripts/generate-image.sh

@@ -0,0 +1,322 @@
+#!/usr/bin/env bash
+#
+# generate-image.sh — Nano Banana Pro (Gemini 3 Pro Image) wrapper for macOS/Linux
+#
+# Usage:
+#   generate-image.sh --prompt "..." --output name.png \
+#                     [--input path/to/ref.png] \
+#                     [--resolution 1K|2K|4K] \
+#                     [--aspect-ratio 1:1|16:9|9:16|4:3|3:4|3:2|2:3|21:9]
+#
+# Design goals:
+#   - Idempotent: safe to run repeatedly; existing `images/` dir is fine.
+#   - Agent-friendly errors: every failure path writes a single-line tagged
+#     message to stderr prefixed with `[generate-image:<stage>]` so the caller
+#     can pattern-match and react.
+#   - Portable: requires only curl + base64 + (python3 OR jq). No hard jq dep.
+#
+# Exit codes:
+#    0  success — absolute output path on stdout
+#    2  bad CLI args
+#    3  missing dependency (curl/base64/python3|jq)
+#    4  missing/invalid env (COMATE_USERNAME_ENCRYPTED)
+#    5  input file missing / unreadable
+#   10  HTTP/network failure
+#   11  API returned error payload
+#   12  API response had no image data
+#   13  output file empty after write
+
+set -uo pipefail
+
+err() { printf '[generate-image:%s] %s\n' "$1" "$2" >&2; }
+die() { err "$1" "$2"; exit "$3"; }
+
+API_URL="https://comate.baidu-int.com/api/aidevops/autocomate/rest/autowork/v1/generate-image"
+OUT_DIR="images"
+
+PROMPT=""
+OUTPUT=""
+INPUT=""
+RESOLUTION=""
+ASPECT="1:1"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -p|--prompt)       PROMPT="${2:-}"; shift 2 ;;
+    -o|--output)       OUTPUT="${2:-}"; shift 2 ;;
+    -i|--input)        INPUT="${2:-}"; shift 2 ;;
+    -r|--resolution)   RESOLUTION="${2:-}"; shift 2 ;;
+    -a|--aspect-ratio) ASPECT="${2:-}"; shift 2 ;;
+    -h|--help)
+      sed -n '3,18p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    *) die "args" "unknown argument: $1" 2 ;;
+  esac
+done
+
+# ---- arg validation ---------------------------------------------------------
+[[ -z "$PROMPT" ]] && die "args" "--prompt is required" 2
+[[ -z "$OUTPUT" ]] && die "args" "--output is required" 2
+[[ "$OUTPUT" == */* ]] && die "args" "--output must be a filename only, not a path: $OUTPUT" 2
+
+if [[ -n "$RESOLUTION" ]]; then
+  case "$RESOLUTION" in 1K|2K|4K) ;; *) die "args" "invalid --resolution: $RESOLUTION (expect 1K|2K|4K)" 2 ;; esac
+fi
+case "$ASPECT" in
+  1:1|16:9|9:16|4:3|3:4|3:2|2:3|21:9) ;;
+  *) die "args" "invalid --aspect-ratio: $ASPECT" 2 ;;
+esac
+
+# ---- dependency check -------------------------------------------------------
+for bin in curl base64; do
+  command -v "$bin" >/dev/null 2>&1 || die "deps" "required binary not found: $bin" 3
+done
+# JSON tool: prefer python3 (universally available on Linux/macOS), fallback jq.
+JSON_TOOL=""
+if command -v python3 >/dev/null 2>&1; then
+  JSON_TOOL="python3"
+elif command -v jq >/dev/null 2>&1; then
+  JSON_TOOL="jq"
+else
+  die "deps" "need either 'python3' or 'jq' for JSON handling (install one)" 3
+fi
+
+# ---- JSON helpers (branch on $JSON_TOOL) ------------------------------------
+# build_payload_text <outfile>                  — uses PROMPT/RESOLUTION/ASPECT env
+# build_payload_image <outfile> <b64> <mime>    — uses PROMPT/RESOLUTION/ASPECT env
+# parse_error  <respfile>  -> prints error message or empty
+# parse_image  <respfile>  -> prints base64 data or empty
+# parse_text   <respfile>  -> prints concatenated text parts (reasoning)
+# parse_jwt_identity <raw-b64-decoded-json on stdin> -> prints identity
+
+build_payload_text() {
+  local out="$1"
+  if [[ "$JSON_TOOL" == "python3" ]]; then
+    PROMPT="$PROMPT" RES="$RESOLUTION" ASP="$ASPECT" python3 - <<'PY' > "$out"
+import json, os
+print(json.dumps({
+  "contents":[{"role":"USER","parts":[{"text":os.environ["PROMPT"]}]}],
+  "resolution":os.environ["RES"],
+  "aspectRatio":os.environ["ASP"]
+}))
+PY
+  else
+    jq -n --arg t "$PROMPT" --arg r "$RESOLUTION" --arg a "$ASPECT" \
+      '{contents:[{role:"USER",parts:[{text:$t}]}],resolution:$r,aspectRatio:$a}' > "$out"
+  fi
+}
+
+# NOTE: base64 payloads can exceed ARG_MAX (E2BIG) if passed via argv/env,
+# so we always pass the base64 via a file path.
+build_payload_image() {
+  local out="$1" b64_file="$2" mime="$3"
+  if [[ "$JSON_TOOL" == "python3" ]]; then
+    PROMPT="$PROMPT" RES="$RESOLUTION" ASP="$ASPECT" MIME="$mime" B64_FILE="$b64_file" python3 - <<'PY' > "$out"
+import json, os
+with open(os.environ["B64_FILE"], "r") as f:
+    b64 = f.read()
+print(json.dumps({
+  "contents":[{"role":"USER","parts":[
+    {"inline_data":{"mime_type":os.environ["MIME"],"data":b64}},
+    {"text":os.environ["PROMPT"]}
+  ]}],
+  "resolution":os.environ["RES"],
+  "aspectRatio":os.environ["ASP"]
+}))
+PY
+  else
+    # --rawfile reads the whole file as a raw string, bypassing argv length limits.
+    jq -n --arg t "$PROMPT" --rawfile b "$b64_file" --arg m "$mime" --arg r "$RESOLUTION" --arg a "$ASPECT" \
+      '{contents:[{role:"USER",parts:[{inline_data:{mime_type:$m,data:$b}},{text:$t}]}],resolution:$r,aspectRatio:$a}' > "$out"
+  fi
+}
+
+parse_error() {
+  local f="$1"
+  if [[ "$JSON_TOOL" == "python3" ]]; then
+    python3 - "$f" <<'PY'
+import json, sys
+try:
+    d = json.load(open(sys.argv[1]))
+    e = d.get("error")
+    if not e: sys.exit(0)
+    if isinstance(e, dict):
+        print(e.get("message") or json.dumps(e, ensure_ascii=False))
+    else:
+        print(str(e))
+except Exception:
+    pass
+PY
+  else
+    jq -r 'if .error then (.error.message // (.error|tostring)) else empty end' "$f" 2>/dev/null
+  fi
+}
+
+parse_image() {
+  local f="$1"
+  if [[ "$JSON_TOOL" == "python3" ]]; then
+    python3 - "$f" <<'PY'
+import json, sys
+try:
+    d = json.load(open(sys.argv[1]))
+    for p in (d.get("candidates") or [{}])[0].get("content",{}).get("parts",[]) or []:
+        data = (p.get("inlineData") or {}).get("data") or (p.get("inline_data") or {}).get("data")
+        if data:
+            sys.stdout.write(data)
+            break
+except Exception:
+    pass
+PY
+  else
+    jq -r '.candidates[0].content.parts[]? | select(.inlineData // .inline_data) | (.inlineData // .inline_data).data' "$f" 2>/dev/null | head -1
+  fi
+}
+
+parse_text() {
+  local f="$1"
+  if [[ "$JSON_TOOL" == "python3" ]]; then
+    python3 - "$f" <<'PY'
+import json, sys
+try:
+    d = json.load(open(sys.argv[1]))
+    out=[]
+    for p in (d.get("candidates") or [{}])[0].get("content",{}).get("parts",[]) or []:
+        if "text" in p and p["text"]:
+            out.append(p["text"])
+    sys.stdout.write("\n".join(out))
+except Exception:
+    pass
+PY
+  else
+    jq -r '.candidates[0].content.parts[]? | select(.text) | .text' "$f" 2>/dev/null
+  fi
+}
+
+parse_jwt_identity_from_stdin() {
+  if [[ "$JSON_TOOL" == "python3" ]]; then
+    # Use -c (not heredoc) so stdin remains the piped JWT bytes, not the script.
+    python3 -c 'import json,sys
+try:
+    d=json.load(sys.stdin)
+    sys.stdout.write((d.get("content") or {}).get("identity") or "")
+except Exception:
+    pass'
+  else
+    jq -r '.content.identity // empty' 2>/dev/null
+  fi
+}
+
+# ---- resolve login-name (env > ~/.comate/login JWT) -------------------------
+resolve_login_name() {
+  if [[ -n "${COMATE_USERNAME_ENCRYPTED:-}" ]]; then
+    printf '%s' "$COMATE_USERNAME_ENCRYPTED"; return 0
+  fi
+  local f="${HOME}/.comate/login"
+  [[ -f "$f" ]] || return 1
+  local token payload pad ident
+  token=$(tr -d '[:space:]' < "$f" | sed 's/^Bearer-//')
+  payload="${token#*.}"; payload="${payload%%.*}"
+  [[ -z "$payload" ]] && return 1
+  # base64url -> base64 + pad to multiple of 4
+  payload=$(printf '%s' "$payload" | tr '_-' '/+')
+  pad=$(( (4 - ${#payload} % 4) % 4 ))
+  while [[ $pad -gt 0 ]]; do payload+='='; pad=$((pad-1)); done
+  ident=$(printf '%s' "$payload" | base64 --decode 2>/dev/null | parse_jwt_identity_from_stdin)
+  [[ -n "$ident" ]] && { printf '%s' "$ident"; return 0; }
+  return 1
+}
+
+LOGIN_NAME=$(resolve_login_name) || die "env" "COMATE_USERNAME_ENCRYPTED not set and ~/.comate/login unavailable/unparseable" 4
+
+if [[ -n "$INPUT" ]]; then
+  [[ -f "$INPUT" ]] || die "input" "input image not found: $INPUT" 5
+  [[ -r "$INPUT" ]] || die "input" "input image not readable: $INPUT" 5
+  [[ -s "$INPUT" ]] || die "input" "input image is empty: $INPUT" 5
+fi
+
+# ---- output dir (idempotent) ------------------------------------------------
+if [[ -e "$OUT_DIR" && ! -d "$OUT_DIR" ]]; then
+  die "output" "'$OUT_DIR' exists but is not a directory" 13
+fi
+mkdir -p "$OUT_DIR" || die "output" "failed to create output dir: $OUT_DIR" 13
+
+# ---- resolution auto-detect (image-to-image only) ---------------------------
+if [[ -n "$INPUT" && -z "$RESOLUTION" ]]; then
+  MAX_DIM=0
+  if command -v sips >/dev/null 2>&1; then
+    MAX_DIM=$(sips -g pixelWidth -g pixelHeight "$INPUT" 2>/dev/null | awk '/pixel/{print $2}' | sort -rn | head -1 || echo 0)
+  elif command -v identify >/dev/null 2>&1; then
+    MAX_DIM=$(identify -format "%[fx:max(w,h)]" "$INPUT" 2>/dev/null || echo 0)
+  fi
+  if   [[ "$MAX_DIM" =~ ^[0-9]+$ ]] && [[ "$MAX_DIM" -ge 3000 ]]; then RESOLUTION="4K"
+  elif [[ "$MAX_DIM" =~ ^[0-9]+$ ]] && [[ "$MAX_DIM" -ge 1500 ]]; then RESOLUTION="2K"
+  else                                                                RESOLUTION="1K"
+  fi
+fi
+RESOLUTION="${RESOLUTION:-1K}"
+
+# ---- build payload ----------------------------------------------------------
+TMP_JSON=$(mktemp -t genimg.XXXXXX) || die "tmp" "mktemp failed" 13
+TMP_RESP=$(mktemp -t genimg-resp.XXXXXX) || die "tmp" "mktemp failed" 13
+TMP_B64=$(mktemp -t genimg-b64.XXXXXX) || die "tmp" "mktemp failed" 13
+trap 'rm -f "$TMP_JSON" "$TMP_RESP" "$TMP_B64"' EXIT
+
+if [[ -n "$INPUT" ]]; then
+  # Write base64 to a file (not an env var / argv) to avoid ARG_MAX (E2BIG) for large images.
+  # macOS base64 supports `-i <file>`; GNU coreutils uses `base64 <file>`.
+  if ! base64 -i "$INPUT" 2>/dev/null | tr -d '\n' > "$TMP_B64"; then
+    base64 "$INPUT" 2>/dev/null | tr -d '\n' > "$TMP_B64" \
+      || die "input" "base64 encoding failed for: $INPUT" 5
+  fi
+  [[ -s "$TMP_B64" ]] || die "input" "base64 produced empty output for: $INPUT" 5
+  MIME="image/png"
+  case "${INPUT##*.}" in
+    jpg|jpeg|JPG|JPEG) MIME="image/jpeg" ;;
+    webp|WEBP)         MIME="image/webp" ;;
+  esac
+  build_payload_image "$TMP_JSON" "$TMP_B64" "$MIME" || die "payload" "failed to build request JSON" 13
+else
+  build_payload_text "$TMP_JSON" || die "payload" "failed to build request JSON" 13
+fi
+[[ -s "$TMP_JSON" ]] || die "payload" "payload file is empty" 13
+
+# ---- HTTP call --------------------------------------------------------------
+HTTP_CODE=$(curl -sS -o "$TMP_RESP" -w '%{http_code}' -X POST "$API_URL" \
+  -H "Content-Type: application/json" \
+  -H "login-name: ${LOGIN_NAME}" \
+  -d "@$TMP_JSON" 2>&1) || {
+    err "http" "curl failed: $HTTP_CODE"
+    exit 10
+  }
+
+if [[ "$HTTP_CODE" != 2* ]]; then
+  BODY_SNIP=$(head -c 2000 "$TMP_RESP" | tr '\n' ' ')
+  err "http" "HTTP $HTTP_CODE from API"
+  err "http" "body: $BODY_SNIP"
+  exit 10
+fi
+
+# ---- parse response ---------------------------------------------------------
+ERR_MSG=$(parse_error "$TMP_RESP")
+if [[ -n "$ERR_MSG" ]]; then
+  err "api" "server returned error: $(printf '%s' "$ERR_MSG" | head -c 1000)"
+  exit 11
+fi
+
+B64=$(parse_image "$TMP_RESP")
+if [[ -z "$B64" ]]; then
+  TEXT=$(parse_text "$TMP_RESP" | head -c 1000)
+  BODY_SNIP=$(head -c 2000 "$TMP_RESP" | tr '\n' ' ')
+  [[ -n "$TEXT" ]] && err "api" "no image returned; model said: $TEXT"
+  err "api" "no inlineData in response. body: $BODY_SNIP"
+  exit 12
+fi
+
+# ---- write output -----------------------------------------------------------
+OUT_PATH="$OUT_DIR/$OUTPUT"
+printf '%s' "$B64" | base64 --decode > "$OUT_PATH" || die "write" "base64 decode failed" 13
+
+if [[ ! -s "$OUT_PATH" ]]; then
+  die "write" "output file is empty after decode: $OUT_PATH" 13
+fi
+
+printf '%s\n' "$(cd "$(dirname "$OUT_PATH")" && pwd)/$(basename "$OUT_PATH")"

package/comate-engine/assets/skills/create-subagent/SKILL.md

@@ -30,6 +30,18 @@ When multiple subagents share the same name, the higher-priority location wins.
 
 **Personal subagents** (`~/.comate/agents/`): Personal agents available across all your projects.
 
+## Available Models
+
+Subagents can optionally use a different model than the main agent via the `model` frontmatter field. Valid values are:
+
+- `inherit` — use the main agent's current model (default when `model` is omitted or the value is unrecognized)
+- `fast` — a cheaper, faster model
+- An exact model name from the list below:
+
+${COMATE_AVAILABLE_MODELS}
+
+Models listed with a `-Thinking` suffix support extended thinking/reasoning mode.
+
 ## Subagent File Format
 
 Create a `.md` file with YAML frontmatter and a markdown body (the system prompt):
@@ -38,6 +50,7 @@ Create a `.md` file with YAML frontmatter and a markdown body (the system prompt
 ---
 name: code-reviewer
 description: Reviews code for quality and best practices
+model: Model this subagent uses
 ---
 
 You are a code reviewer. When invoked, analyze the code and provide
@@ -50,6 +63,7 @@ specific, actionable feedback on quality, security, and best practices.
 |-------|-------------|
 | `name` | Unique identifier (lowercase letters and hyphens only) |
 | `description` | When to delegate to this subagent (be specific!) |
+| `model` | (Optional) Model this subagent uses. Must be one of the valid values from the **Available Models** section above: `inherit` (default), `fast`, or an exact model name from that list (including `-Thinking` variants). Unrecognized names fall back to `inherit`. |
 
 ## Writing Effective Descriptions
 
@@ -199,7 +213,11 @@ Below are candidate tools name, according to the user's query, decide the subage
 If you are not sure with some tools, ask her directly.
 Empty means only selecting default read-only tools; Lack of this key means selecting all tools
 
-### Step 3: Create the File
+### Step 3: Clarify the Agent's Model
+**If the user requests a specific model, confirm the exact name from the **Available Models** list above**.
+Otherwise, tell her she can use `inherit` or `fast`.
+
+### Step 4: Create the File
 
 ```bash
 # For project-level
@@ -211,11 +229,11 @@ mkdir -p ~/.comate/agents
 touch ~/.comate/agents/my-agent.md
 ```
 
-### Step 4: Define Configuration
+### Step 5: Define Configuration
 
-Write the frontmatter with the required fields (`name` and `description`).
+Write the frontmatter with the required fields (`name` and `description`). Optionally add `model` (placed after `description`) using one of the valid values from the **Available Models** section: `inherit`, `fast`, or an exact model name from that list. If the user requests a specific model, confirm the exact name from the **Available Models** list.
 
-### Step 5: Write the System Prompt
+### Step 6: Write the System Prompt
 
 The body becomes the system prompt. Be specific about:
 - What the agent should do when invoked
@@ -223,7 +241,7 @@ The body becomes the system prompt. Be specific about:
 - Output format and structure
 - Any constraints or guidelines
 
-### Step 6: Test the Agent
+### Step 7: Test the Agent
 
 Ask the AI to use your new agent: