finch-multi-agent 0.1.0

package/i18n/en-US.json

@@ -0,0 +1,88 @@
+{
+  "name": "Multi-Agent",
+  "description": "Split one goal into parallel sub-agent Sessions that hand results over as immutable artifacts instead of chat messages.",
+  "systemPrompt": "Use multi_agent_run when a request is genuinely decomposable into independent, low-bandwidth subtasks — research fan-out, multi-module review, batch processing, parallel drafting. Do not use it for small tasks, tightly coupled work, or anything needing low-latency back-and-forth. From the user's side there are only two steps — ask, then get the answer — so keep dispatching, executing and waiting inside one continuous chain of calls, and never narrate the mechanics or ask whether to keep waiting. Name every subtask as \"<role> · <what it is doing>\" (e.g. \"Competitor research · price the top three\") — that string becomes the worker's session title. To wait for a result, call wait (repeatedly if needed); never sleep and never poll with status. When the user changes direction mid-run, use revise to stop the affected tasks and queue replacements in the same run — do not start a new one.",
+  "tool.title": "Multi-Agent Run",
+  "tool.description": "Run a job as a team of parallel sub-agent Sessions: one worker per subtask, each in its own context, handing results over as immutable artifacts instead of chat messages.\n\n**From the user's side there are only two steps: ask, then get the answer.** Dispatching, executing and waiting all happen inside one continuous chain of calls — do not narrate the mechanics and do not ask whether you should keep waiting. Report once, when you have the result.\n\naction:\n  dispatch — start a run. Pass goal plus 2-12 tasks; each task becomes its own Session. This call waits up to 540s by default and streams live progress on the tool card.\n  wait     — keep waiting on a run that is already going (pass runId; up to another 540s). Call it when dispatch hit its budget; call it repeatedly if needed.\n  revise   — use this when the user changes direction mid-run. `cancel` lists the task ids to stop; `tasks` lists new or replacement subtasks (**reusing an id replaces that task**, and anything depending on it picks up the new result). The rest of the run keeps going, then this call keeps waiting.\n  status   — one-shot snapshot, no waiting. Use it when the user asks how it is going.\n  collect  — read the finished deliverables (artifact text plus the handoff graph) so you can write the final answer.\n  cancel   — cancel one task or an entire run.\n  list     — list recent runs of this session (or all runs).\n  models   — list the models this user actually has enabled (with `provider:model` keys, provider, and whether each is fast / supports thinking). Call it before honouring a model the user named.\n\nWaiting (important):\n- Waiting happens inside the tool: dispatch, wait and revise watch those worker Sessions themselves and refresh progress every few seconds. So do not sleep, and do not call status in a loop to poll.\n- Whenever the run is not finished and you want the result, call wait — you may call it repeatedly. Do not stop and ask the user.\n- The user interrupting a wait is not a failure — it usually means they want a different direction. Do NOT start a new run: read what they said, then use revise to stop the affected tasks and queue the replacements.\n\nTask titles (important):\n- Every task title must read as \"<role> · <what it is doing>\", in the user's language.\n- Good: \"竞品调研 · 摸清三家定价\" / \"Reviewer · audit the auth module\" / \"翻译 · 处理第 3-6 页\".\n- Bad: \"定价情况\" / \"Task A\" / \"MCP 协议生态现状\" — a bare topic noun says nothing about what that worker is doing.\n- The title becomes the worker Session's title, so it is what the user sees in their session list.\n\nHow it works:\n- Decompose the goal yourself. Each task must be independently executable and must produce a self-contained written deliverable.\n- Workers never see this conversation. Their only inputs are their own prompt and any upstream artifact handed to them.\n- Use dependsOn only when a task truly consumes another task's output; the dependency graph must be acyclic and each edge becomes a recorded Handoff.\n- Results never travel as chat messages between workers: every deliverable is published as an immutable Artifact, and the run report is kept as a versioned Document.\n\nModel choice (important):\n- **When the user did not ask for a model, do not pass one** — the app default is the normal case.\n- When they did name one (\"use Opus for the reasoning, something fast for the rest\"), **call action=models first** to get the real list, then pass the matching `provider:model` key as dispatch's `model` (run-wide) or `tasks[].model` (single task). Do not write a model name from memory.\n- For a vague ask (\"the cheap one\", \"something that thinks hard\"), pick using the list's instant / supportsThinking flags and say which one you picked.\n- A request that cannot be matched falls back to the default, and the result says so explicitly (\"请求的 X 没匹配上\") — relay that to the user honestly.\n\nWhen the run finishes:\n- Call collect and synthesise the workers' outputs into the answer; cite the artifacts you used.\n- Report the result, not the process.",
+  "scope.prefix": "Multi-agent run",
+  "progress.scope.1": "Rounding up a crew…",
+  "progress.scope.2": "Splitting the work, handing out assignments…",
+  "progress.scope.3": "Opening a project room…",
+  "progress.running.1": "The crew is at it — {done}/{total} done",
+  "progress.running.2": "{done}/{total} handed in their homework",
+  "progress.running.3": "{running} still typing… ({done}/{total} done)",
+  "progress.running.4": "Chasing the last {remaining} · {done}/{total} done",
+  "progress.running.5": "Everyone is heads-down · {done}/{total} done",
+  "progress.running.6": "Making progress, nothing on fire · {done}/{total} done",
+  "progress.revise.1": "Got it — changing course…",
+  "progress.revise.2": "Dropping the wrong work, re-assigning…",
+  "progress.revise.3": "Swapping in new hands…",
+  "result.goal": "goal",
+  "result.progress": "progress",
+  "result.model": "model",
+  "result.parallel": "parallel",
+  "result.space": "space",
+  "result.labelSession": "session",
+  "result.labelWaiting": "waiting for",
+  "result.labelError": "error",
+  "result.labelDeliverable": "deliverable",
+  "result.appDefaultModel": "app default",
+  "result.noTasks": "Provide 2-12 tasks for action=dispatch.",
+  "result.tooManyTasks": "Too many tasks: the limit is {max} per run.",
+  "result.taskMissingFields": "Task #{index} needs both a title and a prompt.",
+  "result.selfDependency": "Task `{task}` cannot depend on itself.",
+  "result.unknownDependency": "Task `{task}` depends on unknown task `{dep}`.",
+  "result.cycle": "The dependency graph contains a cycle: {chain}",
+  "result.noGoal": "Provide a goal for action=dispatch.",
+  "result.noRun": "No matching run. Pass runId, or dispatch one first.",
+  "result.noRuns": "No multi-agent runs yet.",
+  "result.noTask": "No task `{task}` in that run.",
+  "result.unknownAction": "Unknown action `{action}`. Use dispatch, status, collect, cancel or list.",
+  "result.missingApi": "This Finch version does not expose: {list}. Update Finch to use multi-agent runs.",
+  "result.scopeFailed": "Could not create the collaboration scope: {error}",
+  "result.dispatched.running": "The crew is on it ({runId}) — not everyone is back yet after {seconds}s, so it keeps going in the background.",
+  "result.dispatched.completed": "All done — every worker handed in ({runId}).",
+  "result.dispatched.partial": "Mostly done ({runId}) — a few workers did not make it.",
+  "result.dispatched.failed": "Nobody made it this time ({runId}) — all workers failed.",
+  "result.dispatched.cancelled": "Called it off ({runId}).",
+  "result.nextStatus": "Call multi_agent_run with action=status and runId={runId} for a snapshot, or action=wait to keep waiting for the result.",
+  "result.nextWait": "Some workers are still running: call multi_agent_run with action=wait and runId={runId} to keep waiting inside one call — do not stop and hand it back to the user.",
+  "result.nextCollect": "Call multi_agent_run with action=collect and runId={runId} to read the deliverables.",
+  "result.usingDefaultModel": "No model was requested, so every worker uses the app default model.",
+  "result.collectHeader": "Deliverables for \"{goal}\" ({runId}) — status: {status}",
+  "result.artifactRef": "artifact",
+  "result.handoffGraph": "Handoff graph:",
+  "result.handoffs": "Handoffs:",
+  "result.document": "Versioned document: {id} (revision {revision})",
+  "result.summaryArtifact": "Structured run summary: {id}",
+  "result.notStarted": "not started yet",
+  "result.collectTruncated": "…output truncated; use action=status for the full task list.",
+  "result.allFailed": "every task failed",
+  "result.cancelledByUser": "cancelled by the user",
+  "result.emptyOutput": "(this worker handed in a blank page)",
+  "result.sessionGone": "the worker Session is no longer available",
+  "result.sendFailed": "the task never reached its worker",
+  "result.waitStillRunning": "Waited another {seconds}s — some workers are still out ({runId}).",
+  "result.waitAlreadyDone": "That run already finished ({runId}) — nothing left to wait for.",
+  "result.waitAborted": "The user interrupted the wait ({runId}) — the run keeps going in the background. Call action=wait to keep waiting, or action=revise if they want a new direction.",
+  "result.revised": "interrupted for the new direction",
+  "result.reviseNotRunning": "That run already finished ({runId}) — to change direction, dispatch a new one.",
+  "result.reviseNoop": "revise needs either cancel (task ids to stop) or tasks (new or replacement subtasks).",
+  "result.reviseApplied": "Stopped {cancelled}, queued {added}.",
+  "result.reviseDone": "Course corrected: stopped {cancelled}, queued {added}.",
+  "model.tagInstant": "fast",
+  "model.tagThinking": "supports thinking",
+  "model.tagAlias": "alias {alias}",
+  "model.unmatched": "requested {requested} did not match anything — fell back to the default model",
+  "result.modelsHeader": "{count} models are enabled for this user (grouped by provider):",
+  "result.modelsDefault": "Default worker model: {model}",
+  "result.modelsHowTo": "To pick one: pass its `provider:model` key as dispatch/revise's model (run-wide) or tasks[].model (single task). If the user did not ask for a model, do not pass one.",
+  "result.noModels": "Could not read the available model list.",
+  "result.runList": "{count} recent run(s):",
+  "result.thisSession": " (this session)",
+  "menu.defaultModel": "Default worker model",
+  "menu.appDefault": "Follow app default",
+  "menu.modelCount": "{count} models",
+  "menu.clearRuns": "Clear finished runs",
+  "menu.cleared": "Finished runs cleared"
+}

package/i18n/zh-CN.json

@@ -0,0 +1,88 @@
+{
+  "name": "多智能体",
+  "description": "把一个目标拆成多个并行的子智能体会话，它们用不可变产物交接成果，而不是互相发消息。",
+  "systemPrompt": "当一个请求确实可以拆成独立、低通信带宽的子任务时（并行调研、多模块审查、批量处理、并行起草），使用 multi_agent_run。小任务、强耦合的工作、需要低延迟来回确认的事情不要用它。用户视角只有两步：提问 → 结果，中间的分派/执行/等待都在一次连续调用里完成，不要汇报机械过程、不要问「要我等吗」。每个子任务的标题都写成「角色 · 在做什么」（例如「竞品调研 · 摸清三家定价」），它就是 worker 会话的标题。等结果用 wait（可连调），不要 sleep、不要反复调 status。用户中途改方向时用 revise 掐掉受影响的任务并在同一轮里补上新任务，不要重开一轮。",
+  "tool.title": "多智能体任务",
+  "tool.description": "把一件事交给一支并行的子智能体小队来做：每个子任务一个 worker 会话、各自独立的上下文，用不可变产物交接成果，而不是互相发消息。\n\n**用户视角只有两步：提出问题 → 拿到结果。** 中间的分派、执行、等待都由你在一次连续的调用链里完成，不要向用户汇报机械过程，也不要问「要我等吗」——跑完了再一次性给结果。\n\naction：\n  dispatch — 启动一轮任务。传入 goal 和 2-12 个任务，每个任务对应一个独立会话。**这一次调用默认最多等 540s**，期间进度实时显示在工具卡上。\n  wait     — 接着等已经在跑的 run（传 runId，默认再等 540s）。dispatch 等满时间还没跑完就调它继续等，可以连着调多次。\n  revise   — 用户在跑的过程中改了方向时用：cancel 传要中断的任务 id，tasks 传新的或替换的任务（**复用同一个 id 就是替换**，依赖它的下游会自动改用新结果）。整轮任务继续，其他 worker 不受影响，然后继续等。\n  status   — 只看一眼当前状态，不等待。用户问「怎么样了」时用。\n  collect  — 读取已完成任务的产出（产物正文和交接图），用于写出最终答复。\n  cancel   — 取消单个任务或整轮任务。\n  list     — 列出当前会话（或全部）最近的任务轮次。\n  models   — 列出用户当前真正启用的模型（含 `provider:model` 键、provider、是否支持思考/是否快速）。用户点名要某个模型前先调它。\n\n等待与轮询（重要）：\n- 等待发生在工具内部：dispatch / wait / revise 自己会盯着这些 worker 会话并每几秒刷新进度，所以既不要 sleep，也不要为了查进度反复调 status。\n- 只要 run 还没结束、你想拿到结果，就调 wait（可以连着调多次），不要停下来问用户。\n- 用户中途打断（等待被 abort）不是失败：那通常是他们想改方向。这时**不要重开一轮**，先看用户说了什么，再用 revise 掐掉受影响的任务、补上新任务。\n\n任务标题（重要）：\n- 每个任务的 title 都写成「角色 · 在做什么」，用用户的语言。\n- 好的例子：「竞品调研 · 摸清三家定价」「统稿 · 把三份素材合成定位简报」「翻译 · 处理第 3-6 页」。\n- 反例：「定价情况」「任务 A」「MCP 协议生态现状」——光一个主题名词，看不出这个 worker 在干什么。\n- 这个标题会成为 worker 会话的标题，也就是用户在会话列表里看到的那行字。\n\n工作方式：\n- 由你自己拆解目标。每个任务必须能独立执行，并产出一份自洽的书面结果。\n- worker 看不到当前这段对话。它们的输入只有自己的提示词，以及交接给它的上游产物。\n- 只有当一个任务确实要消费另一个任务的产出时才用 dependsOn；依赖图必须无环，每条依赖边都会记录成一次 Handoff 交接。\n- 结果不会以对话消息的形式在 worker 之间传递：每份产出都发布为不可变 Artifact，整轮报告维护成一个带版本号的 Document。\n\n模型选择（重要）：\n- **用户没提模型就别传 model**，一路用应用默认即可——这是常态。\n- 用户点名要某个模型（「推理用 Opus」「其余用快的那个」）时：**先调 action=models 拿真实可用的列表**，再把匹配到的 `provider:model` 键传给 dispatch 的 `model`（整轮）或 `tasks[].model`（单个任务）。不要凭记忆写模型名。\n- 用户说的是模糊说法（「便宜的」「带思考的」）时，用列表里的 instant / supportsThinking 标记来挑，并说明你挑了哪个。\n- 匹配不上会回退到默认，但结果里会明确标出「请求的 X 没匹配上」——看到这行要如实告诉用户。\n\n跑完之后：\n- 调用 collect，把各 worker 的产出综合成给用户的最终答案，并说明用到了哪些产物。\n- 汇报结果，不要复盘流程。",
+  "scope.prefix": "多智能体任务",
+  "progress.scope.1": "正在召集小队…",
+  "progress.scope.2": "把活拆开，分头去干…",
+  "progress.scope.3": "先去开个协作房间…",
+  "progress.running.1": "小队正在干活 · {done}/{total} 完成",
+  "progress.running.2": "已经有 {done}/{total} 位交卷了",
+  "progress.running.3": "{running} 位还在敲键盘…（{done}/{total} 完成）",
+  "progress.running.4": "催更最后 {remaining} 位 · {done}/{total} 完成",
+  "progress.running.5": "各忙各的，一切正常 · {done}/{total} 完成",
+  "progress.running.6": "稳步推进，没人摸鱼 · {done}/{total} 完成",
+  "progress.revise.1": "收到，调整方向…",
+  "progress.revise.2": "掐掉不对路的活，重新分派…",
+  "progress.revise.3": "换个人继续干…",
+  "result.goal": "目标",
+  "result.progress": "进度",
+  "result.model": "模型",
+  "result.parallel": "并发",
+  "result.space": "空间",
+  "result.labelSession": "会话",
+  "result.labelWaiting": "等待",
+  "result.labelError": "错误",
+  "result.labelDeliverable": "交付",
+  "result.appDefaultModel": "应用默认",
+  "result.noTasks": "action=dispatch 需要提供 2-12 个任务。",
+  "result.tooManyTasks": "任务太多了：每轮上限 {max} 个。",
+  "result.taskMissingFields": "第 {index} 个任务需要同时提供 title 和 prompt。",
+  "result.selfDependency": "任务 `{task}` 不能依赖自己。",
+  "result.unknownDependency": "任务 `{task}` 依赖了不存在的任务 `{dep}`。",
+  "result.cycle": "依赖图里存在环：{chain}",
+  "result.noGoal": "action=dispatch 需要提供 goal。",
+  "result.noRun": "没有匹配的任务轮次。请传 runId，或先 dispatch 一轮。",
+  "result.noRuns": "还没有多智能体任务。",
+  "result.noTask": "该轮任务里没有 `{task}`。",
+  "result.unknownAction": "未知 action `{action}`。请使用 dispatch、status、collect、cancel 或 list。",
+  "result.missingApi": "当前 Finch 版本未提供：{list}。请升级 Finch 后再使用多智能体任务。",
+  "result.scopeFailed": "创建协作范围失败：{error}",
+  "result.dispatched.running": "小队还在干活（{runId}）—— 已经 {seconds}s，还没全员归队，先转后台继续。",
+  "result.dispatched.completed": "全员交卷 ✓（{runId}）",
+  "result.dispatched.partial": "大部分交卷（{runId}）—— 有几位没跑通。",
+  "result.dispatched.failed": "这轮翻车了（{runId}）—— 所有 worker 都失败。",
+  "result.dispatched.cancelled": "已叫停（{runId}）。",
+  "result.nextStatus": "想看进度就调用 multi_agent_run 并传 action=status、runId={runId}；要接着等结果就用 action=wait。",
+  "result.nextWait": "还有 worker 在跑：紧接着调用 multi_agent_run 并传 action=wait、runId={runId} 可以在一次调用里继续等（进度会外显），不要停下来问用户。",
+  "result.nextCollect": "调用 multi_agent_run 并传 action=collect、runId={runId} 即可读取产出。",
+  "result.usingDefaultModel": "本次未指定模型，所有 worker 使用应用默认模型。",
+  "result.collectHeader": "「{goal}」的产出（{runId}）—— 状态：{status}",
+  "result.artifactRef": "产物",
+  "result.handoffGraph": "交接图：",
+  "result.handoffs": "交接记录：",
+  "result.document": "版本化文档：{id}（第 {revision} 版）",
+  "result.summaryArtifact": "结构化任务摘要：{id}",
+  "result.notStarted": "尚未开始",
+  "result.collectTruncated": "…内容已截断，完整任务列表请用 action=status 查看。",
+  "result.allFailed": "所有任务都失败了",
+  "result.cancelledByUser": "已被用户取消",
+  "result.emptyOutput": "（这位选手交了个白卷）",
+  "result.sessionGone": "worker 会话已不存在",
+  "result.sendFailed": "任务下发失败，worker 没有跑起来",
+  "result.waitStillRunning": "又等了 {seconds}s，还有 worker 没交卷（{runId}）。",
+  "result.waitAlreadyDone": "这轮已经结束了（{runId}），不用再等。",
+  "result.waitAborted": "等待被用户打断了（{runId}）—— 任务还在后台跑。要接着等用 action=wait；用户要改方向就用 action=revise。",
+  "result.revised": "已按新方向中断",
+  "result.reviseNotRunning": "这轮已经结束了（{runId}），改方向就直接 dispatch 新一轮。",
+  "result.reviseNoop": "revise 需要提供 cancel（要中断的任务 id）或 tasks（新的/替换的任务）。",
+  "result.reviseApplied": "已中断 {cancelled} 个任务，新排入 {added} 个。",
+  "result.reviseDone": "调整已生效：中断 {cancelled} 个，新排入 {added} 个。",
+  "model.tagInstant": "快速",
+  "model.tagThinking": "支持思考",
+  "model.tagAlias": "别名 {alias}",
+  "model.unmatched": "请求的 {requested} 没匹配上，已改用默认模型",
+  "result.modelsHeader": "当前可用的模型 {count} 个（按 provider 分组）：",
+  "result.modelsDefault": "默认工作模型：{model}",
+  "result.modelsHowTo": "要指定模型：把对应的 `provider:model` 键传给 dispatch/revise 的 model（整轮）或 tasks[].model（单任务）。用户没提模型就不要传。",
+  "result.noModels": "没有拿到可用模型列表。",
+  "result.runList": "最近 {count} 轮任务：",
+  "result.thisSession": "（当前会话）",
+  "menu.defaultModel": "默认工作模型",
+  "menu.appDefault": "跟随应用默认",
+  "menu.modelCount": "{count} 个模型",
+  "menu.clearRuns": "清理已结束的任务",
+  "menu.cleared": "已清理结束的任务"
+}

package/icons/agents.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">
+  <circle cx="12" cy="12" r="2.6"/>
+  <circle cx="12" cy="3.6" r="1.8"/>
+  <circle cx="4.7" cy="16.6" r="1.8"/>
+  <circle cx="19.3" cy="16.6" r="1.8"/>
+  <path d="M12 5.4v4"/>
+  <path d="M10.2 13.7 6.3 15.6"/>
+  <path d="M13.8 13.7l3.9 1.9"/>
+</svg>

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "finch-multi-agent",
+  "version": "0.1.0",
+  "description": "Spin up a team of sub-agents from one natural-language goal: Fan out a plan into parallel worker Sessions that share immutable Artifacts, versioned Documents and structured Handoffs.",
+  "author": {
+    "name": "PuterJam",
+    "url": "https://github.com/puterjam"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/puterjam/finch-tools.git",
+    "directory": "finch-multi-agent"
+  },
+  "homepage": "https://github.com/puterjam/finch-tools/tree/main/finch-multi-agent#readme",
+  "bugs": {
+    "url": "https://github.com/puterjam/finch-tools/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "keywords": [
+    "finch",
+    "finch-minitool",
+    "multi-agent",
+    "subagents",
+    "orchestration",
+    "collaboration",
+    "artifacts"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run build && npx @finchtoys/minitools doctor ."
+  },
+  "finch": {
+    "manifestVersion": 1,
+    "id": "multi-agent",
+    "minVersion": "1.6.4",
+    "name": "Multi-Agent",
+    "description": "Turn one goal into a team of sub-agents: parallel worker sessions that hand off immutable artifacts instead of chat messages.",
+    "systemPrompt": "Use multi_agent_run when a request is genuinely decomposable into independent, low-bandwidth subtasks — research fan-out, multi-module review, batch processing, parallel drafting. Do not use it for small tasks, tightly coupled work, or anything needing low-latency back-and-forth. From the user's side there are only two steps — ask, then get the answer — so keep dispatching, executing and waiting inside one continuous chain of calls, and never narrate the mechanics or ask whether to keep waiting. Name every subtask as \"<role> · <what it is doing>\" (e.g. \"Competitor research · price the top three\") — that string becomes the worker's session title. To wait for a result, call wait (repeatedly if needed); never sleep and never poll with status. When the user changes direction mid-run, use revise to stop the affected tasks and queue replacements in the same run — do not start a new one.",
+    "main": "dist/index.js",
+    "activationEvents": [
+      "onStartup"
+    ],
+    "miniToolType": "local",
+    "categories": [
+      "productivity",
+      "agents"
+    ],
+    "contributes": {
+      "tools": true,
+      "iconPacks": [
+        {
+          "id": "agents-icons",
+          "label": "Multi-Agent Icons"
+        }
+      ],
+      "icons": {
+        "agents": {
+          "description": "Multi-agent network mark — the mini tool's own icon in the Toolcase settings entry",
+          "svg": "./icons/agents.svg"
+        }
+      },
+      "settingsMenu": {
+        "icon": "ext:agents"
+      }
+    },
+    "permissions": {
+      "filesystem": "readwrite",
+      "network": false,
+      "shell": false,
+      "artifacts": true,
+      "collaboration": true,
+      "sessions": true
+    }
+  },
+  "devDependencies": {
+    "@finchtoys/minitool-api": "^0.3.13",
+    "@types/node": "^26.1.0",
+    "esbuild": "^0.28.1",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "dist/",
+    "i18n/",
+    "icons/",
+    "icon.png",
+    "README.md"
+  ]
+}