generate-minecraft-3d-build-plan

어떤 스킬인가요?

Call Craftsman Agent API OneKey Router to generate a Minecraft 3D scene build plan.

설치 방법

프로젝트 폴더에서 아래 명령어를 실행하고, 설치할 에이전트를 선택하세요.

설치 명령을 직접 실행해야 적용됩니다. 지원 에이전트와 필요한 권한·라이선스는 제작자의 안내를 확인하세요.

스킬 원문 파일

---
name: generate-minecraft-3D-build-plan
description: Call Craftsman Agent API OneKey Router to generate a Minecraft 3D scene build plan.
env:
  DEEPNLP_ONEKEY_ROUTER_ACCESS:
    required: true
    description: OneKey Gateway API key
dependencies:
  npm:
    - "@aiagenta2z/onekey-gateway"
  python:
    - "ai-agent-marketplace"
installation:
  npm: npm -g install @aiagenta2z/onekey-gateway
  python: pip install ai-agent-marketplace
---

# Generate Minecraft 3D Build Plan

Call Craftsman Agent API OneKey Router to generate a Minecraft 3D scene build plan.

## Quick Start

1. Set your environment variable `DEEPNLP_ONEKEY_ROUTER_ACCESS`.
2. Use the CLI (primary suggested method) or the provided scripts.

## Usage

### 1. CLI (Recommended)

#### CLI Illustration
```shell
onekey agent <unique_id> <api_id> $JSON --timeout 30000
```
- `<unique_id>`: the unique identifier of the onekey routed agents, "owner/repo".
- `<api_id>`: refers to the unique endpoint name of API.
- `$JSON`: the json string passed to cli.
- `--timeout`: controlls the timeout of API calling, unit is mill seconds.

#### Example
```bash
export DEEPNLP_ONEKEY_ROUTER_ACCESS=YOUR_ACCESS_KEY
onekey agent craftsman-agent/craftsman-agent generate_minecraft_build_plan '{"prompt":"Minecraft scene of Grassland and TNT Block, Purple Crystals","images":[],"mode":"basic"}' --timeout 30000
```

### 2. Python REST API

```bash
python3 scripts/generate_minecraft_build_plan.py --prompt "Minecraft scene of Grassland and TNT Block, Purple Crystals" --mode basic
```

### 3. TypeScript REST API

```bash
node scripts/generate_minecraft_build_plan.ts --prompt "Minecraft scene of Grassland and TNT Block, Purple Crystals" --mode basic
```

## Authentication

Remember to set the environment variable:
```bash
export DEEPNLP_ONEKEY_ROUTER_ACCESS=YOUR_ACCESS_KEY
```
Get your key at [DeepNLP Workspace](https://www.deepnlp.org/workspace/keys).

## Demo Result

```json
{"success":true,"text":"","images":[{"url":"https://us-static.aiagenta2z.com/local/files-wd/onekey_llm_router/efd67a8f-a427-4e56-8b00-c02d4eb332d5.png"}]}
```

#!/usr/bin/env python3
"""Call Craftsman Agent OneKey Router to generate a Minecraft build plan."""

import argparse
import json
import os
import sys
from urllib import request, parse, error

ENDPOINT = "https://agent.deepnlp.org/agent_router"
UNIQUE_ID = "craftsman-agent/craftsman-agent"
API_ID = "generate_minecraft_build_plan"
ENV_KEY = "DEEPNLP_ONEKEY_ROUTER_ACCESS"
DEMO_KEY = "BETA_TEST_KEY_MARCH_2026"
ONEKEY_HEADER = "X-OneKey"


def die_missing_key():
    print("\n" + "=" * 60)
    print("WARNING: DEMO MODE — NO API KEY SET")
    print("Using default test key (BETA_TEST_KEY_MARCH_2026)")
    print("Results may be mocked or inaccurate")
    print("Set: export DEEPNLP_ONEKEY_ROUTER_ACCESS=your_key")
    print("=" * 60 + "\n")

def validate_image_urls(urls):
    for url in urls:
        parsed = parse.urlparse(url)
        if parsed.scheme not in ("http", "https"):
            raise ValueError(f"Invalid ref image URL scheme: {url}")

def build_payload(prompt, images, mode):
    return {
        "unique_id": UNIQUE_ID,
        "api_id": API_ID,
        "data": {
            "prompt": prompt,
            "images": images,
            "mode": mode,
        },
    }


def post_json(url, payload, api_key):
    data = json.dumps(payload).encode("utf-8")
    req = request.Request(
        url,
        data=data,
        headers={"Content-Type": "application/json", ONEKEY_HEADER: api_key},
        method="POST",
    )
    with request.urlopen(req, timeout=60) as resp:
        body = resp.read().decode("utf-8")
        return resp.status, body


def main():
    parser = argparse.ArgumentParser(description="Generate Minecraft build plan via Craftsman Agent")
    parser.add_argument("--prompt", required=True, help="Text prompt for the build")
    parser.add_argument(
        "--images",
        action="append",
        default=[],
        help="Reference image URL (repeatable)",
    )
    parser.add_argument("--mode", default="basic", help="demo|basic|standard|advanced")
    args = parser.parse_args()

    api_key = os.getenv(ENV_KEY)
    if not api_key:
        die_missing_key()
        api_key = DEMO_KEY

    url = ENDPOINT
    try:
        validate_image_urls(args.images)
    except ValueError as exc:
        sys.stderr.write(f"{exc}\n")
        sys.exit(2)

    payload = build_payload(args.prompt, args.images, args.mode)

    try:
        status, body = post_json(url, payload, api_key)
    except error.HTTPError as e:
        error_body = e.read().decode("utf-8") if e.fp else ""
        sys.stderr.write(f"HTTP {e.code}: {error_body}\n")
        sys.exit(1)
    except error.URLError as e:
        sys.stderr.write(f"Network error: {e.reason}\n")
        sys.exit(1)

    try:
        parsed = json.loads(body)
        print(json.dumps(parsed, indent=2))
    except json.JSONDecodeError:
        print(body)


if __name__ == "__main__":
    main()

#!/usr/bin/env node

const ENDPOINT = "https://agent.deepnlp.org/agent_router";
const UNIQUE_ID = "craftsman-agent/craftsman-agent";
const API_ID = "generate_minecraft_build_plan";
const ENV_KEY = "DEEPNLP_ONEKEY_ROUTER_ACCESS";
const ONEKEY_HEADER = "X-OneKey";
const DEMO_KEY = "BETA_TEST_KEY_MARCH_2026";

function getApiKey(): string {
  const apiKey = process.env[ENV_KEY];
  if (apiKey) return apiKey;

  console.log("\n" + "=".repeat(60));
  console.log("WARNING: DEMO MODE — NO API KEY SET");
  console.log("Using default test key (BETA_TEST_KEY_MARCH_2026)");
  console.log("Results may be mocked or inaccurate");
  console.log("Set: export DEEPNLP_ONEKEY_ROUTER_ACCESS=your_key");
  console.log("=".repeat(60) + "\n");
  return DEMO_KEY;
}

function validateImageUrls(urls: string[]) {
  for (const url of urls) {
    try {
      const parsed = new URL(url);
      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
        throw new Error(`Invalid ref image URL scheme: ${url}`);
      }
    } catch (err) {
      throw new Error(`Invalid ref image URL: ${url}`);
    }
  }
}

function parseArgs(argv: string[]) {
  const args: Record<string, string | string[]> = {};
  for (let i = 0; i < argv.length; i += 1) {
    const token = argv[i];
    if (token === "--prompt" || token === "--mode" || token === "--images") {
      const value = argv[i + 1];
      i += 1;
      if (token === "--images") {
        const list = (args[token] as string[]) || [];
        list.push(value);
        args[token] = list;
      } else {
        args[token] = value;
      }
    }
  }

  return {
    prompt: (args["--prompt"] as string) || "",
    mode: (args["--mode"] as string) || "basic",
    images: (args["--images"] as string[]) || [],
  };
}

async function main() {
  const { prompt, mode, images } = parseArgs(process.argv.slice(2));
  if (!prompt) {
    console.error("Missing --prompt");
    process.exit(1);
  }

  const apiKey = getApiKey();

  const url = new URL(ENDPOINT);
  validateImageUrls(images);

  const payload = {
    unique_id: UNIQUE_ID,
    api_id: API_ID,
    data: {
      prompt: prompt,
      images: images,
      mode,
    },
  };

  const response = await fetch(url.toString(), {
    method: "POST",
    headers: { "Content-Type": "application/json", [ONEKEY_HEADER]: apiKey },
    body: JSON.stringify(payload),
  });

  const text = await response.text();
  if (!response.ok) {
    console.error(`HTTP ${response.status}: ${text}`);
    process.exit(1);
  }

  try {
    const json = JSON.parse(text);
    console.log(JSON.stringify(json, null, 2));
  } catch {
    console.log(text);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});