@buyong/pi-devin 0.1.4 → 0.1.6

package/src/core/services/http-transport.ts

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer, type Scope } from "effect";
+import type { HttpClient } from "effect/http";
+import { makeFetchHttpClient } from "../protocol/http/fetch-client.ts";
+import { makeNodeHttpClient, type HTTPTransportOptions } from "../protocol/http/node-client.ts";
+
+export interface HttpTransportShape {
+  /**
+   * An `HttpClient` for the calling scope. The built-in transport opens its own keep-alive pool and destroys it with the scope,
+   * so clients never share connections and closing one never drops another's.
+   */
+  readonly open: Effect.Effect<HttpClient.HttpClient, never, Scope.Scope>;
+}
+
+/** How Devin clients and logins reach the network. */
+export class HttpTransport extends Context.Service<HttpTransport, HttpTransportShape>()("pi-devin/HttpTransport") {}
+
+/** Node's `http`/`https`: TLS 1.2 or later with certificate and host checks, HTTP/1.1 only, and a pool per opening scope. */
+export function nodeTransport(options: HTTPTransportOptions = {}): HttpTransportShape {
+  return { open: makeNodeHttpClient(options) };
+}
+
+/** An injected `fetch`, such as the one Pi passes in stream options. */
+export function fetchTransport(fetchImpl: typeof fetch): HttpTransportShape {
+  return { open: Effect.sync(() => makeFetchHttpClient(fetchImpl)) };
+}
+
+export const NodeHttpTransport = (options?: HTTPTransportOptions): Layer.Layer<HttpTransport> => Layer.succeed(HttpTransport, nodeTransport(options));
+export const FetchHttpTransport = (fetchImpl: typeof fetch): Layer.Layer<HttpTransport> => Layer.succeed(HttpTransport, fetchTransport(fetchImpl));

package/src/core/services/platform.ts

@@ -0,0 +1,54 @@
+import { Effect, Layer, Stream } from "effect";
+import type { PlatformError } from "effect/PlatformError";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+// Subpath imports: the package index also loads NodeRedis, whose `redis` peer Pi's installer does not install.
+import * as NodeChildProcessSpawner from "@effect/platform-node/NodeChildProcessSpawner";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as NodePath from "@effect/platform-node/NodePath";
+import { DevinError, toDevinError } from "../errors.ts";
+
+/** Keeps the operating system's own message and error code, as the Node APIs reported them. */
+export function fromPlatformError(error: PlatformError): DevinError {
+  const cause = error.reason.cause;
+  return cause === undefined ? new DevinError({ message: error.message }) : toDevinError(cause);
+}
+
+/** Node implementations of the process and file services this package uses. */
+export const NodePlatformLayer = Layer.mergeAll(
+  NodeChildProcessSpawner.layer.pipe(Layer.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer))),
+  NodeFileSystem.layer,
+  NodePath.layer,
+);
+
+export interface CommandOutputOptions {
+  env: Record<string, string>;
+  timeoutMs: number;
+  maxOutputBytes: number;
+}
+
+/** Runs a fixed command without a shell input and returns its stdout, like `execFileSync` with an output bound. */
+export function commandOutput(file: string, args: readonly string[], options: CommandOutputOptions): Effect.Effect<string, DevinError, ChildProcessSpawner.ChildProcessSpawner> {
+  return Effect.scoped(Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const handle = yield* spawner.spawn(ChildProcess.make(file, [...args], {
+      env: options.env, extendEnv: false, detached: false, stdin: "ignore", stderr: "ignore",
+    })).pipe(Effect.mapError(fromPlatformError));
+    let bytes = 0;
+    const chunks: Uint8Array[] = [];
+    yield* handle.stdout.pipe(
+      Stream.mapError(fromPlatformError),
+      Stream.runForEach((chunk) => {
+        bytes += chunk.byteLength;
+        if (bytes > options.maxOutputBytes) return Effect.fail(new DevinError({ message: `${file} output exceeds ${options.maxOutputBytes} bytes.` }));
+        chunks.push(chunk);
+        return Effect.void;
+      }),
+    );
+    const exitCode = yield* handle.exitCode.pipe(Effect.mapError(fromPlatformError));
+    if (exitCode !== 0) return yield* Effect.fail(new DevinError({ message: `${file} exited with code ${exitCode}.` }));
+    return Buffer.concat(chunks).toString("utf8");
+  })).pipe(Effect.timeoutOrElse({
+    duration: options.timeoutMs,
+    orElse: () => Effect.fail(new DevinError({ message: `${file} timed out after ${options.timeoutMs}ms.`, code: "ETIMEDOUT" })),
+  }));
+}

package/src/core/types.ts

@@ -1,28 +1,5 @@
 export type JsonObject = Record<string, unknown>;
 
-export function object(value: unknown, label: string): JsonObject {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${label}: a JSON object is required.`);
-  }
-  return value as JsonObject;
-}
-
-export function requiredString(value: unknown, label: string): string {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`${label}: a non-empty string is required.`);
-  }
-  return value;
-}
-
-export function tokenCount(value: unknown, label: string): number {
-  if (typeof value !== "number" && !(typeof value === "string" && /^\d+$/.test(value))) {
-    throw new Error(`${label}: invalid token count.`);
-  }
-  const count = Number(value);
-  if (!Number.isSafeInteger(count) || count < 0) throw new Error(`${label}: invalid token count.`);
-  return count;
-}
-
 export interface Credential {
   version: 1;
   sessionToken: string;
@@ -87,6 +64,8 @@ export interface ChatResult {
   stopFrameIndex?: number;
   lastUsageFrameIndex?: number;
   idlessToolDeltaCount: number;
+  /** Tool call ID → why its arguments cannot run, in Pi's `argumentsError` wording. */
+  toolArgumentErrors: Readonly<Record<string, string>>;
   durationMs: number;
   firstDeltaMs?: number;
   actualModelUid?: string;

package/src/core/validation.ts

@@ -0,0 +1,25 @@
+import { Effect, Predicate } from "effect";
+import { DevinError } from "./errors.ts";
+import type { JsonObject } from "./types.ts";
+
+export function object(value: unknown, label: string): Effect.Effect<JsonObject, DevinError> {
+  return Predicate.isObject(value) ? Effect.succeed(value as JsonObject)
+    : Effect.fail(new DevinError({ message: `${label}: a JSON object is required.` }));
+}
+
+export function requiredString(value: unknown, label: string): Effect.Effect<string, DevinError> {
+  return Predicate.isString(value) && value.length > 0 ? Effect.succeed(value)
+    : Effect.fail(new DevinError({ message: `${label}: a non-empty string is required.` }));
+}
+
+export function tokenCount(value: unknown, label: string): Effect.Effect<number, DevinError> {
+  const isCountLike = Predicate.isNumber(value) || (Predicate.isString(value) && /^\d+$/.test(value));
+  const count = Number(value);
+  return isCountLike && Number.isSafeInteger(count) && count >= 0 ? Effect.succeed(count)
+    : Effect.fail(new DevinError({ message: `${label}: invalid token count.` }));
+}
+
+/** Fails with a message-only error. */
+export function failWith(message: string): Effect.Effect<never, DevinError> {
+  return Effect.fail(new DevinError({ message }));
+}

package/src/pi/adapters/pi/devin-command.ts

@@ -0,0 +1,82 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Effect } from "effect";
+import { toDevinFailure, type DevinError, type DevinFailure } from "../../../core/errors.ts";
+import { ExtensionConfig } from "../../app/config.ts";
+import type { ExtensionRuntime } from "../../app/runtime.ts";
+import { ModelCatalog } from "../../features/catalog/service.ts";
+import { DisplaySettings } from "../../features/settings/service.ts";
+import type { DevinPreferences } from "../../features/settings/types.ts";
+import { sessionUsage, usageReport } from "../../features/usage/report.ts";
+import { DevinPanel, PREFERENCE_ITEMS } from "./ui/devin-panel.ts";
+import { UsageStatus } from "./usage-status.ts";
+
+export const DEVIN_COMMAND_NAME = "devin";
+const USAGE = "Usage: /devin, /devin recommended on|off, /devin status on|off";
+const ARGUMENT_KEYS: Readonly<Record<string, keyof DevinPreferences>> = { recommended: "recommendedOnly", status: "showUsageStatus" };
+
+const onOff = (value: boolean) => value ? "on" : "off";
+
+/** Saves the settings and applies them: a changed filter rebuilds Pi's model snapshots without network. Only a failed save fails. */
+const applyPreferences = (ctx: ExtensionCommandContext, next: DevinPreferences): Effect.Effect<void, DevinError, DisplaySettings | ModelCatalog | UsageStatus> => Effect.gen(function* () {
+  const settings = yield* DisplaySettings;
+  const catalog = yield* ModelCatalog;
+  const previous = yield* settings.read;
+  // A list refresh failure after saving is reported as a warning so the screen and the saved value stay in sync.
+  yield* settings.write(next);
+  if (previous.recommendedOnly !== next.recommendedOnly) {
+    yield* catalog.rebuild;
+    // Pi keeps model and availability snapshots. Rebuild them without network so `/model` and RPC lists update immediately.
+    yield* Effect.tryPromise({ try: () => ctx.modelRegistry.refresh({ providers: ["devin"], allowNetwork: false }), catch: toDevinFailure }).pipe(
+      Effect.catch((error) => Effect.sync(() => ctx.ui.notify(`Settings were saved, but the model list could not be rebuilt: ${error.message}`, "warning"))),
+    );
+    const model = ctx.model;
+    if (model?.provider === "devin" && !(yield* catalog.models).some((item) => item.id === model.id)) {
+      ctx.ui.notify(`The current model ${model.name} is now hidden from the list but stays in use for this session. To restore it when reopening the session, pick a model from the list.`, "warning");
+    }
+  }
+  yield* (yield* UsageStatus).update(ctx);
+});
+
+const devinCommand = (args: string, ctx: ExtensionCommandContext, runtime: ExtensionRuntime): Effect.Effect<void, DevinFailure, DisplaySettings | ModelCatalog | UsageStatus | ExtensionConfig> => Effect.gen(function* () {
+  const settings = yield* DisplaySettings;
+  const status = yield* UsageStatus;
+  const { now } = yield* ExtensionConfig;
+  const report = () => runtime.runSync(Effect.gen(function* () {
+    return usageReport(yield* status.accountUsage, sessionUsage(ctx.sessionManager.getBranch()), now());
+  }));
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length) {
+    const key = ARGUMENT_KEYS[tokens[0]];
+    if (tokens.length !== 2 || !key || (tokens[1] !== "on" && tokens[1] !== "off")) {
+      ctx.ui.notify(`Unknown argument. ${USAGE}`, "error");
+      return;
+    }
+    const value = tokens[1] === "on";
+    yield* applyPreferences(ctx, { ...(yield* settings.read), [key]: value });
+    ctx.ui.notify(`${PREFERENCE_ITEMS.find((item) => item.key === key)!.label}: ${onOff(value)} (saved globally)`, "info");
+    return;
+  }
+  if (ctx.mode === "tui") {
+    const preferences = yield* settings.read;
+    const services = yield* Effect.context<DisplaySettings | ModelCatalog | UsageStatus>();
+    yield* Effect.tryPromise({ try: () => ctx.ui.custom<void>((tui, theme, _keybindings, done) => new DevinPanel({
+      theme, report, preferences, onChange: (next) => applyPreferences(ctx, next).pipe(Effect.provideContext(services)),
+      requestRender: () => tui.requestRender(), done: () => done(),
+    })), catch: toDevinFailure });
+    return;
+  }
+  const preferences = yield* settings.read;
+  const summary = PREFERENCE_ITEMS.map((item) => `${item.label} ${onOff(preferences[item.key])}`).join(" · ");
+  ctx.ui.notify([...report().map((line) => line.text), `Settings: ${summary}`, USAGE].join("\n"), "info");
+});
+
+/**
+ * `/devin` shows usage details and display settings. Settings are saved globally and applied immediately.
+ * The TUI gets a dedicated screen; other modes use arguments and notifications.
+ */
+export function registerDevinCommand(pi: ExtensionAPI, runtime: ExtensionRuntime): void {
+  pi.registerCommand(DEVIN_COMMAND_NAME, {
+    description: "Show Devin usage and change display settings (recommended models only, usage in the status line); saved globally",
+    handler: (args, ctx) => runtime.runPromise(devinCommand(args, ctx, runtime)),
+  });
+}

package/src/pi/adapters/pi/fusion-command.ts

@@ -0,0 +1,92 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Effect } from "effect";
+import { toDevinFailure, type DevinFailure } from "../../../core/errors.ts";
+import type { ExtensionRuntime } from "../../app/runtime.ts";
+import { FUSION_MODEL_ID } from "../../features/catalog/constants.ts";
+import { ModelCatalog } from "../../features/catalog/service.ts";
+import type { DevinModel, FusionChoices, FusionSelection } from "../../features/catalog/types.ts";
+import { FusionSettings } from "../../features/settings/service.ts";
+import { FusionPicker } from "./ui/fusion-picker.ts";
+
+export const FUSION_COMMAND_NAME = "devin-fusion";
+const USAGE = `Usage: /${FUSION_COMMAND_NAME} or /${FUSION_COMMAND_NAME} <lead model ID> <sidekick model ID>`;
+
+const host = <A>(evaluate: () => Promise<A>) => Effect.tryPromise({ try: evaluate, catch: toDevinFailure });
+
+const currentFusion = (models: readonly DevinModel[]) => models.find((model) => model.id === FUSION_MODEL_ID);
+
+/** Disambiguates duplicate display names in a select list with an index, and maps the chosen label back to its value. */
+function choose<T>(ctx: ExtensionCommandContext, title: string, items: readonly T[], label: (item: T) => string, isCurrent: (item: T) => boolean): Effect.Effect<T | undefined, DevinFailure> {
+  const names = items.map(label);
+  const labels = items.map((item, index) => {
+    const name = names.filter((other) => other === names[index]).length > 1 ? `${names[index]} (${index + 1})` : names[index];
+    return (isCurrent(item) ? "● " : "  ") + name;
+  });
+  return Effect.map(host(() => ctx.ui.select(title, labels)), (picked) => picked === undefined ? undefined : items[labels.indexOf(picked)]);
+}
+
+function pickInteractively(ctx: ExtensionCommandContext, choices: FusionChoices, current: FusionSelection | undefined): Effect.Effect<FusionSelection | undefined, DevinFailure> {
+  return Effect.gen(function* () {
+    const lead = yield* choose(ctx, "Devin Fusion · lead model", choices.leads, (item) => item.name, (item) => item.id === current?.leadID);
+    if (!lead) return undefined;
+    const groups = [...new Set(choices.sidekicks.map((item) => item.groupName))];
+    const currentGroup = choices.sidekicks.find((item) => item.id === current?.sidekickID)?.groupName;
+    const group = groups.length === 1 ? groups[0] : yield* choose(ctx, "Devin Fusion · sidekick model", groups, (item) => item, (item) => item === currentGroup);
+    if (group === undefined) return undefined;
+    const variants = choices.sidekicks.filter((item) => item.groupName === group);
+    const sidekick = variants.length === 1 ? variants[0]
+      : yield* choose(ctx, `Devin Fusion · sidekick variant (${group})`, variants, (item) => item.name, (item) => item.id === current?.sidekickID);
+    return sidekick ? { leadID: lead.id, sidekickID: sidekick.id } : undefined;
+  });
+}
+
+const fusionCommand = (args: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Effect.Effect<void, DevinFailure, ModelCatalog | FusionSettings> => Effect.gen(function* () {
+  const catalog = yield* ModelCatalog;
+  const settings = yield* FusionSettings;
+  const choices = yield* catalog.fusionChoices;
+  if (!choices?.leads.length || !choices.sidekicks.length) {
+    ctx.ui.notify("No Devin models are available for Fusion. Check that the model list refreshed after /login.", "warning");
+    return;
+  }
+  const before = currentFusion(yield* catalog.models);
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  let selection: FusionSelection | undefined;
+  if (tokens.length) {
+    const [leadID, sidekickID] = tokens;
+    if (tokens.length !== 2 || !choices.leads.some((item) => item.id === leadID) || !choices.sidekicks.some((item) => item.id === sidekickID)) {
+      ctx.ui.notify(`This model cannot be used for Fusion. ${USAGE}`, "error");
+      return;
+    }
+    selection = { leadID, sidekickID };
+  } else if (ctx.mode === "tui") {
+    selection = yield* host(() => ctx.ui.custom<FusionSelection | undefined>((tui, theme, _keybindings, done) => new FusionPicker({
+      choices, current: before?.devin.fusion, theme, requestRender: () => tui.requestRender(), done,
+    })));
+    if (!selection) return;
+  } else if (ctx.hasUI) {
+    // RPC clients cannot draw the custom screen, so they get the select dialogs.
+    selection = yield* pickInteractively(ctx, choices, before?.devin.fusion);
+    if (!selection) return;
+  } else {
+    ctx.ui.notify(before ? `Current: ${before.name}` : `No Devin Fusion pair is set. ${USAGE}`, "info");
+    return;
+  }
+  yield* settings.write(selection);
+  yield* catalog.rebuild;
+  // Pi keeps model and availability snapshots. Rebuild them without network so `/model` and RPC lists update immediately.
+  yield* host(() => ctx.modelRegistry.refresh({ providers: ["devin"], allowNetwork: false }));
+  const after = currentFusion(yield* catalog.models);
+  if (after && ctx.model?.provider === "devin" && ctx.model.id === FUSION_MODEL_ID) yield* host(() => pi.setModel(after));
+  ctx.ui.notify(after ? `Saved ${after.name}. Pick Devin Fusion in /model to use it.` : "The Fusion pair was saved, but it cannot be built from the current model list.", "info");
+});
+
+/**
+ * `/devin-fusion` only chooses the lead/sidekick pair. Whether Fusion is used is decided by picking Devin Fusion in `/model`.
+ * If the current model is Fusion, it is re-selected with the updated model object so the thinking level range matches.
+ */
+export function registerFusionCommand(pi: ExtensionAPI, runtime: ExtensionRuntime): void {
+  pi.registerCommand(FUSION_COMMAND_NAME, {
+    description: "Choose the lead and sidekick models for Devin Fusion (saved globally)",
+    handler: (args, ctx) => runtime.runPromise(fusionCommand(args, ctx, pi)),
+  });
+}

package/src/pi/adapters/pi/oauth.ts

@@ -0,0 +1,14 @@
+import type { OAuthAuth } from "@earendil-works/pi-ai";
+import type { ProviderRuntime } from "../../app/runtime.ts";
+import { AccountLogin } from "../../features/auth/login.ts";
+
+/** Pi's OAuth contract over the sign-in service. Promises reject with the original failure, so Pi sees its name and message. */
+export function makeOAuthAuth(runtime: ProviderRuntime): OAuthAuth {
+  const accountLogin = runtime.runSync(AccountLogin);
+  return {
+    name: "Devin account",
+    login: (interaction) => runtime.runPromise(accountLogin.login(interaction)),
+    refresh: (current, signal) => runtime.runPromise(accountLogin.refresh(current, signal)),
+    toAuth: (current) => runtime.runPromise(accountLogin.toAuth(current)),
+  };
+}

package/src/pi/adapters/pi/provider.ts

@@ -0,0 +1,22 @@
+import type { ProviderRuntime } from "../../app/runtime.ts";
+import { ModelCatalog } from "../../features/catalog/service.ts";
+import { Inference } from "../../features/inference/service.ts";
+import { makeOAuthAuth } from "./oauth.ts";
+import type { DevinProvider } from "./types.ts";
+
+/**
+ * The provider Pi registers. Building it builds the runtime's layers, which perform no I/O; work starts with Pi's first refresh or request.
+ * Pi's synchronous calls run synchronous effects; `stream` returns at once while the request runs in a fiber the inference service owns.
+ */
+export function makeDevinProvider(runtime: ProviderRuntime): DevinProvider {
+  const catalog = runtime.runSync(ModelCatalog);
+  const inference = runtime.runSync(Inference);
+  return {
+    id: "devin", name: "Devin", auth: { oauth: makeOAuthAuth(runtime) },
+    getModels: () => runtime.runSync(catalog.models),
+    filterModels: (models, credential) => runtime.runSync(catalog.filter(models, credential)),
+    refreshModels: (context) => runtime.runPromise(catalog.refresh(context)),
+    stream: (model, context, options) => runtime.runSync(inference.start(model, context, options)),
+    streamSimple: (model, context, options) => runtime.runSync(inference.start(model, context, options)),
+  };
+}

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);
+    });
+  }
+}