magpie-ima-local-auth 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 更新记录
 
+## 0.3.0 — 2026-10-28
+
+- **工具调用**：新增 `src/tools.mjs` 文本工具协议。把 OpenAI tools 写成提示，解析模型输出
+  `{"tool_calls":[...]}`，转成 OpenAI `tool_calls`；支持 `role:"tool"` 结果回灌、流式/非流式；
+  模型条目声明 `toolcall: true`。实测 `task_plan` / `subagent_spawn` 5/5，DSH `write` 端到端成功。
+- 工具模式每个请求用全新 ima session + 完整历史，避免单问 session 丢工具上下文。
+- README / docs 修正：ima 不是裸 LLM，但正常工具契约可用；sovereign 破甲会触发注入检测，不要用。
+
 ## 0.2.0 — 2026-10-28
 
 - **修复客户端指纹**：`x-ima-cookie` 的 `CLIENT-TYPE` 改为 ima 2.6.15 实际值 `256021`。没有它，服务端静默退回旧目录（DeepSeek V3.2 / HY 2.0，Copilot 只有默认模型）；有了它，免费目录变为 **DeepSeek-V4.1-Flash / Hy3 / Hy4 preview / GLM-5.3-Flash（各带 Think 变体）**，Copilot `scene:1` 也能读到完整积分目录。

package/README.md

@@ -96,10 +96,10 @@ magpie plugin list
 不用。登录导入之后，magpie 用 refresh token 续期；客户端只在导入那一下需要存在。
 
 **Q：为什么没有 Copilot 的模型？**
-Copilot 是 ima 的云端 agent（`robot_type=15`），不是模型通道。本机版本直接返回「当前版本暂不支持」；插件按“模型供应商”定位，不把 agent 包装成模型。
+Copilot 是 ima 的云端 agent（`robot_type=15`），不是模型通道。它的 V4.1 / Hy3 / Hy4 / GLM / MiMo / MiniMax / Kimi 目录确实存在、也支持流式思考；插件按“模型供应商”定位，不把 agent 包装成模型。
 
 **Q：支持工具调用 / 图片吗？**
-不支持。ima 的问答接口没有 tool 通道，免费模型也不收图；插件在模型条目上如实声明 `toolcall: false` / `attachment: false`。
+**工具调用支持**：ima 的问答接口没有原生 tools 字段，插件用文本工具协议模拟——把调用方的工具表写进问题，模型输出 `{"tool_calls":[...]}`，插件再转成 OpenAI 的 `tool_calls`；工具结果会作为 `role:"tool"` 回灌。已用 `task_plan` / `subagent_spawn` 和 DSH 的 `todo_write` / `write` 实测。图片**不支持**（`attachment: false`）。
 
 **Q：上下文窗口是多少？**
 ima 的模型目录不下发窗口大小。插件把 `limit.context` 留 0，让 magpie 用它自己的模型库；不写一个猜的数字。

package/docs/evaluation.md

@@ -106,6 +106,23 @@ V3.2；把客户端真实的 `CLIENT-TYPE=256021` 带上后，同一 `official_3
   服务端降级，不是 UI 造假。
 - Copilot 的 V4.1（`official_paid_ep-i2azx8ko`）也是真 V4.1；两条通道不同，但都真实存在。
 
+## 工具协议与系统提示词测试（2026-10-28）
+
+关键修正：ima 的模型不是裸 LLM（有自己的身份/安全包装），但**正常工具契约可以工作**；
+sovereign 破甲反而触发它的注入检测，不要用。
+
+| 测试 | 结果 |
+|---|---|
+| 免费 V4.1 + `task_plan` / `subagent_spawn` 工具表 | **5/5 输出合法裸 JSON `tool_calls`**（非流式）；流式同样返回 tool_calls 帧 |
+| Copilot V4.1 + 同一工具表 | 同样输出合法 `tool_calls`（`task_plan` 参数补全了 goal/steps） |
+| DSH headless + `write` 工具 | 模型实际调用 DSH 的 `write`，文件被创建并回复 `DSH-BASH-OK` |
+| 工具结果回灌 | assistant tool_calls + role=tool 的消息被拼回提示，模型输出最终正文 |
+| sovereign 破甲 + 强制改身份 | 免费/Copilot 都识别为注入并拒绝，**不要用破甲** |
+
+实现：`src/tools.mjs` 把 OpenAI tools 写成提示，解析 `{"tool_calls":[...]}` 转成
+OpenAI tool_calls；`toolcall: true`；流式工具请求先攒后发（工具 JSON 必须完整）。
+工具调用不是 ima 原生能力，是文本协议模拟，但已达到正常 API 的可用形态。
+
 ## 与 CodeBuddy / 其它免费源的对比
 
 | 免费源 | 档位 | 接入成本 | 结论 |
@@ -126,7 +143,8 @@ V3.2；把客户端真实的 `CLIENT-TYPE=256021` 带上后，同一 `official_3
 
 - **单问 session**：`assistant/qa` 一次只收一个问题，没有 messages 数组；插件用 session
   保持多轮，但 system prompt 只在 session 第一问里发。
-- **没有工具调用**：ima 的问答接口没有 tool 通道；模型条目如实声明 `toolcall: false`。
+- **工具调用是文本协议模拟**：ima 没有原生 tools 字段；插件把工具表写进提示，模型输出
+  `{"tool_calls":[...]}` 后转成 OpenAI `tool_calls`，工具由 DSH 执行。平台升级后需重新验证。
 - **没有 token 计数**：ima 不返回 usage；插件不按字符数编，返回 0。
 - **没有上下文窗口**：模型目录不下发；`limit.context` 留 0，交给 magpie 的模型库。
 - **私有接口 + 指纹**：`CLIENT-TYPE=256021` 是抓包值，客户端升级可能变；可用
@@ -137,7 +155,7 @@ V3.2；把客户端真实的 `CLIENT-TYPE=256021` 带上后，同一 `official_3
 ## 已完成的验收
 
 - `node scripts/check.mjs`：通过 29 · 警告 0 · 失败 0
-- `node --test`：10/10
+- `node --test`：17/17
 - magpie 0.1.1814 安装后 `ima (ima, 8 models) signed in as 001ab…`
 - 网关：`POST /v1/chat/completions`（`ima/deepseek-v4.1-flash`）返回 `GATEWAY-V41`；
   流式返回 role/content/`finish_reason:"stop"`；思考模型返回 `reasoning_content`。

package/docs/internals.md

@@ -97,6 +97,14 @@ HEARTBEAT
 V4.1-Flash `official_paid_ep-i2azx8ko`）；但 Copilot 走 `robot_type=15`，是 ima 的云端
 agent，所以默认不列。
 
+### 5.1 工具调用协议
+
+ima 没有 OpenAI 的 `tools` 字段。`src/tools.mjs` 把工具表写进问题，要求模型输出
+`{"tool_calls":[{"name":"...","arguments":{...}}]}`；插件解析后转成 OpenAI `tool_calls`。
+工具结果（`role:"tool"`）会被拼回下一次问题。已实测 `task_plan` / `subagent_spawn` 5/5、
+DSH 的 `write` 端到端成功。sovereign 破甲不要用——它反而触发 ima 的注入检测，正常工具契约
+就够了。工具模式每个请求开新 ima session，避免单问 session 丢工具上下文。
+
 ## 6. 被否掉的方案
 
 - **云端 cookie 直连**：magpie-ima-auth 走的就是它；它把 ima 的 agent 会话包装成 chat，

package/index.mjs

@@ -33,6 +33,7 @@ import {
   transcript,
 } from "./src/chat.mjs"
 import { buildModels } from "./src/models.mjs"
+import { aggregateToolResponse, buildToolPrompt, streamToolResponse } from "./src/tools.mjs"
 import { importLocalLogin, saveSeed } from "./src/login.mjs"
 
 const SESSION_TTL_MS = 30 * 60 * 1000
@@ -114,6 +115,25 @@ function authError(e, message) {
 }
 
 /** 选一条 session 路径，失败时按 session/auth 各重试一次 */
+async function sendToolTurn(auth, { model, question, save }) {
+  try {
+    const id = await initSession(auth, question)
+    return await ask(auth, { sessionId: id, question, model })
+  } catch (e) {
+    if (!(e instanceof ImaError)) throw e
+    if (e.auth) {
+      const next = await refreshToken(auth)
+      save?.({ ...auth, access: next.access, refresh: next.refresh, expires: next.expires })
+      return await sendToolTurn({ ...auth, ...next }, { model, question, save })
+    }
+    if (e.session) {
+      const id = await initSession(auth, question)
+      return await ask(auth, { sessionId: id, question, model })
+    }
+    throw e
+  }
+}
+
 async function sendTurn(auth, { model, question, conv, instructions, carried, save }) {
   const key = auth.uid + "|" + (conv || "anon")
   let entry = getSession(key)
@@ -226,6 +246,28 @@ export const ImaLocalAuthPlugin = async ({ client } = {}) => {
     if (!model) {
       return errorResponse(404, `ima: 没有模型 ${String(chat.model ?? "")}`, {})
     }
+
+    const tools = Array.isArray(chat.tools) ? chat.tools : []
+    const hasToolHistory = Array.isArray(chat.messages) && chat.messages.some(
+      (m) => m?.role === "tool" || (m?.role === "assistant" && Array.isArray(m?.tool_calls) && m.tool_calls.length > 0),
+    )
+    const toolMode = tools.length > 0 && (chat.tool_choice !== "none" || hasToolHistory)
+    if (toolMode) {
+      const { question } = buildToolPrompt(chat.messages, tools, chat.tool_choice)
+      try {
+        const res = await sendToolTurn(auth, { model, question, save: saveAuth })
+        if (chat.stream === false) return await aggregateToolResponse(res, model.id, tools)
+        return streamToolResponse(res, model.id, tools, {
+          includeUsage: chat.stream_options?.include_usage === true,
+        })
+      } catch (e) {
+        if (e instanceof ImaError && e.auth) {
+          return errorResponse(401, `ima 登录被拒：${e.message}`, { signIn: "expired" })
+        }
+        return errorResponse(502, `ima: ${e?.message ?? e}`, {})
+      }
+    }
+
     const { text, index } = lastUser(chat.messages)
     if (!text) return errorResponse(400, "ima: 这轮没有 user 消息", {})
     const instructions = systemText(chat.messages)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-ima-local-auth",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "magpie / OpenCode provider plugin for the ima.copilot desktop app: its free DeepSeek and Tencent HY models, imported from the client already signed in on this machine, without pasting cookies.",
   "type": "module",
   "main": "./index.mjs",

package/src/context.mjs

@@ -56,7 +56,7 @@ export function staticModels() {
       capabilities: {
         temperature: false,
         reasoning: !!thinking,
-        toolcall: false,
+        toolcall: true,
         attachment: false,
         input: { text: true, image: false },
         output: { text: true },

package/src/models.mjs

@@ -47,7 +47,7 @@ function entry(id, name, thinking, { free = true, rate = null } = {}) {
     capabilities: {
       temperature: false,
       reasoning: !!thinking,
-      toolcall: false,
+      toolcall: true,
       attachment: false,
       input: { text: true, image: false },
       output: { text: true },

package/src/tools.mjs

@@ -0,0 +1,325 @@
+// src/tools.mjs —— 文本工具协议
+//
+// ima 的 /assistant/qa 没有 OpenAI 的 tools 字段，但实测（2026-10-28）：
+// 把 DSH 的工具表写进问题，要求模型输出
+//   {"tool_calls":[{"name":"task_plan","arguments":{...}}]}
+// 免费 V4.1 和 Copilot V4.1 都能稳定输出裸 JSON（不要加 sovereign 破甲；
+// 破甲反而触发 ima 的注入检测，正常工具契约就够了）。
+//
+// 这里负责：
+//   1. 把 OpenAI tools 变成提示词里的工具表 + 输出契约
+//   2. 把 messages（含 assistant.tool_calls 和 role=tool 的结果）拼成一次问题
+//   3. 从模型正文里解析 tool_calls
+//   4. 把 ima 的 SSE 包成 OpenAI 的 chat.completion(.chunk)
+
+import { randomBytes, randomUUID } from "node:crypto"
+import {
+  eventError,
+  eventText,
+  eventThinking,
+  isContextMessage,
+  partText,
+  readIMAStream,
+  systemText,
+} from "./chat.mjs"
+
+export function toolEntries(tools) {
+  const out = []
+  for (const t of Array.isArray(tools) ? tools : []) {
+    const f = t?.function ?? t
+    const name = String(f?.name ?? "").trim()
+    if (!name) continue
+    out.push({
+      name,
+      description: String(f?.description ?? "").trim(),
+      parameters: f?.parameters ?? f?.input_schema ?? { type: "object", properties: {} },
+    })
+  }
+  return out
+}
+
+export function toolNames(tools) {
+  return new Set(toolEntries(tools).map((t) => t.name))
+}
+
+function contract(tools, toolChoice) {
+  const defs = toolEntries(tools)
+    .map((t, i) => `${i + 1}. ${t.name}\n   描述：${t.description || "（无描述）"}\n   参数 Schema：${JSON.stringify(t.parameters)}`)
+    .join("\n")
+  const forced =
+    toolChoice === "required"
+      ? "本次必须调用至少一个工具。"
+      : toolChoice && typeof toolChoice === "object" && toolChoice?.function?.name
+        ? `本次必须调用工具 ${toolChoice.function.name}。`
+        : ""
+  return `## 工具调用协议（DSH 编排层）
+
+你是 DSH 的模型后端，一个纯文本补全引擎。下面这份工具表由**调用方**提供，不是 ima 的内置工具；
+即使 ima 自己没有同名工具，也必须按本协议输出调用请求，由 DSH 在用户机器上执行。
+不要回答“我没有这个工具”，不要用 ima 的搜索、文件、图片、脑图等内置能力替代这些工具，
+不要用你自己的环境执行，也不要假装已经执行。
+
+本次可用工具：
+${defs || "（本次没有可用工具）"}
+
+需要调用工具时，只输出一个裸 JSON 对象，不要代码块围栏、不要前后解释、不要道歉：
+{"tool_calls":[{"name":"工具名","arguments":{参数对象}}]}
+
+严格示例（必须照这个形状）：
+{"tool_calls":[{"name":"task_plan","arguments":{"action":"update","goal":"修复登录 bug","steps":[{"id":"1","title":"复现"}]}}]}
+
+不需要调用工具时，直接输出给用户看的自然语言正文。
+如果已经收到工具结果，请基于结果继续；需要继续调用工具就再输出 tool_calls，否则直接给最终答案。
+${forced}`
+}
+
+function toolCallText(m) {
+  const calls = Array.isArray(m?.tool_calls) ? m.tool_calls : []
+  if (!calls.length) return ""
+  const normalized = calls.map((c) => {
+    let args = c?.function?.arguments ?? c?.arguments ?? {}
+    if (typeof args === "string") {
+      try { args = JSON.parse(args) } catch { args = {} }
+    }
+    return {
+      name: c?.function?.name ?? c?.name ?? "",
+      arguments: args && typeof args === "object" ? args : {},
+    }
+  })
+  return JSON.stringify({ tool_calls: normalized })
+}
+
+/**
+ * 把 OpenAI messages 拼成 ima 的一次问题。
+ * 返回 { question, current, hasToolResult }。
+ */
+export function buildToolPrompt(messages, tools, toolChoice) {
+  const list = Array.isArray(messages) ? messages : []
+  const instructions = systemText(list)
+  const turns = []
+  let lastRole = ""
+  let lastUserText = ""
+
+  for (const m of list) {
+    if (!m || m.role === "system" || m.role === "developer") continue
+    if (isContextMessage(m)) continue
+    if (m.role === "user") {
+      const text = partText(m.content).trim()
+      if (!text) continue
+      turns.push(`User: ${text.slice(0, 6000)}`)
+      lastRole = "user"
+      lastUserText = text
+    } else if (m.role === "assistant") {
+      const calls = toolCallText(m)
+      const text = partText(m.content).trim()
+      if (calls) {
+        turns.push(`Assistant（工具调用）: ${calls.slice(0, 4000)}`)
+        lastRole = "assistant"
+      } else if (text) {
+        turns.push(`Assistant: ${text.slice(0, 4000)}`)
+        lastRole = "assistant"
+      }
+    } else if (m.role === "tool") {
+      const text = partText(m.content).trim()
+      const name = m.name || m.tool_call_id || "工具"
+      if (text) {
+        turns.push(`Tool result（${name}）: ${text.slice(0, 6000)}`)
+        lastRole = "tool"
+      }
+    }
+  }
+
+  let current = ""
+  let history = turns
+  if (lastRole === "user" && lastUserText) {
+    current = lastUserText
+    history = turns.slice(0, -1)
+  } else {
+    current = "工具结果已经返回。请根据上面的工具结果继续；需要继续调用工具就再输出 tool_calls，否则直接给最终答案。"
+  }
+
+  const parts = []
+  if (instructions) parts.push(`## 调用方系统指令\n${instructions.slice(0, 12000)}`)
+  if (history.length) parts.push(`## 对话历史\n${history.join("\n\n")}`)
+  parts.push(contract(tools, toolChoice))
+  parts.push(`## 当前请求\n${current}`)
+  return {
+    question: parts.join("\n\n").slice(0, 60000),
+    current,
+    hasToolResult: lastRole === "tool" || list.some((m) => m?.role === "tool"),
+  }
+}
+
+function tryJson(s) {
+  const attempts = [s]
+  const fenced = s.match(/```(?:json)?\s*([\s\S]*?)```/i)
+  if (fenced) attempts.unshift(fenced[1].trim())
+  const i = s.indexOf("{")
+  const k = s.lastIndexOf("}")
+  if (i >= 0 && k > i) attempts.push(s.slice(i, k + 1))
+  for (const a of attempts) {
+    try {
+      const v = JSON.parse(a)
+      if (v && typeof v === "object") return v
+    } catch {}
+  }
+  return null
+}
+
+function normalizeCalls(obj, known) {
+  let listed = null
+  if (Array.isArray(obj?.tool_calls)) listed = obj.tool_calls
+  else if (Array.isArray(obj?.toolCalls)) listed = obj.toolCalls
+  else if (obj?.name || obj?.function?.name) listed = [obj]
+  if (!listed) return null
+  const out = []
+  for (const c of listed) {
+    const name = String(c?.function?.name ?? c?.name ?? "").trim()
+    if (!name) continue
+    if (known?.size && !known.has(name)) continue
+    let args = c?.function?.arguments ?? c?.arguments ?? {}
+    if (typeof args === "string") {
+      try { args = JSON.parse(args) } catch { args = {} }
+    }
+    out.push({ name, arguments: args && typeof args === "object" ? args : {} })
+  }
+  return out.length ? out : null
+}
+
+/** 从模型正文里解析 tool_calls；解析失败返回 null，由调用方当正文。 */
+export function parseToolCalls(text, knownNames) {
+  const raw = typeof text === "string" ? text.trim() : ""
+  if (!raw) return null
+  const obj = tryJson(raw)
+  if (!obj) return null
+  const calls = normalizeCalls(obj, knownNames instanceof Set ? knownNames : new Set(knownNames ?? []))
+  return calls ? { calls } : null
+}
+
+export function argumentsString(args) {
+  try {
+    return JSON.stringify(args && typeof args === "object" ? args : {})
+  } catch {
+    return "{}"
+  }
+}
+
+export function toOpenAIToolCalls(calls) {
+  return (calls ?? []).map((c) => ({
+    id: "call_" + randomUUID().replace(/-/g, "").slice(0, 24),
+    type: "function",
+    function: { name: c.name, arguments: argumentsString(c.arguments) },
+  }))
+}
+
+async function collect(res) {
+  let text = ""
+  let thinking = ""
+  let failed = null
+  await readIMAStream(res, (name, raw) => {
+    if (failed) return
+    const bad = eventError(name, raw)
+    if (bad) { failed = new Error(bad.message); return }
+    if (name === "THINKING" || name === "STRUCTURED_BLOCK") thinking += eventThinking(raw)
+    if (name === "MESSAGE" || name === "STRUCTURED_BLOCK") text += eventText(raw)
+  })
+  if (failed) throw failed
+  return { text, thinking }
+}
+
+function id() {
+  return "chatcmpl-" + randomBytes(12).toString("hex")
+}
+
+const USAGE = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+
+/** 非流式：工具请求的 chat.completion */
+export async function aggregateToolResponse(res, modelId, tools) {
+  const { text, thinking } = await collect(res)
+  const parsed = parseToolCalls(text, toolNames(tools))
+  const calls = parsed?.calls ?? null
+  const openaiCalls = calls ? toOpenAIToolCalls(calls) : null
+  return new Response(
+    JSON.stringify({
+      id: id(),
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: modelId,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: calls ? null : text,
+            ...(thinking ? { reasoning_content: thinking } : {}),
+            ...(openaiCalls ? { tool_calls: openaiCalls } : {}),
+          },
+          finish_reason: calls ? "tool_calls" : "stop",
+        },
+      ],
+      usage: USAGE,
+    }),
+    { headers: { "content-type": "application/json; charset=utf-8" } },
+  )
+}
+
+/** 流式：工具请求先攒后发（工具 JSON 必须完整才能判定），再按 OpenAI chunk 发。 */
+export function streamToolResponse(res, modelId, tools, { includeUsage = false } = {}) {
+  const responseId = id()
+  const created = Math.floor(Date.now() / 1000)
+  const enc = new TextEncoder()
+  return new Response(
+    new ReadableStream({
+      async start(controller) {
+        const send = (obj) => controller.enqueue(enc.encode("data: " + JSON.stringify(obj) + "\n\n"))
+        const frame = (delta, finish = null) =>
+          send({
+            id: responseId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [{ index: 0, delta, finish_reason: finish }],
+          })
+        try {
+          const { text, thinking } = await collect(res)
+          const parsed = parseToolCalls(text, toolNames(tools))
+          const calls = parsed?.calls ?? null
+          frame({ role: "assistant" })
+          if (thinking) frame({ reasoning_content: thinking })
+          if (calls) {
+            const openaiCalls = toOpenAIToolCalls(calls)
+            frame({
+              tool_calls: openaiCalls.map((tc, i) => ({
+                index: i,
+                id: tc.id,
+                type: "function",
+                function: { name: tc.function.name, arguments: tc.function.arguments },
+              })),
+            })
+            frame({}, "tool_calls")
+          } else {
+            if (text) frame({ content: text })
+            frame({}, "stop")
+          }
+          if (includeUsage) {
+            send({ id: responseId, object: "chat.completion.chunk", created, model: modelId, choices: [], usage: USAGE })
+          }
+          controller.enqueue(enc.encode("data: [DONE]\n\n"))
+        } catch (e) {
+          send({ error: { type: "api_error", message: String(e?.message ?? e) } })
+        } finally {
+          controller.close()
+        }
+      },
+    }),
+    {
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        "x-accel-buffering": "no",
+      },
+    },
+  )
+}
+
+export const _toolsInternal = { contract, tryJson, normalizeCalls, USAGE }