@buyong/pi-devin 0.1.4 → 0.1.6

package/src/pi/sidekick.ts

@@ -1,211 +0,0 @@
-import { join } from "node:path";
-import type { Model } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { DEVIN_API, type DevinModel } from "./models.ts";
-import type { DevinProvider } from "./provider.ts";
-import { boundReport, type BoundedReport } from "./sidekick-report.ts";
-import { SidekickRuntime, type Handoff, type HandoffReport, type SidekickLaunch, type SidekickRuntimeOptions } from "./sidekick-runtime.ts";
-
-export const SIDEKICK_TOOL_NAME = "devin_sidekick";
-/** Marker set on the child Pi started as the sidekick. The child's extension does not register Fusion again. */
-export const FUSION_CHILD_ENV = "PI_DEVIN_FUSION_CHILD";
-/** Custom message type that delivers a background handoff report to the lead. */
-export const SIDEKICK_REPORT_MESSAGE = "devin-sidekick-report";
-/** Appended by the provider to Fusion lead requests only, so a custom system prompt cannot drop it. */
-export const FUSION_LEAD_GUIDANCE = [
-  `Fusion mode: you are the lead. Plan, talk to the user, and decide; delegate hands-on exploration, implementation, and verification to the \`${SIDEKICK_TOOL_NAME}\` tool with clear context and done criteria.`,
-  `The sidekick is a separate agent in this workspace with the same tools, and it keeps its context across handoffs. \`${SIDEKICK_TOOL_NAME}\` waits for the report by default; pass \`block: false\` to keep working while it runs, and its report arrives later as a message. Calling \`${SIDEKICK_TOOL_NAME}\` while it is busy adds instructions to the running handoff.`,
-  "Review its report critically, decide the next step, and do not redo work it already reported. Present the combined result as your own work.",
-].join("\n");
-const SYSTEM_PROMPT = [
-  "You are the sidekick: a hands-on software engineer paired with a lead agent in the same workspace.",
-  "The lead sends you briefs with context and done criteria and may add instructions while you work. Do the work with the available tools: explore, implement, and verify.",
-  "You cannot talk to the user. When you finish, reply without tool calls with a concise report: what you did, how you verified it, and anything unresolved or risky.",
-  "Your conversation persists across briefs from the same lead session, so build on what you already know.",
-].join("\n");
-
-export interface SidekickDetails {
-  sidekickModel: string;
-  handoffId: string;
-  status: HandoffReport["status"] | "running" | "background";
-  toolCalls: number;
-  durationMs?: number;
-  isSteer: boolean;
-  /** Complete report saved when the text the lead received was cut. */
-  fullReportPath?: string;
-}
-
-export interface SidekickToolOptions {
-  /** Pi agent directory that holds sidekick session files. */
-  agentDir: () => string;
-  /** Lets tests replace how the child is started. */
-  runtime?: Omit<SidekickRuntimeOptions, "childEnv" | "onProgress">;
-}
-
-/** The host may copy model objects in its settings layer, so Fusion data is looked up by id in the provider's current list. */
-export function fusionOf(provider: Pick<DevinProvider, "getModels">, model: Model<any> | undefined): NonNullable<DevinModel["devin"]["fusion"]> | undefined {
-  if (model?.provider !== "devin" || model.api !== DEVIN_API) return undefined;
-  return (provider.getModels() as readonly DevinModel[]).find((candidate) => candidate.id === model.id)?.devin.fusion;
-}
-
-const launchKey = (launch: SidekickLaunch) => JSON.stringify([launch.cwd, launch.modelID, launch.thinking, launch.sessionFile, launch.tools]);
-const shortID = (id: string) => id.slice(0, 8);
-
-/** Bound and preserve the complete report, including status, errors and any background delivery heading. */
-async function reportText(report: HandoffReport, heading = ""): Promise<BoundedReport> {
-  const body = report.text.trim();
-  const reason = report.error ?? (report.status === "aborted" ? "cancelled." : "failed.");
-  const text = report.status === "completed" ? body || "(The sidekick finished without a report.)"
-    : [`The sidekick task ${report.status === "aborted" ? "stopped" : "failed"}: ${reason}`, body].filter(Boolean).join("\n\n");
-  return boundReport(heading + text);
-}
-
-interface ReportDelivery {
-  owner: "background" | "blocking" | "delivered";
-  scheduled: boolean;
-}
-
-const reportPath = (fullReportPath: string | undefined) => fullReportPath ? { fullReportPath } : {};
-
-/**
- * The lead's `devin_sidekick` tool. The sidekick runs as one child Pi process per lead session and uses the lead's active tools.
- * By default it waits for the report; with `block: false`, or when a user message arrives while waiting, it moves to the background and delivers the report once.
- */
-export function createSidekickTool(pi: ExtensionAPI, provider: DevinProvider, options: SidekickToolOptions) {
-  const runtimes = new Map<string, SidekickRuntime>();
-  // Steers share the same done promise; completed handoffs must not be retained by delivery bookkeeping.
-  const deliveries = new WeakMap<Promise<HandoffReport>, ReportDelivery>();
-  const waits = new Set<() => void>();
-  let progressListener: (() => void) | undefined;
-
-  const deliverLater = (handoff: Handoff, runtime: SidekickRuntime, delivery: ReportDelivery) => {
-    if (delivery.scheduled || delivery.owner === "delivered") return;
-    delivery.scheduled = true;
-    void handoff.done.then(async (report) => {
-      try {
-        // A blocking call owns the report unless user input moves it back to the background.
-        const canDeliver = () => delivery.owner === "background" && [...runtimes.values()].includes(runtime);
-        if (report.status === "aborted" || !canDeliver()) return;
-        const { text, fullReportPath } = await reportText(report, `Sidekick report for background handoff ${shortID(report.id)}:\n\n`);
-        if (!canDeliver()) return;
-        delivery.owner = "delivered";
-        pi.sendMessage({
-          customType: SIDEKICK_REPORT_MESSAGE, display: true, content: text,
-          details: { sidekickModel: runtime.launch.modelID, handoffId: report.id, status: report.status, toolCalls: report.toolCalls, durationMs: report.durationMs, isSteer: false,
-            ...reportPath(fullReportPath) } satisfies SidekickDetails,
-        }, { deliverAs: "followUp", triggerTurn: true });
-      } finally { delivery.scheduled = false; }
-    });
-  };
-
-  const definition: ToolDefinition = {
-    name: SIDEKICK_TOOL_NAME,
-    label: "Sidekick",
-    description: "Delegate hands-on work to your persistent sidekick, a separate coding agent that shares this workspace and your tools. "
-      + "Put the task context and done criteria in `message`. By default the call waits and returns the sidekick's report; "
-      + "set `block` to false to continue while it works, and the report arrives later as a message. "
-      + "Calling it while the sidekick is busy adds instructions to the running handoff.",
-    promptSnippet: "Delegate hands-on work to a persistent sidekick agent and get its report",
-    parameters: {
-      type: "object",
-      properties: {
-        message: { type: "string", description: "Brief for the sidekick: context, the task, and done criteria." },
-        block: { type: "boolean", description: "Wait for the report (default true). Use false to keep working while the sidekick runs." },
-      },
-      required: ["message"],
-      additionalProperties: false,
-    } as unknown as ToolDefinition["parameters"],
-    defaultActive: false,
-    executionMode: "sequential",
-    async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      signal?.throwIfAborted();
-      const fusion = fusionOf(provider, ctx.model);
-      if (!fusion) throw new Error("The sidekick is only available with the Devin Fusion model.");
-      const input = params as { message?: unknown; block?: unknown } | undefined;
-      const message = typeof input?.message === "string" ? input.message.trim() : "";
-      if (!message) throw new Error("A message for the sidekick is required.");
-      // The lead list hides exact UIDs covered by groups, so the level comes from the Fusion candidates.
-      const sidekickChoice = provider.getFusionChoices()?.sidekicks.find((item) => item.id === fusion.sidekickID);
-      if (!sidekickChoice) throw new Error("The sidekick model is not in the current Devin model list. Refresh the model list.");
-      const sessionId = ctx.sessionManager.getSessionId();
-      const launch: SidekickLaunch = {
-        cwd: ctx.cwd, modelID: fusion.sidekickID, thinking: sidekickChoice.level,
-        sessionFile: ctx.sessionManager.getSessionFile() ? join(options.agentDir(), "pi-devin", "sidekick", `${sessionId}.jsonl`) : undefined,
-        tools: pi.getActiveTools().filter((name) => name !== SIDEKICK_TOOL_NAME),
-        systemPrompt: SYSTEM_PROMPT,
-      };
-      let runtime = runtimes.get(sessionId);
-      // When the pair or tools change, only an idle process is restarted. Context continues through the same session file.
-      if (runtime && !runtime.isBusy() && launchKey(runtime.launch) !== launchKey(launch)) { runtime.close(); runtime = undefined; }
-      if (!runtime) {
-        runtime = new SidekickRuntime(launch, { ...options.runtime, childEnv: { [FUSION_CHILD_ENV]: "1" }, onProgress: () => progressListener?.() });
-        runtimes.set(sessionId, runtime);
-      }
-      signal?.throwIfAborted();
-      const handoff = runtime.handoff(message);
-      let delivery = deliveries.get(handoff.done);
-      if (!delivery) {
-        delivery = { owner: "background", scheduled: false };
-        deliveries.set(handoff.done, delivery);
-      }
-      const details = (status: SidekickDetails["status"], report?: HandoffReport): SidekickDetails => ({
-        sidekickModel: launch.modelID, handoffId: handoff.id, status, toolCalls: report?.toolCalls ?? runtime!.progress()?.toolCalls ?? 0,
-        ...(report ? { durationMs: report.durationMs } : {}), isSteer: handoff.isSteer,
-      });
-      const backgroundResult = (reason: string) => {
-        deliverLater(handoff, runtime!, delivery);
-        return { content: [{ type: "text" as const, text: `${reason} The report will arrive as a message. (handoff ${shortID(handoff.id)})` }], details: details("background") };
-      };
-      if (input?.block === false) {
-        return backgroundResult(handoff.isSteer ? "Added instructions to the running sidekick task." : "The sidekick started working in the background.");
-      }
-      delivery.owner = "blocking";
-      let settle!: (outcome: "done" | "aborted" | "interrupted") => void;
-      const waiting = new Promise<"done" | "aborted" | "interrupted">((resolve) => { settle = resolve; });
-      const interrupt = () => settle("interrupted"), abort = () => settle("aborted");
-      waits.add(interrupt);
-      signal?.addEventListener("abort", abort, { once: true });
-      progressListener = () => {
-        const progress = runtime!.progress();
-        if (progress) onUpdate?.({ content: [{ type: "text", text: `sidekick: ${progress.toolCalls} tool calls${progress.recentTools.length ? ` · ${progress.recentTools.join(", ")}` : ""}` }], details: details("running") });
-      };
-      if (signal?.aborted) abort();
-      void handoff.done.then(() => settle("done"));
-      const outcome = await waiting.finally(() => {
-        progressListener = undefined;
-        waits.delete(interrupt);
-        signal?.removeEventListener("abort", abort);
-      });
-      if (outcome === "interrupted") {
-        delivery.owner = "background";
-        return backgroundResult("A user message arrived, so the sidekick task moved to the background.");
-      }
-      delivery.owner = "delivered";
-      if (outcome === "aborted") {
-        runtime.abort();
-        throw new Error("Cancelled the sidekick task.");
-      }
-      const report = await handoff.done;
-      const { text, fullReportPath } = await reportText(report);
-      if (report.status !== "completed") throw new Error(text);
-      return { content: [{ type: "text" as const, text }], details: { ...details(report.status, report), ...reportPath(fullReportPath) } };
-    },
-  };
-
-  return {
-    definition,
-    /** On user input, a waiting handoff moves to the background. Input sent by extensions does not count. */
-    onInput(source: string): void {
-      if (source === "extension") return;
-      for (const interrupt of [...waits]) interrupt();
-    },
-    /** Cleans up the sidekick of a different lead session. */
-    onSessionStart(sessionId: string): void {
-      for (const [id, runtime] of runtimes) if (id !== sessionId) { runtime.close(); runtimes.delete(id); }
-    },
-    reset(): void {
-      for (const runtime of runtimes.values()) runtime.close();
-      runtimes.clear();
-    },
-  };
-}

package/src/pi/stream.ts

@@ -1,124 +0,0 @@
-import { createAssistantMessageEventStream, type AssistantMessage, type Model, type ToolCall } from "@earendil-works/pi-ai";
-import type { ChatAccumulator } from "../core/inference/chat.ts";
-import type { ChatMessage, ChatResult, JsonObject } from "../core/types.ts";
-import { attachReplayMetadata } from "./messages.ts";
-import { DEVIN_API } from "./models.ts";
-
-export class DevinResponseStream {
-  readonly stream = createAssistantMessageEventStream();
-  readonly message: AssistantMessage;
-  private active?: { type: "text" | "thinking"; index: number };
-  private tools = new Map<string, { index: number; characters: number; hasEnded: boolean }>();
-  private hasTerminated = false;
-  private usageModelUid?: string;
-  private hasUsageReported = false;
-  constructor(model: Model<typeof DEVIN_API>, requestedUID: string) {
-    this.message = {
-      role: "assistant", api: DEVIN_API, provider: "devin", model: model.id, providerThinkingLevel: requestedUID,
-      content: [], stopReason: "pending", timestamp: Date.now(),
-      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-    };
-    this.stream.push({ type: "start", partial: this.message });
-  }
-  private closeText(): void {
-    if (!this.active) return;
-    const block = this.message.content[this.active.index];
-    if (block.type === "text") this.stream.push({ type: "text_end", contentIndex: this.active.index, content: block.text, partial: this.message });
-    else if (block.type === "thinking") this.stream.push({ type: "thinking_end", contentIndex: this.active.index, content: block.thinking, partial: this.message });
-    this.active = undefined;
-  }
-  private text(type: "text" | "thinking", delta: string, redacted = false): void {
-    if (!this.active || this.active.type !== type) {
-      this.closeText();
-      const index = this.message.content.length;
-      this.message.content.push(type === "text" ? { type, text: "" } : { type, thinking: "", ...(redacted ? { redacted: true } : {}) });
-      this.active = { type, index };
-      this.stream.push({ type: type === "text" ? "text_start" : "thinking_start", contentIndex: index, partial: this.message });
-    }
-    const block = this.message.content[this.active.index];
-    if (!delta) return;
-    if (block.type === "text") {
-      block.text += delta;
-      this.stream.push({ type: "text_delta", contentIndex: this.active.index, delta, partial: this.message });
-    } else if (block.type === "thinking") {
-      block.thinking += delta;
-      this.stream.push({ type: "thinking_delta", contentIndex: this.active.index, delta, partial: this.message });
-    }
-  }
-  accept(data: JsonObject, accumulator: ChatAccumulator): void {
-    if (this.hasTerminated) throw new Error("Cannot add a delta to a finished Pi response.");
-    if (accumulator.message.thinkingRedacted) {
-      for (const block of this.message.content) if (block.type === "thinking") { block.thinking = ""; block.redacted = true; }
-      if (!this.message.content.some((block) => block.type === "thinking")) this.text("thinking", "", true);
-    } else if (typeof data.deltaThinking === "string" && data.deltaThinking) this.text("thinking", data.deltaThinking);
-    if (typeof data.deltaText === "string" && data.deltaText) this.text("text", data.deltaText);
-    for (const call of accumulator.calls.values()) {
-      let state = this.tools.get(call.id);
-      if (!state) {
-        this.closeText();
-        const index = this.message.content.length;
-        this.message.content.push({ type: "toolCall", id: call.id, name: "", arguments: {} });
-        state = { index, characters: 0, hasEnded: false }; this.tools.set(call.id, state);
-        this.stream.push({ type: "toolcall_start", contentIndex: index, partial: this.message });
-      }
-      const block = this.message.content[state.index] as ToolCall;
-      block.name = call.name;
-      try { const value = JSON.parse(call.argumentsJson); if (value && typeof value === "object" && !Array.isArray(value)) block.arguments = value; } catch {}
-      const delta = call.argumentsJson.slice(state.characters);
-      state.characters = call.argumentsJson.length;
-      if (delta) this.stream.push({ type: "toolcall_delta", contentIndex: state.index, delta, partial: this.message });
-    }
-    if (accumulator.message.messageId) this.message.responseId = accumulator.message.messageId;
-    if (typeof data.actualModelUid === "string") this.message.responseModel = data.actualModelUid;
-    if (data.usage && typeof data.usage === "object") {
-      const usage = data.usage as JsonObject;
-      if (typeof usage.modelUid === "string") this.usageModelUid = usage.modelUid;
-      if (["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"].some((key) => usage[key] !== undefined)) this.hasUsageReported = true;
-    }
-    this.message.usage = { ...accumulator.usage, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
-  }
-  private closeContent(): void {
-    this.closeText();
-    for (const state of this.tools.values()) if (!state.hasEnded) {
-      state.hasEnded = true;
-      this.stream.push({ type: "toolcall_end", contentIndex: state.index, toolCall: this.message.content[state.index] as ToolCall, partial: this.message });
-    }
-  }
-  private provenance(native: ChatMessage, usageReported: boolean): void {
-    this.message.providerThinkingLevel = native.modelUid ?? this.message.providerThinkingLevel;
-    attachReplayMetadata(this.message, native);
-    this.message.diagnostics = [{ type: "devin_provenance", timestamp: Date.now(), details: {
-      requestedUID: this.message.providerThinkingLevel ?? "", ...(this.message.responseModel ? { responseUID: this.message.responseModel } : {}),
-      ...(this.usageModelUid ? { usageUID: this.usageModelUid } : {}), costsUnknown: true, usageReported,
-    } }];
-  }
-  redact(): void {
-    for (const block of this.message.content) {
-      if (block.type === "text") block.text = "";
-      else if (block.type === "thinking") { block.thinking = ""; block.redacted = true; }
-      else block.arguments = {};
-    }
-    this.closeContent(); this.message.content = []; this.tools.clear();
-  }
-  finish(result: ChatResult): void {
-    if (this.hasTerminated) return;
-    if (!this.message.content.length && (result.message.signature || result.message.geminiThoughtSignature || result.message.outputId)) this.text("text", "");
-    this.provenance(result.message, result.usageReported);
-    this.closeContent();
-    this.hasTerminated = true;
-    this.message.rawStopReason = result.stopReason;
-    this.message.stopReason = result.message.toolCalls?.length ? "toolUse" : result.stopReason === "STOP_REASON_MAX_TOKENS" ? "length" : "stop";
-    this.stream.push({ type: "done", reason: this.message.stopReason, message: this.message });
-    this.stream.end(this.message);
-  }
-  fail(errorMessage: string, isAborted: boolean, native?: ChatMessage): void {
-    if (this.hasTerminated) return;
-    if (native) this.provenance(native, this.hasUsageReported);
-    this.closeContent();
-    this.hasTerminated = true;
-    this.message.stopReason = isAborted ? "aborted" : "error";
-    this.message.errorMessage = errorMessage;
-    this.stream.push({ type: "error", reason: this.message.stopReason, error: this.message });
-    this.stream.end(this.message);
-  }
-}