Terminal Launcher (pour les environnements à ressources limitées)
diff --git a/README.id.md b/README.id.md index 3fe4c1276..bba010dec 100644 --- a/README.id.md +++ b/README.id.md @@ -56,6 +56,8 @@ ## 📢 Berita +2026-03-31 📱 **Dukungan Android!** PicoClaw sekarang berjalan di Android! Unduh APK di [picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 Dirilis!** Perombakan arsitektur Agent (SubTurn, Hooks, Steering, EventBus), integrasi WeChat/WeCom, penguatan keamanan (.security.yml, penyaringan data sensitif), provider baru (AWS Bedrock, Azure, Xiaomi MiMo), dan 35 perbaikan bug. PicoClaw telah mencapai **26K Stars**! 2026-03-17 🚀 **v0.2.3 Dirilis!** UI system tray (Windows & Linux), pelacakan status sub-agent (`spawn_status`), eksperimental Gateway hot-reload, gerbang keamanan Cron, dan 2 perbaikan keamanan. PicoClaw telah mencapai **25K Stars**! @@ -318,9 +320,9 @@ Kemudian ikuti bagian Terminal Launcher di bawah untuk menyelesaikan konfigurasi
-**Opsi 2: Instal APK (segera hadir)**
+**Opsi 2: Instal APK**
-APK Android mandiri dengan WebUI bawaan sedang dalam pengembangan. Pantau terus!
+Unduh APK dari [picoclaw.io](https://picoclaw.io/download/) dan instal langsung. Tanpa Termux!
Terminal Launcher (untuk lingkungan dengan sumber daya terbatas)
diff --git a/README.it.md b/README.it.md index 8748aea9c..50f08ad8b 100644 --- a/README.it.md +++ b/README.it.md @@ -56,6 +56,8 @@ ## 📢 Novità +2026-03-31 📱 **Supporto Android!** PicoClaw ora funziona su Android! Scarica l'APK su [picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 rilasciata!** Revisione dell'architettura Agent (SubTurn, Hooks, Steering, EventBus), integrazione WeChat/WeCom, rafforzamento della sicurezza (.security.yml, filtraggio dati sensibili), nuovi provider (AWS Bedrock, Azure, Xiaomi MiMo) e 35 correzioni di bug. PicoClaw raggiunge **26K Stars**! 2026-03-17 🚀 **v0.2.3 rilasciata!** Interfaccia system tray (Windows & Linux), query sullo stato dei sub-agent (`spawn_status`), hot-reload sperimentale del Gateway, gate di sicurezza per Cron e 2 correzioni di sicurezza. PicoClaw raggiunge **25K Stars**! @@ -318,9 +320,9 @@ Poi segui la sezione Terminal Launcher qui sotto per completare la configurazion
-**Opzione 2: APK Install (prossimamente)**
+**Opzione 2: Installazione APK**
-Un APK Android standalone con WebUI integrato è in sviluppo. Resta sintonizzato!
+Scarica l'APK da [picoclaw.io](https://picoclaw.io/download/) e installa direttamente. Senza Termux!
Terminal Launcher (per ambienti con risorse limitate)
diff --git a/README.ja.md b/README.ja.md index 3772ff532..7171a87b9 100644 --- a/README.ja.md +++ b/README.ja.md @@ -56,6 +56,8 @@ ## 📢 ニュース +2026-03-31 📱 **Android サポート！** PicoClawがAndroidで動作！APKは[picoclaw.io](https://picoclaw.io/download)からダウンロード + 2026-03-25 🚀 **v0.2.4 リリース！** Agent アーキテクチャ全面刷新（SubTurn、Hooks、Steering、EventBus）、WeChat/WeCom 統合、セキュリティ強化（.security.yml、機密データフィルタリング）、新プロバイダー（AWS Bedrock、Azure、Xiaomi MiMo）、35 件のバグ修正。PicoClaw **26K ⭐** 達成！ 2026-03-17 🚀 **v0.2.3 リリース！** システムトレイ UI（Windows & Linux）、サブエージェントステータス追跡（`spawn_status`）、実験的 Gateway ホットリロード、cron セキュリティゲート、セキュリティ修正 2 件。PicoClaw **25K ⭐** 達成！ @@ -318,9 +320,9 @@ termux-chroot ./picoclaw onboard # chroot で標準的な Linux ファイル
-**オプション 2: APK インストール（近日公開）**
+**オプション 2: APK インストール**
-内蔵 WebUI を備えたスタンドアロン Android APK を開発中です。お楽しみに！
+[picoclaw.io](https://picoclaw.io/download/) から APK をダウンロードして直接インストール。Termux 不要！
Terminal Launcher（リソース制約環境向け）
diff --git a/README.md b/README.md index 947fed9e2..db38e644f 100644 --- a/README.md +++ b/README.md @@ -56,6 +56,8 @@ ## 📢 News +2026-03-31 📱 **Android Support!** PicoClaw now runs on Android! Download the APK at [picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 Released!** Agent architecture overhaul (SubTurn, Hooks, Steering, EventBus), WeChat/WeCom integration, security hardening (.security.yml, sensitive data filtering), new providers (AWS Bedrock, Azure, Xiaomi MiMo), and 35 bug fixes. PicoClaw has reached **26K Stars**! 2026-03-17 🚀 **v0.2.3 Released!** System tray UI (Windows & Linux), sub-agent status query (`spawn_status`), experimental Gateway hot-reload, Cron security gating, and 2 security fixes. PicoClaw has reached **25K Stars**! @@ -318,9 +320,9 @@ Then follow the Terminal Launcher section below to complete configuration.
-**Option 2: APK Install (coming soon)**
+**Option 2: APK Install**
-A standalone Android APK with built-in WebUI is in development. Stay tuned!
+Download the APK from [picoclaw.io](https://picoclaw.io/download/) and install directly. No Termux required!
Terminal Launcher (for resource-constrained environments)
diff --git a/README.my.md b/README.my.md index c07cdd005..095d4b66a 100644 --- a/README.my.md +++ b/README.my.md @@ -56,6 +56,8 @@ ## 📢 Berita +2026-03-31 📱 **Sokongan Android!** PicoClaw sekarang berjalan di Android! Muat turun APK di [picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 Dikeluarkan!** Penstrukturan semula seni bina Agent (SubTurn, Hooks, Steering, EventBus), integrasi WeChat/WeCom, penguatan keselamatan (.security.yml, penapisan data sensitif), penyedia baharu (AWS Bedrock, Azure, Xiaomi MiMo), dan 35 pembetulan pepijat. PicoClaw mencapai **26K Stars**! 2026-03-17 🚀 **v0.2.3 Dikeluarkan!** UI dulang sistem (Windows & Linux), pertanyaan status sub-agent (`spawn_status`), muat semula panas Gateway eksperimental, kawalan keselamatan Cron, dan 2 pembetulan keselamatan. PicoClaw mencapai **25K Stars**! @@ -315,9 +317,9 @@ Kemudian ikuti bahagian Pelancar Terminal di bawah untuk melengkapkan konfiguras
-**Pilihan 2: APK (akan datang)**
+**Pilihan 2: Pasang APK**
-APK Android bebas dengan WebUI terbina dalam sedang dalam pembangunan. Nantikan!
+Muat turun APK dari [picoclaw.io](https://picoclaw.io/download/) dan pasang secara langsung. Tiada Termux diperlukan!
Pelancar Terminal (untuk persekitaran terhad sumber)
diff --git a/README.pt-br.md b/README.pt-br.md index dfe7cb0f2..bbc5b4957 100644 --- a/README.pt-br.md +++ b/README.pt-br.md @@ -56,6 +56,8 @@ ## 📢 Novidades +2026-03-31 📱 **Suporte Android!** PicoClaw agora roda no Android! Baixe o APK em [picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 Lançada!** Reformulação da arquitetura Agent (SubTurn, Hooks, Steering, EventBus), integração WeChat/WeCom, fortalecimento de segurança (.security.yml, filtragem de dados sensíveis), novos providers (AWS Bedrock, Azure, Xiaomi MiMo) e 35 correções de bugs. O PicoClaw atingiu **26K Stars**! 2026-03-17 🚀 **v0.2.3 Lançada!** UI na bandeja do sistema (Windows e Linux), consulta de status de sub-agent (`spawn_status`), hot-reload experimental do Gateway, controle de segurança do Cron e 2 correções de segurança. O PicoClaw atingiu **25K Stars**! @@ -318,9 +320,9 @@ Em seguida, siga a seção Terminal Launcher abaixo para concluir a configuraç
-**Opção 2: Instalação via APK (em breve)**
+**Opção 2: Instalação via APK**
-Um APK Android independente com WebUI integrado está em desenvolvimento. Fique ligado!
+Baixe o APK de [picoclaw.io](https://picoclaw.io/download/) e instale diretamente. Sem necessidade de Termux!
Terminal Launcher (para ambientes com recursos limitados)
diff --git a/README.vi.md b/README.vi.md index 6c8f6ad44..7ae414723 100644 --- a/README.vi.md +++ b/README.vi.md @@ -56,6 +56,8 @@ ## 📢 Tin tức +2026-03-31 📱 **Hỗ trợ Android!** PicoClaw giờ chạy trên Android! Tải APK tại [picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 đã phát hành!** Tái cấu trúc kiến trúc Agent (SubTurn, Hooks, Steering, EventBus), tích hợp WeChat/WeCom, tăng cường bảo mật (.security.yml, lọc dữ liệu nhạy cảm), provider mới (AWS Bedrock, Azure, Xiaomi MiMo) và 35 bản vá lỗi. PicoClaw đã đạt **26K Stars**! 2026-03-17 🚀 **v0.2.3 đã phát hành!** Giao diện system tray (Windows & Linux), truy vấn trạng thái sub-agent (`spawn_status`), thử nghiệm Gateway hot-reload, bảo mật Cron, và 2 bản vá bảo mật. PicoClaw đã đạt **25K Stars**! @@ -318,9 +320,9 @@ Sau đó làm theo phần Terminal Launcher bên dưới để hoàn tất cấu
-**Tùy chọn 2: Cài đặt APK (sắp ra mắt)**
+**Tùy chọn 2: Cài đặt APK**
-Một APK Android độc lập với WebUI tích hợp đang được phát triển. Hãy đón chờ!
+Tải APK từ [picoclaw.io](https://picoclaw.io/download/) và cài đặt trực tiếp. Không cần Termux!
Terminal Launcher (cho môi trường hạn chế tài nguyên)
diff --git a/README.zh.md b/README.zh.md index b92e8e889..569ca1656 100644 --- a/README.zh.md +++ b/README.zh.md @@ -56,6 +56,8 @@ ## 📢 新闻 +2026-03-31 📱 **Android 支持！** PicoClaw 现可在 Android 上运行！APK 下载地址：[picoclaw.io](https://picoclaw.io/download) + 2026-03-25 🚀 **v0.2.4 发布！** Agent 架构全面重构（SubTurn、Hook、Steering、EventBus）、微信/企业微信深度集成、安全体系升级（.security.yml、敏感数据过滤）、新增 Provider（AWS Bedrock、Azure、小米 MiMo），以及 35 项 Bug 修复。PicoClaw 已达 **26K ⭐**！ 2026-03-17 🚀 **v0.2.3 发布！** 系统托盘 UI（Windows & Linux）、子 Agent 状态查询 (`spawn_status`)、实验性 Gateway 热重载、Cron 安全门控，以及 2 项安全修复。PicoClaw 已达 **25K ⭐**！ @@ -318,9 +320,9 @@ termux-chroot ./picoclaw onboard # chroot 提供标准 Linux 文件系统布
-**方式二：APK 安装（即将推出）**
+**方式二：APK 安装**
-内置 WebUI 的独立 Android APK 正在开发中，敬请期待！
+从 [picoclaw.io](https://picoclaw.io/download/) 下载 APK 并直接安装，无需 Termux！
Terminal Launcher（适用于资源受限环境）
From 0f395ce11057d941344c43f32ef95295fe8c178d Mon Sep 17 00:00:00 2001 From: Hua Audio
+
+ )
+}
diff --git a/web/frontend/src/components/agent/hub/market-skill-card.tsx b/web/frontend/src/components/agent/hub/market-skill-card.tsx
new file mode 100644
index 000000000..64493ddf4
--- /dev/null
+++ b/web/frontend/src/components/agent/hub/market-skill-card.tsx
@@ -0,0 +1,132 @@
+import {
+ IconCheck,
+ IconFileInfo,
+ IconLoader2,
+ IconPlus,
+} from "@tabler/icons-react"
+import { useTranslation } from "react-i18next"
+
+import {
+ type SkillRegistrySearchResult,
+ type SkillSupportItem,
+} from "@/api/skills"
+import { Button } from "@/components/ui/button"
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from "@/components/ui/card"
+
+export function MarketSkillCard({
+ result,
+ canInstall,
+ installPending,
+ installedSkill,
+ onInstall,
+ onViewInstalled,
+}: {
+ result: SkillRegistrySearchResult
+ canInstall: boolean
+ installPending: boolean
+ installedSkill: SkillSupportItem | null
+ onInstall: () => void
+ onViewInstalled: () => void
+}) {
+ const { t } = useTranslation()
+
+ return (
+
+
+
+
+
+
+
+
+
+
+ {result.summary}
+
+ {result.url ? (
+
+
+
+ {result.display_name || result.slug}
+
+
+ {result.registry_name}
+
+ {result.installed ? (
+
+ {t("pages.agent.skills.marketplace_installed")}
+
+ ) : null}
+
+
+ {result.slug}
+ {result.version ? (
+
+ {" "}
+ · v{result.version}
+
+ ) : null}
+
+
+
+ {result.url}
+
+
+ ) : null}
+
+
+ {result.installed && installedSkill ? (
+
+ ) : null}
+
+
+ {t("pages.agent.skills.marketplace_installed_hint", {
+ name: result.installed_name,
+ })}
+
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/hub/search-panel.tsx b/web/frontend/src/components/agent/hub/search-panel.tsx
new file mode 100644
index 000000000..875aaad6b
--- /dev/null
+++ b/web/frontend/src/components/agent/hub/search-panel.tsx
@@ -0,0 +1,91 @@
+import { IconLoader2 } from "@tabler/icons-react"
+import { useTranslation } from "react-i18next"
+
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+
+import type { UnavailableToolMessage } from "./tool-support"
+
+export function SearchPanel({
+ marketQuery,
+ canSearchMarketplace,
+ isMarketSearchInitialLoading,
+ unavailableToolMessages,
+ onMarketQueryChange,
+ onSearchSubmit,
+}: {
+ marketQuery: string
+ canSearchMarketplace: boolean
+ isMarketSearchInitialLoading: boolean
+ unavailableToolMessages: UnavailableToolMessage[]
+ onMarketQueryChange: (value: string) => void
+ onSearchSubmit: () => void
+}) {
+ const { t } = useTranslation()
+
+ return (
+
+ {canSearchMarketplace && hasSubmittedQuery ? (
+
+
+
+ ) : !canSearchMarketplace ? (
+
+
+
+ {isMarketSearchInitialLoading ? (
+
+ {t("pages.agent.skills.marketplace_notice_title")}
+
+
+ {t("pages.agent.skills.marketplace_notice_body")}
+
+
+
+ ) : marketSearchError ? (
+
+
+ ) : marketResults.length ? (
+
+
+
+
+ ) : (
+
+
+ + {t("pages.agent.skills.marketplace_results_title", { + query: submittedQuery, + count: marketResults.length, + })} +
+ + {t("pages.agent.skills.marketplace_results_hint")} + +
+ {marketResults.map((result) => (
+ onInstall(result)}
+ onViewInstalled={onViewInstalled}
+ />
+ ))}
+
+ {isMarketSearchLoadingMore ? (
+
+
+ ) : null}
+
+
+ )}
+
+
+ {t("pages.agent.skills.marketplace_unavailable")}
+
+
+ ) : (
+
+
+ )}
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/hub/tool-support.ts b/web/frontend/src/components/agent/hub/tool-support.ts
new file mode 100644
index 000000000..257f9c12a
--- /dev/null
+++ b/web/frontend/src/components/agent/hub/tool-support.ts
@@ -0,0 +1,54 @@
+import type { TFunction } from "i18next"
+
+import type { ToolSupportItem } from "@/api/tools"
+
+type MarketplaceTool = Pick
+
+
+
+
+ {unavailableToolMessages.length ? (
+ + {t("pages.agent.skills.marketplace_title", { + defaultValue: "Discover Skills", + })} +
++ {t("pages.agent.skills.marketplace_description")} +
+
+ {unavailableToolMessages.map((item) => (
+
+ ) : null}
+
+
+ ))}
+ {item.label}
+ {item.message}
+
+
+
+ {activeSkillDetail?.origin_kind === "builtin" ? (
+
+
+
+ {activeSkillDetail?.name || t("pages.agent.skills.viewer_title")}
+
+
+ {activeSkillDetail?.description ||
+ t("pages.agent.skills.viewer_description")}
+
+
+
+ {isLoading ? (
+
+
+
+ ) : error ? (
+
+
+ ) : selectedSkillDetail ? (
+
+ {activeSkillOrigin === "third_party" ? (
+
+ ) : null}
+
+
+ ) : null}
+
+
+
+
+
+ {selectedSkillDetail.registry_name ? (
+
+ {selectedSkillDetail.registry_url}
+
+ }
+ mono
+ />
+ ) : null}
+
+
+ {DETAIL_VIEWS.map((view) => (
+
+ ))}
+
+
+ {detailView === "preview" ? (
+
+
+ {selectedSkillDetail.content}
+
+
+ ) : null}
+
+ {detailView === "raw" ? (
+
+
+ ) : null}
+
+ {detailView === "meta" ? (
+
+ {selectedSkillDetail.content}
+
+
+
+ ) : null}
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/filter-bar.tsx b/web/frontend/src/components/agent/skills/filter-bar.tsx
new file mode 100644
index 000000000..303fd6f60
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/filter-bar.tsx
@@ -0,0 +1,136 @@
+import {
+ IconLayoutGrid,
+ IconLayoutList,
+ IconSearch,
+} from "@tabler/icons-react"
+import { useTranslation } from "react-i18next"
+
+import { Input } from "@/components/ui/input"
+import {
+ Select,
+ SelectContent,
+ SelectItem,
+ SelectTrigger,
+ SelectValue,
+} from "@/components/ui/select"
+import { cn } from "@/lib/utils"
+
+import { getOriginLabel } from "./origin-utils"
+import type { SkillLayoutMode, SkillSortOption } from "./types"
+
+interface FilterBarProps {
+ searchQuery: string
+ sourceFilter: string
+ availableOrigins: string[]
+ sortOrder: SkillSortOption
+ layoutMode: SkillLayoutMode
+ onSearchQueryChange: (value: string) => void
+ onSourceFilterChange: (value: string) => void
+ onSortOrderChange: (value: SkillSortOption) => void
+ onLayoutModeChange: (value: SkillLayoutMode) => void
+}
+
+export function FilterBar({
+ searchQuery,
+ sourceFilter,
+ availableOrigins,
+ sortOrder,
+ layoutMode,
+ onSearchQueryChange,
+ onSourceFilterChange,
+ onSortOrderChange,
+ onLayoutModeChange,
+}: FilterBarProps) {
+ const { t } = useTranslation()
+
+ return (
+
+ {label}
+
+
+ {value}
+
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/import-dialog.tsx b/web/frontend/src/components/agent/skills/import-dialog.tsx
new file mode 100644
index 000000000..21f4827e3
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/import-dialog.tsx
@@ -0,0 +1,160 @@
+import { IconLoader2, IconUpload, IconX } from "@tabler/icons-react"
+import type { DragEvent } from "react"
+import { useTranslation } from "react-i18next"
+
+import { Button } from "@/components/ui/button"
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogHeader,
+ DialogTitle,
+} from "@/components/ui/dialog"
+import { cn } from "@/lib/utils"
+
+interface ImportDialogProps {
+ open: boolean
+ isImportPending: boolean
+ isDragActive: boolean
+ onOpenChange: (open: boolean) => void
+ onImportClick: () => void
+ onDragEnter: (event: DragEvent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/origin-badge.tsx b/web/frontend/src/components/agent/skills/origin-badge.tsx
new file mode 100644
index 000000000..0b7bf4391
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/origin-badge.tsx
@@ -0,0 +1,46 @@
+import {
+ IconFileCode,
+ IconFolder,
+ IconSparkles,
+ IconWorld,
+} from "@tabler/icons-react"
+
+import { cn } from "@/lib/utils"
+
+import { getOriginBadgeClasses } from "./origin-utils"
+
+export function OriginBadge({
+ origin,
+ label,
+}: {
+ origin: string
+ label: string
+}) {
+ return (
+
+ {
+ if (!isImportPending) {
+ onImportClick()
+ }
+ }}
+ onDragEnter={onDragEnter}
+ onDragLeave={onDragLeave}
+ onDragOver={(event) => event.preventDefault()}
+ onDrop={onDrop}
+ >
+
+
+
+
+
+
+
+ {isDragActive
+ ? t("pages.agent.skills.dropzone_active")
+ : t("pages.agent.skills.dropzone_label")}
+
+ + {isDragActive + ? t("pages.agent.skills.dropzone_release") + : t("pages.agent.skills.import_constraints")} +
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/skill-card.tsx b/web/frontend/src/components/agent/skills/skill-card.tsx
new file mode 100644
index 000000000..15bdc2c63
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/skill-card.tsx
@@ -0,0 +1,84 @@
+import { IconFileInfo, IconTrash } from "@tabler/icons-react"
+import { useTranslation } from "react-i18next"
+
+import type { SkillSupportItem } from "@/api/skills"
+import { Button } from "@/components/ui/button"
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from "@/components/ui/card"
+
+interface SkillCardProps {
+ skill: SkillSupportItem
+ onView: () => void
+ onDelete: () => void
+}
+
+export function SkillCard({ skill, onView, onDelete }: SkillCardProps) {
+ const { t } = useTranslation()
+
+ return (
+
+ {[1, 2, 3, 4].map((index) => (
+
+
+
+
+
+
+ {[1, 2, 3, 4].map((index) => (
+
+
+
+
+
+ {skill.description || t("pages.agent.skills.no_description")}
+
+
+
+
+ {skill.name}
+
+ {skill.registry_name ? (
+
+ {skill.registry_name}
+
+ ) : null}
+
+
+
+ {skill.source === "workspace" ? (
+
+ ) : null}
+
+
+
+ )
+ }
+
+ if (layoutMode === "grouped" && sourceFilter === "all") {
+ return (
+
+
+ + {hasActiveFilters + ? t("pages.agent.skills.no_results") + : t("pages.agent.skills.empty")} +
+
+ {groupedSkills.map((section) => (
+
+ )
+ }
+
+ return (
+
+
+ ))}
+
+
+
+ {section.skills.map((skill) => (
+ onViewSkill(skill)}
+ onDelete={() => onDeleteSkill(skill)}
+ />
+ ))}
+
+
+ {sortedSkills.map((skill) => (
+ onViewSkill(skill)}
+ onDelete={() => onDeleteSkill(skill)}
+ />
+ ))}
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/skills-page.tsx b/web/frontend/src/components/agent/skills/skills-page.tsx
new file mode 100644
index 000000000..d9b5a7cd1
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/skills-page.tsx
@@ -0,0 +1,160 @@
+import { IconLoader2, IconPlus } from "@tabler/icons-react"
+import { useTranslation } from "react-i18next"
+
+import { PageHeader } from "@/components/page-header"
+import { Button } from "@/components/ui/button"
+
+import { DeleteDialog } from "./delete-dialog"
+import { DetailSheet } from "./detail-sheet"
+import { FilterBar } from "./filter-bar"
+import { ImportDialog } from "./import-dialog"
+import { PageSkeleton } from "./page-skeleton"
+import { SkillsList } from "./skills-list"
+import { Stats } from "./stats"
+import { useSkillsPage } from "./use-skills-page"
+
+export function SkillsPage() {
+ const { t } = useTranslation()
+ const {
+ searchQuery,
+ sourceFilter,
+ sortOrder,
+ layoutMode,
+ detailView,
+ isDragActive,
+ isImportDialogOpen,
+ selectedSkill,
+ skillPendingDelete,
+ availableOrigins,
+ groupedSkills,
+ stats,
+ sortedSkills,
+ hasActiveFilters,
+ importInputRef,
+ selectedSkillDetail,
+ skillsError,
+ skillDetailError,
+ isLoading,
+ isSkillDetailLoading,
+ isImportPending,
+ isDeletePending,
+ setSearchQuery,
+ setSourceFilter,
+ setSortOrder,
+ setLayoutMode,
+ setDetailView,
+ openImportDialog,
+ handleViewSkill,
+ handleRequestDelete,
+ handleConfirmDelete,
+ handleImportClick,
+ handleImportFileChange,
+ handleDropZoneDragEnter,
+ handleDropZoneDragLeave,
+ handleDropZoneDrop,
+ handleDetailSheetOpenChange,
+ handleImportDialogOpenChange,
+ handleDeleteDialogOpenChange,
+ } = useSkillsPage()
+
+ return (
+
+
+
+
+
+ }
+ />
+
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/stats.tsx b/web/frontend/src/components/agent/skills/stats.tsx
new file mode 100644
index 000000000..c718fc3be
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/stats.tsx
@@ -0,0 +1,39 @@
+import { Card, CardContent } from "@/components/ui/card"
+import { cn } from "@/lib/utils"
+
+import { OriginIcon } from "./origin-badge"
+import { getOriginAccentClasses } from "./origin-utils"
+import type { SkillStatItem } from "./types"
+
+export function Stats({ stats }: { stats: SkillStatItem[] }) {
+ return (
+
+
+
+
+ {isLoading ? (
+
+
+ )}
+
+
+ {t("pages.agent.load_error")}
+
+ ) : (
+
+
+
+
+ {stats.map((stat) => (
+
+
+
+
+ ))}
+
+ )
+}
diff --git a/web/frontend/src/components/agent/skills/types.ts b/web/frontend/src/components/agent/skills/types.ts
new file mode 100644
index 000000000..44509854c
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/types.ts
@@ -0,0 +1,17 @@
+import type { SkillSupportItem } from "@/api/skills"
+
+export type SkillSortOption = "name-asc" | "name-desc" | "source"
+export type SkillLayoutMode = "grouped" | "grid"
+export type SkillDetailView = "preview" | "raw" | "meta"
+
+export interface SkillGroupSection {
+ origin: string
+ skills: SkillSupportItem[]
+}
+
+export interface SkillStatItem {
+ key: string
+ origin: string
+ label: string
+ count: number
+}
diff --git a/web/frontend/src/components/agent/skills/use-skills-page.ts b/web/frontend/src/components/agent/skills/use-skills-page.ts
new file mode 100644
index 000000000..ffe9fc90c
--- /dev/null
+++ b/web/frontend/src/components/agent/skills/use-skills-page.ts
@@ -0,0 +1,336 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import {
+ type ChangeEvent,
+ type DragEvent,
+ startTransition,
+ useDeferredValue,
+ useMemo,
+ useRef,
+ useState,
+} from "react"
+import { useTranslation } from "react-i18next"
+import { toast } from "sonner"
+
+import {
+ type SkillSupportItem,
+ deleteSkill,
+ getSkill,
+ getSkills,
+ importSkill,
+} from "@/api/skills"
+
+import {
+ compareSkills,
+ getOriginLabel,
+ getSkillOriginKind,
+ sortOrigins,
+} from "./origin-utils"
+import type {
+ SkillDetailView,
+ SkillGroupSection,
+ SkillLayoutMode,
+ SkillSortOption,
+ SkillStatItem,
+} from "./types"
+
+const MAX_IMPORT_FILE_SIZE = 1 << 20
+
+export function useSkillsPage() {
+ const { t } = useTranslation()
+ const queryClient = useQueryClient()
+ const importInputRef = useRef
+
+
+ {stat.label}
+
+
+ {stat.count}
+
+
+
+
+
+ )
+}
+
+function ToolStatusBadge({ status }: { status: ToolSupportItem["status"] }) {
+ const { t } = useTranslation()
+
+ return (
+
+ {t(`pages.agent.tools.status.${status}`)}
+
+ )
+}
diff --git a/web/frontend/src/components/app-sidebar.tsx b/web/frontend/src/components/app-sidebar.tsx
index 1ba255693..dea43197c 100644
--- a/web/frontend/src/components/app-sidebar.tsx
+++ b/web/frontend/src/components/app-sidebar.tsx
@@ -6,6 +6,7 @@ import {
IconKey,
IconListDetails,
IconMessageCircle,
+ IconSearch,
IconSettings,
IconSparkles,
IconTools,
@@ -24,14 +25,15 @@ import {
import {
Sidebar,
SidebarContent,
+ SidebarFooter,
SidebarGroup,
SidebarGroupContent,
SidebarGroupLabel,
SidebarMenu,
SidebarMenuButton,
- SidebarFooter,
SidebarMenuItem,
SidebarRail,
+ useSidebar,
} from "@/components/ui/sidebar"
import { useSidebarChannels } from "@/hooks/use-sidebar-channels"
@@ -71,6 +73,7 @@ const baseNavGroups: Omit
+
+
+ {/* Header & Description */}
+
+
+
+
+ ) : isLoading ? (
+ // Skeleton Loading State
+
+
+
+
+ ) : (
+ // Tool Categories list
+
+
+ {/* Filters Toolbar */}
+
+
+ {/* Content Area */}
+ {error ? (
+
+
+
+
+
+ + {t("pages.agent.load_error")} +
+
+ {[1, 2].map((groupIndex) => (
+
+ ) : totalFilteredCount === 0 ? (
+ // Empty State
+
+
+ ))}
+
+ {[1, 2, 3, 4].map((itemIndex) => (
+
+
+
+
+
+
+ ))}
+
+
+
+ + {data?.tools.length === 0 + ? t("pages.agent.tools.empty") + : t("pages.agent.tools.no_results")} +
+ {data?.tools.length !== 0 && ( ++ Try adjusting your search criteria or status filters. +
+ )} +
+ {groupedTools.map(([category, items]) => (
+
+ )}
+
+
+ ))}
+ + {t(`pages.agent.tools.categories.${category}`)} +
+
+ {items.map((tool) => {
+ const reasonText = tool.reason_code
+ ? t(`pages.agent.tools.reasons.${tool.reason_code}`)
+ : ""
+ const isPending =
+ toggleMutation.isPending &&
+ toggleMutation.variables?.name === tool.name
+ const isEnabled = tool.status === "enabled"
+ const isDisabled = tool.status === "disabled"
+ const isBlocked = tool.status === "blocked"
+
+ return (
+
+
+
+ {reasonText && (
+
+
+ )}
+
+ )
+ })}
+
+
+
+
+
+ {tool.description}
+
+
+
+
+ {tool.name}
+
+
+
+
+ toggleMutation.mutate({
+ name: tool.name,
+ enabled: checked,
+ })
+ }
+ />
+
+
+ {reasonText}
+
+
{t("footer.version")}:{" "}
diff --git a/web/frontend/src/components/skills/skills-page.tsx b/web/frontend/src/components/skills/skills-page.tsx
deleted file mode 100644
index 7e0d66d47..000000000
--- a/web/frontend/src/components/skills/skills-page.tsx
+++ /dev/null
@@ -1,319 +0,0 @@
-import {
- IconFileInfo,
- IconLoader2,
- IconPlus,
- IconTrash,
-} from "@tabler/icons-react"
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
-import { type ChangeEvent, useRef, useState } from "react"
-import { useTranslation } from "react-i18next"
-import ReactMarkdown from "react-markdown"
-import rehypeRaw from "rehype-raw"
-import rehypeSanitize from "rehype-sanitize"
-import remarkGfm from "remark-gfm"
-import { toast } from "sonner"
-
-import {
- type SkillSupportItem,
- deleteSkill,
- getSkill,
- getSkills,
- importSkill,
-} from "@/api/skills"
-import { PageHeader } from "@/components/page-header"
-import {
- AlertDialog,
- AlertDialogAction,
- AlertDialogCancel,
- AlertDialogContent,
- AlertDialogDescription,
- AlertDialogFooter,
- AlertDialogHeader,
- AlertDialogTitle,
-} from "@/components/ui/alert-dialog"
-import { Button } from "@/components/ui/button"
-import {
- Card,
- CardContent,
- CardDescription,
- CardHeader,
- CardTitle,
-} from "@/components/ui/card"
-import {
- Sheet,
- SheetContent,
- SheetDescription,
- SheetHeader,
- SheetTitle,
-} from "@/components/ui/sheet"
-
-export function SkillsPage() {
- const { t } = useTranslation()
- const queryClient = useQueryClient()
- const importInputRef = useRef(null)
- const [selectedSkill, setSelectedSkill] = useState(
- null,
- )
- const [skillPendingDelete, setSkillPendingDelete] =
- useState(null)
-
- const { data, isLoading, error } = useQuery({
- queryKey: ["skills"],
- queryFn: getSkills,
- })
- const {
- data: selectedSkillDetail,
- isLoading: isSkillDetailLoading,
- error: skillDetailError,
- } = useQuery({
- queryKey: ["skills", selectedSkill?.name],
- queryFn: () => getSkill(selectedSkill!.name),
- enabled: selectedSkill !== null,
- })
-
- const importMutation = useMutation({
- mutationFn: async (file: File) => importSkill(file),
- onSuccess: () => {
- toast.success(t("pages.agent.skills.import_success"))
- void queryClient.invalidateQueries({ queryKey: ["skills"] })
- },
- onError: (err) => {
- toast.error(
- err instanceof Error
- ? err.message
- : t("pages.agent.skills.import_error"),
- )
- },
- })
-
- const deleteMutation = useMutation({
- mutationFn: async (name: string) => deleteSkill(name),
- onSuccess: (_, deletedName) => {
- toast.success(t("pages.agent.skills.delete_success"))
- setSkillPendingDelete(null)
- if (
- selectedSkill?.name === deletedName &&
- selectedSkill.source === "workspace"
- ) {
- setSelectedSkill(null)
- }
- void queryClient.invalidateQueries({ queryKey: ["skills"] })
- },
- onError: (err) => {
- toast.error(
- err instanceof Error
- ? err.message
- : t("pages.agent.skills.delete_error"),
- )
- },
- })
-
- const handleImportClick = () => {
- importInputRef.current?.click()
- }
-
- const handleImportFileChange = (event: ChangeEvent) => {
- const file = event.target.files?.[0]
- if (!file) return
- importMutation.mutate(file)
- event.target.value = ""
- }
-
- return (
- ()
- for (const item of data.tools) {
- const list = buckets.get(item.category) ?? []
- list.push(item)
- buckets.set(item.category, list)
- }
- return Array.from(buckets.entries())
- })()
-
- return (
- ) {
+ return ) {
+ return ) {
+ return ) {
+ return ) {
+ return (
+ & {
+ showCloseButton?: boolean
+}) {
+ return (
+
+
+ {children}
+ {showCloseButton && (
+
+
+
+ )}
+
+
+ )
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+ return (
+
+ )
+}
+
+function DialogFooter({
+ className,
+ showCloseButton = false,
+ children,
+ ...props
+}: React.ComponentProps<"div"> & {
+ showCloseButton?: boolean
+}) {
+ return (
+ ) {
+ return (
+ ) {
+ return (
+
Date: Wed, 1 Apr 2026 21:32:10 +0800
Subject: [PATCH 06/12] feat: add load_image tool for local file vision (#2116)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
* feat: add load_image tool for local file vision
* fix: address load_image PR review feedback
- Exclude load_image from sub-agent tools via Unregister after Clone,
since RunToolLoop does not call resolveMediaRefs
- Add ToolRegistry.Unregister() method
- Fix scope collision: use channel:chatID instead of filename
- Add channel/chatID context resolution matching send_file pattern
- Add comment explaining iteration > 1 guard on resolveMediaRefs
- Remove emoji from ForUser for consistency with send_file
- Add load_image_test.go
* feat: enable load_image for subagents via MediaResolver in RunToolLoop
Instead of removing load_image from sub-agent tools (28f69e71), inject a
MediaResolver into the legacy RunToolLoop fallback path so media:// refs
are resolved to base64 before each LLM call — matching the main agent
loop behavior.
- Add MediaResolver field to ToolLoopConfig and call it on iteration > 1
- Add SubagentManager.SetMediaResolver() and wire it through runTask
- Remove ToolRegistry.Unregister() (no longer needed)
- Restore load_image in sub-agent tool set (revert Clone+Unregister)
- Add TestSubagentManager_SetMediaResolver_StoresResolver
* refactor(load_image): remove prompt parameter from tool schema
* test(tools): add success-path test for LoadImageTool
Add TestLoadImage_SuccessPath that creates a real PNG file with valid
magic bytes, calls Execute with WithToolContext, and verifies:
- result.IsError == false
- ToolResult.Media contains a media:// ref
- ToolResult.ForLLM contains the [image: marker
- media ref is resolvable in the store
Add explanatory comment in loop.go for why Media and ArtifactTags
coexist on non-ResponseHandled tool results (e.g. load_image).
* fix: preallocate slice in tests and add ResponseHandled guard in toolloop
Fix prealloc linter failure in load_image_test.go.
Prevent double-resolving media by checking ResponseHandled in toolloop.go.
* Register TTS tool if provider is available
---------
Co-authored-by: Reusu
Co-authored-by: 美電球
---
pkg/agent/loop.go | 37 ++++++++
pkg/tools/load_image.go | 163 ++++++++++++++++++++++++++++++++
pkg/tools/load_image_test.go | 174 +++++++++++++++++++++++++++++++++++
pkg/tools/subagent.go | 19 ++++
pkg/tools/toolloop.go | 36 +++++++-
5 files changed, 425 insertions(+), 4 deletions(-)
create mode 100644 pkg/tools/load_image.go
create mode 100644 pkg/tools/load_image_test.go
diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index b376ed0af..19c1f0369 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -281,6 +281,17 @@ func registerSharedTools(
agent.Tools.Register(tools.NewSendTTSTool(ttsProvider, nil))
}
+ if cfg.Tools.IsToolEnabled("load_image") {
+ loadImageTool := tools.NewLoadImageTool(
+ agent.Workspace,
+ cfg.Agents.Defaults.RestrictToWorkspace,
+ cfg.Agents.Defaults.GetMaxMediaSize(),
+ nil,
+ allowReadPaths,
+ )
+ agent.Tools.Register(loadImageTool)
+ }
+
// Skill discovery and installation tools
skills_enabled := cfg.Tools.IsToolEnabled("skills")
find_skills_enable := cfg.Tools.IsToolEnabled("find_skills")
@@ -323,6 +334,14 @@ func registerSharedTools(
subagentManager := tools.NewSubagentManager(provider, agent.Model, agent.Workspace)
subagentManager.SetLLMOptions(agent.MaxTokens, agent.Temperature)
+ // Inject a media resolver so the legacy RunToolLoop fallback path can
+ // resolve media:// refs in the same way the main AgentLoop does.
+ // This keeps subagent vision support working even when the optimized
+ // sub-turn spawner path is unavailable.
+ subagentManager.SetMediaResolver(func(msgs []providers.Message) []providers.Message {
+ return resolveMediaRefs(msgs, al.mediaStore, cfg.Agents.Defaults.GetMaxMediaSize())
+ })
+
// Set the spawner that links into AgentLoop's turnState
subagentManager.SetSpawner(func(
ctx context.Context,
@@ -1861,6 +1880,14 @@ turnLoop:
providerToolDefs = filtered
}
+ // Resolve media:// refs produced by tool results (e.g. load_image).
+ // Skipped on iteration 1 because inbound user media is already resolved
+ // before entering the loop; only subsequent iterations can contain new
+ // tool-generated media refs that need base64 encoding.
+ if iteration > 1 {
+ messages = resolveMediaRefs(messages, al.mediaStore, maxMediaSize)
+ }
+
callMessages := messages
if gracefulTerminal {
callMessages = append(append([]providers.Message(nil), messages...), ts.interruptHintMessage())
@@ -2551,6 +2578,13 @@ turnLoop:
}
if len(toolResult.Media) > 0 && !toolResult.ResponseHandled {
+ // For tools like load_image that produce media refs without sending them
+ // to the user channel (ResponseHandled == false), both Media and ArtifactTags
+ // coexist on the result:
+ // - Media: carries media:// refs that resolveMediaRefs will base64-encode
+ // into image_url parts in the next LLM iteration (enabling vision).
+ // - ArtifactTags: exposes the local file path as a structured [file:…] tag
+ // in the tool result text, so the LLM knows an artifact was produced.
toolResult.ArtifactTags = buildArtifactTags(al.mediaStore, toolResult.Media)
}
@@ -2570,6 +2604,9 @@ turnLoop:
Content: contentForLLM,
ToolCallID: toolCallID,
}
+ if len(toolResult.Media) > 0 && !toolResult.ResponseHandled {
+ toolResultMsg.Media = append(toolResultMsg.Media, toolResult.Media...)
+ }
al.emitEvent(
EventKindToolExecEnd,
ts.eventMeta("runTurn", "turn.tool.end"),
diff --git a/pkg/tools/load_image.go b/pkg/tools/load_image.go
new file mode 100644
index 000000000..41ea6d054
--- /dev/null
+++ b/pkg/tools/load_image.go
@@ -0,0 +1,163 @@
+package tools
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "path/filepath"
+ "regexp"
+ "strings"
+
+ "github.com/sipeed/picoclaw/pkg/config"
+ "github.com/sipeed/picoclaw/pkg/media"
+)
+
+// LoadImageTool loads a local image file into the MediaStore and returns a
+// media:// reference. The agent loop's resolveMediaRefs will then base64-encode
+// it and attach it as an image_url part in the next LLM request, enabling
+// vision on local files — the same pipeline used when a user sends an image
+// through a chat channel.
+//
+// This is intentionally different from SendFileTool:
+// - SendFileTool → MediaResult + WithResponseHandled() → sends file to user, ends turn
+// - LoadImageTool → plain ToolResult with media:// in ForLLM → LLM sees the image next turn
+type LoadImageTool struct {
+ workspace string
+ restrict bool
+ maxFileSize int
+ mediaStore media.MediaStore
+ allowPaths []*regexp.Regexp
+
+ defaultChannel string
+ defaultChatID string
+}
+
+func NewLoadImageTool(
+ workspace string,
+ restrict bool,
+ maxFileSize int,
+ store media.MediaStore,
+ allowPaths ...[]*regexp.Regexp,
+) *LoadImageTool {
+ if maxFileSize <= 0 {
+ maxFileSize = config.DefaultMaxMediaSize
+ }
+ var patterns []*regexp.Regexp
+ if len(allowPaths) > 0 {
+ patterns = allowPaths[0]
+ }
+ return &LoadImageTool{
+ workspace: workspace,
+ restrict: restrict,
+ maxFileSize: maxFileSize,
+ mediaStore: store,
+ allowPaths: patterns,
+ }
+}
+
+func (t *LoadImageTool) Name() string { return "load_image" }
+
+func (t *LoadImageTool) Description() string {
+ return "Load a local image file so you can analyze its contents with vision. " +
+ "Supported formats: JPEG, PNG, GIF, WebP, BMP. " +
+ "After calling this tool, describe or analyze the image in your next response."
+}
+
+func (t *LoadImageTool) Parameters() map[string]any {
+ return map[string]any{
+ "type": "object",
+ "properties": map[string]any{
+ "path": map[string]any{
+ "type": "string",
+ "description": "Path to the local image file. Relative paths are resolved from workspace.",
+ },
+ },
+ "required": []string{"path"},
+ }
+}
+
+func (t *LoadImageTool) SetContext(channel, chatID string) {
+ t.defaultChannel = channel
+ t.defaultChatID = chatID
+}
+
+func (t *LoadImageTool) SetMediaStore(store media.MediaStore) {
+ t.mediaStore = store
+}
+
+func (t *LoadImageTool) Execute(ctx context.Context, args map[string]any) *ToolResult {
+ path, _ := args["path"].(string)
+ if strings.TrimSpace(path) == "" {
+ return ErrorResult("path is required")
+ }
+
+ // Prefer context-injected channel/chatID (set by ExecuteWithContext), fall back to SetContext values.
+ channel := ToolChannel(ctx)
+ if channel == "" {
+ channel = t.defaultChannel
+ }
+ chatID := ToolChatID(ctx)
+ if chatID == "" {
+ chatID = t.defaultChatID
+ }
+ if channel == "" || chatID == "" {
+ return ErrorResult("no target channel/chat available")
+ }
+
+ if t.mediaStore == nil {
+ return ErrorResult("media store not configured")
+ }
+
+ resolved, err := validatePathWithAllowPaths(path, t.workspace, t.restrict, t.allowPaths)
+ if err != nil {
+ return ErrorResult(fmt.Sprintf("invalid path: %v", err))
+ }
+
+ info, err := os.Stat(resolved)
+ if err != nil {
+ return ErrorResult(fmt.Sprintf("file not found: %v", err))
+ }
+ if info.IsDir() {
+ return ErrorResult("path is a directory, expected an image file")
+ }
+ if info.Size() > int64(t.maxFileSize) {
+ return ErrorResult(fmt.Sprintf(
+ "file too large: %d bytes (max %d bytes)", info.Size(), t.maxFileSize,
+ ))
+ }
+
+ // Detect MIME type — reuse the helper already in send_file.go
+ mediaType := detectMediaType(resolved)
+ if !strings.HasPrefix(mediaType, "image/") {
+ return ErrorResult(fmt.Sprintf(
+ "file does not appear to be an image (detected type: %s)", mediaType,
+ ))
+ }
+
+ filename := filepath.Base(resolved)
+ scope := fmt.Sprintf("tool:load_image:%s:%s", channel, chatID)
+
+ ref, err := t.mediaStore.Store(resolved, media.MediaMeta{
+ Filename: filename,
+ ContentType: mediaType,
+ Source: "tool:load_image",
+ CleanupPolicy: media.CleanupPolicyForgetOnly,
+ }, scope)
+ if err != nil {
+ return ErrorResult(fmt.Sprintf("failed to register image in media store: %v", err))
+ }
+
+ // Build the tool result text. The media:// ref will be picked up by
+ // resolveMediaRefs in loop_media.go and converted to a base64 data URL
+ // before the next LLM call, exactly like channel-received images.
+ msg := fmt.Sprintf("Image loaded: %s\n[image: %s]", filename, ref)
+
+ return &ToolResult{
+ ForLLM: msg,
+ ForUser: fmt.Sprintf("Loaded image: %s", filename),
+ // Media refs inside ForLLM are resolved by resolveMediaRefs in the
+ // agent loop before the next LLM call. Do NOT use MediaResult here —
+ // that would send the file to the user channel instead.
+ Media: []string{ref},
+ }
+}
diff --git a/pkg/tools/load_image_test.go b/pkg/tools/load_image_test.go
new file mode 100644
index 000000000..91118f93e
--- /dev/null
+++ b/pkg/tools/load_image_test.go
@@ -0,0 +1,174 @@
+package tools
+
+import (
+ "context"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "github.com/sipeed/picoclaw/pkg/config"
+ "github.com/sipeed/picoclaw/pkg/media"
+ "github.com/sipeed/picoclaw/pkg/providers"
+)
+
+func TestLoadImage_PathRequired(t *testing.T) {
+ tool := NewLoadImageTool("/tmp", false, 0, nil)
+ ctx := WithToolContext(context.Background(), "test", "chat1")
+ result := tool.Execute(ctx, map[string]any{})
+ if !result.IsError {
+ t.Fatal("expected error for missing path")
+ }
+}
+
+func TestLoadImage_NilMediaStore(t *testing.T) {
+ tool := NewLoadImageTool("/tmp", false, 0, nil)
+ ctx := WithToolContext(context.Background(), "test", "chat1")
+ result := tool.Execute(ctx, map[string]any{"path": "test.png"})
+ if !result.IsError || result.ForLLM != "media store not configured" {
+ t.Fatalf("expected media store error, got: %s", result.ForLLM)
+ }
+}
+
+func TestLoadImage_NoChannelContext(t *testing.T) {
+ store := media.NewFileMediaStore()
+ tool := NewLoadImageTool("/tmp", false, 0, store)
+ // No WithToolContext — should fail
+ result := tool.Execute(context.Background(), map[string]any{"path": "test.png"})
+ if !result.IsError || result.ForLLM != "no target channel/chat available" {
+ t.Fatalf("expected channel error, got: %s", result.ForLLM)
+ }
+}
+
+func TestLoadImage_NonImageFile(t *testing.T) {
+ dir := t.TempDir()
+ txtFile := filepath.Join(dir, "readme.txt")
+ os.WriteFile(txtFile, []byte("hello"), 0o644)
+
+ store := media.NewFileMediaStore()
+ tool := NewLoadImageTool(dir, false, 0, store)
+ ctx := WithToolContext(context.Background(), "test", "chat1")
+ result := tool.Execute(ctx, map[string]any{"path": txtFile})
+ if !result.IsError {
+ t.Fatal("expected error for non-image file")
+ }
+}
+
+func TestLoadImage_DefaultMaxSize(t *testing.T) {
+ tool := NewLoadImageTool("/tmp", false, 0, nil)
+ if tool.maxFileSize != config.DefaultMaxMediaSize {
+ t.Errorf("expected default max size %d, got %d", config.DefaultMaxMediaSize, tool.maxFileSize)
+ }
+}
+
+func TestLoadImage_FileTooLarge(t *testing.T) {
+ dir := t.TempDir()
+ bigFile := filepath.Join(dir, "big.png")
+ // Create a file with PNG header but exceeding max size
+ data := make([]byte, 1024)
+ copy(data, []byte{0x89, 0x50, 0x4E, 0x47}) // PNG magic bytes
+ os.WriteFile(bigFile, data, 0o644)
+
+ store := media.NewFileMediaStore()
+ tool := NewLoadImageTool(dir, false, 512, store) // maxSize = 512
+ ctx := WithToolContext(context.Background(), "test", "chat1")
+ result := tool.Execute(ctx, map[string]any{"path": bigFile})
+ if !result.IsError {
+ t.Fatal("expected error for oversized file")
+ }
+}
+
+func TestSubagentManager_SetMediaResolver_StoresResolver(t *testing.T) {
+ manager := NewSubagentManager(nil, "gpt-test", "/tmp")
+
+ called := false
+ manager.SetMediaResolver(func(msgs []providers.Message) []providers.Message {
+ called = true
+ return msgs
+ })
+
+ manager.mu.RLock()
+ got := manager.mediaResolver
+ manager.mu.RUnlock()
+
+ if got == nil {
+ t.Fatal("expected mediaResolver to be set")
+ }
+
+ if called {
+ t.Fatal("resolver should not be called during SetMediaResolver")
+ }
+}
+
+func TestLoadImage_SuccessPath(t *testing.T) {
+ dir := t.TempDir()
+
+ // Create a minimal valid PNG file (8-byte signature + minimal IHDR + IEND).
+ // The PNG spec requires the 8-byte magic header: 0x89 P N G \r \n 0x1a \n
+ pngSignature := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
+ // IHDR chunk: length(13) + "IHDR" + 1x1 px, 8-bit RGB, no interlace + CRC
+ ihdr := []byte{
+ 0x00, 0x00, 0x00, 0x0D, // chunk length = 13
+ 0x49, 0x48, 0x44, 0x52, // "IHDR"
+ 0x00, 0x00, 0x00, 0x01, // width = 1
+ 0x00, 0x00, 0x00, 0x01, // height = 1
+ 0x08, // bit depth = 8
+ 0x02, // color type = RGB
+ 0x00, 0x00, 0x00, // compression, filter, interlace
+ 0x90, 0x77, 0x53, 0xDE, // CRC (valid for this IHDR)
+ }
+ // IEND chunk
+ iend := []byte{
+ 0x00, 0x00, 0x00, 0x00, // chunk length = 0
+ 0x49, 0x45, 0x4E, 0x44, // "IEND"
+ 0xAE, 0x42, 0x60, 0x82, // CRC
+ }
+
+ pngData := make([]byte, 0, len(pngSignature)+len(ihdr)+len(iend))
+ pngData = append(pngData, pngSignature...)
+ pngData = append(pngData, ihdr...)
+ pngData = append(pngData, iend...)
+
+ imgPath := filepath.Join(dir, "test_image.png")
+ if err := os.WriteFile(imgPath, pngData, 0o644); err != nil {
+ t.Fatalf("failed to create test PNG: %v", err)
+ }
+
+ store := media.NewFileMediaStore()
+ tool := NewLoadImageTool(dir, false, 0, store)
+ ctx := WithToolContext(context.Background(), "test", "chat1")
+
+ result := tool.Execute(ctx, map[string]any{"path": imgPath})
+
+ // 1. Must not be an error
+ if result.IsError {
+ t.Fatalf("expected success, got error: %s", result.ForLLM)
+ }
+
+ // 2. Media must contain exactly one media:// ref
+ if len(result.Media) != 1 {
+ t.Fatalf("expected 1 media ref, got %d", len(result.Media))
+ }
+ if !strings.HasPrefix(result.Media[0], "media://") {
+ t.Errorf("expected media ref to start with 'media://', got: %s", result.Media[0])
+ }
+
+ // 3. ForLLM must contain the [image: marker
+ if !strings.Contains(result.ForLLM, "[image:") {
+ t.Errorf("expected ForLLM to contain '[image:' marker, got: %s", result.ForLLM)
+ }
+
+ // 4. ForLLM should also contain the media:// ref
+ if !strings.Contains(result.ForLLM, result.Media[0]) {
+ t.Errorf("expected ForLLM to contain media ref %q, got: %s", result.Media[0], result.ForLLM)
+ }
+
+ // 5. Verify the ref is resolvable in the store
+ resolved, err := store.Resolve(result.Media[0])
+ if err != nil {
+ t.Fatalf("media ref not resolvable: %v", err)
+ }
+ if resolved != imgPath {
+ t.Errorf("expected resolved path %q, got %q", imgPath, resolved)
+ }
+}
diff --git a/pkg/tools/subagent.go b/pkg/tools/subagent.go
index 9a1a8b802..ada89efb7 100644
--- a/pkg/tools/subagent.go
+++ b/pkg/tools/subagent.go
@@ -67,6 +67,12 @@ type SubagentManager struct {
hasTemperature bool
nextID int
spawner SpawnSubTurnFunc
+
+ // mediaResolver resolves media:// refs in tool-loop messages before
+ // each LLM call in the legacy RunToolLoop fallback path.
+ // This lets subagents reuse the same media handling behavior as the
+ // main agent loop without importing pkg/agent and creating a cycle.
+ mediaResolver func([]providers.Message) []providers.Message
}
func NewSubagentManager(
@@ -90,6 +96,17 @@ func (sm *SubagentManager) SetSpawner(spawner SpawnSubTurnFunc) {
sm.spawner = spawner
}
+// SetMediaResolver injects a message preprocessor that resolves media:// refs
+// into LLM-ready content before each tool-loop iteration.
+// This is only used by the legacy RunToolLoop fallback path.
+func (sm *SubagentManager) SetMediaResolver(
+ resolver func([]providers.Message) []providers.Message,
+) {
+ sm.mu.Lock()
+ defer sm.mu.Unlock()
+ sm.mediaResolver = resolver
+}
+
// SetLLMOptions sets max tokens and temperature for subagent LLM calls.
func (sm *SubagentManager) SetLLMOptions(maxTokens int, temperature float64) {
sm.mu.Lock()
@@ -177,6 +194,7 @@ func (sm *SubagentManager) runTask(
temperature := sm.temperature
hasMaxTokens := sm.hasMaxTokens
hasTemperature := sm.hasTemperature
+ mediaResolver := sm.mediaResolver
sm.mu.RUnlock()
var result *ToolResult
@@ -223,6 +241,7 @@ After completing the task, provide a clear summary of what was done.`
Tools: tools,
MaxIterations: maxIter,
LLMOptions: llmOptions,
+ MediaResolver: mediaResolver,
}, messages, task.OriginChannel, task.OriginChatID)
if err == nil {
diff --git a/pkg/tools/toolloop.go b/pkg/tools/toolloop.go
index 387813e94..ac568f598 100644
--- a/pkg/tools/toolloop.go
+++ b/pkg/tools/toolloop.go
@@ -24,6 +24,11 @@ type ToolLoopConfig struct {
Tools *ToolRegistry
MaxIterations int
LLMOptions map[string]any
+
+ // MediaResolver resolves media:// refs in messages before each LLM call.
+ // This is optional and is mainly used by subagent legacy fallback execution
+ // so subagents can reuse the same multimodal media handling as the main loop.
+ MediaResolver func(messages []providers.Message) []providers.Message
}
// ToolLoopResult contains the result of running the tool loop.
@@ -63,8 +68,27 @@ func RunToolLoop(
if llmOpts == nil {
llmOpts = map[string]any{}
}
- // 3. Call LLM
- response, err := config.Provider.Chat(ctx, messages, providerToolDefs, config.Model, llmOpts)
+
+ // 3. Resolve media:// refs and Call LLM.
+ // Tools like load_image produce media:// refs in their result messages.
+ // Without this step, the LLM would receive raw "media://uuid" strings
+ // instead of base64-encoded image data URLs.
+ //
+ // We build a separate callMessages slice so that:
+ // (a) the resolver output is used for the LLM call only,
+ // (b) the original `messages` slice keeps the unresolved refs for
+ // subsequent iterations — the resolver is idempotent but working
+ // on the original avoids double-encoding issues.
+ //
+ // On iteration 1 the initial user messages typically have no media://
+ // refs (they come from plain text), so this is effectively a no-op;
+ // it becomes relevant from iteration 2 onward when tool results may
+ // contain media refs.
+ callMessages := messages
+ if config.MediaResolver != nil && iteration > 1 {
+ callMessages = config.MediaResolver(messages)
+ }
+ response, err := config.Provider.Chat(ctx, callMessages, providerToolDefs, config.Model, llmOpts)
if err != nil {
logger.ErrorCF("toolloop", "LLM call failed",
map[string]any{
@@ -161,11 +185,15 @@ func RunToolLoop(
for _, r := range results {
contentForLLM := r.result.ContentForLLM()
- messages = append(messages, providers.Message{
+ toolMsg := providers.Message{
Role: "tool",
Content: contentForLLM,
ToolCallID: r.tc.ID,
- })
+ }
+ if len(r.result.Media) > 0 && !r.result.ResponseHandled {
+ toolMsg.Media = append(toolMsg.Media, r.result.Media...)
+ }
+ messages = append(messages, toolMsg)
}
}
From e2a9bb97c72f0852a19c847c142ace1120944bbc Mon Sep 17 00:00:00 2001
From: Cytown
Date: Wed, 1 Apr 2026 23:26:49 +0800
Subject: [PATCH 07/12] unify all panic event to panic log file (#2250)
---
pkg/agent/loop.go | 1 +
pkg/agent/subturn.go | 1 +
pkg/channels/discord/voice.go | 1 +
pkg/logger/panic.go | 40 ++++++++++++++++++++--------
pkg/tools/registry.go | 1 +
web/backend/middleware/middleware.go | 1 +
6 files changed, 34 insertions(+), 11 deletions(-)
diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index 19c1f0369..15535e138 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -991,6 +991,7 @@ func (al *AgentLoop) ReloadProviderAndConfig(
go func() {
defer func() {
if r := recover(); r != nil {
+ logger.RecoverPanicNoExit(r)
panicErr = fmt.Errorf("panic during registry creation: %v", r)
logger.ErrorCF("agent", "Panic during registry creation",
map[string]any{"panic": r})
diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go
index f5ba412ab..82a2a2010 100644
--- a/pkg/agent/subturn.go
+++ b/pkg/agent/subturn.go
@@ -427,6 +427,7 @@ func spawnSubTurn(
// 7. Defer cleanup: deliver result (for async), emit End event, and recover from panics
defer func() {
if r := recover(); r != nil {
+ logger.RecoverPanicNoExit(r)
err = fmt.Errorf("subturn panicked: %v", r)
result = nil
logger.ErrorCF("subturn", "SubTurn panicked", map[string]any{
diff --git a/pkg/channels/discord/voice.go b/pkg/channels/discord/voice.go
index 5b686b141..554b8ae71 100644
--- a/pkg/channels/discord/voice.go
+++ b/pkg/channels/discord/voice.go
@@ -120,6 +120,7 @@ func streamOggOpusToDiscord(ctx context.Context, vc *discordgo.VoiceConnection,
defer func() {
if rec := recover(); rec != nil {
retErr = fmt.Errorf("voice connection closed during playback")
+ logger.RecoverPanicNoExit(rec)
}
}()
diff --git a/pkg/logger/panic.go b/pkg/logger/panic.go
index e53e4351a..0a9125dda 100644
--- a/pkg/logger/panic.go
+++ b/pkg/logger/panic.go
@@ -2,12 +2,15 @@ package logger
import (
"fmt"
+ "io"
"os"
"path/filepath"
"runtime/debug"
"time"
)
+var panicWriter io.WriteCloser
+
func InitPanic(filePath string) (func(), error) {
if err := os.MkdirAll(filepath.Dir(filePath), 0o755); err != nil {
return nil, fmt.Errorf("failed to create log directory: %w", err)
@@ -16,21 +19,36 @@ func InitPanic(filePath string) (func(), error) {
if writer == nil {
return nil, fmt.Errorf("failed to create log file: %s", filePath)
}
+ if panicWriter != nil {
+ _ = panicWriter.Close()
+ }
+ panicWriter = writer
return func() {
- defer writer.Close()
+ defer func() {
+ writer.Close()
+ panicWriter = nil
+ }()
if err := recover(); err != nil {
- now := time.Now().Format("2006-01-02 15:04:05")
- stack := debug.Stack()
- logMsg := "\n\n====================\n[" + now + "] PANIC OCCURRED: " + fmt.Sprintf(
- "%v",
- err,
- ) + "\n" + string(
- stack,
- )
-
- writer.Write([]byte(logMsg))
+ RecoverPanicNoExit(err)
os.Exit(1)
}
}, nil
}
+
+func RecoverPanicNoExit(err any) {
+ if panicWriter == nil {
+ Errorf("panicWriter is nil, should not happen")
+ return
+ }
+ now := time.Now().Format("2006-01-02 15:04:05")
+ stack := debug.Stack()
+ logMsg := "\n\n====================\n[" + now + "] PANIC OCCURRED: " + fmt.Sprintf(
+ "%v",
+ err,
+ ) + "\n" + string(
+ stack,
+ )
+
+ panicWriter.Write([]byte(logMsg))
+}
diff --git a/pkg/tools/registry.go b/pkg/tools/registry.go
index 56af8d695..e51dff71a 100644
--- a/pkg/tools/registry.go
+++ b/pkg/tools/registry.go
@@ -228,6 +228,7 @@ func (r *ToolRegistry) ExecuteWithContext(
func() {
defer func() {
if re := recover(); re != nil {
+ logger.RecoverPanicNoExit(re)
errMsg := fmt.Sprintf("Tool '%s' crashed with panic: %v", name, re)
logger.ErrorCF("tool", "Tool execution panic recovered",
map[string]any{
diff --git a/web/backend/middleware/middleware.go b/web/backend/middleware/middleware.go
index a0b7eb998..f9eb3149d 100644
--- a/web/backend/middleware/middleware.go
+++ b/web/backend/middleware/middleware.go
@@ -71,6 +71,7 @@ func Recoverer(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
+ logger.RecoverPanicNoExit(err)
logger.ErrorC("http", fmt.Sprintf("panic recovered: %v\n%s", err, debug.Stack()))
http.Error(w, `{"error":"internal server error"}`, http.StatusInternalServerError)
}
From 49e61fa07f07abdd57b96fbb0c40b64702d21868 Mon Sep 17 00:00:00 2001
From: sky5454
Date: Wed, 1 Apr 2026 23:41:32 +0800
Subject: [PATCH 08/12] feat(updater): robust self-update selection &
extraction (nightly default) (#2201)
* feat(updater): add web self-update endpoint and updater package
* feat(selfupgrade): when url empty, using GetTestReleaseAPIURL for test .
* feat(selfupgrade): only GetTestReleaseAPIURL .
* feat(upgrade): cli $0 update work well!
* fix(ci): fix ci err
* fix(test): fix ci test
* fix(ci): fix ci lint fmt err
* test(updater): add test for updater
* fix(ci): fix ci lint var copy err
* fix(ci): retry ci
* updater: require checksum verification, prefer API digest, verify SHA256, fix zip extraction, update tests
* fix(lint): lint fixed
* fix(lint): lint fixed2
* updater: stream download and verify sha256; add http client timeout and progress
Avoid double-download by streaming asset into temp file while computing SHA256 and verifying against checksum; replace http.Get with shared httpClient (2m timeout) to prevent hangs; add simple stderr progress display; remove unused helpers.
---
cmd/picoclaw/main.go | 2 +
cmd/picoclaw/main_test.go | 1 +
go.mod | 2 +
go.sum | 11 +
pkg/updater/updater.go | 707 ++++++++++++++++++++++++++++++++++++
pkg/updater/updater_test.go | 97 +++++
web/backend/api/router.go | 3 +
web/backend/api/update.go | 52 +++
8 files changed, 875 insertions(+)
create mode 100644 pkg/updater/updater.go
create mode 100644 pkg/updater/updater_test.go
create mode 100644 web/backend/api/update.go
diff --git a/cmd/picoclaw/main.go b/cmd/picoclaw/main.go
index bf9c0389f..48dffbb33 100644
--- a/cmd/picoclaw/main.go
+++ b/cmd/picoclaw/main.go
@@ -24,6 +24,7 @@ import (
"github.com/sipeed/picoclaw/cmd/picoclaw/internal/status"
"github.com/sipeed/picoclaw/cmd/picoclaw/internal/version"
"github.com/sipeed/picoclaw/pkg/config"
+ "github.com/sipeed/picoclaw/pkg/updater"
)
func NewPicoclawCommand() *cobra.Command {
@@ -45,6 +46,7 @@ func NewPicoclawCommand() *cobra.Command {
migrate.NewMigrateCommand(),
skills.NewSkillsCommand(),
model.NewModelCommand(),
+ updater.NewUpdateCommand("picoclaw"),
version.NewVersionCommand(),
)
diff --git a/cmd/picoclaw/main_test.go b/cmd/picoclaw/main_test.go
index ad18cb330..cb221dece 100644
--- a/cmd/picoclaw/main_test.go
+++ b/cmd/picoclaw/main_test.go
@@ -43,6 +43,7 @@ func TestNewPicoclawCommand(t *testing.T) {
"onboard",
"skills",
"status",
+ "update",
"version",
}
diff --git a/go.mod b/go.mod
index 5f311306e..3fa15b427 100644
--- a/go.mod
+++ b/go.mod
@@ -23,6 +23,7 @@ require (
github.com/h2non/filetype v1.1.3
github.com/larksuite/oapi-sdk-go/v3 v3.5.3
github.com/mdp/qrterminal/v3 v3.2.1
+ github.com/minio/selfupdate v0.6.0
github.com/modelcontextprotocol/go-sdk v1.4.1
github.com/mymmrac/telego v1.7.0
github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1
@@ -48,6 +49,7 @@ require (
)
require (
+ aead.dev/minisign v0.2.0 // indirect
filippo.io/edwards25519 v1.2.0 // indirect
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 // indirect
github.com/aws/aws-sdk-go-v2/credentials v1.19.12 // indirect
diff --git a/go.sum b/go.sum
index ca5dd0423..c1fef5983 100644
--- a/go.sum
+++ b/go.sum
@@ -1,3 +1,5 @@
+aead.dev/minisign v0.2.0 h1:kAWrq/hBRu4AARY6AlciO83xhNnW9UaC8YipS2uhLPk=
+aead.dev/minisign v0.2.0/go.mod h1:zdq6LdSd9TbuSxchxwhpA9zEb9YXcVGoE8JakuiGaIQ=
cloud.google.com/go/compute/metadata v0.3.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k=
filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
@@ -184,6 +186,8 @@ github.com/mattn/go-sqlite3 v1.14.34 h1:3NtcvcUnFBPsuRcno8pUtupspG/GM+9nZ88zgJcp
github.com/mattn/go-sqlite3 v1.14.34/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/mdp/qrterminal/v3 v3.2.1 h1:6+yQjiiOsSuXT5n9/m60E54vdgFsw0zhADHhHLrFet4=
github.com/mdp/qrterminal/v3 v3.2.1/go.mod h1:jOTmXvnBsMy5xqLniO0R++Jmjs2sTm9dFSuQ5kpz/SU=
+github.com/minio/selfupdate v0.6.0 h1:i76PgT0K5xO9+hjzKcacQtO7+MjJ4JKA8Ak8XQ9DDwU=
+github.com/minio/selfupdate v0.6.0/go.mod h1:bO02GTIPCMQFTEvE5h4DjYB58bCoZ35XLeBf0buTDdM=
github.com/modelcontextprotocol/go-sdk v1.4.1 h1:M4x9GyIPj+HoIlHNGpK2hq5o3BFhC+78PkEaldQRphc=
github.com/modelcontextprotocol/go-sdk v1.4.1/go.mod h1:Bo/mS87hPQqHSRkMv4dQq1XCu6zv4INdXnFZabkNU6s=
github.com/mymmrac/telego v1.7.0 h1:yRO/l00tFGG4nY66ufUKb4ARqv7qx9+LsjQv/b0NEyo=
@@ -308,7 +312,10 @@ golang.org/x/arch v0.24.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20211209193657-4570a0811e8b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
@@ -329,6 +336,7 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
@@ -351,11 +359,13 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210228012217-479acdf4ea46/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -369,6 +379,7 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
diff --git a/pkg/updater/updater.go b/pkg/updater/updater.go
new file mode 100644
index 000000000..e73c1e859
--- /dev/null
+++ b/pkg/updater/updater.go
@@ -0,0 +1,707 @@
+package updater
+
+import (
+ "archive/tar"
+ "archive/zip"
+ "compress/gzip"
+ "crypto/sha256"
+ "encoding/hex"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "os"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "strings"
+ "time"
+
+ "github.com/minio/selfupdate"
+ "github.com/spf13/cobra"
+
+ "github.com/sipeed/picoclaw/pkg/config"
+)
+
+// httpClient is a shared HTTP client used for release checks and downloads.
+// The Timeout value applies to the entire HTTP request: dialing, TLS
+// handshake, redirects, and reading the response body. It is NOT only
+// a connection (dial) timeout. To control lower-level timeouts (dial,
+// TLS handshake, response header wait), supply a custom Transport with
+// an appropriately configured net.Dialer.
+var httpClient = &http.Client{Timeout: 2 * time.Minute}
+
+// DownloadAndExtractRelease downloads a release archive (or uses a direct
+// asset URL) and extracts it to a temporary directory. It returns the
+// extraction directory on success. If releaseURL is empty, the latest
+// release of the current project is used. platform/arch can be used to
+// select the correct asset (e.g. "linux", "amd64").
+func DownloadAndExtractRelease(releaseURL, platform, arch string) (string, error) {
+ assetURL, checksum, err := findAssetInfo(releaseURL, platform, arch)
+ if err != nil {
+ return "", err
+ }
+
+ // Download asset to temp file. Use the asset URL extension so
+ // extractArchive can detect the archive format (zip/tar.gz/tar).
+ tmpPattern := "picoclaw-release-*"
+ if u, perr := url.Parse(assetURL); perr == nil {
+ base := filepath.Base(u.Path)
+ lbase := strings.ToLower(base)
+ switch {
+ case strings.HasSuffix(lbase, ".zip"):
+ tmpPattern += ".zip"
+ case strings.HasSuffix(lbase, ".tar.gz") || strings.HasSuffix(lbase, ".tgz"):
+ tmpPattern += ".tar.gz"
+ case strings.HasSuffix(lbase, ".tar"):
+ tmpPattern += ".tar"
+ default:
+ tmpPattern += ".archive"
+ }
+ } else {
+ tmpPattern += ".archive"
+ }
+
+ tmpFile, err := os.CreateTemp("", tmpPattern)
+ if err != nil {
+ return "", err
+ }
+ tmpPath := tmpFile.Name()
+ defer tmpFile.Close()
+
+ resp, err := httpClient.Get(assetURL)
+ if err != nil {
+ os.Remove(tmpPath)
+ return "", err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ os.Remove(tmpPath)
+ return "", fmt.Errorf("failed to download asset: status %d", resp.StatusCode)
+ }
+
+ // Stream download while computing SHA256 to avoid a second download.
+ // Also show a simple progress line to stderr so users see activity.
+ h := sha256.New()
+ pw := &progressWriter{total: resp.ContentLength}
+ mw := io.MultiWriter(tmpFile, h, pw)
+ if _, err = io.Copy(mw, resp.Body); err != nil {
+ _ = os.Remove(tmpPath)
+ return "", err
+ }
+ // ensure final progress line ends with newline
+ pw.Finish()
+
+ // verify checksum if available
+ if checksum != "" {
+ got := hex.EncodeToString(h.Sum(nil))
+ if !strings.EqualFold(got, checksum) {
+ _ = os.Remove(tmpPath)
+ return "", fmt.Errorf("checksum mismatch: got %s expected %s", got, checksum)
+ }
+ }
+
+ // Extract
+ destDir, err := os.MkdirTemp("", "picoclaw-extract-*")
+ if err != nil {
+ os.Remove(tmpPath)
+ return "", err
+ }
+
+ if err := extractArchive(tmpPath, destDir); err != nil {
+ os.Remove(tmpPath)
+ os.RemoveAll(destDir)
+ return "", err
+ }
+
+ // cleanup archive file; keep extracted contents
+ _ = os.Remove(tmpPath)
+ return destDir, nil
+}
+
+// UpdateSelfFromRelease downloads the release matching the given parameters,
+// extracts it and applies the binary named programName to update the
+// currently running executable using minio/selfupdate.
+// If releaseURL is empty, the latest release is used. If platform or arch
+// is empty, runtime values are used.
+func UpdateSelfFromRelease(releaseURL, platform, arch, programName string) error {
+ if platform == "" {
+ platform = runtime.GOOS
+ }
+ if arch == "" {
+ arch = runtime.GOARCH
+ }
+
+ dir, err := DownloadAndExtractRelease(releaseURL, platform, arch)
+ if err != nil {
+ return err
+ }
+ defer os.RemoveAll(dir)
+
+ binPath, err := findBinaryInDir(dir, programName)
+ if err != nil {
+ return err
+ }
+
+ // ensure executable bit on non-windows
+ if runtime.GOOS != "windows" {
+ _ = os.Chmod(binPath, 0o755)
+ }
+
+ f, err := os.Open(binPath)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ // Backup current executable so we can roll back if needed.
+ var opts selfupdate.Options
+ if exePath, err := os.Executable(); err == nil {
+ opts.OldSavePath = exePath + ".old"
+ }
+
+ if err := selfupdate.Apply(f, opts); err != nil {
+ return fmt.Errorf("apply update: %w", err)
+ }
+
+ return nil
+}
+
+// UpdateSelf updates the running executable by fetching the latest release
+// and applying the binary matching programName.
+func UpdateSelf(programName string) error {
+ // By default, select the latest stable release when no explicit
+ // release URL is provided. Use --nightly or a custom URL to override.
+ return UpdateSelfFromRelease("", runtime.GOOS, runtime.GOARCH, programName)
+}
+
+// GetReleaseAPIURL returns the GitHub Releases API URL for the given repo owner.
+// Example: owner="sky5454" -> https://api.github.com/repos/sky5454/picoclaw/releases/latest
+func GetReleaseAPIURL(owner string) string {
+ return fmt.Sprintf("https://api.github.com/repos/%s/picoclaw/releases/latest", owner)
+}
+
+// GetProdReleaseAPIURL returns the production release API URL (upstream).
+func GetProdReleaseAPIURL() string {
+ return GetReleaseAPIURL("sipeed")
+}
+
+// GetReleaseTagAPIURL returns the GitHub Releases API URL for a specific tag.
+// Example: owner="sipeed", tag="nightly" -> https://api.github.com/repos/sipeed/picoclaw/releases/tags/nightly
+func GetReleaseTagAPIURL(owner, tag string) string {
+ return fmt.Sprintf("https://api.github.com/repos/%s/picoclaw/releases/tags/%s", owner, tag)
+}
+
+// GetNightlyReleaseAPIURL returns the nightly release API URL for the production repo.
+func GetNightlyReleaseAPIURL() string {
+ return GetReleaseTagAPIURL("sipeed", "nightly")
+}
+
+// findAssetURL resolves the appropriate asset URL for the given release
+// selector. It accepts direct archive URLs as well as GitHub release URLs
+// or empty (latest release for the project).
+func findAssetInfo(releaseURL, platform, arch string) (string, string, error) {
+ // returns (assetURL, sha256ChecksumHex, error)
+ if looksLikeDirectAssetURL(releaseURL) {
+ return "", "", fmt.Errorf("no checksum found for asset %s", releaseURL)
+ }
+
+ apiURL := buildReleaseAPIURL(releaseURL)
+ if apiURL == "" {
+ // If caller provided an empty releaseURL, default to the
+ // production latest release API URL (stable release).
+ apiURL = GetProdReleaseAPIURL()
+ }
+
+ resp, err := httpClient.Get(apiURL)
+ if err != nil {
+ return "", "", err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ return "", "", fmt.Errorf("failed to query releases: status %d", resp.StatusCode)
+ }
+
+ var data struct {
+ TagName string `json:"tag_name"`
+ Assets []struct {
+ Name string `json:"name"`
+ BrowserDownloadURL string `json:"browser_download_url"`
+ Digest string `json:"digest"`
+ } `json:"assets"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+ return "", "", err
+ }
+
+ // Selection order: platform -> arch -> extension.
+ platformLower := strings.ToLower(platform)
+ archLower := strings.ToLower(arch)
+
+ isZip := func(name string) bool {
+ return strings.HasSuffix(name, ".zip")
+ }
+ isTarGz := func(name string) bool {
+ return strings.HasSuffix(name, ".tar.gz") || strings.HasSuffix(name, ".tgz")
+ }
+ isTar := func(name string) bool { return strings.HasSuffix(name, ".tar") }
+
+ // collect indices of assets that contain platform (if provided)
+ var platformIdx []int
+ for i, a := range data.Assets {
+ n := strings.ToLower(a.Name)
+ if platform == "" || strings.Contains(n, platformLower) {
+ platformIdx = append(platformIdx, i)
+ }
+ }
+
+ pickBest := func(idxs []int) (string, int, bool) {
+ if len(idxs) == 0 {
+ return "", -1, false
+ }
+ // prefer arch matches within idxs; if arch was specified but
+ // no arch match exists among idxs, treat as no candidate.
+ var archIdx []int
+ if arch != "" {
+ aliases := archAliases(archLower)
+ for _, i := range idxs {
+ n := strings.ToLower(data.Assets[i].Name)
+ for _, ali := range aliases {
+ if strings.Contains(n, ali) {
+ archIdx = append(archIdx, i)
+ break
+ }
+ }
+ }
+ if len(archIdx) == 0 {
+ return "", -1, false
+ }
+ }
+ candidates := archIdx
+ if len(candidates) == 0 {
+ candidates = idxs
+ }
+
+ // extension preference
+ if platformLower == "windows" {
+ // prefer .zip only
+ for _, i := range candidates {
+ if isZip(strings.ToLower(data.Assets[i].Name)) {
+ return data.Assets[i].BrowserDownloadURL, i, true
+ }
+ }
+ // if no zip found, fallthrough to first candidate
+ return data.Assets[candidates[0]].BrowserDownloadURL, candidates[0], true
+ }
+
+ // non-windows: prefer tar.gz/tgz, then tar, then zip
+ for _, i := range candidates {
+ if isTarGz(strings.ToLower(data.Assets[i].Name)) {
+ return data.Assets[i].BrowserDownloadURL, i, true
+ }
+ }
+ for _, i := range candidates {
+ if isTar(strings.ToLower(data.Assets[i].Name)) {
+ return data.Assets[i].BrowserDownloadURL, i, true
+ }
+ }
+ for _, i := range candidates {
+ if isZip(strings.ToLower(data.Assets[i].Name)) {
+ return data.Assets[i].BrowserDownloadURL, i, true
+ }
+ }
+ // fallback to first candidate
+ return data.Assets[candidates[0]].BrowserDownloadURL, candidates[0], true
+ }
+
+ // Try platform matches first
+ if url, idx, ok := pickBest(platformIdx); ok {
+ // attempt to find checksum: prefer asset digest from API if present
+ if d := strings.TrimSpace(data.Assets[idx].Digest); d != "" {
+ dLower := strings.ToLower(d)
+ if strings.HasPrefix(dLower, "sha256:") {
+ hexpart := strings.TrimPrefix(dLower, "sha256:")
+ return url, hexpart, nil
+ }
+ // If digest already looks like a 64-hex, return it
+ if ok, _ := regexp.MatchString("(?i)^[a-f0-9]{64}$", dLower); ok {
+ return url, dLower, nil
+ }
+ }
+ // Look for checksum assets and verify by computing the asset's sha256.
+ for j, a := range data.Assets {
+ n := strings.ToLower(a.Name)
+ if strings.Contains(n, "sha256") ||
+ strings.Contains(n, "sha256sum") ||
+ strings.Contains(n, "checksums") ||
+ strings.HasSuffix(n, ".sha256") ||
+ strings.HasSuffix(n, ".sha256sum") {
+ resp2, err := httpClient.Get(data.Assets[j].BrowserDownloadURL)
+ if err != nil {
+ continue
+ }
+ bs, err := io.ReadAll(resp2.Body)
+ resp2.Body.Close()
+ if err != nil {
+ continue
+ }
+ if h, ok := findHashInChecksumContent(bs, url); ok {
+ return url, h, nil
+ }
+ }
+ }
+ // No checksum found for the selected platform asset -> error
+ return "", "", fmt.Errorf("no checksum found for asset %s", url)
+ }
+
+ // No platform match — require explicit platform+arch; fail fast.
+ return "", "", fmt.Errorf("no release asset matching platform %q and arch %q", platform, arch)
+}
+
+func looksLikeDirectAssetURL(u string) bool {
+ if u == "" {
+ return false
+ }
+ lower := strings.ToLower(u)
+ if strings.HasSuffix(lower, ".zip") ||
+ strings.HasSuffix(lower, ".tar.gz") ||
+ strings.HasSuffix(lower, ".tgz") ||
+ strings.HasSuffix(lower, ".tar") {
+ return true
+ }
+ if strings.Contains(lower, "/releases/download/") {
+ return true
+ }
+ return false
+}
+
+func buildReleaseAPIURL(releaseURL string) string {
+ if releaseURL == "" {
+ return ""
+ }
+ if strings.Contains(releaseURL, "api.github.com") {
+ return releaseURL
+ }
+ u, err := url.Parse(releaseURL)
+ if err != nil {
+ return ""
+ }
+ if u.Host != "github.com" {
+ return ""
+ }
+ parts := strings.Split(strings.Trim(u.Path, "/"), "/")
+ if len(parts) < 2 {
+ return ""
+ }
+ owner := parts[0]
+ repo := parts[1]
+ // if tag specified
+ if len(parts) >= 5 && parts[2] == "releases" && parts[3] == "tag" {
+ tag := parts[4]
+ return fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/tags/%s", owner, repo, tag)
+ }
+ // default to latest
+ return fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", owner, repo)
+}
+
+// NOTE: helper functions to compute SHA256 from URL/path were removed
+// after refactoring to stream the download and verify the checksum
+// during the single download to avoid double-transfer.
+
+// findHashInChecksumContent attempts to locate a 64-hex SHA256 in the
+// checksum file content that corresponds to assetURL. It returns the
+// found hash (lowercase) and true, or "", false if not found.
+func findHashInChecksumContent(bs []byte, assetURL string) (string, bool) {
+ s := strings.ToLower(string(bs))
+ var assetBase string
+ if u, err := url.Parse(assetURL); err == nil {
+ assetBase = strings.ToLower(filepath.Base(u.Path))
+ } else {
+ assetBase = strings.ToLower(filepath.Base(assetURL))
+ }
+ re := regexp.MustCompile(`(?i)\b([a-f0-9]{64})\b`)
+ // prefer a line containing the asset filename
+ for _, line := range strings.Split(s, "\n") {
+ if strings.Contains(line, assetBase) {
+ if m := re.FindString(line); m != "" {
+ return m, true
+ }
+ }
+ }
+ // fallback: if there's exactly one unique 64-hex value, return it
+ matches := re.FindAllString(s, -1)
+ uniq := map[string]struct{}{}
+ for _, m := range matches {
+ uniq[m] = struct{}{}
+ }
+ if len(uniq) == 1 {
+ for k := range uniq {
+ return k, true
+ }
+ }
+ return "", false
+}
+
+// progressWriter implements io.Writer and prints a simple progress
+// line to stderr while bytes are written. It is intended to be used
+// as one writer in an io.MultiWriter so we can stream-to-disk, compute
+// the sha256, and update the progress display in a single pass.
+type progressWriter struct {
+ total int64
+ written int64
+ last time.Time
+}
+
+func (pw *progressWriter) Write(p []byte) (int, error) {
+ n := len(p)
+ pw.written += int64(n)
+ now := time.Now()
+ if pw.last.IsZero() || now.Sub(pw.last) >= 200*time.Millisecond || (pw.total > 0 && pw.written == pw.total) {
+ pw.print()
+ pw.last = now
+ }
+ return n, nil
+}
+
+func (pw *progressWriter) print() {
+ if pw.total > 0 {
+ pct := float64(pw.written) * 100.0 / float64(pw.total)
+ fmt.Fprintf(os.Stderr, "\rDownloading: %s / %s (%.1f%%)", humanBytes(pw.written), humanBytes(pw.total), pct)
+ } else {
+ fmt.Fprintf(os.Stderr, "\rDownloading: %s", humanBytes(pw.written))
+ }
+}
+
+func (pw *progressWriter) Finish() {
+ pw.print()
+ fmt.Fprintln(os.Stderr, "")
+}
+
+func humanBytes(n int64) string {
+ f := float64(n)
+ const (
+ KB = 1024.0
+ MB = KB * 1024.0
+ GB = MB * 1024.0
+ )
+ switch {
+ case f >= GB:
+ return fmt.Sprintf("%.2f GB", f/GB)
+ case f >= MB:
+ return fmt.Sprintf("%.2f MB", f/MB)
+ case f >= KB:
+ return fmt.Sprintf("%.2f KB", f/KB)
+ default:
+ return fmt.Sprintf("%d B", n)
+ }
+}
+
+// archAliases returns common name variants for an architecture string
+// so we can match release asset names like "x86_64" vs Go's "amd64".
+// archAliases returns name variants for an architecture string.
+// If `arch` is empty or matches the local runtime.GOARCH, prefer the
+// compile-time architecture aliases provided by archAliasesForLocal
+// (implemented per-architecture via build tags). For other `arch`
+// values we use a small synonyms map.
+func archAliases(arch string) []string {
+ a := strings.ToLower(arch)
+ if syns, ok := archSynonyms[a]; ok {
+ return syns
+ }
+ return []string{a}
+}
+
+var archSynonyms = map[string][]string{
+ "amd64": {"amd64", "x86_64", "x64"},
+ "x86_64": {"amd64", "x86_64", "x64"},
+ "x64": {"amd64", "x86_64", "x64"},
+ "386": {"386", "x86"},
+ "x86": {"386", "x86"},
+ "arm64": {"arm64", "aarch64"},
+ "aarch64": {"arm64", "aarch64"},
+ "arm": {"arm"},
+}
+
+func extractArchive(archivePath, destDir string) error {
+ lower := strings.ToLower(archivePath)
+ if strings.HasSuffix(lower, ".zip") {
+ return extractZip(archivePath, destDir)
+ }
+ // treat .tar.gz and .tgz as gzip+tar
+ if strings.HasSuffix(lower, ".tar.gz") || strings.HasSuffix(lower, ".tgz") {
+ return extractTarGz(archivePath, destDir)
+ }
+ if strings.HasSuffix(lower, ".tar") {
+ return extractTar(archivePath, destDir)
+ }
+ // fallback: try tar.gz
+ return extractTarGz(archivePath, destDir)
+}
+
+func extractZip(archivePath, destDir string) error {
+ r, err := zip.OpenReader(archivePath)
+ if err != nil {
+ return err
+ }
+ defer r.Close()
+ destClean := filepath.Clean(destDir)
+ for _, f := range r.File {
+ target := filepath.Clean(filepath.Join(destClean, f.Name))
+ if !strings.HasPrefix(target, destClean+string(os.PathSeparator)) && target != destClean {
+ return fmt.Errorf("path traversal detected: %s", f.Name)
+ }
+ if f.FileInfo().IsDir() {
+ if err := os.MkdirAll(target, f.FileInfo().Mode()); err != nil {
+ return err
+ }
+ continue
+ }
+ if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+ return err
+ }
+ rc, err := f.Open()
+ if err != nil {
+ return err
+ }
+ out, err := os.OpenFile(target, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, f.FileInfo().Mode())
+ if err != nil {
+ rc.Close()
+ return err
+ }
+ if _, err := io.Copy(out, rc); err != nil {
+ rc.Close()
+ out.Close()
+ return err
+ }
+ rc.Close()
+ out.Close()
+ }
+ return nil
+}
+
+func extractTarGz(archivePath, destDir string) error {
+ f, err := os.Open(archivePath)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ gzr, err := gzip.NewReader(f)
+ if err != nil {
+ return err
+ }
+ defer gzr.Close()
+ tr := tar.NewReader(gzr)
+ return extractTarFromReader(tr, destDir)
+}
+
+func extractTar(archivePath, destDir string) error {
+ f, err := os.Open(archivePath)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ tr := tar.NewReader(f)
+ return extractTarFromReader(tr, destDir)
+}
+
+// extractTarFromReader contains logic common to extracting entries from a
+// tar.Reader and is used by both extractTarGz and extractTar to avoid
+// duplicated code (golangci-lint: dupl).
+func extractTarFromReader(tr *tar.Reader, destDir string) error {
+ for {
+ hdr, err := tr.Next()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ return err
+ }
+ target := filepath.Clean(filepath.Join(filepath.Clean(destDir), hdr.Name))
+ if !strings.HasPrefix(target, filepath.Clean(destDir)+string(os.PathSeparator)) &&
+ target != filepath.Clean(destDir) {
+ return fmt.Errorf("path traversal detected: %s", hdr.Name)
+ }
+ switch hdr.Typeflag {
+ case tar.TypeDir:
+ if err := os.MkdirAll(target, 0o755); err != nil {
+ return err
+ }
+ case tar.TypeReg:
+ if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+ return err
+ }
+ out, err := os.OpenFile(target, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, os.FileMode(hdr.Mode))
+ if err != nil {
+ return err
+ }
+ if _, err := io.Copy(out, tr); err != nil {
+ out.Close()
+ return err
+ }
+ out.Close()
+ }
+ }
+ return nil
+}
+
+func findBinaryInDir(dir, programName string) (string, error) {
+ wanted := []string{programName}
+ if runtime.GOOS == "windows" {
+ wanted = append([]string{programName + ".exe"}, wanted...)
+ } else {
+ // also accept programs with .exe in archives targeting windows
+ wanted = append(wanted, programName+".exe")
+ }
+
+ var found string
+ if err := filepath.WalkDir(dir, func(p string, d os.DirEntry, err error) error {
+ if err != nil || found != "" {
+ return err
+ }
+ if d.IsDir() {
+ return nil
+ }
+ base := filepath.Base(p)
+ for _, w := range wanted {
+ if base == w {
+ found = p
+ return io.EOF // use EOF to stop walking early
+ }
+ }
+ return nil
+ }); err != nil && err != io.EOF {
+ return "", err
+ }
+ if found == "" {
+ return "", fmt.Errorf("binary %q not found in archive", programName)
+ }
+ return found, nil
+}
+
+// NewUpdateCommand returns a cobra command that triggers UpdateSelfFromRelease.
+func NewUpdateCommand(binaryName string) *cobra.Command {
+ var urlStr, platform, arch string
+ cmd := &cobra.Command{
+ Use: "update",
+ Short: "Check and apply updates from GitHub releases",
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if platform == "" {
+ platform = runtime.GOOS
+ }
+ if arch == "" {
+ arch = runtime.GOARCH
+ }
+ fmt.Printf("Current version: %s\n", config.FormatVersion())
+ if err := UpdateSelfFromRelease(urlStr, platform, arch, binaryName); err != nil {
+ return err
+ }
+ fmt.Println("Update applied; restart to use the new version.")
+ return nil
+ },
+ }
+ cmd.Flags().StringVarP(&urlStr, "url", "u", "", "Direct URL to download release asset or release page")
+ cmd.Flags().StringVar(&platform, "platform", "", "Target platform (default: runtime.GOOS)")
+ cmd.Flags().StringVar(&arch, "arch", "", "Target arch (default: runtime.GOARCH)")
+ return cmd
+}
diff --git a/pkg/updater/updater_test.go b/pkg/updater/updater_test.go
new file mode 100644
index 000000000..ff75432e4
--- /dev/null
+++ b/pkg/updater/updater_test.go
@@ -0,0 +1,97 @@
+package updater
+
+import (
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+// matchesMagic checks whether the file at path looks like a platform binary
+// by inspecting magic bytes (ELF for linux, MZ for windows).
+func matchesMagic(path, platform string) (bool, error) {
+ f, err := os.Open(path)
+ if err != nil {
+ return false, err
+ }
+ defer f.Close()
+ buf := make([]byte, 4)
+ n, err := f.Read(buf)
+ if err != nil && err != io.EOF {
+ return false, err
+ }
+ if n >= 4 && buf[0] == 0x7f && buf[1] == 'E' && buf[2] == 'L' && buf[3] == 'F' {
+ return strings.Contains(platform, "linux"), nil
+ }
+ if n >= 2 && buf[0] == 'M' && buf[1] == 'Z' {
+ return strings.Contains(platform, "windows"), nil
+ }
+ return false, nil
+}
+
+// TestDownloadAndExtractRelease_RealPlatforms downloads the latest release
+// asset for multiple platform/arch combos and inspects the extracted
+// artifacts to ensure a binary-like file is present. This is a network test
+// and is skipped in short mode.
+func TestDownloadAndExtractRelease_RealPlatforms(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping network tests in short mode")
+ }
+
+ combos := []struct{ platform, arch string }{
+ {"linux", "amd64"},
+ {"linux", "arm64"},
+ {"windows", "amd64"},
+ {"windows", "arm64"},
+ }
+
+ apiURL := GetProdReleaseAPIURL()
+ for _, c := range combos {
+ t.Run(c.platform+"_"+c.arch, func(t *testing.T) {
+ assetURL, checksum, err := findAssetInfo(apiURL, c.platform, c.arch)
+ if err != nil {
+ // If no checksum could be located for this asset, skip this
+ // combo rather than failing — we require signed/checksummed
+ // releases for real-network tests.
+ t.Skipf("skipping %s/%s: %v", c.platform, c.arch, err)
+ }
+ t.Logf("asset URL: %s checksum: %s", assetURL, checksum)
+
+ // Pass the release API URL (not the direct asset URL) so
+ // DownloadAndExtractRelease can locate and verify the asset.
+ dir, err := DownloadAndExtractRelease(apiURL, c.platform, c.arch)
+ if err != nil {
+ t.Fatalf("DownloadAndExtractRelease failed for %s/%s: %v", c.platform, c.arch, err)
+ }
+ defer os.RemoveAll(dir)
+
+ var found bool
+ _ = filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
+ if err != nil || d.IsDir() {
+ return err
+ }
+ info, err := d.Info()
+ if err != nil {
+ return err
+ }
+ if info.Size() < 64 {
+ return nil
+ }
+ ok, err := matchesMagic(path, c.platform)
+ if err != nil {
+ return err
+ }
+ if ok {
+ found = true
+ t.Logf("found artifact: %s (size=%d)", path, info.Size())
+ // continue walking to list all
+ }
+ return nil
+ })
+ if !found {
+ t.Fatalf("no binary-like artifact found for %s/%s", c.platform, c.arch)
+ }
+ })
+ }
+}
diff --git a/web/backend/api/router.go b/web/backend/api/router.go
index 3823fe08c..c6781baf1 100644
--- a/web/backend/api/router.go
+++ b/web/backend/api/router.go
@@ -81,6 +81,9 @@ func (h *Handler) RegisterRoutes(mux *http.ServeMux) {
// Launcher service parameters (port/public)
h.registerLauncherConfigRoutes(mux)
+ // Self-update endpoint (requires dashboard auth)
+ h.registerUpdateRoutes(mux)
+
// Runtime build/version metadata
h.registerVersionRoutes(mux)
diff --git a/web/backend/api/update.go b/web/backend/api/update.go
new file mode 100644
index 000000000..2ba862631
--- /dev/null
+++ b/web/backend/api/update.go
@@ -0,0 +1,52 @@
+package api
+
+import (
+ "encoding/json"
+ "net/http"
+
+ "github.com/sipeed/picoclaw/pkg/updater"
+)
+
+// registerUpdateRoutes registers the self-update endpoint.
+func (h *Handler) registerUpdateRoutes(mux *http.ServeMux) {
+ mux.HandleFunc("/api/update", h.handleUpdate)
+}
+
+type updateRequest struct {
+ URL string `json:"url,omitempty"`
+ Binary string `json:"binary,omitempty"`
+}
+
+type updateResponse struct {
+ Status string `json:"status"`
+ Message string `json:"message,omitempty"`
+}
+
+func (h *Handler) handleUpdate(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodPost {
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ _ = json.NewEncoder(w).Encode(updateResponse{Status: "error", Message: "method not allowed"})
+ return
+ }
+
+ dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
+ var req updateRequest
+ if err := dec.Decode(&req); err != nil {
+ w.WriteHeader(http.StatusBadRequest)
+ _ = json.NewEncoder(w).Encode(updateResponse{Status: "error", Message: "invalid request body"})
+ return
+ }
+
+ binary := req.Binary
+ if binary == "" {
+ binary = "picoclaw-launcher"
+ }
+
+ if err := updater.UpdateSelfFromRelease(req.URL, "", "", binary); err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ _ = json.NewEncoder(w).Encode(updateResponse{Status: "error", Message: err.Error()})
+ return
+ }
+
+ _ = json.NewEncoder(w).Encode(updateResponse{Status: "ok", Message: "update applied; restart to use new version"})
+}
From 9ac21c5908db82b4a879569c5dffaa03c8ee14fe Mon Sep 17 00:00:00 2001
From: Cytown
Date: Wed, 1 Apr 2026 23:44:41 +0800
Subject: [PATCH 09/12] add missing recover panic in subturn.go (#2253)
---
pkg/agent/subturn.go | 1 +
1 file changed, 1 insertion(+)
diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go
index 82a2a2010..9447f1384 100644
--- a/pkg/agent/subturn.go
+++ b/pkg/agent/subturn.go
@@ -511,6 +511,7 @@ func deliverSubTurnResult(al *AgentLoop, parentTS *turnState, childID string, re
// We use defer/recover to catch any unlikely channel panics if it were ever closed.
defer func() {
if r := recover(); r != nil {
+ logger.RecoverPanicNoExit(r)
logger.WarnCF("subturn", "recovered panic sending to pendingResults", map[string]any{
"parent_id": parentTS.turnID,
"child_id": childID,
From bbcfeaa361845c4e903b086b9067cdd105335460 Mon Sep 17 00:00:00 2001
From: LC <64722907+lc6464@users.noreply.github.com>
Date: Wed, 1 Apr 2026 23:50:29 +0800
Subject: [PATCH 10/12] feat(provider): add Venice AI support and update
related documentation (#2238)
* feat(provider): add Venice AI support and update related documentation
* revert(asr): restore asr files to previous commit
* feat(config): add Venice API base URL and local LM Studio configuration
* fix(config): update Venice API base URL to correct endpoint
---
config/config.example.json | 5 ++++
docs/providers.md | 2 ++
docs/zh/providers.md | 2 ++
pkg/config/defaults.go | 14 ++++++++++
pkg/providers/factory_provider.go | 3 +-
pkg/providers/factory_provider_test.go | 29 ++++++++++++++++++++
pkg/providers/openai_compat/provider.go | 1 +
pkg/providers/openai_compat/provider_test.go | 8 ++++++
8 files changed, 63 insertions(+), 1 deletion(-)
diff --git a/config/config.example.json b/config/config.example.json
index 95fe24e0b..bedd543d7 100644
--- a/config/config.example.json
+++ b/config/config.example.json
@@ -48,6 +48,11 @@
"model": "deepseek/deepseek-chat",
"api_key": "sk-your-deepseek-key"
},
+ {
+ "model_name": "venice-uncensored",
+ "model": "venice/venice-uncensored",
+ "api_key": "your-venice-api-key"
+ },
{
"model_name": "lmstudio-local",
"model": "lmstudio/openai/gpt-oss-20b"
diff --git a/docs/providers.md b/docs/providers.md
index f45aa5f3b..b0dfa0bc8 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -16,6 +16,7 @@
| `openrouter` | LLM (recommended, access to all models) | [openrouter.ai](https://openrouter.ai) |
| `anthropic` | LLM (Claude direct) | [console.anthropic.com](https://console.anthropic.com) |
| `openai` | LLM (GPT direct) | [platform.openai.com](https://platform.openai.com) |
+| `venice` | LLM (Venice AI direct) | [venice.ai](https://venice.ai) |
| `deepseek` | LLM (DeepSeek direct) | [platform.deepseek.com](https://platform.deepseek.com) |
| `qwen` | LLM (Qwen direct) | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
| `groq` | LLM + **Voice transcription** (Whisper) | [console.groq.com](https://console.groq.com) |
@@ -46,6 +47,7 @@ This design also enables **multi-agent support** with flexible provider selectio
| Vendor | `model` Prefix | Default API Base | Protocol | API Key |
| ------------------- | ----------------- |-----------------------------------------------------| --------- | ---------------------------------------------------------------- |
| **OpenAI** | `openai/` | `https://api.openai.com/v1` | OpenAI | [Get Key](https://platform.openai.com) |
+| **Venice AI** | `venice/` | `https://api.venice.ai/api/v1` | OpenAI | [Get Key](https://venice.ai) |
| **Anthropic** | `anthropic/` | `https://api.anthropic.com/v1` | Anthropic | [Get Key](https://console.anthropic.com) |
| **智谱 AI (GLM)** | `zhipu/` | `https://open.bigmodel.cn/api/paas/v4` | OpenAI | [Get Key](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
| **Z.AI Coding Plan** | `openai/` | `https://api.z.ai/api/coding/paas/v4` | OpenAI | [Get Key](https://z.ai/manage-apikey/apikey-list) |
diff --git a/docs/zh/providers.md b/docs/zh/providers.md
index 04b2f7a88..43c4f26db 100644
--- a/docs/zh/providers.md
+++ b/docs/zh/providers.md
@@ -15,6 +15,7 @@
| `openrouter` | LLM (推荐，可访问所有模型) | [openrouter.ai](https://openrouter.ai) |
| `anthropic` | LLM (Claude 直连) | [console.anthropic.com](https://console.anthropic.com) |
| `openai` | LLM (GPT 直连) | [platform.openai.com](https://platform.openai.com) |
+| `venice` | LLM (Venice AI 直连) | [venice.ai](https://venice.ai) |
| `deepseek` | LLM (DeepSeek 直连) | [platform.deepseek.com](https://platform.deepseek.com) |
| `qwen` | LLM (通义千问) | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
| `groq` | LLM + **语音转录** (Whisper) | [console.groq.com](https://console.groq.com) |
@@ -44,6 +45,7 @@
| 厂商 | `model` 前缀 | 默认 API Base | 协议 | 获取 API Key |
| ------------------- | ----------------- | --------------------------------------------------- | --------- | ----------------------------------------------------------------- |
| **OpenAI** | `openai/` | `https://api.openai.com/v1` | OpenAI | [获取密钥](https://platform.openai.com) |
+| **Venice AI** | `venice/` | `https://api.venice.ai/api/v1` | OpenAI | [获取密钥](https://venice.ai) |
| **Anthropic** | `anthropic/` | `https://api.anthropic.com/v1` | Anthropic | [获取密钥](https://console.anthropic.com) |
| **智谱 AI (GLM)** | `zhipu/` | `https://open.bigmodel.cn/api/paas/v4` | OpenAI | [获取密钥](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
| **DeepSeek** | `deepseek/` | `https://api.deepseek.com/v1` | OpenAI | [获取密钥](https://platform.deepseek.com) |
diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go
index 6eac5d8b9..a9a107975 100644
--- a/pkg/config/defaults.go
+++ b/pkg/config/defaults.go
@@ -185,6 +185,13 @@ func DefaultConfig() *Config {
APIBase: "https://api.deepseek.com/v1",
},
+ // Venice AI - https://venice.ai
+ {
+ ModelName: "venice-uncensored",
+ Model: "venice/venice-uncensored",
+ APIBase: "https://api.venice.ai/api/v1",
+ },
+
// Google Gemini - https://ai.google.dev/
{
ModelName: "gemini-2.0-flash",
@@ -335,6 +342,13 @@ func DefaultConfig() *Config {
APIBase: "http://localhost:8000/v1",
},
+ // LM Studio (local) - http://localhost:1234
+ {
+ ModelName: "lmstudio-local",
+ Model: "lmstudio/openai/gpt-oss-20b",
+ APIBase: "http://localhost:1234/v1",
+ },
+
// Azure OpenAI - https://portal.azure.com
// model_name is a user-friendly alias; the model field's path after "azure/" is your deployment name
{
diff --git a/pkg/providers/factory_provider.go b/pkg/providers/factory_provider.go
index 16b2ead10..fb5191bf8 100644
--- a/pkg/providers/factory_provider.go
+++ b/pkg/providers/factory_provider.go
@@ -24,6 +24,7 @@ type protocolMeta struct {
var protocolMetaByName = map[string]protocolMeta{
"openai": {defaultAPIBase: "https://api.openai.com/v1"},
+ "venice": {defaultAPIBase: "https://api.venice.ai/api/v1"},
"openrouter": {defaultAPIBase: "https://openrouter.ai/api/v1"},
"litellm": {defaultAPIBase: "http://localhost:4000/v1"},
"lmstudio": {defaultAPIBase: "http://localhost:1234/v1", emptyAPIKeyAllowed: true},
@@ -209,7 +210,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err
}
return provider, modelID, nil
- case "litellm", "lmstudio", "openrouter", "groq", "zhipu", "gemini", "nvidia",
+ case "litellm", "lmstudio", "openrouter", "groq", "zhipu", "gemini", "nvidia", "venice",
"ollama", "moonshot", "shengsuanyun", "deepseek", "cerebras",
"vivgrid", "volcengine", "vllm", "qwen", "qwen-intl", "qwen-international", "dashscope-intl",
"qwen-us", "dashscope-us", "mistral", "avian", "longcat", "modelscope", "novita",
diff --git a/pkg/providers/factory_provider_test.go b/pkg/providers/factory_provider_test.go
index 588b81650..e2eafb934 100644
--- a/pkg/providers/factory_provider_test.go
+++ b/pkg/providers/factory_provider_test.go
@@ -112,6 +112,7 @@ func TestCreateProviderFromConfig_DefaultAPIBase(t *testing.T) {
protocol string
}{
{"openai", "openai"},
+ {"venice", "venice"},
{"groq", "groq"},
{"novita", "novita"},
{"openrouter", "openrouter"},
@@ -160,6 +161,12 @@ func TestGetDefaultAPIBase_LMStudio(t *testing.T) {
}
}
+func TestGetDefaultAPIBase_Venice(t *testing.T) {
+ if got := getDefaultAPIBase("venice"); got != "https://api.venice.ai/api/v1" {
+ t.Fatalf("getDefaultAPIBase(%q) = %q, want %q", "venice", got, "https://api.venice.ai/api/v1")
+ }
+}
+
func TestCreateProviderFromConfig_LiteLLM(t *testing.T) {
cfg := &config.ModelConfig{
ModelName: "test-litellm",
@@ -362,6 +369,28 @@ func TestCreateProviderFromConfig_Mimo(t *testing.T) {
}
}
+func TestCreateProviderFromConfig_Venice(t *testing.T) {
+ cfg := &config.ModelConfig{
+ ModelName: "test-venice",
+ Model: "venice/venice-uncensored",
+ }
+ cfg.SetAPIKey("test-key")
+
+ provider, modelID, err := CreateProviderFromConfig(cfg)
+ if err != nil {
+ t.Fatalf("CreateProviderFromConfig() error = %v", err)
+ }
+ if provider == nil {
+ t.Fatal("CreateProviderFromConfig() returned nil provider")
+ }
+ if modelID != "venice-uncensored" {
+ t.Errorf("modelID = %q, want %q", modelID, "venice-uncensored")
+ }
+ if _, ok := provider.(*HTTPProvider); !ok {
+ t.Fatalf("expected *HTTPProvider, got %T", provider)
+ }
+}
+
func TestGetDefaultAPIBase_Mimo(t *testing.T) {
if got := getDefaultAPIBase("mimo"); got != "https://api.xiaomimimo.com/v1" {
t.Fatalf("getDefaultAPIBase(%q) = %q, want %q", "mimo", got, "https://api.xiaomimimo.com/v1")
diff --git a/pkg/providers/openai_compat/provider.go b/pkg/providers/openai_compat/provider.go
index aa9473731..4ff42506f 100644
--- a/pkg/providers/openai_compat/provider.go
+++ b/pkg/providers/openai_compat/provider.go
@@ -44,6 +44,7 @@ const defaultRequestTimeout = common.DefaultRequestTimeout
var stripModelPrefixProviders = map[string]struct{}{
"litellm": {},
+ "venice": {},
"moonshot": {},
"nvidia": {},
"groq": {},
diff --git a/pkg/providers/openai_compat/provider_test.go b/pkg/providers/openai_compat/provider_test.go
index 823b0ff28..30aa76eb3 100644
--- a/pkg/providers/openai_compat/provider_test.go
+++ b/pkg/providers/openai_compat/provider_test.go
@@ -479,6 +479,11 @@ func TestProviderChat_StripsKnownProviderPrefixes(t *testing.T) {
input: "lmstudio/openai/gpt-oss-20b",
wantModel: "openai/gpt-oss-20b",
},
+ {
+ name: "strips venice prefix",
+ input: "venice/venice-uncensored",
+ wantModel: "venice-uncensored",
+ },
{
name: "strips deepseek prefix",
input: "deepseek/deepseek-chat",
@@ -587,6 +592,9 @@ func TestNormalizeModel_UsesAPIBase(t *testing.T) {
if got := normalizeModel("lmstudio/openai/gpt-oss-20b", "http://localhost:1234/v1"); got != "openai/gpt-oss-20b" {
t.Fatalf("normalizeModel(lmstudio) = %q, want %q", got, "openai/gpt-oss-20b")
}
+ if got := normalizeModel("venice/venice-uncensored", "https://api.venice.ai/api/v1"); got != "venice-uncensored" {
+ t.Fatalf("normalizeModel(venice) = %q, want %q", got, "venice-uncensored")
+ }
if got := normalizeModel("openrouter/auto", "https://openrouter.ai/api/v1"); got != "openrouter/auto" {
t.Fatalf("normalizeModel(openrouter) = %q, want %q", got, "openrouter/auto")
}
From 2973b30ad7029eacc4665216c4cfcebc3626c722 Mon Sep 17 00:00:00 2001
From: Cytown
Date: Wed, 1 Apr 2026 23:56:46 +0800
Subject: [PATCH 11/12] implement create dmg for macOS 10.11 & above (#2252)
---
.github/workflows/create_dmg.yml | 62 ++++++++++++++++++++++++++++++++
Makefile | 17 +++++----
scripts/build-macos-app.sh | 22 ++++++------
3 files changed, 82 insertions(+), 19 deletions(-)
create mode 100644 .github/workflows/create_dmg.yml
diff --git a/.github/workflows/create_dmg.yml b/.github/workflows/create_dmg.yml
new file mode 100644
index 000000000..b47247fc2
--- /dev/null
+++ b/.github/workflows/create_dmg.yml
@@ -0,0 +1,62 @@
+name: Create macOS DMG
+on:
+ workflow_dispatch:
+
+jobs:
+ build:
+ name: Build ${{ matrix.arch }}
+ runs-on: macos-latest
+ strategy:
+ matrix:
+ # This creates two parallel jobs
+ arch: [arm64, amd64]
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v6
+ with:
+ ref: main
+
+ # 1. 安装指定版本的 Go (可选，但推荐)
+ - name: Setup Go
+ uses: actions/setup-go@v6
+ with:
+ go-version-file: go.mod
+
+ # 2. 安装 pnpm
+ - name: Install pnpm
+ run: brew install pnpm
+
+ # 3. 运行你的 Makefile 编译二进制文件
+ - name: Build with Make
+ run: make build ARCH=${{ matrix.arch }} && make build-macos-app ARCH=${{ matrix.arch }}
+
+ # 4. 签名
+ - name: Ad-hoc Sign
+ run: codesign --force --deep --sign - "build/PicoClaw Launcher.app"
+
+ # 5. 安装打包工具
+ - name: Install create-dmg
+ run: brew install create-dmg
+
+ # 6. 执行打包命令
+ - name: Create DMG
+ run: |
+ mkdir -p dist
+ create-dmg \
+ --volname "PicoClaw Installer" \
+ --window-pos 200 120 \
+ --window-size 800 400 \
+ --icon-size 100 \
+ --icon "PicoClaw Launcher.app" 200 190 \
+ --hide-extension "PicoClaw Launcher.app" \
+ --app-drop-link 600 185 \
+ "dist/picoclaw-${{ matrix.arch }}.dmg" \
+ "build/PicoClaw Launcher.app"
+
+ # 6. 上传文件到 GitHub Artifacts (供你下载)
+ - name: Upload DMG
+ uses: actions/upload-artifact@v4
+ with:
+ name: macos-dmg-${{ matrix.arch }}
+ path: dist/*.dmg
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 992182775..21d8bdeac 100644
--- a/Makefile
+++ b/Makefile
@@ -93,13 +93,13 @@ ifeq ($(UNAME_S),Linux)
endif
else ifeq ($(UNAME_S),Darwin)
PLATFORM=darwin
- WEB_GO=CGO_ENABLED=1 go
+ WEB_GO=CGO_LDFLAGS="-mmacosx-version-min=10.11" CGO_CFLAGS="-mmacosx-version-min=10.11" CGO_ENABLED=1 go
ifeq ($(UNAME_M),x86_64)
- ARCH=amd64
+ ARCH?=amd64
else ifeq ($(UNAME_M),arm64)
- ARCH=arm64
+ ARCH?=arm64
else
- ARCH=$(UNAME_M)
+ ARCH?=$(UNAME_M)
endif
else
PLATFORM=$(UNAME_S)
@@ -122,7 +122,7 @@ generate:
build: generate
@echo "Building $(BINARY_NAME) for $(PLATFORM)/$(ARCH)..."
@mkdir -p $(BUILD_DIR)
- @$(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_PATH) ./$(CMD_DIR)
+ @GOARCH=${ARCH} $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_PATH) ./$(CMD_DIR)
@echo "Build complete: $(BINARY_PATH)"
@ln -sf $(BINARY_NAME)-$(PLATFORM)-$(ARCH) $(BUILD_DIR)/$(BINARY_NAME)
@@ -130,7 +130,7 @@ build: generate
build-launcher:
@echo "Building picoclaw-launcher for $(PLATFORM)/$(ARCH)..."
@mkdir -p $(BUILD_DIR)
- @$(MAKE) -C web build \
+ @GOARCH=${ARCH} $(MAKE) -C web build \
OUTPUT="$(CURDIR)/$(BUILD_DIR)/picoclaw-launcher-$(PLATFORM)-$(ARCH)" \
WEB_GO='$(WEB_GO)' \
GO_BUILD_TAGS='$(GO_BUILD_TAGS)' \
@@ -324,14 +324,13 @@ docker-clean:
## build-macos-app: Build PicoClaw macOS .app bundle (no terminal window)
-build-macos-app:
+build-macos-app:build-launcher
@echo "Building macOS .app bundle..."
@if [ "$(UNAME_S)" != "Darwin" ]; then \
echo "Error: This target is only available on macOS"; \
exit 1; \
fi
- @cd web && $(MAKE) build && cd ..
- @./scripts/build-macos-app.sh $(BINARY_NAME)-$(PLATFORM)-$(ARCH)
+ @./scripts/build-macos-app.sh $(PLATFORM)-$(ARCH)
@echo "macOS .app bundle created: $(BUILD_DIR)/PicoClaw.app"
## help: Show this help message
diff --git a/scripts/build-macos-app.sh b/scripts/build-macos-app.sh
index 76cc72938..df2100aec 100755
--- a/scripts/build-macos-app.sh
+++ b/scripts/build-macos-app.sh
@@ -10,6 +10,8 @@ if [ -z "$EXECUTABLE" ]; then
exit 1
fi
+LAUNCHER_EXECUTABLE="picoclaw-launcher-${EXECUTABLE}"
+EXECUTABLE="picoclaw-${EXECUTABLE}"
echo "executable: $EXECUTABLE"
APP_NAME="PicoClaw Launcher"
@@ -33,17 +35,17 @@ mkdir -p "$APP_RESOURCES"
# Copy executable
echo "Copying executable..."
-if [ -f "./web/build/${APP_EXECUTABLE}" ]; then
- cp "./web/build/${APP_EXECUTABLE}" "${APP_MACOS}/"
+if [ -f "./build/${LAUNCHER_EXECUTABLE}" ]; then
+ cp "./build/${LAUNCHER_EXECUTABLE}" "${APP_MACOS}/${APP_EXECUTABLE}"
else
- echo "Error: ./web/build/${APP_EXECUTABLE} not found. Please build the web backend first."
- echo "Run: make build in web dir"
+ echo "Error: ./build/${LAUNCHER_EXECUTABLE} not found. Please build the web backend first."
+ echo "Run: make build-launcher"
exit 1
fi
-if [ -f "./build/picoclaw" ]; then
- cp "./build/picoclaw" "${APP_MACOS}/"
+if [ -f "./build/${EXECUTABLE}" ]; then
+ cp "./build/${EXECUTABLE}" "${APP_MACOS}/picoclaw"
else
- echo "Error: ./build/picoclaw not found. Please build the main file first."
+ echo "Error: ./build/${EXECUTABLE} not found. Please build the main file first."
echo "Run: make build"
exit 1
fi
@@ -76,10 +78,10 @@ cat > "${APP_CONTENTS}/Info.plist" << 'EOF'
NSSupportsAutomaticGraphicsSwitching
LSRequiresCarbon
- LSUIElement
- 1
+ LSMinimumSystemVersion
+ 10.11
EOF
From 7eba27c3c464ff186eb623b7b8b9878c833b8b93 Mon Sep 17 00:00:00 2001
From: Liu Yuan
Date: Thu, 2 Apr 2026 00:08:15 +0800
Subject: [PATCH 12/12] feat: add ContextManager abstraction for pluggable
context management (#2203)
- Define ContextManager interface with Assemble/Compact/Ingest methods
- Implement legacyContextManager wrapping existing summarization logic
- Wire Assemble (before BuildMessages), Compact (post-turn + overflow),
and Ingest (after message persistence) into agent loop
- Add ContextManager config field and factory registry with config passthrough
- Remove old maybeSummarize/summarizeSession/summarizeBatch/etc from loop.go
- All existing tests pass with default (legacy) config
Co-authored-by: Liu Yuan
---
pkg/agent/context_legacy.go | 379 +++++++++++++++
pkg/agent/context_manager.go | 89 ++++
pkg/agent/context_manager_test.go | 764 ++++++++++++++++++++++++++++++
pkg/agent/eventbus_test.go | 5 +-
pkg/agent/events.go | 2 +
pkg/agent/loop.go | 444 ++++-------------
pkg/agent/turn.go | 18 +
pkg/config/config.go | 34 +-
8 files changed, 1354 insertions(+), 381 deletions(-)
create mode 100644 pkg/agent/context_legacy.go
create mode 100644 pkg/agent/context_manager.go
create mode 100644 pkg/agent/context_manager_test.go
diff --git a/pkg/agent/context_legacy.go b/pkg/agent/context_legacy.go
new file mode 100644
index 000000000..23402460e
--- /dev/null
+++ b/pkg/agent/context_legacy.go
@@ -0,0 +1,379 @@
+package agent
+
+import (
+ "context"
+ "fmt"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/sipeed/picoclaw/pkg/logger"
+ "github.com/sipeed/picoclaw/pkg/providers"
+)
+
+// legacyContextManager wraps the existing summarization/compression logic
+// as a ContextManager implementation. It is the default when no other
+// ContextManager is configured.
+type legacyContextManager struct {
+ al *AgentLoop
+ summarizing sync.Map // dedup for async Compact (post-turn)
+}
+
+func (m *legacyContextManager) Assemble(_ context.Context, req *AssembleRequest) (*AssembleResponse, error) {
+ // Legacy: read history from session, return as-is.
+ // Budget enforcement happens in BuildMessages caller via
+ // isOverContextBudget + forceCompression.
+ agent := m.al.registry.GetDefaultAgent()
+ if agent == nil {
+ return &AssembleResponse{}, nil
+ }
+ history := agent.Sessions.GetHistory(req.SessionKey)
+ summary := agent.Sessions.GetSummary(req.SessionKey)
+ return &AssembleResponse{
+ History: history,
+ Summary: summary,
+ }, nil
+}
+
+func (m *legacyContextManager) Compact(_ context.Context, req *CompactRequest) error {
+ switch req.Reason {
+ case ContextCompressReasonProactive, ContextCompressReasonRetry:
+ // Sync emergency compression — budget exceeded.
+ if result, ok := m.forceCompression(req.SessionKey); ok {
+ m.al.emitEvent(
+ EventKindContextCompress,
+ m.al.newTurnEventScope("", req.SessionKey).meta(0, "forceCompression", "turn.context.compress"),
+ ContextCompressPayload{
+ Reason: req.Reason,
+ DroppedMessages: result.DroppedMessages,
+ RemainingMessages: result.RemainingMessages,
+ },
+ )
+ }
+ case ContextCompressReasonSummarize:
+ m.maybeSummarize(req.SessionKey)
+ }
+ return nil
+}
+
+func (m *legacyContextManager) Ingest(_ context.Context, _ *IngestRequest) error {
+ // Legacy: no-op. Messages are persisted by Sessions JSONL.
+ return nil
+}
+
+// maybeSummarize triggers summarization if the session history exceeds thresholds.
+// It runs asynchronously in a goroutine.
+func (m *legacyContextManager) maybeSummarize(sessionKey string) {
+ agent := m.al.registry.GetDefaultAgent()
+ if agent == nil {
+ return
+ }
+
+ newHistory := agent.Sessions.GetHistory(sessionKey)
+ tokenEstimate := m.estimateTokens(newHistory)
+ threshold := agent.ContextWindow * agent.SummarizeTokenPercent / 100
+
+ if len(newHistory) > agent.SummarizeMessageThreshold || tokenEstimate > threshold {
+ summarizeKey := agent.ID + ":" + sessionKey
+ if _, loading := m.summarizing.LoadOrStore(summarizeKey, true); !loading {
+ go func() {
+ defer m.summarizing.Delete(summarizeKey)
+ defer func() {
+ if r := recover(); r != nil {
+ logger.WarnCF("agent", "Summarization panic recovered", map[string]any{
+ "session_key": sessionKey,
+ "panic": r,
+ })
+ }
+ }()
+ logger.Debug("Memory threshold reached. Optimizing conversation history...")
+ m.summarizeSession(agent, sessionKey)
+ }()
+ }
+ }
+}
+
+type compressionResult struct {
+ DroppedMessages int
+ RemainingMessages int
+}
+
+// forceCompression aggressively reduces context when the limit is hit.
+// It drops the oldest ~50% of Turns (a Turn is a complete user→LLM→response
+// cycle, as defined in #1316), so tool-call sequences are never split.
+func (m *legacyContextManager) forceCompression(sessionKey string) (compressionResult, bool) {
+ agent := m.al.registry.GetDefaultAgent()
+ if agent == nil {
+ return compressionResult{}, false
+ }
+
+ history := agent.Sessions.GetHistory(sessionKey)
+ if len(history) <= 2 {
+ return compressionResult{}, false
+ }
+
+ turns := parseTurnBoundaries(history)
+ var mid int
+ if len(turns) >= 2 {
+ mid = turns[len(turns)/2]
+ } else {
+ mid = findSafeBoundary(history, len(history)/2)
+ }
+ var keptHistory []providers.Message
+ if mid <= 0 {
+ for i := len(history) - 1; i >= 0; i-- {
+ if history[i].Role == "user" {
+ keptHistory = []providers.Message{history[i]}
+ break
+ }
+ }
+ } else {
+ keptHistory = history[mid:]
+ }
+
+ droppedCount := len(history) - len(keptHistory)
+
+ existingSummary := agent.Sessions.GetSummary(sessionKey)
+ compressionNote := fmt.Sprintf(
+ "[Emergency compression dropped %d oldest messages due to context limit]",
+ droppedCount,
+ )
+ if existingSummary != "" {
+ compressionNote = existingSummary + "\n\n" + compressionNote
+ }
+ agent.Sessions.SetSummary(sessionKey, compressionNote)
+
+ agent.Sessions.SetHistory(sessionKey, keptHistory)
+ agent.Sessions.Save(sessionKey)
+
+ logger.WarnCF("agent", "Forced compression executed", map[string]any{
+ "session_key": sessionKey,
+ "dropped_msgs": droppedCount,
+ "new_count": len(keptHistory),
+ })
+
+ return compressionResult{
+ DroppedMessages: droppedCount,
+ RemainingMessages: len(keptHistory),
+ }, true
+}
+
+func (m *legacyContextManager) summarizeSession(agent *AgentInstance, sessionKey string) {
+ ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+ defer cancel()
+
+ history := agent.Sessions.GetHistory(sessionKey)
+ summary := agent.Sessions.GetSummary(sessionKey)
+
+ if len(history) <= 4 {
+ return
+ }
+
+ safeCut := findSafeBoundary(history, len(history)-4)
+ if safeCut <= 0 {
+ return
+ }
+ keepCount := len(history) - safeCut
+ toSummarize := history[:safeCut]
+
+ maxMessageTokens := agent.ContextWindow / 2
+ validMessages := make([]providers.Message, 0)
+ omitted := false
+
+ for _, msg := range toSummarize {
+ if msg.Role != "user" && msg.Role != "assistant" {
+ continue
+ }
+ msgTokens := len(msg.Content) / 2
+ if msgTokens > maxMessageTokens {
+ omitted = true
+ continue
+ }
+ validMessages = append(validMessages, msg)
+ }
+
+ if len(validMessages) == 0 {
+ return
+ }
+
+ const (
+ maxSummarizationMessages = 10
+ llmMaxRetries = 3
+ )
+
+ var finalSummary string
+ if len(validMessages) > maxSummarizationMessages {
+ mid := len(validMessages) / 2
+ mid = m.findNearestUserMessage(validMessages, mid)
+
+ part1 := validMessages[:mid]
+ part2 := validMessages[mid:]
+
+ s1, _ := m.summarizeBatch(ctx, agent, part1, "")
+ s2, _ := m.summarizeBatch(ctx, agent, part2, "")
+
+ mergePrompt := fmt.Sprintf(
+ "Merge these two conversation summaries into one cohesive summary:\n\n1: %s\n\n2: %s",
+ s1, s2,
+ )
+
+ resp, err := m.retryLLMCall(ctx, agent, mergePrompt, llmMaxRetries)
+ if err == nil && resp.Content != "" {
+ finalSummary = resp.Content
+ } else {
+ finalSummary = s1 + " " + s2
+ }
+ } else {
+ finalSummary, _ = m.summarizeBatch(ctx, agent, validMessages, summary)
+ }
+
+ if omitted && finalSummary != "" {
+ finalSummary += "\n[Note: Some oversized messages were omitted from this summary for efficiency.]"
+ }
+
+ if finalSummary != "" {
+ agent.Sessions.SetSummary(sessionKey, finalSummary)
+ agent.Sessions.TruncateHistory(sessionKey, keepCount)
+ agent.Sessions.Save(sessionKey)
+ m.al.emitEvent(
+ EventKindSessionSummarize,
+ m.al.newTurnEventScope(agent.ID, sessionKey).meta(0, "summarizeSession", "turn.session.summarize"),
+ SessionSummarizePayload{
+ SummarizedMessages: len(validMessages),
+ KeptMessages: keepCount,
+ SummaryLen: len(finalSummary),
+ OmittedOversized: omitted,
+ },
+ )
+ }
+}
+
+func (m *legacyContextManager) findNearestUserMessage(messages []providers.Message, mid int) int {
+ originalMid := mid
+
+ for mid > 0 && messages[mid].Role != "user" {
+ mid--
+ }
+
+ if messages[mid].Role == "user" {
+ return mid
+ }
+
+ mid = originalMid
+ for mid < len(messages) && messages[mid].Role != "user" {
+ mid++
+ }
+
+ if mid < len(messages) {
+ return mid
+ }
+
+ return originalMid
+}
+
+func (m *legacyContextManager) retryLLMCall(
+ ctx context.Context,
+ agent *AgentInstance,
+ prompt string,
+ maxRetries int,
+) (*providers.LLMResponse, error) {
+ const llmTemperature = 0.3
+
+ var resp *providers.LLMResponse
+ var err error
+
+ for attempt := 0; attempt < maxRetries; attempt++ {
+ m.al.activeRequests.Add(1)
+ resp, err = func() (*providers.LLMResponse, error) {
+ defer m.al.activeRequests.Done()
+ return agent.Provider.Chat(
+ ctx,
+ []providers.Message{{Role: "user", Content: prompt}},
+ nil,
+ agent.Model,
+ map[string]any{
+ "max_tokens": agent.MaxTokens,
+ "temperature": llmTemperature,
+ "prompt_cache_key": agent.ID,
+ },
+ )
+ }()
+
+ if err == nil && resp != nil && resp.Content != "" {
+ return resp, nil
+ }
+ if attempt < maxRetries-1 {
+ time.Sleep(time.Duration(attempt+1) * 100 * time.Millisecond)
+ }
+ }
+
+ return resp, err
+}
+
+func (m *legacyContextManager) summarizeBatch(
+ ctx context.Context,
+ agent *AgentInstance,
+ batch []providers.Message,
+ existingSummary string,
+) (string, error) {
+ const (
+ llmMaxRetries = 3
+ fallbackMinContentLength = 200
+ fallbackMaxContentPercent = 10
+ )
+
+ var sb strings.Builder
+ sb.WriteString("Provide a concise summary of this conversation segment, preserving core context and key points.\n")
+ if existingSummary != "" {
+ sb.WriteString("Existing context: ")
+ sb.WriteString(existingSummary)
+ sb.WriteString("\n")
+ }
+ sb.WriteString("\nCONVERSATION:\n")
+ for _, msg := range batch {
+ fmt.Fprintf(&sb, "%s: %s\n", msg.Role, msg.Content)
+ }
+ prompt := sb.String()
+
+ response, err := m.retryLLMCall(ctx, agent, prompt, llmMaxRetries)
+ if err == nil && response.Content != "" {
+ return strings.TrimSpace(response.Content), nil
+ }
+
+ var fallback strings.Builder
+ fallback.WriteString("Conversation summary: ")
+ for i, msg := range batch {
+ if i > 0 {
+ fallback.WriteString(" | ")
+ }
+ content := strings.TrimSpace(msg.Content)
+ runes := []rune(content)
+ if len(runes) == 0 {
+ fallback.WriteString(fmt.Sprintf("%s: ", msg.Role))
+ continue
+ }
+
+ keepLength := len(runes) * fallbackMaxContentPercent / 100
+ if keepLength < fallbackMinContentLength {
+ keepLength = fallbackMinContentLength
+ }
+ if keepLength > len(runes) {
+ keepLength = len(runes)
+ }
+
+ content = string(runes[:keepLength])
+ if keepLength < len(runes) {
+ content += "..."
+ }
+ fallback.WriteString(fmt.Sprintf("%s: %s", msg.Role, content))
+ }
+ return fallback.String(), nil
+}
+
+func (m *legacyContextManager) estimateTokens(messages []providers.Message) int {
+ total := 0
+ for _, msg := range messages {
+ total += estimateMessageTokens(msg)
+ }
+ return total
+}
diff --git a/pkg/agent/context_manager.go b/pkg/agent/context_manager.go
new file mode 100644
index 000000000..cc8904ccf
--- /dev/null
+++ b/pkg/agent/context_manager.go
@@ -0,0 +1,89 @@
+package agent
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "sync"
+
+ "github.com/sipeed/picoclaw/pkg/providers"
+)
+
+// ContextManager manages conversation context via a pluggable strategy.
+// Exactly ONE ContextManager is active per AgentLoop, selected by config.
+// The default ("legacy") preserves current summarization behavior.
+type ContextManager interface {
+ // Assemble builds budget-aware context from the ContextManager's own storage.
+ // Called before BuildMessages. Returns assembled messages ready for LLM.
+ Assemble(ctx context.Context, req *AssembleRequest) (*AssembleResponse, error)
+
+ // Compact compresses conversation history.
+ // Called after turn completes (may be async internally) and on context overflow (sync).
+ Compact(ctx context.Context, req *CompactRequest) error
+
+ // Ingest records a message into the ContextManager's own storage.
+ // Called after each message is persisted to session JSONL.
+ Ingest(ctx context.Context, req *IngestRequest) error
+}
+
+// AssembleRequest is the input to Assemble.
+type AssembleRequest struct {
+ SessionKey string // session identifier
+ Budget int // context window in tokens
+ MaxTokens int // max response tokens
+}
+
+// AssembleResponse is the output of Assemble.
+type AssembleResponse struct {
+ History []providers.Message // assembled conversation history for BuildMessages
+ Summary string // conversation summary embedded into system prompt by BuildMessages
+}
+
+// CompactRequest is the input to Compact.
+type CompactRequest struct {
+ SessionKey string // session identifier
+ Reason ContextCompressReason // proactive_budget | llm_retry | summarize
+}
+
+// IngestRequest is the input to Ingest.
+type IngestRequest struct {
+ SessionKey string // session identifier
+ Message providers.Message // the message just persisted
+}
+
+// ContextManagerFactory constructs a ContextManager from config.
+// al provides access to the AgentLoop's runtime resources (provider, model, workspace, etc.)
+// cfg is the raw JSON configuration from config.json (may be nil).
+type ContextManagerFactory func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error)
+
+var (
+ cmRegistryMu sync.RWMutex
+ cmRegistry = map[string]ContextManagerFactory{}
+)
+
+// RegisterContextManager registers a named ContextManager factory.
+func RegisterContextManager(name string, factory ContextManagerFactory) error {
+ if name == "" {
+ return fmt.Errorf("context manager name is required")
+ }
+ if factory == nil {
+ return fmt.Errorf("context manager %q factory is nil", name)
+ }
+
+ cmRegistryMu.Lock()
+ defer cmRegistryMu.Unlock()
+
+ if _, exists := cmRegistry[name]; exists {
+ return fmt.Errorf("context manager %q is already registered", name)
+ }
+ cmRegistry[name] = factory
+ return nil
+}
+
+func lookupContextManager(name string) (ContextManagerFactory, bool) {
+ cmRegistryMu.RLock()
+ defer cmRegistryMu.RUnlock()
+
+ f, ok := cmRegistry[name]
+ return f, ok
+}
diff --git a/pkg/agent/context_manager_test.go b/pkg/agent/context_manager_test.go
new file mode 100644
index 000000000..6bde5e1a9
--- /dev/null
+++ b/pkg/agent/context_manager_test.go
@@ -0,0 +1,764 @@
+package agent
+
+import (
+ "context"
+ "encoding/json"
+ "os"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/sipeed/picoclaw/pkg/bus"
+ "github.com/sipeed/picoclaw/pkg/config"
+ "github.com/sipeed/picoclaw/pkg/providers"
+)
+
+// ---------------------------------------------------------------------------
+// Factory registry tests
+// ---------------------------------------------------------------------------
+
+func TestRegisterContextManager_Success(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ factory := func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return &noopContextManager{}, nil
+ }
+ if err := RegisterContextManager("test_cm", factory); err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ f, ok := lookupContextManager("test_cm")
+ if !ok {
+ t.Fatal("expected factory to be registered")
+ }
+ if f == nil {
+ t.Fatal("expected non-nil factory")
+ }
+}
+
+func TestRegisterContextManager_EmptyName(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ err := RegisterContextManager("", func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return &noopContextManager{}, nil
+ })
+ if err == nil {
+ t.Fatal("expected error for empty name")
+ }
+ if !strings.Contains(err.Error(), "name is required") {
+ t.Fatalf("unexpected error: %v", err)
+ }
+}
+
+func TestRegisterContextManager_NilFactory(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ err := RegisterContextManager("nil_factory", nil)
+ if err == nil {
+ t.Fatal("expected error for nil factory")
+ }
+ if !strings.Contains(err.Error(), "factory is nil") {
+ t.Fatalf("unexpected error: %v", err)
+ }
+}
+
+func TestRegisterContextManager_Duplicate(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ factory := func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return &noopContextManager{}, nil
+ }
+ if err := RegisterContextManager("dup_cm", factory); err != nil {
+ t.Fatalf("first registration failed: %v", err)
+ }
+ err := RegisterContextManager("dup_cm", factory)
+ if err == nil {
+ t.Fatal("expected error for duplicate registration")
+ }
+ if !strings.Contains(err.Error(), "already registered") {
+ t.Fatalf("unexpected error: %v", err)
+ }
+}
+
+func TestLookupContextManager_Unknown(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ _, ok := lookupContextManager("nonexistent")
+ if ok {
+ t.Fatal("expected lookup to fail for unknown name")
+ }
+}
+
+// ---------------------------------------------------------------------------
+// resolveContextManager tests
+// ---------------------------------------------------------------------------
+
+func TestResolveContextManager_Default(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "", // default → legacy
+ },
+ },
+ }
+ al := newCMTestAgentLoop(cfg)
+
+ cm := al.contextManager
+ if cm == nil {
+ t.Fatal("expected non-nil context manager")
+ }
+ if _, ok := cm.(*legacyContextManager); !ok {
+ t.Fatalf("expected *legacyContextManager, got %T", cm)
+ }
+}
+
+func TestResolveContextManager_ExplicitLegacy(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "legacy",
+ },
+ },
+ }
+ al := newCMTestAgentLoop(cfg)
+
+ if _, ok := al.contextManager.(*legacyContextManager); !ok {
+ t.Fatalf("expected *legacyContextManager, got %T", al.contextManager)
+ }
+}
+
+func TestResolveContextManager_UnknownFallsBackToLegacy(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "unknown_cm",
+ },
+ },
+ }
+ al := newCMTestAgentLoop(cfg)
+
+ if _, ok := al.contextManager.(*legacyContextManager); !ok {
+ t.Fatalf("expected fallback to *legacyContextManager, got %T", al.contextManager)
+ }
+}
+
+func TestResolveContextManager_RegisteredFactory(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ factory := func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return &noopContextManager{}, nil
+ }
+ if err := RegisterContextManager("custom_cm", factory); err != nil {
+ t.Fatalf("register failed: %v", err)
+ }
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "custom_cm",
+ },
+ },
+ }
+ al := newCMTestAgentLoop(cfg)
+
+ if _, ok := al.contextManager.(*noopContextManager); !ok {
+ t.Fatalf("expected *noopContextManager, got %T", al.contextManager)
+ }
+}
+
+func TestResolveContextManager_FactoryError(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ factory := func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return nil, os.ErrPermission
+ }
+ if err := RegisterContextManager("broken_cm", factory); err != nil {
+ t.Fatalf("register failed: %v", err)
+ }
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "broken_cm",
+ },
+ },
+ }
+ al := newCMTestAgentLoop(cfg)
+
+ // Should fall back to legacy when factory returns error
+ if _, ok := al.contextManager.(*legacyContextManager); !ok {
+ t.Fatalf("expected fallback to *legacyContextManager on factory error, got %T", al.contextManager)
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Legacy Assemble tests
+// ---------------------------------------------------------------------------
+
+func TestLegacyAssemble_Passthrough(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ agent := al.registry.GetDefaultAgent()
+ if agent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ history := []providers.Message{
+ {Role: "user", Content: "hello"},
+ {Role: "assistant", Content: "hi there"},
+ }
+ agent.Sessions.SetHistory("test-session", history)
+
+ resp, err := al.contextManager.Assemble(context.Background(), &AssembleRequest{
+ SessionKey: "test-session",
+ Budget: 8000,
+ MaxTokens: 4096,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if len(resp.History) != len(history) {
+ t.Fatalf("expected %d messages, got %d", len(history), len(resp.History))
+ }
+ for i, msg := range resp.History {
+ if msg.Content != history[i].Content || msg.Role != history[i].Role {
+ t.Fatalf("message %d mismatch: want %+v, got %+v", i, history[i], msg)
+ }
+ }
+}
+
+func TestLegacyAssemble_EmptyHistory(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ resp, err := al.contextManager.Assemble(context.Background(), &AssembleRequest{
+ SessionKey: "test-session",
+ Budget: 8000,
+ MaxTokens: 4096,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if len(resp.History) != 0 {
+ t.Fatalf("expected empty messages, got %d", len(resp.History))
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Legacy Compact overflow tests
+// ---------------------------------------------------------------------------
+
+func TestLegacyCompact_Overflow(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ history := []providers.Message{
+ {Role: "user", Content: "msg 1"},
+ {Role: "assistant", Content: "resp 1"},
+ {Role: "user", Content: "msg 2"},
+ {Role: "assistant", Content: "resp 2"},
+ {Role: "user", Content: "msg 3"},
+ }
+ defaultAgent.Sessions.SetHistory("session-overflow", history)
+
+ sub := al.SubscribeEvents(16)
+ defer al.UnsubscribeEvents(sub.ID)
+
+ err := al.contextManager.Compact(context.Background(), &CompactRequest{
+ SessionKey: "session-overflow",
+ Reason: ContextCompressReasonRetry,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ // After overflow compression, history should be shorter
+ newHistory := defaultAgent.Sessions.GetHistory("session-overflow")
+ if len(newHistory) >= len(history) {
+ t.Fatalf("expected compressed history, got %d messages (was %d)", len(newHistory), len(history))
+ }
+
+ // Summary should contain compression note
+ summary := defaultAgent.Sessions.GetSummary("session-overflow")
+ if !strings.Contains(summary, "Emergency compression") {
+ t.Fatalf("expected compression note in summary, got %q", summary)
+ }
+
+ // Event should carry the proactive reason
+ events := collectEventStream(sub.C)
+ compressEvt, ok := findEvent(events, EventKindContextCompress)
+ if !ok {
+ t.Fatal("expected context compress event")
+ }
+ payload, ok := compressEvt.Payload.(ContextCompressPayload)
+ if !ok {
+ t.Fatalf("expected ContextCompressPayload, got %T", compressEvt.Payload)
+ }
+ if payload.Reason != ContextCompressReasonRetry {
+ t.Fatalf("expected retry reason, got %q", payload.Reason)
+ }
+}
+
+func TestLegacyCompact_Overflow_ProactiveReason(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ history := []providers.Message{
+ {Role: "user", Content: "msg 1"},
+ {Role: "assistant", Content: "resp 1"},
+ {Role: "user", Content: "msg 2"},
+ {Role: "assistant", Content: "resp 2"},
+ {Role: "user", Content: "msg 3"},
+ }
+ defaultAgent.Sessions.SetHistory("session-proactive", history)
+
+ sub := al.SubscribeEvents(16)
+ defer al.UnsubscribeEvents(sub.ID)
+
+ err := al.contextManager.Compact(context.Background(), &CompactRequest{
+ SessionKey: "session-proactive",
+ Reason: ContextCompressReasonProactive,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ events := collectEventStream(sub.C)
+ compressEvt, ok := findEvent(events, EventKindContextCompress)
+ if !ok {
+ t.Fatal("expected context compress event")
+ }
+ payload, ok := compressEvt.Payload.(ContextCompressPayload)
+ if !ok {
+ t.Fatalf("expected ContextCompressPayload, got %T", compressEvt.Payload)
+ }
+ if payload.Reason != ContextCompressReasonProactive {
+ t.Fatalf("expected proactive reason, got %q", payload.Reason)
+ }
+}
+
+func TestLegacyCompact_Overflow_TooShortToCompress(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ history := []providers.Message{
+ {Role: "user", Content: "only one"},
+ }
+ defaultAgent.Sessions.SetHistory("session-tiny", history)
+
+ err := al.contextManager.Compact(context.Background(), &CompactRequest{
+ SessionKey: "session-tiny",
+ Reason: ContextCompressReasonRetry,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ // History should be unchanged (too short to compress)
+ newHistory := defaultAgent.Sessions.GetHistory("session-tiny")
+ if len(newHistory) != len(history) {
+ t.Fatalf("expected history unchanged, got %d messages (was %d)", len(newHistory), len(history))
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Legacy Compact post-turn tests
+// ---------------------------------------------------------------------------
+
+func TestLegacyCompact_PostTurn_BelowThreshold(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ // Small history, below summarization thresholds
+ history := []providers.Message{
+ {Role: "user", Content: "hi"},
+ {Role: "assistant", Content: "hello"},
+ }
+ defaultAgent.Sessions.SetHistory("session-small", history)
+
+ err := al.contextManager.Compact(context.Background(), &CompactRequest{
+ SessionKey: "session-small",
+ Reason: ContextCompressReasonSummarize,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ // History should remain unchanged
+ newHistory := defaultAgent.Sessions.GetHistory("session-small")
+ if len(newHistory) != len(history) {
+ t.Fatalf("expected unchanged history, got %d messages (was %d)", len(newHistory), len(history))
+ }
+}
+
+func TestLegacyCompact_PostTurn_ExceedsMessageThreshold(t *testing.T) {
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextWindow: 8000,
+ SummarizeMessageThreshold: 2,
+ SummarizeTokenPercent: 75,
+ },
+ },
+ }
+ msgBus := bus.NewMessageBus()
+ al := NewAgentLoop(cfg, msgBus, &simpleMockProvider{response: "summary"})
+
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ // 6 messages > threshold of 2
+ history := []providers.Message{
+ {Role: "user", Content: "q1"},
+ {Role: "assistant", Content: "a1"},
+ {Role: "user", Content: "q2"},
+ {Role: "assistant", Content: "a2"},
+ {Role: "user", Content: "q3"},
+ {Role: "assistant", Content: "a3"},
+ }
+ defaultAgent.Sessions.SetHistory("session-threshold", history)
+
+ err := al.contextManager.Compact(context.Background(), &CompactRequest{
+ SessionKey: "session-threshold",
+ Reason: ContextCompressReasonSummarize,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ // Wait for async summarization to complete via event
+ sub := al.SubscribeEvents(16)
+ defer al.UnsubscribeEvents(sub.ID)
+
+ waitForEvent(t, sub.C, 5*time.Second, func(evt Event) bool {
+ return evt.Kind == EventKindSessionSummarize
+ })
+
+ newHistory := defaultAgent.Sessions.GetHistory("session-threshold")
+ if len(newHistory) >= len(history) {
+ t.Fatalf("expected summarization to reduce history from %d messages, got %d", len(history), len(newHistory))
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Legacy Ingest tests
+// ---------------------------------------------------------------------------
+
+func TestLegacyIngest_NoOp(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ err := al.contextManager.Ingest(context.Background(), &IngestRequest{
+ SessionKey: "session-ingest",
+ Message: providers.Message{Role: "user", Content: "test"},
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Mock ContextManager — verifies dispatch through AgentLoop
+// ---------------------------------------------------------------------------
+
+func TestAgentLoop_UsesCustomContextManager(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ mock := &trackingContextManager{}
+ factory := func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return mock, nil
+ }
+ if err := RegisterContextManager("tracking_cm", factory); err != nil {
+ t.Fatalf("register failed: %v", err)
+ }
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "tracking_cm",
+ },
+ },
+ }
+ al := newCMTestAgentLoop(cfg)
+
+ // Verify the mock was installed
+ if al.contextManager != mock {
+ t.Fatalf("expected mock context manager, got %T", al.contextManager)
+ }
+
+ // Direct method calls
+ _, err := mock.Assemble(context.Background(), &AssembleRequest{
+ SessionKey: "s1",
+ Budget: 8000,
+ MaxTokens: 4096,
+ })
+ if err != nil {
+ t.Fatalf("Assemble error: %v", err)
+ }
+ if mock.assembleCalls.Load() != 1 {
+ t.Fatalf("expected 1 assemble call, got %d", mock.assembleCalls.Load())
+ }
+
+ err = mock.Compact(context.Background(), &CompactRequest{
+ SessionKey: "s1",
+ Reason: ContextCompressReasonRetry,
+ })
+ if err != nil {
+ t.Fatalf("Compact error: %v", err)
+ }
+ if mock.compactCalls.Load() != 1 {
+ t.Fatalf("expected 1 compact call, got %d", mock.compactCalls.Load())
+ }
+
+ err = mock.Ingest(context.Background(), &IngestRequest{
+ SessionKey: "s1",
+ Message: providers.Message{Role: "user", Content: "test"},
+ })
+ if err != nil {
+ t.Fatalf("Ingest error: %v", err)
+ }
+ if mock.ingestCalls.Load() != 1 {
+ t.Fatalf("expected 1 ingest call, got %d", mock.ingestCalls.Load())
+ }
+}
+
+func TestIngestCalledDuringTurn(t *testing.T) {
+ cleanup := resetCMRegistry()
+ defer cleanup()
+
+ mock := &trackingContextManager{}
+ factory := func(cfg json.RawMessage, al *AgentLoop) (ContextManager, error) {
+ return mock, nil
+ }
+ if err := RegisterContextManager("ingest_track_cm", factory); err != nil {
+ t.Fatalf("register failed: %v", err)
+ }
+
+ cfg := &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ ContextManager: "ingest_track_cm",
+ },
+ },
+ }
+
+ msgBus := bus.NewMessageBus()
+ al := NewAgentLoop(cfg, msgBus, &simpleMockProvider{response: "done"})
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ // Run a turn — ingestMessage is called for user message and final assistant message
+ _, err := al.runAgentLoop(context.Background(), defaultAgent, processOptions{
+ SessionKey: "session-ingest-turn",
+ Channel: "cli",
+ ChatID: "direct",
+ UserMessage: "test ingest",
+ DefaultResponse: defaultResponse,
+ EnableSummary: false,
+ SendResponse: false,
+ })
+ if err != nil {
+ t.Fatalf("runAgentLoop failed: %v", err)
+ }
+
+ // Should have at least 2 ingest calls: user message + final assistant message
+ if mock.ingestCalls.Load() < 2 {
+ t.Fatalf("expected >= 2 ingest calls during turn, got %d", mock.ingestCalls.Load())
+ }
+}
+
+// ---------------------------------------------------------------------------
+// forceCompression edge cases (via legacy Compact)
+// ---------------------------------------------------------------------------
+
+func TestLegacyCompact_Overflow_SingleTurnKeepsLastUserMessage(t *testing.T) {
+ cfg := testConfig(t)
+ al := newCMTestAgentLoop(cfg)
+
+ defaultAgent := al.registry.GetDefaultAgent()
+ if defaultAgent == nil {
+ t.Fatal("expected default agent")
+ }
+
+ // History with only 2 messages — forceCompression should still handle it
+ history := []providers.Message{
+ {Role: "user", Content: "first question"},
+ {Role: "assistant", Content: "first answer"},
+ }
+ defaultAgent.Sessions.SetHistory("session-2msg", history)
+
+ err := al.contextManager.Compact(context.Background(), &CompactRequest{
+ SessionKey: "session-2msg",
+ Reason: ContextCompressReasonRetry,
+ })
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+
+ newHistory := defaultAgent.Sessions.GetHistory("session-2msg")
+ // With 2 messages, forceCompression returns false (len <= 2), so no compression
+ if len(newHistory) != len(history) {
+ t.Fatalf("expected no compression for 2-message history, got %d", len(newHistory))
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+// noopContextManager is a minimal ContextManager that does nothing.
+type noopContextManager struct{}
+
+func (m *noopContextManager) Assemble(_ context.Context, req *AssembleRequest) (*AssembleResponse, error) {
+ return &AssembleResponse{}, nil
+}
+func (m *noopContextManager) Compact(_ context.Context, _ *CompactRequest) error { return nil }
+func (m *noopContextManager) Ingest(_ context.Context, _ *IngestRequest) error { return nil }
+
+// trackingContextManager tracks call counts for each method.
+type trackingContextManager struct {
+ assembleCalls atomic.Int64
+ compactCalls atomic.Int64
+ ingestCalls atomic.Int64
+ mu sync.Mutex
+ lastAssemble *AssembleRequest
+ lastCompact *CompactRequest
+ lastIngest *IngestRequest
+}
+
+func (m *trackingContextManager) Assemble(_ context.Context, req *AssembleRequest) (*AssembleResponse, error) {
+ m.assembleCalls.Add(1)
+ m.mu.Lock()
+ m.lastAssemble = req
+ m.mu.Unlock()
+ return &AssembleResponse{}, nil
+}
+
+func (m *trackingContextManager) Compact(_ context.Context, req *CompactRequest) error {
+ m.compactCalls.Add(1)
+ m.mu.Lock()
+ m.lastCompact = req
+ m.mu.Unlock()
+ return nil
+}
+
+func (m *trackingContextManager) Ingest(_ context.Context, req *IngestRequest) error {
+ m.ingestCalls.Add(1)
+ m.mu.Lock()
+ m.lastIngest = req
+ m.mu.Unlock()
+ return nil
+}
+
+// resetCMRegistry clears the global factory registry and returns a cleanup
+// function that restores the original state after the test.
+func resetCMRegistry() func() {
+ cmRegistryMu.Lock()
+ original := make(map[string]ContextManagerFactory, len(cmRegistry))
+ for k, v := range cmRegistry {
+ original[k] = v
+ }
+ cmRegistry = make(map[string]ContextManagerFactory)
+ cmRegistryMu.Unlock()
+
+ return func() {
+ cmRegistryMu.Lock()
+ cmRegistry = original
+ cmRegistryMu.Unlock()
+ }
+}
+
+func testConfig(t *testing.T) *config.Config {
+ t.Helper()
+ return &config.Config{
+ Agents: config.AgentsConfig{
+ Defaults: config.AgentDefaults{
+ Workspace: t.TempDir(),
+ ModelName: "test-model",
+ MaxTokens: 4096,
+ MaxToolIterations: 10,
+ },
+ },
+ }
+}
+
+func newCMTestAgentLoop(cfg *config.Config) *AgentLoop {
+ msgBus := bus.NewMessageBus()
+ return NewAgentLoop(cfg, msgBus, &simpleMockProvider{response: "test"})
+}
diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go
index 19a1ea9eb..2785d70a5 100644
--- a/pkg/agent/eventbus_test.go
+++ b/pkg/agent/eventbus_test.go
@@ -472,8 +472,9 @@ func TestAgentLoop_EmitsSessionSummarizeEvent(t *testing.T) {
sub := al.SubscribeEvents(16)
defer al.UnsubscribeEvents(sub.ID)
- turnScope := al.newTurnEventScope(defaultAgent.ID, "session-1")
- al.summarizeSession(defaultAgent, "session-1", turnScope)
+ // Use legacyContextManager's summarizeSession via contextManager interface
+ lcm := &legacyContextManager{al: al}
+ lcm.summarizeSession(defaultAgent, "session-1")
events := collectEventStream(sub.C)
summaryEvt, ok := findEvent(events, EventKindSessionSummarize)
diff --git a/pkg/agent/events.go b/pkg/agent/events.go
index f4562b360..615eacf9f 100644
--- a/pkg/agent/events.go
+++ b/pkg/agent/events.go
@@ -167,6 +167,8 @@ const (
ContextCompressReasonProactive ContextCompressReason = "proactive_budget"
// ContextCompressReasonRetry indicates compression during context-error retry handling.
ContextCompressReasonRetry ContextCompressReason = "llm_retry"
+ // ContextCompressReasonSummarize indicates post-turn async summarization.
+ ContextCompressReasonSummarize ContextCompressReason = "summarize"
)
// ContextCompressPayload describes a forced history compression.
diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go
index 15535e138..624ff261b 100644
--- a/pkg/agent/loop.go
+++ b/pkg/agent/loop.go
@@ -48,7 +48,7 @@ type AgentLoop struct {
// Runtime state
running atomic.Bool
- summarizing sync.Map
+ contextManager ContextManager
fallback *providers.FallbackChain
channelManager *channels.Manager
mediaStore media.MediaStore
@@ -137,13 +137,13 @@ func NewAgentLoop(
registry: registry,
state: stateManager,
eventBus: eventBus,
- summarizing: sync.Map{},
fallback: fallbackChain,
cmdRegistry: commands.NewRegistry(commands.BuiltinDefinitions()),
steering: newSteeringQueue(parseSteeringMode(cfg.Agents.Defaults.SteeringMode)),
}
al.hooks = NewHookManager(eventBus)
configureHookManagerFromConfig(al.hooks, cfg)
+ al.contextManager = al.resolveContextManager()
// Register shared tools to all agents (now that al is created)
registerSharedTools(al, cfg, msgBus, registry, provider)
@@ -1690,8 +1690,15 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState) (turnResult, er
var history []providers.Message
var summary string
if !ts.opts.NoHistory {
- history = ts.agent.Sessions.GetHistory(ts.sessionKey)
- summary = ts.agent.Sessions.GetSummary(ts.sessionKey)
+ // ContextManager assembles budget-aware history and summary.
+ if resp, err := al.contextManager.Assemble(turnCtx, &AssembleRequest{
+ SessionKey: ts.sessionKey,
+ Budget: ts.agent.ContextWindow,
+ MaxTokens: ts.agent.MaxTokens,
+ }); err == nil && resp != nil {
+ history = resp.History
+ summary = resp.Summary
+ }
}
ts.captureRestorePoint(history, summary)
@@ -1716,22 +1723,27 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState) (turnResult, er
if isOverContextBudget(ts.agent.ContextWindow, messages, toolDefs, ts.agent.MaxTokens) {
logger.WarnCF("agent", "Proactive compression: context budget exceeded before LLM call",
map[string]any{"session_key": ts.sessionKey})
- if compression, ok := al.forceCompression(ts.agent, ts.sessionKey); ok {
- al.emitEvent(
- EventKindContextCompress,
- ts.eventMeta("runTurn", "turn.context.compress"),
- ContextCompressPayload{
- Reason: ContextCompressReasonProactive,
- DroppedMessages: compression.DroppedMessages,
- RemainingMessages: compression.RemainingMessages,
- },
- )
- ts.refreshRestorePointFromSession(ts.agent)
+ if err := al.contextManager.Compact(turnCtx, &CompactRequest{
+ SessionKey: ts.sessionKey,
+ Reason: ContextCompressReasonProactive,
+ }); err != nil {
+ logger.WarnCF("agent", "Proactive compact failed", map[string]any{
+ "session_key": ts.sessionKey,
+ "error": err.Error(),
+ })
+ }
+ ts.refreshRestorePointFromSession(ts.agent)
+ // Re-assemble from CM after compact.
+ if resp, err := al.contextManager.Assemble(turnCtx, &AssembleRequest{
+ SessionKey: ts.sessionKey,
+ Budget: ts.agent.ContextWindow,
+ MaxTokens: ts.agent.MaxTokens,
+ }); err == nil && resp != nil {
+ history = resp.History
+ summary = resp.Summary
}
- newHistory := ts.agent.Sessions.GetHistory(ts.sessionKey)
- newSummary := ts.agent.Sessions.GetSummary(ts.sessionKey)
messages = ts.agent.ContextBuilder.BuildMessages(
- newHistory, newSummary, ts.userMessage,
+ history, summary, ts.userMessage,
ts.media, ts.channel, ts.chatID,
ts.opts.SenderID, ts.opts.SenderDisplayName,
activeSkillNames(ts.agent, ts.opts)...,
@@ -1753,6 +1765,7 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState) (turnResult, er
ts.agent.Sessions.AddMessage(ts.sessionKey, rootMsg.Role, rootMsg.Content)
}
ts.recordPersistedMessage(rootMsg)
+ ts.ingestMessage(turnCtx, al, rootMsg)
}
activeCandidates, activeModel, usedLight := al.selectCandidates(ts.agent, ts.userMessage, messages)
@@ -2096,23 +2109,27 @@ turnLoop:
})
}
- if compression, ok := al.forceCompression(ts.agent, ts.sessionKey); ok {
- al.emitEvent(
- EventKindContextCompress,
- ts.eventMeta("runTurn", "turn.context.compress"),
- ContextCompressPayload{
- Reason: ContextCompressReasonRetry,
- DroppedMessages: compression.DroppedMessages,
- RemainingMessages: compression.RemainingMessages,
- },
- )
- ts.refreshRestorePointFromSession(ts.agent)
+ if compactErr := al.contextManager.Compact(turnCtx, &CompactRequest{
+ SessionKey: ts.sessionKey,
+ Reason: ContextCompressReasonRetry,
+ }); compactErr != nil {
+ logger.WarnCF("agent", "Context overflow compact failed", map[string]any{
+ "session_key": ts.sessionKey,
+ "error": compactErr.Error(),
+ })
+ }
+ ts.refreshRestorePointFromSession(ts.agent)
+ // Re-assemble from CM after compact.
+ if asmResp, asmErr := al.contextManager.Assemble(turnCtx, &AssembleRequest{
+ SessionKey: ts.sessionKey,
+ Budget: ts.agent.ContextWindow,
+ MaxTokens: ts.agent.MaxTokens,
+ }); asmErr == nil && asmResp != nil {
+ history = asmResp.History
+ summary = asmResp.Summary
}
-
- newHistory := ts.agent.Sessions.GetHistory(ts.sessionKey)
- newSummary := ts.agent.Sessions.GetSummary(ts.sessionKey)
messages = ts.agent.ContextBuilder.BuildMessages(
- newHistory, newSummary, "",
+ history, summary, "",
nil, ts.channel, ts.chatID, ts.opts.SenderID, ts.opts.SenderDisplayName,
activeSkillNames(ts.agent, ts.opts)...,
)
@@ -2285,6 +2302,7 @@ turnLoop:
if !ts.opts.NoHistory {
ts.agent.Sessions.AddFullMessage(ts.sessionKey, assistantMsg)
ts.recordPersistedMessage(assistantMsg)
+ ts.ingestMessage(turnCtx, al, assistantMsg)
}
ts.setPhase(TurnPhaseTools)
@@ -2624,6 +2642,7 @@ turnLoop:
if !ts.opts.NoHistory {
ts.agent.Sessions.AddFullMessage(ts.sessionKey, toolResultMsg)
ts.recordPersistedMessage(toolResultMsg)
+ ts.ingestMessage(turnCtx, al, toolResultMsg)
}
if steerMsgs := al.dequeueSteeringMessagesForScope(ts.sessionKey); len(steerMsgs) > 0 {
@@ -2723,6 +2742,7 @@ turnLoop:
if !ts.opts.NoHistory {
ts.agent.Sessions.AddMessage(ts.sessionKey, summaryMsg.Role, summaryMsg.Content)
ts.recordPersistedMessage(summaryMsg)
+ ts.ingestMessage(turnCtx, al, summaryMsg)
if err := ts.agent.Sessions.Save(ts.sessionKey); err != nil {
turnStatus = TurnEndStatusError
al.emitEvent(
@@ -2737,7 +2757,7 @@ turnLoop:
}
}
if ts.opts.EnableSummary {
- al.maybeSummarize(ts.agent, ts.sessionKey, ts.scope)
+ al.contextManager.Compact(turnCtx, &CompactRequest{SessionKey: ts.sessionKey, Reason: ContextCompressReasonSummarize})
}
ts.setPhase(TurnPhaseCompleted)
@@ -2792,6 +2812,7 @@ turnLoop:
finalMsg := providers.Message{Role: "assistant", Content: finalContent}
ts.agent.Sessions.AddMessage(ts.sessionKey, finalMsg.Role, finalMsg.Content)
ts.recordPersistedMessage(finalMsg)
+ ts.ingestMessage(turnCtx, al, finalMsg)
if err := ts.agent.Sessions.Save(ts.sessionKey); err != nil {
turnStatus = TurnEndStatusError
al.emitEvent(
@@ -2807,7 +2828,13 @@ turnLoop:
}
if ts.opts.EnableSummary {
- al.maybeSummarize(ts.agent, ts.sessionKey, ts.scope)
+ al.contextManager.Compact(
+ turnCtx,
+ &CompactRequest{
+ SessionKey: ts.sessionKey,
+ Reason: ContextCompressReasonSummarize,
+ },
+ )
}
ts.setPhase(TurnPhaseCompleted)
@@ -2886,103 +2913,28 @@ func (al *AgentLoop) selectCandidates(
return agent.LightCandidates, resolvedCandidateModel(agent.LightCandidates, agent.Router.LightModel()), true
}
-// maybeSummarize triggers summarization if the session history exceeds thresholds.
-func (al *AgentLoop) maybeSummarize(agent *AgentInstance, sessionKey string, turnScope turnEventScope) {
- newHistory := agent.Sessions.GetHistory(sessionKey)
- tokenEstimate := al.estimateTokens(newHistory)
- threshold := agent.ContextWindow * agent.SummarizeTokenPercent / 100
-
- if len(newHistory) > agent.SummarizeMessageThreshold || tokenEstimate > threshold {
- summarizeKey := agent.ID + ":" + sessionKey
- if _, loading := al.summarizing.LoadOrStore(summarizeKey, true); !loading {
- go func() {
- defer al.summarizing.Delete(summarizeKey)
- logger.Debug("Memory threshold reached. Optimizing conversation history...")
- al.summarizeSession(agent, sessionKey, turnScope)
- }()
- }
+// resolveContextManager selects the ContextManager implementation based on config.
+func (al *AgentLoop) resolveContextManager() ContextManager {
+ name := al.cfg.Agents.Defaults.ContextManager
+ if name == "" || name == "legacy" {
+ return &legacyContextManager{al: al}
}
-}
-
-type compressionResult struct {
- DroppedMessages int
- RemainingMessages int
-}
-
-// forceCompression aggressively reduces context when the limit is hit.
-// It drops the oldest ~50% of Turns (a Turn is a complete user→LLM→response
-// cycle, as defined in #1316), so tool-call sequences are never split.
-//
-// If the history is a single Turn with no safe split point, the function
-// falls back to keeping only the most recent user message. This breaks
-// Turn atomicity as a last resort to avoid a context-exceeded loop.
-//
-// Session history contains only user/assistant/tool messages — the system
-// prompt is built dynamically by BuildMessages and is NOT stored here.
-// The compression note is recorded in the session summary so that
-// BuildMessages can include it in the next system prompt.
-func (al *AgentLoop) forceCompression(agent *AgentInstance, sessionKey string) (compressionResult, bool) {
- history := agent.Sessions.GetHistory(sessionKey)
- if len(history) <= 2 {
- return compressionResult{}, false
+ factory, ok := lookupContextManager(name)
+ if !ok {
+ logger.WarnCF("agent", "Unknown context manager, falling back to legacy", map[string]any{
+ "name": name,
+ })
+ return &legacyContextManager{al: al}
}
-
- // Split at a Turn boundary so no tool-call sequence is torn apart.
- // parseTurnBoundaries gives us the start of each Turn; we drop the
- // oldest half of Turns and keep the most recent ones.
- turns := parseTurnBoundaries(history)
- var mid int
- if len(turns) >= 2 {
- mid = turns[len(turns)/2]
- } else {
- // Fewer than 2 Turns — fall back to message-level midpoint
- // aligned to the nearest Turn boundary.
- mid = findSafeBoundary(history, len(history)/2)
+ cm, err := factory(al.cfg.Agents.Defaults.ContextManagerConfig, al)
+ if err != nil {
+ logger.WarnCF("agent", "Failed to create context manager, falling back to legacy", map[string]any{
+ "name": name,
+ "error": err.Error(),
+ })
+ return &legacyContextManager{al: al}
}
- var keptHistory []providers.Message
- if mid <= 0 {
- // No safe Turn boundary — the entire history is a single Turn
- // (e.g. one user message followed by a massive tool response).
- // Keeping everything would leave the agent stuck in a context-
- // exceeded loop, so fall back to keeping only the most recent
- // user message. This breaks Turn atomicity as a last resort.
- for i := len(history) - 1; i >= 0; i-- {
- if history[i].Role == "user" {
- keptHistory = []providers.Message{history[i]}
- break
- }
- }
- } else {
- keptHistory = history[mid:]
- }
-
- droppedCount := len(history) - len(keptHistory)
-
- // Record compression in the session summary so BuildMessages includes it
- // in the system prompt. We do not modify history messages themselves.
- existingSummary := agent.Sessions.GetSummary(sessionKey)
- compressionNote := fmt.Sprintf(
- "[Emergency compression dropped %d oldest messages due to context limit]",
- droppedCount,
- )
- if existingSummary != "" {
- compressionNote = existingSummary + "\n\n" + compressionNote
- }
- agent.Sessions.SetSummary(sessionKey, compressionNote)
-
- agent.Sessions.SetHistory(sessionKey, keptHistory)
- agent.Sessions.Save(sessionKey)
-
- logger.WarnCF("agent", "Forced compression executed", map[string]any{
- "session_key": sessionKey,
- "dropped_msgs": droppedCount,
- "new_count": len(keptHistory),
- })
-
- return compressionResult{
- DroppedMessages: droppedCount,
- RemainingMessages: len(keptHistory),
- }, true
+ return cm
}
// GetStartupInfo returns information about loaded tools and skills for logging.
@@ -3074,247 +3026,13 @@ func formatToolsForLog(toolDefs []providers.ToolDefinition) string {
}
// summarizeSession summarizes the conversation history for a session.
-func (al *AgentLoop) summarizeSession(agent *AgentInstance, sessionKey string, turnScope turnEventScope) {
- ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
- defer cancel()
-
- history := agent.Sessions.GetHistory(sessionKey)
- summary := agent.Sessions.GetSummary(sessionKey)
-
- // Keep the most recent Turns for continuity, aligned to a Turn boundary
- // so that no tool-call sequence is split.
- if len(history) <= 4 {
- return
- }
-
- safeCut := findSafeBoundary(history, len(history)-4)
- if safeCut <= 0 {
- return
- }
- keepCount := len(history) - safeCut
- toSummarize := history[:safeCut]
-
- // Oversized Message Guard
- maxMessageTokens := agent.ContextWindow / 2
- validMessages := make([]providers.Message, 0)
- omitted := false
-
- for _, m := range toSummarize {
- if m.Role != "user" && m.Role != "assistant" {
- continue
- }
- msgTokens := len(m.Content) / 2
- if msgTokens > maxMessageTokens {
- omitted = true
- continue
- }
- validMessages = append(validMessages, m)
- }
-
- if len(validMessages) == 0 {
- return
- }
-
- const (
- maxSummarizationMessages = 10
- llmMaxRetries = 3
- llmTemperature = 0.3
- fallbackMaxContentLength = 200
- )
-
- // Multi-Part Summarization
- var finalSummary string
- if len(validMessages) > maxSummarizationMessages {
- mid := len(validMessages) / 2
-
- mid = al.findNearestUserMessage(validMessages, mid)
-
- part1 := validMessages[:mid]
- part2 := validMessages[mid:]
-
- s1, _ := al.summarizeBatch(ctx, agent, part1, "")
- s2, _ := al.summarizeBatch(ctx, agent, part2, "")
-
- mergePrompt := fmt.Sprintf(
- "Merge these two conversation summaries into one cohesive summary:\n\n1: %s\n\n2: %s",
- s1,
- s2,
- )
-
- resp, err := al.retryLLMCall(ctx, agent, mergePrompt, llmMaxRetries)
- if err == nil && resp.Content != "" {
- finalSummary = resp.Content
- } else {
- finalSummary = s1 + " " + s2
- }
- } else {
- finalSummary, _ = al.summarizeBatch(ctx, agent, validMessages, summary)
- }
-
- if omitted && finalSummary != "" {
- finalSummary += "\n[Note: Some oversized messages were omitted from this summary for efficiency.]"
- }
-
- if finalSummary != "" {
- agent.Sessions.SetSummary(sessionKey, finalSummary)
- agent.Sessions.TruncateHistory(sessionKey, keepCount)
- agent.Sessions.Save(sessionKey)
- al.emitEvent(
- EventKindSessionSummarize,
- turnScope.meta(0, "summarizeSession", "turn.session.summarize"),
- SessionSummarizePayload{
- SummarizedMessages: len(validMessages),
- KeptMessages: keepCount,
- SummaryLen: len(finalSummary),
- OmittedOversized: omitted,
- },
- )
- }
-}
-
// findNearestUserMessage finds the nearest user message to the given index.
// It searches backward first, then forward if no user message is found.
-func (al *AgentLoop) findNearestUserMessage(messages []providers.Message, mid int) int {
- originalMid := mid
-
- for mid > 0 && messages[mid].Role != "user" {
- mid--
- }
-
- if messages[mid].Role == "user" {
- return mid
- }
-
- mid = originalMid
- for mid < len(messages) && messages[mid].Role != "user" {
- mid++
- }
-
- if mid < len(messages) {
- return mid
- }
-
- return originalMid
-}
-
// retryLLMCall calls the LLM with retry logic.
-func (al *AgentLoop) retryLLMCall(
- ctx context.Context,
- agent *AgentInstance,
- prompt string,
- maxRetries int,
-) (*providers.LLMResponse, error) {
- const (
- llmTemperature = 0.3
- )
-
- var resp *providers.LLMResponse
- var err error
-
- for attempt := 0; attempt < maxRetries; attempt++ {
- al.activeRequests.Add(1)
- resp, err = func() (*providers.LLMResponse, error) {
- defer al.activeRequests.Done()
- return agent.Provider.Chat(
- ctx,
- []providers.Message{{Role: "user", Content: prompt}},
- nil,
- agent.Model,
- map[string]any{
- "max_tokens": agent.MaxTokens,
- "temperature": llmTemperature,
- "prompt_cache_key": agent.ID,
- },
- )
- }()
-
- if err == nil && resp != nil && resp.Content != "" {
- return resp, nil
- }
- if attempt < maxRetries-1 {
- time.Sleep(time.Duration(attempt+1) * 100 * time.Millisecond)
- }
- }
-
- return resp, err
-}
-
// summarizeBatch summarizes a batch of messages.
-func (al *AgentLoop) summarizeBatch(
- ctx context.Context,
- agent *AgentInstance,
- batch []providers.Message,
- existingSummary string,
-) (string, error) {
- const (
- llmMaxRetries = 3
- llmTemperature = 0.3
- fallbackMinContentLength = 200
- fallbackMaxContentPercent = 10
- )
-
- var sb strings.Builder
- sb.WriteString(
- "Provide a concise summary of this conversation segment, preserving core context and key points.\n",
- )
- if existingSummary != "" {
- sb.WriteString("Existing context: ")
- sb.WriteString(existingSummary)
- sb.WriteString("\n")
- }
- sb.WriteString("\nCONVERSATION:\n")
- for _, m := range batch {
- fmt.Fprintf(&sb, "%s: %s\n", m.Role, m.Content)
- }
- prompt := sb.String()
-
- response, err := al.retryLLMCall(ctx, agent, prompt, llmMaxRetries)
- if err == nil && response.Content != "" {
- return strings.TrimSpace(response.Content), nil
- }
-
- var fallback strings.Builder
- fallback.WriteString("Conversation summary: ")
- for i, m := range batch {
- if i > 0 {
- fallback.WriteString(" | ")
- }
- content := strings.TrimSpace(m.Content)
- runes := []rune(content)
- if len(runes) == 0 {
- fallback.WriteString(fmt.Sprintf("%s: ", m.Role))
- continue
- }
-
- keepLength := len(runes) * fallbackMaxContentPercent / 100
- if keepLength < fallbackMinContentLength {
- keepLength = fallbackMinContentLength
- }
-
- if keepLength > len(runes) {
- keepLength = len(runes)
- }
-
- content = string(runes[:keepLength])
- if keepLength < len(runes) {
- content += "..."
- }
- fallback.WriteString(fmt.Sprintf("%s: %s", m.Role, content))
- }
- return fallback.String(), nil
-}
-
// estimateTokens estimates the number of tokens in a message list.
// Counts Content, ToolCalls arguments, and ToolCallID metadata so that
// tool-heavy conversations are not systematically undercounted.
-func (al *AgentLoop) estimateTokens(messages []providers.Message) int {
- total := 0
- for _, m := range messages {
- total += estimateMessageTokens(m)
- }
- return total
-}
-
func (al *AgentLoop) handleCommand(
ctx context.Context,
msg bus.InboundMessage,
diff --git a/pkg/agent/turn.go b/pkg/agent/turn.go
index e4970c519..8f099ed1d 100644
--- a/pkg/agent/turn.go
+++ b/pkg/agent/turn.go
@@ -8,6 +8,7 @@ import (
"time"
"github.com/sipeed/picoclaw/pkg/bus"
+ "github.com/sipeed/picoclaw/pkg/logger"
"github.com/sipeed/picoclaw/pkg/providers"
"github.com/sipeed/picoclaw/pkg/session"
"github.com/sipeed/picoclaw/pkg/tools"
@@ -338,6 +339,23 @@ func (ts *turnState) refreshRestorePointFromSession(agent *AgentInstance) {
ts.captureRestorePoint(history, summary)
}
+// ingestMessage calls the ContextManager's Ingest method for a persisted message.
+// Errors are logged but never block the turn.
+func (ts *turnState) ingestMessage(ctx context.Context, al *AgentLoop, msg providers.Message) {
+ if al.contextManager == nil {
+ return
+ }
+ if err := al.contextManager.Ingest(ctx, &IngestRequest{
+ SessionKey: ts.sessionKey,
+ Message: msg,
+ }); err != nil {
+ logger.WarnCF("agent", "Context manager ingest failed", map[string]any{
+ "session_key": ts.sessionKey,
+ "error": err.Error(),
+ })
+ }
+}
+
func (ts *turnState) restoreSession(agent *AgentInstance) error {
ts.mu.RLock()
history := append([]providers.Message(nil), ts.restorePointHistory...)
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 7a11d1ab7..a35689bc1 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -226,26 +226,28 @@ type ToolFeedbackConfig struct {
}
type AgentDefaults struct {
- Workspace string `json:"workspace" env:"PICOCLAW_AGENTS_DEFAULTS_WORKSPACE"`
- RestrictToWorkspace bool `json:"restrict_to_workspace" env:"PICOCLAW_AGENTS_DEFAULTS_RESTRICT_TO_WORKSPACE"`
- AllowReadOutsideWorkspace bool `json:"allow_read_outside_workspace" env:"PICOCLAW_AGENTS_DEFAULTS_ALLOW_READ_OUTSIDE_WORKSPACE"`
- Provider string `json:"provider" env:"PICOCLAW_AGENTS_DEFAULTS_PROVIDER"`
- ModelName string `json:"model_name" env:"PICOCLAW_AGENTS_DEFAULTS_MODEL_NAME"`
+ Workspace string `json:"workspace" env:"PICOCLAW_AGENTS_DEFAULTS_WORKSPACE"`
+ RestrictToWorkspace bool `json:"restrict_to_workspace" env:"PICOCLAW_AGENTS_DEFAULTS_RESTRICT_TO_WORKSPACE"`
+ AllowReadOutsideWorkspace bool `json:"allow_read_outside_workspace" env:"PICOCLAW_AGENTS_DEFAULTS_ALLOW_READ_OUTSIDE_WORKSPACE"`
+ Provider string `json:"provider" env:"PICOCLAW_AGENTS_DEFAULTS_PROVIDER"`
+ ModelName string `json:"model_name" env:"PICOCLAW_AGENTS_DEFAULTS_MODEL_NAME"`
ModelFallbacks []string `json:"model_fallbacks,omitempty"`
- ImageModel string `json:"image_model,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_IMAGE_MODEL"`
+ ImageModel string `json:"image_model,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_IMAGE_MODEL"`
ImageModelFallbacks []string `json:"image_model_fallbacks,omitempty"`
- MaxTokens int `json:"max_tokens" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_TOKENS"`
- ContextWindow int `json:"context_window,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_WINDOW"`
- Temperature *float64 `json:"temperature,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_TEMPERATURE"`
- MaxToolIterations int `json:"max_tool_iterations" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_TOOL_ITERATIONS"`
- SummarizeMessageThreshold int `json:"summarize_message_threshold" env:"PICOCLAW_AGENTS_DEFAULTS_SUMMARIZE_MESSAGE_THRESHOLD"`
- SummarizeTokenPercent int `json:"summarize_token_percent" env:"PICOCLAW_AGENTS_DEFAULTS_SUMMARIZE_TOKEN_PERCENT"`
- MaxMediaSize int `json:"max_media_size,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_MEDIA_SIZE"`
+ MaxTokens int `json:"max_tokens" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_TOKENS"`
+ ContextWindow int `json:"context_window,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_WINDOW"`
+ Temperature *float64 `json:"temperature,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_TEMPERATURE"`
+ MaxToolIterations int `json:"max_tool_iterations" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_TOOL_ITERATIONS"`
+ SummarizeMessageThreshold int `json:"summarize_message_threshold" env:"PICOCLAW_AGENTS_DEFAULTS_SUMMARIZE_MESSAGE_THRESHOLD"`
+ SummarizeTokenPercent int `json:"summarize_token_percent" env:"PICOCLAW_AGENTS_DEFAULTS_SUMMARIZE_TOKEN_PERCENT"`
+ MaxMediaSize int `json:"max_media_size,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_MEDIA_SIZE"`
Routing *RoutingConfig `json:"routing,omitempty"`
- SteeringMode string `json:"steering_mode,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_STEERING_MODE"` // "one-at-a-time" (default) or "all"
- SubTurn SubTurnConfig `json:"subturn" envPrefix:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_"`
+ SteeringMode string `json:"steering_mode,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_STEERING_MODE"` // "one-at-a-time" (default) or "all"
+ SubTurn SubTurnConfig `json:"subturn" envPrefix:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_"`
ToolFeedback ToolFeedbackConfig `json:"tool_feedback,omitempty"`
- SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker
+ SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker
+ ContextManager string `json:"context_manager,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"`
+ ContextManagerConfig json.RawMessage `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"`
}
const DefaultMaxMediaSize = 20 * 1024 * 1024 // 20 MB
-
-
-
-
- }
- />
-
- {
- if (!open) setSelectedSkill(null)
- }}
- >
-
-
-
- {selectedSkill?.name || t("pages.agent.skills.viewer_title")}
-
-
- {selectedSkill?.description ||
- t("pages.agent.skills.viewer_description")}
-
-
-
-
-
-
- {
- if (!open) setSkillPendingDelete(null)
- }}
- >
-
-
-
- {t("pages.agent.skills.delete_title")}
-
-
- {t("pages.agent.skills.delete_description", {
- name: skillPendingDelete?.name,
- })}
-
-
-
-
- {t("common.cancel")}
-
- {
- if (skillPendingDelete)
- deleteMutation.mutate(skillPendingDelete.name)
- }}
- >
- {deleteMutation.isPending ? (
-
-
-
-
-
- )
-}
diff --git a/web/frontend/src/components/tools/tools-page.tsx b/web/frontend/src/components/tools/tools-page.tsx
deleted file mode 100644
index 6a521a565..000000000
--- a/web/frontend/src/components/tools/tools-page.tsx
+++ /dev/null
@@ -1,192 +0,0 @@
-import { IconLoader2 } from "@tabler/icons-react"
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
-import { useTranslation } from "react-i18next"
-import { toast } from "sonner"
-
-import { type ToolSupportItem, getTools, setToolEnabled } from "@/api/tools"
-import { PageHeader } from "@/components/page-header"
-import { Button } from "@/components/ui/button"
-import {
- Card,
- CardContent,
- CardDescription,
- CardHeader,
- CardTitle,
-} from "@/components/ui/card"
-import { cn } from "@/lib/utils"
-import { refreshGatewayState } from "@/store/gateway"
-
-export function ToolsPage() {
- const { t } = useTranslation()
- const queryClient = useQueryClient()
- const { data, isLoading, error } = useQuery({
- queryKey: ["tools"],
- queryFn: getTools,
- })
-
- const toggleMutation = useMutation({
- mutationFn: async ({ name, enabled }: { name: string; enabled: boolean }) =>
- setToolEnabled(name, enabled),
- onSuccess: (_, variables) => {
- toast.success(
- variables.enabled
- ? t("pages.agent.tools.enable_success")
- : t("pages.agent.tools.disable_success"),
- )
- void queryClient.invalidateQueries({ queryKey: ["tools"] })
- void refreshGatewayState({ force: true })
- },
- onError: (err) => {
- toast.error(
- err instanceof Error
- ? err.message
- : t("pages.agent.tools.toggle_error"),
- )
- },
- })
-
- const groupedTools = (() => {
- if (!data) return [] as Array<[string, ToolSupportItem[]]>
- const buckets = new Map
-
-
-
- {isLoading ? (
-
-
-
- {t("pages.agent.skills.empty")}
-
-
- )}
-
- )}
-
-
- {t("labels.loading")}
-
- ) : error ? (
-
- {t("pages.agent.load_error")}
-
- ) : (
- - {t("pages.agent.skills.description")} -
- - {data?.skills.length ? ( -
- {data.skills.map((skill) => (
-
-
-
-
-
-
- ))}
-
- ) : (
-
-
-
-
- {skill.name}
-
-
- {skill.description ||
- t("pages.agent.skills.no_description")}
-
-
-
-
- {skill.source === "workspace" ? (
-
- ) : null}
-
-
- {t("pages.agent.skills.path")}
-
-
- {skill.path}
-
-
- {isSkillDetailLoading ? (
-
-
- {t("pages.agent.skills.loading_detail")}
-
- ) : skillDetailError ? (
-
- {t("pages.agent.skills.load_detail_error")}
-
- ) : selectedSkillDetail ? (
-
-
- ) : null}
-
-
- {selectedSkillDetail.content}
-
-
-
-
- )
-}
-
-function ToolStatusBadge({ status }: { status: ToolSupportItem["status"] }) {
- const { t } = useTranslation()
-
- return (
-
- {t(`pages.agent.tools.status.${status}`)}
-
- )
-}
diff --git a/web/frontend/src/components/ui/dialog.tsx b/web/frontend/src/components/ui/dialog.tsx
new file mode 100644
index 000000000..da1eb3a12
--- /dev/null
+++ b/web/frontend/src/components/ui/dialog.tsx
@@ -0,0 +1,163 @@
+import * as React from "react"
+import { Dialog as DialogPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+import { Button } from "@/components/ui/button"
+import { IconX } from "@tabler/icons-react"
+
+function Dialog({
+ ...props
+}: React.ComponentProps
-
-
- {isLoading ? (
-
-
-
- {t("pages.agent.tools.empty")}
-
-
- )}
-
- )}
-
-
- {t("labels.loading")}
-
- ) : error ? (
-
- {t("pages.agent.load_error")}
-
- ) : (
- - {t("pages.agent.tools.description")} -
- - {data?.tools.length ? ( - groupedTools.map(([category, items]) => ( -
-
- ))
- ) : (
-
- {t(`pages.agent.tools.categories.${category}`)}
-
-
- {items.map((tool) => {
- const reasonText = tool.reason_code
- ? t(`pages.agent.tools.reasons.${tool.reason_code}`)
- : ""
- const isPending =
- toggleMutation.isPending &&
- toggleMutation.variables?.name === tool.name
- const nextEnabled = tool.status !== "enabled"
-
- return (
-
-
-
-
-
-
- )
- })}
-
-
-
-
-
- {tool.name}
-
-
- {tool.description}
-
-
-
-
-
- {t("pages.agent.tools.config_key", {
- key: tool.config_key,
- })}
-
- {reasonText ? (
-
- {reasonText}
-
- ) : null}
-
+ {children}
+ {showCloseButton && (
+
+
+
+ )}
+
+ )
+}
+
+function DialogTitle({
+ className,
+ ...props
+}: React.ComponentProps