@buyong/pi-devin 0.1.5 → 0.1.6

package/src/pi/features/sidekick/types.ts

@@ -0,0 +1,99 @@
+import type { spawn } from "node:child_process";
+import type { Deferred, Effect } from "effect";
+import type { DevinError, DevinFailure } from "../../../core/errors.ts";
+
+export interface SidekickCommand { command: string; args: string[] }
+
+/** Launch settings of the sidekick child Pi. When they change, the process restarts before the next handoff. */
+export interface SidekickLaunch {
+  cwd: string;
+  /** Devin model ID of the exact variant (its catalog UID). */
+  modelID: string;
+  thinking?: string;
+  /** Without it, the child starts with `--no-session`. */
+  sessionFile?: string;
+  tools: readonly string[];
+  systemPrompt: string;
+}
+
+export interface HandoffProgress { toolCalls: number; recentTools: string[]; elapsedMs: number }
+export interface HandoffReport {
+  id: string;
+  status: "completed" | "aborted" | "error";
+  text: string;
+  toolCalls: number;
+  durationMs: number;
+  error?: string;
+}
+/** A handoff and its single report. A steer shares the running handoff's report. */
+export interface Handoff { id: string; done: Deferred.Deferred<HandoffReport>; isSteer: boolean }
+
+export interface BoundedReport {
+  text: string;
+  /** Private temporary file with the complete report, set only when the report was cut and the file was written. */
+  fullReportPath?: string;
+}
+
+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;
+}
+
+/** How a sidekick child Pi is started. */
+export interface SidekickLauncherShape {
+  /** Command that runs Pi. The default is the same Node and Pi CLI as the lead. */
+  readonly resolveCommand: Effect.Effect<SidekickCommand, DevinError>;
+  /**
+   * Starts the child. Node's spawner is used directly rather than Effect's: the child stays in the lead's process group,
+   * so terminal signals reach it, and a broken stdin is noticed while writing.
+   */
+  readonly spawn: typeof spawn;
+  readonly env: NodeJS.ProcessEnv;
+  /** Passed to the child with `-e`, so it loads the same extension copy as the lead. */
+  readonly packageRoot: string;
+}
+
+/** What the sidekick needs from the lead Pi. */
+export interface SidekickHostShape {
+  /** The lead's active tools. The child gets them without the sidekick tool itself. */
+  readonly activeTools: Effect.Effect<readonly string[]>;
+  /** Delivers a background report to the lead as a follow-up message that starts a turn. */
+  readonly deliverReport: (report: { content: string; details: SidekickDetails }) => Effect.Effect<void>;
+}
+
+/** One `devin_sidekick` call. */
+export interface HandoffRequest {
+  /** Tool parameters as Pi passed them. */
+  params: unknown;
+  /** The lead's model. Only the Devin Fusion model may hand off. */
+  model: { provider?: string; api?: string; id: string } | undefined;
+  cwd: string;
+  sessionId: string;
+  /** The lead session is saved to a file; the child then keeps its own session file. */
+  isSessionSaved: boolean;
+  signal: AbortSignal | undefined;
+  /** Progress while a blocking call waits for the report. */
+  onProgress?: (text: string, details: SidekickDetails) => void;
+}
+
+export interface HandoffResult { content: { type: "text"; text: string }[]; details: SidekickDetails }
+
+export interface SidekicksShape {
+  /**
+   * Starts or steers the session's handoff. By default waits for the report; with `block: false`, or when user input arrives
+   * while waiting, the report moves to the background and is delivered once.
+   */
+  readonly handoff: (request: HandoffRequest) => Effect.Effect<HandoffResult, DevinFailure>;
+  /** User input moves a waiting handoff to the background. Input sent by extensions does not count. */
+  readonly userInput: (source: string) => Effect.Effect<void>;
+  /** Stops the sidekicks of other lead sessions. */
+  readonly sessionStarted: (sessionId: string) => Effect.Effect<void>;
+  /** Stops every sidekick. */
+  readonly reset: Effect.Effect<void>;
+}

package/src/pi/features/usage/changes.ts

@@ -0,0 +1,20 @@
+import { Context, Effect, Layer } from "effect";
+import type { UsageChangesShape } from "./types.ts";
+
+/**
+ * Change notices for displays such as the status line. Owners of account records and the current credential publish;
+ * listeners run synchronously inside the publishing effect, so a redraw sees the state that caused it.
+ */
+export class UsageChanges extends Context.Service<UsageChanges, UsageChangesShape>()("pi-devin/UsageChanges") {}
+
+export const UsageChangesLive = Layer.sync(UsageChanges, () => {
+  const listeners = new Set<{ readonly listener: Effect.Effect<void> }>();
+  return {
+    // A display failure must not affect requests or refreshes.
+    publish: Effect.suspend(() => Effect.forEach([...listeners], (entry) => Effect.catchCause(entry.listener, () => Effect.void), { discard: true })),
+    subscribe: (listener) => Effect.asVoid(Effect.acquireRelease(
+      Effect.sync(() => { const entry = { listener }; listeners.add(entry); return entry; }),
+      (entry) => Effect.sync(() => { listeners.delete(entry); }),
+    )),
+  } satisfies UsageChangesShape;
+});

package/src/pi/{usage.ts → features/usage/report.ts}

@@ -1,31 +1,6 @@
-import type { JsonObject } from "../core/types.ts";
+import type { JsonObject } from "../../../core/types.ts";
+import type { AccountUsage, SessionUsage, UsageLine, UsagePainter, UsageTone } from "./types.ts";
 
-/** Quota from the account status (`GetUserStatus`). Values may have changed since it was fetched. */
-export interface AccountUsage {
-  billingStrategy?: string;
-  dailyRemainingPercent?: number;
-  weeklyRemainingPercent?: number;
-  dailyResetAtMs?: number;
-  weeklyResetAtMs?: number;
-  fetchedAtMs: number;
-}
-
-/** Totals of Devin assistant responses recorded in the current session branch. Sidekick child conversations are separate sessions and are not included. */
-export interface SessionUsage {
-  requests: number;
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-}
-
-export interface BudgetUsage { used: number; limit: number; isActive: boolean }
-
-/** Color level by remaining amount. Matches the Pi theme color names `success`, `warning` and `error`. */
-export type UsageTone = "success" | "warning" | "error";
-export interface UsageLine { text: string; isHeading?: boolean; tone?: UsageTone }
-/** Colors a segment. The default returns it uncolored. */
-export type UsagePainter = (tone: UsageTone, text: string) => string;
 const plain: UsagePainter = (_tone, text) => text;
 
 const QUOTA_STRATEGY = "BILLING_STRATEGY_QUOTA";
@@ -87,10 +62,6 @@ export function remainingTone(percent: number): UsageTone {
   return percent <= 20 ? "error" : percent <= 40 ? "warning" : "success";
 }
 
-function budgetTone(used: number, limit: number): UsageTone {
-  return used >= limit ? "error" : used / limit >= 0.75 ? "warning" : "success";
-}
-
 function hasQuota(account: AccountUsage | undefined): account is AccountUsage & { dailyRemainingPercent: number; weeklyRemainingPercent: number } {
   return account?.billingStrategy === QUOTA_STRATEGY && account.dailyRemainingPercent !== undefined && account.weeklyRemainingPercent !== undefined;
 }
@@ -127,7 +98,7 @@ export function relativeTime(targetMs: number, nowMs: number): string {
 }
 
 /** Details shown by `/devin`. Built only from the last account status and session records; sends no requests. */
-export function usageReport(account: AccountUsage | undefined, session: SessionUsage, budget: BudgetUsage, nowMs: number): UsageLine[] {
+export function usageReport(account: AccountUsage | undefined, session: SessionUsage, nowMs: number): UsageLine[] {
   const lines: UsageLine[] = [];
   if (!account) {
     lines.push({ text: "Account quota · not received yet", isHeading: true });
@@ -147,7 +118,5 @@ export function usageReport(account: AccountUsage | undefined, session: SessionU
   lines.push({ text: "This session · lead conversation (sidekick excluded)", isHeading: true });
   lines.push({ text: `  ${session.requests} ${session.requests === 1 ? "request" : "requests"} · input ${formatTokens(session.input)} · output ${formatTokens(session.output)}`
     + ` · cache read ${formatTokens(session.cacheRead)} · cache write ${formatTokens(session.cacheWrite)}` });
-  lines.push({ text: `Run budget · ${budget.isActive ? "in progress" : "last run"}`, isHeading: true });
-  lines.push({ text: `  ${progressBar((budget.used / budget.limit) * 100)} ${budget.used}/${budget.limit} model calls used`, tone: budgetTone(budget.used, budget.limit) });
   return lines;
 }

package/src/pi/features/usage/types.ts

@@ -0,0 +1,33 @@
+import type { Effect, Scope } from "effect";
+
+/** Quota from the account status (`GetUserStatus`). Values may have changed since it was fetched. */
+export interface AccountUsage {
+  billingStrategy?: string;
+  dailyRemainingPercent?: number;
+  weeklyRemainingPercent?: number;
+  dailyResetAtMs?: number;
+  weeklyResetAtMs?: number;
+  fetchedAtMs: number;
+}
+
+/** Totals of Devin assistant responses recorded in the current session branch. Sidekick child conversations are separate sessions and are not included. */
+export interface SessionUsage {
+  requests: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+/** Color level by remaining amount. Matches the Pi theme color names `success`, `warning` and `error`. */
+export type UsageTone = "success" | "warning" | "error";
+export interface UsageLine { text: string; isHeading?: boolean; tone?: UsageTone }
+/** Colors a segment. The default returns it uncolored. */
+export type UsagePainter = (tone: UsageTone, text: string) => string;
+
+export interface UsageChangesShape {
+  /** Tells every listener, in order, that the quota or the current credential may have changed. Listener failures never reach the caller. */
+  readonly publish: Effect.Effect<void>;
+  /** Listens until the scope closes. */
+  readonly subscribe: (listener: Effect.Effect<void>) => Effect.Effect<void, never, Scope.Scope>;
+}

package/src/core/inference/chat.ts

@@ -1,234 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { object, requiredString, tokenCount, type ChatMessage, type ChatResult, type ChatTool, type ImageData, type JsonObject, type ToolCall, type Usage } from "../types.ts";
-import type { ConnectClient } from "../protocol/transport.ts";
-import { CHAT_METHOD } from "../protocol/protobuf.ts";
-import { wireMessages } from "./messages.ts";
-
-export const DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant. Follow the user\'s request concisely.";
-
-export function userMessage(prompt: string, images: readonly ImageData[] = []): ChatMessage {
-  return {
-    messageId: randomUUID(), source: "CHAT_MESSAGE_SOURCE_USER", prompt,
-    ...(images.length ? { images: images.map((image) => ({ ...image })) } : {}),
-  };
-}
-
-export function chatRequest(options: {
-  metadata: JsonObject;
-  model: string;
-  messages: ChatMessage[];
-  systemPrompt: string;
-  maxTokens: number;
-  cascadeId: string;
-  trajectoryId: string;
-  executionId?: string;
-  clientSessionId?: string;
-  modelAssignmentJwt?: string;
-  stepIndex?: number;
-  isAuxiliary?: boolean;
-  isRecovery?: boolean;
-  includeContext?: boolean;
-  cwd?: string;
-  tools?: ChatTool[];
-}): JsonObject {
-  return {
-    metadata: options.metadata,
-    prompt: options.systemPrompt,
-    chatMessagePrompts: wireMessages(options.messages, { includeContext: options.includeContext, cwd: options.cwd }),
-    chatModelUid: options.model,
-    requestType: "CHAT_MESSAGE_REQUEST_TYPE_CASCADE",
-    configuration: {
-      maxTokens: options.maxTokens,
-      numCompletions: 1,
-      maxNewlines: 400,
-      temperature: 1,
-      topK: 40,
-      topP: Math.fround(0.95),
-    },
-    trajectoryReference: {
-      trajectoryId: options.trajectoryId,
-      trajectoryType: "CORTEX_TRAJECTORY_TYPE_CASCADE",
-      ...(!options.isAuxiliary && !options.isRecovery && options.messages.at(-1)?.source === "CHAT_MESSAGE_SOURCE_USER" ? { stepType: "CORTEX_STEP_TYPE_USER_INPUT" } : {}),
-      ...(options.stepIndex ? { stepIndex: options.stepIndex } : {}),
-    },
-    cascadeId: options.cascadeId,
-    plannerMode: "CONVERSATIONAL_PLANNER_MODE_DEFAULT",
-    ...(!options.isAuxiliary && options.executionId ? { executionId: options.executionId } : {}),
-    ...(options.clientSessionId ? { clientSessionId: options.clientSessionId } : {}),
-    ...(options.modelAssignmentJwt ? { modelAssignmentJwt: options.modelAssignmentJwt } : {}),
-    ...(options.tools?.length ? { tools: options.tools } : {}),
-  };
-}
-
-// Backends mark a finished turn differently: Anthropic text ends with MIN_LOG_PROB, Gemini tool calls with STOP_PATTERN,
-// and OpenAI sends no stop reason (UNSPECIFIED is the proto3 default, so it is not on the wire).
-const COMPLETE_STOP_REASONS = new Set(["STOP_REASON_STOP_PATTERN", "STOP_REASON_FUNCTION_CALL", "STOP_REASON_MIN_LOG_PROB", "STOP_REASON_UNSPECIFIED", ""]);
-
-/** Attaches argument deltas without an ID to the call that started with the first ID. Ambiguous parallel deltas are rejected. */
-export class ChatAccumulator {
-  readonly message: ChatMessage = { messageId: "", source: "CHAT_MESSAGE_SOURCE_SYSTEM", prompt: "" };
-  readonly usage: Usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 };
-  readonly calls = new Map<string, ToolCall>();
-  private currentCall?: ToolCall;
-  private hasEnded = false;
-  private startedAt = performance.now();
-  private firstDeltaMs?: number;
-  private stopReason = "";
-  private usageReported = false;
-  private frameCount = 0;
-  private stopFrameIndex?: number;
-  private lastUsageFrameIndex?: number;
-  private idlessToolDeltaCount = 0;
-  private actualModelUid?: string;
-  private usageModelUid?: string;
-
-  accept(data: JsonObject, isEnd = false): void {
-    if (this.hasEnded) throw new Error("Cannot accumulate a response after EndStream.");
-    this.frameCount++;
-    if (isEnd) {
-      if (data.error) throw new Error("An error EndStream cannot be treated as success.");
-      this.hasEnded = true;
-      return;
-    }
-    if (data.redact === true) throw new Error("The server redacted the response.");
-    if (typeof data.messageId === "string" && data.messageId) this.message.messageId = data.messageId;
-    if (data.thinkingRedacted === true) {
-      this.message.thinkingRedacted = true;
-      this.message.thinking = "";
-    }
-    if (typeof data.deltaText === "string") this.message.prompt += data.deltaText;
-    if (typeof data.deltaThinking === "string" && !this.message.thinkingRedacted) {
-      this.message.thinking = (this.message.thinking ?? "") + data.deltaThinking;
-    }
-    if (typeof data.deltaSignature === "string") this.message.signature = (this.message.signature ?? "") + data.deltaSignature;
-    for (const [source, target] of [
-      ["deltaSignatureType", "signatureType"], ["geminiThoughtSignature", "geminiThoughtSignature"],
-      ["outputId", "outputId"], ["thinkingId", "thinkingId"], ["phase", "phase"],
-    ] as const) {
-      if (typeof data[source] === "string") this.message[target] = data[source];
-    }
-    if (typeof data.actualModelUid === "string") this.actualModelUid = data.actualModelUid;
-    if (data.deltaToolCalls !== undefined) {
-      if (!Array.isArray(data.deltaToolCalls)) throw new Error("deltaToolCalls must be an array.");
-      for (const value of data.deltaToolCalls) {
-        const delta = object(value, "tool delta");
-        const id = typeof delta.id === "string" && delta.id ? delta.id : undefined;
-        if (id) {
-          let call = this.calls.get(id);
-          if (!call) {
-            call = { id, name: "", argumentsJson: "" };
-            this.calls.set(id, call);
-          }
-          this.currentCall = call;
-        } else {
-          this.idlessToolDeltaCount++;
-          if (data.deltaToolCalls.length !== 1 || !this.currentCall || this.calls.size > 1) {
-            throw new Error("Cannot attach a delta without a tool ID to a specific call.");
-          }
-        }
-        const call = this.currentCall!;
-        if (delta.isCustomToolCall) throw new Error("Grammar-based custom tools are not supported.");
-        if (delta.invalidJsonErr || delta.invalidJsonStr) throw new Error("The server reported a tool argument JSON error.");
-        if (typeof delta.name === "string") call.name += delta.name;
-        if (typeof delta.argumentsJson === "string") call.argumentsJson += delta.argumentsJson;
-      }
-    }
-    if (data.deltaText || data.deltaThinking || data.deltaToolCalls) {
-      this.firstDeltaMs ??= performance.now() - this.startedAt;
-    }
-    if (typeof data.stopReason === "string" && data.stopReason) {
-      this.stopReason = data.stopReason;
-      this.stopFrameIndex = this.frameCount;
-    }
-    if (data.usage !== undefined) {
-      const usage = object(data.usage, "usage");
-      if (typeof usage.modelUid === "string") this.usageModelUid = usage.modelUid;
-      for (const [source, target] of [
-        ["inputTokens", "input"], ["outputTokens", "output"],
-        ["cacheReadTokens", "cacheRead"], ["cacheWriteTokens", "cacheWrite"],
-      ] as const) {
-        if (usage[source] !== undefined) {
-          this.usage[target] = tokenCount(usage[source], source);
-          this.usageReported = true;
-          this.lastUsageFrameIndex = this.frameCount;
-        }
-      }
-      this.usage.totalTokens = this.usage.input + this.usage.output + this.usage.cacheRead + this.usage.cacheWrite;
-    }
-  }
-
-  finish(): ChatResult {
-    if (!this.hasEnded) throw new Error("No successful EndStream.");
-    if (!COMPLETE_STOP_REASONS.has(this.stopReason) && this.stopReason !== "STOP_REASON_MAX_TOKENS") {
-      throw new Error(`stopReason cannot be treated as success: ${this.stopReason || "(none)"}`);
-    }
-    if (this.calls.size > 0) {
-      this.message.toolCalls = [...this.calls.values()];
-      for (const call of this.message.toolCalls) {
-        requiredString(call.name, "tool name");
-        let args: unknown;
-        try { args = JSON.parse(call.argumentsJson); }
-        catch { throw new Error(`Arguments of tool ${call.name} are not valid JSON.`); }
-        object(args, "tool arguments");
-      }
-    }
-    if (this.stopReason === "STOP_REASON_FUNCTION_CALL" && !this.calls.size) {
-      throw new Error("The response ended with FUNCTION_CALL but has no tool call.");
-    }
-    // Tool use is read from the calls themselves; only calls cut off at the output limit are rejected.
-    if (this.calls.size && !COMPLETE_STOP_REASONS.has(this.stopReason)) {
-      throw new Error("Tool calls and the stop reason do not match.");
-    }
-    this.message.messageId ||= randomUUID();
-    return {
-      message: this.message,
-      stopReason: this.stopReason,
-      usage: this.usage,
-      usageReported: this.usageReported,
-      frameCount: this.frameCount,
-      stopFrameIndex: this.stopFrameIndex,
-      lastUsageFrameIndex: this.lastUsageFrameIndex,
-      idlessToolDeltaCount: this.idlessToolDeltaCount,
-      durationMs: Math.round(performance.now() - this.startedAt),
-      firstDeltaMs: this.firstDeltaMs === undefined ? undefined : Math.round(this.firstDeltaMs),
-      actualModelUid: this.actualModelUid,
-      ...(this.usageModelUid ? { usageModelUid: this.usageModelUid } : {}),
-    };
-  }
-}
-
-export async function streamChat(
-  client: ConnectClient,
-  request: JsonObject,
-  options: { signal?: AbortSignal; onText?: (delta: string) => void; stage?: string; onDispatched?: () => void } = {},
-): Promise<ChatResult> {
-  const accumulator = new ChatAccumulator();
-  for await (const frame of client.stream(CHAT_METHOD, request, options.signal, { stage: options.stage, onDispatched: options.onDispatched })) {
-    accumulator.accept(frame.data, frame.isEnd);
-    if (!frame.isEnd && typeof frame.data.deltaText === "string") options.onText?.(frame.data.deltaText);
-  }
-  const result = accumulator.finish();
-  // Field 22 records the model of the generation request, not actualModelUid/usage.modelUid.
-  if (typeof request.chatModelUid === "string") result.message.modelUid = request.chatModelUid;
-  return result;
-}
-
-/** Raw thinking and signatures never go to logs or reports. They are only resent inside requests. */
-export function summarizeChat(result: ChatResult): JsonObject {
-  return {
-    text: result.message.prompt,
-    stopReason: result.stopReason,
-    usage: result.usage,
-    usageReported: result.usageReported,
-    toolCalls: result.message.toolCalls ?? [],
-    thinkingChars: result.message.thinking?.length ?? 0,
-    hasSignature: Boolean(result.message.signature || result.message.geminiThoughtSignature),
-    frameCount: result.frameCount,
-    stopFrameIndex: result.stopFrameIndex,
-    lastUsageFrameIndex: result.lastUsageFrameIndex,
-    idlessToolDeltaCount: result.idlessToolDeltaCount,
-    durationMs: result.durationMs,
-    firstDeltaMs: result.firstDeltaMs,
-    actualModelUid: result.actualModelUid,
-  };
-}