feat: 新增图生3D能力，集成 Lux3D API

- 新增 generate_3d_model 工具：API Key 解析、签名生成、任务创建/轮询、结果下载、manifest 记录

- 新增 lux3d_api.md 作为 API 参考文档

- 新增 inputs/little-bird.png 作为示例输入图

agent_loop.py

@@ -1,8 +1,15 @@
+import base64
+import hashlib
 import json
+import mimetypes
 import os
 import subprocess
 import sys
 import textwrap
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
 from datetime import datetime
 from pathlib import Path
 from uuid import uuid4
@@ -19,20 +26,38 @@ if os.getenv("ANTHROPIC_BASE_URL"):
     os.environ.pop("ANTHROPIC_AUTH_TOKEN", None)
 
 WORKDIR = Path.cwd()
-DEFAULT_OUTPUT_PATH = "outputs/model.step"
+DEFAULT_CADQUERY_OUTPUT_PATH = "outputs/model.step"
+DEFAULT_LUX3D_OUTPUT_PATH = "outputs"
 STEP_SUFFIXES = (".step", ".stp")
+IMAGE_SUFFIXES = (".png", ".jpg", ".jpeg", ".webp")
+LUX3D_API_KEY_ENV = "LUX3D_API_KEY"
+LUX3D_CREATE_URL = "https://api.luxreal.ai/global/lux3d/generate/task/create"
+LUX3D_GET_URL = "https://api.luxreal.ai/global/lux3d/generate/task/get"
+LUX3D_POLL_INTERVAL_SECONDS = 12
+LUX3D_TIMEOUT_SECONDS = 600
 
 SYSTEM = f"""
-You are a CAD generation agent at {WORKDIR}.
+You are a CAD and 3D model generation agent at {WORKDIR}.
 
-Your only tool is execute. For CAD tasks:
+You have two tools:
+- execute_cadquery: use it for precise CAD, dimensioned parts, parametric geometry, engineering models, and STEP/CAD output.
+- generate_3d_model: use it when the user provides an image path and asks for a 3D model, mesh, GLB, OBJ, or other non-precise 3D asset.
+
+For CadQuery tasks:
 - Write CadQuery Python code.
 - The code must assign the final model to a variable named result.
 - You may use cadquery as cq; it is pre-imported by the tool.
-- Call execute with the code and optional output_path.
-- Each successful execute writes into a unique run directory to avoid overwriting previous models.
-- If execute returns ok=false, inspect the structured error, fix the code, and call execute again.
-- When execute returns ok=true, report the output_path to the user.
+- Call execute_cadquery with the code and optional output_path.
+- Each successful tool call writes into a unique run directory to avoid overwriting previous models.
+- If execute_cadquery returns ok=false, inspect the structured error, fix the code, and call execute_cadquery again.
+
+For image-to-3D tasks:
+- The user must provide a workspace-relative image path.
+- If the user asks for image-to-3D generation but does not provide an image path, ask for the image path. Do not guess.
+- Call generate_3d_model with the image_path and optional output_path.
+- Do not ask the user to read files, convert images to base64, call APIs, or download results manually.
+
+When a tool returns ok=true, report output_path, run_dir, and manifest_path to the user.
 
 Do not ask the user to run commands or create files manually.
 """.strip()
@@ -60,6 +85,22 @@ def new_run_id() -> str:
     return f"{timestamp}_{uuid4().hex[:6]}"
 
 
+def tail_text(text: str, limit: int = 4000) -> str:
+    if not text:
+        return ""
+    return text[-limit:]
+
+
+def allocate_run_dir(output_root: Path) -> tuple[Path, str]:
+    for _ in range(20):
+        run_id = new_run_id()
+        run_dir = output_root / "runs" / run_id
+        if not run_dir.exists():
+            return run_dir, run_id
+
+    raise RuntimeError("Failed to allocate a unique output run directory.")
+
+
 def resolve_run_output(requested_output_path: str) -> tuple[Path, Path, str]:
     requested_path = safe_path(requested_output_path)
     suffix = requested_path.suffix.lower()
@@ -73,13 +114,22 @@ def resolve_run_output(requested_output_path: str) -> tuple[Path, Path, str]:
         output_root = requested_path
         output_name = "model.step"
 
-    for _ in range(20):
-        run_id = new_run_id()
-        run_dir = output_root / "runs" / run_id
-        if not run_dir.exists():
-            return run_dir, run_dir / output_name, run_id
+    run_dir, run_id = allocate_run_dir(output_root)
+    return run_dir, run_dir / output_name, run_id
 
-    raise RuntimeError("Failed to allocate a unique output run directory.")
+
+def resolve_lux3d_run(output_path: str | None) -> tuple[Path, Path, str, str | None, str]:
+    requested_output_path = output_path or DEFAULT_LUX3D_OUTPUT_PATH
+    requested_path = safe_path(requested_output_path)
+    if requested_path.suffix:
+        output_root = requested_path.parent
+        output_name = requested_path.name
+    else:
+        output_root = requested_path
+        output_name = None
+
+    run_dir, run_id = allocate_run_dir(output_root)
+    return output_root, run_dir, run_id, output_name, requested_output_path
 
 
 def update_latest_link(output_root: Path, run_dir: Path) -> str | None:
@@ -107,6 +157,7 @@ def write_manifest(
     payload: dict,
 ) -> Path:
     manifest_path = run_dir / "manifest.json"
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
     manifest = {
         "run_id": run_id,
         "created_at": datetime.now().astimezone().isoformat(timespec="seconds"),
@@ -122,6 +173,164 @@ def write_manifest(
     return manifest_path
 
 
+def write_lux3d_manifest(
+    run_dir: Path,
+    run_id: str,
+    prompt: str | None,
+    image_path: Path,
+    requested_output_path: str,
+    output_path: Path | None,
+    busid: str | int | None,
+    status: int | None,
+    result_url: str | None,
+    poll_count: int,
+    error: str | None = None,
+) -> Path:
+    manifest_path = run_dir / "manifest.json"
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest = {
+        "run_id": run_id,
+        "created_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+        "generator": "lux3d",
+        "prompt": prompt,
+        "image_path": workspace_relative(image_path),
+        "requested_output_path": requested_output_path,
+        "output_path": workspace_relative(output_path) if output_path else None,
+        "busid": busid,
+        "status": status,
+        "result_url": result_url,
+        "poll_count": poll_count,
+        "error": error,
+    }
+    manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
+    return manifest_path
+
+
+def validate_image_path(image_path: str) -> Path:
+    if not image_path or not image_path.strip():
+        raise ValueError("image_path is required for image-to-3D generation.")
+
+    path = safe_path(image_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Image file does not exist: {image_path}")
+    if not path.is_file():
+        raise ValueError(f"image_path must be a file: {image_path}")
+    if path.suffix.lower() not in IMAGE_SUFFIXES:
+        raise ValueError(f"Unsupported image format: {path.suffix}. Use one of: {', '.join(IMAGE_SUFFIXES)}")
+    return path
+
+
+def image_to_data_url(image_path: Path) -> str:
+    mime_type = mimetypes.guess_type(str(image_path))[0]
+    if not mime_type:
+        mime_type = "image/jpeg" if image_path.suffix.lower() in (".jpg", ".jpeg") else f"image/{image_path.suffix.lower().lstrip('.')}"
+    encoded = base64.b64encode(image_path.read_bytes()).decode("ascii")
+    return f"data:{mime_type};base64,{encoded}"
+
+
+def parse_lux3d_api_key() -> dict:
+    api_key = os.getenv(LUX3D_API_KEY_ENV, "").strip()
+    if not api_key:
+        raise ValueError(f"Missing {LUX3D_API_KEY_ENV}. Set it in your environment or .env file.")
+
+    try:
+        decoded = base64.b64decode(api_key, validate=True).decode("utf-8")
+    except Exception as exc:
+        raise ValueError(f"Invalid {LUX3D_API_KEY_ENV}: expected a base64-encoded API key.") from exc
+
+    parts = decoded.split(":")
+    if len(parts) != 4 or not all(parts):
+        raise ValueError(f"Invalid {LUX3D_API_KEY_ENV}: expected decoded format version:appkey:appsecret:appuid.")
+
+    version, appkey, appsecret, appuid = parts
+    return {
+        "version": version,
+        "appkey": appkey,
+        "appsecret": appsecret,
+        "appuid": appuid,
+    }
+
+
+def lux3d_query(credentials: dict, extra: dict | None = None) -> str:
+    timestamp = str(int(time.time() * 1000))
+    sign = hashlib.md5(
+        (credentials["appsecret"] + credentials["appkey"] + credentials["appuid"] + timestamp).encode("utf-8")
+    ).hexdigest()
+    params = {
+        "appuid": credentials["appuid"],
+        "appkey": credentials["appkey"],
+        "timestamp": timestamp,
+        "sign": sign,
+    }
+    if extra:
+        params.update(extra)
+    return urllib.parse.urlencode(params)
+
+
+def lux3d_json_request(method: str, url: str, payload: dict | None = None, timeout: int = 30) -> dict:
+    data = None
+    headers = {}
+    if payload is not None:
+        data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        headers["Content-Type"] = "application/json"
+
+    request = urllib.request.Request(url, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            raw = response.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"Lux3D API HTTP {exc.code}: {tail_text(body)}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"Lux3D API request failed: {exc.reason}") from exc
+
+    try:
+        return json.loads(raw)
+    except Exception as exc:
+        raise RuntimeError(f"Lux3D API returned invalid JSON: {tail_text(raw)}") from exc
+
+
+def lux3d_create_task(credentials: dict, image_data_url: str) -> str | int:
+    query = lux3d_query(credentials)
+    payload = lux3d_json_request("POST", f"{LUX3D_CREATE_URL}?{query}", {"img": image_data_url})
+    busid = payload.get("d")
+    if not busid:
+        raise RuntimeError(f"Lux3D create task response did not include busid: {payload}")
+    return busid
+
+
+def lux3d_get_task(credentials: dict, busid: str | int) -> dict:
+    query = lux3d_query(credentials, {"busid": busid})
+    payload = lux3d_json_request("GET", f"{LUX3D_GET_URL}?{query}")
+    data = payload.get("d")
+    if not isinstance(data, dict):
+        raise RuntimeError(f"Lux3D get task response did not include task data: {payload}")
+    return data
+
+
+def infer_lux3d_output_name(result_url: str) -> str:
+    parsed = urllib.parse.urlparse(result_url)
+    name = Path(urllib.parse.unquote(parsed.path)).name
+    if name and "." in name:
+        return name
+    return "model.glb"
+
+
+def download_lux3d_result(result_url: str, output_path: Path) -> None:
+    request = urllib.request.Request(result_url, headers={"User-Agent": "aigc-3dcad/0.1"})
+    try:
+        with urllib.request.urlopen(request, timeout=120) as response:
+            data = response.read()
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"Lux3D result download HTTP {exc.code}: {tail_text(body)}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"Lux3D result download failed: {exc.reason}") from exc
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(data)
+
+
 CADQUERY_RUNNER = r"""
 import contextlib
 import io
@@ -235,14 +444,14 @@ def _json_response(payload: dict) -> str:
     return json.dumps(payload, ensure_ascii=False, indent=2)
 
 
-def run_execute(code: str, output_path: str = DEFAULT_OUTPUT_PATH, prompt: str | None = None) -> str:
+def run_execute_cadquery(code: str, output_path: str = DEFAULT_CADQUERY_OUTPUT_PATH, prompt: str | None = None) -> str:
     try:
         if not code or not code.strip():
             return _json_response({
                 "ok": False,
                 "stage": "input",
                 "error_type": "EmptyCode",
-                "error": "execute requires non-empty CadQuery code.",
+                "error": "execute_cadquery requires non-empty CadQuery code.",
                 "traceback_tail": "",
                 "stdout": "",
                 "stderr": "",
@@ -356,14 +565,148 @@ def run_execute(code: str, output_path: str = DEFAULT_OUTPUT_PATH, prompt: str |
     return _json_response(payload)
 
 
+def run_generate_3d_model(
+    image_path: str,
+    output_path: str | None = None,
+    prompt: str | None = None,
+    poll_interval_seconds: int = LUX3D_POLL_INTERVAL_SECONDS,
+    timeout_seconds: int = LUX3D_TIMEOUT_SECONDS,
+) -> str:
+    busid = None
+    status = None
+    result_url = None
+    output = None
+    poll_count = 0
+    run_dir = None
+    run_id = None
+    requested_output_path = output_path or DEFAULT_LUX3D_OUTPUT_PATH
+
+    try:
+        image = validate_image_path(image_path)
+        credentials = parse_lux3d_api_key()
+        output_root, run_dir, run_id, requested_output_name, requested_output_path = resolve_lux3d_run(output_path)
+        image_data_url = image_to_data_url(image)
+    except Exception as exc:
+        return _json_response({
+            "ok": False,
+            "stage": "input",
+            "error_type": type(exc).__name__,
+            "error": str(exc),
+            "busid": busid,
+        })
+
+    try:
+        busid = lux3d_create_task(credentials, image_data_url)
+        deadline = time.time() + timeout_seconds
+
+        while True:
+            if time.time() >= deadline:
+                raise TimeoutError(f"Lux3D task timed out after {timeout_seconds} seconds.")
+
+            time.sleep(poll_interval_seconds)
+            poll_count += 1
+            task = lux3d_get_task(credentials, busid)
+            raw_status = task.get("status")
+            status = int(raw_status) if raw_status is not None else None
+
+            if status in (0, 1):
+                continue
+
+            if status == 3:
+                outputs = task.get("outputs") or []
+                result_url = next(
+                    (item.get("content") for item in outputs if isinstance(item, dict) and item.get("content")),
+                    None,
+                )
+                if not result_url:
+                    raise RuntimeError(f"Lux3D task succeeded but did not include a result URL: {task}")
+
+                output_name = requested_output_name or infer_lux3d_output_name(result_url)
+                output = run_dir / output_name
+                download_lux3d_result(result_url, output)
+                manifest_path = write_lux3d_manifest(
+                    run_dir=run_dir,
+                    run_id=run_id,
+                    prompt=prompt,
+                    image_path=image,
+                    requested_output_path=requested_output_path,
+                    output_path=output,
+                    busid=busid,
+                    status=status,
+                    result_url=result_url,
+                    poll_count=poll_count,
+                )
+                latest_warning = update_latest_link(output_root, run_dir)
+                payload = {
+                    "ok": True,
+                    "stage": "done",
+                    "run_id": run_id,
+                    "run_dir": workspace_relative(run_dir),
+                    "output_path": workspace_relative(output),
+                    "manifest_path": workspace_relative(manifest_path),
+                    "latest_path": workspace_relative(output_root / "latest"),
+                    "busid": busid,
+                    "status": status,
+                    "result_url": result_url,
+                    "poll_count": poll_count,
+                }
+                if latest_warning:
+                    payload["warning"] = latest_warning
+                return _json_response(payload)
+
+            if status == 4:
+                raise RuntimeError(f"Lux3D task failed: {task}")
+
+            raise RuntimeError(f"Lux3D task returned unknown status {raw_status}: {task}")
+    except Exception as exc:
+        manifest_path = None
+        if run_dir and run_id:
+            manifest_path = write_lux3d_manifest(
+                run_dir=run_dir,
+                run_id=run_id,
+                prompt=prompt,
+                image_path=image,
+                requested_output_path=requested_output_path,
+                output_path=output,
+                busid=busid,
+                status=status,
+                result_url=result_url,
+                poll_count=poll_count,
+                error=str(exc),
+            )
+
+        payload = {
+            "ok": False,
+            "stage": "lux3d",
+            "error_type": type(exc).__name__,
+            "error": str(exc),
+            "busid": busid,
+            "status": status,
+            "result_url": result_url,
+            "poll_count": poll_count,
+        }
+        if manifest_path:
+            payload["run_id"] = run_id
+            payload["run_dir"] = workspace_relative(run_dir)
+            payload["manifest_path"] = workspace_relative(manifest_path)
+        return _json_response(payload)
+
+
 # -- The dispatch map: {tool_name: handler} --
 TOOL_HANDLERS = {
-    "execute": lambda **kw: run_execute(kw["code"], kw.get("output_path", DEFAULT_OUTPUT_PATH)),
+    "execute_cadquery": lambda **kw: run_execute_cadquery(
+        kw["code"],
+        kw.get("output_path", DEFAULT_CADQUERY_OUTPUT_PATH),
+    ),
+    "generate_3d_model": lambda **kw: run_generate_3d_model(
+        kw["image_path"],
+        kw.get("output_path"),
+    ),
 }
 
 TOOLS = [
     {
-        "name": "execute",
+        "name": "execute_cadquery",
         "description": textwrap.dedent("""
             Execute CadQuery Python code and export the result as a STEP file.
             The code must assign the final CadQuery model to a variable named result.
@@ -386,6 +729,28 @@ TOOLS = [
             "required": ["code"],
         },
     },
+    {
+        "name": "generate_3d_model",
+        "description": textwrap.dedent("""
+            Generate a non-precise 3D model from a local image using the Lux3D image-to-3D API.
+            The input is a workspace-relative image path, not image bytes or base64 text.
+            The tool reads the image, creates a Lux3D task, polls for completion, downloads the result, and writes a manifest.
+        """).strip(),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "image_path": {
+                    "type": "string",
+                    "description": "Workspace-relative path to a source image file. Supported formats: .png, .jpg, .jpeg, .webp.",
+                },
+                "output_path": {
+                    "type": "string",
+                    "description": "Optional workspace-relative model file path or output directory. Defaults to outputs.",
+                },
+            },
+            "required": ["image_path"],
+        },
+    },
 ]
 
 
@@ -412,10 +777,16 @@ def agent_loop(messages: list):
         prompt = latest_user_prompt(messages)
         for block in response.content:
             if block.type == "tool_use":
-                if block.name == "execute":
-                    output = run_execute(
+                if block.name == "execute_cadquery":
+                    output = run_execute_cadquery(
                         code=block.input["code"],
-                        output_path=block.input.get("output_path", DEFAULT_OUTPUT_PATH),
+                        output_path=block.input.get("output_path", DEFAULT_CADQUERY_OUTPUT_PATH),
+                        prompt=prompt,
+                    )
+                elif block.name == "generate_3d_model":
+                    output = run_generate_3d_model(
+                        image_path=block.input["image_path"],
+                        output_path=block.input.get("output_path"),
                         prompt=prompt,
                     )
                 else:

lux3d_api.md

@@ -0,0 +1,153 @@
+API 调用
+概述
+Lux3D 当前提供 2 个接口，用于完成图生 3D 的异步生成流程：
+
+创建任务
+查询任务
+调用流程如下：
+
+API Key -> 解析 appuid/appkey/appsecret -> 生成 sign -> 创建任务 -> 查询任务 -> 获取 lux3d_url
+建议每 10-15 秒轮询查询任务状态。
+
+鉴权说明
+API 调用使用签名方式鉴权。
+
+开发者申请到的 API Key 并不是直接作为请求参数透传给接口，而是需要先解析出以下信息：
+
+appuid
+appkey
+appsecret
+随后按以下规则生成签名：
+
+sign = MD5(appsecret + appkey + appuid + timestamp)
+其中：
+
+timestamp 为毫秒级时间戳
+sign 作为 query 参数参与接口调用
+目前 Lux3D 不提供独立的服务端接口帮助开发者解析 API Key。 如果使用 API 方式接入，开发者需要在本地或自己的服务中先完成 API Key 解析，再使用解析结果调用 Lux3D API。
+
+API Key 解析结果
+根据当前实现，API Key 可解析出以下结构：
+
+version:appkey:appsecret:appuid
+编码方式为 Base64。
+
+API Key 解析示例
+以下示例展示如何从 API Key 中解析出 appkey、appsecret 和 appuid。
+
+JavaScript
+const apiKey = "YOUR_API_KEY";
+const decoded =
+  typeof atob === "function"
+    ? atob(apiKey)
+    : Buffer.from(apiKey, "base64").toString("utf-8");
+const [version, appkey, appsecret, appuid] = decoded.split(":");
+
+if (!version || !appkey || !appsecret || !appuid) {
+  throw new Error("Invalid API Key format");
+}
+Python
+import base64
+
+api_key = "YOUR_API_KEY"
+decoded = base64.b64decode(api_key).decode("utf-8")
+version, appkey, appsecret, appuid = decoded.split(":")
+签名生成示例
+以下示例展示如何基于解析结果生成 sign。
+
+JavaScript
+const appkey = "YOUR_APPKEY";
+const appsecret = "YOUR_APPSECRET";
+const appuid = "YOUR_APPUID";
+const timestamp = Date.now().toString();
+const sign = CryptoJS.MD5(appsecret + appkey + appuid + timestamp).toString();
+Python
+import hashlib
+import time
+
+appkey = "YOUR_APPKEY"
+appsecret = "YOUR_APPSECRET"
+appuid = "YOUR_APPUID"
+timestamp = str(int(time.time() * 1000))
+sign = hashlib.md5((appsecret + appkey + appuid + timestamp).encode("utf-8")).hexdigest()
+接口列表
+接口	方法	说明
+https://api.luxreal.ai/global/lux3d/generate/task/create	POST	创建图生 3D 任务
+https://api.luxreal.ai/global/lux3d/generate/task/get	GET	查询图生 3D 任务状态与结果
+创建图生 3D 任务
+描述
+创建图生 3D 任务。
+
+请求成功后返回任务 ID busid，后续可通过查询接口获取任务状态和结果。
+
+API
+POST https://api.luxreal.ai/global/lux3d/generate/task/create
+Query 参数
+参数	是否必须	类型	说明
+appuid	是	string	第三方用户 ID
+appkey	是	string	由 API Key 解析得到
+timestamp	是	long	毫秒级时间戳
+sign	是	string	签名结果
+Request Body
+{
+  "img": ""
+}
+Body 参数说明
+参数	是否必须	类型	说明
+img	是	string	图片 Base64，建议使用 Data URL 格式，例如 data:image/png;base64,...
+响应
+{
+  "d": "",
+  "m": null,
+  "c": null
+}
+响应字段说明
+参数	是否必须	类型	说明
+d	是	long	返回 busid
+m	是	string	null
+c	是	string	null
+示例
+curl -X POST "https://api.luxreal.ai/global/lux3d/generate/task/create?appuid=YOUR_APPUID&appkey=YOUR_APPKEY&timestamp=YOUR_TIMESTAMP&sign=YOUR_SIGN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "img": "data:image/png;base64,BASE64_IMAGE_STRING"
+  }'
+查询图生 3D 任务
+描述
+根据 busid 查询任务状态和结果。
+
+查询结果中的输出内容有效期为 2 小时，建议在任务成功后尽快获取并保存结果。
+
+API
+GET https://api.luxreal.ai/global/lux3d/generate/task/get
+Query 参数
+参数	是否必须	类型	说明
+appuid	是	string	第三方用户 ID
+appkey	是	string	由 API Key 解析得到
+timestamp	是	long	毫秒级时间戳
+sign	是	string	签名结果
+busid	是	long	任务 ID
+响应
+{
+  "d": {
+    "busId": "",
+    "outputs": [
+      {
+        "content": null
+      }
+    ],
+    "status": ""
+  },
+  "m": null,
+  "c": null
+}
+响应字段说明
+参数	是否必须	类型	说明
+d.busId	是	long	主线 ID
+d.status	是	int	0 初始化，1 进行中，3 成功，4 失败
+d.outputs	否	list<object>	输出列表
+d.outputs[].content	否	string	结果内容
+m	是	string	null
+c	是	string	null
+示例
+curl -X GET "https://api.luxreal.ai/global/lux3d/generate/task/get?appuid=YOUR_APPUID&appkey=YOUR_APPKEY&timestamp=YOUR_TIMESTAMP&sign=YOUR_SIGN&busid=123456789"