yunti-browser-runtime 0.1.0

package/scripts/print-config.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const mcpServerPath = join(rootDir, "mcp", "server.js")
+const skillPath = join(rootDir, "skills", "yunti-browser-runtime")
+const bridgePort = process.env.YUNTI_BROWSER_BRIDGE_PORT || "48887"
+const bridgeTokenConfigured = Boolean(String(process.env.YUNTI_BROWSER_BRIDGE_TOKEN || "").trim())
+const supportedAgents = ["codex", "claude-code", "cursor", "cline"]
+
+function parseArgs(argv) {
+  const result = { agent: "codex", format: "json" }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === "--agent") {
+      result.agent = argv[i + 1] || result.agent
+      i += 1
+      continue
+    }
+    if (arg.startsWith("--agent=")) {
+      result.agent = arg.slice("--agent=".length)
+      continue
+    }
+    if (arg === "--human") result.format = "human"
+    if (arg === "--json") result.format = "json"
+  }
+  result.agent = String(result.agent || "codex").trim().toLowerCase()
+  return result
+}
+
+function mcpServerConfig() {
+  const env = {
+    YUNTI_BROWSER_BRIDGE_PORT: bridgePort,
+  }
+  if (bridgeTokenConfigured) {
+    env.YUNTI_BROWSER_BRIDGE_TOKEN = "<set the same local bridge token>"
+  }
+  return {
+    command: "node",
+    args: [mcpServerPath],
+    env,
+  }
+}
+
+function agentConfig(agent) {
+  const server = mcpServerConfig()
+  switch (agent) {
+    case "codex":
+    case "claude-code":
+    case "cursor":
+    case "cline":
+      return {
+        mcpServers: {
+          "yunti-browser-runtime": server,
+        },
+      }
+    default:
+      return {
+        mcpServers: {
+          "yunti-browser-runtime": server,
+        },
+      }
+  }
+}
+
+function buildConfig(agent) {
+  return {
+    ok: supportedAgents.includes(agent),
+    agent,
+    supportedAgents,
+    projectRoot: rootDir,
+    mcpServerPath,
+    bridge: {
+      port: bridgePort,
+      tokenEnv: "YUNTI_BROWSER_BRIDGE_TOKEN",
+      tokenConfigured: bridgeTokenConfigured,
+      tokenInstruction: bridgeTokenConfigured
+        ? "Token is configured in the current environment; copy the same secret into your agent and extension settings without committing it."
+        : "Set YUNTI_BROWSER_BRIDGE_TOKEN in your agent and save the same token in the extension popup when bridge auth is enabled.",
+    },
+    skill: {
+      sourcePath: skillPath,
+      installHint: "Copy the yunti-browser-runtime skill directory into your agent skills directory if the agent supports skills.",
+    },
+    config: agentConfig(agent),
+  }
+}
+
+function humanOutput(payload) {
+  return [
+    `Yunti Browser Runtime MCP config for ${payload.agent}`,
+    "",
+    JSON.stringify(payload.config, null, 2),
+    "",
+    `Project root: ${payload.projectRoot}`,
+    `MCP server: ${payload.mcpServerPath}`,
+    `Bridge port: ${payload.bridge.port}`,
+    `Token: ${payload.bridge.tokenInstruction}`,
+    `Skill: ${payload.skill.sourcePath}`,
+    payload.ok ? "" : `Unsupported agent "${payload.agent}". Supported: ${payload.supportedAgents.join(", ")}`,
+  ]
+    .filter((line, index, lines) => line || lines[index - 1] !== "")
+    .join("\n")
+}
+
+const args = parseArgs(process.argv.slice(2))
+const payload = buildConfig(args.agent)
+
+if (args.format === "human") {
+  console.log(humanOutput(payload))
+} else {
+  console.log(JSON.stringify(payload, null, 2))
+}
+
+if (!payload.ok) process.exitCode = 1

package/scripts/release-check.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { spawnSync } from "node:child_process"
+
+const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const residueTerms = ["/Users", "Codeg", "xyy", "ybm100"]
+const residueRoots = ["README.md", "docs", "skills", "package.json"]
+const requiredExtensionZipFiles = [
+  "background.js",
+  "cdp.js",
+  "content.css",
+  "content.js",
+  "network-monitor.js",
+  "manifest.json",
+  "popup.css",
+  "popup.html",
+  "popup.js",
+  "session-manager.js",
+  "settings.js",
+  "tool-handlers.js",
+]
+
+function readJsonFile(path) {
+  return JSON.parse(readFileSync(join(rootDir, path), "utf8"))
+}
+
+function listFiles(path) {
+  const absolutePath = join(rootDir, path)
+  const stats = statSync(absolutePath)
+  if (stats.isFile()) return [absolutePath]
+  if (!stats.isDirectory()) return []
+  return readdirSync(absolutePath, { withFileTypes: true }).flatMap((entry) => {
+    const childPath = join(path, entry.name)
+    if (entry.isDirectory()) return listFiles(childPath)
+    if (entry.isFile()) return [join(rootDir, childPath)]
+    return []
+  })
+}
+
+function checkPublicDocResidue() {
+  const matches = []
+  for (const file of residueRoots.flatMap(listFiles)) {
+    const text = readFileSync(file, "utf8")
+    for (const term of residueTerms) {
+      if (text.includes(term)) {
+        matches.push({
+          file: file.slice(rootDir.length + 1),
+          term,
+        })
+      }
+    }
+  }
+  if (matches.length) {
+    console.error("Public documentation residue check failed:")
+    for (const match of matches) console.error(`- ${match.file}: ${match.term}`)
+    return false
+  }
+  console.error("Public documentation residue check passed.")
+  return true
+}
+
+function stripMarkdownCodeFences(text) {
+  return text.replace(/```[\s\S]*?```/g, "")
+}
+
+function checkMarkdownLinks() {
+  const files = residueRoots
+    .flatMap(listFiles)
+    .filter((file) => file.endsWith(".md"))
+  const broken = []
+  const linkPattern = /(?<!!)\[[^\]]+\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g
+
+  for (const file of files) {
+    const text = stripMarkdownCodeFences(readFileSync(file, "utf8"))
+    for (const match of text.matchAll(linkPattern)) {
+      const rawTarget = String(match[1] || "").trim()
+      if (
+        !rawTarget ||
+        rawTarget.startsWith("#") ||
+        /^[a-z][a-z0-9+.-]*:/i.test(rawTarget) ||
+        rawTarget.startsWith("mailto:")
+      ) {
+        continue
+      }
+
+      const [targetPath, anchor] = rawTarget.split("#")
+      if (!targetPath) continue
+      const absoluteTarget = resolve(dirname(file), decodeURIComponent(targetPath))
+      if (!existsSync(absoluteTarget)) {
+        broken.push({
+          file: file.slice(rootDir.length + 1),
+          target: rawTarget,
+          reason: "target file missing",
+        })
+        continue
+      }
+      if (anchor && !statSync(absoluteTarget).isFile()) {
+        broken.push({
+          file: file.slice(rootDir.length + 1),
+          target: rawTarget,
+          reason: "anchor target is not a file",
+        })
+      }
+    }
+  }
+
+  if (broken.length) {
+    console.error("Public Markdown link check failed:")
+    for (const item of broken) {
+      console.error(`- ${item.file}: ${item.target} (${item.reason})`)
+    }
+    return false
+  }
+
+  console.error(`Public Markdown link check passed (${files.length} files).`)
+  return true
+}
+
+function checkVersionConsistency() {
+  const packageJson = readJsonFile("package.json")
+  const manifestJson = readJsonFile("extension/manifest.json")
+  const packageVersion = String(packageJson.version || "").trim()
+  const manifestVersion = String(manifestJson.version || "").trim()
+
+  if (!packageVersion || !manifestVersion || packageVersion !== manifestVersion) {
+    console.error("Version consistency check failed:")
+    console.error(`- package.json version: ${packageVersion || "(missing)"}`)
+    console.error(`- extension/manifest.json version: ${manifestVersion || "(missing)"}`)
+    return false
+  }
+
+  console.error(`Version consistency check passed (${packageVersion}).`)
+  return true
+}
+
+function checkCliSmoke() {
+  const packageJson = readJsonFile("package.json")
+  const binPath = packageJson.bin?.["yunti-browser-runtime"]
+  if (binPath !== "bin/yunti-browser-runtime.js") {
+    console.error("CLI smoke check failed:")
+    console.error(`- package.json bin yunti-browser-runtime: ${binPath || "(missing)"}`)
+    return false
+  }
+
+  const help = spawnSync(process.execPath, ["bin/yunti-browser-runtime.js", "--help"], {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+  })
+  if (
+    help.status !== 0 ||
+    !help.stdout.includes("Yunti Browser Runtime") ||
+    !help.stdout.includes("package-extension")
+  ) {
+    console.error("CLI smoke check failed:")
+    console.error(`- --help exit code: ${help.status}`)
+    console.error(`- --help stdout: ${help.stdout.trim() || "(empty)"}`)
+    console.error(`- --help stderr: ${help.stderr.trim() || "(empty)"}`)
+    return false
+  }
+
+  const version = spawnSync(process.execPath, ["bin/yunti-browser-runtime.js", "--version"], {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+  })
+  const expectedVersion = String(packageJson.version || "").trim()
+  const actualVersion = version.stdout.trim()
+  if (version.status !== 0 || actualVersion !== expectedVersion) {
+    console.error("CLI smoke check failed:")
+    console.error(`- --version exit code: ${version.status}`)
+    console.error(`- expected version: ${expectedVersion || "(missing)"}`)
+    console.error(`- actual version: ${actualVersion || "(empty)"}`)
+    console.error(`- --version stderr: ${version.stderr.trim() || "(empty)"}`)
+    return false
+  }
+
+  console.error(`CLI smoke check passed (${actualVersion}).`)
+  return true
+}
+
+function checkPrintConfigSmoke() {
+  const agents = ["codex", "claude-code", "cursor", "cline"]
+  for (const agent of agents) {
+    const result = spawnSync(
+      process.execPath,
+      ["scripts/print-config.js", "--agent", agent, "--json"],
+      {
+        cwd: rootDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+      }
+    )
+    if (result.status !== 0) {
+      console.error("print-config smoke check failed:")
+      console.error(`- agent: ${agent}`)
+      console.error(`- exit code: ${result.status}`)
+      console.error(`- stderr: ${result.stderr.trim() || "(empty)"}`)
+      return false
+    }
+
+    let payload
+    try {
+      payload = JSON.parse(result.stdout || "{}")
+    } catch (error) {
+      console.error("print-config smoke check failed:")
+      console.error(`- agent: ${agent}`)
+      console.error(`- JSON parse error: ${error.message}`)
+      return false
+    }
+
+    const server =
+      payload?.config?.mcpServers?.["yunti-browser-runtime"]
+    const env = server?.env || {}
+    if (
+      payload?.ok !== true ||
+      payload?.agent !== agent ||
+      server?.command !== "node" ||
+      !Array.isArray(server?.args) ||
+      !server.args[0]?.endsWith("mcp/server.js") ||
+      env.YUNTI_BROWSER_BRIDGE_PORT !== "48887" ||
+      payload?.bridge?.tokenEnv !== "YUNTI_BROWSER_BRIDGE_TOKEN" ||
+      !String(payload?.skill?.sourcePath || "").endsWith("skills/yunti-browser-runtime")
+    ) {
+      console.error("print-config smoke check failed:")
+      console.error(`- agent: ${agent}`)
+      console.error(`- unexpected payload: ${JSON.stringify(payload, null, 2)}`)
+      return false
+    }
+  }
+
+  const human = spawnSync(
+    process.execPath,
+    ["scripts/print-config.js", "--agent", "codex", "--human"],
+    {
+      cwd: rootDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env,
+    }
+  )
+  if (
+    human.status !== 0 ||
+    !human.stdout.includes("Yunti Browser Runtime MCP config for codex") ||
+    !human.stdout.includes("YUNTI_BROWSER_BRIDGE_TOKEN") ||
+    !human.stdout.includes("skills/yunti-browser-runtime")
+  ) {
+    console.error("print-config smoke check failed:")
+    console.error(`- human exit code: ${human.status}`)
+    console.error(`- human stdout: ${human.stdout.trim() || "(empty)"}`)
+    console.error(`- human stderr: ${human.stderr.trim() || "(empty)"}`)
+    return false
+  }
+
+  console.error(`print-config smoke check passed (${agents.length} agents).`)
+  return true
+}
+
+function checkDoctorSmoke() {
+  const result = spawnSync(process.execPath, ["scripts/doctor.js"], {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+  })
+
+  let payload
+  try {
+    payload = JSON.parse(result.stdout || "{}")
+  } catch (error) {
+    console.error("doctor smoke check failed:")
+    console.error(`- JSON parse error: ${error.message}`)
+    console.error(`- stdout: ${result.stdout.trim() || "(empty)"}`)
+    console.error(`- stderr: ${result.stderr.trim() || "(empty)"}`)
+    return false
+  }
+
+  const checks = payload?.checks || {}
+  if (
+    !payload?.checkedAt ||
+    checks.node?.ok !== true ||
+    checks.node?.required !== ">=22" ||
+    checks.mcpServer?.ok !== true ||
+    !String(checks.mcpServer?.path || "").endsWith("mcp/server.js") ||
+    checks.skill?.ok !== true ||
+    !String(checks.skill?.path || "").endsWith("skills/yunti-browser-runtime/SKILL.md") ||
+    typeof checks.bridge?.reachable !== "boolean" ||
+    checks.bridge?.tokenHeader !== "x-yunti-browser-token" ||
+    !Array.isArray(payload?.nextSteps)
+  ) {
+    console.error("doctor smoke check failed:")
+    console.error(`- unexpected payload: ${JSON.stringify(payload, null, 2)}`)
+    return false
+  }
+
+  console.error(
+    `doctor smoke check passed (bridge ${checks.bridge.reachable ? "reachable" : "not reachable"}).`
+  )
+  return true
+}
+
+function run(command, args) {
+  console.error(`\n$ ${[command, ...args].join(" ")}`)
+  const result = spawnSync(command, args, {
+    cwd: rootDir,
+    stdio: "inherit",
+    env: process.env,
+  })
+  return result.status === 0
+}
+
+function checkPackageContents() {
+  const requiredFiles = [
+    "README.md",
+    "LICENSE",
+    "package.json",
+    "bin/yunti-browser-runtime.js",
+    "mcp/server.js",
+    "mcp/http-server.js",
+    "mcp/bridge-hub.js",
+    "mcp/tools.js",
+    "extension/manifest.json",
+    "extension/background.js",
+    "extension/content.js",
+    "extension/cdp.js",
+    "extension/session-manager.js",
+    "extension/tool-handlers.js",
+    "skills/yunti-browser-runtime/SKILL.md",
+    "docs/INSTALL.md",
+    "docs/RELEASE.md",
+    "docs/PUBLISHING_BLOCKERS.md",
+    "scripts/check-package-metadata.js",
+    "scripts/check-published-package.js",
+    "scripts/release-check.js",
+  ]
+
+  console.error("\n$ npm pack --json --dry-run")
+  const result = spawnSync("npm", ["pack", "--json", "--dry-run"], {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "inherit"],
+    env: process.env,
+  })
+  if (result.status !== 0) return false
+
+  let payload
+  try {
+    payload = JSON.parse(result.stdout || "[]")
+  } catch (error) {
+    console.error(`npm pack JSON parse failed: ${error.message}`)
+    return false
+  }
+
+  const pack = Array.isArray(payload) ? payload[0] : null
+  const packedFiles = new Set(
+    Array.isArray(pack?.files) ? pack.files.map((file) => file.path) : []
+  )
+  const missing = requiredFiles.filter((file) => !packedFiles.has(file))
+  if (missing.length) {
+    console.error("Required npm package contents check failed:")
+    for (const file of missing) console.error(`- missing ${file}`)
+    return false
+  }
+
+  console.error(
+    `Required npm package contents check passed (${packedFiles.size} files).`
+  )
+  return true
+}
+
+function listZipEntries(zipPath) {
+  const data = readFileSync(zipPath)
+  let eocdOffset = -1
+  for (let i = data.length - 22; i >= 0; i -= 1) {
+    if (data.readUInt32LE(i) === 0x06054b50) {
+      eocdOffset = i
+      break
+    }
+  }
+  if (eocdOffset < 0) {
+    throw new Error(`ZIP end of central directory not found: ${zipPath}`)
+  }
+
+  const entryCount = data.readUInt16LE(eocdOffset + 10)
+  const centralDirectoryOffset = data.readUInt32LE(eocdOffset + 16)
+  const entries = []
+  let offset = centralDirectoryOffset
+
+  for (let i = 0; i < entryCount; i += 1) {
+    if (data.readUInt32LE(offset) !== 0x02014b50) {
+      throw new Error(`Invalid ZIP central directory entry at offset ${offset}`)
+    }
+    const nameLength = data.readUInt16LE(offset + 28)
+    const extraLength = data.readUInt16LE(offset + 30)
+    const commentLength = data.readUInt16LE(offset + 32)
+    const name = data
+      .subarray(offset + 46, offset + 46 + nameLength)
+      .toString("utf8")
+    if (name && !name.endsWith("/")) entries.push(name)
+    offset += 46 + nameLength + extraLength + commentLength
+  }
+
+  return entries
+}
+
+function checkExtensionZipContents() {
+  console.error("\n$ node scripts/package-extension.js")
+  const result = spawnSync("node", ["scripts/package-extension.js"], {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "inherit"],
+    env: process.env,
+  })
+  if (result.status !== 0) return false
+
+  let payload
+  try {
+    payload = JSON.parse(result.stdout || "{}")
+  } catch (error) {
+    console.error(`extension package JSON parse failed: ${error.message}`)
+    return false
+  }
+
+  const zipPath = payload?.zipPath
+  if (!zipPath || !statSync(zipPath, { throwIfNoEntry: false })?.isFile()) {
+    console.error(`extension zip was not created: ${zipPath || "(missing zipPath)"}`)
+    return false
+  }
+
+  let entries
+  try {
+    entries = listZipEntries(zipPath)
+  } catch (error) {
+    console.error(error.message)
+    return false
+  }
+
+  const expected = new Set(requiredExtensionZipFiles)
+  const actual = new Set(entries)
+  const missing = requiredExtensionZipFiles.filter((file) => !actual.has(file))
+  const unexpected = entries.filter((file) => !expected.has(file))
+
+  if (missing.length || unexpected.length) {
+    console.error("Extension zip contents check failed:")
+    for (const file of missing) console.error(`- missing ${file}`)
+    for (const file of unexpected) console.error(`- unexpected ${file}`)
+    return false
+  }
+
+  console.error(
+    `Extension zip contents check passed (${entries.length} files).`
+  )
+  return true
+}
+
+let ok = checkPublicDocResidue()
+ok = checkMarkdownLinks() && ok
+ok = checkVersionConsistency() && ok
+ok = checkCliSmoke() && ok
+ok = checkPrintConfigSmoke() && ok
+ok = checkDoctorSmoke() && ok
+ok = run("npm", ["run", "check"]) && ok
+ok = run("npm", ["test"]) && ok
+ok = checkPackageContents() && ok
+ok = checkExtensionZipContents() && ok
+
+if (!ok) process.exitCode = 1

package/skills/yunti-browser-runtime/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: yunti-browser-runtime
+description: Use when an agent needs to operate or inspect a user's browser through Yunti Browser Runtime MCP tools, including viewing pages, switching tabs, clicking, typing, screenshots, network or console logs, CDP commands, browser target inventory, or recovering stale browserSessionId routes.
+---
+
+# Yunti Browser Runtime
+
+## First Step
+
+For any browser task, first call `yunti_get_tool_usage_hints` unless the user is only asking a conceptual question.
+
+Then call `yunti_list_browser_targets` to understand the live browser state before choosing a page or tab.
+
+## Routing Rules
+
+- Treat `yunti_list_browser_targets` as the canonical live browser inventory.
+- Keep the returned `browserSessionId` for follow-up page and CDP calls.
+- If a stored `browserSessionId` fails or appears stale, call `yunti_list_browser_targets` again and retry with the latest route.
+- Stale-session errors include a reason and recovery hint; do not keep retrying the expired id.
+- New tabs may return a new `browserSessionId`; use that returned value for follow-up actions on the new tab.
+- Do not use raw `tabId` or `targetId` as a replacement for `browserSessionId`.
+- Local standalone mode defaults to `userId=local`; do not add `userId` unless the environment explicitly needs a different route user.
+
+## Tool Choice
+
+- Use `yunti_get_page_snapshot` for lightweight page text, title, URL, selected text, and page state.
+- Use `yunti_take_snapshot` before uid-based clicks, fills, or hovers.
+- Use `yunti_click`, `yunti_fill`, `yunti_hover`, `yunti_press_key`, and `yunti_type_text` for normal page actions.
+- Use `yunti_take_screenshot` for visual verification.
+- Use `yunti_list_browser_targets` for tab counts, tab selection, target IDs, and whole-browser awareness.
+- Use `yunti_cdp_send_command` for Chrome DevTools Protocol commands.
+- Use `yunti_list_network_requests`, `yunti_get_network_log`, and `yunti_get_network_request` for network diagnostics.
+- Use `yunti_list_console_messages` and `yunti_get_console_message` for console diagnostics.
+- Use `yunti_get_tool_usage_hints` before retrying a failed or uncertain tool call.
+
+## CDP Rules
+
+- Never run CDP method names in a terminal or shell.
+- Always call CDP through `yunti_cdp_send_command`.
+- `yunti_cdp_send_command` requires `method`; `params` is optional but must be an object when provided.
+- Required CDP shape:
+
+```json
+{
+  "browserSessionId": "yunti-...",
+  "method": "Runtime.evaluate",
+  "params": {
+    "expression": "document.title",
+    "returnByValue": true
+  }
+}
+```
+
+- For tab activation or closing, pass top-level `tabId` or `targetId` with a valid `browserSessionId`.
+- For multi-step JavaScript work that depends on page-local state, prefer one `Runtime.evaluate` expression that performs setup, action, wait, and readback in one call.
+
+## Parameter Rules
+
+- `yunti_click` and `yunti_hover` need `uid`, `selector`, or both `x` and `y`; call `yunti_take_snapshot` first when possible.
+- `yunti_fill` requires `value` plus `uid` or `selector`; coordinate-only fill is not supported.
+- `yunti_close_page` accepts `browserSessionId`, not raw `tabId` or `targetId`; use `yunti_cdp_send_command` with `Target.closeTarget` for raw browser targets.
+- `yunti_forget_learning_memory` needs a memory `id`, or `all=true` and `confirmed=true` for deleting everything.
+
+## Safety
+
+- Read-only inspection is allowed by default.
+- Before submitting forms, deleting data, uploading sensitive files, approving workflows, making purchases, or changing production data, ask the user for explicit confirmation.
+- Do not expose raw cookies, passwords, authorization headers, or token-like values.
+- If a tool output appears to include sensitive data, summarize only the safe parts.
+
+## Recovery
+
+- No connected tab: ask the user to open a page, load the extension, or refresh the page.
+- Stale session: call `yunti_list_browser_targets` and use the latest `browserSessionId`.
+- Wrong tab: use `yunti_list_browser_targets` to find the intended tab, then route CDP with that tab's `tabId` or `targetId`.
+- Parameter uncertainty: call `yunti_get_tool_usage_hints` with the specific tool name.
+- Missing memory id: call `yunti_get_learning_memory` first, then retry with a returned `id`.