@blackbelt-technology/pi-agent-dashboard 0.5.0 → 0.5.2

package/packages/server/src/model-proxy/convert/__tests__/openai-out.test.ts

@@ -0,0 +1,166 @@
+/* Ported from BlackBeltTechnology/pi-model-proxy@179d450 test suite.
+ * See model-proxy/convert/UPSTREAM.md for divergences.
+ */
+import { describe, it, expect } from "vitest";
+import { ToolCallIndexTracker, eventToSSEChunks, eventToNonStreamingResponse } from "../openai-out.js";
+
+function parseSSE(chunk: string): { data: any } {
+  const lines = chunk.trim().split("\n");
+  const dataLine = lines.find((l) => l.startsWith("data: "));
+  if (!dataLine) throw new Error(`No data line in chunk: ${chunk}`);
+  const raw = dataLine.slice(6);
+  if (raw === "[DONE]") return { data: "[DONE]" };
+  return { data: JSON.parse(raw) };
+}
+
+const MODEL = "anthropic/claude-3-5-sonnet";
+const MSG_ID = "test-id";
+
+function makeTracker() {
+  return new ToolCallIndexTracker();
+}
+
+describe("ToolCallIndexTracker", () => {
+  it("assigns sequential indices", () => {
+    const t = makeTracker();
+    expect(t.getIndex("a")).toBe(0);
+    expect(t.getIndex("b")).toBe(1);
+    expect(t.getIndex("a")).toBe(0); // idempotent
+  });
+
+  it("getIndexByContentIndex resolves via toolCall id", () => {
+    const t = makeTracker();
+    t.getIndex("tc1");
+    const content = [{ type: "toolCall", id: "tc1" }];
+    expect(t.getIndexByContentIndex(0, content)).toBe(0);
+  });
+
+  it("getIndexByContentIndex returns 0 for non-toolCall", () => {
+    const t = makeTracker();
+    expect(t.getIndexByContentIndex(0, [{ type: "text" }])).toBe(0);
+  });
+});
+
+describe("eventToSSEChunks", () => {
+  it("start event emits assistant role chunk", () => {
+    const chunks = eventToSSEChunks({ type: "start" }, MODEL, MSG_ID, makeTracker());
+    expect(chunks).toHaveLength(1);
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].delta.role).toBe("assistant");
+    expect(data.object).toBe("chat.completion.chunk");
+  });
+
+  it("text_delta emits content chunk", () => {
+    const chunks = eventToSSEChunks({ type: "text_delta", delta: "hello" }, MODEL, MSG_ID, makeTracker());
+    expect(chunks).toHaveLength(1);
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].delta.content).toBe("hello");
+  });
+
+  it("thinking_delta emits reasoning_content chunk", () => {
+    const chunks = eventToSSEChunks({ type: "thinking_delta", delta: "thinking..." }, MODEL, MSG_ID, makeTracker());
+    expect(chunks).toHaveLength(1);
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].delta.reasoning_content).toBe("thinking...");
+  });
+
+  it("toolcall_start emits tool_calls chunk with index 0", () => {
+    const tracker = makeTracker();
+    const event = {
+      type: "toolcall_start",
+      contentIndex: 0,
+      partial: { content: [{ type: "toolCall", id: "tc1", name: "my_fn" }] },
+    };
+    const chunks = eventToSSEChunks(event, MODEL, MSG_ID, tracker);
+    expect(chunks).toHaveLength(1);
+    const { data } = parseSSE(chunks[0]);
+    const tc = data.choices[0].delta.tool_calls[0];
+    expect(tc.index).toBe(0);
+    expect(tc.function.name).toBe("my_fn");
+  });
+
+  it("toolcall_delta emits argument delta", () => {
+    const tracker = makeTracker();
+    tracker.getIndex("tc1");
+    const event = {
+      type: "toolcall_delta",
+      contentIndex: 0,
+      delta: '{"x":',
+      partial: { content: [{ type: "toolCall", id: "tc1" }] },
+    };
+    const chunks = eventToSSEChunks(event, MODEL, MSG_ID, tracker);
+    expect(chunks).toHaveLength(1);
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].delta.tool_calls[0].function.arguments).toBe('{"x":');
+  });
+
+  it("done event emits finish chunk + [DONE]", () => {
+    const msg = {
+      stopReason: "stop",
+      usage: { input: 10, output: 5 },
+      content: [],
+    };
+    const chunks = eventToSSEChunks({ type: "done", message: msg }, MODEL, MSG_ID, makeTracker());
+    expect(chunks).toHaveLength(2);
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].finish_reason).toBe("stop");
+    expect(data.usage.prompt_tokens).toBe(10);
+    expect(chunks[1].trim()).toBe("data: [DONE]");
+  });
+
+  it("done with stopReason=toolUse → finish_reason=tool_calls", () => {
+    const msg = { stopReason: "toolUse", usage: { input: 0, output: 0 }, content: [] };
+    const chunks = eventToSSEChunks({ type: "done", message: msg }, MODEL, MSG_ID, makeTracker());
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].finish_reason).toBe("tool_calls");
+  });
+
+  it("done with stopReason=length → finish_reason=length", () => {
+    const msg = { stopReason: "length", usage: { input: 0, output: 0 }, content: [] };
+    const chunks = eventToSSEChunks({ type: "done", message: msg }, MODEL, MSG_ID, makeTracker());
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].finish_reason).toBe("length");
+  });
+
+  it("error event emits stop chunk + [DONE]", () => {
+    const chunks = eventToSSEChunks({ type: "error", error: { errorMessage: "fail" } }, MODEL, MSG_ID, makeTracker());
+    expect(chunks).toHaveLength(2);
+    const { data } = parseSSE(chunks[0]);
+    expect(data.choices[0].finish_reason).toBe("stop");
+    expect(chunks[1].trim()).toBe("data: [DONE]");
+  });
+});
+
+describe("eventToNonStreamingResponse", () => {
+  it("text-only response", () => {
+    const msg = {
+      content: [{ type: "text", text: "hello" }],
+      stopReason: "stop",
+      usage: { input: 5, output: 3 },
+    };
+    const response = eventToNonStreamingResponse(msg, MODEL, MSG_ID);
+    expect(response.object).toBe("chat.completion");
+    expect(response.choices[0].message.content).toBe("hello");
+    expect(response.choices[0].finish_reason).toBe("stop");
+    expect(response.usage.prompt_tokens).toBe(5);
+    expect(response.usage.completion_tokens).toBe(3);
+  });
+
+  it("tool call response", () => {
+    const msg = {
+      content: [{ type: "toolCall", id: "tc1", name: "fn", arguments: { x: 1 } }],
+      stopReason: "toolUse",
+      usage: { input: 5, output: 3 },
+    };
+    const response = eventToNonStreamingResponse(msg, MODEL, MSG_ID);
+    expect(response.choices[0].finish_reason).toBe("tool_calls");
+    expect(response.choices[0].message.tool_calls[0].function.name).toBe("fn");
+    expect(response.choices[0].message.content).toBeNull();
+  });
+
+  it("length stop reason", () => {
+    const msg = { content: [], stopReason: "length", usage: { input: 1, output: 1 } };
+    const response = eventToNonStreamingResponse(msg, MODEL, MSG_ID);
+    expect(response.choices[0].finish_reason).toBe("length");
+  });
+});

package/packages/server/src/model-proxy/convert/anthropic-in.ts

@@ -0,0 +1,129 @@
+/* Lifted from BlackBeltTechnology/pi-model-proxy@179d450, MIT licensed.
+ * See model-proxy/convert/UPSTREAM.md for divergences.
+ */
+import type { AnthropicMessagesRequest, AnthropicMessage, AnthropicContentBlock, AnthropicTool } from "./types.js";
+
+/**
+ * Convert Anthropic Messages request into pi-ai Context.
+ */
+export function convertAnthropicMessages(request: AnthropicMessagesRequest): { systemPrompt?: string; messages: any[] } {
+  const systemPrompt = extractSystemPrompt(request.system);
+  const messages: any[] = [];
+
+  for (const msg of request.messages) {
+    if (msg.role === "user") {
+      messages.push(...convertUserMessage(msg));
+    } else if (msg.role === "assistant") {
+      messages.push(convertAssistantMessage(msg));
+    }
+  }
+
+  return { systemPrompt: systemPrompt || undefined, messages };
+}
+
+export function convertAnthropicTools(tools: AnthropicTool[]): any[] {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description || "",
+    parameters: t.input_schema || { type: "object", properties: {} },
+  }));
+}
+
+function extractSystemPrompt(system: string | AnthropicContentBlock[] | undefined): string | undefined {
+  if (!system) return undefined;
+  if (typeof system === "string") return system;
+  return (system as any[])
+    .filter((b) => b.type === "text")
+    .map((b) => b.text)
+    .join("\n") || undefined;
+}
+
+function convertUserMessage(msg: AnthropicMessage): any[] {
+  if (typeof msg.content === "string") {
+    return [{ role: "user", content: msg.content, timestamp: Date.now() }];
+  }
+
+  const results: any[] = [];
+  const userParts: any[] = [];
+
+  for (const block of msg.content as AnthropicContentBlock[]) {
+    if (block.type === "text") {
+      userParts.push({ type: "text", text: (block as any).text });
+    } else if (block.type === "image") {
+      userParts.push({
+        type: "image",
+        mimeType: (block as any).source.media_type,
+        data: (block as any).source.data,
+      });
+    } else if (block.type === "tool_result") {
+      if (userParts.length > 0) {
+        results.push({
+          role: "user",
+          content: userParts.length === 1 && userParts[0].type === "text" ? userParts[0].text : [...userParts],
+          timestamp: Date.now(),
+        });
+        userParts.length = 0;
+      }
+      const toolBlock = block as any;
+      const toolContent = typeof toolBlock.content === "string"
+        ? toolBlock.content
+        : Array.isArray(toolBlock.content)
+          ? toolBlock.content.map((b: any) => b.text).join("")
+          : "";
+      results.push({
+        role: "toolResult",
+        toolCallId: toolBlock.tool_use_id,
+        toolName: "",
+        content: [{ type: "text", text: toolContent }],
+        isError: toolBlock.is_error || false,
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  if (userParts.length > 0) {
+    results.push({
+      role: "user",
+      content: userParts.length === 1 && userParts[0].type === "text" ? userParts[0].text : [...userParts],
+      timestamp: Date.now(),
+    });
+  }
+
+  if (results.length === 0) {
+    results.push({ role: "user", content: "", timestamp: Date.now() });
+  }
+
+  return results;
+}
+
+function convertAssistantMessage(msg: AnthropicMessage): any {
+  const content: any[] = [];
+  if (typeof msg.content === "string") {
+    if (msg.content) content.push({ type: "text", text: msg.content });
+  } else {
+    for (const block of msg.content as AnthropicContentBlock[]) {
+      if (block.type === "text") {
+        content.push({ type: "text", text: (block as any).text });
+      } else if (block.type === "tool_use") {
+        const tb = block as any;
+        content.push({
+          type: "toolCall",
+          id: tb.id,
+          name: tb.name,
+          arguments: tb.input,
+        });
+      }
+    }
+  }
+
+  return {
+    role: "assistant",
+    content,
+    api: "anthropic",
+    provider: "proxy",
+    model: "proxy",
+    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(),
+  };
+}

package/packages/server/src/model-proxy/convert/anthropic-out.ts

@@ -0,0 +1,173 @@
+/* Lifted from BlackBeltTechnology/pi-model-proxy@179d450, MIT licensed.
+ * See model-proxy/convert/UPSTREAM.md for divergences.
+ */
+
+/**
+ * Track content block indices for Anthropic SSE events.
+ */
+export class AnthropicBlockTracker {
+  private currentIndex = -1;
+
+  nextIndex(): number {
+    return ++this.currentIndex;
+  }
+
+  getCurrentIndex(): number {
+    return this.currentIndex;
+  }
+}
+
+/**
+ * Convert a pi-ai event to Anthropic SSE event strings.
+ */
+export function eventToAnthropicSSE(
+  event: any, // pi-ai AssistantMessageEvent
+  model: string,
+  msgId: string,
+  tracker: AnthropicBlockTracker,
+): string[] {
+  const chunks: string[] = [];
+
+  const makeSSE = (eventType: string, data: any) =>
+    `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+
+  switch (event.type) {
+    case "start":
+      chunks.push(makeSSE("message_start", {
+        type: "message_start",
+        message: {
+          id: msgId,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: 0, output_tokens: 0 },
+        },
+      }));
+      break;
+
+    case "text_delta": {
+      const idx = tracker.getCurrentIndex();
+      if (idx < 0) {
+        const newIdx = tracker.nextIndex();
+        chunks.push(makeSSE("content_block_start", {
+          type: "content_block_start",
+          index: newIdx,
+          content_block: { type: "text", text: "" },
+        }));
+      }
+      chunks.push(makeSSE("content_block_delta", {
+        type: "content_block_delta",
+        index: Math.max(0, tracker.getCurrentIndex()),
+        delta: { type: "text_delta", text: event.delta },
+      }));
+      break;
+    }
+
+    case "thinking_delta": {
+      const idx = tracker.getCurrentIndex();
+      if (idx < 0) {
+        const newIdx = tracker.nextIndex();
+        chunks.push(makeSSE("content_block_start", {
+          type: "content_block_start",
+          index: newIdx,
+          content_block: { type: "thinking", thinking: "" },
+        }));
+      }
+      chunks.push(makeSSE("content_block_delta", {
+        type: "content_block_delta",
+        index: Math.max(0, tracker.getCurrentIndex()),
+        delta: { type: "thinking_delta", thinking: event.delta },
+      }));
+      break;
+    }
+
+    case "toolcall_start": {
+      const tc = event.partial.content[event.contentIndex];
+      if (tracker.getCurrentIndex() >= 0) {
+        chunks.push(makeSSE("content_block_stop", {
+          type: "content_block_stop",
+          index: tracker.getCurrentIndex(),
+        }));
+      }
+      const newIdx = tracker.nextIndex();
+      chunks.push(makeSSE("content_block_start", {
+        type: "content_block_start",
+        index: newIdx,
+        content_block: { type: "tool_use", id: tc.id, name: tc.name, input: {} },
+      }));
+      break;
+    }
+
+    case "toolcall_delta":
+      chunks.push(makeSSE("content_block_delta", {
+        type: "content_block_delta",
+        index: tracker.getCurrentIndex(),
+        delta: { type: "input_json_delta", partial_json: event.delta },
+      }));
+      break;
+
+    case "done": {
+      const msg = event.message;
+      if (tracker.getCurrentIndex() >= 0) {
+        chunks.push(makeSSE("content_block_stop", {
+          type: "content_block_stop",
+          index: tracker.getCurrentIndex(),
+        }));
+      }
+      const stopReason = msg.stopReason === "toolUse" ? "tool_use"
+        : msg.stopReason === "length" ? "max_tokens"
+          : "end_turn";
+      chunks.push(makeSSE("message_delta", {
+        type: "message_delta",
+        delta: { stop_reason: stopReason, stop_sequence: null },
+        usage: { output_tokens: msg.usage.output },
+      }));
+      chunks.push(makeSSE("message_stop", { type: "message_stop" }));
+      break;
+    }
+
+    case "error":
+      chunks.push(makeSSE("error", {
+        type: "error",
+        error: { type: "api_error", message: event.error?.errorMessage || "Provider error" },
+      }));
+      break;
+  }
+
+  return chunks;
+}
+
+/**
+ * Convert a completed pi-ai AssistantMessage to a non-streaming Anthropic response.
+ */
+export function eventToAnthropicResponse(finalMsg: any, model: string, msgId: string): any {
+  const content: any[] = [];
+  for (const item of finalMsg.content) {
+    if (item.type === "text") {
+      content.push({ type: "text", text: item.text });
+    } else if (item.type === "toolCall") {
+      content.push({ type: "tool_use", id: item.id, name: item.name, input: item.arguments });
+    }
+  }
+
+  const stopReason = finalMsg.stopReason === "toolUse" ? "tool_use"
+    : finalMsg.stopReason === "length" ? "max_tokens"
+      : "end_turn";
+
+  return {
+    id: msgId,
+    type: "message",
+    role: "assistant",
+    content,
+    model,
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: finalMsg.usage.input,
+      output_tokens: finalMsg.usage.output,
+    },
+  };
+}

package/packages/server/src/model-proxy/convert/index.ts

@@ -0,0 +1,8 @@
+/* Lifted from BlackBeltTechnology/pi-model-proxy@179d450, MIT licensed.
+ * See model-proxy/convert/UPSTREAM.md for divergences.
+ */
+export { convertOpenAIMessages, convertOpenAITools } from "./openai-in.js";
+export { eventToSSEChunks, eventToNonStreamingResponse, ToolCallIndexTracker } from "./openai-out.js";
+export { convertAnthropicMessages, convertAnthropicTools } from "./anthropic-in.js";
+export { eventToAnthropicSSE, eventToAnthropicResponse, AnthropicBlockTracker } from "./anthropic-out.js";
+export type { OpenAIMessage, OpenAITool, AnthropicMessagesRequest, AnthropicTool } from "./types.js";

package/packages/server/src/model-proxy/convert/openai-in.ts

@@ -0,0 +1,119 @@
+/* Lifted from BlackBeltTechnology/pi-model-proxy@179d450, MIT licensed.
+ * See model-proxy/convert/UPSTREAM.md for divergences.
+ */
+import type { OpenAIMessage, OpenAIContentPart, OpenAITool } from "./types.js";
+
+/**
+ * Convert an array of OpenAI messages into a pi-ai Context
+ * (systemPrompt + messages array).
+ *
+ * Returns generic objects compatible with pi-ai's Message types.
+ */
+export function convertOpenAIMessages(openaiMessages: OpenAIMessage[]): { systemPrompt?: string; messages: any[] } {
+  let systemPrompt: string | undefined;
+  const messages: any[] = [];
+
+  for (const msg of openaiMessages) {
+    if (msg.role === "system") {
+      const text = extractText(msg.content);
+      systemPrompt = systemPrompt ? `${systemPrompt}\n${text}` : text;
+      continue;
+    }
+    if (msg.role === "user") {
+      messages.push(convertUserMessage(msg));
+      continue;
+    }
+    if (msg.role === "assistant") {
+      messages.push(convertAssistantMessage(msg));
+      continue;
+    }
+    if (msg.role === "tool") {
+      messages.push(convertToolResult(msg));
+      continue;
+    }
+  }
+
+  return { systemPrompt, messages };
+}
+
+export function convertOpenAITools(tools: OpenAITool[]): any[] {
+  return tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description || "",
+    parameters: t.function.parameters || { type: "object", properties: {} },
+  }));
+}
+
+function convertUserMessage(msg: OpenAIMessage): any {
+  return {
+    role: "user",
+    content: convertUserContent(msg.content),
+    timestamp: Date.now(),
+  };
+}
+
+function convertAssistantMessage(msg: OpenAIMessage): any {
+  const content: any[] = [];
+  if (msg.content) {
+    const text = extractText(msg.content);
+    if (text) content.push({ type: "text", text });
+  }
+  if (msg.tool_calls) {
+    for (const tc of msg.tool_calls) {
+      content.push({
+        type: "toolCall",
+        id: tc.id,
+        name: tc.function.name,
+        arguments: tryParseJSON(tc.function.arguments),
+      });
+    }
+  }
+  return {
+    role: "assistant",
+    content,
+    api: "openai-completions",
+    provider: "proxy",
+    model: "proxy",
+    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 convertToolResult(msg: OpenAIMessage): any {
+  return {
+    role: "toolResult",
+    toolCallId: msg.tool_call_id || "",
+    toolName: msg.name || "",
+    content: [{ type: "text", text: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) }],
+    isError: false,
+    timestamp: Date.now(),
+  };
+}
+
+function convertUserContent(content: string | OpenAIContentPart[] | null): string | any[] {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  const parts: any[] = [];
+  for (const part of content) {
+    if (part.type === "text" && part.text) {
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "image_url" && part.image_url?.url) {
+      const match = part.image_url.url.match(/^data:([^;]+);base64,(.+)$/);
+      if (match) {
+        parts.push({ type: "image", mimeType: match[1], data: match[2] });
+      }
+    }
+  }
+  return parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts;
+}
+
+function extractText(content: string | OpenAIContentPart[] | null): string {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text!).join("");
+}
+
+function tryParseJSON(s: string): Record<string, any> {
+  try { return JSON.parse(s); } catch { return {}; }
+}