@honor-claw/yoyo 1.6.1-beta.2 → 1.6.1-beta.4

package/dist/gateway-client/protocol-client.mjs

@@ -1,17 +1,18 @@
 import { useClawLogger as e } from "../utils/logger.mjs";
-import { loadOrCreateDeviceIdentity as t } from "../modules/device/identity.mjs";
-import { buildDeviceAuthCredential as n } from "../modules/device/credential-builder.mjs";
-import { GatewayClient as r } from "./client.mjs";
-import { ErrorCodes as i, GATEWAY_CLIENT_IDS as a, GATEWAY_CLIENT_MODES as o, WebSocketClientError as s } from "./types/client.mjs";
-import { randomUUID as c } from "node:crypto";
+import { getProtocolVersion as t } from "../utils/version.mjs";
+import { loadOrCreateDeviceIdentity as n } from "../modules/device/identity.mjs";
+import { buildDeviceAuthCredential as r } from "../modules/device/credential-builder.mjs";
+import { GatewayClient as i } from "./client.mjs";
+import { ErrorCodes as a, GATEWAY_CLIENT_IDS as o, GATEWAY_CLIENT_MODES as s, WebSocketClientError as c } from "./types/client.mjs";
+import { randomUUID as l } from "node:crypto";
 //#region src/gateway-client/protocol-client.ts
-var l = {
+var u = {
 	role: "operator",
 	scopes: [],
-	clientId: a.CLI,
+	clientId: o.CLI,
 	displayName: "Protocol Client",
-	clientMode: o.CLI
-}, u = 3e4, d = "1.0.0", f = "server", p = 2, m = 1e3, h = class extends r {
+	clientMode: s.CLI
+}, d = 3e4, f = "1.0.0", p = "server", m = 2, h = 1e3, g = class extends i {
 	protocolOpts;
 	config;
 	pendingRequests = /* @__PURE__ */ new Map();
@@ -27,7 +28,7 @@ var l = {
 	isReconnecting = !1;
 	constructor(e = {}, t = {}) {
 		super(e), this.protocolOpts = e, this.config = {
-			...l,
+			...u,
 			...t
 		}, this.debug = process.env.DEBUG_GATEWAY === "true";
 	}
@@ -67,15 +68,15 @@ var l = {
 		if (t) if (this.logDebug("response", e), this.pendingRequests.delete(e.id), this.clearTimer(e.id), e.ok) t.resolve(e.payload);
 		else {
 			let n = e.error || {
-				code: i.UNKNOWN,
+				code: a.UNKNOWN,
 				message: "Unknown error"
 			};
-			t.reject(new s(this.toErrorCode(n.code), n.message, n.details, n.retryable));
+			t.reject(new c(this.toErrorCode(n.code), n.message, n.details, n.retryable));
 		}
 	}
 	async sendConnect() {
-		let e = this.config.clientMode ?? o.CLI, r = await t(), i = this.connectNonce ? n({
-			deviceIdentity: r,
+		let e = this.config.clientMode ?? s.CLI, i = await n(), a = this.connectNonce ? r({
+			deviceIdentity: i,
 			clientName: this.config.clientId,
 			clientMode: e,
 			role: this.config.role,
@@ -83,16 +84,16 @@ var l = {
 			authToken: this.protocolOpts.token,
 			nonce: this.connectNonce,
 			platform: process.platform,
-			deviceFamily: f
-		}) : void 0, a = {
-			minProtocol: 4,
-			maxProtocol: 4,
+			deviceFamily: p
+		}) : void 0, o = {
+			minProtocol: t(),
+			maxProtocol: t(),
 			client: {
 				id: this.config.clientId,
 				displayName: this.config.displayName,
-				version: d,
+				version: f,
 				platform: process.platform,
-				deviceFamily: f,
+				deviceFamily: p,
 				mode: e
 			},
 			role: this.config.role,
@@ -101,21 +102,21 @@ var l = {
 				token: this.protocolOpts.token,
 				password: this.protocolOpts.password
 			},
-			device: i
+			device: a
 		};
-		this.sendRequest("connect", a).then((e) => {
+		this.sendRequest("connect", o).then((e) => {
 			this.helloOk = e, this.connected = !0, this.authenticated = !0, this.protocolOpts.onAuthenticated?.();
 		}).catch((e) => {
-			this.authenticated = !1, e instanceof s ? this.protocolOpts.onClose?.(`auth failed: [${e.code}] ${e.message}`) : this.protocolOpts.onClose?.(`auth failed: ${e.message}`);
+			this.authenticated = !1, e instanceof c ? this.protocolOpts.onClose?.(`auth failed: [${e.code}] ${e.message}`) : this.protocolOpts.onClose?.(`auth failed: ${e.message}`);
 		});
 	}
 	async sendRequest(e, t) {
-		let n = c();
+		let n = l();
 		return this.logDebug("request", {
 			id: n,
 			method: e,
 			params: t
-		}), new Promise((r, a) => {
+		}), new Promise((r, i) => {
 			let o = {
 				type: "req",
 				id: n,
@@ -124,22 +125,22 @@ var l = {
 			};
 			this.pendingRequests.set(n, {
 				resolve: r,
-				reject: a
+				reject: i
 			});
 			try {
 				this.send(JSON.stringify(o));
 			} catch (e) {
-				this.pendingRequests.delete(n), a(new s(i.CONNECTION_FAILED, `WebSocket is not connected, ${JSON.stringify(e)}`));
+				this.pendingRequests.delete(n), i(new c(a.CONNECTION_FAILED, `WebSocket is not connected, ${JSON.stringify(e)}`));
 				return;
 			}
-			let c = setTimeout(() => {
+			let s = setTimeout(() => {
 				if (this.pendingRequests.has(n)) {
 					this.pendingRequests.delete(n);
 					let t = this.pendingTimers.get(n);
-					t && clearTimeout(t), this.pendingTimers.delete(n), a(new s(i.TIMEOUT, `Request timeout: ${e}`));
+					t && clearTimeout(t), this.pendingTimers.delete(n), i(new c(a.TIMEOUT, `Request timeout: ${e}`));
 				}
-			}, u);
-			this.pendingTimers.set(n, c);
+			}, d);
+			this.pendingTimers.set(n, s);
 		});
 	}
 	isAuthenticated() {
@@ -149,7 +150,7 @@ var l = {
 		return this.connected;
 	}
 	toErrorCode(e) {
-		return Object.values(i).includes(e) ? e : i.UNKNOWN;
+		return Object.values(a).includes(e) ? e : a.UNKNOWN;
 	}
 	clearTimer(e) {
 		let t = this.pendingTimers.get(e);
@@ -170,15 +171,15 @@ var l = {
 	}
 	scheduleReconnect() {
 		if (!(this.closed || this.isReconnecting)) {
-			if (this.reconnectAttempts >= p) {
-				e().error(`[protocol-gateway] max reconnect attempts (${p}) reached, giving up`), this.protocolOpts.onReconnectFailed?.();
+			if (this.reconnectAttempts >= m) {
+				e().error(`[protocol-gateway] max reconnect attempts (${m}) reached, giving up`), this.protocolOpts.onReconnectFailed?.();
 				return;
 			}
-			this.reconnectAttempts++, this.isReconnecting = !0, e().info(`[protocol-gateway] attempting to reconnect (attempt ${this.reconnectAttempts}/${p})`), this.reconnectTimer = setTimeout(() => {
+			this.reconnectAttempts++, this.isReconnecting = !0, e().info(`[protocol-gateway] attempting to reconnect (attempt ${this.reconnectAttempts}/${m})`), this.reconnectTimer = setTimeout(() => {
 				this.isReconnecting = !1, this.closed || super.connect();
-			}, m);
+			}, h);
 		}
 	}
 };
 //#endregion
-export { h as ProtocolGatewayClient };
+export { g as ProtocolGatewayClient };

package/dist/hooks/index.mjs

@@ -22,15 +22,21 @@ function c(e) {
 }
 function l(e) {
 	e.on("after_tool_call", async (t) => {
-		if (!(t.toolName !== "read" || t.error || !u(t.params))) try {
+		if (!(t.toolName !== "read" || t.error || !d(t.params))) try {
 			await r(o, "after_tool_call:read_yoyo_control_skill"), e.logger.info("[yoyoclaw-skill-refresh] yoyo-control skill read marker updated");
 		} catch (t) {
 			e.logger.warn(`[yoyoclaw-skill-refresh] failed to update skill read marker: ${String(t)}`);
 		}
 	});
 }
-function u(e) {
-	return n(e.path) || n(e.file_path);
+var u = [
+	"path",
+	"file_path",
+	"filePath",
+	"file"
+];
+function d(e) {
+	return u.some((t) => n(e[t]));
 }
 //#endregion
 export { s as registerHooks };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { setYoyoRuntime as e } from "./runtime.mjs";
-import { setClawLogger as t } from "./utils/logger.mjs";
+import { setClawLogger as e } from "./utils/logger.mjs";
+import { setYoyoRuntime as t } from "./runtime.mjs";
 import { registerCommands as n } from "./commands/index.mjs";
 import { registerHooks as r } from "./hooks/index.mjs";
 import { YoyoPluginConfigSchema as i } from "./schemas.mjs";
@@ -12,7 +12,7 @@ var o = {
 	description: "OpenClaw Honor Yoyo connection plugin",
 	configSchema: i,
 	register(i) {
-		e(i.runtime), t(i.logger), i.registerService(a(i)), r(i), n(i);
+		t(i.runtime), e(i.logger), i.registerService(a(i)), r(i), n(i);
 	}
 };
 //#endregion

package/dist/modules/configs/config-manager.mjs

@@ -1,34 +1,34 @@
-import { isBetaVersion as e } from "../../utils/version.mjs";
-import { getYoyoRuntime as t } from "../../runtime.mjs";
-import { areStringArraysEqual as n } from "../../utils/array.mjs";
-import { getEnvFromProcessEnv as r } from "../../utils/env.mjs";
-import { wrapError as i } from "../../utils/error.mjs";
-import { useClawLogger as a } from "../../utils/logger.mjs";
-import { detectProvidersToRename as o, updateProviderReferences as s } from "./provider.mjs";
-import { STATE_FLAG as c, hasPersistedStateFlag as l, markPersistedStateFlag as u } from "./state-flags.mjs";
+import { areStringArraysEqual as e } from "../../utils/array.mjs";
+import { getEnvFromProcessEnv as t } from "../../utils/env.mjs";
+import { wrapError as n } from "../../utils/error.mjs";
+import { useClawLogger as r } from "../../utils/logger.mjs";
+import { detectProvidersToRename as i, updateProviderReferences as a } from "./provider.mjs";
+import { STATE_FLAG as o, hasPersistedStateFlag as s, markPersistedStateFlag as c } from "./state-flags.mjs";
+import { getYoyoRuntime as l } from "../../runtime.mjs";
+import { isBetaVersion as u } from "../../utils/version.mjs";
 //#region src/modules/configs/config-manager.ts
 var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,alarm.enable,alarm.query,alarm.update,app.close,app.open,call.phone,call.search,capture-screenshot,contact.search,file-upload,hotspot,local-search,message.search,message.send,mobile-data,no-disturb,quiet-mode,ringing-mode,schedule.create,schedule.delete,schedule.search,schedule.update,screen-record,vibration-mode,volume.operate,wlan,bluetooth,location-service,nfc,usb-shared-network,eyecomfort,status-bar-show,brightness,autoscreen-onnotice,dark-mode,device-operation,camera,app.uninstall,audio-record,battery,gui.create,gui.pause,gui.terminate,mcp.tool.call,task_result_query".split(","), p = class {
 	loadConfig() {
 		try {
-			let e = t().config, n = e.current;
-			return typeof n == "function" ? structuredClone(n()) : structuredClone(e.loadConfig());
+			let e = l().config, t = e.current;
+			return typeof t == "function" ? structuredClone(t()) : structuredClone(e.loadConfig());
 		} catch (e) {
-			throw i(e, "Failed to load config");
+			throw n(e, "Failed to load config");
 		}
 	}
 	async saveConfig(e) {
 		try {
-			let n = t().config, r = n.replaceConfigFile;
-			if (typeof r == "function") {
-				await r({
+			let t = l().config, n = t.replaceConfigFile;
+			if (typeof n == "function") {
+				await n({
 					nextConfig: e,
 					afterWrite: { mode: "auto" }
 				});
 				return;
 			}
-			await n.writeConfigFile(e);
+			await t.writeConfigFile(e);
 		} catch (e) {
-			throw i(e, "Failed to save config");
+			throw n(e, "Failed to save config");
 		}
 	}
 	getGatewayAuthConfig() {
@@ -62,14 +62,14 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 	}
 	getEnvInfo() {
 		try {
-			let e = this.loadConfig().plugins?.entries?.[d]?.config, t = e?.envInfo;
-			if (t?.env) return t;
-			let n = e?.env;
-			if (n) return {
-				env: n,
+			let e = this.loadConfig().plugins?.entries?.[d]?.config, n = e?.envInfo;
+			if (n?.env) return n;
+			let r = e?.env;
+			if (r) return {
+				env: r,
 				source: "manual"
 			};
-			let i = r();
+			let i = t();
 			return i ? {
 				env: i,
 				source: "env"
@@ -124,7 +124,7 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 			};
 			await this.saveConfig(r);
 		} catch (e) {
-			throw i(e, "Failed to update device config");
+			throw n(e, "Failed to update device config");
 		}
 	}
 	async updateEnv(e) {
@@ -152,7 +152,7 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 			};
 			await this.saveConfig(n);
 		} catch (e) {
-			throw i(e, "Failed to update env config");
+			throw n(e, "Failed to update env config");
 		}
 	}
 	async resetEnv() {
@@ -181,7 +181,7 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 			};
 			await this.saveConfig(n);
 		} catch (e) {
-			throw i(e, "Failed to reset env config");
+			throw n(e, "Failed to reset env config");
 		}
 	}
 	async updateGrayTag(e) {
@@ -205,7 +205,7 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 			};
 			await this.saveConfig(n);
 		} catch (e) {
-			throw i(e, "Failed to update gray tag config");
+			throw n(e, "Failed to update gray tag config");
 		}
 	}
 	async updateUserConfig(e) {
@@ -229,7 +229,7 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 			};
 			await this.saveConfig(n);
 		} catch (e) {
-			throw i(e, "Failed to update user config");
+			throw n(e, "Failed to update user config");
 		}
 	}
 	async clearUserConfig() {
@@ -252,38 +252,38 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 			};
 			await this.saveConfig(t);
 		} catch (e) {
-			throw i(e, "Failed to clear user config");
+			throw n(e, "Failed to clear user config");
 		}
 	}
-	async initializePluginConfig(t) {
+	async initializePluginConfig(l) {
 		try {
-			let i = this.loadConfig(), d = i.skills || {}, p = d.load || {}, m = p.watch === !0, h = !m || await l(c.DISABLE_SKILLS_LOAD_WATCH_MIGRATION_DONE), g = i.plugins?.allow || [], _ = !g.includes(t), v = g.includes(t) ? g : [...g, t], y = i.gateway?.nodes?.allowCommands || [], b = Array.from(new Set([...y, ...f])), x = !n(y, b), S = m && !h, C = i.plugins?.entries?.[t]?.config?.envInfo, w = i.plugins?.entries?.[t]?.config?.env, T = !!(C?.env || w), E = r(), D = !!C?.env && C.source === "env", O = !C?.env && !!w || D && E && C.env !== E, k = !T || O, A = {
-				env: E || w || (e() ? "test" : "production"),
+			let n = this.loadConfig(), d = n.skills || {}, p = d.load || {}, m = p.watch === !0, h = !m || await s(o.DISABLE_SKILLS_LOAD_WATCH_MIGRATION_DONE), g = n.plugins?.allow || [], _ = !g.includes(l), v = g.includes(l) ? g : [...g, l], y = n.gateway?.nodes?.allowCommands || [], b = Array.from(new Set([...y, ...f])), x = !e(y, b), S = m && !h, C = n.plugins?.entries?.[l]?.config?.envInfo, w = n.plugins?.entries?.[l]?.config?.env, T = !!(C?.env || w), E = t(), D = !!C?.env && C.source === "env", O = !C?.env && !!w || D && E && C.env !== E, k = !T || O, A = {
+				env: E || w || (u() ? "test" : "production"),
 				source: "env"
-			}, j = i.plugins?.entries?.[t]?.config || {}, M = k ? {
+			}, j = n.plugins?.entries?.[l]?.config || {}, M = k ? {
 				...j,
 				envInfo: A,
 				env: void 0
-			} : j, N = i.plugins?.entries?.[t]?.enabled !== !0, P = o(i), F = Object.keys(P).length > 0;
-			if (F && a().info(`[claw-configs] Found ${Object.keys(P).length} providers to rename: ${Object.entries(P).map(([e, t]) => `${e} -> ${t}`).join(", ")}`), !_ && !x && !S && !k && !N && !F) return;
+			} : j, N = n.plugins?.entries?.[l]?.enabled !== !0, P = i(n), F = Object.keys(P).length > 0;
+			if (F && r().info(`[claw-configs] Found ${Object.keys(P).length} providers to rename: ${Object.entries(P).map(([e, t]) => `${e} -> ${t}`).join(", ")}`), !_ && !x && !S && !k && !N && !F) return;
 			let I = {
-				...i,
+				...n,
 				plugins: {
-					...i.plugins,
+					...n.plugins,
 					allow: v,
 					entries: {
-						...i.plugins?.entries,
-						[t]: {
-							...i.plugins?.entries?.[t],
+						...n.plugins?.entries,
+						[l]: {
+							...n.plugins?.entries?.[l],
 							enabled: !0,
 							config: M
 						}
 					}
 				},
 				gateway: {
-					...i.gateway,
+					...n.gateway,
 					nodes: {
-						...i.gateway?.nodes,
+						...n.gateway?.nodes,
 						allowCommands: b
 					}
 				}
@@ -297,9 +297,9 @@ var d = "yoyo", f = /* @__PURE__ */ "alarm.create,alarm.delete,alarm.disable,ala
 						watch: !1
 					}
 				}
-			}, a().info("[claw-configs] Disabled skills.load.watch for yoyo migration")), F && (I = s(I, P), a().info("[claw-configs] Provider renaming completed")), await this.saveConfig(I), S && await u(c.DISABLE_SKILLS_LOAD_WATCH_MIGRATION_DONE);
+			}, r().info("[claw-configs] Disabled skills.load.watch for yoyo migration")), F && (I = a(I, P), r().info("[claw-configs] Provider renaming completed")), await this.saveConfig(I), S && await c(o.DISABLE_SKILLS_LOAD_WATCH_MIGRATION_DONE);
 		} catch (e) {
-			throw i(e, "failed to initialize plugin config");
+			throw n(e, "failed to initialize plugin config");
 		}
 	}
 }, m = null;

package/dist/modules/device/registry.mjs

@@ -1,6 +1,6 @@
-import { getYoyoPluginVersionCode as e } from "../../utils/version.mjs";
-import { useClawLogger as t } from "../../utils/logger.mjs";
-import { getConfigManager as n } from "../configs/config-manager.mjs";
+import { useClawLogger as e } from "../../utils/logger.mjs";
+import { getConfigManager as t } from "../configs/config-manager.mjs";
+import { getYoyoPluginVersionCode as n } from "../../utils/version.mjs";
 import { isOKResponse as r } from "../../apis/helpers.mjs";
 import { createClawCloudClient as i } from "../../apis/claw-cloud.mjs";
 import { getPersistedIdentity as a, updatePersistedIdentity as o } from "../configs/identity-persist.mjs";
@@ -9,28 +9,28 @@ import "../../apis/index.mjs";
 import { formatHashForLog as s } from "../../utils/hash.mjs";
 import { createGatewayAuthMd5 as c, isSameGatewayAuthMd5 as l } from "./gateway-auth.mjs";
 //#region src/modules/device/registry.ts
-async function u(t, a) {
-	if (!t || !a) throw Error("设备信息或用户信息缺失");
-	let o = n().getGatewayAuthConfig(), s = c(o), l = e(), u = await i().registerDevice(t, a, o);
+async function u(e, a) {
+	if (!e || !a) throw Error("设备信息或用户信息缺失");
+	let o = t().getGatewayAuthConfig(), s = c(o), l = n(), u = await i().registerDevice(e, a, o);
 	if (!r(u)) throw Error(`注册失败：${u.data?.cnMessage}`);
 	await f(s, l);
 }
 async function d(r, i) {
-	let o = c(n().getGatewayAuthConfig()), d = e(), f = await a(), p = f?.gatewayAuthMd5, m = f?.pluginVersionCode, h = t();
+	let o = c(t().getGatewayAuthConfig()), d = n(), f = await a(), p = f?.gatewayAuthMd5, m = f?.pluginVersionCode, h = e();
 	if (h.info(`[yoyoclaw-registry] checking registration state: gatewayAuth current=${s(o)}, persisted=${s(p)}; pluginVersionCode current=${d}, persisted=${m ?? "none"}`), l(p, o) && m === d) {
 		h.info("[yoyoclaw-registry] registration state unchanged, skipping device registration");
 		return;
 	}
 	h.info("[yoyoclaw-registry] registration state changed, registering device"), await u(r, i), h.info(`[yoyoclaw-registry] device registration succeeded, pluginVersionCode=${d}`);
 }
-async function f(e, n) {
+async function f(t, n) {
 	try {
 		await o({
-			gatewayAuthMd5: e,
+			gatewayAuthMd5: t,
 			pluginVersionCode: n
-		}), t().info("[yoyoclaw-registry] registration state persisted after device registration");
-	} catch (e) {
-		t().warn(`[yoyoclaw-registry] failed to persist registration state: ${String(e)}`);
+		}), e().info("[yoyoclaw-registry] registration state persisted after device registration");
+	} catch (t) {
+		e().warn(`[yoyoclaw-registry] failed to persist registration state: ${String(t)}`);
 	}
 }
 //#endregion

package/dist/utils/home-dir.mjs

@@ -1,16 +1,16 @@
 import { findPackageRoot as e } from "./package-json.mjs";
 import t from "node:path";
-import { fileURLToPath as n } from "node:url";
-import r from "node:os";
+import n from "node:os";
+import { fileURLToPath as r } from "node:url";
 //#region src/utils/home-dir.ts
 function i(e) {
 	return e?.trim() || void 0;
 }
-function a(r = import.meta.url) {
-	return e(r) ?? t.parse(n(r)).root;
+function a(n = import.meta.url) {
+	return e(n) ?? t.parse(r(n)).root;
 }
-function o(e = process.env, n = r.homedir) {
-	let i = s(e, n);
+function o(e = process.env, r = n.homedir) {
+	let i = s(e, r);
 	return i ? t.resolve(i) : void 0;
 }
 function s(e, t) {

package/dist/utils/version.mjs

@@ -1,27 +1,59 @@
 import { findPackageRoot as e, readPackageJson as t } from "./package-json.mjs";
+import { getYoyoRuntime as n } from "../runtime.mjs";
 //#region src/utils/version.ts
-var n = "@honor-claw/yoyo";
-function r() {
-	let e = o();
+var r = "@honor-claw/yoyo", i = 3;
+function a() {
+	try {
+		let e = n().version;
+		return o(e);
+	} catch {
+		return i;
+	}
+}
+function o(e) {
+	let t = s(e);
+	return t && c(t, [
+		2026,
+		5,
+		12
+	]) >= 0 ? 4 : i;
+}
+function s(e) {
+	if (!e) return null;
+	let t = e.split("-", 1)[0].split(".");
+	if (t.length === 0) return null;
+	let n = t.map((e) => Number.parseInt(e, 10));
+	return n.some((e) => !Number.isFinite(e) || e < 0) ? null : n;
+}
+function c(e, t) {
+	let n = Math.max(e.length, t.length);
+	for (let r = 0; r < n; r += 1) {
+		let n = e[r] ?? 0, i = t[r] ?? 0;
+		if (n !== i) return n - i;
+	}
+	return 0;
+}
+function l() {
+	let e = f();
 	return e.includes("beta") || e.includes("alpha");
 }
-function i(e) {
+function u(e) {
 	if (!e) return 0;
 	let t = Number.parseInt(e, 10);
 	return Number.isFinite(t) && t >= 0 ? t : 0;
 }
-function a() {
-	let [e, t, n] = o().split("-", 1)[0].split("."), r = i(e), a = i(t), s = i(n);
-	return r * 1e6 + a * 1e3 + s;
+function d() {
+	let [e, t, n] = f().split("-", 1)[0].split("."), r = u(e), i = u(t), a = u(n);
+	return r * 1e6 + i * 1e3 + a;
 }
-function o() {
+function f() {
 	try {
-		let r = e(import.meta.url, n);
-		if (!r) return "0.0.0";
-		let i = t(r)?.version;
+		let n = e(import.meta.url, r);
+		if (!n) return "0.0.0";
+		let i = t(n)?.version;
 		if (typeof i == "string") return i;
 	} catch {}
 	return "0.0.0";
 }
 //#endregion
-export { a as getYoyoPluginVersionCode, r as isBetaVersion };
+export { a as getProtocolVersion, d as getYoyoPluginVersionCode, l as isBetaVersion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honor-claw/yoyo",
-  "version": "1.6.1-beta.2",
+  "version": "1.6.1-beta.4",
   "description": "OpenClaw Honor Yoyo connection plugin",
   "keywords": [
     "ai",

package/skills/yoyo-control/SKILL.md

@@ -140,8 +140,6 @@ metadata: { "openclaw": { "emoji": "📱", "always": true } }
 | `flashlight`          | `references/flashlight.md`               | 手电筒控制                           |
 | `airplane-mode`       | `references/airplane-mode.md`            | 飞行模式管理                         |
 | `clean-dirty`         | `references/clean-dirty.md`              | 扬声器清理                           |
-| `flight-monitor`      | `references/flight-monitor-create.md`    | 创建机票价格监控                     |
-| `flight-monitor`      | `references/flight-monitor-search.md`    | 查询机票监控任务                     |
 | `express`             | `references/express-logistics-search.md` | 快递查询                             |
 | `countdown-timer`     | `references/countdown-timer.md`          | 倒计时计时器管理                      |
 | `desktop`             | `references/desktop.md`                  | 手机桌面管理，支持查询桌面布局、打开桌面设置页，并对风格、应用角标、桌面图标、快捷方式、搜索入口、应用名称、通透模式与布局等进行配置。 |

package/skills/yoyo-control/references/flight-monitor-create.md

@@ -1,233 +0,0 @@
----
-name: flight-monitor.create
-description: >
-  创建机票价格监控任务。支持设置目的地、出发地、监控时间段与目标价格，缺省或低于最低监控价时给出价格区间与建议价。
-  只支持飞机票价的监控任务创建，其余票务类型（如酒店、机票联程、火车票等）暂不支持。
----
-
-# Create Flight Monitor Task 创建机票监控任务
-
-## Tool Provider
-```bash
-com.hihonor.magicvoice
-```
-
-## Tool Command
-```bash
-create_flight_monitor_task
-```
-
-## 3. 业务规则
-
-### 适用场景及操作流程
-1. 解析并提取目的地城市、出发地城市、监控时间段与目标价格
-2. 未提供出发地时，默认使用用户当前位置城市
-3. 未提供目的地时，提醒用户指定目的地
-4. 对价格进行币种识别与人民币换算，并向下取整
-5. 当未指定监控价格或设定价格低于最低可监控价时，工具返回可监控价格区间与建议价
-6. 创建机票价格监控任务并开始持续监控
-
-### 特定交互
-- 币种默认人民币；如检测到外币（如 USD、美元），按实时汇率换算为人民币后取整
-- 城市名必须为具体城市中文名，不支持省份或国家级地名
-- 监控时间段使用用户原始的自然语言日期表述（如“下周二到下周三”“10月1日-10月7日”），不做改写
-- 价格仅提取数值部分，取整为不大于该值的整数；“以内/不高于/低于”等等价于上限价
-
-## 4. 集成工作流
-
-### Step 1: 意图解析与参数组装
-```
-┌─────────────────────────────────────────────────────────────┐
-│  意图识别与参数提取                                          │
-│  - 识别操作意图: 创建 + 机票价格监控任务                      │
-│  - 提取目的地城市: 城市中文名（不含省/国家）                  │
-│  - 提取出发地城市: 城市中文名（缺省为当前位置）              │
-│  - 提取监控时间段: 自然语言日期描述（直接保留）              │
-│  - 提取目标价格: 数字，币种识别与换算，向下取整              │
-│  - 特殊处理: "飞/去/到" 等同义词统一识别为目的地              │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│  消歧与槽位填充                                              │
-│  - 未指定出发地时，默认为用户当前位置城市                    │
-│  - 未指定监控价格时，返回价格区间与建议价                    │
-│  - 价格低于最低可监控价时，提示范围并给出建议价              │
-│  - date_time 仅当 query 含时间表述时填写                     │
-│  - 验证规则: 目的地与出发地不能相同                          │
-│  - "从/出发地" → 映射为出发地槽位                            │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│  生成工具调用                                                │
-│  - 组装 destination_city 及可选参数（departure_city,         │
-│    date_time, price）                                        │
-│  - 生成平台特定的命令格式                                    │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Step 2: 执行调用
-- 根据操作系统选择对应的命令格式
-- Windows: Cmd 格式（双引号需转义）
-- Linux: Bash 格式（单引号包裹）
-
-## 5. 参数定义
-### 工具输入参数说明
-```json
-{
-  "destination_city": {
-    "type": "string",
-    "description": "必填参数，机票监控的目的地城市中文名称，不支持省份或国家。如：深圳、北京。"
-  },
-  "departure_city": {
-    "type": "string",
-    "description": "机票监控的出发地城市中文名称，默认为用户当前位置所在城市，不支持省份或国家。如：深圳、北京。"
-  },
-  "date_time": {
-    "type": "string",
-    "description": "监控时间段的自然语言描述，直接提取用户输入中日期的描述。如：下周、下周二到下周三、周一下午。"
-  },
-  "price": {
-    "type": "integer",
-    "description": "用户设定的监控目标最高价格。直接提取价格数字，向下取整。默认币种人民币，其他币种需换算人民币。如果没有指定币种，按照人民币处理。"
-  }
-}
-```
-
-### 工具输出参数说明
-```json
-{
-  "result_code": {
-    "type": "integer",
-    "description": "结果状态码。100：执行成功。201：用户没有指定价格时返回，追问用户需要设置的监控价格，同时返回价格区间（suggested_price_range）与推荐价格（suggested_price）。202：追问，没有出发地城市，同时当前城市查询失败时追问。304：未授权三方账号，用户拒绝授权三方。406：授权三方失败。500：出发地不在支持列表范围内。501：目的地不在支持列表范围内。502：监控日期超出监控范围。503：查询监控价格失败，当前航线未查询到直飞航班报价。504：用户设置的监控价格过低，低于最低可监控价格，同时返回价格区间（suggested_price_range）与推荐价格（suggested_price）。505：监控任务创建失败。506：已存在重复监控任务。507：监控任务已达上限。"
-  },
-  "result_content": {
-    "type": "string",
-    "description": "针对不同状态码场景下，详细的执行结果，包含错误原因等。"
-  },
-  "suggested_price_range": {
-    "type": "string",
-    "description": "工具根据历史数据建议的价格区间，货币单位为人民币，格式为最低可监控价格-最高监控价格，如：500-1000。"
-  },
-  "suggested_price": {
-    "type": "integer",
-    "description": "工具建议的监控目标价格，货币单位为人民币。"
-  },
-  "departure_city": {
-    "type": "string",
-    "description": "出发地城市中文名称。如：深圳、北京。"
-  },
-  "destination_city": {
-    "type": "string",
-    "description": "目的地城市中文名称。如：深圳、北京。"
-  },
-  "date_range": {
-    "type": "string",
-    "description": "监控的日期范围，格式为 YYYY-MM-DD~YYYY-MM-DD。"
-  },
-  "price": {
-    "type": "integer",
-    "description": "用户设置的监控价格，货币单位为人民币，未提供或小于最低可监控价格则设为0。"
-  }
-}
-```
-
-
-### 参数注意事项
-1. **默认值或缺省行为**: 未提供`departure_city`时默认取用户当前位置城市；未提供`price`时由工具返回可监控价格区间与建议价；未标明币种时按人民币处理。
-2. **参数间关联/验证**: `destination_city`为必填且不得与`departure_city`相同；外币价格需先换算为人民币后再对`price`进行向下取整。
-3. **可选参数填写条件**: `date_time`仅在用户明确提及时间/日期时填写，不做推断；`departure_city`仅在用户未使用默认定位或明确指定时填写。
-
-### date_time 参数格式转换
-1. 当用户输入包含时间表述时，工具会直接保留原始的自然语言日期表述，然后调用`scripts/time_infer.py`时间推理模型进行转换。具体执行指令如下：
-```bash
-python3 scripts/time_infer.py --query <date_time>
-```
-2. 拿到json-string格式的转换结果，重新改写`date_time`参数，并调用`openclaw nodes invoke`命令执行工具。
-3. 注意：time_infer模型返回的结果格式如下：`{"data_time": {...}}`，用`{...}`JSONstring的完整内容重写`date_time`参数。**不能拆解{...}的内容**
-
-## 6. Query 示例及输出
-
-### 示例 1: 指定出发地、时间段与人民币价格上限
-**用户输入**: "帮我监控一下去上海的机票，出发地是北京，时间是十月一号到十月七号，价格设为1000元以内"
-
-**工具**: "create_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "destination_city": "上海",
-  "departure_city": "北京",
-  "date_time": "十月一号到十月七号",
-  "price": 1000
-}
-```
-**调用时间推理模型**:
-```bash
-python3 scripts/time_infer.py --query "十月一号到十月七号"
-```
-返回结果: {"data_time": <json-string-data>} (注意字符串转义的问题！！！)
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"create_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"destination_city\":\"上海\",\"departure_city\":\"北京\",\"date_time\":\"<json-string-data>\",\"price\":1000}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"create_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{"destination_city":"上海","departure_city":"北京","date_time":"<json-string-data>","price":1000}}'
-```
-
----
-
-### 示例 2: 仅目的地与美元价格（自动换算为人民币）
-**用户输入**: "帮我监控飞广州的机票，价格低于200美元就提醒"
-
-**工具**: "create_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "destination_city": "广州",
-  "price": 1440
-}
-```
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"create_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"destination_city\":\"广州\",\"price\":1440}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"create_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{"destination_city":"广州","price":1440}}'
-```
-
----
-
-### 示例 3: 指定目的地与出发时段，不设价格（工具返回建议价）
-**用户输入**: "帮我关注去杭州的机票，下周三下午出发"
-
-**工具**: "create_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "destination_city": "杭州",
-  "date_time": "下周三下午"
-}
-```
-**调用时间推理模型**:
-```bash
-python3 scripts/time_infer.py --query "下周三下午"
-```
-返回结果: {"data_time": <json-string-data>} (注意字符串转义的问题！！！)
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"create_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"destination_city\":\"杭州\",\"date_time\":\"<json-string-data>\"}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"create_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{"destination_city":"杭州","date_time":"<json-string-data>"}}'
-```

package/skills/yoyo-control/references/flight-monitor-search.md

@@ -1,229 +0,0 @@
----
-name: flight-monitor.query
-description: >
-  查询用户已创建的机票价格监控任务，支持按出发地、目的地、监控日期与任务状态筛选。
-  只支持飞机票价的监控任务创建，其余票务类型（如酒店、机票联程、火车票等）暂不支持。
----
-
-# Query Flight Monitor Task 机票监控任务查询
-
-## Tool Provider
-```bash
-com.hihonor.magicvoice
-```
-
-## Tool Command
-```bash
-query_flight_monitor_task
-```
-
-## 集成工作流
-
-### Step 1: 意图解析与参数组装
-```
-┌─────────────────────────────────────────────────────────────┐
-│  意图识别与参数提取                                          │
-│  - 识别操作意图: 查询 + 机票价格监控任务                     │
-│  - 提取目的地: 城市名/机场名/别称                            │
-│  - 提取出发地: 城市名/机场名/别称                            │
-│  - 提取监控日期: 具体日期/日期范围/自然语言时间              │
-│  - 提取任务状态: 已过期/监控中/监控成功                      │
-│  - 特殊处理: "监控中的/正在监控" → 映射为监控中              │
-│  - 特殊处理: "过期/失效" → 已过期；"成功/达成" → 监控成功     │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│  消歧与槽位填充                                              │
-│  - 未指定任何筛选条件时，默认查询全部监控任务               │
-│  - destination_city/departure_city/date_time/status 缺失时， │
-│    不对该项筛选                                              │
-│  - date_time 仅当 query 含时间表述时填写                     │
-│  - "监控中的/进行中/在监控" → 映射为监控中                   │
-│  - "已失效/过期的" → 已过期；"已触发/成功了" → 监控成功      │
-│  - 城市名需为有效地名，避免与机场简称冲突                    │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│  生成工具调用                                                │
-│  - 组装 status 及可选参数（destination_city、departure_city、 │
-│    date_time）                                               │
-│  - 生成平台特定的命令格式                                    │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Step 2: 执行调用
-- 根据操作系统选择对应的命令格式
-- Windows: Cmd 格式（双引号需转义）
-- Linux: Bash 格式（单引号包裹）
-
-## 参数定义
-### 工具输入参数说明
-```json
-{
-  "destination_city": {
-    "type": "string",
-    "description": "监控任务的目的地城市名称。"
-  },
-  "departure_city": {
-    "type": "string",
-    "description": "监控任务的出发地城市名称。"
-  },
-  "date_time": {
-    "type": "string",
-    "description": "监控时间段的自然语言描述，直接提取用户输入中日期的描述。如：下周、下周二到下周三、周一下午。"
-  },
-  "status": {
-    "type": "string",
-    "enum": ["已过期", "监控中", "监控成功"],
-    "description": "监控任务的当前生效状态。"
-  }
-}
-```
-
-### 工具输出参数说明
-```json
-{
-  "result_code":{
-    "type":"integer",
-    "description":"结果状态码，100：执行成功。304：未授权三方账号，用户拒绝授权三方。402：三方接口调用出错。406：授权三方失败。500：无监控任务。"
-  },
-  "result_content":{
-    "type":"string",
-    "description":"针对不同状态码场景下，详细的执行结果，包含错误原因等。"
-  },
-  "task_count":{
-    "type":"integer",
-    "description":"查询到的监控任务总数量。"
-  },
-  "task_list":{
-    "type":"string",
-    "description":"监控任务的详细列表数据。每条数据包含序号、出发地、目的地、监控日期段、监控状态。查询失败或无监控任务（500）时返回空字符串。",
-    "examples":[
-      "{\"监控任务列表\":[{\"序号\":1,\"出发地\":\"北京\",\"目的地\":\"上海\",\"开始日期\":\"2023-12-01\",\"结束日期\":\"2023-12-03\",\"状态\":\"监控中\"},{\"序号\":2,\"出发地\":\"上海\",\"目的地\":\"广州\",\"开始日期\":\"2023-12-05\",\"状态\":\"监控成功\"}]}"
-    ]
-  }
-}
-```
-
-### 参数注意事项
-1. **默认值或缺省行为**: 未提供任一筛选条件时，默认返回全部监控任务；某参数未提供则不作为筛选条件参与过滤。
-2. **可选参数填写条件**: `date_time` 仅在用户输入包含时间表述时填写；`destination_city`、`departure_city` 仅在出现明确城市名时填写；`status` 仅在用户明确提及时填写。
-3. **格式/原样保留要求**: `date_time` 必须保留用户的自然语言原始表述，不做标准化或改写。
-
-### date_time 参数格式转换
-1. 当用户输入包含时间表述时，工具会直接保留原始的自然语言日期表述，然后调用`scripts/time_infer.py`时间推理模型进行转换。具体执行指令如下：
-```bash
-python3 scripts/time_infer.py --query <date_time>
-```
-2. 拿到json-string格式的转换结果，重新改写`date_time`参数，并调用`openclaw nodes invoke`命令执行工具。
-3. 注意：time_infer模型返回的结果格式如下：`{"data_time": {...}}`，用`{...}`JSONstring的完整内容重写`date_time`参数。**不能拆解{...}的内容**
-
-## Query 示例及输出
-
-### 示例 1: 按目的地筛选
-**用户输入**: "帮我查一下去上海的监控任务"
-
-**工具**: "query_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "destination_city": "上海"
-}
-```
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"query_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"destination_city\":\"上海\"}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"query_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{"destination_city":"上海"}}'
-```
-
----
-
-### 示例 2: 按任务状态筛选
-**用户输入**: "查询所有监控中的任务"
-
-**工具**: "query_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "status": "监控中"
-}
-```
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"query_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"status\":\"监控中\"}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"query_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{"status":"监控中"}}'
-```
-
----
-
-### 示例 3: 按时间与状态组合筛选（自然语言时间）
-**用户输入**: "查询下周监控中的任务"
-
-**工具**: "query_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "date_time": "下周",
-  "status": "监控中"
-}
-```
-**调用时间推理模型**:
-```bash
-python3 scripts/time_infer.py --query "下周"
-```
-返回结果：{"data_time": <json-string-data>} (注意字符串转义的问题！！！)
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"query_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"date_time\":\"<json-string-data>\",\"status\":\"监控中\"}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"query_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{"date_time":"<json-string-data>","status":"监控中"}}'
-```
-
----
-
-### 示例 4: 按时间范围与状态组合筛选
-**用户输入**: "查询十月一号到十月七号监控中的任务"
-
-**工具**: "query_flight_monitor_task"
-
-**JSON 参数**:
-```json
-{
-  "date_time": "十月一号到十月七号",
-  "status": "监控中"
-}
-```
-**调用时间推理模型**:
-```bash
-python3 scripts/time_infer.py --query "十月一号到十月七号"
-```
-返回结果：{"data_time": <json-string-data>} (注意字符串转义的问题！！！)
-
-**Windows (Cmd) 执行命令**:
-```bash
-cmd /c 'openclaw nodes invoke --node <ID> --command mcp.tool.call --params "{\"name\":\"query_flight_monitor_task\",\"appPkg\":\"com.hihonor.magicvoice\",\"arguments\":{\"date_time\":\"<json-string-data>\",\"status\":\"监控中\"}}"'
-```
-
-**Linux (Bash) 执行命令**:
-```bash
-openclaw nodes invoke --node <ID> --command mcp.tool.call --params '{"name":"query_flight_monitor_task","appPkg":"com.hihonor.magicvoice","arguments":{date_time":"<json-string-data>","status":"监控中"}}'
-```
-
----

package/skills/yoyo-control/scripts/time_infer.py

@@ -1,99 +0,0 @@
-import time
-import hmac
-import hashlib
-import base64
-import json
-import requests
-from datetime import datetime
-import argparse
-
-
-def gen_headers():
-    # ak / sk 建议线上不要写死在代码里，放到环境变量或配置文件中
-    ak = "DB1178355DDE4CD2"
-    sk = "4764F7B34264E8F4343AC7363AA6D4"
-
-    # 对应：var ts = Math.floor(Date.now()).toString();
-    # Date.now() 是毫秒，这里同样用毫秒时间戳
-    ts = str(int(time.time() * 1000))
-
-    # 对应：CryptoJS.HmacSHA256(ts + ak, sk).toString().toUpperCase()
-    msg = (ts + ak).encode("utf-8")
-    key = sk.encode("utf-8")
-    digest = hmac.new(key, msg, hashlib.sha256).hexdigest().upper()
-
-    # 对应：new Buffer(...).toString('base64');
-    # 即对十六进制字符串做 base64 编码
-    sign = base64.b64encode(digest.encode("utf-8")).decode("utf-8")
-
-    headers = {
-        "accessKey": ak,
-        "ts": ts,
-        "sign": sign,
-        "Content-Type": "application/json",
-    }
-    return headers
-
-
-def get_current_local_time_str():
-    """
-    生成形如：2025-12-23 12:48:00.000 的时间字符串
-    使用当前系统时间
-    """
-    now = datetime.now()
-    # %f 是微秒，取前 3 位当毫秒
-    return now.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="调用 time-agent 接口的命令行工具"
-    )
-    parser.add_argument(
-        "--query",
-        # required=True,
-        default="大小周下周六休息7点",
-        help="语义查询内容（必填）",
-    )
-    parser.add_argument(
-        "--type",
-        dest="req_type",
-        default="time",
-        help="payload.data.type，默认值为 'time'",
-    )
-    parser.add_argument(
-        "--timeZone",
-        dest="time_zone",
-        default="+0800",
-        help="payload.data.timeZone，默认值为 '+0800'",
-    )
-    return parser.parse_args()
-
-
-def main():
-    url = "https://ai-model-access-drcn.rnd.honor.com/time-agent/v1/models/model/predict"
-    args = parse_args()
-
-    payload = {
-        "data": {
-            "type": args.req_type,
-            "timeZone": args.time_zone,
-            "query": args.query,
-            "localTime": get_current_local_time_str()
-        }
-    }
-
-    headers = gen_headers()
-
-    resp = requests.post(url, headers=headers, data=json.dumps(payload))
-    print("Status code:", resp.status_code)
-    try:
-        datas = resp.json()
-        res = json.dumps(datas.get("data", {}), separators=(",", ":"), ensure_ascii=False)
-        print({"data_time": res})
-    except Exception:
-        print("Response text:", resp.text)
-
-
-if __name__ == "__main__":
-    main()