pi-codebuddy-sdk 0.1.2 → 0.1.3

package/package.json

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

package/src/index.ts

@@ -94,22 +94,4 @@ export default async function (pi: ExtensionAPI) {
     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

@@ -14,6 +14,7 @@ import type {
   Message as CbMessage,
   ThinkingConfig,
   Effort,
+  RawMessageStreamEvent,
 } from "@tencent-ai/agent-sdk";
 import { buildFullMessage, buildDeltaMessage } from "./context.js";
 import { acquireSession, evictSession } from "./session-pool.js";
@@ -126,7 +127,9 @@ export function streamCodebuddy(
         options?.thinkingBudgets,
       );
 
-      const includePartial = !!(model.reasoning && options?.reasoning && options.reasoning !== "off");
+      // 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();
 
@@ -143,8 +146,14 @@ export function streamCodebuddy(
       session = pooled;
       isFirst = first;
 
-      let contentIndex = 0;
-      let msgCount = 0; // track assistant messages for empty-response detection
+      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 }>();
 
       // ── abort handling ──
       let aborted = false;
@@ -166,6 +175,79 @@ export function streamCodebuddy(
       // ── send prompt ──
       await session.send(userMessage);
 
+      // ── 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);
+        if (meta) blockMeta.set(idx, meta);
+
+        if (kind === 'redacted_thinking') {
+          const tc: ThinkingContent = { type: 'thinking', thinking: '[redacted]', redacted: true, thinkingSignature: meta?.signature };
+          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++;
+        }
+      }
+
+      function onBlockDelta(idx: number, deltaType: string, deltaValue: string) {
+        const kind = blockKind.get(idx);
+        if (!kind) return;
+
+        if (deltaType === 'text_delta' && kind === 'text') {
+          const newText = (blockAccum.get(idx) || '') + deltaValue;
+          blockAccum.set(idx, newText);
+          const blocks = [...partial.content];
+          blocks[idx] = { type: 'text', text: newText };
+          partial.content = blocks;
+          stream.push({ type: 'text_delta', contentIndex: idx, delta: deltaValue, partial });
+        } else if (deltaType === 'thinking_delta' && kind === 'thinking') {
+          const newThinking = (blockAccum.get(idx) || '') + deltaValue;
+          blockAccum.set(idx, newThinking);
+          const blocks = [...partial.content];
+          blocks[idx] = { type: 'thinking', thinking: newThinking, thinkingSignature: blockMeta.get(idx)?.signature };
+          partial.content = blocks;
+          stream.push({ type: 'thinking_delta', contentIndex: idx, delta: deltaValue, partial });
+        } else if (deltaType === 'input_json_delta' && kind === 'tool_use') {
+          const newJson = (blockAccum.get(idx) || '') + deltaValue;
+          blockAccum.set(idx, newJson);
+          const blocks = [...partial.content];
+          try {
+            blocks[idx] = { ...blocks[idx], arguments: JSON.parse(newJson) };
+          } catch { /* partial JSON — keep previous */ }
+          partial.content = blocks;
+          stream.push({ type: 'toolcall_delta', contentIndex: idx, delta: deltaValue, partial } as any);
+        }
+      }
+
+      function onBlockStop(idx: number) {
+        const kind = blockKind.get(idx);
+        const accum = blockAccum.get(idx) || '';
+        if (kind === 'text') {
+          stream.push({ type: 'text_end', contentIndex: idx, content: accum, partial });
+        } else if (kind === 'thinking') {
+          stream.push({ type: 'thinking_end', contentIndex: idx, content: accum, partial });
+        } else if (kind === 'tool_use') {
+          const toolCall = partial.content[idx] as ToolCall;
+          stream.push({ type: 'toolcall_end', contentIndex: idx, toolCall, partial });
+        }
+      }
+
       // ── iterate responses ──
       for await (const msg of session.stream()) {
         if (aborted) return;
@@ -175,53 +257,53 @@ export function streamCodebuddy(
           continue;
         }
 
-        if (msg.type === "assistant") {
+        // Primary path: token-level streaming via stream_event
+        if (msg.type === "stream_event") {
+          hasStreamEvents = true;
+          const evt = msg.event;
+
+          if (evt.type === "content_block_start") {
+            const block = evt.content_block;
+            if (block.type === "text") {
+              onBlockStart(evt.index, 'text', block.text || '');
+            } else if (block.type === "thinking") {
+              onBlockStart(evt.index, 'thinking', block.thinking || '', { id: '', name: '', signature: block.signature });
+            } else if (block.type === "redacted_thinking") {
+              onBlockStart(evt.index, 'redacted_thinking', '[redacted]', { id: '', name: '', signature: block.data });
+            } else if (block.type === "tool_use") {
+              const initJson = JSON.stringify(block.input || {});
+              onBlockStart(evt.index, 'tool_use', initJson, { id: block.id, name: block.name });
+            }
+          } else if (evt.type === "content_block_delta") {
+            const d = evt.delta;
+            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)
+        if (msg.type === "assistant" && !hasStreamEvents) {
           msgCount++;
+          let ci = 0;
           for (const block of msg.message.content) {
-            // Non-reasoning models may emit thinking blocks wrapping text (Hunyuan quirk).
-            // Treat them as text.
+            const idx = ci++;
             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 });
-              }
+              onBlockStart(idx, 'thinking', block.thinking, { id: '', name: '', signature: undefined });
+              onBlockStop(idx);
             } 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 });
+              onBlockStart(idx, 'redacted_thinking', '[redacted]', { id: '', name: '', signature: block.data });
             } 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 });
+              onBlockStart(idx, 'text', block.text);
+              onBlockStop(idx);
             } 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 });
+              const initJson = JSON.stringify(block.input ?? {});
+              onBlockStart(idx, 'tool_use', initJson, { id: block.id, name: block.name });
+              onBlockStop(idx);
             }
           }
         }
@@ -237,10 +319,8 @@ export function streamCodebuddy(
             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;
         }
       }
@@ -249,8 +329,6 @@ export function streamCodebuddy(
       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);