@buyong/pi-devin 0.1.5 → 0.1.6

package/src/pi/adapters/pi/registration.ts

@@ -0,0 +1,89 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Effect, type Layer } from "effect";
+import { failWith } from "../../../core/validation.ts";
+import { ExtensionConfig } from "../../app/config.ts";
+import type { ExtensionEnvironment } from "../../app/layer.ts";
+import { makeExtensionRuntime, type ExtensionServices } from "../../app/runtime.ts";
+import { attachSession, shutdownProvider } from "../../app/session.ts";
+import { fusionOf } from "../../features/catalog/fusion.ts";
+import { ModelCatalog } from "../../features/catalog/service.ts";
+import { Runs } from "../../features/runs/service.ts";
+import { DEVIN_STATE_ENTRY } from "../../features/runs/state.ts";
+import { SIDEKICK_TOOL_NAME } from "../../features/sidekick/prompts.ts";
+import { Sidekicks } from "../../features/sidekick/service.ts";
+import { registerDevinCommand } from "./devin-command.ts";
+import { registerFusionCommand } from "./fusion-command.ts";
+import { makeDevinProvider } from "./provider.ts";
+import { PiSidekickHost, sidekickTool } from "./sidekick-tool.ts";
+import type { DevinExtension } from "./types.ts";
+import { UsageStatus } from "./usage-status.ts";
+
+/**
+ * Registers one extension instance: its runtime, the provider, and, for the lead, the sidekick tool, `/devin` and `/devin-fusion`.
+ * Pi's event handlers run their effects synchronously and return after the services finished, so the next event sees the result.
+ * A failed layer build throws here, before anything is registered.
+ */
+export function registerDevinExtension(pi: ExtensionAPI, environment: Layer.Layer<ExtensionEnvironment>): DevinExtension {
+  const runtime = makeExtensionRuntime(environment, PiSidekickHost(pi));
+  const run = <A, E>(effect: Effect.Effect<A, E, ExtensionServices>) => runtime.runSync(effect);
+  const { isFusionChild } = run(ExtensionConfig);
+  const isLead = !isFusionChild;
+  const provider = makeDevinProvider(runtime);
+  const catalog = run(ModelCatalog), runs = run(Runs), sidekicks = run(Sidekicks), status = run(UsageStatus);
+  pi.registerProvider(provider);
+  if (isLead) {
+    registerDevinCommand(pi, runtime);
+    pi.registerTool(sidekickTool(runtime));
+    registerFusionCommand(pi, runtime);
+  }
+  // Enables the sidekick only for the Fusion model and leaves other extensions' and the user's active tools alone.
+  const syncSidekick = (model: Model<any> | undefined) => {
+    if (!isLead) return;
+    const active = pi.getActiveTools(), isActive = active.includes(SIDEKICK_TOOL_NAME);
+    const shouldBeActive = fusionOf(run(catalog.models), model) !== undefined;
+    if (shouldBeActive && !isActive) pi.setActiveTools([...active, SIDEKICK_TOOL_NAME]);
+    else if (!shouldBeActive && isActive) pi.setActiveTools(active.filter((name) => name !== SIDEKICK_TOOL_NAME));
+  };
+  // Pi sets the new model before this event, so the status line follows it at once.
+  pi.on("model_select", (event, context) => {
+    syncSidekick(event.model);
+    run(status.update(context));
+  });
+  pi.on("input", (event) => { if (isLead) run(sidekicks.userInput(event.source)); });
+  pi.on("session_start", (_event, context) => {
+    if (context.modelRegistry.getRegisteredNativeProvider("devin") !== provider) {
+      run(shutdownProvider);
+      run(failWith("The Devin provider ID collides with another registration. Remove the duplicate extension and reload."));
+    }
+    run(attachSession({
+      getSessionId: () => context.sessionManager.getSessionId(),
+      getBranch: () => context.sessionManager.getBranch(),
+      append: (data) => pi.appendEntry(DEVIN_STATE_ENTRY, data),
+    }));
+    if (isLead) run(sidekicks.sessionStarted(context.sessionManager.getSessionId()));
+    syncSidekick(context.model);
+    run(Effect.andThen(status.bind(context), status.update(context)));
+  });
+  pi.on("message_end", (event, context) => {
+    if (event.message.role === "assistant" && event.message.provider === "devin") run(status.update(context, event.message));
+  });
+  // Subagents and other sessions record quota in the shared store; any model's turn picks it up.
+  pi.on("turn_end", (_event, context) => { run(status.update(context)); });
+  pi.on("before_agent_start", () => { run(runs.begin("agent")); });
+  pi.on("agent_start", () => { run(runs.agentStarted); });
+  // Host retry or overflow recovery can continue after agent_end.
+  pi.on("agent_settled", (_event, context) => { run(Effect.andThen(runs.finish, status.update(context))); });
+  pi.on("session_before_compact", (event) => { run(runs.beforeCompaction(event.reason)); });
+  pi.on("session_compact", (event) => { run(runs.afterCompaction(event.reason)); });
+  pi.on("session_compact_failed", (event) => { run(runs.afterCompaction(event.reason)); });
+  pi.on("session_before_tree", (event) => { if (event.preparation.userWantsSummary) run(runs.beforeTree); });
+  pi.on("session_tree", (_event, context) => { run(Effect.andThen(runs.treeChanged, status.update(context))); });
+  pi.on("cache_warming_decision", (_event, context) => context.model?.provider === "devin" ? { action: "stop" } : undefined);
+  pi.on("session_shutdown", () => {
+    run(status.bind(undefined));
+    if (isLead) run(sidekicks.reset);
+    run(shutdownProvider);
+  });
+  return { provider, runtime };
+}

package/src/pi/adapters/pi/response-stream.ts

@@ -0,0 +1,164 @@
+import { createAssistantMessageEventStream, type AssistantMessage, type Model, type ToolCall } from "@earendil-works/pi-ai";
+import { Effect, Predicate } from "effect";
+import type { DevinError } from "../../../core/errors.ts";
+import type { ChatAccumulator } from "../../../core/inference/accumulator.ts";
+import type { ChatMessage, ChatResult, JsonObject } from "../../../core/types.ts";
+import { failWith } from "../../../core/validation.ts";
+import { DEVIN_API } from "../../features/catalog/constants.ts";
+import type { DevinAPI } from "../../features/catalog/types.ts";
+import { attachReplayMetadata } from "./transcript.ts";
+
+const USAGE_FIELDS = ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"];
+
+/** Pi's event stream for one Devin response: one start, balanced content events and exactly one terminal event. */
+export class DevinResponseStream {
+  readonly stream = createAssistantMessageEventStream();
+  readonly message: AssistantMessage;
+  private active?: { type: "text" | "thinking"; index: number };
+  private readonly tools = new Map<string, { index: number; characters: number; hasEnded: boolean }>();
+  private hasTerminated = false;
+  private usageModelUid?: string;
+  private hasUsageReported = false;
+
+  constructor(model: Model<DevinAPI>, 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 });
+    }
+  }
+
+  /** Emits the content events of one frame the accumulator already accepted. */
+  accept(data: JsonObject, accumulator: ChatAccumulator): Effect.Effect<void, DevinError> {
+    return Effect.suspend(() => {
+      if (this.hasTerminated) return failWith("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 (Predicate.isString(data.deltaThinking) && data.deltaThinking) this.text("thinking", data.deltaThinking);
+      if (Predicate.isString(data.deltaText) && data.deltaText) this.text("text", data.deltaText);
+      for (const call of accumulator.calls.values()) this.toolDelta(call.id, call.name, call.argumentsJson);
+      if (accumulator.message.messageId) this.message.responseId = accumulator.message.messageId;
+      if (Predicate.isString(data.actualModelUid)) this.message.responseModel = data.actualModelUid;
+      if (Predicate.isObject(data.usage)) {
+        const usage = data.usage as JsonObject;
+        if (Predicate.isString(usage.modelUid)) this.usageModelUid = usage.modelUid;
+        if (USAGE_FIELDS.some((key) => usage[key] !== undefined)) this.hasUsageReported = true;
+      }
+      this.message.usage = { ...accumulator.usage, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+      return Effect.void;
+    });
+  }
+
+  private toolDelta(id: string, name: string, argumentsJson: string): void {
+    let state = this.tools.get(id);
+    if (!state) {
+      this.closeText();
+      const index = this.message.content.length;
+      this.message.content.push({ type: "toolCall", id, name: "", arguments: {} });
+      state = { index, characters: 0, hasEnded: false }; this.tools.set(id, state);
+      this.stream.push({ type: "toolcall_start", contentIndex: index, partial: this.message });
+    }
+    const block = this.message.content[state.index] as ToolCall;
+    block.name = name;
+    try {
+      const value = JSON.parse(argumentsJson) as unknown;
+      if (Predicate.isObject(value)) block.arguments = value as ToolCall["arguments"];
+    } catch { /* Partial arguments stay as the last complete object until the call ends. */ }
+    const delta = argumentsJson.slice(state.characters);
+    state.characters = argumentsJson.length;
+    if (delta) this.stream.push({ type: "toolcall_delta", contentIndex: state.index, delta, partial: this.message });
+  }
+
+  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,
+    } }];
+  }
+
+  /** The server redacted the response: everything shown so far is cleared and closed. */
+  get redact(): Effect.Effect<void> {
+    return Effect.sync(() => {
+      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): Effect.Effect<void> {
+    return Effect.sync(() => {
+      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);
+      // Pi runs no call whose arguments are invalid, reports the error to the model and lets it call again.
+      for (const [id, error] of Object.entries(result.toolArgumentErrors)) {
+        const state = this.tools.get(id);
+        if (!state) continue;
+        const block = this.message.content[state.index] as ToolCall;
+        block.arguments = {}; block.argumentsError = error;
+      }
+      this.closeContent();
+      this.hasTerminated = true;
+      this.message.rawStopReason = result.stopReason;
+      // At the output limit Pi runs none of the calls, since their arguments may be cut off, and asks the model to repeat them.
+      this.message.stopReason = result.stopReason === "STOP_REASON_MAX_TOKENS" ? "length" : result.message.toolCalls?.length ? "toolUse" : "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): Effect.Effect<void> {
+    return Effect.sync(() => {
+      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);
+    });
+  }
+}

package/src/pi/adapters/pi/sidekick-tool.ts

@@ -0,0 +1,45 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Effect, Layer, type ManagedRuntime } from "effect";
+import type { DevinError } from "../../../core/errors.ts";
+import { SIDEKICK_REPORT_MESSAGE, SIDEKICK_TOOL_NAME } from "../../features/sidekick/prompts.ts";
+import { SidekickHost, Sidekicks } from "../../features/sidekick/service.ts";
+
+/** The lead Pi as the sidekick sees it. */
+export const PiSidekickHost = (pi: ExtensionAPI) => Layer.succeed(SidekickHost, {
+  activeTools: Effect.sync(() => pi.getActiveTools()),
+  deliverReport: (report) => Effect.sync(() => {
+    pi.sendMessage({ customType: SIDEKICK_REPORT_MESSAGE, display: true, content: report.content, details: report.details }, { deliverAs: "followUp", triggerTurn: true });
+  }),
+});
+
+/**
+ * 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 sidekickTool(runtime: ManagedRuntime.ManagedRuntime<Sidekicks, DevinError>): ToolDefinition {
+  const sidekicks = runtime.runSync(Sidekicks);
+  return {
+    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",
+    execute: (_toolCallId, params, signal, onUpdate, ctx) => runtime.runPromise(sidekicks.handoff({
+      params, model: ctx.model, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), isSessionSaved: Boolean(ctx.sessionManager.getSessionFile()), signal,
+      onProgress: (text, details) => onUpdate?.({ content: [{ type: "text", text }], details }),
+    })),
+  };
+}

package/src/pi/adapters/pi/transcript.ts

@@ -0,0 +1,177 @@
+import { randomUUID } from "node:crypto";
+import { getCurrentSystemPrompt, getCurrentTools, type AssistantMessage, type TranscriptContext } from "@earendil-works/pi-ai";
+import { Effect, Predicate } from "effect";
+import { DevinError } from "../../../core/errors.ts";
+import { imageFromBase64, MAX_IMAGES_BYTES } from "../../../core/inference/images.ts";
+import type { ChatMessage, ChatTool, ModelInfo } from "../../../core/types.ts";
+import { failWith, object, requiredString } from "../../../core/validation.ts";
+import { DEVIN_API } from "../../features/catalog/constants.ts";
+
+const REPLAY_PREFIX = "devin:v1:";
+const replayStrings = ["signature", "signatureType", "geminiThoughtSignature", "outputId", "thinkingId", "phase", "modelUid"] as const;
+type ReplayMetadata = Pick<ChatMessage, typeof replayStrings[number] | "thinkingRedacted">;
+export interface DevinTranscript { messages: ChatMessage[]; tools: ChatTool[]; systemPrompt: string }
+
+export function encodeReplayMetadata(message: ChatMessage): string {
+  const metadata: ReplayMetadata = {};
+  for (const key of replayStrings) if (message[key] !== undefined) metadata[key] = message[key];
+  if (message.thinkingRedacted !== undefined) metadata.thinkingRedacted = message.thinkingRedacted;
+  return REPLAY_PREFIX + JSON.stringify(metadata);
+}
+
+function replayMetadata(value: string | undefined): Effect.Effect<ReplayMetadata | undefined, DevinError> {
+  if (!value?.startsWith(REPLAY_PREFIX)) return Effect.succeed(undefined);
+  return Effect.gen(function* () {
+    const parsed = yield* Effect.try({ try: () => JSON.parse(value.slice(REPLAY_PREFIX.length)) as unknown, catch: () => undefined }).pipe(
+      Effect.flatMap((json) => object(json, "Devin replay metadata")),
+      Effect.mapError(() => new DevinError({ message: "Invalid Devin response replay metadata." })),
+    );
+    const result: ReplayMetadata = {};
+    for (const key of replayStrings) {
+      const field = parsed[key];
+      if (field !== undefined && !Predicate.isString(field)) return yield* failWith("Unexpected Devin response replay metadata format.");
+      if (Predicate.isString(field)) result[key] = field;
+    }
+    if (parsed.thinkingRedacted !== undefined) {
+      if (!Predicate.isBoolean(parsed.thinkingRedacted)) return yield* failWith("Invalid Devin redacted thinking metadata.");
+      result.thinkingRedacted = parsed.thinkingRedacted;
+    }
+    return result;
+  });
+}
+
+/** Stores the native response metadata on every content block, so the next request can replay it exactly. */
+export function attachReplayMetadata(output: AssistantMessage, message: ChatMessage): void {
+  const signature = encodeReplayMetadata(message);
+  for (const block of output.content) {
+    if (block.type === "thinking") block.thinkingSignature = signature;
+    else if (block.type === "text") block.textSignature = signature;
+    else block.thoughtSignature = signature;
+  }
+}
+
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+const SCHEMA_MAPS = new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
+const SCHEMA_DATA = new Set(["enum", "const", "default", "examples", "example"]);
+
+/** Devin's own tools give every schema a single `type`; its Gemini route rejects a list such as `["integer", "null"]`. */
+function toDevinToolSchema(schema: unknown): unknown {
+  if (Array.isArray(schema)) return schema.map(toDevinToolSchema);
+  if (!schema || typeof schema !== "object") return schema;
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (SCHEMA_DATA.has(key)) result[key] = value;
+    else if (SCHEMA_MAPS.has(key) && Predicate.isObject(value)) {
+      result[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, toDevinToolSchema(child)]));
+    } else if (key === "type" && Array.isArray(value)) {
+      // Omitting the field still covers null; several remaining types become one branch each.
+      const types = value.filter((type) => type !== "null");
+      if (types.length === 1) result.type = types[0];
+      else if (types.length > 1 && !("anyOf" in schema)) result.anyOf = types.map((type) => ({ type }));
+      else result.type = value;
+    } else result[key] = toDevinToolSchema(value);
+  }
+  return result;
+}
+
+function toolDeclarations(context: TranscriptContext, model: ModelInfo): Effect.Effect<ChatTool[], DevinError> {
+  return Effect.gen(function* () {
+    const declarations = getCurrentTools(context.messages);
+    if (declarations.length && !model.supportsToolCalls) return yield* failWith("This model does not support the current Pi tool declarations.");
+    const tools: ChatTool[] = [];
+    for (const tool of declarations) {
+      // Grammar sampling is optional; like Pi's providers without grammar tools, send the JSON schema instead.
+      if (tool.constrainedSampling && tool.constrainedSampling.type === "json_schema" && tool.constrainedSampling.strict === "require") {
+        return yield* failWith(`Devin does not support this tool's forced sampling format: ${tool.name}`);
+      }
+      tools.push({ name: tool.name, description: tool.description, jsonSchemaString: JSON.stringify(toDevinToolSchema(tool.parameters)) });
+    }
+    return tools;
+  });
+}
+
+type ContextMessage = TranscriptContext["messages"][number];
+
+/** A successful assistant response with its own replay metadata, never a failed or unfinished one. */
+function assistantMessage(message: Extract<ContextMessage, { role: "assistant" }>): Effect.Effect<ChatMessage, DevinError> {
+  return Effect.gen(function* () {
+    const own = message.provider === "devin" && message.api === DEVIN_API;
+    const result: ChatMessage = { messageId: message.responseId ?? randomUUID(), source: "CHAT_MESSAGE_SOURCE_SYSTEM", prompt: "" };
+    let replay: ReplayMetadata | undefined;
+    for (const block of message.content) {
+      if (block.type === "text") result.prompt += block.text;
+      else if (block.type === "thinking") {
+        if (!block.redacted) result.thinking = (result.thinking ?? "") + block.thinking;
+        else result.thinkingRedacted = true;
+      } else {
+        result.toolCalls ??= [];
+        result.toolCalls.push({ id: yield* requiredString(block.id, "tool call id"), name: block.namespace ? `${block.namespace}.${block.name}` : block.name,
+          argumentsJson: JSON.stringify(yield* object(block.arguments, "tool arguments")) });
+      }
+      if (own) {
+        const metadata = yield* replayMetadata(block.type === "text" ? block.textSignature : block.type === "thinking" ? block.thinkingSignature : block.thoughtSignature);
+        if (metadata) {
+          if (replay && JSON.stringify(replay) !== JSON.stringify(metadata)) return yield* failWith("Devin replay metadata differs within one response.");
+          replay = metadata;
+        }
+      }
+    }
+    Object.assign(result, replay);
+    if (own && message.providerThinkingLevel) result.modelUid = message.providerThinkingLevel;
+    if (result.thinkingRedacted) result.thinking = "";
+    return result;
+  });
+}
+
+/** A user message or tool result with its images, within the per-message image budget. */
+function inputMessage(message: Exclude<ContextMessage, { role: "assistant" | "system" }>, model: ModelInfo): Effect.Effect<ChatMessage, DevinError> {
+  return Effect.gen(function* () {
+    const result: ChatMessage = {
+      messageId: randomUUID(), source: message.role === "toolResult" ? "CHAT_MESSAGE_SOURCE_TOOL" : "CHAT_MESSAGE_SOURCE_USER", prompt: "",
+      ...(message.role === "toolResult" ? { toolCallId: message.toolCallId, toolResultIsError: message.isError } : {}),
+    };
+    let imageBytes = 0, isAfterPlaceholder = false;
+    const content = typeof message.content === "string" ? [{ type: "text" as const, text: message.content }] : message.content;
+    for (const block of content) {
+      if (block.type === "text") {
+        result.prompt += block.text; isAfterPlaceholder = false;
+      } else if (!model.supportsImages) {
+        // Like Pi's own providers: a text-only model gets a note instead, so earlier images do not stop the conversation.
+        if (!isAfterPlaceholder) result.prompt += message.role === "toolResult" ? NON_VISION_TOOL_IMAGE_PLACEHOLDER : NON_VISION_USER_IMAGE_PLACEHOLDER;
+        isAfterPlaceholder = true;
+      } else {
+        const converted = yield* imageFromBase64(block.data, block.mimeType);
+        imageBytes += converted.sizeBytes;
+        if (imageBytes > MAX_IMAGES_BYTES) return yield* failWith(`Images in one message must total at most ${MAX_IMAGES_BYTES} bytes.`);
+        (result.images ??= []).push(converted.image);
+      }
+    }
+    return result;
+  });
+}
+
+/** Pi history as Devin chat messages. Failed or aborted assistants and the results of their tool calls are not replayed. */
+export function toDevinTranscript(context: TranscriptContext, model: ModelInfo): Effect.Effect<DevinTranscript, DevinError> {
+  return Effect.gen(function* () {
+    const tools = yield* toolDeclarations(context, model);
+    // Results follow their assistant, so only the calls of the latest failed assistant are skipped. A later failure that
+    // reuses an earlier call ID leaves the earlier result in place.
+    let failedCalls = new Set<string>();
+    const messages: ChatMessage[] = [];
+    for (const message of context.messages) {
+      if (message.role === "system") continue;
+      if (message.role === "assistant") {
+        const isFailed = message.stopReason === "error" || message.stopReason === "aborted";
+        failedCalls = new Set(isFailed ? message.content.filter((block) => block.type === "toolCall").map((block) => block.id) : []);
+        if (isFailed) continue;
+        if (message.stopReason === "pending") return yield* failWith("An unfinished assistant response cannot be sent as Devin history.");
+        messages.push(yield* assistantMessage(message));
+        continue;
+      }
+      if (message.role === "toolResult" && failedCalls.has(message.toolCallId)) continue;
+      messages.push(yield* inputMessage(message, model));
+    }
+    return { messages, tools, systemPrompt: getCurrentSystemPrompt(context.messages) };
+  });
+}

package/src/pi/adapters/pi/types.ts

@@ -0,0 +1,14 @@
+import type { Provider } from "@earendil-works/pi-ai";
+import type { ExtensionRuntime } from "../../app/runtime.ts";
+import type { DevinAPI } from "../../features/catalog/types.ts";
+
+/** Pi's provider contract, and nothing else: extension features reach the services through the runtime. */
+export interface DevinProvider extends Provider<DevinAPI> {
+  refreshModels: NonNullable<Provider<DevinAPI>["refreshModels"]>;
+}
+
+/** A registered extension instance: the provider Pi holds and the runtime its handlers run on. */
+export interface DevinExtension {
+  readonly provider: DevinProvider;
+  readonly runtime: ExtensionRuntime;
+}

package/src/pi/{devin-panel.ts → adapters/pi/ui/devin-panel.ts}

@@ -1,11 +1,13 @@
 import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import type { DevinPreferences } from "./devin-settings.ts";
+import { Cause, Effect, Exit } from "effect";
+import type { DevinError } from "../../../../core/errors.ts";
+import type { DevinPreferences } from "../../../features/settings/types.ts";
+import type { UsageLine } from "../../../features/usage/types.ts";
 import type { PickerTheme } from "./fusion-picker.ts";
-import type { UsageLine } from "./usage.ts";
 
 export const PREFERENCE_ITEMS: readonly { key: keyof DevinPreferences; label: string; detail: string }[] = [
   { key: "recommendedOnly", label: "Recommended models only", detail: "/model shows only models with a recommended variant and Devin Fusion" },
-  { key: "showUsageStatus", label: "Usage in status line", detail: "shows quota and session tokens in the footer" },
+  { key: "showUsageStatus", label: "Usage in status line", detail: "shows quota and session tokens in the footer while a Devin model is selected" },
 ];
 const HELP = "↑↓ move · space/↵ toggle · esc close";
 
@@ -14,7 +16,7 @@ export interface DevinPanelOptions {
   report: () => UsageLine[];
   preferences: DevinPreferences;
   /** Saves and applies on every toggle. On failure, shows a notice and reverts to the previous value. */
-  onChange: (next: DevinPreferences) => Promise<void>;
+  onChange: (next: DevinPreferences) => Effect.Effect<void, DevinError>;
   requestRender: () => void;
   done: () => void;
 }
@@ -48,14 +50,14 @@ export class DevinPanel {
     const key = PREFERENCE_ITEMS[this.cursor].key, previous = this.preferences;
     this.preferences = { ...previous, [key]: !previous[key] };
     this.isSaving = true; this.notice = undefined; this.changed();
-    try {
-      await this.options.onChange(this.preferences);
-    } catch (error) {
+    const exit = await Effect.runPromiseExit(this.options.onChange(this.preferences));
+    if (Exit.isFailure(exit)) {
       this.preferences = previous;
+      // A thrown host error is reported with its own message, like a failed save.
+      const error = Cause.squash(exit.cause);
       this.notice = `Could not save: ${error instanceof Error ? error.message : String(error)}`;
-    } finally {
-      this.isSaving = false; this.changed();
     }
+    this.isSaving = false; this.changed();
   }
 
   render(width: number): string[] {

package/src/pi/{fusion-picker.ts → adapters/pi/ui/fusion-picker.ts}

@@ -1,6 +1,6 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { decodeKittyPrintable, fuzzyFilter, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import type { FusionChoices, FusionSelection } from "./models.ts";
+import type { FusionChoices, FusionSelection } from "../../../features/catalog/types.ts";
 
 export type PickerTheme = Pick<Theme, "fg" | "bold">;
 interface Item { id: string; name: string; recommended?: true }

package/src/pi/adapters/pi/usage-status.ts

@@ -0,0 +1,65 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Context, Effect, Layer } from "effect";
+import { ExtensionConfig } from "../../app/config.ts";
+import { Accounts } from "../../features/accounts/service.ts";
+import { ModelCatalog } from "../../features/catalog/service.ts";
+import { DisplaySettings } from "../../features/settings/service.ts";
+import { UsageChanges } from "../../features/usage/changes.ts";
+import { sessionUsage, usageStatusText } from "../../features/usage/report.ts";
+import type { AccountsShape } from "../../features/accounts/types.ts";
+import type { ModelCatalogShape } from "../../features/catalog/types.ts";
+import type { AccountUsage } from "../../features/usage/types.ts";
+
+/** The only status key this package uses. */
+export const USAGE_STATUS_KEY = "devin-usage";
+
+export interface UsageStatusShape {
+  /** Newest quota for the credential of the last model refresh. Makes no request. */
+  readonly accountUsage: Effect.Effect<AccountUsage | undefined>;
+  /**
+   * Draws the status in the TUI only, while the session's current model is a Devin model, from the last account status and
+   * the session records. `pendingMessage` is a response Pi has not stored yet. Another provider's model or turning the toggle
+   * off clears only this package's key; `/devin` reports usage whatever the model.
+   */
+  readonly update: (context: ExtensionContext, pendingMessage?: unknown) => Effect.Effect<void>;
+  /** The session whose status line follows quota changes that happen outside event handlers. */
+  readonly bind: (context: ExtensionContext | undefined) => Effect.Effect<void>;
+}
+
+export class UsageStatus extends Context.Service<UsageStatus, UsageStatusShape>()("pi-devin/UsageStatus") {}
+
+/** Newest quota for the credential of the last model refresh: the account `/devin` and the status line show. Makes no request. */
+export const currentAccountUsage = (catalog: ModelCatalogShape, accounts: AccountsShape): Effect.Effect<AccountUsage | undefined> =>
+  Effect.flatMap(catalog.currentScope, (scope) => scope ? accounts.usage(scope) : Effect.succeed(undefined));
+
+/** Pi stores a message only after every `message_end` handler ran, so a just-finished response is counted explicitly. */
+function branchWith(context: ExtensionContext, pendingMessage: unknown): readonly unknown[] {
+  const branch = context.sessionManager.getBranch();
+  if (!pendingMessage || branch.some((entry) => entry.type === "message" && entry.message === pendingMessage)) return branch;
+  return [...branch, { type: "message", message: pendingMessage }];
+}
+
+export const UsageStatusLive = Layer.effect(UsageStatus, Effect.gen(function* () {
+  const config = yield* ExtensionConfig;
+  const settings = yield* DisplaySettings;
+  const accounts = yield* Accounts;
+  const catalog = yield* ModelCatalog;
+  const changes = yield* UsageChanges;
+  let bound: ExtensionContext | undefined;
+  const accountUsage = currentAccountUsage(catalog, accounts);
+  // The sidekick child shows no status line.
+  const update = (context: ExtensionContext, pendingMessage?: unknown) => config.isFusionChild ? Effect.void : Effect.gen(function* () {
+    if (context.mode !== "tui") return;
+    const isShown = context.model?.provider === "devin" && (yield* settings.read).showUsageStatus;
+    const text = isShown
+      ? usageStatusText(yield* accountUsage, sessionUsage(branchWith(context, pendingMessage)), (tone, segment) => context.ui.theme.fg(tone, segment)) : undefined;
+    context.ui.setStatus(USAGE_STATUS_KEY, text);
+  });
+  // The session may be replaced or reloaded meanwhile; its next session_start redraws.
+  yield* changes.subscribe(Effect.suspend(() => bound ? update(bound) : Effect.void));
+  return {
+    accountUsage,
+    update,
+    bind: (context) => Effect.sync(() => { bound = context; }),
+  } satisfies UsageStatusShape;
+}));