pi-codebuddy-sdk 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codebuddy-sdk",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "CodeBuddy Agent SDK provider for Pi — native tool execution, 29+ models, thinking controls, session pool",
   "author": "slahser",
   "license": "MIT",

package/src/provider.ts

@@ -1,3 +1,12 @@
+/**
+ * CodeBuddy Provider — stateless, lightweight.
+ *
+ * Uses sdk.query() (one-shot) — no context building, no session pool,
+ * no tool boundary. Pi manages conversation, CodeBuddy is just a model backend.
+ *
+ * Architecture follows pi-openai-compatible / pi-anthropic pattern:
+ * extract latest user message → send to SDK → stream events back to Pi.
+ */
 import {
   createAssistantMessageEventStream,
   type Api,
@@ -16,8 +25,6 @@ import type {
   Effort,
   RawMessageStreamEvent,
 } 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");
 
@@ -70,13 +77,83 @@ function extractUsageUpdate(msg: CbMessage): Partial<AssistantMessage> | null {
   return null;
 }
 
+// ── extract latest user message ──
+
+function extractLatestUserText(context: Context): string {
+  const messages = context.messages;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      let raw = extractRawContent((messages[i] as any).content);
+      if (!raw) continue;
+      // Strip context-mode session state injection prepended to user messages.
+      // Pi's context-mode adds its hierarchy/state before the actual user input.
+      raw = stripContextModeInjection(raw);
+      if (raw) return raw;
+    }
+  }
+  return "Continue.";
+}
+
+function extractRawContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((c: any) => c?.type === "text")
+    .map((c: any) => c.text)
+    .join("\n");
+}
+
+/**
+ * Pi context-mode prepends its session state to user messages.
+ * Strip it to keep CodeBuddy from treating it as conversation content.
+ *
+ * Injected format:
+ *   context-mode active. Hierarchy: ...
+ *   <session_state source="compaction">
+ *   <session_mode>investigate</session_mode>
+ *   </session_state>
+ *   [actual user message]
+ */
+function stripContextModeInjection(text: string): string {
+  // Find the end of context-mode injection
+  // Pattern: </session_state> followed by newlines then actual message
+  const sessionEnd = text.lastIndexOf("</session_state>");
+  if (sessionEnd >= 0) {
+    const after = text.slice(sessionEnd + "</session_state>".length).trimStart();
+    if (after) return after;
+  }
+
+  // Fallback: look for "context-mode active" header and take everything after it + session_state
+  const cmStart = text.indexOf("context-mode active.");
+  if (cmStart >= 0) {
+    // Find first blank line after </session_state> or end of XML
+    const afterSession = afterSessionState(text);
+    if (afterSession) return afterSession;
+  }
+
+  return text;
+}
+
+function afterSessionState(text: string): string | null {
+  // Try to find the actual user message after context-mode XML injection
+  const patterns = [
+    /context-mode active\.[\s\S]*?<\/session_state>\s*\n+([\s\S]+)$/,
+    /<session_state[\s\S]*?<\/session_state>\s*\n+([\s\S]+)$/,
+  ];
+  for (const re of patterns) {
+    const m = text.match(re);
+    if (m?.[1]?.trim()) return m[1].trim();
+  }
+  return null;
+}
+
 // ── thinking config mapping ──
 
 const DEFAULT_THINKING_BUDGETS: Record<string, number> = {
   minimal: 1600,
   low: 4000,
-  medium: 0,  // adaptive
-  high: 0,    // adaptive
+  medium: 0,
+  high: 0,
   xhigh: 32000,
 };
 
@@ -114,53 +191,35 @@ export function streamCodebuddy(
   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 userText = extractLatestUserText(context);
 
       const { thinking, effort } = buildThinkingConfig(
         options?.reasoning,
         options?.thinkingBudgets,
       );
 
-      // Always request partial messages so we get stream_event deltas for real streaming.
-      // Non-streaming-capable models will still emit assistant messages as fallback.
-      const includePartial = true;
-
-      const cwd = process.cwd();
-
-      const { session: pooled, message: userMessage, isFirst: first } =
-        await acquireSession(cwd, sdk, context, buildFullMessage, buildDeltaMessage, {
+      const q = sdk.query({
+        prompt: userText,
+        options: {
           model: model.id,
           permissionMode: "bypassPermissions",
           maxTurns: 100,
           thinking,
           effort,
-          includePartialMessages: includePartial,
-        });
-
-      session = pooled;
-      isFirst = first;
-
-      let msgCount = 0; // track content blocks for empty-response detection
-      let hasStreamEvents = false; // true once we see first stream_event
-
-      // Per-index tracking for stream_event delta accumulation
-      type BlockKind = 'text' | 'thinking' | 'tool_use' | 'redacted_thinking';
-      const blockKind = new Map<number, BlockKind>();
-      const blockAccum = new Map<number, string>();
-      const blockMeta = new Map<number, { id: string; name: string; signature?: string }>();
+          includePartialMessages: true,
+        },
+      });
 
       // ── abort handling ──
       let aborted = false;
       const onAbort = async () => {
         if (aborted) return;
         aborted = true;
-        try { await session!.interrupt(); } catch { /* best-effort */ }
+        try { await q.interrupt(); } catch { /* best-effort */ }
         partial.stopReason = "aborted";
         stream.push({ type: "error", reason: "aborted", error: partial });
       };
@@ -172,10 +231,14 @@ export function streamCodebuddy(
         }
       }
 
-      // ── send prompt ──
-      await session.send(userMessage);
+      // ── per-index block tracking ──
+      type BlockKind = 'text' | 'thinking' | 'tool_use' | 'redacted_thinking';
+      const blockKind = new Map<number, BlockKind>();
+      const blockAccum = new Map<number, string>();
+      const blockMeta = new Map<number, { id: string; name: string; signature?: string }>();
+
+      let hasStreamEvents = false;
 
-      // ── helpers for stream_event block tracking ──
       function onBlockStart(idx: number, kind: BlockKind, initText: string, meta?: { id: string; name: string; signature?: string }) {
         blockKind.set(idx, kind);
         blockAccum.set(idx, initText);
@@ -186,22 +249,18 @@ export function streamCodebuddy(
           partial.content = [...partial.content, tc];
           stream.push({ type: 'thinking_start', contentIndex: idx, partial });
           stream.push({ type: 'thinking_end', contentIndex: idx, content: '[redacted]', partial });
-          msgCount++;
         } else if (kind === 'thinking') {
           const tc: ThinkingContent = { type: 'thinking', thinking: initText, thinkingSignature: meta?.signature };
           partial.content = [...partial.content, tc];
           stream.push({ type: 'thinking_start', contentIndex: idx, partial });
-          msgCount++;
         } else if (kind === 'text') {
           const tb: TextContent = { type: 'text', text: initText };
           partial.content = [...partial.content, tb];
           stream.push({ type: 'text_start', contentIndex: idx, partial });
-          msgCount++;
         } else if (kind === 'tool_use' && meta) {
           const toolCall: ToolCall = { type: 'toolCall', id: meta.id, name: meta.name, arguments: {} };
           partial.content = [...partial.content, toolCall];
           stream.push({ type: 'toolcall_start', contentIndex: idx, partial });
-          msgCount++;
         }
       }
 
@@ -229,7 +288,7 @@ export function streamCodebuddy(
           const blocks = [...partial.content];
           try {
             blocks[idx] = { ...blocks[idx], arguments: JSON.parse(newJson) };
-          } catch { /* partial JSON — keep previous */ }
+          } catch { /* partial JSON */ }
           partial.content = blocks;
           stream.push({ type: 'toolcall_delta', contentIndex: idx, delta: deltaValue, partial } as any);
         }
@@ -248,8 +307,8 @@ export function streamCodebuddy(
         }
       }
 
-      // ── iterate responses ──
-      for await (const msg of session.stream()) {
+      // ── iterate ──
+      for await (const msg of q) {
         if (aborted) return;
 
         if (msg.type === "system") {
@@ -257,7 +316,6 @@ export function streamCodebuddy(
           continue;
         }
 
-        // Primary path: token-level streaming via stream_event
         if (msg.type === "stream_event") {
           hasStreamEvents = true;
           const evt = msg.event;
@@ -279,21 +337,19 @@ export function streamCodebuddy(
             if (d.type === 'text_delta') onBlockDelta(evt.index, 'text_delta', d.text);
             else if (d.type === 'thinking_delta') onBlockDelta(evt.index, 'thinking_delta', d.thinking);
             else if (d.type === 'input_json_delta') onBlockDelta(evt.index, 'input_json_delta', d.partial_json);
-            // ponytail: signature_delta not surfaced to Pi — signature only sent at block start
           } else if (evt.type === "content_block_stop") {
             onBlockStop(evt.index);
           }
           continue;
         }
 
-        // Fallback: full assistant messages (used when model doesn't support streaming)
+        // Fallback: full assistant messages
         if (msg.type === "assistant" && !hasStreamEvents) {
-          msgCount++;
           let ci = 0;
           for (const block of msg.message.content) {
             const idx = ci++;
             if (block.type === "thinking") {
-              onBlockStart(idx, 'thinking', block.thinking, { id: '', name: '', signature: undefined });
+              onBlockStart(idx, 'thinking', block.thinking);
               onBlockStop(idx);
             } else if (block.type === "redacted_thinking") {
               onBlockStart(idx, 'redacted_thinking', '[redacted]', { id: '', name: '', signature: block.data });
@@ -319,24 +375,13 @@ export function streamCodebuddy(
             partial.stopReason = "error";
             partial.errorMessage = msg.errors?.join("; ") ?? `CodeBuddy error: ${msg.subtype}`;
             stream.push({ type: "error", reason: "error", error: { ...partial } });
-            evictSession(cwd);
           }
           break;
         }
       }
-
-      // Some models (Hunyuan) return empty on session reuse → evict for fresh session next turn
-      if (msgCount === 0) {
-        evictSession(cwd);
-      }
     } 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.
     }
   });
 

package/src/context.ts

@@ -1,238 +0,0 @@
-import type { Context, ImageContent, Message } from "@earendil-works/pi-ai/compat";
-import { convertToLlm } from "@earendil-works/pi-coding-agent";
-import type { UserMessage as CbUserMessage, ContentBlock } from "@tencent-ai/agent-sdk";
-
-// ── public API ──
-
-export function buildFullMessage(context: Context): string | CbUserMessage {
-  return buildMessage(context, 0);
-}
-
-export function buildDeltaMessage(context: Context, startIndex: number): string | CbUserMessage {
-  return buildMessage(context, startIndex);
-}
-
-// ── tool boundary (like pi-cursor-sdk's getCursorToolBoundaryText) ──
-
-const CODEBUDDY_TOOL_BOUNDARY = [
-  "CodeBuddy SDK tool boundary:",
-  "Call only CodeBuddy SDK native tools (Read, Write, Bash, Grep, Edit, Glob, etc.).",
-  "Do not call any Pi-ecosystem tools — they are not registered in this session.",
-  "Tool names from conversation history refer to a prior provider; they are unavailable now.",
-  "CodeBuddy executes tools locally on the filesystem.",
-].join("\n");
-
-const CODEBUDDY_TOOL_TAIL = [
-  "Answer the latest user request above using CodeBuddy SDK tools and capabilities.",
-  "Shell: cd to repo path for project commands; session cwd may differ from tool args.",
-  "Exact-output requests: output exactly the requested text; no preamble or checks unless asked.",
-  "Tools: call available CodeBuddy SDK tools; never print tool cards or names as assistant text.",
-].join("\n");
-
-// ── system prompt sanitization (like pi-cursor-sdk's sanitizeSystemPromptForCursor) ──
-
-function sanitizeSystemPrompt(prompt: string): string {
-  let s = prompt;
-
-  // Strip Pi tool catalog section
-  s = s.replace(
-    /Available tools:\n[\s\S]*?\n\nIn addition to the tools above[\s\S]*?\n\n/g,
-    "Pi tool catalog omitted: CodeBuddy can call only CodeBuddy SDK tools.\n\n",
-  );
-
-  // Strip Guidelines section (Pi-specific guidelines)
-  s = s.replace(
-    /Guidelines:\n[\s\S]*?\n\nPi documentation /g,
-    "Guidelines:\n- Be concise in your responses.\n- Show file paths clearly when working with files.\n\nPi documentation ",
-  );
-
-  // Strip semantic code intelligence priority section
-  s = s.replace(/\n+Semantic code intelligence priority:[\s\S]*$/g, "");
-
-  return s.trim();
-}
-
-// ── message formatting ──
-
-function formatMessage(msg: Message): string | undefined {
-  switch (msg.role) {
-    case "user": {
-      const text = extractTextContent(msg.content);
-      const hasImages = extractImages(msg).length > 0;
-      if (text) {
-        return `User: ${text}${hasImages ? " [image omitted]" : ""}`;
-      }
-      if (hasImages) return "User: [image omitted]";
-      return undefined;
-    }
-    case "assistant": {
-      const blocks = Array.isArray(msg.content) ? msg.content : [];
-      const parts: string[] = [];
-      for (const block of blocks) {
-        if (typeof block === "object" && block !== null && "type" in block) {
-          if (block.type === "text") {
-            parts.push((block as { text: string }).text);
-          } else if (block.type === "toolCall") {
-            const tc = block as { name: string; arguments: Record<string, unknown> };
-            parts.push(`[Tool used: ${tc.name}(${JSON.stringify(tc.arguments)})]`);
-          }
-          // Skip thinking content blocks
-        }
-      }
-      return parts.length > 0 ? `Assistant: ${parts.join("\n")}` : undefined;
-    }
-    case "toolResult": {
-      const text = extractTextContent(msg.content);
-      const label = msg.isError ? "Tool error" : "Tool result";
-      const snippet = truncateToolResult(text);
-      return `[${label} (${msg.toolName}): ${snippet}]`;
-    }
-    default:
-      return undefined;
-  }
-}
-
-// ── truncation ──
-
-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}`;
-}
-
-// ── main builder ──
-
-function buildMessage(context: Context, startIndex: number): string | CbUserMessage {
-  const parts: string[] = [];
-
-  // 1. Tool boundary (always first)
-  parts.push(CODEBUDDY_TOOL_BOUNDARY);
-
-  // 2. Sanitized system prompt (first turn only — like pi-cursor-sdk)
-  if (startIndex === 0 && context.systemPrompt) {
-    const sanitized = sanitizeSystemPrompt(context.systemPrompt);
-    if (sanitized) {
-      parts.push(`System instructions from pi:\n${sanitized}`);
-    }
-  }
-
-  // 3. Normalize and format messages (filter out non-LLM roles via convertToLlm)
-  const rawMessages = context.messages as Parameters<typeof convertToLlm>[0];
-  let llmMessages = convertToLlm(rawMessages);
-
-  // ponytail: filter compaction/branch summary user messages on first turn.
-  // convertToLlm wraps them as user messages with <summary> tags; Hunyuan
-  // parrots context-mode state from them. Smarter models follow boundary text.
-  if (startIndex === 0) {
-    llmMessages = llmMessages.filter((m) => {
-      if (m.role !== "user") return true;
-      const text = extractTextContent(m.content);
-      // Compaction summaries are large blocks with context-mode state
-      if (text.includes("<summary>") || text.includes("compacted into")) return false;
-      // context-mode session state injection
-      if (text.includes("context-mode active") || text.includes("<session_state")) return false;
-      return true;
-    });
-  }
-  const latestUserIdx = findLatestUserIndex(llmMessages);
-  const msgParts: string[] = [];
-  for (let i = startIndex; i < llmMessages.length; i++) {
-    if (i === latestUserIdx) continue; // handled separately (images etc.)
-    const formatted = formatMessage(llmMessages[i]);
-    if (formatted) msgParts.push(formatted);
-  }
-
-  // 4. Latest user message
-  const lastUser = latestUserIdx >= 0 ? llmMessages[latestUserIdx] : null;
-  const lastUserText = lastUser ? extractTextContent(lastUser.content) : "Continue.";
-  const images = lastUser ? extractImages(lastUser) : [];
-
-  // 5. Tool tail guard
-  parts.push(
-    msgParts.length > 0 ? msgParts.join("\n") : "(new conversation)",
-  );
-  parts.push(CODEBUDDY_TOOL_TAIL);
-
-  const prefix = parts.join("\n\n");
-
-  // Plain text (no images)
-  if (images.length === 0) {
-    return prefix + "\n\n" + lastUserText;
-  }
-
-  // Structured message with images
-  const blocks: ContentBlock[] = [];
-  blocks.push({ type: "text", text: prefix });
-  blocks.push({ type: "text", text: lastUserText });
-  for (const block of lastUser!.content) {
-    if (typeof block === "object" && block !== null && "type" in block && (block as { type: string }).type === "image") {
-      const img = block as ImageContent;
-      blocks.push({
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: parseImageMediaType(img.mimeType),
-          data: stripBase64Prefix(img.data),
-        },
-      });
-    }
-  }
-
-  return {
-    type: "user",
-    session_id: "",
-    message: { role: "user", content: blocks },
-    parent_tool_use_id: null,
-  };
-}
-
-// ── helpers ──
-
-function findLatestUserIndex(messages: Message[]): number {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "user") return i;
-  }
-  return -1;
-}
-
-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 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/session-pool.ts

@@ -1,99 +0,0 @@
-/**
- * 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);
-  }
-}