@comate/zulu 1.4.0-beta.3 → 1.4.0-beta.5

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-skill/SKILL.md

@@ -79,7 +79,6 @@ Based on the user interview, fill in these components:
 
 - **name**: Skill identifier
 - **description**: When to trigger, what it does. This is the primary triggering mechanism - include both what the skill does AND specific contexts for when to use it. All "when to use" info goes here, not in the body. Note: currently Comate has a tendency to "undertrigger" skills -- to not use them when they'd be useful. To combat this, please make the skill descriptions a little bit "pushy". So for instance, instead of "How to build a simple fast dashboard to display internal Anthropic data.", you might write "How to build a simple fast dashboard to display internal Anthropic data. Make sure to use this skill whenever the user mentions dashboards, data visualization, internal metrics, or wants to display any kind of company data, even if they don't explicitly ask for a 'dashboard.'"
-- **compatibility**: Required tools, dependencies (optional, rarely needed)
 - **the rest of the skill :)**
 
 ### Skill Writing Guide
@@ -446,4 +445,4 @@ Repeating one more time the core loop here for emphasis:
 - Repeat until you and the user are satisfied
 - Package the final skill and return it to the user.
 
-Please add steps to your TodoList, if you have such a thing, to make sure you don't forget.
+Please add steps to your TodoList, if you have such a thing, to make sure you don't forget.

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

@@ -38,6 +38,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 +51,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. One of: `inherit` (inherit from main agent, default), `fast` (cheaper/faster model), or a specific model display name. For specific models, the user must pick from their available list at https://ku.baidu-int.com/knowledge/HFVrC7hq1Q/_SKPgSwp2G/jyGhbHUQQG/ZS3uu0XgQjLm31 (**models supporting thinking have `-Thinking` appended to the displayName, e.g. `Claude Sonnet 4.6-Thinking`** MUST tell user this, she may not know). Unrecognized names fall back to `inherit`. |
 
 ## Writing Effective Descriptions
 
@@ -199,7 +201,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, ask her to confirm the exact displayName from the user's available model list** [model name](https://ku.baidu-int.com/knowledge/HFVrC7hq1Q/_SKPgSwp2G/jyGhbHUQQG/ZS3uu0XgQjLm31).
+Otherwise, tell her can use inherit or fast.
+
+### Step 4: Create the File
 
 ```bash
 # For project-level
@@ -211,11 +217,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`) with one of: `inherit`, `fast`, or a specific model display name from the user's available model list (https://ku.baidu-int.com/knowledge/HFVrC7hq1Q/_SKPgSwp2G/jyGhbHUQQG/ZS3uu0XgQjLm31). If the user requests a specific model, ask them to confirm the exact displayName from that 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 +229,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: