@plusonelabs/cue 0.0.94 → 0.0.95

package/dist/skills/z-asr/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: z-asr
+description: Transcribe audio using Z.AI GLM-ASR model. Use when user asks to transcribe audio with Z.AI, ZhipuAI, or GLM-ASR. Supports wav/mp3 files, international and Chinese endpoints.
+category: media
+type: hybrid
+env:
+  - Z_AI_API_KEY
+metadata:
+  short-description: Transcribe audio with Z.AI
+  scope: first-party
+---
+
+Transcribe audio files to text using Z.AI's GLM-ASR-2512 model.
+
+## Requirements
+
+- Python 3.10+, `httpx` package
+- `Z_AI_API_KEY` environment variable (or configured via `cue skill env set`)
+- Get your API key at: https://z.ai/manage-apikey/apikey-list
+
+## Usage
+
+```bash
+# Transcribe a local audio file
+python3 <skill-dir>/generate.py audio.mp3
+
+# Use Chinese endpoint (open.bigmodel.cn)
+python3 <skill-dir>/generate.py audio.mp3 --cn
+
+# Save transcript to file
+python3 <skill-dir>/generate.py audio.mp3 --output transcript.txt
+
+# JSON output with metadata
+python3 <skill-dir>/generate.py audio.mp3 --json
+
+# Provide context for better accuracy
+python3 <skill-dir>/generate.py audio.mp3 --prompt "Previous sentence context here"
+
+# Hotwords for domain-specific vocabulary
+python3 <skill-dir>/generate.py audio.mp3 --hotword "TensorFlow" --hotword "PyTorch"
+```
+
+**Constraints:** Audio files must be `.wav` or `.mp3`, max 25MB, max 30 seconds duration, mono channel.
+
+**Endpoints:**
+
+- Default: `api.z.ai` (international)
+- `--cn`: `open.bigmodel.cn` (Chinese domestic)
+
+## Troubleshooting
+
+| Error                        | Solution                                             |
+| ---------------------------- | ---------------------------------------------------- |
+| "Z_AI_API_KEY not set"       | Set with: `/skill env set Z_AI_API_KEY <your-key>`   |
+| "File too large"             | Audio must be under 25MB                             |
+| "Unsupported format"         | Only `.wav` and `.mp3` are supported                 |
+| "API error: 401"             | Check your API key is valid                          |
+| "only supports mono channel" | Convert with: `ffmpeg -i input.wav -ac 1 output.wav` |

package/dist/skills/z-asr/generate.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Z-ASR - Audio transcription using Z.AI GLM-ASR-2512 model.
+
+Usage:
+    python generate.py audio.mp3
+    python generate.py audio.wav --output transcript.txt
+    python generate.py audio.mp3 --json
+    python generate.py audio.mp3 --prompt "context" --hotword "term1" --hotword "term2"
+    python generate.py audio.mp3 --cn
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '_lib'))
+from credentials import get_credential
+
+try:
+    import httpx
+except ImportError:
+    print("Error: httpx not installed. Run: pip install httpx")
+    sys.exit(1)
+
+
+BASE_URLS = {
+    "intl": "https://api.z.ai/api/paas/v4/audio/transcriptions",
+    "cn": "https://open.bigmodel.cn/api/paas/v4/audio/transcriptions",
+}
+MODEL = "glm-asr-2512"
+TIMEOUT = 120.0
+MAX_FILE_SIZE = 25 * 1024 * 1024
+SUPPORTED_FORMATS = {".wav", ".mp3"}
+SKILL_DIR = Path(__file__).parent
+TEMP_DIR = SKILL_DIR / "temp"
+
+
+def transcribe(
+    file_path: Path,
+    prompt: str | None = None,
+    hotwords: list[str] | None = None,
+    use_cn: bool = False,
+) -> dict:
+    api_key = get_credential("Z_AI_API_KEY", "z-asr")
+    api_url = BASE_URLS["cn"] if use_cn else BASE_URLS["intl"]
+
+    if not file_path.exists():
+        print(f"Error: File not found: {file_path}")
+        sys.exit(1)
+
+    suffix = file_path.suffix.lower()
+    if suffix not in SUPPORTED_FORMATS:
+        print(f"Error: Unsupported format '{suffix}'. Use .wav or .mp3")
+        sys.exit(1)
+
+    file_size = file_path.stat().st_size
+    if file_size > MAX_FILE_SIZE:
+        print(f"Error: File too large ({file_size / 1024 / 1024:.1f}MB). Max 25MB.")
+        sys.exit(1)
+
+    region = "CN" if use_cn else "intl"
+    print(f"Transcribing {file_path.name} ({file_size / 1024:.0f}KB) with {MODEL} ({region})...")
+
+    data: dict = {"model": MODEL, "stream": "false"}
+    if prompt:
+        data["prompt"] = prompt
+    if hotwords:
+        data["hotwords"] = json.dumps(hotwords)
+
+    mime = "audio/wav" if suffix == ".wav" else "audio/mpeg"
+
+    start_time = time.time()
+
+    with httpx.Client(timeout=TIMEOUT) as client:
+        with open(file_path, "rb") as f:
+            response = client.post(
+                api_url,
+                headers={"Authorization": f"Bearer {api_key}"},
+                data=data,
+                files={"file": (file_path.name, f, mime)},
+            )
+
+        if response.status_code != 200:
+            print(f"Error: API returned {response.status_code}")
+            print(response.text[:500])
+            sys.exit(1)
+
+        result = response.json()
+
+    processing_time = int((time.time() - start_time) * 1000)
+
+    if "error" in result or "code" in result:
+        err = result.get("error", result)
+        msg = err.get("message", err) if isinstance(err, dict) else str(err)
+        print(f"Error: {msg}")
+        sys.exit(1)
+
+    return {
+        "text": result.get("text", ""),
+        "model": result.get("model", MODEL),
+        "id": result.get("id", ""),
+        "processing_time_ms": processing_time,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Transcribe audio using Z.AI GLM-ASR-2512",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s audio.mp3
+  %(prog)s recording.wav --output transcript.txt
+  %(prog)s audio.mp3 --json
+  %(prog)s audio.mp3 --prompt "Previous context" --hotword "TensorFlow"
+  %(prog)s audio.mp3 --cn
+        """,
+    )
+    parser.add_argument("file", type=Path, help="Audio file to transcribe (.wav or .mp3)")
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file path (default: print to stdout)",
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output JSON with metadata",
+    )
+    parser.add_argument(
+        "--prompt", "-p",
+        help="Context from previous transcription (up to 8000 chars)",
+    )
+    parser.add_argument(
+        "--hotword",
+        action="append",
+        help="Hotword for better recognition (can be used multiple times, max 100)",
+    )
+    parser.add_argument(
+        "--cn",
+        action="store_true",
+        help="Use Chinese endpoint (open.bigmodel.cn) instead of international (api.z.ai)",
+    )
+
+    args = parser.parse_args()
+
+    result = transcribe(
+        file_path=args.file,
+        prompt=args.prompt,
+        hotwords=args.hotword,
+        use_cn=args.cn,
+    )
+
+    if args.json:
+        output_content = json.dumps(result, indent=2, ensure_ascii=False)
+    else:
+        output_content = result["text"]
+
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(output_content, encoding="utf-8")
+        print(f"Saved: {output_path}")
+    else:
+        print(output_content)
+
+    print(f"\nProcessing time: {result['processing_time_ms']}ms")
+    word_count = len(result["text"].split())
+    print(f"Word count: {word_count}")
+
+
+if __name__ == "__main__":
+    main()

package/dist/skills/z-search/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: z-search
+description: Web search using Z.AI Search Prime engine. Use when user asks to search the web with Z.AI, ZhipuAI, or needs LLM-optimized search results.
+category: data
+type: hybrid
+env:
+  - Z_AI_API_KEY
+metadata:
+  short-description: Web search with Z.AI
+  scope: first-party
+---
+
+Search the web using Z.AI's Search Prime engine, optimized for LLM consumption.
+
+## Requirements
+
+- Python 3.10+, `httpx` package
+- `Z_AI_API_KEY` environment variable (or configured via `cue skill env set`)
+- Get your API key at: https://z.ai/manage-apikey/apikey-list
+
+## Usage
+
+```bash
+# Basic search
+python3 <skill-dir>/generate.py "latest news about AI"
+
+# Limit results
+python3 <skill-dir>/generate.py "Python 3.14 features" --count 5
+
+# Filter by recency
+python3 <skill-dir>/generate.py "breaking news" --recency oneDay
+
+# Filter by domain
+python3 <skill-dir>/generate.py "machine learning" --domain arxiv.org
+
+# JSON output with metadata
+python3 <skill-dir>/generate.py "web search API" --json
+
+# Save results to file
+python3 <skill-dir>/generate.py "search query" --output results.txt
+```
+
+**Options:**
+
+- `--count N` — Number of results (1-50, default 10)
+- `--recency` — Time filter: `oneDay`, `oneWeek`, `oneMonth`, `oneYear`, `noLimit` (default)
+- `--domain` — Restrict results to a specific domain
+- `--json` — Output full JSON with metadata
+- `--output FILE` — Save results to file
+
+## Troubleshooting
+
+| Error                  | Solution                                           |
+| ---------------------- | -------------------------------------------------- |
+| "Z_AI_API_KEY not set" | Set with: `/skill env set Z_AI_API_KEY <your-key>` |
+| "API error: 401"       | Check your API key is valid                        |
+| "API error: 429"       | Rate limited or insufficient balance               |

package/dist/skills/z-search/generate.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+Z-Search - Web search using Z.AI Search Prime engine.
+
+Usage:
+    python generate.py "search query"
+    python generate.py "search query" --count 5
+    python generate.py "search query" --recency oneDay
+    python generate.py "search query" --domain arxiv.org
+    python generate.py "search query" --json
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '_lib'))
+from credentials import get_credential
+
+try:
+    import httpx
+except ImportError:
+    print("Error: httpx not installed. Run: pip install httpx")
+    sys.exit(1)
+
+
+API_URL = "https://api.z.ai/api/paas/v4/web_search"
+SEARCH_ENGINE = "search-prime"
+TIMEOUT = 30.0
+RECENCY_CHOICES = ["oneDay", "oneWeek", "oneMonth", "oneYear", "noLimit"]
+
+
+def search(
+    query: str,
+    count: int = 10,
+    recency: str | None = None,
+    domain: str | None = None,
+) -> dict:
+    api_key = get_credential("Z_AI_API_KEY", "z-search")
+
+    payload: dict = {
+        "search_engine": SEARCH_ENGINE,
+        "search_query": query,
+    }
+    if count != 10:
+        payload["count"] = count
+    if recency and recency != "noLimit":
+        payload["search_recency_filter"] = recency
+    if domain:
+        payload["search_domain_filter"] = domain
+
+    start_time = time.time()
+
+    with httpx.Client(timeout=TIMEOUT) as client:
+        response = client.post(
+            API_URL,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            print(f"Error: API returned {response.status_code}")
+            print(response.text[:500])
+            sys.exit(1)
+
+        result = response.json()
+
+    processing_time = int((time.time() - start_time) * 1000)
+
+    if "error" in result or "code" in result:
+        err = result.get("error", result)
+        msg = err.get("message", err) if isinstance(err, dict) else str(err)
+        print(f"Error: {msg}")
+        sys.exit(1)
+
+    results = result.get("search_result", [])
+    return {
+        "query": query,
+        "results": results,
+        "count": len(results),
+        "id": result.get("id", ""),
+        "processing_time_ms": processing_time,
+    }
+
+
+def format_results(data: dict) -> str:
+    lines = []
+    results = data["results"]
+    if not results:
+        return "No results found."
+
+    for i, item in enumerate(results, 1):
+        title = item.get("title", "No title")
+        link = item.get("link", "")
+        content = item.get("content", "")
+        media = item.get("media", "")
+        date = item.get("publish_date", "")
+
+        header = f"{i}. {title}"
+        if media:
+            header += f" ({media})"
+        lines.append(header)
+        if link:
+            lines.append(f"   {link}")
+        if date:
+            lines.append(f"   Published: {date}")
+        if content:
+            lines.append(f"   {content}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Search the web using Z.AI Search Prime",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s "latest AI news"
+  %(prog)s "Python tutorials" --count 5
+  %(prog)s "breaking news" --recency oneDay
+  %(prog)s "machine learning papers" --domain arxiv.org
+  %(prog)s "search query" --json
+        """,
+    )
+    parser.add_argument("query", help="Search query string")
+    parser.add_argument(
+        "--count", "-c",
+        type=int,
+        default=10,
+        help="Number of results (1-50, default: 10)",
+    )
+    parser.add_argument(
+        "--recency", "-r",
+        choices=RECENCY_CHOICES,
+        help="Filter by recency: oneDay, oneWeek, oneMonth, oneYear, noLimit",
+    )
+    parser.add_argument(
+        "--domain", "-d",
+        help="Restrict results to a specific domain (e.g., arxiv.org)",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file path (default: print to stdout)",
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output JSON with metadata",
+    )
+
+    args = parser.parse_args()
+
+    if args.count < 1 or args.count > 50:
+        print("Error: --count must be between 1 and 50")
+        sys.exit(1)
+
+    result = search(
+        query=args.query,
+        count=args.count,
+        recency=args.recency,
+        domain=args.domain,
+    )
+
+    if args.json:
+        output_content = json.dumps(result, indent=2, ensure_ascii=False)
+    else:
+        output_content = format_results(result)
+
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(output_content, encoding="utf-8")
+        print(f"Saved: {output_path}")
+    else:
+        print(output_content)
+
+    print(f"\n{result['count']} results in {result['processing_time_ms']}ms")
+
+
+if __name__ == "__main__":
+    main()

package/dist/skills/z-tts/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: z-tts
+description: Text-to-speech using Z.AI GLM-TTS model. Use when user asks to convert text to speech, generate audio from text, or synthesize voice with Z.AI or ZhipuAI.
+category: media
+type: hybrid
+env:
+  - Z_AI_API_KEY
+metadata:
+  short-description: Text-to-speech with Z.AI
+  scope: first-party
+---
+
+Convert text to natural speech using Z.AI's GLM-TTS model.
+
+## Requirements
+
+- Python 3.10+, `httpx` package
+- `Z_AI_API_KEY` environment variable (or configured via `cue skill env set`)
+- Get your API key at: https://z.ai/manage-apikey/apikey-list
+- Uses Chinese endpoint (`open.bigmodel.cn`) — TTS is only available on this domain
+
+## Usage
+
+```bash
+# Generate speech (default voice: tongtong)
+python3 <skill-dir>/generate.py "Hello, how are you today?"
+
+# Choose a voice
+python3 <skill-dir>/generate.py "你好世界" --voice kazi
+
+# Adjust speed and volume
+python3 <skill-dir>/generate.py "Fast speech" --speed 1.5 --volume 5
+
+# Save to specific file
+python3 <skill-dir>/generate.py "Save this" --output speech.wav
+
+# Output as WAV (default) or PCM
+python3 <skill-dir>/generate.py "Hello" --format pcm
+```
+
+**Voices:** `tongtong` (default), `chuichui`, `xiaochen`, `jam`, `kazi`, `douji`, `luodo`
+
+**Constraints:** Input text max 1024 characters.
+
+## Troubleshooting
+
+| Error                  | Solution                                           |
+| ---------------------- | -------------------------------------------------- |
+| "Z_AI_API_KEY not set" | Set with: `/skill env set Z_AI_API_KEY <your-key>` |
+| "Input too long"       | Text must be under 1024 characters                 |
+| "API error: 401"       | Check your API key is valid                        |

package/dist/skills/z-tts/generate.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Z-TTS - Text-to-speech using Z.AI GLM-TTS model.
+
+Usage:
+    python generate.py "Hello, how are you?"
+    python generate.py "你好世界" --voice kazi
+    python generate.py "Fast speech" --speed 1.5
+    python generate.py "Save this" --output speech.wav
+"""
+
+import argparse
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '_lib'))
+from credentials import get_credential
+
+try:
+    import httpx
+except ImportError:
+    print("Error: httpx not installed. Run: pip install httpx")
+    sys.exit(1)
+
+
+API_URL = "https://open.bigmodel.cn/api/paas/v4/audio/speech"
+MODEL = "glm-tts"
+TIMEOUT = 60.0
+MAX_INPUT_LENGTH = 1024
+VOICES = ["tongtong", "chuichui", "xiaochen", "jam", "kazi", "douji", "luodo"]
+FORMATS = ["wav", "pcm"]
+SKILL_DIR = Path(__file__).parent
+TEMP_DIR = SKILL_DIR / "temp"
+
+
+def synthesize(
+    text: str,
+    voice: str = "tongtong",
+    speed: float = 1.0,
+    volume: float = 1.0,
+    response_format: str = "wav",
+) -> tuple[bytes, int]:
+    api_key = get_credential("Z_AI_API_KEY", "z-tts")
+
+    if len(text) > MAX_INPUT_LENGTH:
+        print(f"Error: Input too long ({len(text)} chars). Max {MAX_INPUT_LENGTH}.")
+        sys.exit(1)
+
+    if voice not in VOICES:
+        print(f"Error: Unknown voice '{voice}'. Choose from: {', '.join(VOICES)}")
+        sys.exit(1)
+
+    print(f"Generating speech with {MODEL} (voice: {voice}, speed: {speed}x)...")
+
+    payload = {
+        "model": MODEL,
+        "input": text,
+        "voice": voice,
+        "response_format": response_format,
+        "speed": speed,
+        "volume": volume,
+    }
+
+    start_time = time.time()
+
+    with httpx.Client(timeout=TIMEOUT) as client:
+        response = client.post(
+            API_URL,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            print(f"Error: API returned {response.status_code}")
+            try:
+                print(response.json())
+            except Exception:
+                print(response.text[:500])
+            sys.exit(1)
+
+        audio_data = response.content
+
+    processing_time = int((time.time() - start_time) * 1000)
+    return audio_data, processing_time
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Text-to-speech using Z.AI GLM-TTS",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Voices: tongtong (default), chuichui, xiaochen, jam, kazi, douji, luodo
+
+Examples:
+  %(prog)s "Hello, how are you?"
+  %(prog)s "你好世界" --voice kazi
+  %(prog)s "Fast speech" --speed 1.5
+  %(prog)s "Save this" --output speech.wav
+  %(prog)s "Hello" --format pcm
+        """,
+    )
+    parser.add_argument("text", help="Text to convert to speech (max 1024 chars)")
+    parser.add_argument(
+        "--voice", "-v",
+        default="tongtong",
+        choices=VOICES,
+        help="Voice selection (default: tongtong)",
+    )
+    parser.add_argument(
+        "--speed", "-s",
+        type=float,
+        default=1.0,
+        help="Speech rate 0.5-2.0 (default: 1.0)",
+    )
+    parser.add_argument(
+        "--volume",
+        type=float,
+        default=1.0,
+        help="Volume level 0-10 (default: 1.0)",
+    )
+    parser.add_argument(
+        "--format", "-f",
+        default="wav",
+        choices=FORMATS,
+        help="Audio format: wav or pcm (default: wav)",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file path (default: auto-generated in skill temp dir)",
+    )
+
+    args = parser.parse_args()
+
+    if args.speed < 0.5 or args.speed > 2.0:
+        print("Error: --speed must be between 0.5 and 2.0")
+        sys.exit(1)
+
+    if args.volume < 0 or args.volume > 10:
+        print("Error: --volume must be between 0 and 10")
+        sys.exit(1)
+
+    audio_data, processing_time = synthesize(
+        text=args.text,
+        voice=args.voice,
+        speed=args.speed,
+        volume=args.volume,
+        response_format=args.format,
+    )
+
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        TEMP_DIR.mkdir(parents=True, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = TEMP_DIR / f"tts_{timestamp}.{args.format}"
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(audio_data)
+
+    size_kb = len(audio_data) / 1024
+    print(f"Saved: {output_path} ({size_kb:.1f}KB)")
+    print(f"Processing time: {processing_time}ms")
+
+
+if __name__ == "__main__":
+    main()