pi-codebuddy-sdk 0.1.0

package/README.md

@@ -0,0 +1,107 @@
+# pi-codebuddy-sdk
+
+回退到 `@tencent-ai/agent-sdk` 的 Pi provider 扩展。无反向代理，直接使用本地 CodeBuddy CLI，合规安全。
+
+## 安装
+
+### 方式 1：全局安装（日常使用）
+
+```bash
+ln -s ~/Desktop/pi-codebuddy/src ~/.pi/agent/extensions/pi-codebuddy
+cd ~/Desktop/pi-codebuddy && npm install
+```
+
+重启 Pi 即可自动发现。
+
+### 方式 2：临时加载（测试）
+
+```bash
+pi -e ~/Desktop/pi-codebuddy/src/index.ts --provider codebuddy --model <model>
+```
+
+## 认证
+
+CodeBuddy SDK 从本地环境读取凭证，优先级：
+
+### 1. 已通过 CLI 登录（自动，无需配置）
+
+```bash
+# 如果已登录 CodeBuddy CLI，SDK 自动复用凭证
+codebuddy login
+```
+
+### 2. API Key（手动设置）
+
+```bash
+# 国际版
+export CODEBUDDY_API_KEY="your-key"
+
+# 中国版
+export CODEBUDDY_API_KEY="your-key"
+export CODEBUDDY_INTERNET_ENVIRONMENT=internal
+
+# iOA 版（企业内）
+export CODEBUDDY_API_KEY="your-key"
+export CODEBUDDY_INTERNET_ENVIRONMENT=ioa
+```
+
+**获取 API Key：**
+
+| 版本 | 地址 |
+|------|------|
+| 国际版 | https://www.codebuddy.ai/profile/keys |
+| 中国版 | https://copilot.tencent.com/profile/ |
+| iOA | https://tencent.sso.copilot.tencent.com/profile/keys |
+
+## 使用
+
+```bash
+# 列出 codebuddy 所有模型
+pi --list-models
+
+# 使用指定模型
+pi --provider codebuddy --model claude-sonnet-4.6
+
+# 或进入 Pi 后切换
+/model codebuddy/claude-sonnet-4.6
+```
+
+### 推荐模型
+
+| 模型 | 说明 |
+|------|------|
+| `claude-sonnet-4.6` | Claude Sonnet 4.6，支持 thinking |
+| `claude-opus-4.8` | Claude Opus 4.8，支持 thinking + image |
+| `gemini-3.1-pro` | Gemini 3.1 Pro，支持 thinking + image |
+| `gpt-5.5` | GPT-5.5，支持 thinking + image |
+| `hy3-preview-agent-ioa` | 混元 3 Preview，iOA 内免费无限额度 |
+
+## 特性
+
+| 特性 | 说明 |
+|------|------|
+| **动态模型发现** | 启动时从 CodeBuddy SDK 拉取 29 个模型，自动标注 thinking/image 能力 |
+| **Session 池复用** | 多轮对话复用同一 CodeBuddy CLI 进程，首轮后每轮省 ~6s 启动 |
+| **Thinking 控制** | Pi 的 thinking level 映射到 CodeBuddy 的 thinking/effort 参数 |
+| **Image 输入** | 原生支持 Claude/Gemini/GPT 的多模态图片输入 |
+| **Abort 处理** | Esc 取消 → CodeBuddy `interrupt()`，干净终止 |
+| **Token 统计** | 包含 cache_read / cache_write / total_cost_usd |
+| **YOLO 模式** | `bypassPermissions`，所有工具自动批准（与 pi-cursor-sdk 一致） |
+
+## FAQ
+
+**Q: 和 pi-cursor-sdk 有什么区别？**
+
+pi-cursor-sdk 需要自建 MCP bridge 桥接 Cursor SDK 工具，pi-codebuddy SDK 原生处理工具执行，代码量减少 60%+。
+
+**Q: 怎么查看当前用了多少 tokens？**
+
+每次回复后 Pi 会显示 usage，包含 input/output/cache/total 及费用。
+
+**Q: maxTurns 限制？**
+
+100（安全上限）。CodeBuddy agent 完成任务会自动停止，不会循环满。
+
+**Q: 支持哪些 CodeBuddy 版本？**
+
+CodeBuddy CLI ≥ 2.x（`@tencent-ai/agent-sdk` ≥ 0.3.0）。

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "pi-codebuddy-sdk",
+  "version": "0.1.0",
+  "description": "CodeBuddy Agent SDK provider for Pi — native tool execution, 29+ models, thinking controls, session pool",
+  "author": "slahser",
+  "license": "MIT",
+  "type": "module",
+  "repository": "github:RealAlexandreAI/pi-codebuddy-sdk",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "codebuddy",
+    "agent-sdk",
+    "provider"
+  ],
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@tencent-ai/agent-sdk": "^0.3.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-ai": { "optional": true },
+    "@earendil-works/pi-coding-agent": { "optional": true },
+    "typebox": { "optional": true }
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.80.2",
+    "@earendil-works/pi-coding-agent": "^0.80.2"
+  }
+}

package/src/context.ts

@@ -0,0 +1,190 @@
+import type { Context, ImageContent } from "@earendil-works/pi-ai/compat";
+import type { UserMessage as CbUserMessage, ContentBlock } from "@tencent-ai/agent-sdk";
+
+/**
+ * Build a CodeBuddy UserMessage from the FULL Pi Context.
+ * Used on the first turn of a pooled session.
+ *
+ * Returns either a plain string (text-only) or a structured UserMessage
+ * with ContentBlock[] when images are present in the latest user message.
+ */
+export function buildFullMessage(context: Context): string | CbUserMessage {
+  return buildMessage(context, 0);
+}
+
+/**
+ * Build a CodeBuddy UserMessage from only NEW messages since startIndex.
+ * Used on continuation turns of a pooled session (delta mode).
+ *
+ * Historical messages before startIndex are omitted — the CodeBuddy
+ * session already has them in its internal context.
+ */
+export function buildDeltaMessage(context: Context, startIndex: number): string | CbUserMessage {
+  return buildMessage(context, startIndex);
+}
+
+// ── internal ──
+
+function buildMessage(context: Context, startIndex: number): string | CbUserMessage {
+  const prefix = buildHistoryPrefix(context, startIndex);
+  const lastUserMsg = findLastUserMessage(context, startIndex);
+  const images = extractImages(lastUserMsg);
+
+  if (images.length === 0) {
+    return prefix + extractTextFromMessage(lastUserMsg);
+  }
+
+  // Image support: build ContentBlock[]
+  const blocks: ContentBlock[] = [];
+
+  if (prefix) {
+    blocks.push({ type: "text", text: prefix });
+  }
+
+  for (const block of lastUserMsg!.content) {
+    if (typeof block === "string") {
+      blocks.push({ type: "text", text: block });
+    } else if (block.type === "text") {
+      blocks.push({ type: "text", text: block.text });
+    } else if (block.type === "image") {
+      blocks.push({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: parseImageMediaType(block.mimeType),
+          data: stripBase64Prefix(block.data),
+        },
+      });
+    }
+  }
+
+  return {
+    type: "user",
+    session_id: "",
+    message: { role: "user", content: blocks },
+    parent_tool_use_id: null,
+  };
+}
+
+/**
+ * Build conversation history prefix for messages in [startIndex, end).
+ * The latest user message is always excluded (handled separately).
+ */
+function buildHistoryPrefix(context: Context, startIndex: number): string {
+  const parts: string[] = [];
+
+  // System prompt only on first turn (startIndex === 0)
+  if (startIndex === 0 && context.systemPrompt) {
+    parts.push(context.systemPrompt);
+    parts.push("");
+  }
+
+  const messages = context.messages;
+
+  // All messages in range except the last user message
+  for (let i = startIndex; i < messages.length; i++) {
+    const msg = messages[i];
+    if (i === messages.length - 1 && msg.role === "user") continue;
+
+    if (msg.role === "user") {
+      const text = extractTextContent(msg.content);
+      const hasImages = extractImages(msg).length > 0;
+      if (text) {
+        parts.push(`User: ${text}${hasImages ? " [image omitted]" : ""}`);
+      } else if (hasImages) {
+        parts.push("User: [image omitted]");
+      }
+    } else if (msg.role === "assistant") {
+      const text = extractTextContent(msg.content);
+      if (text) parts.push(`Assistant: ${text}`);
+      for (const block of msg.content) {
+        if (block.type === "toolCall") {
+          parts.push(
+            `[Tool used: ${block.name}(${JSON.stringify(block.arguments)})]`,
+          );
+        }
+      }
+    } else if (msg.role === "toolResult") {
+      const text = extractTextContent(msg.content);
+      const status = msg.isError ? "Error" : "Result";
+      const snippet = truncateToolResult(text);
+      parts.push(`[Tool ${status} (${msg.toolName}): ${snippet}]`);
+    }
+  }
+
+  return parts.length > 0 ? parts.join("\n") + "\n\n" : "";
+}
+
+/**
+ * Truncate tool result with head + tail strategy (industry best practice).
+ * Head 1200 chars (captures output start), tail 600 chars (captures errors/summaries),
+ * marker in middle.
+ */
+const TOOL_RESULT_HEAD = 1200;
+const TOOL_RESULT_TAIL = 600;
+
+function truncateToolResult(text: string): string {
+  if (!text) return "(empty)";
+  if (text.length <= TOOL_RESULT_HEAD + TOOL_RESULT_TAIL + 50) return text;
+
+  const head = text.slice(0, TOOL_RESULT_HEAD);
+  const tail = text.slice(-TOOL_RESULT_TAIL);
+  const skipped = text.length - TOOL_RESULT_HEAD - TOOL_RESULT_TAIL;
+  return `${head}\n...[${skipped.toLocaleString()} chars skipped]...\n${tail}`;
+}
+
+// ── helpers ──
+
+function findLastUserMessage(context: Context, startIndex: number) {
+  for (let i = context.messages.length - 1; i >= startIndex; i--) {
+    if (context.messages[i].role === "user") return context.messages[i];
+  }
+  return null;
+}
+
+function extractImages(msg: any): ImageContent[] {
+  if (!msg || !Array.isArray(msg.content)) return [];
+  return msg.content.filter(
+    (c: any) => typeof c === "object" && c !== null && c.type === "image",
+  );
+}
+
+function extractTextFromMessage(msg: any): string {
+  if (!msg) return "Continue.";
+  return extractTextContent(msg.content) || "Continue.";
+}
+
+function extractTextContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter(
+      (c): c is { type: "text"; text: string } =>
+        typeof c === "object" &&
+        c !== null &&
+        "type" in c &&
+        c.type === "text" &&
+        "text" in c,
+    )
+    .map((c) => c.text)
+    .join("\n");
+}
+
+type ImageMediaType = "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+
+function parseImageMediaType(mimeType: string): ImageMediaType {
+  const valid: ImageMediaType[] = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+  ];
+  if (valid.includes(mimeType as ImageMediaType))
+    return mimeType as ImageMediaType;
+  return "image/png";
+}
+
+function stripBase64Prefix(data: string): string {
+  const comma = data.indexOf(",");
+  return comma >= 0 ? data.slice(comma + 1) : data;
+}

package/src/index.ts

@@ -0,0 +1,115 @@
+import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+
+// ponytail: hardcoded patterns for capability detection since supportedModels() returns
+// only {id, name} without capability metadata.
+const THINKING_PATTERNS = [/claude/i, /gemini/i, /gpt-5/i];
+const IMAGE_PATTERNS = [/claude/i, /gemini/i, /gpt/i];
+// ponytail: rough context window estimates by model family
+const CONTEXT_ESTIMATES: Record<string, [number, number]> = {
+  // [contextWindow, maxTokens]
+  claude: [200000, 8192],
+  gemini: [1048576, 8192],
+  gpt: [200000, 16384],
+  deepseek: [131072, 8192],
+  glm: [131072, 8192],
+  minimax: [131072, 8192],
+  kimi: [131072, 8192],
+  hy: [131072, 8192], // Hunyuan
+};
+
+function detectCapabilities(modelId: string) {
+  const reasoning = THINKING_PATTERNS.some((p) => p.test(modelId));
+  const hasImage = IMAGE_PATTERNS.some((p) => p.test(modelId));
+
+  // Match family for context window estimate
+  const family = Object.keys(CONTEXT_ESTIMATES).find((k) =>
+    modelId.toLowerCase().startsWith(k),
+  );
+  const [contextWindow, maxTokens] = family
+    ? CONTEXT_ESTIMATES[family]
+    : [128000, 8192];
+
+  return {
+    reasoning,
+    input: (hasImage ? ["text", "image"] : ["text"]) as ("text" | "image")[],
+    contextWindow,
+    maxTokens,
+  };
+}
+
+async function discoverModels(): Promise<ProviderModelConfig[]> {
+  try {
+    const sdk = await import("@tencent-ai/agent-sdk");
+    const q = sdk.query({
+      prompt: "",
+      options: {
+        permissionMode: "bypassPermissions",
+        maxTurns: 0,
+      },
+    });
+    const models = await Promise.race([
+      q.supportedModels(),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("CodeBuddy model discovery timed out after 15s")), 15000),
+      ),
+    ]);
+    if (models && models.length > 0) {
+      return models.map((m) => {
+        const caps = detectCapabilities(m.id);
+        return {
+          id: m.id,
+          name: m.name || m.id,
+          reasoning: caps.reasoning,
+          input: caps.input,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: caps.contextWindow,
+          maxTokens: caps.maxTokens,
+        };
+      });
+    }
+  } catch (e) {
+    // Discovery failed — SDK not installed, CLI missing, or network issue.
+    // Fall back to hardcoded minimal list so Pi can still show a provider.
+    console.warn(
+      `[pi-codebuddy-sdk] Model discovery failed: ${e instanceof Error ? e.message : String(e)}. Using ${3} fallback models.`,
+    );
+  }
+
+  // ponytail: fallback model list when discovery fails
+  return [
+    { id: "hy3-preview-agent-ioa", name: "Hunyuan 3 Preview", reasoning: false, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128000, maxTokens: 8192 },
+    { id: "claude-sonnet-4.6", name: "Claude Sonnet 4.6", reasoning: true, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 200000, maxTokens: 8192 },
+    { id: "deepseek-v4-pro-ioa", name: "DeepSeek V4 Pro", reasoning: false, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128000, maxTokens: 8192 },
+  ];
+}
+
+export default async function (pi: ExtensionAPI) {
+  const models = await discoverModels();
+
+  pi.registerProvider("codebuddy", {
+    name: "CodeBuddy",
+    baseUrl: "https://codebuddy.ai",
+    apiKey: "codebuddy-local",
+    api: "codebuddy-sdk",
+    models,
+    streamSimple: (await import("./provider.js")).streamCodebuddy,
+  });
+
+  pi.registerCommand("codebuddy-refresh-models", {
+    description: "Refresh CodeBuddy model list from SDK",
+    handler: async (_args, ctx) => {
+      const refreshed = await discoverModels();
+      pi.registerProvider("codebuddy", {
+        name: "CodeBuddy",
+        baseUrl: "https://codebuddy.ai",
+        apiKey: "codebuddy-local",
+        api: "codebuddy-sdk",
+        models: refreshed,
+        streamSimple: (await import("./provider.js")).streamCodebuddy,
+      });
+      if (ctx.hasUI) {
+        ctx.ui.notify(`CodeBuddy: ${refreshed.length} models loaded`, "info");
+      }
+    },
+  });
+}

package/src/provider.ts

@@ -0,0 +1,266 @@
+import {
+  createAssistantMessageEventStream,
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Context,
+  type Model,
+  type SimpleStreamOptions,
+  type TextContent,
+  type ThinkingContent,
+  type ToolCall,
+} from "@earendil-works/pi-ai/compat";
+import type {
+  Message as CbMessage,
+  ThinkingConfig,
+  Effort,
+} from "@tencent-ai/agent-sdk";
+import { buildFullMessage, buildDeltaMessage } from "./context.js";
+import { acquireSession, evictSession } from "./session-pool.js";
+
+type CodebuddySdk = typeof import("@tencent-ai/agent-sdk");
+
+async function loadCodebuddySdk(): Promise<CodebuddySdk> {
+  return import("@tencent-ai/agent-sdk");
+}
+
+// ── helpers ──
+
+function makePartial(model: Model<Api>): AssistantMessage {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+}
+
+function makeErrorPartial(model: Model<Api>, error: unknown): AssistantMessage {
+  return {
+    ...makePartial(model),
+    stopReason: "error",
+    errorMessage: `CodeBuddy SDK error: ${error instanceof Error ? error.message : String(error)}`,
+  };
+}
+
+function extractUsageUpdate(msg: CbMessage): Partial<AssistantMessage> | null {
+  if (msg.type === "result" && msg.usage) {
+    return {
+      usage: {
+        input: msg.usage.input_tokens ?? 0,
+        output: msg.usage.output_tokens ?? 0,
+        cacheRead: msg.usage.cache_read_input_tokens ?? 0,
+        cacheWrite: msg.usage.cache_creation_input_tokens ?? 0,
+        totalTokens: (msg.usage.input_tokens ?? 0) + (msg.usage.output_tokens ?? 0) + (msg.usage.cache_read_input_tokens ?? 0) + (msg.usage.cache_creation_input_tokens ?? 0),
+        cost: {
+          input: 0,
+          output: 0,
+          cacheRead: 0,
+          cacheWrite: 0,
+          total: msg.total_cost_usd ?? 0,
+        },
+      },
+    };
+  }
+  return null;
+}
+
+// ── thinking config mapping ──
+
+const DEFAULT_THINKING_BUDGETS: Record<string, number> = {
+  minimal: 1600,
+  low: 4000,
+  medium: 0,  // adaptive
+  high: 0,    // adaptive
+  xhigh: 32000,
+};
+
+const DEFAULT_EFFORT: Record<string, Effort | undefined> = {
+  minimal: 'low',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  xhigh: 'xhigh',
+};
+
+function buildThinkingConfig(
+  reasoning: string | undefined,
+  thinkingBudgets?: SimpleStreamOptions["thinkingBudgets"],
+): { thinking?: ThinkingConfig; effort?: Effort } {
+  if (!reasoning) return {};
+  if (reasoning === "off") return { thinking: { type: "disabled" } };
+
+  const budget = thinkingBudgets?.[reasoning as keyof typeof thinkingBudgets]
+    ?? DEFAULT_THINKING_BUDGETS[reasoning] ?? 0;
+  const effort = DEFAULT_EFFORT[reasoning];
+
+  if (budget > 0) return { thinking: { type: "enabled", budgetTokens: budget }, effort };
+  return { thinking: { type: "adaptive" }, effort };
+}
+
+// ── main provider ──
+
+export function streamCodebuddy(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+  const partial = makePartial(model);
+
+  queueMicrotask(async () => {
+    let session: Awaited<ReturnType<CodebuddySdk["unstable_v2_createSession"]>> | undefined;
+    let isFirst = false;
+
+    try {
+      stream.push({ type: "start", partial });
+
+      const sdk = await loadCodebuddySdk();
+
+      const { thinking, effort } = buildThinkingConfig(
+        options?.reasoning,
+        options?.thinkingBudgets,
+      );
+
+      const includePartial = !!(model.reasoning && options?.reasoning && options.reasoning !== "off");
+
+      const cwd = process.cwd();
+
+      const { session: pooled, message: userMessage, isFirst: first } =
+        await acquireSession(cwd, sdk, context, buildFullMessage, buildDeltaMessage, {
+          model: model.id,
+          permissionMode: "bypassPermissions",
+          maxTurns: 100,
+          thinking,
+          effort,
+          includePartialMessages: includePartial,
+        });
+
+      session = pooled;
+      isFirst = first;
+
+      let contentIndex = 0;
+      let msgCount = 0; // track assistant messages for empty-response detection
+
+      // ── abort handling ──
+      let aborted = false;
+      const onAbort = async () => {
+        if (aborted) return;
+        aborted = true;
+        try { await session!.interrupt(); } catch { /* best-effort */ }
+        partial.stopReason = "aborted";
+        stream.push({ type: "error", reason: "aborted", error: partial });
+      };
+      if (options?.signal) {
+        options.signal.addEventListener("abort", onAbort, { once: true });
+        if (options.signal.aborted) {
+          await onAbort();
+          return;
+        }
+      }
+
+      // ── send prompt ──
+      await session.send(userMessage);
+
+      // ── iterate responses ──
+      for await (const msg of session.stream()) {
+        if (aborted) return;
+
+        if (msg.type === "system") {
+          if (msg.model) partial.responseModel = msg.model;
+          continue;
+        }
+
+        if (msg.type === "assistant") {
+          msgCount++;
+          for (const block of msg.message.content) {
+            // Non-reasoning models may emit thinking blocks wrapping text (Hunyuan quirk).
+            // Treat them as text.
+            if (block.type === "thinking") {
+              if (model.reasoning) {
+                const ci = contentIndex++;
+                const tc: ThinkingContent = { type: "thinking", thinking: block.thinking };
+                partial.content = [...partial.content, tc];
+                stream.push({ type: "thinking_start", contentIndex: ci, partial });
+                stream.push({ type: "thinking_delta", contentIndex: ci, delta: block.thinking, partial });
+                stream.push({ type: "thinking_end", contentIndex: ci, content: block.thinking, partial });
+              } else {
+                // Fallback: emit as text for non-reasoning models
+                const ci = contentIndex++;
+                const textBlock: TextContent = { type: "text", text: block.thinking };
+                partial.content = [...partial.content, textBlock];
+                stream.push({ type: "text_start", contentIndex: ci, partial });
+                stream.push({ type: "text_delta", contentIndex: ci, delta: block.thinking, partial });
+                stream.push({ type: "text_end", contentIndex: ci, content: block.thinking, partial });
+              }
+            } else if (block.type === "redacted_thinking") {
+              const ci = contentIndex++;
+              const tc: ThinkingContent = {
+                type: "thinking", thinking: "[redacted]",
+                thinkingSignature: block.data, redacted: true,
+              };
+              partial.content = [...partial.content, tc];
+              stream.push({ type: "thinking_start", contentIndex: ci, partial });
+              stream.push({ type: "thinking_end", contentIndex: ci, content: "[redacted]", partial });
+            } else if (block.type === "text") {
+              const ci = contentIndex++;
+              const textBlock: TextContent = { type: "text", text: block.text };
+              partial.content = [...partial.content, textBlock];
+              stream.push({ type: "text_start", contentIndex: ci, partial });
+              stream.push({ type: "text_delta", contentIndex: ci, delta: block.text, partial });
+              stream.push({ type: "text_end", contentIndex: ci, content: block.text, partial });
+            } else if (block.type === "tool_use") {
+              const ci = contentIndex++;
+              const toolCall: ToolCall = {
+                type: "toolCall", id: block.id, name: block.name,
+                arguments: (block.input ?? {}) as Record<string, unknown>,
+              };
+              partial.content = [...partial.content, toolCall];
+              stream.push({ type: "toolcall_start", contentIndex: ci, partial });
+              stream.push({ type: "toolcall_end", contentIndex: ci, toolCall, partial });
+            }
+          }
+        }
+
+        if (msg.type === "result") {
+          const usageUpdate = extractUsageUpdate(msg);
+          if (usageUpdate) Object.assign(partial, usageUpdate);
+
+          if (msg.subtype === "success") {
+            partial.stopReason = "stop";
+            stream.push({ type: "done", reason: "stop", message: { ...partial } });
+          } else {
+            partial.stopReason = "error";
+            partial.errorMessage = msg.errors?.join("; ") ?? `CodeBuddy error: ${msg.subtype}`;
+            stream.push({ type: "error", reason: "error", error: { ...partial } });
+            // Error on a turn: evict session so next turn starts fresh
+            evictSession(cwd);
+          }
+          // break (not return) to let iterator drain naturally
+          break;
+        }
+      }
+
+      // Some models (Hunyuan) return empty on session reuse → evict for fresh session next turn
+      if (msgCount === 0) {
+        evictSession(cwd);
+      }
+
+      // Stream ended; no extra done emission (handled in result branch above)
+    } catch (error) {
+      evictSession(process.cwd());
+      const errPartial = makeErrorPartial(model, error);
+      stream.push({ type: "error", reason: "error", error: errPartial });
+    } finally {
+      // ponytail: do NOT close pooled sessions — they are reused across turns.
+      // Only close when evicted (via evictSession).
+      // session?.close() intentionally omitted here.
+    }
+  });
+
+  return stream;
+}

package/src/session-pool.ts

@@ -0,0 +1,99 @@
+/**
+ * Session Pool — CodeBuddy CLI subprocess reuse across Pi turns.
+ *
+ * ~3s CLI cold-start saved per turn after the first.
+ *
+ * Key: cwd + fingerprint of conversation's first user message.
+ * Session change detected when the first message differs.
+ *
+ * Anti-double-history: on continuation, only send new messages
+ * (the delta since last send). CodeBuddy session keeps internal context.
+ */
+import type { Message as CbMessage, Session } from "@tencent-ai/agent-sdk";
+import type { Context } from "@earendil-works/pi-ai/compat";
+
+type CodebuddySdk = typeof import("@tencent-ai/agent-sdk");
+
+interface PoolEntry {
+  session: Session;
+  sentCount: number;
+  firstFingerprint: string;
+}
+
+const pool = new Map<string, PoolEntry>();
+
+function fingerprintFirstMessage(context: Context): string {
+  const first = context.messages[0];
+  if (!first || first.role !== "user") return "";
+  if (typeof first.content === "string") return first.content.slice(0, 80);
+  if (Array.isArray(first.content)) {
+    const texts = first.content
+      .filter((c: any) => c?.type === "text")
+      .map((c: any) => c.text)
+      .join(" ");
+    return texts.slice(0, 80);
+  }
+  return "";
+}
+
+export async function acquireSession(
+  cwd: string,
+  sdk: CodebuddySdk,
+  context: Context,
+  buildFull: (ctx: Context) => string | CbMessage,
+  buildDelta: (ctx: Context, startIndex: number) => string | CbMessage,
+  sessionOptions: Parameters<CodebuddySdk["unstable_v2_createSession"]>[0],
+): Promise<{
+  session: Session;
+  message: string | CbMessage;
+  isFirst: boolean;
+}> {
+  const key = cwd || process.cwd();
+  const fp = fingerprintFirstMessage(context);
+  const existing = pool.get(key);
+
+  const isNew = !existing || existing.firstFingerprint !== fp;
+
+  if (isNew) {
+    if (existing) {
+      try { existing.session.close(); } catch { /* best-effort */ }
+    }
+
+    const session = sdk.unstable_v2_createSession(sessionOptions);
+    try {
+      await session.connect();
+    } catch (e) {
+      try { session.close(); } catch { /* best-effort, already broken */ }
+      throw e;
+    }
+
+    const message = buildFull(context);
+    pool.set(key, { session, sentCount: context.messages.length, firstFingerprint: fp });
+    return { session, message, isFirst: true };
+  }
+
+  const deltaStart = existing.sentCount;
+  const message =
+    deltaStart < context.messages.length
+      ? buildDelta(context, deltaStart)
+      : "Continue.";
+
+  existing.sentCount = context.messages.length;
+  return { session: existing.session, message, isFirst: false };
+}
+
+export function evictSession(cwd: string): void {
+  const key = cwd || process.cwd();
+  const entry = pool.get(key);
+  if (entry) {
+    try { entry.session.close(); } catch { /* best-effort */ }
+    pool.delete(key);
+  }
+}
+
+export function closeAll(): void {
+  for (const [key, entry] of pool) {
+    try { entry.session.close(); } catch { /* best-effort */ }
+    pool.delete(key);
+  }
+}