diff --git a/README.md b/README.md index c2349e72860a..187c0a8d2e4e 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ T3 Code is an "agent harness control surface". It enables control of the agents on your machine with a best-in-class mobile app ([iOS](https://apps.apple.com/us/app/t3-code-remote-claude-more/id6787819824), [Android](https://play.google.com/store/apps/details?id=com.t3tools.t3code)), [web app](https://app.t3.codes) and [Electron-based desktop app](https://t3.codes). -Works with your subscriptions on Claude Code, Codex, Cursor, Grok Build, and OpenCode. If they're set up on your computer, T3 Code can control them. +Works with your subscriptions on Claude Code, Codex, Cursor, Devin, Grok Build, and OpenCode. If they're set up on your computer, T3 Code can control them. ## "Wait, what are you selling me?" @@ -13,11 +13,12 @@ We wanted something performant, remote-ready, and truly open. If we ever go the ## Installation > [!WARNING] -> T3 Code currently supports Codex, Claude, Cursor, Grok Build and OpenCode. Install and authenticate at least one provider before use: +> T3 Code currently supports Codex, Claude, Cursor, Devin, Grok Build and OpenCode. Install and authenticate at least one provider before use: > > - Codex: install [Codex CLI](https://developers.openai.com/codex/cli) and run `codex login` > - Claude: install [Claude Code](https://claude.com/product/claude-code) and run `claude auth login` > - Cursor: install [Cursor CLI](https://cursor.com/cli) and run `agent login` +> - Devin: install the [Devin CLI](https://devin.ai) and follow the Devin CLI documentation to authenticate > - Grok Build: install [Grok Build CLI](https://x.ai/cli) and run `grok login` > - OpenCode: install [OpenCode](https://opencode.ai) and run `opencode auth login` @@ -72,7 +73,7 @@ Full docs live in [docs/](./docs). There's no docs site yet. - [Remote access from a phone or another machine](./docs/user/remote-access.md) - [Keeping app and server in sync](./docs/user/updating.md) - [Source control integrations](./docs/user/source-control.md) -- Multiple accounts: [Codex](./docs/user/providers-codex.md) · [Claude](./docs/user/providers-claude.md) +- Multiple accounts: [Codex](./docs/user/providers-codex.md) · [Claude](./docs/user/providers-claude.md) · [Devin](./docs/user/providers-devin.md) - Linux: [run T3 Code as a background service](./docs/user/background-service.md) Building from source? Start at [docs/internals/overview.md](./docs/internals/overview.md). diff --git a/apps/marketing/public/harnesses/devin.svg b/apps/marketing/public/harnesses/devin.svg new file mode 100644 index 000000000000..adb472f66ad0 --- /dev/null +++ b/apps/marketing/public/harnesses/devin.svg @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/apps/marketing/src/pages/index.astro b/apps/marketing/src/pages/index.astro index 20fae288279c..2e7aca1a5fc9 100644 --- a/apps/marketing/src/pages/index.astro +++ b/apps/marketing/src/pages/index.astro @@ -41,6 +41,9 @@ const mobileEndorsementRows = [ + + +
@@ -49,7 +52,7 @@ const mobileEndorsementRows = [

- Orchestrate Claude Code, Codex, OpenCode, Cursor, and Grok from one surface. + Orchestrate Claude Code, Codex, OpenCode, Cursor, Grok, and Devin from one surface. Bring your own subscription. Fork the whole thing.

@@ -228,6 +231,13 @@ const mobileEndorsementRows = [
grok login
+
+
+
+
Devin
+
devin auth login
+
+
@@ -661,6 +671,7 @@ const mobileEndorsementRows = [ .hero-float-mark.hf-opencode { background: radial-gradient(circle at 30% 25%, rgba(255, 255, 255, 0.06), rgba(20, 20, 24, 0.92) 65%); top: 30%; left: 5%; animation-delay: -5s; transform: rotate(4deg); } .hero-float-mark.hf-cursor { background: radial-gradient(circle at 30% 25%, rgba(255, 255, 255, 0.08), rgba(20, 20, 24, 0.92) 65%); top: 30%; right: 5%; animation-delay: -7s; transform: rotate(-5deg); } .hero-float-mark.hf-grok { background: radial-gradient(circle at 30% 25%, rgba(255, 255, 255, 0.08), rgba(20, 20, 24, 0.92) 65%); top: 52%; left: 6%; animation-delay: -1.2s; transform: rotate(3deg); } + .hero-float-mark.hf-devin { background: radial-gradient(circle at 30% 25%, rgba(255, 255, 255, 0.06), rgba(20, 20, 24, 0.92) 65%); top: 52%; right: 6%; animation-delay: -4s; transform: rotate(-3deg); } @media (max-width: 1180px) { .hero-float-mark { width: 76px; height: 76px; border-radius: 20px; } @@ -670,6 +681,7 @@ const mobileEndorsementRows = [ .hero-float-mark.hf-opencode { top: 26%; left: 2%; } .hero-float-mark.hf-cursor { top: 24%; right: 2%; } .hero-float-mark.hf-grok { top: 48%; left: 2%; transform: rotate(3deg); } + .hero-float-mark.hf-devin { top: 48%; right: 2%; transform: rotate(-3deg); } } @media (max-width: 820px) { @@ -704,7 +716,7 @@ const mobileEndorsementRows = [ height: 44px; } - /* Three stacked on the left, two on the right — keeps the center CTA clear. */ + /* Three stacked on the left, three on the right — keeps the center CTA clear. */ .hero-float-mark.hf-claude { top: 44px; left: 10px; @@ -731,6 +743,13 @@ const mobileEndorsementRows = [ transform: rotate(8deg); } + .hero-float-mark.hf-devin { + top: 240px; + right: 4px; + left: auto; + transform: rotate(4deg); + } + .hero-float-mark.hf-cursor { top: 474px; right: 4px; @@ -740,14 +759,22 @@ const mobileEndorsementRows = [ } @media (max-width: 340px) { - .hero-float-mark.hf-grok { + .hero-float-mark.hf-grok, + .hero-float-mark.hf-devin { top: 220px; - left: 0; width: 52px; height: 52px; border-radius: 14px; } + .hero-float-mark.hf-grok { + left: 0; + } + + .hero-float-mark.hf-devin { + right: 0; + } + .hero-float-mark.hf-opencode, .hero-float-mark.hf-cursor { top: 580px; @@ -765,6 +792,7 @@ const mobileEndorsementRows = [ } .hero-float-mark.hf-grok img, + .hero-float-mark.hf-devin img, .hero-float-mark.hf-opencode img, .hero-float-mark.hf-cursor img { width: 30px; @@ -811,7 +839,7 @@ const mobileEndorsementRows = [ .harness-grid { display: grid; - grid-template-columns: repeat(5, 1fr); + grid-template-columns: repeat(6, 1fr); gap: 0; border: 1px solid var(--border); border-radius: var(--radius); @@ -1266,7 +1294,7 @@ const mobileEndorsementRows = [ .harness-grid { grid-template-columns: 1fr 1fr; } .harness { border-right: 0; border-bottom: 1px solid var(--border); } .harness:nth-child(odd) { border-right: 1px solid var(--border); } - .harness:nth-child(5):last-child { + .harness:nth-child(odd):last-child { grid-column: 1 / -1; border-right: 0; } diff --git a/apps/mobile/src/features/usage/usageProviders.ts b/apps/mobile/src/features/usage/usageProviders.ts index 3e2d027a9e35..971f63747a69 100644 --- a/apps/mobile/src/features/usage/usageProviders.ts +++ b/apps/mobile/src/features/usage/usageProviders.ts @@ -5,11 +5,12 @@ import { useColorScheme } from "react-native"; * Series and table order. The chart stacks providers from the bottom in this * order, so it also fixes which band sits on top of the bars. */ -export const PROVIDER_ORDER: readonly UsageProviderKind[] = ["codex", "claude"]; +export const PROVIDER_ORDER: readonly UsageProviderKind[] = ["codex", "claude", "devin"]; export const PROVIDER_LABEL: Record = { claude: "Claude Code", codex: "Codex", + devin: "Devin", }; /** @@ -21,5 +22,6 @@ export function useProviderColors(): Record { return { claude: "#d97757", codex: scheme === "dark" ? "#e6e6e6" : "#3c3c43", + devin: "#8a63d2", }; } diff --git a/apps/mobile/src/lib/modelOptions.ts b/apps/mobile/src/lib/modelOptions.ts index cb7a8c4198ec..d46ec3c0ba97 100644 --- a/apps/mobile/src/lib/modelOptions.ts +++ b/apps/mobile/src/lib/modelOptions.ts @@ -35,6 +35,7 @@ function providerDisplayLabel(provider: { if (provider.displayName) return provider.displayName; if (provider.driver === "codex") return "Codex"; if (provider.driver === "claudeAgent") return "Claude"; + if (provider.driver === "devin") return "Devin"; return provider.instanceId; } diff --git a/apps/server/scripts/acp-mock-agent.ts b/apps/server/scripts/acp-mock-agent.ts index bc7828dd8547..64b4b9f4c281 100644 --- a/apps/server/scripts/acp-mock-agent.ts +++ b/apps/server/scripts/acp-mock-agent.ts @@ -40,6 +40,17 @@ const failSetConfigOption = process.env.T3_ACP_FAIL_SET_CONFIG_OPTION === "1"; const exitOnSetConfigOption = process.env.T3_ACP_EXIT_ON_SET_CONFIG_OPTION === "1"; const promptResponseText = process.env.T3_ACP_PROMPT_RESPONSE_TEXT; const promptDelayMs = Number(process.env.T3_ACP_PROMPT_DELAY_MS ?? "0"); +const advertisedAuthMethods = (() => { + const raw = process.env.T3_ACP_AUTH_METHODS; + if (!raw) { + return undefined; + } + try { + return JSON.parse(raw) as ReadonlyArray; + } catch { + return undefined; + } +})(); const permissionOptionIds = { allowOnce: process.env.T3_ACP_ALLOW_ONCE_OPTION_ID ?? "allow-once", allowAlways: process.env.T3_ACP_ALLOW_ALWAYS_OPTION_ID ?? "allow-always", @@ -218,7 +229,10 @@ function configOptions(): ReadonlyArray { { value: "default", name: "Auto" }, { value: "composer-2", name: "Composer 2" }, { value: "composer-2[fast=true]", name: "Composer 2 Fast" }, - { value: "gpt-5.3-codex[reasoning=medium,fast=false]", name: "Codex 5.3" }, + { + value: "gpt-5.3-codex[reasoning=medium,fast=false]", + name: "Codex 5.3", + }, ], }, ]; @@ -303,6 +317,7 @@ const program = Effect.gen(function* () { return { protocolVersion: 1, agentCapabilities: { loadSession: true }, + ...(advertisedAuthMethods !== undefined ? { authMethods: advertisedAuthMethods } : {}), }; }), ); @@ -674,13 +689,21 @@ const program = Effect.gen(function* () { ], }, options: [ - { optionId: permissionOptionIds.allowOnce, name: "Allow once", kind: "allow_once" }, + { + optionId: permissionOptionIds.allowOnce, + name: "Allow once", + kind: "allow_once", + }, { optionId: permissionOptionIds.allowAlways, name: "Allow always", kind: "allow_always", }, - { optionId: permissionOptionIds.rejectOnce, name: "Reject", kind: "reject_once" }, + { + optionId: permissionOptionIds.rejectOnce, + name: "Reject", + kind: "reject_once", + }, ], }); @@ -784,7 +807,10 @@ const program = Effect.gen(function* () { question: "Which scope should Grok use?", multiSelect: null, options: [ - { label: "Workspace", description: "Use the current workspace" }, + { + label: "Workspace", + description: "Use the current workspace", + }, { label: "Session", description: "Only use this session" }, ], }, @@ -869,7 +895,10 @@ const program = Effect.gen(function* () { sessionId: requestedSessionId, update: { sessionUpdate: "agent_message_chunk", - content: { type: "text", text: promptResponseText ?? "hello from mock" }, + content: { + type: "text", + text: promptResponseText ?? "hello from mock", + }, }, }); diff --git a/apps/server/src/provider/Drivers/DevinBinary.ts b/apps/server/src/provider/Drivers/DevinBinary.ts new file mode 100644 index 000000000000..eec288e92c83 --- /dev/null +++ b/apps/server/src/provider/Drivers/DevinBinary.ts @@ -0,0 +1,32 @@ +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import { isCommandAvailable } from "@t3tools/shared/shell"; + +const DEFAULT_DEVIN_BINARIES = ["devin", "devin-desktop"] as const; + +export const resolveEffectiveDevinBinary = Effect.fn("resolveEffectiveDevinBinary")(function* ( + binaryPath: string | null | undefined, + environment?: NodeJS.ProcessEnv, +): Effect.fn.Return { + const configured = (binaryPath ?? "").trim() || "devin"; + + const env = environment ?? process.env; + + if (!DEFAULT_DEVIN_BINARIES.includes(configured as (typeof DEFAULT_DEVIN_BINARIES)[number])) { + return configured; + } + + if (yield* isCommandAvailable(configured, { env })) { + return configured; + } + + for (const candidate of DEFAULT_DEVIN_BINARIES) { + if (candidate === configured) continue; + if (yield* isCommandAvailable(candidate, { env })) { + return candidate; + } + } + + return configured; +}); diff --git a/apps/server/src/provider/Drivers/DevinDriver.ts b/apps/server/src/provider/Drivers/DevinDriver.ts new file mode 100644 index 000000000000..c509d455f829 --- /dev/null +++ b/apps/server/src/provider/Drivers/DevinDriver.ts @@ -0,0 +1,175 @@ +import { DevinSettings, ProviderDriverKind, type ServerProvider } from "@t3tools/contracts"; +import * as Crypto from "effect/Crypto"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; +import { HttpClient } from "effect/unstable/http"; +import { ChildProcessSpawner } from "effect/unstable/process"; + +import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; +import { ServerConfig } from "../../config.ts"; +import { ServerSettingsService } from "../../serverSettings.ts"; +import { makeDevinTextGeneration } from "../../textGeneration/DevinTextGeneration.ts"; +import { ProviderDriverError } from "../Errors.ts"; +import { makeDevinAdapter } from "../Layers/DevinAdapter.ts"; +import { resolveEffectiveDevinBinary } from "./DevinBinary.ts"; +import { makeDevinContinuationGroupKey, makeDevinEnvironment } from "./DevinHome.ts"; +import { + buildInitialDevinProviderSnapshot, + checkDevinProviderStatus, + enrichDevinSnapshot, +} from "../Layers/DevinProvider.ts"; +import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts"; +import { makeManagedServerProvider } from "../makeManagedServerProvider.ts"; +import { type ProviderDriver, type ProviderInstance } from "../ProviderDriver.ts"; +import type { ServerProviderDraft } from "../providerSnapshot.ts"; +import { mergeProviderInstanceEnvironment } from "../ProviderInstanceEnvironment.ts"; +import { + makeManualOnlyProviderMaintenanceCapabilities, + makeStaticProviderMaintenanceResolver, + resolveProviderMaintenanceCapabilitiesEffect, +} from "../providerMaintenance.ts"; +import { + haveProviderSnapshotSettingsChanged, + makeProviderSnapshotSettingsSource, + type ProviderSnapshotSettings, +} from "../providerUpdateSettings.ts"; + +const decodeDevinSettings = Schema.decodeSync(DevinSettings); + +const DRIVER_KIND = ProviderDriverKind.make("devin"); +const UPDATE = makeStaticProviderMaintenanceResolver( + makeManualOnlyProviderMaintenanceCapabilities({ + provider: DRIVER_KIND, + packageName: null, + }), +); + +export type DevinDriverEnv = + | BackgroundPolicy.BackgroundPolicy + | ChildProcessSpawner.ChildProcessSpawner + | Crypto.Crypto + | FileSystem.FileSystem + | HttpClient.HttpClient + | Path.Path + | ProviderEventLoggers + | ServerConfig + | ServerSettingsService; + +const withInstanceIdentity = + (input: { + readonly instanceId: ProviderInstance["instanceId"]; + readonly displayName: string | undefined; + readonly accentColor: string | undefined; + readonly continuationGroupKey: string; + }) => + (snapshot: ServerProviderDraft): ServerProvider => ({ + ...snapshot, + instanceId: input.instanceId, + driver: DRIVER_KIND, + ...(input.displayName ? { displayName: input.displayName } : {}), + ...(input.accentColor ? { accentColor: input.accentColor } : {}), + continuation: { groupKey: input.continuationGroupKey }, + }); + +export const DevinDriver: ProviderDriver = { + driverKind: DRIVER_KIND, + metadata: { + displayName: "Devin", + supportsMultipleInstances: true, + }, + configSchema: DevinSettings, + defaultConfig: (): DevinSettings => decodeDevinSettings({}), + create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => + Effect.gen(function* () { + const crypto = yield* Crypto.Crypto; + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const httpClient = yield* HttpClient.HttpClient; + const serverSettings = yield* ServerSettingsService; + const eventLoggers = yield* ProviderEventLoggers; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const processEnv = mergeProviderInstanceEnvironment(environment); + const continuationGroupKey = yield* makeDevinContinuationGroupKey(config); + const continuationIdentity = { + driverKind: DRIVER_KIND, + continuationKey: continuationGroupKey, + }; + const stampIdentity = withInstanceIdentity({ + instanceId, + displayName, + accentColor, + continuationGroupKey: continuationIdentity.continuationKey, + }); + + const resolvedBinary = yield* resolveEffectiveDevinBinary(config.binaryPath, processEnv); + const devinEnv = yield* makeDevinEnvironment(config, processEnv); + + const effectiveConfig = { + ...config, + enabled, + binaryPath: resolvedBinary, + } satisfies DevinSettings; + const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE, { + binaryPath: effectiveConfig.binaryPath, + env: processEnv, + }); + + const adapter = yield* makeDevinAdapter(effectiveConfig, { + environment: devinEnv, + ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}), + instanceId, + }); + const textGeneration = yield* makeDevinTextGeneration(effectiveConfig, devinEnv); + + const checkProvider = checkDevinProviderStatus(effectiveConfig, devinEnv).pipe( + Effect.map(stampIdentity), + Effect.provideService(Crypto.Crypto, crypto), + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + ); + + const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings); + const snapshot = yield* makeManagedServerProvider>({ + maintenanceCapabilities, + getSettings: snapshotSettings.getSettings, + streamSettings: snapshotSettings.streamSettings, + haveSettingsChanged: haveProviderSnapshotSettingsChanged, + initialSnapshot: (settings) => + buildInitialDevinProviderSnapshot(settings.provider).pipe(Effect.map(stampIdentity)), + checkProvider, + enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) => + enrichDevinSnapshot({ + snapshot: currentSnapshot, + maintenanceCapabilities, + enableProviderUpdateChecks: settings.enableProviderUpdateChecks, + publishSnapshot, + httpClient, + }), + }).pipe( + Effect.mapError( + (cause) => + new ProviderDriverError({ + driver: DRIVER_KIND, + instanceId, + detail: "Failed to build the Devin provider snapshot.", + cause, + }), + ), + ); + + return { + instanceId, + driverKind: DRIVER_KIND, + continuationIdentity, + displayName, + accentColor, + enabled, + snapshot, + adapter, + textGeneration, + } satisfies ProviderInstance; + }), +}; diff --git a/apps/server/src/provider/Drivers/DevinHome.test.ts b/apps/server/src/provider/Drivers/DevinHome.test.ts new file mode 100644 index 000000000000..1f6de00e089a --- /dev/null +++ b/apps/server/src/provider/Drivers/DevinHome.test.ts @@ -0,0 +1,66 @@ +import * as NodeOS from "node:os"; + +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { describe, expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Path from "effect/Path"; + +import { + makeDevinCapabilitiesCacheKey, + makeDevinContinuationGroupKey, + makeDevinEnvironment, + resolveDevinHomePath, +} from "./DevinHome.ts"; + +it.layer(NodeServices.layer)("DevinHome", (it) => { + describe("Devin home resolution", () => { + it.effect("uses ~/.devin when no Devin home override is configured", () => + Effect.gen(function* () { + const path = yield* Path.Path; + const resolved = path.resolve(NodeOS.homedir(), ".devin"); + + expect(yield* resolveDevinHomePath({ homePath: "" })).toBe(resolved); + }), + ); + + it.effect("resolves configured Devin HOME and stamps continuation/cache keys with it", () => + Effect.gen(function* () { + const path = yield* Path.Path; + const homePath = "~/.devin-work"; + const resolved = path.resolve(NodeOS.homedir(), ".devin-work"); + + expect(yield* resolveDevinHomePath({ homePath })).toBe(resolved); + expect((yield* makeDevinEnvironment({ homePath })).DEVIN_HOME).toBe(resolved); + expect(yield* makeDevinContinuationGroupKey({ homePath })).toBe(`devin:home:${resolved}`); + expect(yield* makeDevinCapabilitiesCacheKey({ binaryPath: "devin", homePath })).toBe( + `devin\0${resolved}\0`, + ); + }), + ); + + it.effect("clears an inherited DEVIN_HOME when no Devin home override is configured", () => + Effect.gen(function* () { + const path = yield* Path.Path; + const resolved = path.resolve(NodeOS.homedir(), ".devin"); + + const env = yield* makeDevinEnvironment( + { homePath: "" }, + { ...process.env, DEVIN_HOME: "/some/other/home" }, + ); + + expect(env.DEVIN_HOME).toBe(resolved); + }), + ); + + it.effect("keeps continuation compatible across instances with the same Devin HOME", () => + Effect.gen(function* () { + const path = yield* Path.Path; + const resolved = path.resolve(NodeOS.homedir(), ".devin"); + + expect(yield* makeDevinContinuationGroupKey({ homePath: "" })).toBe( + `devin:home:${resolved}`, + ); + }), + ); + }); +}); diff --git a/apps/server/src/provider/Drivers/DevinHome.ts b/apps/server/src/provider/Drivers/DevinHome.ts new file mode 100644 index 000000000000..0be436cb078d --- /dev/null +++ b/apps/server/src/provider/Drivers/DevinHome.ts @@ -0,0 +1,57 @@ +import * as NodeOS from "node:os"; + +import { type DevinSettings } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Path from "effect/Path"; + +import { expandHomePath } from "../../pathExpansion.ts"; + +export const DEVIN_DEFAULT_HOME_DIR = ".devin"; +export const DEVIN_USAGE_TRANSCRIPT_NAME = "t3code-usage.jsonl"; + +export const resolveDevinHomePath = Effect.fn("resolveDevinHomePath")(function* ( + config: Pick, +): Effect.fn.Return { + const path = yield* Path.Path; + const homePath = config.homePath.trim(); + const expanded = + homePath.length > 0 + ? expandHomePath(homePath) + : path.join(NodeOS.homedir(), DEVIN_DEFAULT_HOME_DIR); + return path.resolve(expanded); +}); + +export const makeDevinEnvironment = Effect.fn("makeDevinEnvironment")(function* ( + config: Pick, + baseEnv?: NodeJS.ProcessEnv, +): Effect.fn.Return { + const resolvedBaseEnv = baseEnv ?? process.env; + const resolvedHomePath = yield* resolveDevinHomePath(config); + return { + ...resolvedBaseEnv, + DEVIN_HOME: resolvedHomePath, + }; +}); + +export const makeDevinContinuationGroupKey = Effect.fn("makeDevinContinuationGroupKey")(function* ( + config: Pick, +): Effect.fn.Return { + const resolvedHomePath = yield* resolveDevinHomePath(config); + return `devin:home:${resolvedHomePath}`; +}); + +export const makeDevinCapabilitiesCacheKey = Effect.fn("makeDevinCapabilitiesCacheKey")(function* ( + config: Pick, + cwd?: string, +): Effect.fn.Return { + const resolvedHomePath = yield* resolveDevinHomePath(config); + return `${config.binaryPath}\0${resolvedHomePath}\0${cwd ?? ""}`; +}); + +export const resolveDevinUsageTranscriptPath = Effect.fn("resolveDevinUsageTranscriptPath")( + function* (config: Pick): Effect.fn.Return { + const path = yield* Path.Path; + const homePath = yield* resolveDevinHomePath(config); + return path.join(homePath, DEVIN_USAGE_TRANSCRIPT_NAME); + }, +); diff --git a/apps/server/src/provider/Errors.ts b/apps/server/src/provider/Errors.ts index 0cf1522399b4..fe2ef3c8d90e 100644 --- a/apps/server/src/provider/Errors.ts +++ b/apps/server/src/provider/Errors.ts @@ -85,6 +85,40 @@ export class ProviderAdapterProcessError extends Schema.TaggedErrorClass()( + "ProviderProbeError", + { + provider: Schema.String, + stage: ProviderProbeStage, + failureKind: ProviderProbeFailureKind, + exitCode: Schema.optional(Schema.Number), + detail: Schema.optional(Schema.String), + cause: Schema.optional(Schema.Defect()), + }, +) { + override get message(): string { + const detail = + this.failureKind === "exit-code-failure" + ? `command failed with exit code ${this.exitCode ?? "unknown"}` + : this.failureKind === "unparseable-output" + ? "command output could not be parsed into models" + : "probe failed"; + return `Provider probe error (${this.provider}) in ${this.stage}: ${detail}`; + } +} + /** * ProviderValidationError - Invalid provider API input. */ diff --git a/apps/server/src/provider/Layers/DevinAdapter.test.ts b/apps/server/src/provider/Layers/DevinAdapter.test.ts new file mode 100644 index 000000000000..dfad339ebd9e --- /dev/null +++ b/apps/server/src/provider/Layers/DevinAdapter.test.ts @@ -0,0 +1,297 @@ +import { describe, expect, it } from "@effect/vitest"; +import * as EffectAcpSchema from "effect-acp/schema"; + +import type { AcpParsedSessionEvent } from "../acp/AcpRuntimeModel.ts"; +import { + isAcpUsageGreaterOrNew, + makeDevinTokenUsageSnapshot, + makeDevinTokenUsageSnapshotFromUsageUpdate, + usageFromUsageUpdate, +} from "./DevinAdapter.ts"; + +function makeUsageUpdatedEvent( + event: Partial> & { + readonly used: number; + }, +): Extract { + return { + _tag: "UsageUpdated", + used: event.used, + size: event.size ?? 0, + cost: event.cost ?? null, + inputTokens: event.inputTokens ?? undefined, + outputTokens: event.outputTokens ?? undefined, + cachedReadTokens: event.cachedReadTokens ?? undefined, + rawPayload: event.rawPayload ?? {}, + }; +} + +describe("usageFromUsageUpdate", () => { + it("keeps provided input and output tokens", () => { + const event = makeUsageUpdatedEvent({ + used: 21776, + inputTokens: 21687, + outputTokens: 89, + }); + expect(usageFromUsageUpdate(event)).toEqual({ + inputTokens: 21687, + outputTokens: 89, + totalTokens: 21776, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + }); + }); + + it("derives input tokens from used and output when input is missing", () => { + const event = makeUsageUpdatedEvent({ + used: 21776, + outputTokens: 89, + }); + expect(usageFromUsageUpdate(event)).toEqual({ + inputTokens: 21687, + outputTokens: 89, + totalTokens: 21776, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + }); + }); + + it("uses used as input when both breakdown fields are missing", () => { + const event = makeUsageUpdatedEvent({ + used: 100, + }); + expect(usageFromUsageUpdate(event)).toEqual({ + inputTokens: 100, + outputTokens: 0, + totalTokens: 100, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + }); + }); + + it("does not subtract output when input is present", () => { + const event = makeUsageUpdatedEvent({ + used: 100, + inputTokens: 30, + outputTokens: 20, + }); + expect(usageFromUsageUpdate(event)).toEqual({ + inputTokens: 30, + outputTokens: 20, + totalTokens: 100, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + }); + }); +}); + +describe("isAcpUsageGreaterOrNew", () => { + const baseUsage = { + inputTokens: 10, + outputTokens: 5, + totalTokens: 15, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + } satisfies EffectAcpSchema.Usage; + + it("returns true when there is no current usage", () => { + expect(isAcpUsageGreaterOrNew(undefined, baseUsage)).toBe(true); + }); + + it("returns true when total tokens increased", () => { + expect(isAcpUsageGreaterOrNew(baseUsage, { ...baseUsage, totalTokens: 20 })).toBe(true); + }); + + it("returns false when total tokens decreased", () => { + expect(isAcpUsageGreaterOrNew(baseUsage, { ...baseUsage, totalTokens: 10 })).toBe(false); + }); + + it("returns false when everything is identical", () => { + expect(isAcpUsageGreaterOrNew(baseUsage, { ...baseUsage })).toBe(false); + }); + + it("returns true when total is equal but input tokens differ", () => { + expect(isAcpUsageGreaterOrNew(baseUsage, { ...baseUsage, inputTokens: 12 })).toBe(true); + }); + + it("returns true when total is equal but output tokens differ", () => { + expect(isAcpUsageGreaterOrNew(baseUsage, { ...baseUsage, outputTokens: 7 })).toBe(true); + }); + + it("returns true when total is equal but cached read tokens differ", () => { + expect( + isAcpUsageGreaterOrNew(baseUsage, { + ...baseUsage, + cachedReadTokens: 3, + }), + ).toBe(true); + }); + + it("returns true when total is equal but cached write tokens differ", () => { + expect( + isAcpUsageGreaterOrNew(baseUsage, { + ...baseUsage, + cachedWriteTokens: 2, + }), + ).toBe(true); + }); + + it("returns true when total is equal but thought tokens differ", () => { + expect( + isAcpUsageGreaterOrNew(baseUsage, { + ...baseUsage, + thoughtTokens: 1, + }), + ).toBe(true); + }); +}); +describe("makeDevinTokenUsageSnapshotFromUsageUpdate", () => { + it("uses size as maxTokens and used as usedTokens", () => { + const event = makeUsageUpdatedEvent({ + used: 21_776, + size: 262_000, + inputTokens: 21_687, + outputTokens: 89, + cachedReadTokens: 448, + }); + + const snapshot = makeDevinTokenUsageSnapshotFromUsageUpdate(event, undefined); + + expect(snapshot).toMatchObject({ + usedTokens: 21_776, + maxTokens: 262_000, + totalProcessedTokens: 21_687 + 89, + inputTokens: 21_687, + outputTokens: 89, + cachedInputTokens: 448, + lastUsedTokens: 21_776, + lastInputTokens: 21_687, + lastOutputTokens: 89, + lastCachedInputTokens: 448, + }); + }); + + it("accumulates totalProcessedTokens across usage updates", () => { + const first = makeDevinTokenUsageSnapshotFromUsageUpdate( + makeUsageUpdatedEvent({ + used: 1_000, + size: 200_000, + inputTokens: 990, + outputTokens: 10, + }), + undefined, + ); + + const second = makeDevinTokenUsageSnapshotFromUsageUpdate( + makeUsageUpdatedEvent({ + used: 1_500, + size: 200_000, + inputTokens: 480, + outputTokens: 20, + }), + first, + ); + + expect(second?.usedTokens).toBe(1_500); + expect(second?.maxTokens).toBe(200_000); + expect(second?.totalProcessedTokens).toBe(1_500); + expect(second?.lastUsedTokens).toBe(500); + expect(second?.lastInputTokens).toBe(480); + expect(second?.lastOutputTokens).toBe(20); + }); + + it("does not decrease totalProcessedTokens when context compacts", () => { + const first = makeDevinTokenUsageSnapshotFromUsageUpdate( + makeUsageUpdatedEvent({ + used: 10_000, + size: 200_000, + inputTokens: 9_990, + outputTokens: 10, + }), + undefined, + ); + + const second = makeDevinTokenUsageSnapshotFromUsageUpdate( + makeUsageUpdatedEvent({ + used: 8_000, + size: 200_000, + inputTokens: 1_000, + outputTokens: 500, + }), + first, + ); + + expect(second?.usedTokens).toBe(8_000); + expect(second?.totalProcessedTokens).toBe(11_500); + expect(second?.lastUsedTokens).toBe(0); + expect(second?.lastInputTokens).toBe(1_000); + expect(second?.lastOutputTokens).toBe(500); + }); + + it("ignores size 0 and omits maxTokens", () => { + const event = makeUsageUpdatedEvent({ + used: 100, + size: 0, + }); + + const snapshot = makeDevinTokenUsageSnapshotFromUsageUpdate(event, undefined); + + expect(snapshot).not.toHaveProperty("maxTokens"); + expect(snapshot?.usedTokens).toBe(100); + expect(snapshot?.totalProcessedTokens).toBe(100); + }); +}); + +describe("makeDevinTokenUsageSnapshot", () => { + it("uses totalTokens as totalProcessedTokens and preserves previous context", () => { + const previous = { + usedTokens: 1_500, + maxTokens: 200_000, + totalProcessedTokens: 1_500, + } as const; + + const usage = { + inputTokens: 10_000, + outputTokens: 500, + totalTokens: 10_500, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + } satisfies EffectAcpSchema.Usage; + + const snapshot = makeDevinTokenUsageSnapshot(usage, previous); + + expect(snapshot).toMatchObject({ + usedTokens: 1_500, + totalProcessedTokens: 10_500, + maxTokens: 200_000, + inputTokens: 10_000, + outputTokens: 500, + lastUsedTokens: 9_000, + }); + }); + + it("falls back to totalTokens when there is no previous context", () => { + const usage = { + inputTokens: 1_000, + outputTokens: 100, + totalTokens: 1_100, + cachedReadTokens: null, + cachedWriteTokens: null, + thoughtTokens: null, + } satisfies EffectAcpSchema.Usage; + + const snapshot = makeDevinTokenUsageSnapshot(usage, undefined); + + expect(snapshot).toMatchObject({ + usedTokens: 1_100, + totalProcessedTokens: 1_100, + }); + expect(snapshot?.maxTokens).toBeUndefined(); + }); +}); diff --git a/apps/server/src/provider/Layers/DevinAdapter.ts b/apps/server/src/provider/Layers/DevinAdapter.ts new file mode 100644 index 000000000000..84bf725fec4b --- /dev/null +++ b/apps/server/src/provider/Layers/DevinAdapter.ts @@ -0,0 +1,1757 @@ +import { + ApprovalRequestId, + type DevinSettings, + EventId, + type ProviderApprovalDecision, + type ProviderRuntimeEvent, + type ProviderSession, + type ProviderUserInputAnswers, + ProviderDriverKind, + ProviderInstanceId, + RuntimeRequestId, + type ThreadId, + type ThreadTokenUsageSnapshot, + type UsageTokenTotals, + TurnId, +} from "@t3tools/contracts"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Fiber from "effect/Fiber"; +import * as FileSystem from "effect/FileSystem"; +import * as Option from "effect/Option"; +import * as Path from "effect/Path"; +import * as PubSub from "effect/PubSub"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import * as Scope from "effect/Scope"; +import * as Semaphore from "effect/Semaphore"; +import * as Stream from "effect/Stream"; +import * as SynchronizedRef from "effect/SynchronizedRef"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; +import * as EffectAcpErrors from "effect-acp/errors"; +import type * as EffectAcpSchema from "effect-acp/schema"; + +import { resolveAttachmentPath } from "../../attachmentStore.ts"; +import { ServerConfig } from "../../config.ts"; +import * as McpProviderSession from "../../mcp/McpProviderSession.ts"; +import { + type ProviderAdapterError, + ProviderAdapterProcessError, + ProviderAdapterRequestError, + ProviderAdapterSessionNotFoundError, + ProviderAdapterValidationError, +} from "../Errors.ts"; +import { mapAcpToAdapterError } from "../acp/AcpAdapterSupport.ts"; +import type * as AcpSessionRuntime from "../acp/AcpSessionRuntime.ts"; +import { + makeAcpAssistantItemEvent, + makeAcpContentDeltaEvent, + makeAcpPlanUpdatedEvent, + makeAcpRequestOpenedEvent, + makeAcpRequestResolvedEvent, + makeAcpToolCallEvent, +} from "../acp/AcpCoreRuntimeEvents.ts"; +import { parsePermissionRequest, type AcpParsedSessionEvent } from "../acp/AcpRuntimeModel.ts"; +import { makeAcpNativeLoggerFactory } from "../acp/AcpNativeLogging.ts"; +import { + applyDevinAcpModelSelection, + currentDevinAcpModelSelection, + makeDevinAcpRuntime, + resolveDevinAcpBaseModelId, + resolveDevinAcpModelSelection, +} from "../acp/DevinAcpSupport.ts"; +import { resolveDevinUsageTranscriptPath } from "../Drivers/DevinHome.ts"; +import { type DevinAdapterShape } from "../Services/DevinAdapter.ts"; +import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; + +const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); +const encodeUnknownJsonString = Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); + +const PROVIDER = ProviderDriverKind.make("devin"); +const DEVIN_RESUME_VERSION = 1 as const; + +function encodeJsonStringForDiagnostics(input: unknown): string | undefined { + const result = encodeUnknownJsonStringExit(input); + return Exit.isSuccess(result) ? result.value : undefined; +} + +export interface DevinAdapterLiveOptions { + readonly environment?: NodeJS.ProcessEnv; + readonly nativeEventLogPath?: string; + readonly nativeEventLogger?: EventNdjsonLogger; + readonly instanceId?: ProviderInstanceId; +} + +interface PendingApproval { + readonly decision: Deferred.Deferred; +} + +type PendingUserInputResolution = + | { readonly _tag: "answered"; readonly answers: ProviderUserInputAnswers } + | { readonly _tag: "cancelled" }; + +interface PendingUserInput { + readonly resolution: Deferred.Deferred; +} + +interface DevinSessionContext { + readonly threadId: ThreadId; + readonly acpSessionId: string; + session: ProviderSession; + sessionSetupResult: + | EffectAcpSchema.LoadSessionResponse + | EffectAcpSchema.NewSessionResponse + | EffectAcpSchema.ResumeSessionResponse; + readonly scope: Scope.Closeable; + readonly acp: AcpSessionRuntime.AcpSessionRuntime["Service"]; + notificationFiber: Fiber.Fiber | undefined; + readonly pendingApprovals: Map; + readonly pendingUserInputs: Map; + turns: Array<{ id: TurnId; items: Array }>; + lastPlanFingerprint: string | undefined; + activeTurnId: TurnId | undefined; + /** Turns already interrupted; late prompt RPCs must not resurrect them. */ + interruptedTurnIds: Set; + /** Number of sendTurn prompts currently in flight or being prepared. + * >0 means a turn is actively running, so a new sendTurn is a steer that + * continues it, and only the last remaining prompt settles the turn. */ + promptsInFlight: number; + currentModelId: string | undefined; + currentReasoningValue: string | undefined; + stopped: boolean; + lastKnownTokenUsage: ThreadTokenUsageSnapshot | undefined; + /** Last usage received from ACP (PromptResponse or UsageUpdated). */ + lastAcpUsage: EffectAcpSchema.Usage | undefined; + /** Last usage that was actually persisted to the Devin usage transcript. */ + lastWrittenAcpUsage: EffectAcpSchema.Usage | undefined; +} + +function settlePendingApprovalsAsCancelled( + pendingApprovals: ReadonlyMap, +): Effect.Effect { + return Effect.forEach( + Array.from(pendingApprovals.values()), + (pending) => Deferred.succeed(pending.decision, "cancel").pipe(Effect.ignore), + { discard: true }, + ); +} + +function settlePendingUserInputsAsCancelled( + pendingUserInputs: ReadonlyMap, +): Effect.Effect { + return Effect.forEach( + Array.from(pendingUserInputs.values()), + (pending) => Deferred.succeed(pending.resolution, { _tag: "cancelled" }).pipe(Effect.ignore), + { discard: true }, + ); +} + +function appendPromptResultToTurn( + ctx: DevinSessionContext, + turnId: TurnId, + promptParts: ReadonlyArray, + result: EffectAcpSchema.PromptResponse, +): void { + const existingTurnRecord = ctx.turns.find((turn) => turn.id === turnId); + ctx.turns = existingTurnRecord + ? ctx.turns.map((turn) => + turn.id === turnId + ? { ...turn, items: [...turn.items, { prompt: promptParts, result }] } + : turn, + ) + : [...ctx.turns, { id: turnId, items: [{ prompt: promptParts, result }] }]; +} + +const resolveNotificationTurnId = (ctx: DevinSessionContext): TurnId | undefined => + ctx.activeTurnId; + +const resolveCallbackTurnId = (ctx: DevinSessionContext): TurnId | undefined => ctx.activeTurnId; + +const resolveSessionCallbackTurnId = ( + sessions: ReadonlyMap, + threadId: ThreadId, +): TurnId | undefined => { + const ctx = sessions.get(threadId); + return ctx ? resolveCallbackTurnId(ctx) : undefined; +}; + +const DevinResume = Schema.Struct({ + schemaVersion: Schema.Literal(DEVIN_RESUME_VERSION), + sessionId: Schema.String, +}); + +const decodeDevinResume = Schema.decodeUnknownOption(DevinResume); + +function parseDevinResume(raw: unknown): { sessionId: string } | undefined { + const result = decodeDevinResume(raw); + if (Option.isNone(result)) return undefined; + const sessionId = result.value.sessionId.trim(); + if (sessionId.length === 0) return undefined; + return { sessionId }; +} + +function selectPermissionOptionId( + request: EffectAcpSchema.RequestPermissionRequest, + decision: Exclude, +): string | undefined { + const kind = + decision === "acceptForSession" + ? "allow_always" + : decision === "accept" + ? "allow_once" + : "reject_once"; + const option = request.options.find((entry) => entry.kind === kind); + return option?.optionId.trim() || undefined; +} + +function selectAutoApprovedPermissionOption( + request: EffectAcpSchema.RequestPermissionRequest, +): string | undefined { + return ( + selectPermissionOptionId(request, "acceptForSession") ?? + selectPermissionOptionId(request, "accept") + ); +} + +function completedStopReasonFromPromptResponse( + response: EffectAcpSchema.PromptResponse | undefined, +): EffectAcpSchema.StopReason | null { + return response?.stopReason ?? null; +} + +export function devinPromptSettlementBelongsToContext(input: { + readonly liveAcpSessionId: string; + readonly expectedAcpSessionId: string; + readonly liveActiveTurnId: TurnId | undefined; + readonly liveSessionActiveTurnId: TurnId | undefined; + readonly turnId: TurnId; +}): boolean { + return ( + input.liveAcpSessionId === input.expectedAcpSessionId && + (input.liveActiveTurnId === input.turnId || input.liveSessionActiveTurnId === input.turnId) + ); +} + +function finiteNonNegativeInteger(value: unknown): number | undefined { + if (typeof value !== "number" || !Number.isFinite(value)) return undefined; + const int = Math.floor(value); + return int >= 0 ? int : undefined; +} + +function finiteNonNegativeDelta( + current: number | null | undefined, + previous: number | null | undefined, +): number { + const delta = (current ?? 0) - (previous ?? 0); + return Number.isFinite(delta) && delta > 0 ? Math.floor(delta) : 0; +} + +function devinUsageDeltaTotals( + current: EffectAcpSchema.Usage, + previous: EffectAcpSchema.Usage | undefined, +): UsageTokenTotals { + const inputTokens = finiteNonNegativeDelta(current.inputTokens, previous?.inputTokens); + const cachedReadTokens = finiteNonNegativeDelta( + current.cachedReadTokens, + previous?.cachedReadTokens, + ); + const cachedWriteTokens = finiteNonNegativeDelta( + current.cachedWriteTokens, + previous?.cachedWriteTokens, + ); + const outputTokens = finiteNonNegativeDelta(current.outputTokens, previous?.outputTokens); + const thoughtTokens = finiteNonNegativeDelta(current.thoughtTokens, previous?.thoughtTokens); + + // Input tokens reported by Devin are inclusive of any cached read and write + // tokens, matching the other transcript parsers. + const uncachedInputTokens = Math.max(0, inputTokens - cachedReadTokens - cachedWriteTokens); + + return { + uncachedInputTokens, + cachedInputTokens: cachedReadTokens, + cacheCreationTokens: cachedWriteTokens, + outputTokens, + reasoningTokens: Math.min(outputTokens, thoughtTokens), + }; +} + +export function usageFromUsageUpdate( + event: Extract, +): EffectAcpSchema.Usage { + const outputTokens = event.outputTokens ?? 0; + return { + inputTokens: + event.inputTokens ?? + (event.outputTokens !== undefined ? Math.max(0, event.used - outputTokens) : event.used), + outputTokens, + totalTokens: event.used, + cachedReadTokens: event.cachedReadTokens ?? null, + cachedWriteTokens: null, + thoughtTokens: null, + }; +} + +export function isAcpUsageGreaterOrNew( + current: EffectAcpSchema.Usage | undefined, + next: EffectAcpSchema.Usage, +): boolean { + if (!current) return true; + if (next.totalTokens !== current.totalTokens) { + return next.totalTokens > current.totalTokens; + } + return ( + next.inputTokens !== current.inputTokens || + next.outputTokens !== current.outputTokens || + next.cachedReadTokens !== current.cachedReadTokens || + next.cachedWriteTokens !== current.cachedWriteTokens || + next.thoughtTokens !== current.thoughtTokens + ); +} + +interface DevinUsageTranscriptRecord { + readonly timestamp: string; + readonly sessionId: string; + readonly turnId: string; + readonly model: string; + readonly totals: UsageTokenTotals; + readonly reportedCostUsd: number | null; +} + +function writeDevinUsageTranscriptLine( + config: Pick, + record: DevinUsageTranscriptRecord, +): Effect.Effect { + let filePath: string | undefined; + return Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + filePath = yield* resolveDevinUsageTranscriptPath(config); + const line = yield* encodeUnknownJsonString({ + type: "devin_usage", + ...record, + }).pipe( + Effect.map((json) => `${json}\n`), + Effect.orElseSucceed(() => "[unserializable]\n"), + ); + const dir = path.dirname(filePath); + yield* fileSystem.makeDirectory(dir, { recursive: true }); + yield* fileSystem.writeFileString(filePath, line, { flag: "a" }); + return true; + }).pipe( + Effect.catch((error) => + Effect.logWarning("Failed to append Devin usage transcript", { + filePath: filePath ?? "[unknown]", + error: error.message, + }).pipe(Effect.as(false)), + ), + Effect.catchCause(() => Effect.succeed(false)), + ); +} + +export function makeDevinTokenUsageSnapshot( + usage: EffectAcpSchema.Usage | null | undefined, + previous: ThreadTokenUsageSnapshot | undefined, +): ThreadTokenUsageSnapshot | undefined { + if (!usage) { + return undefined; + } + + const inputTokens = finiteNonNegativeInteger(usage.inputTokens); + const outputTokens = finiteNonNegativeInteger(usage.outputTokens); + const totalTokens = finiteNonNegativeInteger(usage.totalTokens); + const usedTokens = + totalTokens !== undefined && totalTokens > 0 + ? totalTokens + : (inputTokens ?? 0) + (outputTokens ?? 0); + + if (usedTokens <= 0) { + return undefined; + } + + const cachedReadTokens = finiteNonNegativeInteger(usage.cachedReadTokens); + const thoughtTokens = finiteNonNegativeInteger(usage.thoughtTokens); + + const contextUsedTokens = previous?.usedTokens ?? usedTokens; + const contextMaxTokens = previous?.maxTokens; + const previousTotalProcessed = previous?.totalProcessedTokens ?? 0; + const lastUsedTokens = Math.max(0, usedTokens - previousTotalProcessed); + + return { + usedTokens: contextUsedTokens, + totalProcessedTokens: usedTokens, + ...(contextMaxTokens !== undefined ? { maxTokens: contextMaxTokens } : {}), + lastUsedTokens, + ...(inputTokens !== undefined && inputTokens > 0 ? { inputTokens } : {}), + ...(outputTokens !== undefined && outputTokens > 0 ? { outputTokens } : {}), + ...(cachedReadTokens !== undefined && cachedReadTokens > 0 + ? { cachedInputTokens: cachedReadTokens } + : {}), + ...(thoughtTokens !== undefined && thoughtTokens > 0 + ? { reasoningOutputTokens: thoughtTokens } + : {}), + }; +} + +export function makeDevinTokenUsageSnapshotFromUsageUpdate( + usage: Extract, + previous: ThreadTokenUsageSnapshot | undefined, +): ThreadTokenUsageSnapshot | undefined { + const usedTokens = + usage.used > 0 ? usage.used : (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0); + + if (usedTokens <= 0) { + return undefined; + } + + const maxTokens = usage.size > 0 ? usage.size : undefined; + + return buildThreadTokenUsageSnapshot({ + usedTokens, + maxTokens, + inputTokens: usage.inputTokens, + outputTokens: usage.outputTokens, + cachedReadTokens: usage.cachedReadTokens, + thoughtTokens: undefined, + previous, + }); +} + +function buildThreadTokenUsageSnapshot(input: { + readonly usedTokens: number; + readonly maxTokens?: number | undefined; + readonly totalProcessedTokens?: number | undefined; + readonly inputTokens: number | undefined; + readonly outputTokens: number | undefined; + readonly cachedReadTokens: number | undefined; + readonly thoughtTokens: number | undefined; + readonly previous: ThreadTokenUsageSnapshot | undefined; +}): ThreadTokenUsageSnapshot { + const previousUsedTokens = input.previous?.usedTokens ?? 0; + const previousTotalProcessed = input.previous?.totalProcessedTokens ?? 0; + + const maxTokens = + input.maxTokens !== undefined && input.maxTokens > 0 ? input.maxTokens : undefined; + + const inputTokens = input.inputTokens ?? 0; + const outputTokens = input.outputTokens ?? 0; + const cachedReadTokens = input.cachedReadTokens ?? 0; + const turnTokens = inputTokens + outputTokens; + const usedDelta = Math.max(0, input.usedTokens - previousUsedTokens); + + const totalProcessedTokens = + input.totalProcessedTokens ?? + (turnTokens > 0 ? previousTotalProcessed + turnTokens : previousTotalProcessed + usedDelta); + + return { + usedTokens: input.usedTokens, + totalProcessedTokens, + ...(maxTokens !== undefined ? { maxTokens } : {}), + lastUsedTokens: usedDelta, + ...(input.inputTokens !== undefined && input.inputTokens > 0 + ? { + inputTokens: input.inputTokens, + lastInputTokens: input.inputTokens, + } + : {}), + ...(input.outputTokens !== undefined && input.outputTokens > 0 + ? { + outputTokens: input.outputTokens, + lastOutputTokens: input.outputTokens, + } + : {}), + ...(input.cachedReadTokens !== undefined && input.cachedReadTokens > 0 + ? { + cachedInputTokens: input.cachedReadTokens, + lastCachedInputTokens: input.cachedReadTokens, + } + : {}), + ...(input.thoughtTokens !== undefined && input.thoughtTokens > 0 + ? { + reasoningOutputTokens: input.thoughtTokens, + lastReasoningOutputTokens: input.thoughtTokens, + } + : {}), + }; +} + +export const makeDevinAdapter = Effect.fn("makeDevinAdapter")(function* ( + devinSettings: DevinSettings, + options?: DevinAdapterLiveOptions, +) { + const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("devin"); + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const serverConfig = yield* Effect.service(ServerConfig); + const crypto = yield* Crypto.Crypto; + const nativeEventLogger = + options?.nativeEventLogger ?? + (options?.nativeEventLogPath !== undefined + ? yield* makeEventNdjsonLogger(options.nativeEventLogPath, { + stream: "native", + }) + : undefined); + const managedNativeEventLogger = + options?.nativeEventLogger === undefined ? nativeEventLogger : undefined; + const makeAcpNativeLoggers = yield* makeAcpNativeLoggerFactory(); + + const sessions = new Map(); + const threadLocksRef = yield* SynchronizedRef.make(new Map()); + const runtimeEventPubSub = yield* PubSub.unbounded(); + + const nowIso = Effect.map(DateTime.now, DateTime.formatIso); + const randomUUIDv4 = crypto.randomUUIDv4.pipe( + Effect.mapError( + (cause) => + new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "crypto/randomUUIDv4", + detail: "Failed to generate Devin runtime identifier.", + cause, + }), + ), + ); + const nextEventId = Effect.map(randomUUIDv4, (id) => EventId.make(id)); + const makeEventStamp = () => Effect.all({ eventId: nextEventId, createdAt: nowIso }); + const mapAcpCallbackFailure = (effect: Effect.Effect) => + effect.pipe( + Effect.mapError( + (cause) => + new EffectAcpErrors.AcpTransportError({ + detail: "Failed to process Devin ACP callback.", + cause, + }), + ), + ); + + const offerRuntimeEvent = (event: ProviderRuntimeEvent) => + PubSub.publish(runtimeEventPubSub, event).pipe(Effect.asVoid); + + const getThreadSemaphore = (threadId: string) => + SynchronizedRef.modifyEffect(threadLocksRef, (current) => { + const existing: Option.Option = Option.fromNullishOr( + current.get(threadId), + ); + return Option.match(existing, { + onNone: () => + Semaphore.make(1).pipe( + Effect.map((semaphore) => { + const next = new Map(current); + next.set(threadId, semaphore); + return [semaphore, next] as const; + }), + ), + onSome: (semaphore) => Effect.succeed([semaphore, current] as const), + }); + }); + + const withThreadLock = (threadId: string, effect: Effect.Effect) => + Effect.flatMap(getThreadSemaphore(threadId), (semaphore) => semaphore.withPermit(effect)); + + const settlePromptInFlight = ( + threadId: ThreadId, + turnId: TurnId, + expectedAcpSessionId: string, + options?: { + readonly errorMessage?: string; + readonly completedStopReason?: EffectAcpSchema.StopReason | null; + readonly emitTurnCompletion?: boolean; + /** Interrupt/cancel: drop every outstanding prompt slot and settle once. */ + readonly settleAllPrompts?: boolean; + }, + ) => + Effect.gen(function* () { + const liveCtx = sessions.get(threadId); + if (!liveCtx) { + return; + } + const settlementBelongsToLiveContext = devinPromptSettlementBelongsToContext({ + liveAcpSessionId: liveCtx.acpSessionId, + expectedAcpSessionId, + liveActiveTurnId: liveCtx.activeTurnId, + liveSessionActiveTurnId: liveCtx.session.activeTurnId, + turnId, + }); + if (!settlementBelongsToLiveContext) { + // interruptTurn already consumed every prompt slot for this turn. A + // late prompt result must neither emit a second terminal event nor + // consume a slot belonging to a newer turn on the same ACP session. + if ( + liveCtx.acpSessionId !== expectedAcpSessionId || + liveCtx.interruptedTurnIds.has(turnId) + ) { + return; + } + if (options?.emitTurnCompletion !== false) { + if (options?.errorMessage !== undefined) { + yield* offerRuntimeEvent({ + type: "turn.completed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId, + turnId, + payload: { + state: "failed", + errorMessage: options.errorMessage, + }, + }); + } else if (options?.completedStopReason !== undefined) { + yield* offerRuntimeEvent({ + type: "turn.completed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId, + turnId, + payload: { + state: options.completedStopReason === "cancelled" ? "cancelled" : "completed", + stopReason: options.completedStopReason ?? null, + }, + }); + } + } + return; + } + let settleTurnId = turnId; + if (options?.settleAllPrompts) { + liveCtx.promptsInFlight = 0; + if (liveCtx.activeTurnId !== turnId && liveCtx.session.activeTurnId !== turnId) { + const fallbackTurnId = liveCtx.activeTurnId ?? liveCtx.session.activeTurnId; + if (!fallbackTurnId) { + if (liveCtx.session.status === "running" || liveCtx.session.status === "connecting") { + const updatedAt = yield* nowIso; + const { activeTurnId: _activeTurnId, ...readySession } = liveCtx.session; + liveCtx.activeTurnId = undefined; + liveCtx.session = { + ...readySession, + status: "ready", + updatedAt, + }; + } + return; + } + settleTurnId = fallbackTurnId; + } + } else { + const remainingPrompts = Math.max(0, liveCtx.promptsInFlight - 1); + if ( + remainingPrompts > 0 || + liveCtx.activeTurnId !== settleTurnId || + liveCtx.session.activeTurnId !== settleTurnId + ) { + liveCtx.promptsInFlight = remainingPrompts; + return; + } + liveCtx.promptsInFlight = remainingPrompts; + } + const updatedAt = yield* nowIso; + const canEmitTurnCompletion = + liveCtx.session.status === "running" || liveCtx.session.status === "connecting"; + const shouldEmitFailedTurn = options?.errorMessage !== undefined && canEmitTurnCompletion; + const shouldEmitCompletedTurn = + options?.completedStopReason !== undefined && canEmitTurnCompletion; + const { activeTurnId: _activeTurnId, ...readySession } = liveCtx.session; + liveCtx.activeTurnId = undefined; + liveCtx.session = { + ...readySession, + status: "ready", + updatedAt, + }; + if (options?.emitTurnCompletion === false) { + return; + } + if (shouldEmitFailedTurn) { + yield* offerRuntimeEvent({ + type: "turn.completed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId, + turnId: settleTurnId, + payload: { + state: "failed", + errorMessage: options.errorMessage, + }, + }); + } else if (shouldEmitCompletedTurn) { + yield* offerRuntimeEvent({ + type: "turn.completed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId, + turnId: settleTurnId, + payload: { + state: options.completedStopReason === "cancelled" ? "cancelled" : "completed", + stopReason: options.completedStopReason ?? null, + }, + }); + } + }); + + const logNative = (threadId: ThreadId, method: string, payload: unknown) => + Effect.gen(function* () { + if (!nativeEventLogger) return; + const observedAt = yield* nowIso; + yield* nativeEventLogger.write( + { + observedAt, + event: { + id: yield* randomUUIDv4, + kind: "notification", + provider: PROVIDER, + createdAt: observedAt, + method, + threadId, + payload, + }, + }, + threadId, + ); + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to write native Devin notification log.", { + cause, + threadId, + method, + }), + ), + ); + + const emitPlanUpdate = ( + ctx: DevinSessionContext, + turnId: TurnId | undefined, + stamp: { readonly eventId: EventId; readonly createdAt: string }, + payload: { + readonly explanation?: string | null; + readonly plan: ReadonlyArray<{ + readonly step: string; + readonly status: "pending" | "inProgress" | "completed"; + }>; + }, + rawPayload: unknown, + method: string, + ) => + Effect.gen(function* () { + const fingerprint = `${turnId ?? "no-turn"}:${encodeJsonStringForDiagnostics(payload) ?? "[unserializable payload]"}`; + if (ctx.lastPlanFingerprint === fingerprint) { + return; + } + ctx.lastPlanFingerprint = fingerprint; + yield* offerRuntimeEvent( + makeAcpPlanUpdatedEvent({ + stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId, + payload, + source: "acp.jsonrpc", + method, + rawPayload, + }), + ); + }); + + const requireSession = ( + threadId: ThreadId, + ): Effect.Effect => { + const ctx = sessions.get(threadId); + if (!ctx || ctx.stopped) { + return Effect.fail( + new ProviderAdapterSessionNotFoundError({ + provider: PROVIDER, + threadId, + }), + ); + } + return Effect.succeed(ctx); + }; + + const stopSessionInternal = (ctx: DevinSessionContext) => + Effect.uninterruptible( + Effect.gen(function* () { + if (ctx.stopped) return; + ctx.stopped = true; + yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals); + yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs); + if (ctx.notificationFiber) { + yield* Fiber.interrupt(ctx.notificationFiber); + } + yield* Effect.ignore(Scope.close(ctx.scope, Exit.void)); + sessions.delete(ctx.threadId); + yield* offerRuntimeEvent({ + type: "session.exited", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: ctx.threadId, + payload: { exitKind: "graceful" }, + }); + }), + ); + + const startSession: DevinAdapterShape["startSession"] = (input) => + withThreadLock( + input.threadId, + Effect.gen(function* () { + if (input.provider !== undefined && input.provider !== PROVIDER) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "startSession", + issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`, + }); + } + if (!input.cwd?.trim()) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "startSession", + issue: "cwd is required and must be non-empty.", + }); + } + + const cwd = path.resolve(input.cwd.trim()); + const devinModelSelection = + input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : undefined; + const existing = sessions.get(input.threadId); + if (existing && !existing.stopped) { + yield* stopSessionInternal(existing); + } + + const pendingApprovals = new Map(); + const pendingUserInputs = new Map(); + const sessionScope = yield* Scope.make("sequential"); + let sessionScopeTransferred = false; + yield* Effect.addFinalizer(() => + sessionScopeTransferred ? Effect.void : Scope.close(sessionScope, Exit.void), + ); + + const resumeSessionId = parseDevinResume(input.resumeCursor)?.sessionId; + const acpNativeLoggers = makeAcpNativeLoggers({ + nativeEventLogger, + provider: PROVIDER, + threadId: input.threadId, + }); + + const mcpSession = McpProviderSession.readMcpProviderSession(input.threadId); + const acp = yield* makeDevinAcpRuntime({ + devinSettings, + ...(options?.environment ? { environment: options.environment } : {}), + childProcessSpawner, + cwd, + ...(resumeSessionId ? { resumeSessionId } : {}), + clientInfo: { name: "t3-code", version: "0.0.0" }, + ...(mcpSession + ? { + mcpServers: [ + { + type: "http" as const, + name: "t3-code", + url: mcpSession.endpoint, + headers: [ + { + name: "Authorization", + value: mcpSession.authorizationHeader, + }, + ], + }, + ], + } + : {}), + ...acpNativeLoggers, + }).pipe( + Effect.provideService(Crypto.Crypto, crypto), + Effect.provideService(Scope.Scope, sessionScope), + Effect.mapError( + (cause) => + new ProviderAdapterProcessError({ + provider: PROVIDER, + threadId: input.threadId, + detail: cause.message, + cause, + }), + ), + ); + const started = yield* Effect.gen(function* () { + yield* acp.handleRequestPermission((params) => + mapAcpCallbackFailure( + Effect.gen(function* () { + yield* logNative(input.threadId, "session/request_permission", params); + if (input.runtimeMode === "full-access") { + const autoApprovedOptionId = selectAutoApprovedPermissionOption(params); + if (autoApprovedOptionId !== undefined) { + return { + outcome: { + outcome: "selected" as const, + optionId: autoApprovedOptionId, + }, + }; + } + } + const permissionRequest = parsePermissionRequest(params); + const requestId = ApprovalRequestId.make(yield* randomUUIDv4); + const runtimeRequestId = RuntimeRequestId.make(requestId); + const decision = yield* Deferred.make(); + const turnId = resolveSessionCallbackTurnId(sessions, input.threadId); + pendingApprovals.set(requestId, { decision }); + yield* offerRuntimeEvent( + makeAcpRequestOpenedEvent({ + stamp: yield* makeEventStamp(), + provider: PROVIDER, + threadId: input.threadId, + turnId, + requestId: runtimeRequestId, + permissionRequest, + detail: + permissionRequest.detail ?? + encodeJsonStringForDiagnostics(params)?.slice(0, 2000) ?? + "[unserializable params]", + args: params, + source: "acp.jsonrpc", + method: "session/request_permission", + rawPayload: params, + }), + ); + const resolved = yield* Deferred.await(decision); + pendingApprovals.delete(requestId); + yield* offerRuntimeEvent( + makeAcpRequestResolvedEvent({ + stamp: yield* makeEventStamp(), + provider: PROVIDER, + threadId: input.threadId, + turnId, + requestId: runtimeRequestId, + permissionRequest, + decision: resolved, + }), + ); + const selectedOptionId = + resolved === "cancel" ? undefined : selectPermissionOptionId(params, resolved); + return { + outcome: selectedOptionId + ? { + outcome: "selected" as const, + optionId: selectedOptionId, + } + : ({ outcome: "cancelled" } as const), + }; + }), + ), + ); + const started = yield* acp.start(); + return started; + }).pipe( + Effect.mapError((error) => + mapAcpToAdapterError(PROVIDER, input.threadId, "session/start", error), + ), + ); + + const requestedStartModel = resolveDevinAcpModelSelection(devinModelSelection); + const boundModel = yield* applyDevinAcpModelSelection({ + runtime: acp, + current: currentDevinAcpModelSelection(started.sessionSetupResult), + requested: requestedStartModel, + configOptions: started.sessionSetupResult.configOptions ?? [], + mapError: (cause) => + mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_config_option", cause), + }); + + const now = yield* nowIso; + const sessionModel = + boundModel?.familySlug ?? resolveDevinAcpBaseModelId(devinModelSelection?.model); + const session: ProviderSession = { + provider: PROVIDER, + providerInstanceId: boundInstanceId, + status: "ready", + runtimeMode: input.runtimeMode, + cwd, + ...(sessionModel ? { model: sessionModel } : {}), + threadId: input.threadId, + resumeCursor: { + schemaVersion: DEVIN_RESUME_VERSION, + sessionId: started.sessionId, + }, + createdAt: now, + updatedAt: now, + }; + + const ctx: DevinSessionContext = { + threadId: input.threadId, + acpSessionId: started.sessionId, + session, + sessionSetupResult: started.sessionSetupResult, + scope: sessionScope, + acp, + notificationFiber: undefined, + pendingApprovals, + pendingUserInputs, + turns: [], + lastPlanFingerprint: undefined, + activeTurnId: undefined, + interruptedTurnIds: new Set(), + promptsInFlight: 0, + currentModelId: boundModel?.familySlug, + currentReasoningValue: boundModel?.reasoningValue, + stopped: false, + lastKnownTokenUsage: undefined, + lastAcpUsage: undefined, + lastWrittenAcpUsage: undefined, + }; + + const nf = yield* Stream.runDrain( + Stream.mapEffect(acp.getEvents(), (event) => + Effect.gen(function* () { + if (event._tag === "EventStreamBarrier") { + yield* Deferred.succeed(event.acknowledge, undefined); + return; + } + if ( + event._tag === "PlanUpdated" || + event._tag === "ToolCallUpdated" || + event._tag === "ContentDelta" + ) { + yield* logNative(ctx.threadId, "session/update", event.rawPayload); + } + + if (event._tag === "ModeChanged") { + return; + } + + const notificationTurnId = resolveNotificationTurnId(ctx); + if ( + notificationTurnId === undefined || + ctx.interruptedTurnIds.has(notificationTurnId) + ) { + return; + } + const stamp = yield* makeEventStamp(); + + switch (event._tag) { + case "AssistantItemStarted": + yield* offerRuntimeEvent( + makeAcpAssistantItemEvent({ + stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId: notificationTurnId, + itemId: event.itemId, + lifecycle: "item.started", + }), + ); + return; + case "AssistantItemCompleted": + yield* offerRuntimeEvent( + makeAcpAssistantItemEvent({ + stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId: notificationTurnId, + itemId: event.itemId, + lifecycle: "item.completed", + }), + ); + return; + case "PlanUpdated": + yield* emitPlanUpdate( + ctx, + notificationTurnId, + stamp, + event.payload, + event.rawPayload, + "session/update", + ); + return; + case "ToolCallUpdated": + yield* offerRuntimeEvent( + makeAcpToolCallEvent({ + stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId: notificationTurnId, + toolCall: event.toolCall, + rawPayload: event.rawPayload, + }), + ); + return; + case "ContentDelta": + yield* offerRuntimeEvent( + makeAcpContentDeltaEvent({ + stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId: notificationTurnId, + ...(event.itemId ? { itemId: event.itemId } : {}), + text: event.text, + rawPayload: event.rawPayload, + }), + ); + return; + case "UsageUpdated": { + const tokenUsage = makeDevinTokenUsageSnapshotFromUsageUpdate( + event, + ctx.lastKnownTokenUsage, + ); + if (!tokenUsage) { + return; + } + ctx.lastKnownTokenUsage = tokenUsage; + + const acpUsage = usageFromUsageUpdate(event); + if (isAcpUsageGreaterOrNew(ctx.lastAcpUsage, acpUsage)) { + ctx.lastAcpUsage = acpUsage; + } + + yield* offerRuntimeEvent({ + type: "thread.token-usage.updated", + ...stamp, + provider: PROVIDER, + threadId: ctx.threadId, + turnId: notificationTurnId, + payload: { usage: tokenUsage }, + }); + return; + } + } + }), + ), + ).pipe( + Effect.catch((cause) => + Effect.logError("Failed to process Devin runtime notification.", { + cause, + }), + ), + Effect.forkIn(sessionScope), + ); + + ctx.notificationFiber = nf; + sessions.set(input.threadId, ctx); + sessionScopeTransferred = true; + + yield* offerRuntimeEvent({ + type: "session.started", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + payload: { resume: started.initializeResult }, + }); + yield* offerRuntimeEvent({ + type: "session.state.changed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + payload: { state: "ready", reason: "Devin ACP session ready" }, + }); + yield* offerRuntimeEvent({ + type: "thread.started", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + payload: { providerThreadId: started.sessionId }, + }); + + return session; + }).pipe(Effect.scoped), + ); + + const sendTurn: DevinAdapterShape["sendTurn"] = (input) => + Effect.gen(function* () { + const prepared = yield* withThreadLock( + input.threadId, + Effect.gen(function* () { + const ctx = yield* requireSession(input.threadId); + // A sendTurn while a prompt is in flight is a steer: the agent + // folds the new prompt into the ongoing work, so the active turn + // id is reused instead of opening a new turn. + const steeringTurnId = ctx.promptsInFlight > 0 ? ctx.activeTurnId : undefined; + const turnId = steeringTurnId ?? TurnId.make(yield* randomUUIDv4); + // Count this prompt immediately so a superseded in-flight prompt + // resolving from here on does not settle the turn; decremented on + // preparation failure here, and after the prompt below otherwise. + ctx.promptsInFlight += 1; + // Bind the turn id before cooperative yields so interruptTurn can + // settle this prompt even if stop arrives during preparation. + ctx.activeTurnId = turnId; + ctx.session = { + ...ctx.session, + status: steeringTurnId === undefined ? "connecting" : "running", + activeTurnId: turnId, + updatedAt: yield* nowIso, + }; + + return yield* Effect.gen(function* () { + const text = input.input?.trim(); + const imagePromptParts = yield* Effect.forEach(input.attachments ?? [], (attachment) => + Effect.gen(function* () { + const attachmentPath = resolveAttachmentPath({ + attachmentsDir: serverConfig.attachmentsDir, + attachment, + }); + if (!attachmentPath) { + return yield* new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "session/prompt", + detail: `Invalid attachment id '${attachment.id}'.`, + }); + } + const bytes = yield* fileSystem.readFile(attachmentPath).pipe( + Effect.mapError( + (cause) => + new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "session/prompt", + detail: cause.message, + cause, + }), + ), + ); + return { + type: "image", + data: Buffer.from(bytes).toString("base64"), + mimeType: attachment.mimeType, + } satisfies EffectAcpSchema.ContentBlock; + }), + ); + const promptParts: Array = [ + ...(text ? [{ type: "text" as const, text }] : []), + ...imagePromptParts, + ]; + + if (promptParts.length === 0) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "sendTurn", + issue: "Turn requires non-empty text or attachments.", + }); + } + + const turnModelSelection = + input.modelSelection?.instanceId === boundInstanceId + ? input.modelSelection + : undefined; + const requestedTurnModel = resolveDevinAcpModelSelection(turnModelSelection); + const currentModel = yield* applyDevinAcpModelSelection({ + runtime: ctx.acp, + current: + ctx.currentModelId === undefined + ? undefined + : { + familySlug: ctx.currentModelId, + reasoningValue: ctx.currentReasoningValue, + }, + requested: requestedTurnModel, + configOptions: ctx.sessionSetupResult.configOptions ?? [], + mapError: (cause) => + mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_config_option", cause), + }); + + ctx.currentModelId = currentModel?.familySlug; + ctx.currentReasoningValue = currentModel?.reasoningValue; + const displayModel = + (turnModelSelection?.model ?? currentModel?.familySlug) + ? resolveDevinAcpBaseModelId( + turnModelSelection?.model ?? currentModel?.familySlug ?? undefined, + ) + : undefined; + for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) { + yield* Effect.yieldNow; + } + if (ctx.interruptedTurnIds.has(turnId)) { + yield* settlePromptInFlight(input.threadId, turnId, ctx.acpSessionId, { + completedStopReason: "cancelled", + emitTurnCompletion: false, + settleAllPrompts: true, + }); + return yield* new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "session/prompt", + detail: "Devin prompt was interrupted during preparation.", + }); + } + if (steeringTurnId === undefined) { + ctx.lastPlanFingerprint = undefined; + } + ctx.session = { + ...ctx.session, + status: "running", + activeTurnId: turnId, + updatedAt: yield* nowIso, + ...(displayModel ? { model: displayModel } : {}), + }; + + if (steeringTurnId === undefined) { + yield* offerRuntimeEvent({ + type: "turn.started", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + turnId, + payload: displayModel ? { model: displayModel } : {}, + }); + } + + return { + acp: ctx.acp, + acpSessionId: ctx.acpSessionId, + displayModel, + promptParts, + turnId, + }; + }).pipe( + Effect.tapCause(() => + Effect.gen(function* () { + const liveCtx = sessions.get(input.threadId); + if (!liveCtx) { + return; + } + yield* settlePromptInFlight(input.threadId, turnId, liveCtx.acpSessionId, { + errorMessage: "Devin prompt preparation failed.", + emitTurnCompletion: false, + }); + }), + ), + ); + }), + ); + const promptSettled = yield* Ref.make(false); + const promptRpcSucceeded = yield* Ref.make(false); + const promptResultRef = yield* Ref.make( + undefined, + ); + + const promptFailureMessageRef = yield* Ref.make(undefined); + + return yield* Effect.gen(function* () { + const result = yield* prepared.acp + .prompt({ + prompt: prepared.promptParts, + }) + .pipe( + Effect.tap((promptResult) => + Effect.all([ + Ref.set(promptRpcSucceeded, true), + Ref.set(promptResultRef, promptResult), + ]), + ), + Effect.tapError((error) => + Ref.set( + promptFailureMessageRef, + mapAcpToAdapterError(PROVIDER, input.threadId, "session/prompt", error).message, + ).pipe(Effect.andThen(prepared.acp.drainEvents)), + ), + Effect.mapError((error) => + mapAcpToAdapterError(PROVIDER, input.threadId, "session/prompt", error), + ), + ); + + return yield* withThreadLock( + input.threadId, + Effect.gen(function* () { + const ctx = yield* requireSession(input.threadId); + if (ctx.acpSessionId !== prepared.acpSessionId) { + yield* settlePromptInFlight(input.threadId, prepared.turnId, prepared.acpSessionId, { + errorMessage: "Devin session changed before the turn completed.", + settleAllPrompts: true, + }); + yield* Ref.set(promptSettled, true); + return yield* new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "session/prompt", + detail: "Devin session changed before the turn completed.", + }); + } + // Keep prompt settlement atomic with respect to Stop and steering. + // interruptTurn marks its target before waiting for this lock, so + // cancellation can still win while queued ACP events are drained. + for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) { + yield* Effect.yieldNow; + } + yield* prepared.acp.drainEvents; + if (ctx.interruptedTurnIds.has(prepared.turnId)) { + yield* Ref.set(promptSettled, true); + return { + threadId: input.threadId, + turnId: prepared.turnId, + resumeCursor: ctx.session.resumeCursor, + }; + } + + if ( + ctx.promptsInFlight <= 0 || + ctx.activeTurnId !== prepared.turnId || + ctx.session.activeTurnId !== prepared.turnId + ) { + yield* Ref.set(promptSettled, true); + return { + threadId: input.threadId, + turnId: prepared.turnId, + resumeCursor: ctx.session.resumeCursor, + }; + } + + appendPromptResultToTurn(ctx, prepared.turnId, prepared.promptParts, result); + + const usage = result.usage ?? ctx.lastAcpUsage; + if (usage && isAcpUsageGreaterOrNew(ctx.lastAcpUsage, usage)) { + ctx.lastAcpUsage = usage; + } + + const tokenUsage = result.usage + ? makeDevinTokenUsageSnapshot(result.usage, ctx.lastKnownTokenUsage) + : undefined; + if (tokenUsage && result.usage) { + ctx.lastKnownTokenUsage = tokenUsage; + yield* offerRuntimeEvent({ + type: "thread.token-usage.updated", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + turnId: prepared.turnId, + payload: { usage: tokenUsage }, + }); + } + + if (usage) { + const deltaTotals = devinUsageDeltaTotals(usage, ctx.lastWrittenAcpUsage); + const totalDeltaTokens = + deltaTotals.uncachedInputTokens + + deltaTotals.cachedInputTokens + + deltaTotals.cacheCreationTokens + + deltaTotals.outputTokens; + + if (totalDeltaTokens > 0) { + const observedAt = yield* nowIso; + const usageModel = prepared.displayModel ?? ctx.session.model ?? "adaptive"; + const written = yield* writeDevinUsageTranscriptLine(devinSettings, { + timestamp: observedAt, + sessionId: ctx.acpSessionId, + turnId: prepared.turnId, + model: usageModel, + totals: deltaTotals, + reportedCostUsd: null, + }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + ); + if (written) { + ctx.lastWrittenAcpUsage = usage; + } + } + } + + ctx.session = { + ...ctx.session, + status: "running", + activeTurnId: prepared.turnId, + updatedAt: yield* nowIso, + ...(prepared.displayModel ? { model: prepared.displayModel } : {}), + }; + const remainingPrompts = Math.max(0, ctx.promptsInFlight - 1); + ctx.promptsInFlight = remainingPrompts; + + // Only the last remaining prompt settles the turn. A steer- + // superseded prompt resolving while another is in flight or + // pending must leave the merged turn running. + if ( + remainingPrompts === 0 && + ctx.activeTurnId === prepared.turnId && + ctx.session.activeTurnId === prepared.turnId + ) { + if (ctx.interruptedTurnIds.has(prepared.turnId)) { + yield* Ref.set(promptSettled, true); + return { + threadId: input.threadId, + turnId: prepared.turnId, + resumeCursor: ctx.session.resumeCursor, + }; + } + const completedAt = yield* nowIso; + const { activeTurnId: _completedTurnId, ...readySession } = ctx.session; + ctx.activeTurnId = undefined; + ctx.session = { + ...readySession, + status: "ready", + updatedAt: completedAt, + ...(prepared.displayModel ? { model: prepared.displayModel } : {}), + }; + const completedStopReason = completedStopReasonFromPromptResponse(result); + yield* offerRuntimeEvent({ + type: "turn.completed", + ...(yield* makeEventStamp()), + provider: PROVIDER, + threadId: input.threadId, + turnId: prepared.turnId, + payload: { + state: result.stopReason === "cancelled" ? "cancelled" : "completed", + stopReason: completedStopReason, + }, + }); + ctx.interruptedTurnIds.delete(prepared.turnId); + yield* Ref.set(promptSettled, true); + } else if (remainingPrompts > 0) { + yield* Ref.set(promptSettled, true); + } + + return { + threadId: input.threadId, + turnId: prepared.turnId, + resumeCursor: ctx.session.resumeCursor, + }; + }), + ); + }).pipe( + Effect.ensuring( + Effect.gen(function* () { + if (yield* Ref.get(promptSettled)) { + return; + } + + if (yield* Ref.get(promptRpcSucceeded)) { + const promptResult = yield* Ref.get(promptResultRef); + if (promptResult === undefined) { + return; + } + yield* withThreadLock( + input.threadId, + Effect.gen(function* () { + const ctx = yield* requireSession(input.threadId); + if (ctx.acpSessionId !== prepared.acpSessionId) { + yield* settlePromptInFlight( + input.threadId, + prepared.turnId, + prepared.acpSessionId, + { + errorMessage: "Devin session changed before the turn completed.", + settleAllPrompts: true, + }, + ); + return; + } + if (ctx.interruptedTurnIds.has(prepared.turnId)) { + return; + } + if ( + ctx.promptsInFlight <= 0 || + ctx.activeTurnId !== prepared.turnId || + ctx.session.activeTurnId !== prepared.turnId + ) { + return; + } + appendPromptResultToTurn( + ctx, + prepared.turnId, + prepared.promptParts, + promptResult, + ); + yield* settlePromptInFlight( + input.threadId, + prepared.turnId, + prepared.acpSessionId, + { + completedStopReason: completedStopReasonFromPromptResponse(promptResult), + }, + ); + }), + ); + return; + } + + const errorMessage = yield* Ref.get(promptFailureMessageRef); + yield* withThreadLock( + input.threadId, + settlePromptInFlight(input.threadId, prepared.turnId, prepared.acpSessionId, { + errorMessage: errorMessage ?? "Devin prompt request failed.", + }), + ); + }).pipe(Effect.catch(() => Effect.void)), + ), + ); + }); + + const interruptTurn: DevinAdapterShape["interruptTurn"] = (threadId, turnId) => + Effect.gen(function* () { + const observed = yield* Effect.sync(() => { + const ctx = sessions.get(threadId); + if (!ctx || ctx.stopped) { + return { + _tag: "Proceed" as const, + acpSessionId: undefined, + interruptedTurnId: turnId, + }; + } + const activeTurnId = ctx.activeTurnId ?? ctx.session.activeTurnId; + if (turnId !== undefined && activeTurnId !== undefined && activeTurnId !== turnId) { + return { _tag: "Ignore" as const }; + } + const interruptedTurnId = turnId ?? activeTurnId; + if (interruptedTurnId !== undefined) { + ctx.interruptedTurnIds.add(interruptedTurnId); + } + return { + _tag: "Proceed" as const, + acpSessionId: ctx.acpSessionId, + interruptedTurnId, + }; + }); + if (observed._tag === "Ignore") { + return; + } + + yield* withThreadLock( + threadId, + Effect.gen(function* () { + const ctx = yield* requireSession(threadId); + if (observed.acpSessionId !== undefined && ctx.acpSessionId !== observed.acpSessionId) { + return; + } + const activeTurnId = ctx.activeTurnId ?? ctx.session.activeTurnId; + if (turnId !== undefined && activeTurnId !== undefined && activeTurnId !== turnId) { + return; + } + if ( + observed.interruptedTurnId !== undefined && + activeTurnId !== undefined && + activeTurnId !== observed.interruptedTurnId + ) { + return; + } + const interruptedTurnId = + observed.interruptedTurnId ?? turnId ?? activeTurnId ?? ctx.session.activeTurnId; + yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals); + yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs); + yield* Effect.ignore( + ctx.acp.cancel.pipe( + Effect.mapError((error) => + mapAcpToAdapterError(PROVIDER, threadId, "session/cancel", error), + ), + ), + ); + if (interruptedTurnId) { + ctx.interruptedTurnIds.add(interruptedTurnId); + yield* settlePromptInFlight(threadId, interruptedTurnId, ctx.acpSessionId, { + completedStopReason: "cancelled", + settleAllPrompts: true, + }); + } else if ( + ctx.promptsInFlight > 0 || + ctx.session.status === "running" || + ctx.session.status === "connecting" + ) { + const updatedAt = yield* nowIso; + ctx.promptsInFlight = 0; + ctx.activeTurnId = undefined; + const { activeTurnId: _activeTurnId, ...readySession } = ctx.session; + ctx.session = { + ...readySession, + status: "ready", + updatedAt, + }; + } + }), + ); + }); + + const respondToRequest: DevinAdapterShape["respondToRequest"] = (threadId, requestId, decision) => + Effect.gen(function* () { + const ctx = yield* requireSession(threadId); + const pending = ctx.pendingApprovals.get(requestId); + if (!pending) { + return yield* new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "session/request_permission", + detail: `Unknown pending approval request: ${requestId}`, + }); + } + yield* Deferred.succeed(pending.decision, decision); + }); + + const respondToUserInput: DevinAdapterShape["respondToUserInput"] = ( + threadId, + requestId, + answers, + ) => + Effect.gen(function* () { + const ctx = yield* requireSession(threadId); + const pending = ctx.pendingUserInputs.get(requestId); + if (!pending) { + return yield* new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "user-input", + detail: `Unknown pending user-input request: ${requestId}`, + }); + } + yield* Deferred.succeed(pending.resolution, { + _tag: "answered", + answers, + }); + }); + + const readThread: DevinAdapterShape["readThread"] = (threadId) => + Effect.gen(function* () { + const ctx = yield* requireSession(threadId); + return { threadId, turns: ctx.turns }; + }); + + const rollbackThread: DevinAdapterShape["rollbackThread"] = (threadId, numTurns) => + Effect.gen(function* () { + yield* requireSession(threadId); + if (!Number.isInteger(numTurns) || numTurns < 1) { + return yield* new ProviderAdapterValidationError({ + provider: PROVIDER, + operation: "rollbackThread", + issue: "numTurns must be an integer >= 1.", + }); + } + return yield* new ProviderAdapterRequestError({ + provider: PROVIDER, + method: "thread/rollback", + detail: "Devin ACP sessions do not support provider-side rollback yet.", + }); + }); + + const stopSession: DevinAdapterShape["stopSession"] = (threadId) => + withThreadLock( + threadId, + Effect.gen(function* () { + const ctx = yield* requireSession(threadId); + yield* stopSessionInternal(ctx); + }), + ); + + const listSessions: DevinAdapterShape["listSessions"] = () => + Effect.sync(() => Array.from(sessions.values(), (c) => ({ ...c.session }))); + + const hasSession: DevinAdapterShape["hasSession"] = (threadId) => + Effect.sync(() => { + const c = sessions.get(threadId); + return c !== undefined && !c.stopped; + }); + + const stopAll: DevinAdapterShape["stopAll"] = () => + Effect.forEach(Array.from(sessions.values()), stopSessionInternal, { + discard: true, + }); + + yield* Effect.addFinalizer(() => + Effect.ignore(stopAll()).pipe( + Effect.tap(() => PubSub.shutdown(runtimeEventPubSub)), + Effect.tap(() => managedNativeEventLogger?.close() ?? Effect.void), + ), + ); + + const streamEvents = Stream.fromPubSub(runtimeEventPubSub); + + return { + provider: PROVIDER, + capabilities: { sessionModelSwitch: "in-session" }, + startSession, + sendTurn, + interruptTurn, + readThread, + rollbackThread, + respondToRequest, + respondToUserInput, + stopSession, + listSessions, + hasSession, + stopAll, + streamEvents, + } satisfies DevinAdapterShape; +}); diff --git a/apps/server/src/provider/Layers/DevinProvider.smoke.test.ts b/apps/server/src/provider/Layers/DevinProvider.smoke.test.ts new file mode 100644 index 000000000000..cce95d575e33 --- /dev/null +++ b/apps/server/src/provider/Layers/DevinProvider.smoke.test.ts @@ -0,0 +1,35 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; +import { DevinSettings } from "@t3tools/contracts"; + +import { checkDevinProviderStatus } from "./DevinProvider.ts"; + +const decodeDevinSettings = Schema.decodeSync(DevinSettings); + +const settings = decodeDevinSettings({}); + +it.layer(NodeServices.layer)("DevinProvider smoke", (it) => { + it.effect("validates a real Devin CLI when installed and authenticated", () => + Effect.gen(function* () { + const snapshot = yield* checkDevinProviderStatus(settings).pipe(Effect.timeout(60_000)); + + if (!snapshot.installed) { + yield* Effect.logWarning("Devin CLI not available on PATH; skipping smoke test."); + return; + } + + if (snapshot.status !== "ready") { + yield* Effect.logWarning( + `Devin CLI installed but status is ${snapshot.status}; skipping smoke test.`, + ); + return; + } + + yield* Effect.sync(() => { + expect(snapshot.models.length).toBeGreaterThan(0); + }); + }), + ); +}); diff --git a/apps/server/src/provider/Layers/DevinProvider.test.ts b/apps/server/src/provider/Layers/DevinProvider.test.ts new file mode 100644 index 000000000000..6dba23530de4 --- /dev/null +++ b/apps/server/src/provider/Layers/DevinProvider.test.ts @@ -0,0 +1,732 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodePath from "node:path"; + +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { describe, expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; +import { DevinSettings } from "@t3tools/contracts"; +import { createModelCapabilities } from "@t3tools/shared/model"; +import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; + +import { + buildInitialDevinProviderSnapshot, + checkDevinProviderStatus, + deduplicateDevinProviderModels, + parseDevinModelsList, +} from "./DevinProvider.ts"; + +const decodeDevinSettings = Schema.decodeSync(DevinSettings); +const emptyCapabilities = createModelCapabilities({ optionDescriptors: [] }); + +function isWindows(platform: string) { + return platform === "win32"; +} + +function makeMockDevinScript( + fs: FileSystem.FileSystem, + path: Path.Path, + dir: string, + content: string, + platform: string, +) { + const devinPath = isWindows(platform) ? path.join(dir, "devin.cmd") : path.join(dir, "devin"); + return Effect.gen(function* () { + yield* fs.writeFileString(devinPath, content); + if (!isWindows(platform)) { + yield* fs.chmod(devinPath, 0o755); + } + return devinPath; + }); +} + +function mockVersionScript(platform: string, secretStderr: string, exitCode: number) { + if (isWindows(platform)) { + return `@echo off\necho ${secretStderr} >&2\nexit /b ${exitCode}\n`; + } + return ["#!/bin/sh", `printf "%s\\n" "${secretStderr}" >&2`, `exit ${exitCode}`, ""].join("\n"); +} + +function mockModelsListScript(platform: string) { + if (isWindows(platform)) { + return [ + "@echo off", + 'if "%1" == "models" if "%2" == "list" if "%3" == "--format" if "%4" == "json" (', + ' echo [{"family_label": "Adaptive", "slug": "adaptive"}]', + " exit /b 0", + ")", + "echo devin-cli 0.0.99", + "exit /b 0", + "", + ].join("\n"); + } + return [ + "#!/bin/sh", + 'if [ "$1" = "models" ] && [ "$2" = "list" ] && [ "$3" = "--format" ] && [ "$4" = "json" ]; then', + ' printf "[{\\\"family_label\\\": \\\"Adaptive\\\", \\\"slug\\\": \\\"adaptive\\\"}]\\n"', + " exit 0", + "fi", + 'printf "devin-cli 0.0.99\\n"', + "exit 0", + "", + ].join("\n"); +} + +function mockModelsListScriptWithStderrWarning(platform: string) { + const json = JSON.stringify([{ family_label: "Adaptive", slug: "adaptive" }]); + const warning = "warning: legacy flag ignored"; + if (isWindows(platform)) { + return [ + "@echo off", + 'if "%1" == "models" if "%2" == "list" if "%3" == "--format" if "%4" == "json" (', + ` echo ${json}`, + ` echo ${warning} 1>&2`, + " exit /b 0", + ")", + "echo devin-cli 0.0.99", + "exit /b 0", + "", + ].join("\n"); + } + return [ + "#!/bin/sh", + 'if [ "$1" = "models" ] && [ "$2" = "list" ] && [ "$3" = "--format" ] && [ "$4" = "json" ]; then', + ` printf "%s\\n" '${json}'`, + ` printf "%s\\n" '${warning}' >&2`, + " exit 0", + "fi", + 'printf "devin-cli 0.0.99\\n"', + "exit 0", + "", + ].join("\n"); +} + +describe("buildInitialDevinProviderSnapshot", () => { + it.effect("returns a disabled snapshot when settings.enabled is false", () => + Effect.gen(function* () { + const snapshot = yield* buildInitialDevinProviderSnapshot( + decodeDevinSettings({ enabled: false }), + ); + expect(snapshot.enabled).toBe(false); + expect(snapshot.status).toBe("disabled"); + expect(snapshot.installed).toBe(false); + expect(snapshot.message).toContain("disabled"); + }), + ); + + it.effect("returns a pending snapshot by default", () => + Effect.gen(function* () { + const snapshot = yield* buildInitialDevinProviderSnapshot(decodeDevinSettings({})); + expect(snapshot.enabled).toBe(true); + expect(snapshot.installed).toBe(true); + expect(snapshot.status).toBe("warning"); + expect(snapshot.version).toBeNull(); + expect(snapshot.message).toContain("Checking Devin"); + expect(snapshot.requiresNewThreadForModelChange).toBe(false); + }), + ); +}); + +it.layer(NodeServices.layer)("checkDevinProviderStatus", (it) => { + it.effect("reports the binary as missing when the binary path does not resolve", () => + Effect.gen(function* () { + const snapshot = yield* checkDevinProviderStatus( + decodeDevinSettings({ + enabled: true, + binaryPath: "/definitely/not/installed/devin-binary", + }), + ); + expect(snapshot.enabled).toBe(true); + expect(snapshot.installed).toBe(false); + expect(snapshot.status).toBe("error"); + expect(snapshot.message).toMatch(/not installed|not on PATH|Failed to execute/); + }), + ); + + it.effect("reports an installed CLI as unhealthy when --version exits non-zero", () => + Effect.gen(function* () { + const platform = yield* HostProcessPlatform; + const secretStderr = "broken devin install: secret-token-value"; + const snapshot = yield* Effect.scoped( + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const dir = yield* fs.makeTempDirectoryScoped({ + prefix: "t3code-devin-version-", + }); + const devinPath = yield* makeMockDevinScript( + fs, + path, + dir, + mockVersionScript(platform, secretStderr, 2), + platform, + ); + + return yield* checkDevinProviderStatus( + decodeDevinSettings({ enabled: true, binaryPath: devinPath }), + ); + }), + ); + + expect(snapshot.enabled).toBe(true); + expect(snapshot.installed).toBe(true); + expect(snapshot.status).toBe("error"); + expect(snapshot.message).toBe("Devin CLI is installed but failed to run."); + expect(snapshot.message).not.toContain(secretStderr); + }), + ); + + it.effect("discovers models via `devin models list` and reports ready", () => + Effect.gen(function* () { + const platform = yield* HostProcessPlatform; + const snapshot = yield* Effect.scoped( + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const dir = yield* fs.makeTempDirectoryScoped({ + prefix: "t3code-devin-models-", + }); + const devinPath = yield* makeMockDevinScript( + fs, + path, + dir, + mockModelsListScript(platform), + platform, + ); + + return yield* checkDevinProviderStatus( + decodeDevinSettings({ enabled: true, binaryPath: devinPath }), + ); + }), + ); + + expect(snapshot.enabled).toBe(true); + expect(snapshot.installed).toBe(true); + expect(snapshot.status).toBe("ready"); + expect(snapshot.models.map((model) => model.slug)).toEqual(["adaptive"]); + }), + ); + + it.effect( + "discovers models when `devin models list` prints JSON to stdout and a warning to stderr", + () => + Effect.gen(function* () { + const platform = yield* HostProcessPlatform; + const snapshot = yield* Effect.scoped( + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const dir = yield* fs.makeTempDirectoryScoped({ + prefix: "t3code-devin-models-stderr-", + }); + const devinPath = yield* makeMockDevinScript( + fs, + path, + dir, + mockModelsListScriptWithStderrWarning(platform), + platform, + ); + + return yield* checkDevinProviderStatus( + decodeDevinSettings({ enabled: true, binaryPath: devinPath }), + ); + }), + ); + + expect(snapshot.enabled).toBe(true); + expect(snapshot.installed).toBe(true); + expect(snapshot.status).toBe("ready"); + expect(snapshot.models.map((model) => model.slug)).toEqual(["adaptive"]); + }), + ); + + it.effect("falls back to built-in models when `devin models list` fails", () => + Effect.gen(function* () { + const platform = yield* HostProcessPlatform; + const snapshot = yield* Effect.scoped( + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const dir = yield* fs.makeTempDirectoryScoped({ + prefix: "t3code-devin-fail-", + }); + const devinPath = yield* makeMockDevinScript( + fs, + path, + dir, + mockVersionScript(platform, "", 0), + platform, + ); + + return yield* checkDevinProviderStatus( + decodeDevinSettings({ enabled: true, binaryPath: devinPath }), + ); + }), + ); + + expect(snapshot.enabled).toBe(true); + expect(snapshot.installed).toBe(true); + expect(snapshot.status).toBe("ready"); + expect(snapshot.models.map((model) => model.slug)).toEqual(["adaptive"]); + }), + ); +}); + +it.layer(NodeServices.layer)("parseDevinModelsList", (it) => { + it("parses model families from `devin models list` headers, skipping reasoning variants", () => { + const output = [ + "Claude Opus 4.7 (claude-opus-4.7)", + " claude-opus-4-7-medium Claude Opus 4.7 Medium [1M context, $5 / MTok]", + " claude-opus-4-7-high Claude Opus 4.7 High [1M context, $5 / MTok]", + "", + "Claude Opus 4.8 (claude-opus-4.8)", + " claude-opus-4-8-low Claude Opus 4.8 Low [1M context, $5 / MTok]", + " claude-opus-4-8-high Claude Opus 4.8 High [1M context, $5 / MTok]", + "", + "Adaptive (adaptive)", + " aliases: swe, opencode", + " adaptive Adaptive [$0.5 / MTok]", + ].join("\n"); + + const models = parseDevinModelsList(output); + expect( + models.map((m) => ({ + slug: m.slug, + name: m.name, + })), + ).toEqual([ + { slug: "claude-opus-4-7", name: "Claude Opus 4.7" }, + { slug: "claude-opus-4-8", name: "Claude Opus 4.8" }, + { slug: "adaptive", name: "Adaptive" }, + ]); + }); + + it("returns an empty array when output has no models", () => { + expect(parseDevinModelsList("No models available.")).toEqual([]); + }); + + it("deduplicates family slugs after normalization", () => { + const output = ["Claude Opus 4.7 (claude-opus-4.7)", "Claude Opus 4.7 (claude-opus-4-7)"].join( + "\n", + ); + + const models = parseDevinModelsList(output); + expect(models).toHaveLength(1); + expect(models[0]?.slug).toBe("claude-opus-4-7"); + }); + + it("parses JSON output, returning one model per family", () => { + const output = JSON.stringify({ + families: [ + { + family_label: "Claude Opus 4.7", + family_uid: "claude-opus-4.7", + slug: "claude-opus-4.7", + variants: [{ model_uid: "claude-opus-4-7-medium" }], + }, + { + family_label: "Claude Opus 4.8", + family_uid: "claude-opus-4.8", + slug: "claude-opus-4.8", + variants: [{ model_uid: "claude-opus-4-8-low" }], + }, + { + family_label: "Adaptive", + family_uid: "adaptive", + slug: "adaptive", + aliases: ["swe", "opencode"], + variants: [{ model_uid: "adaptive" }], + }, + ], + }); + + const models = parseDevinModelsList(output); + expect( + models.map((m) => ({ + slug: m.slug, + name: m.name, + })), + ).toEqual([ + { slug: "adaptive", name: "Adaptive" }, + { slug: "claude-opus-4-7", name: "Claude Opus 4.7" }, + { slug: "claude-opus-4-8", name: "Claude Opus 4.8" }, + ]); + }); + + it("still accepts a plain JSON array as fallback", () => { + const output = JSON.stringify([ + { + family_label: "Adaptive", + family_uid: "adaptive", + slug: "adaptive", + variants: [{ model_uid: "adaptive" }], + }, + ]); + + const models = parseDevinModelsList(output); + expect(models.map((m) => m.slug)).toEqual(["adaptive"]); + }); + + it("groups flat JSON variants into one model per family", () => { + const output = JSON.stringify([ + { model_uid: "claude-opus-5-medium", label: "Claude Opus 5 Medium" }, + { model_uid: "claude-opus-5-low", label: "Claude Opus 5 Low" }, + { model_uid: "claude-opus-5-high", label: "Claude Opus 5 High" }, + { model_uid: "claude-opus-5-xhigh", label: "Claude Opus 5 XHigh" }, + { model_uid: "claude-opus-5-max", label: "Claude Opus 5 Max" }, + { model_uid: "claude-opus-5-low-fast", label: "Claude Opus 5 Low Fast" }, + { model_uid: "gpt-5-6-sol-none", label: "GPT-5.6 Sol No Thinking" }, + { model_uid: "gpt-5-6-sol-low", label: "GPT-5.6 Sol Low Thinking" }, + { model_uid: "gpt-5-6-sol-high", label: "GPT-5.6 Sol High Thinking" }, + { model_uid: "adaptive", label: "Adaptive" }, + ]); + + const models = parseDevinModelsList(output); + expect( + models.map((m) => ({ + slug: m.slug, + name: m.name, + })), + ).toEqual([ + { slug: "adaptive", name: "Adaptive" }, + { slug: "claude-opus-5", name: "Claude Opus 5" }, + { slug: "gpt-5-6-sol", name: "GPT-5.6 Sol" }, + ]); + }); + + it("uses family_uid when present in flat JSON variants", () => { + const output = JSON.stringify([ + { + model_uid: "claude-opus-5-medium", + label: "Claude Opus 5 Medium", + family_uid: "claude-opus-5", + family_label: "Claude Opus 5", + }, + { + model_uid: "claude-opus-5-low", + label: "Claude Opus 5 Low", + family_uid: "claude-opus-5", + family_label: "Claude Opus 5", + }, + ]); + + const models = parseDevinModelsList(output); + expect(models).toHaveLength(1); + expect(models[0]?.slug).toBe("claude-opus-5"); + expect(models[0]?.name).toBe("Claude Opus 5"); + }); + + it("groups flat JSON variants with compound family slugs", () => { + const output = JSON.stringify([ + { + model_uid: "swe-1-7-lightning-medium", + label: "SWE-1.7 Lightning Medium", + }, + { model_uid: "swe-1-7-lightning-max", label: "SWE-1.7 Lightning Max" }, + { model_uid: "glm-5-2-none", label: "GLM-5.2 No Thinking" }, + { model_uid: "glm-5-2-none-1m", label: "GLM-5.2 No Thinking 1M" }, + { model_uid: "glm-5-2-max", label: "GLM-5.2 Max" }, + ]); + + const models = parseDevinModelsList(output); + expect( + models.map((m) => ({ + slug: m.slug, + name: m.name, + })), + ).toEqual([ + { slug: "glm-5-2", name: "GLM-5.2" }, + { slug: "swe-1-7-lightning", name: "SWE-1.7 Lightning" }, + ]); + }); + + it("derives the family slug from the label for opaque legacy model ids", () => { + const output = JSON.stringify([ + { model_uid: "MODEL_PRIVATE_11", label: "Claude Haiku 4.5" }, + { model_uid: "MODEL_PRIVATE_2", label: "Claude Sonnet 4.5" }, + { model_uid: "MODEL_PRIVATE_3", label: "Claude Sonnet 4.5 Thinking" }, + { model_uid: "MODEL_GPT_5_2_LOW", label: "GPT-5.2 Low Thinking" }, + { model_uid: "MODEL_GPT_5_2_MEDIUM", label: "GPT-5.2 Medium Thinking" }, + { model_uid: "MODEL_CHAT_GPT_4_1_2025_04_14", label: "GPT-4.1" }, + { + model_uid: "MODEL_GOOGLE_GEMINI_3_0_FLASH_MINIMAL", + label: "Gemini 3 Flash Minimal", + }, + { + model_uid: "MODEL_GOOGLE_GEMINI_3_0_FLASH_HIGH", + label: "Gemini 3 Flash High", + }, + { model_uid: "claude-5-fable-medium", label: "Claude Fable 5 Medium" }, + { model_uid: "claude-5-fable-low", label: "Claude Fable 5 Low" }, + ]); + + const models = parseDevinModelsList(output); + expect( + models.map((m) => ({ + slug: m.slug, + name: m.name, + })), + ).toEqual([ + { slug: "claude-fable-5", name: "Claude Fable 5" }, + { slug: "claude-haiku-4-5", name: "Claude Haiku 4.5" }, + { slug: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" }, + { slug: "gemini-3-flash", name: "Gemini 3 Flash" }, + { slug: "gpt-4-1", name: "GPT-4.1" }, + { slug: "gpt-5-2", name: "GPT-5.2" }, + ]); + }); + + it("sorts discovered models by name", () => { + const output = JSON.stringify([ + { model_uid: "claude-opus-5-medium", label: "Claude Opus 5 Medium" }, + { model_uid: "adaptive", label: "Adaptive" }, + { model_uid: "gpt-5-6-sol-low", label: "GPT-5.6 Sol Low Thinking" }, + ]); + + const models = parseDevinModelsList(output); + expect(models.map((m) => m.name)).toEqual(["Adaptive", "Claude Opus 5", "GPT-5.6 Sol"]); + }); + + it.effect("parses the real exported devin model list into families with reasoning options", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const raw = yield* fs.readFileString( + NodePath.join(import.meta.dirname, "../testFixtures/devin-models-list.txt"), + ); + const models = parseDevinModelsList(raw); + + expect(models.length).toBeLessThan(50); + const opus5 = models.find((m) => m.slug === "claude-opus-5"); + expect(opus5).toBeDefined(); + const reasoning = opus5?.capabilities?.optionDescriptors?.[0]; + expect(reasoning?.id).toBe("reasoning"); + expect(reasoning?.type).toBe("select"); + if (reasoning?.type === "select") { + expect(reasoning.options.some((o) => o.id === "medium")).toBe(true); + expect(reasoning.options.some((o) => o.id === "low-fast")).toBe(true); + } + }), + ); + + it("exposes a reasoning option descriptor with real model_uids", () => { + const output = JSON.stringify({ + families: [ + { + family_label: "Claude Opus 5", + family_uid: "claude-opus-5", + slug: "claude-opus-5", + variants: [ + { + model_uid: "claude-opus-5-medium", + label: "Claude Opus 5 Medium", + }, + { model_uid: "claude-opus-5-low", label: "Claude Opus 5 Low" }, + { model_uid: "claude-opus-5-high", label: "Claude Opus 5 High" }, + ], + }, + { + family_label: "Adaptive", + family_uid: "adaptive", + slug: "adaptive", + variants: [{ model_uid: "adaptive", label: "Adaptive" }], + }, + ], + }); + + const models = parseDevinModelsList(output); + const claudeOpus = models.find((m) => m.slug === "claude-opus-5"); + const adaptive = models.find((m) => m.slug === "adaptive"); + + expect(claudeOpus?.capabilities?.optionDescriptors).toHaveLength(1); + const reasoning = claudeOpus?.capabilities?.optionDescriptors?.[0]; + expect(reasoning?.id).toBe("reasoning"); + expect(reasoning?.type).toBe("select"); + expect( + reasoning && reasoning.type === "select" + ? reasoning.options.map((o) => ({ id: o.id, label: o.label })) + : [], + ).toEqual([ + { id: "medium", label: "Medium" }, + { id: "low", label: "Low" }, + { id: "high", label: "High" }, + ]); + + expect(adaptive?.capabilities?.optionDescriptors).toEqual([]); + }); + + it("uses the API variant labels for reasoning options", () => { + const output = JSON.stringify({ + families: [ + { + family_label: "SWE-1.7", + family_uid: "swe-1.7", + slug: "swe-1.7", + variants: [ + { model_uid: "swe-1-7", label: "SWE-1.7 Max" }, + { model_uid: "swe-1-7-medium", label: "SWE-1.7 Medium" }, + ], + }, + { + family_label: "SWE-1.7 Lightning", + family_uid: "swe-1.7-lightning", + slug: "swe-1.7-lightning", + variants: [ + { model_uid: "swe-1-7-lightning", label: "SWE-1.7 Lightning Max" }, + { + model_uid: "swe-1-7-lightning-medium", + label: "SWE-1.7 Lightning Medium", + }, + ], + }, + { + family_label: "GLM-5.2", + family_uid: "glm-5.2", + slug: "glm-5.2", + variants: [ + { model_uid: "glm-5-2", label: "GLM-5.2 High" }, + { model_uid: "glm-5-2-max", label: "GLM-5.2 Max" }, + { model_uid: "glm-5-2-none", label: "GLM-5.2 No Thinking" }, + { model_uid: "glm-5-2-none-1m", label: "GLM-5.2 No Thinking 1M" }, + ], + }, + ], + }); + + const models = parseDevinModelsList(output); + const swe = models.find((m) => m.slug === "swe-1-7"); + const sweLightning = models.find((m) => m.slug === "swe-1-7-lightning"); + const glm = models.find((m) => m.slug === "glm-5-2"); + + const reasoningOptions = (model: (typeof models)[number]) => + model?.capabilities?.optionDescriptors?.[0]?.type === "select" + ? model.capabilities.optionDescriptors[0].options.map((o) => ({ + id: o.id, + label: o.label, + })) + : []; + + expect(swe).toBeDefined(); + expect(sweLightning).toBeDefined(); + expect(glm).toBeDefined(); + expect(reasoningOptions(swe!)).toEqual([ + { id: "max", label: "Max" }, + { id: "medium", label: "Medium" }, + ]); + expect(reasoningOptions(sweLightning!)).toEqual([ + { id: "max", label: "Max" }, + { id: "medium", label: "Medium" }, + ]); + expect(reasoningOptions(glm!)).toEqual([ + { id: "high", label: "High" }, + { id: "max", label: "Max" }, + { id: "no-thinking", label: "No Thinking" }, + { id: "no-thinking-1m", label: "No Thinking 1M" }, + ]); + }); +}); + +describe("deduplicateDevinProviderModels", () => { + it("collapses variant models into one entry per family", () => { + const models = deduplicateDevinProviderModels([ + { + slug: "claude-opus-5-medium", + name: "Claude Opus 5 Medium", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "claude-opus-5-low", + name: "Claude Opus 5 Low", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "claude-opus-5-high", + name: "Claude Opus 5 High", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "gpt-5-6-sol-none", + name: "GPT-5.6 Sol No Thinking", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "gpt-5-6-sol-high", + name: "GPT-5.6 Sol High Thinking", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "adaptive", + name: "Adaptive", + isCustom: false, + capabilities: emptyCapabilities, + }, + ]); + + expect(models.map((m) => ({ slug: m.slug, name: m.name }))).toEqual([ + { slug: "adaptive", name: "Adaptive" }, + { slug: "claude-opus-5", name: "Claude Opus 5" }, + { slug: "gpt-5-6-sol", name: "GPT-5.6 Sol" }, + ]); + }); + + it("derives family slugs from legacy opaque model ids", () => { + const models = deduplicateDevinProviderModels([ + { + slug: "MODEL_PRIVATE_11", + name: "Claude Haiku 4.5", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "MODEL_PRIVATE_2", + name: "Claude Sonnet 4.5", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "MODEL_GPT_5_2_LOW", + name: "GPT-5.2 Low Thinking", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "MODEL_GPT_5_2_MEDIUM", + name: "GPT-5.2 Medium Thinking", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "claude-fable-5", + name: "Claude Fable 5", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "adaptive", + name: "Adaptive", + isCustom: false, + capabilities: emptyCapabilities, + }, + { + slug: "claude-haiku-4-5", + name: "Claude Haiku 4.5", + isCustom: false, + capabilities: emptyCapabilities, + }, + ]); + + expect(models.map((m) => ({ slug: m.slug, name: m.name }))).toEqual([ + { slug: "adaptive", name: "Adaptive" }, + { slug: "claude-fable-5", name: "Claude Fable 5" }, + { slug: "claude-haiku-4-5", name: "Claude Haiku 4.5" }, + { slug: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" }, + { slug: "gpt-5-2", name: "GPT-5.2" }, + ]); + }); +}); diff --git a/apps/server/src/provider/Layers/DevinProvider.ts b/apps/server/src/provider/Layers/DevinProvider.ts new file mode 100644 index 000000000000..173091feee06 --- /dev/null +++ b/apps/server/src/provider/Layers/DevinProvider.ts @@ -0,0 +1,798 @@ +import { + type DevinSettings, + type ModelCapabilities, + type ProviderOptionChoice, + type ProviderOptionDescriptor, + type ServerProvider, + type ServerProviderModel, +} from "@t3tools/contracts"; + +import { causeErrorTag } from "@t3tools/shared/observability"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import * as Option from "effect/Option"; +import * as Result from "effect/Result"; +import * as Schema from "effect/Schema"; +import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; +import { HttpClient } from "effect/unstable/http"; +import { createModelCapabilities } from "@t3tools/shared/model"; +import { resolveSpawnCommand } from "@t3tools/shared/shell"; + +import { ProviderProbeError } from "../Errors.ts"; +import { + buildServerProvider, + isCommandMissingCause, + parseGenericCliVersion, + providerModelsFromSettings, + spawnAndCollect, + type ServerProviderDraft, +} from "../providerSnapshot.ts"; +import { + enrichProviderSnapshotWithVersionAdvisory, + type ProviderMaintenanceCapabilities, +} from "../providerMaintenance.ts"; +import { resolveDevinAcpBaseModelId } from "../acp/DevinAcpSupport.ts"; +import { resolveEffectiveDevinBinary } from "../Drivers/DevinBinary.ts"; + +const DEVIN_PRESENTATION = { + displayName: "Devin", + badgeLabel: "Early Access", + showInteractionModeToggle: false, + requiresNewThreadForModelChange: false, +} as const; +const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({ + optionDescriptors: [], +}); + +const VERSION_PROBE_TIMEOUT_MS = 15_000; +const DEVIN_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15_000; + +const DEVIN_BUILT_IN_MODELS: ReadonlyArray = [ + { + slug: "adaptive", + name: "Adaptive", + isCustom: false, + capabilities: EMPTY_CAPABILITIES, + }, +]; + +export const buildInitialDevinProviderSnapshot = Effect.fn("buildInitialDevinProviderSnapshot")( + function* (devinSettings: DevinSettings) { + const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso); + const models = devinModelsFromSettings(devinSettings.customModels); + + if (!devinSettings.enabled) { + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: false, + checkedAt, + models, + probe: { + installed: false, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Devin is disabled in T3 Code settings.", + }, + }); + } + + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: true, + checkedAt, + models, + probe: { + installed: true, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Checking Devin CLI availability...", + }, + }); + }, +); + +function devinModelsFromSettings( + customModels: ReadonlyArray | undefined, + builtInModels: ReadonlyArray = DEVIN_BUILT_IN_MODELS, +): ReadonlyArray { + return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES); +} + +const DevinModelVariantSchema = Schema.Struct({ + model_uid: Schema.optional(Schema.String), + label: Schema.optional(Schema.String), + family_label: Schema.optional(Schema.String), + family_uid: Schema.optional(Schema.String), + cost_summary: Schema.optional(Schema.String), + max_context_tokens: Schema.optional(Schema.Number), + slug: Schema.optional(Schema.String), +}); + +type DevinModelVariant = typeof DevinModelVariantSchema.Type; + +const DevinModelFamilySchema = Schema.Struct({ + family_label: Schema.optional(Schema.String), + family_uid: Schema.optional(Schema.String), + slug: Schema.optional(Schema.String), + variants: Schema.Array(DevinModelVariantSchema), +}); + +type DevinModelFamily = typeof DevinModelFamilySchema.Type; + +const DevinFamilyRecordSchema = Schema.Struct({ + families: Schema.Array(DevinModelFamilySchema), +}); + +const DevinFamilyListSchema = Schema.Array(DevinModelFamilySchema); +const DevinVariantListSchema = Schema.Array(DevinModelVariantSchema); + +const DevinModelsListJson = Schema.Union([ + DevinFamilyRecordSchema, + DevinFamilyListSchema, + DevinVariantListSchema, +]); + +const decodeDevinModelsListJson = Schema.decodeUnknownOption(DevinModelsListJson); + +const DEVIN_VARIANT_SUFFIXES = new Set([ + "none", + "low", + "medium", + "high", + "xhigh", + "x-high", + "max", + "minimal", + "thinking", + "fast", + "priority", + "1m", + "200k", + "1000k", + "1000000", +]); + +const DEVIN_VARIANT_NAME_TOKENS = new Set(DEVIN_VARIANT_SUFFIXES); + +function isDevinVariantSuffixToken(token: string): boolean { + return DEVIN_VARIANT_SUFFIXES.has(token.toLowerCase()); +} + +function isDevinVariantNameToken(token: string): boolean { + return DEVIN_VARIANT_NAME_TOKENS.has(token.toLowerCase().replace(/[,]/g, "")); +} + +function buildDevinVariantDescription(variant: DevinModelVariant): string | undefined { + const contextTokens = variant.max_context_tokens; + const costSummary = variant.cost_summary; + + const parts: string[] = []; + if (contextTokens) { + parts.push(`${contextTokens >= 1000 ? `${contextTokens / 1000}K` : contextTokens} context`); + } + if (costSummary) { + parts.push(costSummary); + } + + return parts.length > 0 ? parts.join(", ") : undefined; +} + +function buildDevinFamilyDescription(family: DevinModelFamily): string | undefined { + const first = family.variants[0]; + if (!first) { + return undefined; + } + return buildDevinVariantDescription(first); +} + +function normalizeDevinFamilyUidForModelUid(familyUid: string): string { + return familyUid.replace(/\./g, "-").toLowerCase(); +} + +function resolveDevinVariantSuffix(familyUid: string, modelUid: string): string | undefined { + const normalizedFamilyUid = normalizeDevinFamilyUidForModelUid(familyUid); + const normalizedModelUid = modelUid.toLowerCase(); + if (normalizedModelUid === normalizedFamilyUid) { + return ""; + } + const prefix = `${normalizedFamilyUid}-`; + if (!normalizedModelUid.startsWith(prefix)) { + return undefined; + } + return normalizedModelUid.slice(prefix.length); +} + +function normalizeLabelForComparison(input: string): string { + return input + .toLowerCase() + .replace(/[.\-_]/g, " ") + .replace(/\s+/g, " ") + .trim(); +} + +function buildDevinVariantOptionLabel( + variantLabel: string | undefined, + familyName: string, +): string { + const normalizedFamily = normalizeLabelForComparison(familyName); + const label = variantLabel?.trim(); + if (!label) { + return "Default"; + } + + const tokens = label.split(/\s+/); + let consumedTokens = 0; + let consumed = ""; + + for (let i = 0; i < tokens.length; i += 1) { + const token = tokens[i]!; + const next = consumed ? `${consumed} ${token}` : token; + const normalizedNext = normalizeLabelForComparison(next); + if (normalizedFamily.startsWith(normalizedNext)) { + consumed = next; + consumedTokens = i + 1; + } else { + break; + } + } + + const rest = tokens.slice(consumedTokens).join(" "); + return rest.length > 0 ? rest : "Default"; +} + +function normalizeDevinReasoningValue(label: string): string { + return label + .toLowerCase() + .replace(/[^a-z0-9]+/g, "-") + .replace(/^-|-$/g, "") + .replace(/-+/g, "-"); +} + +function buildDevinReasoningDescriptor( + familyName: string, + familyUid: string, + variants: ReadonlyArray, +): ProviderOptionDescriptor | undefined { + const effectiveFamilyUid = familyUid; + const options: Array = []; + + for (const variant of variants) { + const modelUid = variant.model_uid?.trim() ?? ""; + if (!modelUid) { + continue; + } + const suffix = resolveDevinVariantSuffix(effectiveFamilyUid, modelUid); + if (suffix === undefined && variant.label === undefined) { + continue; + } + const label = buildDevinVariantOptionLabel(variant.label, familyName); + options.push({ + id: normalizeDevinReasoningValue(label), + label, + ...(options.length === 0 ? { isDefault: true } : {}), + }); + } + + if (options.length <= 1) { + return undefined; + } + + return { + id: "reasoning", + label: "Reasoning", + type: "select", + options, + }; +} + +function resolveDevinFamilyBaseSlug(rawSlug: string): string | undefined { + if (!rawSlug) { + return undefined; + } + + const normalized = rawSlug.replace(/\./g, "-"); + + const parts = normalized.split("-"); + while (parts.length > 1) { + const last = parts[parts.length - 1]; + if (!last || !isDevinVariantSuffixToken(last)) { + break; + } + parts.pop(); + } + return resolveDevinAcpBaseModelId(parts.join("-")); +} + +function resolveDevinFamilyNameFromLabel(label: string): string { + const tokens = label.split(/\s+/); + while (tokens.length > 1) { + const last = tokens[tokens.length - 1]; + if (!last || !isDevinVariantNameToken(last)) { + break; + } + tokens.pop(); + + // Drop a preceding "No" that was part of "No Thinking". + const prev = tokens[tokens.length - 1]; + if (prev && /^No$/i.test(prev) && last.toLowerCase() === "thinking") { + tokens.pop(); + } + } + + const name = tokens.join(" "); + return name.length > 0 ? name : label; +} + +function slugifyFamilyName(name: string): string { + return name + .toLowerCase() + .replace(/[.]/g, "-") + .replace(/[^a-z0-9-]+/g, "-") + .replace(/^-|-$/g, "") + .replace(/-+/g, "-"); +} + +function isOpaqueDevinModelId(modelUid: string): boolean { + return /^MODEL_/i.test(modelUid) || modelUid.includes("_"); +} + +function resolveDevinFamilySlugFromVariant(variant: DevinModelVariant): string | undefined { + const familyUid = variant.family_uid?.trim() ?? ""; + const modelUid = variant.model_uid?.trim() ?? ""; + const slug = variant.slug?.trim() ?? ""; + + // Prefer explicit family or model slugs; only strip variants from raw model_uids. + const rawSlug = familyUid || slug || modelUid; + if (!rawSlug) { + return undefined; + } + + if (familyUid || slug) { + return resolveDevinFamilyBaseSlug(rawSlug); + } + + const fromModelUid = resolveDevinFamilyBaseSlug(modelUid); + const familyLabel = variant.family_label?.trim() ?? ""; + const label = variant.label?.trim() ?? ""; + + const baseName = familyLabel || (label ? resolveDevinFamilyNameFromLabel(label) : undefined); + const fromLabel = baseName ? resolveDevinAcpBaseModelId(slugifyFamilyName(baseName)) : undefined; + + // Opaque legacy ids like MODEL_PRIVATE_11 don't carry the family slug in the + // model_uid. Some informative ids like claude-5-fable-medium also don't match + // the canonical family slug (claude-fable-5), while labels like + // "Claude Fable 5 Medium" do. In those cases, derive the slug from the label. + if ( + fromLabel && + (fromModelUid === undefined || isOpaqueDevinModelId(modelUid) || fromLabel !== fromModelUid) + ) { + return fromLabel; + } + + return fromModelUid; +} + +function resolveDevinFamilyNameFromVariant(variant: DevinModelVariant): string | undefined { + const familyLabel = variant.family_label?.trim() ?? ""; + if (familyLabel) { + return familyLabel; + } + + const label = variant.label?.trim() ?? ""; + if (!label) { + return undefined; + } + + return resolveDevinFamilyNameFromLabel(label); +} + +export function deduplicateDevinProviderModels( + models: ReadonlyArray, +): ReadonlyArray { + const groups = new Map(); + + for (const model of models) { + const baseName = resolveDevinFamilyNameFromLabel(model.name); + const fromSlug = resolveDevinFamilyBaseSlug(model.slug); + const fromName = resolveDevinAcpBaseModelId(slugifyFamilyName(baseName)); + + const baseSlug = + fromName && + (fromSlug === undefined || isOpaqueDevinModelId(model.slug) || fromName !== fromSlug) + ? fromName + : fromSlug; + if (!baseSlug || groups.has(baseSlug)) { + continue; + } + + const deduplicated = { ...model, slug: baseSlug, name: baseName }; + groups.set(baseSlug, { name: baseName, model: deduplicated }); + } + + return Array.from(groups.values(), (group) => group.model).toSorted((left, right) => + left.name.localeCompare(right.name), + ); +} + +function parseDevinModelFamilyList( + families: ReadonlyArray, +): ReadonlyArray { + const seen = new Set(); + const models: Array = []; + + for (const family of families) { + const rawSlug = family.slug ?? family.family_uid; + const familyName = family.family_label?.trim() ?? ""; + + if (!rawSlug) { + continue; + } + + const slug = resolveDevinAcpBaseModelId(rawSlug.replace(/\./g, "-")); + if (!slug || seen.has(slug)) { + continue; + } + seen.add(slug); + + const description = buildDevinFamilyDescription(family); + const resolvedFamilyName = familyName || slug; + const reasoningDescriptor = buildDevinReasoningDescriptor( + resolvedFamilyName, + family.family_uid ?? slug, + family.variants, + ); + + models.push({ + slug, + name: resolvedFamilyName, + ...(description ? { description } : {}), + isCustom: false, + capabilities: createModelCapabilities({ + optionDescriptors: reasoningDescriptor ? [reasoningDescriptor] : [], + }), + }); + } + + return models.toSorted((left, right) => left.name.localeCompare(right.name)); +} + +function parseDevinModelVariantList( + variants: ReadonlyArray, +): ReadonlyArray { + const groups = new Map< + string, + { + readonly name: string; + readonly familyUid: string | undefined; + readonly variants: Array; + } + >(); + + for (const variant of variants) { + const slug = resolveDevinFamilySlugFromVariant(variant); + if (!slug) { + continue; + } + + const existing = groups.get(slug); + if (existing) { + existing.variants.push(variant); + continue; + } + + const name = + resolveDevinFamilyNameFromVariant(variant) || resolveDevinAcpBaseModelId(slug) || slug; + const familyUid = variant.family_uid; + groups.set(slug, { name, familyUid, variants: [variant] }); + } + + const models: Array = []; + for (const [slug, group] of groups) { + const firstVariant = group.variants[0]; + const description = firstVariant ? buildDevinVariantDescription(firstVariant) : undefined; + const familyUid = group.familyUid ?? slug; + const reasoningDescriptor = buildDevinReasoningDescriptor( + group.name, + familyUid, + group.variants, + ); + + models.push({ + slug, + name: group.name, + ...(description ? { description } : {}), + isCustom: false, + capabilities: createModelCapabilities({ + optionDescriptors: reasoningDescriptor ? [reasoningDescriptor] : [], + }), + }); + } + + return models.toSorted((left, right) => left.name.localeCompare(right.name)); +} + +function parseDevinModelsJson(output: string): ReadonlyArray { + let parsed: unknown; + try { + parsed = JSON.parse(output); + } catch { + return []; + } + + const result = decodeDevinModelsListJson(parsed); + if (Option.isNone(result)) { + return []; + } + + const list = result.value; + if ("families" in list) { + return parseDevinModelFamilyList(list.families); + } + + if (!Array.isArray(list) || list.length === 0) { + return []; + } + + const first = list[0]; + if ("variants" in first && Array.isArray(first.variants)) { + return parseDevinModelFamilyList(list as ReadonlyArray); + } + + return parseDevinModelVariantList(list as ReadonlyArray); +} + +function parseDevinModelsText(output: string): ReadonlyArray { + const seen = new Set(); + const models: Array = []; + + for (const rawLine of output.split("\n")) { + const line = rawLine.replace(/\r/g, ""); + // Header lines group model families, e.g. "Claude Opus 4.7 (claude-opus-4.7)". + // The lines below a header are reasoning/variant entries that we skip so the + // picker only shows one model per family. + const familyMatch = line.match(/^(.+?)\s+\(([\w\d-]+(?:[._-][\w\d-]+)*)\)\s*$/); + if (!familyMatch) { + continue; + } + const rawSlug = familyMatch[2] ?? ""; + const familyName = familyMatch[1] ?? ""; + const slug = resolveDevinAcpBaseModelId(rawSlug.replace(/\./g, "-")); + if (!slug || seen.has(slug)) { + continue; + } + seen.add(slug); + models.push({ + slug, + name: familyName.trim() || slug, + isCustom: false, + capabilities: EMPTY_CAPABILITIES, + }); + } + + return models; +} + +export function parseDevinModelsList(output: string): ReadonlyArray { + const jsonModels = parseDevinModelsJson(output); + if (jsonModels.length > 0) { + return jsonModels; + } + return parseDevinModelsText(output); +} + +const runDevinModelsListCommand = ( + devinSettings: DevinSettings, + environment: NodeJS.ProcessEnv = process.env, +) => + Effect.gen(function* () { + const command = yield* resolveEffectiveDevinBinary(devinSettings.binaryPath, environment); + const spawnCommand = yield* resolveSpawnCommand( + command, + ["models", "list", "--format", "json"], + { + env: environment, + }, + ); + return yield* spawnAndCollect( + command, + ChildProcess.make(spawnCommand.command, spawnCommand.args, { + env: environment, + shell: spawnCommand.shell, + }), + ); + }); + +const discoverDevinModelsViaModelsList = ( + devinSettings: DevinSettings, + environment: NodeJS.ProcessEnv = process.env, +) => + Effect.gen(function* () { + const result = yield* runDevinModelsListCommand(devinSettings, environment); + if (result.code !== 0) { + return yield* new ProviderProbeError({ + provider: "devin", + stage: "models-list", + failureKind: "exit-code-failure", + exitCode: result.code, + }); + } + const stdoutModels = parseDevinModelsList(result.stdout); + const models = stdoutModels.length > 0 ? stdoutModels : parseDevinModelsList(result.stderr); + if (models.length === 0) { + return yield* new ProviderProbeError({ + provider: "devin", + stage: "models-list", + failureKind: "unparseable-output", + }); + } + return models; + }); + +const runDevinVersionCommand = ( + devinSettings: DevinSettings, + environment: NodeJS.ProcessEnv = process.env, +) => + Effect.gen(function* () { + const command = yield* resolveEffectiveDevinBinary(devinSettings.binaryPath, environment); + const spawnCommand = yield* resolveSpawnCommand(command, ["--version"], { + env: environment, + }); + return yield* spawnAndCollect( + command, + ChildProcess.make(spawnCommand.command, spawnCommand.args, { + env: environment, + shell: spawnCommand.shell, + }), + ); + }); + +export const checkDevinProviderStatus = Effect.fn("checkDevinProviderStatus")(function* ( + devinSettings: DevinSettings, + environment: NodeJS.ProcessEnv = process.env, +): Effect.fn.Return< + ServerProviderDraft, + never, + ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto | FileSystem.FileSystem | Path.Path +> { + const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso); + const fallbackModels = devinModelsFromSettings(devinSettings.customModels); + + if (!devinSettings.enabled) { + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: false, + checkedAt, + models: fallbackModels, + probe: { + installed: false, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Devin is disabled in T3 Code settings.", + }, + }); + } + + const versionResult = yield* runDevinVersionCommand(devinSettings, environment).pipe( + Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), + Effect.result, + ); + + if (Result.isFailure(versionResult)) { + const error = versionResult.failure; + yield* Effect.logWarning("Devin CLI health check failed.", { + errorTag: error._tag, + }); + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: devinSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: !isCommandMissingCause(error), + version: null, + status: "error", + auth: { status: "unknown" }, + message: isCommandMissingCause(error) + ? "Devin CLI (`devin`) is not installed or not on PATH." + : "Failed to execute Devin CLI health check.", + }, + }); + } + + if (Option.isNone(versionResult.success)) { + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: devinSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version: null, + status: "error", + auth: { status: "unknown" }, + message: "Devin CLI is installed but timed out while running `devin --version`.", + }, + }); + } + + const versionOutput = versionResult.success.value; + const version = parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`); + if (versionOutput.code !== 0) { + yield* Effect.logWarning("Devin CLI version probe exited with a non-zero status.", { + exitCode: versionOutput.code, + stdoutLength: versionOutput.stdout.length, + stderrLength: versionOutput.stderr.length, + }); + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: devinSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "error", + auth: { status: "unknown" }, + message: "Devin CLI is installed but failed to run.", + }, + }); + } + + const discoveredModels = yield* discoverDevinModelsViaModelsList(devinSettings, environment).pipe( + Effect.timeout(DEVIN_ACP_MODEL_DISCOVERY_TIMEOUT_MS), + Effect.tapError((cause) => + Effect.logWarning("Devin model discovery via `devin models list` failed", { + errorTag: cause._tag, + }), + ), + Effect.orElseSucceed(() => [] as ReadonlyArray), + ); + const deduplicatedDiscoveredModels = + discoveredModels.length > 0 ? deduplicateDevinProviderModels(discoveredModels) : []; + const models = + deduplicatedDiscoveredModels.length > 0 + ? devinModelsFromSettings(devinSettings.customModels, deduplicatedDiscoveredModels) + : fallbackModels; + + return buildServerProvider({ + presentation: DEVIN_PRESENTATION, + enabled: devinSettings.enabled, + checkedAt, + models, + probe: { + installed: true, + version, + status: "ready", + auth: { status: "unknown" }, + }, + }); +}); + +export const enrichDevinSnapshot = (input: { + readonly snapshot: ServerProvider; + readonly maintenanceCapabilities: ProviderMaintenanceCapabilities; + readonly enableProviderUpdateChecks?: boolean; + readonly publishSnapshot: (snapshot: ServerProvider) => Effect.Effect; + readonly httpClient: HttpClient.HttpClient; +}): Effect.Effect => { + const { snapshot, publishSnapshot } = input; + + return enrichProviderSnapshotWithVersionAdvisory(snapshot, input.maintenanceCapabilities, { + enableProviderUpdateChecks: input.enableProviderUpdateChecks, + }).pipe( + Effect.provideService(HttpClient.HttpClient, input.httpClient), + Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)), + Effect.catchCause((cause) => + Effect.logWarning("Devin version advisory enrichment failed", { + errorTag: causeErrorTag(cause), + }), + ), + Effect.asVoid, + ); +}; diff --git a/apps/server/src/provider/Services/DevinAdapter.ts b/apps/server/src/provider/Services/DevinAdapter.ts new file mode 100644 index 000000000000..2aa623426808 --- /dev/null +++ b/apps/server/src/provider/Services/DevinAdapter.ts @@ -0,0 +1,7 @@ +import type { ProviderAdapterError } from "../Errors.ts"; +import type { ProviderAdapterShape } from "./ProviderAdapter.ts"; + +/** + * DevinAdapterShape — per-instance Devin adapter contract. + */ +export interface DevinAdapterShape extends ProviderAdapterShape {} diff --git a/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts b/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts index b1ef0d3e5953..ecddc14236e3 100644 --- a/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts +++ b/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts @@ -626,7 +626,13 @@ describe("AcpSessionRuntime", () => { .trim() .split("\n") .filter((line) => line.length > 0) - .map((line) => JSON.parse(line) as { method?: string; params?: { value?: unknown } }); + .map( + (line) => + JSON.parse(line) as { + method?: string; + params?: { value?: unknown }; + }, + ); expect( recordedRequests.some( (message) => @@ -654,4 +660,122 @@ describe("AcpSessionRuntime", () => { Effect.ensuring(Effect.sync(() => NodeFS.rmSync(tempDir, { recursive: true, force: true }))), ); }); + + it.effect("skips authentication when the agent advertises no auth methods", () => { + const requestEvents: Array = []; + return Effect.gen(function* () { + const runtime = yield* AcpSessionRuntime.AcpSessionRuntime; + yield* runtime.start(); + + expect(requestEvents.some((event) => event.method === "authenticate")).toBe(false); + }).pipe( + Effect.provide( + AcpSessionRuntime.layer({ + spawn: { + command: mockAgentCommand, + args: mockAgentArgs, + }, + cwd: process.cwd(), + clientInfo: { name: "t3-test", version: "0.0.0" }, + authMethodId: "test", + requestLogger: (event) => + Effect.sync(() => { + requestEvents.push(event); + }), + }), + ), + Effect.scoped, + Effect.provide(NodeServices.layer), + ); + }); + + it.effect("authenticates with the requested method when it is advertised", () => { + const requestEvents: Array = []; + const advertisedAuthMethods = JSON.stringify([ + { id: "test", name: "Test" }, + { id: "other", name: "Other" }, + ]); + return Effect.gen(function* () { + const runtime = yield* AcpSessionRuntime.AcpSessionRuntime; + yield* runtime.start(); + + const authenticateStarted = requestEvents.find( + (event) => event.method === "authenticate" && event.status === "started", + ); + expect(authenticateStarted?.payload).toMatchObject({ + methodId: "test", + }); + expect( + requestEvents.some( + (event) => event.method === "authenticate" && event.status === "succeeded", + ), + ).toBe(true); + }).pipe( + Effect.provide( + AcpSessionRuntime.layer({ + spawn: { + command: mockAgentCommand, + args: mockAgentArgs, + env: { + T3_ACP_AUTH_METHODS: advertisedAuthMethods, + }, + }, + cwd: process.cwd(), + clientInfo: { name: "t3-test", version: "0.0.0" }, + authMethodId: "test", + requestLogger: (event) => + Effect.sync(() => { + requestEvents.push(event); + }), + }), + ), + Effect.scoped, + Effect.provide(NodeServices.layer), + ); + }); + + it.effect("fails visibly when the requested auth method is not advertised", () => { + const requestEvents: Array = []; + const advertisedAuthMethods = JSON.stringify([ + { id: "other", name: "Other" }, + { id: "another", name: "Another" }, + ]); + return Effect.gen(function* () { + const runtime = yield* AcpSessionRuntime.AcpSessionRuntime; + const error = yield* runtime.start().pipe(Effect.flip); + + expect(error._tag).toBe("AcpRequestError"); + if (error._tag === "AcpRequestError") { + expect(error.code).toBe(-32602); + expect(error.message).toContain( + "Authentication method 'test' is not advertised by the agent", + ); + expect(error.message).toContain("other"); + expect(error.message).toContain("another"); + } + + expect(requestEvents.some((event) => event.method === "authenticate")).toBe(false); + }).pipe( + Effect.provide( + AcpSessionRuntime.layer({ + spawn: { + command: mockAgentCommand, + args: mockAgentArgs, + env: { + T3_ACP_AUTH_METHODS: advertisedAuthMethods, + }, + }, + cwd: process.cwd(), + clientInfo: { name: "t3-test", version: "0.0.0" }, + authMethodId: "test", + requestLogger: (event) => + Effect.sync(() => { + requestEvents.push(event); + }), + }), + ), + Effect.scoped, + Effect.provide(NodeServices.layer), + ); + }); }); diff --git a/apps/server/src/provider/acp/AcpNativeLogging.ts b/apps/server/src/provider/acp/AcpNativeLogging.ts index 06bff3aa6113..e6a3307979b0 100644 --- a/apps/server/src/provider/acp/AcpNativeLogging.ts +++ b/apps/server/src/provider/acp/AcpNativeLogging.ts @@ -16,7 +16,10 @@ function structuralMethod(value: string): string { function summarizePayload(payload: unknown): Readonly> { if (payload === null) return { valueType: "null" }; if (typeof payload === "string") { - return { valueType: "string", byteLength: new TextEncoder().encode(payload).byteLength }; + return { + valueType: "string", + byteLength: new TextEncoder().encode(payload).byteLength, + }; } if (payload instanceof Uint8Array) { return { valueType: "bytes", byteLength: payload.byteLength }; diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts index 7682c5f5f9cb..e35780fd6a00 100644 --- a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts +++ b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts @@ -299,7 +299,11 @@ describe("AcpRuntimeModel", () => { update: { sessionUpdate: "plan", entries: [ - { content: " Inspect state ", priority: "high", status: "completed" }, + { + content: " Inspect state ", + priority: "high", + status: "completed", + }, { content: "", priority: "medium", status: "in_progress" }, ], }, @@ -374,4 +378,45 @@ describe("AcpRuntimeModel", () => { }, }); }); + + it("projects ACP usage_update notifications into runtime events", () => { + const result = parseSessionUpdateEvent({ + sessionId: "session-1", + update: { + sessionUpdate: "usage_update", + used: 21776, + size: 262000, + _meta: { + "cognition.ai/inputTokens": 21687, + "cognition.ai/outputTokens": 89, + "cognition.ai/cachedReadTokens": 448, + }, + }, + } satisfies EffectAcpSchema.SessionNotification); + + expect(result.events).toEqual([ + { + _tag: "UsageUpdated", + used: 21776, + size: 262000, + cost: null, + inputTokens: 21687, + outputTokens: 89, + cachedReadTokens: 448, + rawPayload: { + sessionId: "session-1", + update: { + sessionUpdate: "usage_update", + used: 21776, + size: 262000, + _meta: { + "cognition.ai/inputTokens": 21687, + "cognition.ai/outputTokens": 89, + "cognition.ai/cachedReadTokens": 448, + }, + }, + }, + }, + ]); + }); }); diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.ts b/apps/server/src/provider/acp/AcpRuntimeModel.ts index e6bfc127e6e9..44643c61ceaf 100644 --- a/apps/server/src/provider/acp/AcpRuntimeModel.ts +++ b/apps/server/src/provider/acp/AcpRuntimeModel.ts @@ -11,6 +11,12 @@ function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); } +function finiteNonNegativeInteger(value: unknown): number | undefined { + if (typeof value !== "number" || !Number.isFinite(value)) return undefined; + const int = Math.floor(value); + return int >= 0 ? int : undefined; +} + function isSessionModelState(value: unknown): value is EffectAcpSchema.SessionModelState { if (!isRecord(value) || typeof value.currentModelId !== "string") { return false; @@ -108,6 +114,16 @@ export type AcpParsedSessionEvent = readonly itemId?: string; readonly text: string; readonly rawPayload: unknown; + } + | { + readonly _tag: "UsageUpdated"; + readonly used: number; + readonly size: number; + readonly cost: number | null; + readonly inputTokens: number | undefined; + readonly outputTokens: number | undefined; + readonly cachedReadTokens: number | undefined; + readonly rawPayload: unknown; }; type AcpSessionSetupResponse = @@ -120,11 +136,22 @@ type AcpToolCallUpdate = Extract< { readonly sessionUpdate: "tool_call" | "tool_call_update" } >; +export const MODEL_CONFIG_OPTION_IDS = new Set(["model", "models", "modelid", "modelids"]); + +export function isModelConfigOption(option: EffectAcpSchema.SessionConfigOption): boolean { + if (option.category === "model") return true; + const id = option.id + .trim() + .toLowerCase() + .replace(/[\s_-]+/g, ""); + return MODEL_CONFIG_OPTION_IDS.has(id); +} + export function extractModelConfigId(sessionResponse: AcpSessionSetupResponse): string | undefined { const configOptions = sessionResponse.configOptions; if (!configOptions) return undefined; for (const opt of configOptions) { - if (opt.category === "model" && opt.id.trim().length > 0) { + if (isModelConfigOption(opt) && opt.id.trim().length > 0) { return opt.id.trim(); } } @@ -574,6 +601,20 @@ export function parseSessionUpdateEvent(params: EffectAcpSchema.SessionNotificat } break; } + case "usage_update": { + const meta = isRecord(upd._meta) ? upd._meta : {}; + events.push({ + _tag: "UsageUpdated", + used: finiteNonNegativeInteger(upd.used) ?? 0, + size: finiteNonNegativeInteger(upd.size) ?? 0, + cost: upd.cost && typeof upd.cost.amount === "number" ? upd.cost.amount : null, + inputTokens: finiteNonNegativeInteger(meta["cognition.ai/inputTokens"]), + outputTokens: finiteNonNegativeInteger(meta["cognition.ai/outputTokens"]), + cachedReadTokens: finiteNonNegativeInteger(meta["cognition.ai/cachedReadTokens"]), + rawPayload: params, + }); + break; + } default: break; } diff --git a/apps/server/src/provider/acp/AcpSessionRuntime.ts b/apps/server/src/provider/acp/AcpSessionRuntime.ts index 09fce6d56f9d..c27d175d747d 100644 --- a/apps/server/src/provider/acp/AcpSessionRuntime.ts +++ b/apps/server/src/provider/acp/AcpSessionRuntime.ts @@ -289,9 +289,13 @@ export const make = ( }), ), ); - const assistantSegmentRef = yield* Ref.make({ nextSegmentIndex: 0 }); + const assistantSegmentRef = yield* Ref.make({ + nextSegmentIndex: 0, + }); const configOptionsRef = yield* Ref.make(sessionConfigOptionsFromSetup(undefined)); - const startStateRef = yield* Ref.make({ _tag: "NotStarted" }); + const startStateRef = yield* Ref.make({ + _tag: "NotStarted", + }); const promptSerializationSemaphore = yield* Semaphore.make(1); const activePromptFiberRef = yield* Ref.make< Option.Option> @@ -541,15 +545,31 @@ export const make = ( acp.agent.initialize(initializePayload), ); - const authenticatePayload = { - methodId: options.authMethodId, - } satisfies EffectAcpSchema.AuthenticateRequest; + const authMethods = initializeResult.authMethods ?? []; + if (authMethods.length > 0) { + const requestedAuthMethodId = options.authMethodId; + const authMethod = authMethods.find((method) => method.id === requestedAuthMethodId); + if (authMethod === undefined) { + return yield* new EffectAcpErrors.AcpRequestError({ + code: -32602, + errorMessage: `Authentication method '${requestedAuthMethodId}' is not advertised by the agent. Available methods: ${authMethods.map((method) => method.id).join(", ")}`, + data: { + requestedAuthMethodId, + availableAuthMethodIds: authMethods.map((method) => method.id), + }, + }); + } + + const authenticatePayload = { + methodId: authMethod.id, + } satisfies EffectAcpSchema.AuthenticateRequest; - yield* runLoggedRequest( - "authenticate", - authenticatePayload, - acp.agent.authenticate(authenticatePayload), - ); + yield* runLoggedRequest( + "authenticate", + authenticatePayload, + acp.agent.authenticate(authenticatePayload), + ); + } let sessionId: string; let sessionSetupResult: diff --git a/apps/server/src/provider/acp/DevinAcpSupport.test.ts b/apps/server/src/provider/acp/DevinAcpSupport.test.ts new file mode 100644 index 000000000000..8a61fae29793 --- /dev/null +++ b/apps/server/src/provider/acp/DevinAcpSupport.test.ts @@ -0,0 +1,534 @@ +import { describe, expect, it, vi } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Result from "effect/Result"; +import * as Schema from "effect/Schema"; +import { DevinSettings, ProviderInstanceId } from "@t3tools/contracts"; + +import { + applyDevinAcpModelSelection, + buildDevinAcpSpawnInput, + DEVIN_AUTH_METHOD_ID, + resolveDevinAcpBaseModelId, + resolveDevinAcpModelSelection, +} from "./DevinAcpSupport.ts"; + +const decodeDevinSettings = Schema.decodeSync(DevinSettings); + +describe("buildDevinAcpSpawnInput", () => { + it("spawns 'devin acp' with default settings", () => { + const settings = decodeDevinSettings({}); + const input = buildDevinAcpSpawnInput(settings, "/work"); + expect(input.command).toBe("devin"); + expect(input.args).toEqual(["acp"]); + expect(input.cwd).toBe("/work"); + expect(input.env).toEqual({}); + }); + + it("maps permissionMode to env var", () => { + const settings = decodeDevinSettings({ + permissionMode: "smart", + }); + const input = buildDevinAcpSpawnInput(settings, "/work"); + expect(input.command).toBe("devin"); + expect(input.args).toEqual(["acp"]); + expect(input.env).toMatchObject({ + DEVIN_PERMISSION_MODE: "smart", + }); + }); + + it("omits default permissionMode", () => { + const settings = decodeDevinSettings({ + permissionMode: "normal", + }); + const input = buildDevinAcpSpawnInput(settings, "/work"); + expect(input.env).toEqual({}); + }); + + it("uses the configured binaryPath", () => { + const settings = decodeDevinSettings({ + binaryPath: "/usr/local/bin/devin", + }); + const input = buildDevinAcpSpawnInput(settings, "/work"); + expect(input.command).toBe("/usr/local/bin/devin"); + }); + + it("merges environment variables", () => { + const env = { FOO: "bar" }; + const input = buildDevinAcpSpawnInput(decodeDevinSettings({}), "/work", env); + expect(input.env).toStrictEqual({ FOO: "bar" }); + expect(input.env).not.toBe(env); + }); +}); + +describe("resolveDevinAcpBaseModelId", () => { + it("trims and normalizes model slugs", () => { + expect(resolveDevinAcpBaseModelId(" opus ")).toBe("opus"); + }); + + it("falls back to 'adaptive' when blank", () => { + expect(resolveDevinAcpBaseModelId("")).toBe("adaptive"); + expect(resolveDevinAcpBaseModelId(undefined)).toBe("adaptive"); + }); +}); + +describe("resolveDevinAcpModelSelection", () => { + it("returns the family slug and reasoning option", () => { + const modelSelection = { + instanceId: ProviderInstanceId.make("devin"), + model: "claude-opus-5", + options: [{ id: "reasoning", value: "high" }], + }; + expect(resolveDevinAcpModelSelection(modelSelection)).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: "high", + }); + }); + + it("falls back to the family slug when no reasoning option is set", () => { + const modelSelection = { + instanceId: ProviderInstanceId.make("devin"), + model: "claude-opus-5", + }; + expect(resolveDevinAcpModelSelection(modelSelection)).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: undefined, + }); + }); +}); + +describe("applyDevinAcpModelSelection", () => { + it.effect("sets the model through the model config option", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + const result = yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { familySlug: "claude-opus-5", reasoningValue: undefined }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "claude-opus-5", name: "Claude Opus 5" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("claude-opus-5"); + expect(setConfigOption).not.toHaveBeenCalled(); + expect(result).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: undefined, + }); + }), + ); + + it.effect("sets reasoning through the effort config option when present", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + const result = yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { familySlug: "claude-opus-5", reasoningValue: "high" }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "claude-opus-5", name: "Claude Opus 5" }, + ], + }, + { + id: "effort", + name: "Effort", + category: "thought_level", + type: "select", + currentValue: "default", + options: [ + { value: "default", name: "Default" }, + { value: "high", name: "High" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("claude-opus-5"); + expect(setConfigOption).toHaveBeenCalledWith("effort", "high"); + expect(result).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: "high", + }); + }), + ); + + it.effect("falls back to a variant slug when the family slug is not in the model list", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { familySlug: "claude-opus-5", reasoningValue: "high" }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "claude-opus-5-high", name: "Claude Opus 5 High" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("claude-opus-5-high"); + }), + ); + + it.effect("normalizes a legacy reasoning option value that contains the family slug", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { + familySlug: "swe-1-7", + reasoningValue: "swe-1-7-medium", + }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "swe-1-7", name: "SWE-1.7" }, + ], + }, + { + id: "effort", + name: "Effort", + category: "thought_level", + type: "select", + currentValue: "default", + options: [ + { value: "max", name: "Max" }, + { value: "medium", name: "Medium" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("swe-1-7"); + expect(setConfigOption).toHaveBeenCalledWith("effort", "medium"); + }), + ); + + it.effect("fails when no model config option is discovered and a model switch is needed", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + const result = yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { familySlug: "claude-opus-5", reasoningValue: "high" }, + configOptions: [ + { + id: "effort", + name: "Effort", + category: "thought_level", + type: "select", + currentValue: "default", + options: [ + { value: "default", name: "Default" }, + { value: "high", name: "High" }, + ], + }, + ], + mapError: (cause) => cause, + }).pipe(Effect.result); + + expect(Result.isFailure(result)).toBe(true); + if (Result.isFailure(result)) { + expect(result.failure._tag).toBe("AcpRequestError"); + expect(result.failure.message).toContain("no model session config option was found"); + } + expect(setModel).not.toHaveBeenCalled(); + expect(setConfigOption).not.toHaveBeenCalled(); + }), + ); + + it.effect("resets reasoning to default when the user requests the default reasoning value", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + const result = yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: { familySlug: "claude-opus-5", reasoningValue: "high" }, + requested: { + familySlug: "claude-opus-5", + reasoningValue: "default", + }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "claude-opus-5", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "claude-opus-5", name: "Claude Opus 5" }, + ], + }, + { + id: "effort", + name: "Effort", + category: "thought_level", + type: "select", + currentValue: "high", + options: [ + { value: "default", name: "Default" }, + { value: "high", name: "High" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).not.toHaveBeenCalled(); + expect(setConfigOption).toHaveBeenCalledWith("effort", "default"); + expect(result).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: undefined, + }); + }), + ); + + it.effect("maps a reasoning synonym to an allowed reasoning config value", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + const result = yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { + familySlug: "claude-opus-5", + reasoningValue: "no-thinking", + }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "claude-opus-5", name: "Claude Opus 5" }, + ], + }, + { + id: "reasoning", + name: "Reasoning", + category: "thought_level", + type: "select", + currentValue: "low", + options: [ + { value: "none", name: "None" }, + { value: "low", name: "Low" }, + { value: "medium", name: "Medium" }, + { value: "high", name: "High" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("claude-opus-5"); + expect(setConfigOption).toHaveBeenCalledWith("reasoning", "none"); + expect(result).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: "none", + }); + }), + ); + + it.effect( + "uses the base model when default reasoning is requested and no reasoning config is present", + () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + const result = yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { + familySlug: "claude-opus-5", + reasoningValue: "default", + }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "claude-opus-5", name: "Claude Opus 5" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("claude-opus-5"); + expect(setConfigOption).not.toHaveBeenCalled(); + expect(result).toEqual({ + familySlug: "claude-opus-5", + reasoningValue: undefined, + }); + }), + ); +}); + +describe("Devin reasoning variant synonyms", () => { + it.effect("maps no-thinking to the none variant", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { familySlug: "glm-5-2", reasoningValue: "no-thinking" }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "glm-5-2", name: "GLM-5.2" }, + { value: "glm-5-2-none", name: "GLM-5.2 No Thinking" }, + { value: "glm-5-2-1m", name: "GLM-5.2 No Thinking 1M" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("glm-5-2-none"); + expect(setConfigOption).not.toHaveBeenCalled(); + }), + ); + + it.effect("maps no-thinking-1m to the 1m variant", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { familySlug: "glm-5-2", reasoningValue: "no-thinking-1m" }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "glm-5-2", name: "GLM-5.2" }, + { value: "glm-5-2-none", name: "GLM-5.2 No Thinking" }, + { value: "glm-5-2-1m", name: "GLM-5.2 No Thinking 1M" }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("glm-5-2-1m"); + expect(setConfigOption).not.toHaveBeenCalled(); + }), + ); + + it.effect("maps lightning-medium to the lightning-medium variant", () => + Effect.gen(function* () { + const setModel = vi.fn().mockReturnValue(Effect.void); + const setConfigOption = vi.fn().mockReturnValue(Effect.succeed({ configOptions: [] })); + + yield* applyDevinAcpModelSelection({ + runtime: { setModel, setConfigOption }, + current: undefined, + requested: { + familySlug: "swe-1-7", + reasoningValue: "lightning-medium", + }, + configOptions: [ + { + id: "model", + name: "Model", + category: "model", + type: "select", + currentValue: "adaptive", + options: [ + { value: "adaptive", name: "Adaptive" }, + { value: "swe-1-7", name: "SWE-1.7" }, + { value: "swe-1-7-medium", name: "SWE-1.7 Medium" }, + { value: "swe-1-7-lightning", name: "SWE-1.7 Lightning" }, + { + value: "swe-1-7-lightning-medium", + name: "SWE-1.7 Lightning Medium", + }, + ], + }, + ], + mapError: (cause) => cause, + }); + + expect(setModel).toHaveBeenCalledWith("swe-1-7-lightning-medium"); + expect(setConfigOption).not.toHaveBeenCalled(); + }), + ); +}); + +describe("Devin ACP auth method", () => { + it("uses the devin-browser auth method advertised by the ACP agent", () => { + expect(DEVIN_AUTH_METHOD_ID).toBe("devin-browser"); + }); +}); diff --git a/apps/server/src/provider/acp/DevinAcpSupport.ts b/apps/server/src/provider/acp/DevinAcpSupport.ts new file mode 100644 index 000000000000..140cbf34b07a --- /dev/null +++ b/apps/server/src/provider/acp/DevinAcpSupport.ts @@ -0,0 +1,373 @@ +import { type DevinSettings, type ModelSelection, ProviderDriverKind } from "@t3tools/contracts"; +import { tokenizeCliArgs } from "@t3tools/shared/cliArgs"; +import { getModelSelectionStringOptionValue, normalizeModelSlug } from "@t3tools/shared/model"; +import * as Crypto from "effect/Crypto"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Scope from "effect/Scope"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; +import * as EffectAcpErrors from "effect-acp/errors"; +import type * as EffectAcpSchema from "effect-acp/schema"; + +import { + collectSessionConfigOptionValues, + findSessionConfigOption, + isModelConfigOption, +} from "./AcpRuntimeModel.ts"; +import * as AcpSessionRuntime from "./AcpSessionRuntime.ts"; + +export const DEVIN_AUTH_METHOD_ID = "devin-browser"; +const DEVIN_DRIVER_KIND = ProviderDriverKind.make("devin"); + +const DEVIN_REASONING_CONFIG_OPTION_IDS = new Set(["effort", "thought_level", "reasoning"]); + +type DevinAcpRuntimeDevinSettings = Pick< + DevinSettings, + "binaryPath" | "homePath" | "launchArgs" | "permissionMode" +>; + +export interface DevinAcpRuntimeInput extends Omit< + AcpSessionRuntime.AcpSessionRuntimeOptions, + "authMethodId" | "clientCapabilities" | "spawn" +> { + readonly childProcessSpawner: ChildProcessSpawner.ChildProcessSpawner["Service"]; + readonly devinSettings: DevinAcpRuntimeDevinSettings | null | undefined; + readonly environment?: NodeJS.ProcessEnv; +} + +export function buildDevinAcpSpawnInput( + devinSettings: DevinAcpRuntimeDevinSettings | null | undefined, + cwd: string, + environment?: NodeJS.ProcessEnv, +): AcpSessionRuntime.AcpSpawnInput { + const args: string[] = ["acp", ...tokenizeCliArgs(devinSettings?.launchArgs)]; + + const env: NodeJS.ProcessEnv = { ...environment }; + const permissionMode = devinSettings?.permissionMode?.trim(); + if (permissionMode && permissionMode !== "normal") { + env.DEVIN_PERMISSION_MODE = permissionMode; + } + + return { + command: devinSettings?.binaryPath || "devin", + args, + cwd, + env, + }; +} + +export const makeDevinAcpRuntime = ( + input: DevinAcpRuntimeInput, +): Effect.Effect< + AcpSessionRuntime.AcpSessionRuntime["Service"], + EffectAcpErrors.AcpError, + Crypto.Crypto | Scope.Scope +> => + Effect.gen(function* () { + const acpContext = yield* Layer.build( + AcpSessionRuntime.layer({ + ...input, + spawn: buildDevinAcpSpawnInput(input.devinSettings, input.cwd, input.environment), + authMethodId: DEVIN_AUTH_METHOD_ID, + }).pipe( + Layer.provide( + Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner), + ), + ), + ); + return yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe( + Effect.provide(acpContext), + ); + }); + +export function resolveDevinAcpBaseModelId(model: string | null | undefined): string { + const base = model?.trim() || "adaptive"; + return normalizeModelSlug(base, DEVIN_DRIVER_KIND) ?? base; +} + +export interface DevinAcpModelSelection { + readonly familySlug: string; + readonly reasoningValue: string | undefined; +} + +export function resolveDevinAcpModelSelection( + modelSelection: ModelSelection | null | undefined, +): DevinAcpModelSelection | undefined { + if (!modelSelection) { + return undefined; + } + const familySlug = resolveDevinAcpBaseModelId(modelSelection.model); + const reasoningValue = getModelSelectionStringOptionValue(modelSelection, "reasoning"); + return { + familySlug, + reasoningValue: reasoningValue?.trim() || undefined, + }; +} + +function normalizeDevinReasoningVariant(variant: string): string { + return variant + .toLowerCase() + .replace(/[.\/\s]+/g, "-") + .replace(/^-|-$/g, "") + .replace(/-+/g, "-"); +} + +function expandDevinReasoningVariants(reasoningValue: string | undefined): ReadonlyArray { + if (!reasoningValue) { + return []; + } + const normalized = normalizeDevinReasoningVariant(reasoningValue); + const variants = new Set([normalized]); + + // Common Devin reasoning labels do not always map 1:1 to ACP model slugs. + // Add synonyms so the picker can match the variant advertised by the agent. + if (normalized === "no-thinking" || normalized === "none") { + variants.add("none"); + variants.add("no-thinking"); + } + if (normalized === "no-thinking-1m" || normalized === "none-1m" || normalized === "1m") { + variants.add("1m"); + variants.add("none-1m"); + variants.add("no-thinking-1m"); + } + if (normalized === "fast" || normalized === "priority") { + variants.add("fast"); + variants.add("priority"); + } + + return Array.from(variants); +} + +function normalizeConfigIdToken(value: string): string { + return value.toLowerCase().replace(/[\s_-]+/g, ""); +} + +function resolveDevinDefaultReasoningValue( + allowedReasoningValues: ReadonlyArray, +): string | undefined { + if (allowedReasoningValues.length === 0) { + return undefined; + } + const clearValue = ["default", "none", "no-thinking"].find((variant) => + allowedReasoningValues.includes(variant), + ); + return clearValue ?? allowedReasoningValues[0]; +} + +function isDevinReasoningConfigOption(option: EffectAcpSchema.SessionConfigOption): boolean { + if (option.category === "thought_level") return true; + const id = normalizeConfigIdToken(option.id); + if (DEVIN_REASONING_CONFIG_OPTION_IDS.has(id)) return true; + if ( + option.category !== undefined && + option.category !== null && + option.category !== "model_config" + ) { + return false; + } + const name = normalizeConfigIdToken(option.name); + return /reasoning|effort|thinking/.test(name); +} + +function findDevinAcpModelConfigId( + configOptions: ReadonlyArray | null | undefined, +): string | undefined { + if (!configOptions) return undefined; + for (const option of configOptions) { + if (isModelConfigOption(option)) { + return option.id; + } + } + return undefined; +} + +function findDevinAcpReasoningConfigId( + configOptions: ReadonlyArray | null | undefined, +): string | undefined { + if (!configOptions) return undefined; + for (const option of configOptions) { + if (isDevinReasoningConfigOption(option)) { + return option.id; + } + } + return undefined; +} + +function getConfigOptionCurrentValue( + configOptions: ReadonlyArray | null | undefined, + configId: string | undefined, +): string | undefined { + if (!configId || !configOptions) return undefined; + const option = findSessionConfigOption(configOptions, configId); + if (!option || option.type !== "select") return undefined; + return option.currentValue.trim() || undefined; +} + +export function currentDevinAcpModelSelection( + sessionSetupResult: + | EffectAcpSchema.LoadSessionResponse + | EffectAcpSchema.NewSessionResponse + | EffectAcpSchema.ResumeSessionResponse, +): DevinAcpModelSelection | undefined { + const configOptions = sessionSetupResult.configOptions; + const modelConfigId = findDevinAcpModelConfigId(configOptions); + const reasoningConfigId = findDevinAcpReasoningConfigId(configOptions); + const familySlug = getConfigOptionCurrentValue(configOptions, modelConfigId); + if (!familySlug) return undefined; + return { + familySlug, + reasoningValue: getConfigOptionCurrentValue(configOptions, reasoningConfigId), + }; +} + +export function applyDevinAcpModelSelection(input: { + readonly runtime: Pick< + AcpSessionRuntime.AcpSessionRuntime["Service"], + "setModel" | "setConfigOption" + >; + readonly current: DevinAcpModelSelection | undefined; + readonly requested: DevinAcpModelSelection | undefined; + readonly configOptions: ReadonlyArray; + readonly mapError: (cause: EffectAcpErrors.AcpError) => E; +}): Effect.Effect { + if (!input.requested) { + return Effect.succeed(input.current); + } + + const requested = input.requested; + const current = input.current; + const modelConfigId = findDevinAcpModelConfigId(input.configOptions); + const reasoningConfigId = findDevinAcpReasoningConfigId(input.configOptions); + + const requestedReasoningDefault = requested.reasoningValue === "default"; + const requestedReasoning = + requested.reasoningValue === requested.familySlug || requestedReasoningDefault + ? undefined + : requested.reasoningValue; + + const needsModelSwitch = !current || requested.familySlug !== current.familySlug; + const needsReasoningSwitch = + reasoningConfigId !== undefined && + (requestedReasoningDefault || + (requestedReasoning !== undefined && requestedReasoning !== current?.reasoningValue)); + + if (!needsModelSwitch && !needsReasoningSwitch) { + return Effect.succeed(current); + } + + let resultReasoningValue: string | undefined = requestedReasoningDefault + ? undefined + : requested.reasoningValue; + + return Effect.gen(function* () { + if (needsModelSwitch) { + if (modelConfigId === undefined) { + return yield* Effect.fail( + input.mapError( + new EffectAcpErrors.AcpRequestError({ + code: -32602, + errorMessage: `Unable to set model: no model session config option was found`, + data: { + requestedModel: requested.familySlug, + configOptions: input.configOptions.map((o) => o.id), + }, + }), + ), + ); + } + + const modelOption = findSessionConfigOption(input.configOptions, modelConfigId); + const allowedModelValues = modelOption ? collectSessionConfigOptionValues(modelOption) : []; + + const variantCandidates: string[] = []; + if (requestedReasoning !== undefined) { + for (const variant of expandDevinReasoningVariants(requestedReasoning)) { + variantCandidates.push(`${requested.familySlug}-${variant}`); + variantCandidates.push(`${requested.familySlug}/${variant}`); + } + } + const baseCandidates = [requested.familySlug]; + + const effectiveModel = + variantCandidates.find((candidate) => allowedModelValues.includes(candidate)) ?? + allowedModelValues.find((value) => + variantCandidates.some( + (candidate) => + value.endsWith(`/${candidate}`) || + value.endsWith(`-${candidate}`) || + value === candidate, + ), + ) ?? + baseCandidates.find((candidate) => allowedModelValues.includes(candidate)); + + if (effectiveModel === undefined) { + return yield* Effect.fail( + input.mapError( + new EffectAcpErrors.AcpRequestError({ + code: -32602, + errorMessage: `Invalid model value "${requested.familySlug}" for session config option "${modelConfigId}"`, + data: { + configId: modelConfigId, + receivedValue: requested.familySlug, + allowedValues: allowedModelValues, + }, + }), + ), + ); + } + yield* input.runtime.setModel(effectiveModel).pipe(Effect.mapError(input.mapError)); + } + + if (needsReasoningSwitch && reasoningConfigId !== undefined) { + const reasoningOption = findSessionConfigOption(input.configOptions, reasoningConfigId); + const allowedReasoningValues = reasoningOption + ? collectSessionConfigOptionValues(reasoningOption) + : []; + const effectiveReasoning = requestedReasoningDefault + ? resolveDevinDefaultReasoningValue(allowedReasoningValues) + : requestedReasoning && allowedReasoningValues.length > 0 + ? (allowedReasoningValues.find((value) => + expandDevinReasoningVariants(requestedReasoning).some( + (variant) => variant === value || variant.endsWith(`-${value}`), + ), + ) ?? requestedReasoning) + : requestedReasoning; + + if (effectiveReasoning !== undefined) { + yield* input.runtime + .setConfigOption(reasoningConfigId, effectiveReasoning) + .pipe(Effect.mapError(input.mapError)); + if (!requestedReasoningDefault) { + resultReasoningValue = effectiveReasoning; + } + } + } + + return { + familySlug: requested.familySlug, + reasoningValue: resultReasoningValue, + }; + }); +} + +export function buildDevinDiscoveredModelsFromSessionModelState( + modelState: EffectAcpSchema.SessionModelState | null | undefined, +): ReadonlyArray<{ slug: string; name: string }> { + if (!modelState || modelState.availableModels.length === 0) { + return []; + } + const seen = new Set(); + return modelState.availableModels + .map((model) => { + const slug = resolveDevinAcpBaseModelId(model.modelId); + if (!slug || seen.has(slug)) { + return undefined; + } + seen.add(slug); + return { + slug, + name: model.name.trim() || slug, + }; + }) + .filter((model): model is { slug: string; name: string } => model !== undefined); +} diff --git a/apps/server/src/provider/builtInDrivers.ts b/apps/server/src/provider/builtInDrivers.ts index 791a96e1da3c..318d450edfd9 100644 --- a/apps/server/src/provider/builtInDrivers.ts +++ b/apps/server/src/provider/builtInDrivers.ts @@ -23,6 +23,7 @@ import { ClaudeDriver, type ClaudeDriverEnv } from "./Drivers/ClaudeDriver.ts"; import { CodexDriver, type CodexDriverEnv } from "./Drivers/CodexDriver.ts"; import { CursorDriver, type CursorDriverEnv } from "./Drivers/CursorDriver.ts"; +import { DevinDriver, type DevinDriverEnv } from "./Drivers/DevinDriver.ts"; import { GrokDriver, type GrokDriverEnv } from "./Drivers/GrokDriver.ts"; import { OpenCodeDriver, type OpenCodeDriverEnv } from "./Drivers/OpenCodeDriver.ts"; import type { AnyProviderDriver } from "./ProviderDriver.ts"; @@ -36,6 +37,7 @@ export type BuiltInDriversEnv = | ClaudeDriverEnv | CodexDriverEnv | CursorDriverEnv + | DevinDriverEnv | GrokDriverEnv | OpenCodeDriverEnv; @@ -48,6 +50,7 @@ export const BUILT_IN_DRIVERS: ReadonlyArray { return Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; - const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-provider-cache-invalid-" }); + const tempDir = yield* fs.makeTempDirectoryScoped({ + prefix: "t3-provider-cache-invalid-", + }); const cachePath = `${tempDir}/provider.json`; const secretCacheValue = "secret-cache-value"; yield* fs.writeFileString(cachePath, `{ "token": "${secretCacheValue}" }`); @@ -79,7 +81,9 @@ it.layer(NodeServices.layer)("providerStatusCache", (it) => { it.effect("writes and reads provider status snapshots", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; - const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-provider-cache-" }); + const tempDir = yield* fs.makeTempDirectoryScoped({ + prefix: "t3-provider-cache-", + }); const codexProvider = makeProvider(CODEX_DRIVER); const claudeProvider = makeProvider(CLAUDE_AGENT_DRIVER, { status: "warning", diff --git a/apps/server/src/provider/providerStatusCache.ts b/apps/server/src/provider/providerStatusCache.ts index 2fe0424b4f57..e625189926a6 100644 --- a/apps/server/src/provider/providerStatusCache.ts +++ b/apps/server/src/provider/providerStatusCache.ts @@ -1,5 +1,5 @@ import { - type ProviderDriverKind, + ProviderDriverKind, type ProviderInstanceId, type ServerProvider, ServerProvider as ServerProviderSchema, @@ -57,9 +57,11 @@ export const hydrateCachedProvider = (input: { } const { message: _fallbackMessage, ...fallbackWithoutMessage } = input.fallbackProvider; + + const merged = mergeProviderModels(input.fallbackProvider.models, input.cachedProvider.models); const hydratedProvider: ServerProvider = { ...fallbackWithoutMessage, - models: mergeProviderModels(input.fallbackProvider.models, input.cachedProvider.models), + models: merged, installed: input.cachedProvider.installed, version: input.cachedProvider.version, status: input.cachedProvider.status, diff --git a/apps/server/src/provider/testFixtures/devin-models-list.txt b/apps/server/src/provider/testFixtures/devin-models-list.txt new file mode 100644 index 000000000000..2e32c1fe74b2 --- /dev/null +++ b/apps/server/src/provider/testFixtures/devin-models-list.txt @@ -0,0 +1,92 @@ +{ + "families": [ + { + "family_label": "Claude Opus 5", + "family_uid": "claude-opus-5", + "slug": "claude-opus-5", + "variants": [ + { "model_uid": "claude-opus-5-medium", "label": "Claude Opus 5 Medium" }, + { "model_uid": "claude-opus-5-low-fast", "label": "Claude Opus 5 Low Fast" }, + { "model_uid": "claude-opus-5-high", "label": "Claude Opus 5 High" } + ] + }, + { + "family_label": "Claude Sonnet 4.5", + "family_uid": "claude-sonnet-4-5", + "slug": "claude-sonnet-4-5", + "variants": [ + { "model_uid": "claude-sonnet-4-5-medium", "label": "Claude Sonnet 4.5 Medium" } + ] + }, + { + "family_label": "Claude Fable 5", + "family_uid": "claude-fable-5", + "slug": "claude-fable-5", + "variants": [ + { "model_uid": "claude-fable-5-medium", "label": "Claude Fable 5 Medium" } + ] + }, + { + "family_label": "Gemini 3 Flash", + "family_uid": "gemini-3-flash", + "slug": "gemini-3-flash", + "variants": [ + { "model_uid": "gemini-3-flash-medium", "label": "Gemini 3 Flash Medium" } + ] + }, + { + "family_label": "GPT-4.1", + "family_uid": "gpt-4-1", + "slug": "gpt-4-1", + "variants": [ + { "model_uid": "gpt-4-1-medium", "label": "GPT-4.1 Medium" } + ] + }, + { + "family_label": "GPT-5.2", + "family_uid": "gpt-5-2", + "slug": "gpt-5.2", + "variants": [ + { "model_uid": "gpt-5-2-medium", "label": "GPT-5.2 Medium" }, + { "model_uid": "gpt-5-2-none", "label": "GPT-5.2 No Thinking" }, + { "model_uid": "gpt-5-2-1m", "label": "GPT-5.2 No Thinking 1M" } + ] + }, + { + "family_label": "SWE-1.7", + "family_uid": "swe-1.7", + "slug": "swe-1.7", + "variants": [ + { "model_uid": "swe-1-7", "label": "SWE-1.7 Max" }, + { "model_uid": "swe-1-7-medium", "label": "SWE-1.7 Medium" } + ] + }, + { + "family_label": "SWE-1.7 Lightning", + "family_uid": "swe-1.7-lightning", + "slug": "swe-1.7-lightning", + "variants": [ + { "model_uid": "swe-1-7-lightning", "label": "SWE-1.7 Lightning Max" }, + { "model_uid": "swe-1-7-lightning-medium", "label": "SWE-1.7 Lightning Medium" } + ] + }, + { + "family_label": "GLM-5.2", + "family_uid": "glm-5.2", + "slug": "glm-5.2", + "variants": [ + { "model_uid": "glm-5-2", "label": "GLM-5.2" }, + { "model_uid": "glm-5-2-none", "label": "GLM-5.2 No Thinking" }, + { "model_uid": "glm-5-2-1m", "label": "GLM-5.2 No Thinking 1M" } + ] + }, + { + "family_label": "Adaptive", + "family_uid": "adaptive", + "slug": "adaptive", + "variants": [ + { "model_uid": "adaptive", "label": "Adaptive" } + ] + } + ] +} diff --git a/apps/server/src/textGeneration/DevinTextGeneration.ts b/apps/server/src/textGeneration/DevinTextGeneration.ts new file mode 100644 index 000000000000..f922d0ac3020 --- /dev/null +++ b/apps/server/src/textGeneration/DevinTextGeneration.ts @@ -0,0 +1,268 @@ +import * as Crypto from "effect/Crypto"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import { ChildProcessSpawner } from "effect/unstable/process"; +import type * as EffectAcpErrors from "effect-acp/errors"; + +import { type DevinSettings, type ModelSelection } from "@t3tools/contracts"; +import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git"; +import { extractJsonObject } from "@t3tools/shared/schemaJson"; + +import { TextGenerationError } from "@t3tools/contracts"; +import * as TextGeneration from "./TextGeneration.ts"; +import { + buildBranchNamePrompt, + buildCommitMessagePrompt, + buildPrContentPrompt, + buildThreadTitlePrompt, +} from "./TextGenerationPrompts.ts"; +import { + sanitizeCommitSubject, + sanitizePrTitle, + sanitizeThreadTitle, +} from "./TextGenerationUtils.ts"; +import { + applyDevinAcpModelSelection, + currentDevinAcpModelSelection, + makeDevinAcpRuntime, + resolveDevinAcpBaseModelId, + resolveDevinAcpModelSelection, +} from "../provider/acp/DevinAcpSupport.ts"; + +const DEVIN_TIMEOUT_MS = 180_000; + +const isTextGenerationError = Schema.is(TextGenerationError); + +export const makeDevinTextGeneration = Effect.fn("makeDevinTextGeneration")(function* ( + devinSettings: DevinSettings, + environment: NodeJS.ProcessEnv = process.env, +) { + const crypto = yield* Crypto.Crypto; + const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; + + const runDevinJson = ({ + operation, + cwd, + prompt, + outputSchemaJson, + modelSelection, + }: { + operation: + | "generateCommitMessage" + | "generatePrContent" + | "generateBranchName" + | "generateThreadTitle"; + cwd: string; + prompt: string; + outputSchemaJson: S; + modelSelection: ModelSelection; + }): Effect.Effect => + Effect.gen(function* () { + const resolvedModel = resolveDevinAcpBaseModelId(modelSelection.model); + const outputRef = yield* Ref.make(""); + const runtime = yield* makeDevinAcpRuntime({ + devinSettings, + environment, + childProcessSpawner: commandSpawner, + cwd, + clientInfo: { name: "t3-code-git-text", version: "0.0.0" }, + }).pipe(Effect.provideService(Crypto.Crypto, crypto)); + + yield* runtime.handleSessionUpdate((notification) => { + const update = notification.update; + if (update.sessionUpdate !== "agent_message_chunk") { + return Effect.void; + } + const content = update.content; + if (content.type !== "text") { + return Effect.void; + } + return Ref.update(outputRef, (current) => current + content.text); + }); + + const promptResult = yield* Effect.gen(function* () { + const started = yield* runtime.start(); + yield* applyDevinAcpModelSelection({ + runtime, + current: currentDevinAcpModelSelection(started.sessionSetupResult), + requested: resolveDevinAcpModelSelection(modelSelection) ?? { + familySlug: resolvedModel, + reasoningValue: undefined, + }, + configOptions: started.sessionSetupResult.configOptions ?? [], + mapError: (cause) => + new TextGenerationError({ + operation, + detail: "Failed to set Devin ACP base model for text generation.", + cause, + }), + }); + + return yield* runtime.prompt({ + prompt: [{ type: "text", text: prompt }], + }); + }).pipe( + Effect.timeoutOption(DEVIN_TIMEOUT_MS), + Effect.flatMap( + Option.match({ + onNone: () => + Effect.fail( + new TextGenerationError({ + operation, + detail: "Devin ACP request timed out.", + }), + ), + onSome: (value) => Effect.succeed(value), + }), + ), + Effect.mapError((cause: EffectAcpErrors.AcpError | TextGenerationError) => + isTextGenerationError(cause) + ? cause + : new TextGenerationError({ + operation, + detail: "Devin ACP request failed.", + cause, + }), + ), + ); + + const trimmed = (yield* Ref.get(outputRef)).trim(); + if (!trimmed) { + return yield* new TextGenerationError({ + operation, + detail: + promptResult.stopReason === "cancelled" + ? "Devin ACP request was cancelled." + : "Devin Agent returned empty output.", + }); + } + + const decodeOutput = Schema.decodeEffect(Schema.fromJsonString(outputSchemaJson)); + return yield* decodeOutput(extractJsonObject(trimmed)).pipe( + Effect.catchTags({ + SchemaError: (cause) => + Effect.fail( + new TextGenerationError({ + operation, + detail: "Devin Agent returned invalid structured output.", + cause, + }), + ), + }), + ); + }).pipe( + Effect.mapError((cause) => + isTextGenerationError(cause) + ? cause + : new TextGenerationError({ + operation, + detail: "Devin ACP text generation failed.", + cause, + }), + ), + Effect.scoped, + ); + + const generateCommitMessage: TextGeneration.TextGeneration["Service"]["generateCommitMessage"] = + Effect.fn("DevinTextGeneration.generateCommitMessage")(function* (input) { + const { prompt, outputSchema } = buildCommitMessagePrompt({ + branch: input.branch, + stagedSummary: input.stagedSummary, + stagedPatch: input.stagedPatch, + includeBranch: input.includeBranch === true, + policy: input.policy, + }); + + const generated = yield* runDevinJson({ + operation: "generateCommitMessage", + cwd: input.cwd, + prompt, + outputSchemaJson: outputSchema, + modelSelection: input.modelSelection, + }); + + return { + subject: sanitizeCommitSubject(generated.subject), + body: generated.body.trim(), + ...("branch" in generated && typeof generated.branch === "string" + ? { branch: sanitizeFeatureBranchName(generated.branch) } + : {}), + }; + }); + + const generatePrContent: TextGeneration.TextGeneration["Service"]["generatePrContent"] = + Effect.fn("DevinTextGeneration.generatePrContent")(function* (input) { + const { prompt, outputSchema } = buildPrContentPrompt({ + baseBranch: input.baseBranch, + headBranch: input.headBranch, + commitSummary: input.commitSummary, + diffSummary: input.diffSummary, + diffPatch: input.diffPatch, + policy: input.policy, + changeRequestTemplate: input.changeRequestTemplate, + }); + + const generated = yield* runDevinJson({ + operation: "generatePrContent", + cwd: input.cwd, + prompt, + outputSchemaJson: outputSchema, + modelSelection: input.modelSelection, + }); + + return { + title: sanitizePrTitle(generated.title), + body: generated.body.trim(), + }; + }); + + const generateBranchName: TextGeneration.TextGeneration["Service"]["generateBranchName"] = + Effect.fn("DevinTextGeneration.generateBranchName")(function* (input) { + const { prompt, outputSchema } = buildBranchNamePrompt({ + message: input.message, + attachments: input.attachments, + }); + + const generated = yield* runDevinJson({ + operation: "generateBranchName", + cwd: input.cwd, + prompt, + outputSchemaJson: outputSchema, + modelSelection: input.modelSelection, + }); + + return { + branch: sanitizeBranchFragment(generated.branch), + }; + }); + + const generateThreadTitle: TextGeneration.TextGeneration["Service"]["generateThreadTitle"] = + Effect.fn("DevinTextGeneration.generateThreadTitle")(function* (input) { + const { prompt, outputSchema } = buildThreadTitlePrompt({ + message: input.message, + previousTitle: input.previousTitle, + attachments: input.attachments, + }); + + const generated = yield* runDevinJson({ + operation: "generateThreadTitle", + cwd: input.cwd, + prompt, + outputSchemaJson: outputSchema, + modelSelection: input.modelSelection, + }); + + return { + title: sanitizeThreadTitle(generated.title), + } satisfies TextGeneration.ThreadTitleGenerationResult; + }); + + return { + generateCommitMessage, + generatePrContent, + generateBranchName, + generateThreadTitle, + } satisfies TextGeneration.TextGeneration["Service"]; +}); diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts index 0bf131ac973b..da23cd93bcc6 100644 --- a/apps/server/src/usage/UsageService.ts +++ b/apps/server/src/usage/UsageService.ts @@ -37,6 +37,7 @@ import { ServerConfig } from "../config.ts"; import * as ServerSettings from "../serverSettings.ts"; import { resolveClaudeHomePath } from "../provider/Drivers/ClaudeHome.ts"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; +import { resolveDevinHomePath } from "../provider/Drivers/DevinHome.ts"; import { UsageAggregator } from "./usageAggregation.ts"; import { parseRateTable, type RateTable } from "./usagePricing.ts"; import { @@ -218,10 +219,17 @@ export const make = Effect.gen(function* () { const claudeHome = yield* resolveClaudeHomePath(settings.providers.claudeAgent); const claudeDir = yield* resolveClaudeTranscriptDir(claudeHome); const codexLayout = yield* resolveCodexHomeLayout(settings.providers.codex); + const devinHome = yield* resolveDevinHomePath(settings.providers.devin).pipe( + Effect.provideService(Path.Path, path), + ); return [ { provider: "claude" as const, dir: claudeDir }, - { provider: "codex" as const, dir: path.join(codexLayout.sharedHomePath, "sessions") }, + { + provider: "codex" as const, + dir: path.join(codexLayout.sharedHomePath, "sessions"), + }, + { provider: "devin" as const, dir: devinHome }, ]; }); diff --git a/apps/server/src/usage/usageScanCache.test.ts b/apps/server/src/usage/usageScanCache.test.ts index 64673e96c090..c0d940b2fa61 100644 --- a/apps/server/src/usage/usageScanCache.test.ts +++ b/apps/server/src/usage/usageScanCache.test.ts @@ -50,6 +50,21 @@ describe("scan cache round trip", () => { expect(restored.get("/b.jsonl")).toEqual(original.get("/b.jsonl")); }); + it("restores devin records unchanged", () => { + const original: ScanCache = new Map(); + original.set("/devin/session.jsonl", { + size: 50, + mtimeMs: 100, + provider: "devin", + records: [record({ provider: "devin", model: "devin-preview" })], + }); + + const restored = decodeScanCache(JSON.parse(JSON.stringify(encodeScanCache(original)))); + + expect(restored.size).toBe(1); + expect(restored.get("/devin/session.jsonl")).toEqual(original.get("/devin/session.jsonl")); + }); + it("interns repeated model and session strings", () => { const encoded = encodeScanCache( cacheWith([["/a.jsonl", 100, [record(), record({ dedupeKey: "msg_2:" }), record()]]]), diff --git a/apps/server/src/usage/usageScanCache.ts b/apps/server/src/usage/usageScanCache.ts index cc15ee9cee62..a0d3ec643574 100644 --- a/apps/server/src/usage/usageScanCache.ts +++ b/apps/server/src/usage/usageScanCache.ts @@ -134,7 +134,7 @@ export function decodeScanCache(document: unknown): ScanCache { if (typeof raw !== "object" || raw === null) continue; const entry = raw as Partial; if (typeof entry.s !== "number" || typeof entry.m !== "number") continue; - if (entry.p !== "claude" && entry.p !== "codex") continue; + if (entry.p !== "claude" && entry.p !== "codex" && entry.p !== "devin") continue; if (!isRecordArray(entry.r)) continue; const provider: UsageProviderKind = entry.p; diff --git a/apps/server/src/usage/usageTranscriptReader.ts b/apps/server/src/usage/usageTranscriptReader.ts index c72f0c24db65..2230f64e8809 100644 --- a/apps/server/src/usage/usageTranscriptReader.ts +++ b/apps/server/src/usage/usageTranscriptReader.ts @@ -19,12 +19,38 @@ import type { UsageProviderKind } from "@t3tools/contracts"; import { initialCodexScanState, - mightCarryUsage, parseClaudeLine, parseCodexLine, + parseDevinLine, + type CodexScanState, type UsageRecord, } from "./usageTranscripts.ts"; +interface TranscriptHandler { + readonly mightCarryUsage: (line: string) => boolean; + readonly createState?: () => CodexScanState; + readonly parseLine: (line: string, state?: CodexScanState) => UsageRecord | null; +} + +const PROVIDER_TRANSCRIPT_HANDLERS: Record = { + claude: { + mightCarryUsage: (line) => line.includes('"usage"'), + parseLine: parseClaudeLine, + }, + codex: { + mightCarryUsage: (line) => + line.includes('"token_count"') || + line.includes('"turn_context"') || + line.includes('"session_meta"'), + createState: initialCodexScanState, + parseLine: parseCodexLine, + }, + devin: { + mightCarryUsage: (line) => line.includes('"devin_usage"'), + parseLine: parseDevinLine, + }, +}; + export interface TranscriptFile { readonly path: string; readonly size: number; @@ -107,7 +133,8 @@ export async function readTranscriptRecords( provider: UsageProviderKind, ): Promise { const records: UsageRecord[] = []; - const codexState = initialCodexScanState(); + const handler = PROVIDER_TRANSCRIPT_HANDLERS[provider]; + const state = handler.createState?.(); try { const lines = NodeReadline.createInterface({ @@ -116,21 +143,8 @@ export async function readTranscriptRecords( }); for await (const line of lines) { - if (provider === "codex") { - if ( - !mightCarryUsage(line, provider) && - !line.includes('"turn_context"') && - !line.includes('"session_meta"') - ) { - continue; - } - const record = parseCodexLine(line, codexState); - if (record !== null) records.push(record); - continue; - } - - if (!mightCarryUsage(line, provider)) continue; - const record = parseClaudeLine(line); + if (!handler.mightCarryUsage(line)) continue; + const record = handler.parseLine(line, state); if (record !== null) records.push(record); } } catch { diff --git a/apps/server/src/usage/usageTranscripts.test.ts b/apps/server/src/usage/usageTranscripts.test.ts index 8f86a3d836bd..3467fee25ae9 100644 --- a/apps/server/src/usage/usageTranscripts.test.ts +++ b/apps/server/src/usage/usageTranscripts.test.ts @@ -2,8 +2,10 @@ import { describe, expect, it } from "@effect/vitest"; import { initialCodexScanState, + mightCarryUsage, parseClaudeLine, parseCodexLine, + parseDevinLine, totalTokens, } from "./usageTranscripts.ts"; @@ -71,7 +73,10 @@ describe("parseCodexLine", () => { const sessionMeta = JSON.stringify({ type: "session_meta", timestamp: "2026-08-01T05:17:41.289Z", - payload: { type: "session_meta", id: "019fbbc1-b12c-7360-a685-28c181f0025f" }, + payload: { + type: "session_meta", + id: "019fbbc1-b12c-7360-a685-28c181f0025f", + }, }); const turnContext = JSON.stringify({ type: "turn_context", @@ -158,7 +163,9 @@ describe("parseCodexLine", () => { ? {} : { source: { - subagent: { thread_spawn: { parent_thread_id: overrides.spawnParentId } }, + subagent: { + thread_spawn: { parent_thread_id: overrides.spawnParentId }, + }, }, }), }, @@ -249,3 +256,109 @@ describe("totalTokens", () => { ).toBe(100); }); }); + +describe("parseDevinLine", () => { + it("extracts token totals from a T3 Code devin_usage line", () => { + const line = JSON.stringify({ + type: "devin_usage", + timestamp: "2026-08-11T16:44:06.637Z", + sessionId: "aloud-lantana", + turnId: "af6deae3-30ba-42d4-aab7-c6908d04361d", + model: "swe-1-7", + totals: { + uncachedInputTokens: 21239, + cachedInputTokens: 448, + cacheCreationTokens: 0, + outputTokens: 89, + reasoningTokens: 0, + }, + reportedCostUsd: null, + }); + + expect(mightCarryUsage(line, "devin")).toBe(true); + + const record = parseDevinLine(line); + expect(record).not.toBeNull(); + expect(record?.provider).toBe("devin"); + expect(record?.model).toBe("swe-1.7"); + expect(record?.sessionId).toBe("aloud-lantana"); + expect(record?.totals).toEqual({ + uncachedInputTokens: 21239, + cachedInputTokens: 448, + cacheCreationTokens: 0, + outputTokens: 89, + reasoningTokens: 0, + }); + expect(record?.dedupeKey).toBe("aloud-lantana:af6deae3-30ba-42d4-aab7-c6908d04361d"); + }); + + it("rehydrates version dots from dashed Devin model slugs", () => { + expect( + parseDevinLine( + JSON.stringify({ + type: "devin_usage", + timestamp: "2026-08-11T16:44:06.637Z", + model: "swe-1-7-lightning-medium", + totals: { + uncachedInputTokens: 0, + cachedInputTokens: 0, + cacheCreationTokens: 0, + outputTokens: 0, + reasoningTokens: 0, + }, + }), + )?.model, + ).toBe("swe-1.7-lightning-medium"); + + expect( + parseDevinLine( + JSON.stringify({ + type: "devin_usage", + timestamp: "2026-08-11T16:44:06.637Z", + model: "glm-5-2", + totals: { + uncachedInputTokens: 0, + cachedInputTokens: 0, + cacheCreationTokens: 0, + outputTokens: 0, + reasoningTokens: 0, + }, + }), + )?.model, + ).toBe("glm-5.2"); + + expect( + parseDevinLine( + JSON.stringify({ + type: "devin_usage", + timestamp: "2026-08-11T16:44:06.637Z", + model: "adaptive", + totals: { + uncachedInputTokens: 0, + cachedInputTokens: 0, + cacheCreationTokens: 0, + outputTokens: 0, + reasoningTokens: 0, + }, + }), + )?.model, + ).toBe("adaptive"); + + expect( + parseDevinLine( + JSON.stringify({ + type: "devin_usage", + timestamp: "2026-08-11T16:44:06.637Z", + model: "swe-1.7", + totals: { + uncachedInputTokens: 0, + cachedInputTokens: 0, + cacheCreationTokens: 0, + outputTokens: 0, + reasoningTokens: 0, + }, + }), + )?.model, + ).toBe("swe-1.7"); + }); +}); diff --git a/apps/server/src/usage/usageTranscripts.ts b/apps/server/src/usage/usageTranscripts.ts index 49f9a1935ccc..d7f5279f6b59 100644 --- a/apps/server/src/usage/usageTranscripts.ts +++ b/apps/server/src/usage/usageTranscripts.ts @@ -6,7 +6,10 @@ * * @module usageTranscripts */ -import type { UsageProviderKind, UsageTokenTotals } from "@t3tools/contracts"; +import type { UsageProviderKind } from "@t3tools/contracts"; +import { UsageTokenTotals } from "@t3tools/contracts"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; export interface UsageRecord { readonly provider: UsageProviderKind; @@ -67,14 +70,45 @@ export function totalTokens(totals: UsageTokenTotals): number { * a 30-day window this skips roughly half the lines outright and is worth about * an order of magnitude. */ +const PROVIDER_MIGHT_CARRY_USAGE: Record boolean> = { + claude: (line) => line.includes('"usage"'), + devin: (line) => line.includes('"devin_usage"'), + codex: (line) => + line.includes('"token_count"') || + line.includes('"turn_context"') || + line.includes('"session_meta"'), +}; + export function mightCarryUsage(line: string, provider: UsageProviderKind): boolean { - return provider === "claude" ? line.includes('"usage"') : line.includes('"token_count"'); + return PROVIDER_MIGHT_CARRY_USAGE[provider](line); } /* -------------------------------------------------------------------------- */ /* Claude Code */ /* -------------------------------------------------------------------------- */ +const ClaudeUsageMessageSchema = Schema.Struct({ + id: Schema.optional(Schema.String), + model: Schema.String, + usage: Schema.Struct({ + input_tokens: Schema.optional(Schema.Number), + cache_read_input_tokens: Schema.optional(Schema.Number), + cache_creation_input_tokens: Schema.optional(Schema.Number), + output_tokens: Schema.optional(Schema.Number), + }), +}); + +const ClaudeUsageLineSchema = Schema.Struct({ + type: Schema.Literal("assistant"), + timestamp: Schema.String, + requestId: Schema.optional(Schema.String), + sessionId: Schema.optional(Schema.String), + message: ClaudeUsageMessageSchema, + costUSD: Schema.optional(Schema.NullOr(Schema.Number)), +}); + +const decodeClaudeUsageLine = Schema.decodeUnknownOption(ClaudeUsageLineSchema); + /** * Parses one line of a Claude Code transcript. * @@ -90,48 +124,38 @@ export function parseClaudeLine(line: string): UsageRecord | null { } catch { return null; } - if (typeof parsed !== "object" || parsed === null) return null; - const record = parsed as Record; - if (record["type"] !== "assistant") return null; + const result = decodeClaudeUsageLine(parsed); + if (Option.isNone(result)) return null; + const record = result.value; - const message = record["message"]; - if (typeof message !== "object" || message === null) return null; - const messageRecord = message as Record; - - const usage = messageRecord["usage"]; - if (typeof usage !== "object" || usage === null) return null; - const usageRecord = usage as Record; - - const timestampMs = parseTimestampMs(record["timestamp"]); + const timestampMs = parseTimestampMs(record.timestamp); if (timestampMs === null) return null; - const model = typeof messageRecord["model"] === "string" ? messageRecord["model"] : ""; - if (model.length === 0) return null; - - const messageId = typeof messageRecord["id"] === "string" ? messageRecord["id"] : null; - const requestId = typeof record["requestId"] === "string" ? record["requestId"] : null; + const messageId = record.message.id ?? null; + const requestId = record.requestId ?? null; // Matches ccusage: prefer the message/request pair, fall back to whichever // half exists. Records with neither cannot be de-duplicated. const dedupeKey = messageId === null && requestId === null ? null : `${messageId ?? ""}:${requestId ?? ""}`; - const cost = record["costUSD"]; - return { provider: "claude", timestampMs, - model, - sessionId: typeof record["sessionId"] === "string" ? record["sessionId"] : "", + model: record.message.model, + sessionId: record.sessionId ?? "", totals: { - uncachedInputTokens: int(usageRecord["input_tokens"]), - cachedInputTokens: int(usageRecord["cache_read_input_tokens"]), - cacheCreationTokens: int(usageRecord["cache_creation_input_tokens"]), - outputTokens: int(usageRecord["output_tokens"]), + uncachedInputTokens: int(record.message.usage.input_tokens), + cachedInputTokens: int(record.message.usage.cache_read_input_tokens), + cacheCreationTokens: int(record.message.usage.cache_creation_input_tokens), + outputTokens: int(record.message.usage.output_tokens), // Anthropic folds thinking tokens into output and does not break them out. reasoningTokens: 0, }, - reportedCostUsd: typeof cost === "number" && Number.isFinite(cost) ? cost : null, + reportedCostUsd: + record.costUSD !== undefined && record.costUSD !== null && Number.isFinite(record.costUSD) + ? record.costUSD + : null, dedupeKey, }; } @@ -177,16 +201,66 @@ export function initialCodexScanState(): CodexScanState { */ const FORK_COPY_MAX_GAP_MS = 1000; +const CodexRecordSchema = Schema.Struct({ + type: Schema.String, + timestamp: Schema.String, + payload: Schema.Unknown, +}); + +const decodeCodexRecord = Schema.decodeUnknownOption(CodexRecordSchema); + +const CodexSessionMetaPayloadSchema = Schema.Struct({ + id: Schema.optional(Schema.String), + session_id: Schema.optional(Schema.String), + forked_from_id: Schema.optional(Schema.String), + source: Schema.optional( + Schema.Struct({ + subagent: Schema.optional( + Schema.Struct({ + thread_spawn: Schema.optional( + Schema.Struct({ + parent_thread_id: Schema.optional(Schema.String), + }), + ), + }), + ), + }), + ), +}); + +type CodexSessionMetaPayload = typeof CodexSessionMetaPayloadSchema.Type; + +const decodeCodexSessionMetaPayload = Schema.decodeUnknownOption(CodexSessionMetaPayloadSchema); + +const CodexTurnContextPayloadSchema = Schema.Struct({ + model: Schema.optional(Schema.String), +}); + +const decodeCodexTurnContextPayload = Schema.decodeUnknownOption(CodexTurnContextPayloadSchema); + +const CodexLastTokenUsageSchema = Schema.Struct({ + input_tokens: Schema.optional(Schema.Number), + cached_input_tokens: Schema.optional(Schema.Number), + cache_write_input_tokens: Schema.optional(Schema.Number), + output_tokens: Schema.optional(Schema.Number), + reasoning_output_tokens: Schema.optional(Schema.Number), +}); + +const CodexTokenCountPayloadSchema = Schema.Struct({ + type: Schema.Literal("token_count"), + info: Schema.Struct({ + last_token_usage: CodexLastTokenUsageSchema, + }), +}); + +const decodeCodexTokenCountPayload = Schema.decodeUnknownOption(CodexTokenCountPayloadSchema); + /** Whether a `session_meta` payload marks the rollout as a fork or subagent. */ -function isForkedSessionMeta(payload: Record): boolean { - if (typeof payload["forked_from_id"] === "string") return true; - const source = payload["source"]; - if (typeof source !== "object" || source === null) return false; - const subagent = (source as Record)["subagent"]; - if (typeof subagent !== "object" || subagent === null) return false; - const spawn = (subagent as Record)["thread_spawn"]; - if (typeof spawn !== "object" || spawn === null) return false; - return typeof (spawn as Record)["parent_thread_id"] === "string"; +function isForkedSessionMeta(payload: CodexSessionMetaPayload): boolean { + if (payload.forked_from_id !== undefined && payload.forked_from_id.length > 0) { + return true; + } + return payload.source?.subagent?.thread_spawn?.parent_thread_id !== undefined; } /** @@ -197,61 +271,62 @@ function isForkedSessionMeta(payload: Record): boolean { * reconciles with the session's final `total_token_usage`, provided * consecutive duplicate events are dropped, which this does. */ -export function parseCodexLine(line: string, state: CodexScanState): UsageRecord | null { +export function parseCodexLine(line: string, state?: CodexScanState): UsageRecord | null { + if (!state) return null; + let parsed: unknown; try { parsed = JSON.parse(line); } catch { return null; } - if (typeof parsed !== "object" || parsed === null) return null; - const record = parsed as Record; - const payload = record["payload"]; - if (typeof payload !== "object" || payload === null) return null; - const payloadRecord = payload as Record; - const payloadType = payloadRecord["type"]; + const recordResult = decodeCodexRecord(parsed); + if (Option.isNone(recordResult)) return null; + const record = recordResult.value; + + if (record.type === "session_meta") { + const payloadResult = decodeCodexSessionMetaPayload(record.payload); + if (Option.isNone(payloadResult)) return null; + const payload = payloadResult.value; - if (record["type"] === "session_meta") { // Only the first meta describes this file's own session. A forked rollout // repeats the ancestors' metas right after it; letting those through would // reassign every subsequent record to an ancestor session. if (state.sawSessionMeta) return null; state.sawSessionMeta = true; - const id = payloadRecord["id"] ?? payloadRecord["session_id"]; - if (typeof id === "string") state.sessionId = id; - const metaTimestampMs = parseTimestampMs(record["timestamp"]); - if (metaTimestampMs !== null && isForkedSessionMeta(payloadRecord)) { + const id = payload.id ?? payload.session_id; + if (id !== undefined) state.sessionId = id; + const metaTimestampMs = parseTimestampMs(record.timestamp); + if (metaTimestampMs !== null && isForkedSessionMeta(payload)) { state.suppressingForkCopies = true; state.forkCopyAnchorMs = metaTimestampMs; } return null; } - if (record["type"] === "turn_context") { - if (typeof payloadRecord["model"] === "string") state.model = payloadRecord["model"]; + if (record.type === "turn_context") { + const payloadResult = decodeCodexTurnContextPayload(record.payload); + if (Option.isNone(payloadResult)) return null; + const payload = payloadResult.value; + if (payload.model !== undefined) state.model = payload.model; return null; } - if (payloadType !== "token_count") return null; + const tokenPayloadResult = decodeCodexTokenCountPayload(record.payload); + if (Option.isNone(tokenPayloadResult)) return null; + const tokenPayload = tokenPayloadResult.value; - const info = payloadRecord["info"]; - if (typeof info !== "object" || info === null) return null; - const last = (info as Record)["last_token_usage"]; - if (typeof last !== "object" || last === null) return null; - const lastRecord = last as Record; - - // Only an event that is otherwise eligible may consume the duplicate - // signature. A token_count arriving before its turn_context (no model yet) - // must not poison it, or the re-emitted copy after the model is known would - // be skipped as a duplicate and those tokens never counted. - const timestampMs = parseTimestampMs(record["timestamp"]); + // token_count + const timestampMs = parseTimestampMs(record.timestamp); if (timestampMs === null) return null; if (state.model.length === 0) return null; + const last = tokenPayload.info.last_token_usage; + // Codex re-emits an unchanged token_count on some stream boundaries. Summing // those would double count, so identical consecutive payloads are skipped. - const signature = JSON.stringify(lastRecord); + const signature = JSON.stringify(last); if (signature === state.lastUsageSignature) return null; state.lastUsageSignature = signature; @@ -266,10 +341,10 @@ export function parseCodexLine(line: string, state: CodexScanState): UsageRecord state.suppressingForkCopies = false; } - const inputTokens = int(lastRecord["input_tokens"]); - const cachedInputTokens = int(lastRecord["cached_input_tokens"]); - const cacheCreationTokens = int(lastRecord["cache_write_input_tokens"]); - const outputTokens = int(lastRecord["output_tokens"]); + const inputTokens = int(last.input_tokens); + const cachedInputTokens = int(last.cached_input_tokens); + const cacheCreationTokens = int(last.cache_write_input_tokens); + const outputTokens = int(last.output_tokens); const totals: UsageTokenTotals = { // Codex reports `input_tokens` inclusive of the cached portion. @@ -278,7 +353,7 @@ export function parseCodexLine(line: string, state: CodexScanState): UsageRecord cacheCreationTokens, outputTokens, // Reported inside output_tokens, surfaced separately for the token mix. - reasoningTokens: Math.min(outputTokens, int(lastRecord["reasoning_output_tokens"])), + reasoningTokens: Math.min(outputTokens, int(last.reasoning_output_tokens)), }; if (totalTokens(totals) === 0) return null; @@ -297,4 +372,70 @@ export function parseCodexLine(line: string, state: CodexScanState): UsageRecord }; } +/* -------------------------------------------------------------------------- */ +/* Devin */ +/* -------------------------------------------------------------------------- */ + +const DevinUsageLineSchema = Schema.Struct({ + type: Schema.Literal("devin_usage"), + timestamp: Schema.String, + sessionId: Schema.optional(Schema.String), + turnId: Schema.optional(Schema.String), + model: Schema.String, + totals: UsageTokenTotals, + reportedCostUsd: Schema.optional(Schema.NullOr(Schema.Number)), +}); + +const decodeDevinUsageLine = Schema.decodeUnknownOption(DevinUsageLineSchema); + +/** + * Devin advertises family slugs with dots (e.g. `swe-1.7`), but the ACP + * `model_uid` values and the T3 Code usage transcript write dashes + * (`swe-1-7`). The Usage page shows the dotted, human-readable version, so + * rehydrate version dots from the dashed slug at parse time. + */ +function displayDevinModelSlug(slug: string): string { + return slug.replace(/(\d+)-(\d+)/g, "$1.$2"); +} + +/** + * Parses one line from a Devin usage transcript written by T3 Code. + * + * Each line is an independent, delta-normalized record keyed by + * `sessionId:turnId` so the aggregator can de-duplicate retries. + */ +export function parseDevinLine(line: string): UsageRecord | null { + let parsed: unknown; + try { + parsed = JSON.parse(line); + } catch { + return null; + } + + const result = decodeDevinUsageLine(parsed); + if (Option.isNone(result)) return null; + const record = result.value; + + const timestampMs = parseTimestampMs(record.timestamp); + if (timestampMs === null) return null; + + const sessionId = record.sessionId?.trim() ?? ""; + const turnId = record.turnId?.trim() ?? ""; + + return { + provider: "devin", + timestampMs, + model: displayDevinModelSlug(record.model), + sessionId, + totals: record.totals, + reportedCostUsd: + record.reportedCostUsd !== undefined && + record.reportedCostUsd !== null && + Number.isFinite(record.reportedCostUsd) + ? record.reportedCostUsd + : null, + dedupeKey: sessionId.length > 0 && turnId.length > 0 ? `${sessionId}:${turnId}` : null, + }; +} + export { EMPTY_TOTALS }; diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsx index 8ea38c519588..09f7bad39867 100644 --- a/apps/web/src/components/Icons.tsx +++ b/apps/web/src/components/Icons.tsx @@ -211,6 +211,17 @@ export const GrokIcon: Icon = ({ className, ...props }) => ( ); +export const DevinIcon: Icon = ({ className, ...props }) => ( + + + +); + export const TraeIcon: Icon = (props) => ( {/* Back rectangle: left strip + bottom strip drawn separately — empty bottom-left corner is the gap between them */} diff --git a/apps/web/src/components/chat/OpenInPicker.tsx b/apps/web/src/components/chat/OpenInPicker.tsx index 8b7a96880b81..b076ee1eb02b 100644 --- a/apps/web/src/components/chat/OpenInPicker.tsx +++ b/apps/web/src/components/chat/OpenInPicker.tsx @@ -9,6 +9,7 @@ import { Menu, MenuItem, MenuPopup, MenuShortcut, MenuTrigger } from "../ui/menu import { AntigravityIcon, CursorIcon, + DevinIcon, Icon, KiroIcon, TraeIcon, @@ -50,6 +51,12 @@ const resolveOptions = (platform: string, availableEditors: ReadonlyArray> = { @@ -8,6 +8,7 @@ export const PROVIDER_ICON_BY_PROVIDER: Partial [ProviderDriverKind.make("opencode")]: OpenCodeIcon, [ProviderDriverKind.make("cursor")]: CursorIcon, [ProviderDriverKind.make("grok")]: GrokIcon, + [ProviderDriverKind.make("devin")]: DevinIcon, }; function isAvailableProviderOption(option: (typeof PROVIDER_OPTIONS)[number]): option is { diff --git a/apps/web/src/components/settings/ProviderModelsSection.tsx b/apps/web/src/components/settings/ProviderModelsSection.tsx index 7ae26b278657..3a16074114a8 100644 --- a/apps/web/src/components/settings/ProviderModelsSection.tsx +++ b/apps/web/src/components/settings/ProviderModelsSection.tsx @@ -98,6 +98,7 @@ export function ProviderModelsSection({ onModelOrderChange, }: ProviderModelsSectionProps) { const [input, setInput] = useState(""); + const [searchQuery, setSearchQuery] = useState(""); const [error, setError] = useState(null); const listRef = useRef(null); const hiddenModelSet = useMemo(() => new Set(hiddenModels), [hiddenModels]); @@ -110,6 +111,15 @@ export function ProviderModelsSection({ }); }, [favoriteModelSet, modelOrder, models]); + const filteredModels = useMemo(() => { + const query = searchQuery.trim().toLowerCase(); + if (!query) return orderedModels; + return orderedModels.filter( + (model) => + model.slug.toLowerCase().includes(query) || model.name.toLowerCase().includes(query), + ); + }, [orderedModels, searchQuery]); + const handleAdd = () => { const normalized = normalizeCustomModelSlug(input); if (!normalized) { @@ -190,14 +200,22 @@ export function ProviderModelsSection({
{models.length} model{models.length === 1 ? "" : "s"} available.
+ setSearchQuery(event.target.value)} + placeholder="Search models..." + className="mt-2" + spellCheck={false} + />
- {orderedModels.map((model, index) => { + {filteredModels.map((model, index) => { const caps = model.capabilities; const capLabels: string[] = []; const isHidden = !model.isCustom && hiddenModelSet.has(model.slug); const isFavorite = favoriteModelSet.has(model.slug); - const previousModel = orderedModels[index - 1]; - const nextModel = orderedModels[index + 1]; + const orderedIndex = orderedModels.findIndex((ordered) => ordered.slug === model.slug); + const previousModel = orderedModels[orderedIndex - 1]; + const nextModel = orderedModels[orderedIndex + 1]; const canMoveUp = previousModel !== undefined && favoriteModelSet.has(previousModel.slug) === isFavorite; const canMoveDown = @@ -221,7 +239,10 @@ export function ProviderModelsSection({ ) { capLabels.push("Reasoning"); } - const hasDetails = capLabels.length > 0 || model.name !== model.slug; + const hasDetails = + capLabels.length > 0 || + model.name !== model.slug || + (model.description != null && model.description.length > 0); return (
{model.slug} + {model.description ? ( +

{model.description}

+ ) : null} {capLabels.length > 0 ? (
{capLabels.map((label) => ( diff --git a/apps/web/src/components/settings/ProviderSettingsForm.test.ts b/apps/web/src/components/settings/ProviderSettingsForm.test.ts index ea8712a87eb5..92b340be2d41 100644 --- a/apps/web/src/components/settings/ProviderSettingsForm.test.ts +++ b/apps/web/src/components/settings/ProviderSettingsForm.test.ts @@ -22,6 +22,32 @@ describe("ProviderSettingsForm helpers", () => { ]); }); + it("derives Devin settings fields in the configured order", () => { + const devin = DRIVER_OPTION_BY_VALUE[ProviderDriverKind.make("devin")]; + + expect(devin).toBeDefined(); + expect(deriveProviderSettingsFields(devin!).map((field) => field.key)).toEqual([ + "binaryPath", + "homePath", + "launchArgs", + "permissionMode", + ]); + + const permissionMode = deriveProviderSettingsFields(devin!).find( + (field) => field.key === "permissionMode", + ); + expect(permissionMode).toMatchObject({ + control: "select", + options: [ + { value: "normal", label: "Normal" }, + { value: "accept-edits", label: "Accept edits" }, + { value: "smart", label: "Smart" }, + { value: "dangerous", label: "Dangerous" }, + { value: "autonomous", label: "Autonomous" }, + ], + }); + }); + it("sources labels and descriptions from schema annotations", () => { const opencode = DRIVER_OPTION_BY_VALUE[ProviderDriverKind.make("opencode")]; expect(opencode).toBeDefined(); diff --git a/apps/web/src/components/settings/ProviderSettingsForm.tsx b/apps/web/src/components/settings/ProviderSettingsForm.tsx index cd34bb35c6b2..f32de3c7ff99 100644 --- a/apps/web/src/components/settings/ProviderSettingsForm.tsx +++ b/apps/web/src/components/settings/ProviderSettingsForm.tsx @@ -12,6 +12,7 @@ import type { import { cn } from "../../lib/utils"; import { DraftInput } from "../ui/draft-input"; import { Input } from "../ui/input"; +import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select"; import { Switch } from "../ui/switch"; import { Textarea } from "../ui/textarea"; import type { ProviderClientDefinition } from "./providerDriverMeta"; @@ -24,6 +25,7 @@ export interface ProviderSettingsFieldModel { readonly placeholder?: string | undefined; readonly clearWhenEmpty: "omit" | "persist"; readonly defaultBooleanValue?: boolean | undefined; + readonly options?: ReadonlyArray<{ readonly value: string; readonly label: string }> | undefined; } function titleizeFieldKey(key: string): string { @@ -106,6 +108,7 @@ export function deriveProviderSettingsFields( ...(formAnnotation.control === "switch" ? { defaultBooleanValue: readFieldBooleanDefault(fieldSchema) } : {}), + ...(formAnnotation.options !== undefined ? { options: formAnnotation.options } : {}), } satisfies ProviderSettingsFieldModel, ]; }); @@ -238,6 +241,42 @@ function ProviderSettingsFieldRow({ ); } + if (field.control === "select") { + const currentValue = readProviderConfigString(value, field.key); + const selectedOption = field.options?.find((option) => option.value === currentValue); + return ( + + + + ); + } + const type = field.control === "password" ? "password" : undefined; return ( diff --git a/apps/web/src/components/settings/providerDriverMeta.ts b/apps/web/src/components/settings/providerDriverMeta.ts index bfee6a8d6807..63307994cbcb 100644 --- a/apps/web/src/components/settings/providerDriverMeta.ts +++ b/apps/web/src/components/settings/providerDriverMeta.ts @@ -2,12 +2,21 @@ import { ClaudeSettings, CodexSettings, CursorSettings, + DevinSettings, GrokSettings, OpenCodeSettings, ProviderDriverKind, } from "@t3tools/contracts"; import type * as Schema from "effect/Schema"; -import { ClaudeAI, CursorIcon, GrokIcon, type Icon, OpenAI, OpenCodeIcon } from "../Icons"; +import { + ClaudeAI, + CursorIcon, + DevinIcon, + GrokIcon, + type Icon, + OpenAI, + OpenCodeIcon, +} from "../Icons"; type ProviderSettingsSchema = { readonly fields: Readonly>; @@ -67,6 +76,13 @@ export const PROVIDER_CLIENT_DEFINITIONS: readonly ProviderClientDefinition[] = icon: OpenCodeIcon, settingsSchema: OpenCodeSettings, }, + { + value: ProviderDriverKind.make("devin"), + label: "Devin", + icon: DevinIcon, + badgeLabel: "Early Access", + settingsSchema: DevinSettings, + }, ]; export const PROVIDER_CLIENT_DEFINITION_BY_VALUE: Partial< diff --git a/apps/web/src/components/usage/usageProviders.ts b/apps/web/src/components/usage/usageProviders.ts index f8b65877dcf4..9f38355c191f 100644 --- a/apps/web/src/components/usage/usageProviders.ts +++ b/apps/web/src/components/usage/usageProviders.ts @@ -1,33 +1,37 @@ import type { UsageProviderKind } from "@t3tools/contracts"; -import { ClaudeAI, type Icon, OpenAI } from "../Icons"; +import { ClaudeAI, DevinIcon, type Icon, OpenAI } from "../Icons"; /** * Series and table order. The chart layers both providers from a shared zero * baseline, so this only fixes the reading order of legends, tables and hover * rows; it does not decide which series sits above the other. */ -export const PROVIDER_ORDER: readonly UsageProviderKind[] = ["codex", "claude"]; +export const PROVIDER_ORDER: readonly UsageProviderKind[] = ["codex", "claude", "devin"]; export const PROVIDER_LABEL: Record = { claude: "Claude Code", codex: "Codex", + devin: "Devin", }; /** Claude's brand orange against a neutral white for Codex. */ export const PROVIDER_COLOR: Record = { claude: "#d97757", codex: "#e6e6e6", + devin: "#8a63d2", }; /** * Brand marks, reused from the provider picker. * - * These ship their own fills (`#d97757` for Claude, white on dark for OpenAI), - * which are the same colours as the chart bands, so swapping a colour dot for a - * mark keeps the series association intact rather than trading it away. + * These ship their own fills (`#d97757` for Claude, white on dark for OpenAI, + * the Devin brand mark for Devin), which are the same colours as the chart + * bands, so swapping a colour dot for a mark keeps the series association intact + * rather than trading it away. */ export const PROVIDER_MARK: Record = { claude: ClaudeAI, codex: OpenAI, + devin: DevinIcon, }; diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts index 4d0a76cf133b..d8cc341d1df3 100644 --- a/apps/web/src/session-logic.ts +++ b/apps/web/src/session-logic.ts @@ -33,7 +33,11 @@ export const PROVIDER_OPTIONS: Array<{ pickerSidebarBadge?: "new" | "soon"; }> = [ { value: ProviderDriverKind.make("codex"), label: "Codex", available: true }, - { value: ProviderDriverKind.make("claudeAgent"), label: "Claude", available: true }, + { + value: ProviderDriverKind.make("claudeAgent"), + label: "Claude", + available: true, + }, { value: ProviderDriverKind.make("opencode"), label: "OpenCode", @@ -52,6 +56,12 @@ export const PROVIDER_OPTIONS: Array<{ available: true, pickerSidebarBadge: "new", }, + { + value: ProviderDriverKind.make("devin"), + label: "Devin", + available: true, + pickerSidebarBadge: "new", + }, ]; export type WorkLogToolLifecycleStatus = diff --git a/docs/README.md b/docs/README.md index 30653e7d5035..6d4f5f6bb5f3 100644 --- a/docs/README.md +++ b/docs/README.md @@ -12,7 +12,7 @@ - [Keeping app and server in sync](./user/updating.md) - [Source control integrations](./user/source-control.md) - [Background service (Linux)](./user/background-service.md) -- Providers: [Codex](./user/providers-codex.md) · [Claude](./user/providers-claude.md) +- Providers: [Codex](./user/providers-codex.md) · [Claude](./user/providers-claude.md) · [Devin](./user/providers-devin.md) Mobile app: [apps/mobile/README.md](../apps/mobile/README.md) diff --git a/docs/internals/glossary.md b/docs/internals/glossary.md index da16f74d339f..cad43cb64198 100644 --- a/docs/internals/glossary.md +++ b/docs/internals/glossary.md @@ -94,7 +94,7 @@ The live backend agent implementation and its event stream. The main service is #### Provider -The backend agent runtime that actually performs work. Five drivers ship built in: Codex, Claude, Cursor, Grok, and OpenCode. See [ProviderService.ts][14], [ProviderAdapter.ts][15], and [CodexAdapter.ts][17] as a representative adapter. +The backend agent runtime that actually performs work. Six drivers ship built in: Codex, Claude, Cursor, Devin, Grok, and OpenCode. See [ProviderService.ts][14], [ProviderAdapter.ts][15], and [CodexAdapter.ts][17] as a representative adapter. #### Session diff --git a/docs/internals/overview.md b/docs/internals/overview.md index b9454f7b58d0..f240ec9cdbb7 100644 --- a/docs/internals/overview.md +++ b/docs/internals/overview.md @@ -18,13 +18,13 @@ there, never in the client. ┌──────────────────▼─────────────────────────────┐ │ apps/server │ │ orchestration engine (event-sourced) │ -│ provider driver registry (5 built-in drivers) │ +│ provider driver registry (6 built-in drivers) │ │ checkpointing, VCS, terminals, filesystem │ └──────────────────┬─────────────────────────────┘ │ per-driver transport ┌──────────────────▼─────────────────────────────┐ -│ Agent CLIs: Codex, Claude, Cursor, Grok, │ -│ OpenCode │ +│ Agent CLIs: Codex, Claude, Cursor, Devin, │ +│ Grok, OpenCode │ └────────────────────────────────────────────────┘ ``` @@ -106,8 +106,8 @@ build production behavior on receipts. ## Provider drivers -Five drivers ship built in, registered in [`builtInDrivers.ts`][drivers] as `BUILT_IN_DRIVERS`: -Codex, Claude, Cursor, Grok, and OpenCode. A driver declares its kind and config schema and creates a +Six drivers ship built in, registered in [`builtInDrivers.ts`][drivers] as `BUILT_IN_DRIVERS`: +Codex, Claude, Cursor, Devin, Grok, and OpenCode. A driver declares its kind and config schema and creates a scoped adapter; `ProviderInstanceRegistry` owns live instances and `ProviderAdapterRegistry` resolves an instance to its adapter, so `ProviderService` routes session and turn operations without knowing which agent is behind them. See [providers.md](./providers.md). diff --git a/docs/internals/providers.md b/docs/internals/providers.md index a309d70f03de..340148061f8e 100644 --- a/docs/internals/providers.md +++ b/docs/internals/providers.md @@ -7,13 +7,14 @@ orchestration layer does not know which one is behind a thread. ## Built-in drivers -[`builtInDrivers.ts`][drivers] exports `BUILT_IN_DRIVERS` with five entries: +[`builtInDrivers.ts`][drivers] exports `BUILT_IN_DRIVERS` with six entries: | Driver kind | Driver source | | ------------- | --------------------------------------- | | `codex` | [`Drivers/CodexDriver.ts`][codex] | | `claudeAgent` | [`Drivers/ClaudeDriver.ts`][claude] | | `cursor` | [`Drivers/CursorDriver.ts`][cursor] | +| `devin` | [`Drivers/DevinDriver.ts`][devin] | | `grok` | [`Drivers/GrokDriver.ts`][grok] | | `opencode` | [`Drivers/OpenCodeDriver.ts`][opencode] | @@ -79,6 +80,7 @@ when a request opens (approval) or user input is requested, via [codex]: ../../apps/server/src/provider/Drivers/CodexDriver.ts [claude]: ../../apps/server/src/provider/Drivers/ClaudeDriver.ts [cursor]: ../../apps/server/src/provider/Drivers/CursorDriver.ts +[devin]: ../../apps/server/src/provider/Drivers/DevinDriver.ts [grok]: ../../apps/server/src/provider/Drivers/GrokDriver.ts [opencode]: ../../apps/server/src/provider/Drivers/OpenCodeDriver.ts [adapter]: ../../apps/server/src/provider/Services/ProviderAdapter.ts diff --git a/docs/user/install.md b/docs/user/install.md index fe0b418ca1e5..a0df1975ab88 100644 --- a/docs/user/install.md +++ b/docs/user/install.md @@ -46,13 +46,14 @@ yay -S t3code-bin T3 Code drives provider CLIs; it does not ship them. Install the CLI for each provider you want to use, then authenticate it. -| Provider | CLI | Default binary | Log in with | -| ---------- | ----------------------------------------------------- | -------------- | --------------------- | -| Codex | [Codex CLI](https://developers.openai.com/codex/cli) | `codex` | `codex login` | -| Claude | [Claude Code](https://claude.com/product/claude-code) | `claude` | `claude auth login` | -| Cursor | [Cursor CLI](https://cursor.com/cli) | `cursor-agent` | `agent login` | -| Grok Build | [Grok Build CLI](https://x.ai/cli) | `grok` | `grok login` | -| OpenCode | [OpenCode](https://opencode.ai) | `opencode` | `opencode auth login` | +| Provider | CLI | Default binary | Log in with | +| ---------- | ----------------------------------------------------- | -------------- | --------------------------- | +| Codex | [Codex CLI](https://developers.openai.com/codex/cli) | `codex` | `codex login` | +| Claude | [Claude Code](https://claude.com/product/claude-code) | `claude` | `claude auth login` | +| Cursor | [Cursor CLI](https://cursor.com/cli) | `cursor-agent` | `agent login` | +| Devin | [Devin CLI](https://devin.ai) | `devin` | see Devin CLI documentation | +| Grok Build | [Grok Build CLI](https://x.ai/cli) | `grok` | `grok login` | +| OpenCode | [OpenCode](https://opencode.ai) | `opencode` | `opencode auth login` | Cursor is the one to watch: install Cursor CLI, which provides the `cursor-agent` binary that T3 Code looks for, but authenticate with `agent login`, not `cursor-agent login`. @@ -74,7 +75,7 @@ T3 Code. You can install T3 Code, open it, and add providers afterwards. A provi authenticated shows its status in **Settings** and fails at session start with the login command to run. -For multi-account setups, see [Codex](./providers-codex.md) and [Claude](./providers-claude.md). +For multi-account setups, see [Codex](./providers-codex.md), [Claude](./providers-claude.md), and [Devin](./providers-devin.md). ## Next Steps diff --git a/docs/user/providers-devin.md b/docs/user/providers-devin.md new file mode 100644 index 000000000000..0604c7c63637 --- /dev/null +++ b/docs/user/providers-devin.md @@ -0,0 +1,112 @@ +# Devin + +This guide is for people who want to use Devin in T3 Code. For other providers, see +[Codex](./providers-codex.md) or [Claude](./providers-claude.md). For first-time setup, see +[Install T3 Code](./install.md). + +T3 Code talks to Devin through its ACP (Agent Client Protocol) interface. It needs a Devin CLI that +exposes `devin acp` on standard input/output. + +## I Only Use One Devin Account + +Use the default provider. + +In T3 Code Settings, your Devin provider can stay like this: + +```text +Display name: Devin +Binary path: devin +Home path: empty +Launch arguments: empty +``` + +An empty `Home path` means T3 Code uses Devin's default home directory (`~/.devin` on macOS and +Linux, and the equivalent Windows user profile path). T3 Code sets this as `DEVIN_HOME` when it +spawns the Devin process. + +## I Want Multiple Devin Accounts Or Presets + +Use a different `Home path` for each provider instance. Each home keeps its own Devin sessions and +Usage transcripts, so T3 Code treats them as separate Devin environments. + +Example: + +```text +Display name: Devin Work +Binary path: devin +Home path: ~/.devin_work +``` + +```text +Display name: Devin Personal +Binary path: devin +Home path: ~/.devin_personal +``` + +T3 Code expands `~` in the `Home path`, resolves it to an absolute path, and sets +`DEVIN_HOME` before launching Devin. It does not create the directory; Devin CLI or the user +is responsible for ensuring it exists. + +## Binary Path And The `devin-desktop` Fallback + +`Binary path` is the command T3 Code runs to start Devin ACP. If you leave it empty, T3 Code tries +`devin` first and then falls back to `devin-desktop` automatically if `devin` is not on `PATH`. + +Some installations expose the CLI as `devin-desktop` while still speaking ACP. T3 Code will use it +the same way, launching it as `devin-desktop acp` with the configured `Launch arguments`. + +If your Devin binary is in a non-standard location, set the full path: + +```text +Binary path: /opt/devin/bin/devin +``` + +## Launch Arguments + +`Launch arguments` are extra arguments passed to the Devin CLI after the `acp` subcommand. They are +tokenized the same way as a shell command, so quoted arguments are supported. + +Example: + +```text +Launch arguments: --verbose --log-level debug +``` + +This produces a command like: + +```text +devin acp --verbose --log-level debug +``` + +Do not put environment variable assignments in `Launch arguments`. Use the provider's +**Environment variables** section for those, and mark tokens or API keys as sensitive. + +## Authentication + +Devin's CLI authentication is handled by Devin itself, not by T3 Code. Run the login command that the +Devin CLI documentation recommends before you start a session, then confirm the provider status in +T3 Code Settings. + +If Devin uses an API key or base URL that needs to be per-provider, add those variables to the +provider's **Environment variables** section and mark the values as sensitive. T3 Code stores +sensitive values as server secrets and does not send them back to the app after saving. + +## Token Usage And Cost + +Devin token usage is reported in real time during a conversation and aggregated in **Usage**. + +- Real-time usage appears from Devin's ACP prompt responses. +- Aggregated usage is written to `/t3code-usage.jsonl` and scanned by the Usage page. +- Cost is estimated from LiteLLM rate data when Devin does not report a cost itself. Unpriced Devin + models appear as `unpriced` rather than inventing a rate. + +## Can I Switch Models In An Existing Thread? + +Yes, when the Devin session advertises the requested model. T3 Code sends a `session/set_config_option` +ACP request for the model config option when the model picker changes. If Devin rejects the model, +the request fails with the provider error shown in the UI. + +## Can I Switch Accounts In An Existing Thread? + +No. Devin sessions are tied to the `Home path` they were created with. A different home is treated +as a different Devin environment, so existing threads cannot be moved to another Devin provider. diff --git a/packages/contracts/src/editor.ts b/packages/contracts/src/editor.ts index 5948d87e1d23..46d00254896e 100644 --- a/packages/contracts/src/editor.ts +++ b/packages/contracts/src/editor.ts @@ -14,8 +14,20 @@ type EditorDefinition = { export const EDITORS = [ { id: "cursor", label: "Cursor", commands: ["cursor"], launchStyle: "goto" }, + { + id: "devin", + label: "Devin Desktop", + commands: ["devin-desktop"], + launchStyle: "goto", + }, { id: "trae", label: "Trae", commands: ["trae"], launchStyle: "goto" }, - { id: "kiro", label: "Kiro", commands: ["kiro"], baseArgs: ["ide"], launchStyle: "goto" }, + { + id: "kiro", + label: "Kiro", + commands: ["kiro"], + baseArgs: ["ide"], + launchStyle: "goto", + }, { id: "vscode", label: "VS Code", commands: ["code"], launchStyle: "goto" }, { id: "vscode-insiders", @@ -23,22 +35,97 @@ export const EDITORS = [ commands: ["code-insiders"], launchStyle: "goto", }, - { id: "vscodium", label: "VSCodium", commands: ["codium"], launchStyle: "goto" }, - { id: "zed", label: "Zed", commands: ["zed", "zeditor"], launchStyle: "direct-path" }, - { id: "antigravity", label: "Antigravity", commands: ["agy"], launchStyle: "goto" }, - { id: "idea", label: "IntelliJ IDEA", commands: ["idea"], launchStyle: "line-column" }, + { + id: "vscodium", + label: "VSCodium", + commands: ["codium"], + launchStyle: "goto", + }, + { + id: "zed", + label: "Zed", + commands: ["zed", "zeditor"], + launchStyle: "direct-path", + }, + { + id: "antigravity", + label: "Antigravity", + commands: ["agy"], + launchStyle: "goto", + }, + { + id: "idea", + label: "IntelliJ IDEA", + commands: ["idea"], + launchStyle: "line-column", + }, { id: "aqua", label: "Aqua", commands: ["aqua"], launchStyle: "line-column" }, - { id: "clion", label: "CLion", commands: ["clion"], launchStyle: "line-column" }, - { id: "datagrip", label: "DataGrip", commands: ["datagrip"], launchStyle: "line-column" }, - { id: "dataspell", label: "DataSpell", commands: ["dataspell"], launchStyle: "line-column" }, - { id: "goland", label: "GoLand", commands: ["goland"], launchStyle: "line-column" }, - { id: "phpstorm", label: "PhpStorm", commands: ["phpstorm"], launchStyle: "line-column" }, - { id: "pycharm", label: "PyCharm", commands: ["pycharm"], launchStyle: "line-column" }, - { id: "rider", label: "Rider", commands: ["rider"], launchStyle: "line-column" }, - { id: "rubymine", label: "RubyMine", commands: ["rubymine"], launchStyle: "line-column" }, - { id: "rustrover", label: "RustRover", commands: ["rustrover"], launchStyle: "line-column" }, - { id: "webstorm", label: "WebStorm", commands: ["webstorm"], launchStyle: "line-column" }, - { id: "file-manager", label: "File Manager", commands: null, launchStyle: "direct-path" }, + { + id: "clion", + label: "CLion", + commands: ["clion"], + launchStyle: "line-column", + }, + { + id: "datagrip", + label: "DataGrip", + commands: ["datagrip"], + launchStyle: "line-column", + }, + { + id: "dataspell", + label: "DataSpell", + commands: ["dataspell"], + launchStyle: "line-column", + }, + { + id: "goland", + label: "GoLand", + commands: ["goland"], + launchStyle: "line-column", + }, + { + id: "phpstorm", + label: "PhpStorm", + commands: ["phpstorm"], + launchStyle: "line-column", + }, + { + id: "pycharm", + label: "PyCharm", + commands: ["pycharm"], + launchStyle: "line-column", + }, + { + id: "rider", + label: "Rider", + commands: ["rider"], + launchStyle: "line-column", + }, + { + id: "rubymine", + label: "RubyMine", + commands: ["rubymine"], + launchStyle: "line-column", + }, + { + id: "rustrover", + label: "RustRover", + commands: ["rustrover"], + launchStyle: "line-column", + }, + { + id: "webstorm", + label: "WebStorm", + commands: ["webstorm"], + launchStyle: "line-column", + }, + { + id: "file-manager", + label: "File Manager", + commands: null, + launchStyle: "direct-path", + }, ] as const satisfies ReadonlyArray; export const EditorId = Schema.Literals(EDITORS.map((e) => e.id)); diff --git a/packages/contracts/src/model.ts b/packages/contracts/src/model.ts index 9fcd0d266dd6..bc392c10c10b 100644 --- a/packages/contracts/src/model.ts +++ b/packages/contracts/src/model.ts @@ -132,6 +132,7 @@ const CLAUDE_DRIVER_KIND = ProviderDriverKind.make("claudeAgent"); const CURSOR_DRIVER_KIND = ProviderDriverKind.make("cursor"); const GROK_DRIVER_KIND = ProviderDriverKind.make("grok"); const OPENCODE_DRIVER_KIND = ProviderDriverKind.make("opencode"); +export const DEVIN_DRIVER_KIND = ProviderDriverKind.make("devin"); export const DEFAULT_MODEL = "gpt-5.6-sol"; @@ -153,6 +154,7 @@ export const DEFAULT_MODEL_BY_PROVIDER: Partial> [CURSOR_DRIVER_KIND]: "Cursor", [GROK_DRIVER_KIND]: "Grok", [OPENCODE_DRIVER_KIND]: "OpenCode", + [DEVIN_DRIVER_KIND]: "Devin", }; diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts index d7bc4c5c1898..da82e6228079 100644 --- a/packages/contracts/src/server.ts +++ b/packages/contracts/src/server.ts @@ -66,6 +66,7 @@ export const ServerProviderModel = Schema.Struct({ name: TrimmedNonEmptyString, shortName: Schema.optional(TrimmedNonEmptyString), subProvider: Schema.optional(TrimmedNonEmptyString), + description: Schema.optional(TrimmedNonEmptyString), isCustom: Schema.Boolean, isDefault: Schema.optional(Schema.Boolean), isLegacy: Schema.optional(Schema.Boolean), diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts index ee1970639adf..b1e01a8d4fbb 100644 --- a/packages/contracts/src/settings.ts +++ b/packages/contracts/src/settings.ts @@ -71,7 +71,10 @@ export const DEFAULT_GLASS_OPACITY: GlassOpacity = 80; export const MIN_INTERFACE_FONT_SIZE = 12; export const MAX_INTERFACE_FONT_SIZE = 20; export const InterfaceFontSize = Schema.Int.check( - Schema.isBetween({ minimum: MIN_INTERFACE_FONT_SIZE, maximum: MAX_INTERFACE_FONT_SIZE }), + Schema.isBetween({ + minimum: MIN_INTERFACE_FONT_SIZE, + maximum: MAX_INTERFACE_FONT_SIZE, + }), ); export type InterfaceFontSize = typeof InterfaceFontSize.Type; export const DEFAULT_INTERFACE_FONT_SIZE: InterfaceFontSize = 16; @@ -79,7 +82,10 @@ export const DEFAULT_INTERFACE_FONT_SIZE: InterfaceFontSize = 16; export const MIN_PROMPT_FONT_SIZE = 12; export const MAX_PROMPT_FONT_SIZE = 20; export const PromptFontSize = Schema.Int.check( - Schema.isBetween({ minimum: MIN_PROMPT_FONT_SIZE, maximum: MAX_PROMPT_FONT_SIZE }), + Schema.isBetween({ + minimum: MIN_PROMPT_FONT_SIZE, + maximum: MAX_PROMPT_FONT_SIZE, + }), ); export type PromptFontSize = typeof PromptFontSize.Type; export const DEFAULT_PROMPT_FONT_SIZE: PromptFontSize = 14; @@ -87,7 +93,10 @@ export const DEFAULT_PROMPT_FONT_SIZE: PromptFontSize = 14; export const MIN_CODE_FONT_SIZE = 10; export const MAX_CODE_FONT_SIZE = 18; export const CodeFontSize = Schema.Int.check( - Schema.isBetween({ minimum: MIN_CODE_FONT_SIZE, maximum: MAX_CODE_FONT_SIZE }), + Schema.isBetween({ + minimum: MIN_CODE_FONT_SIZE, + maximum: MAX_CODE_FONT_SIZE, + }), ); export type CodeFontSize = typeof CodeFontSize.Type; export const DEFAULT_CODE_FONT_SIZE: CodeFontSize = 13; @@ -95,7 +104,10 @@ export const DEFAULT_CODE_FONT_SIZE: CodeFontSize = 13; export const MIN_TERMINAL_FONT_SIZE = 8; export const MAX_TERMINAL_FONT_SIZE = 20; export const TerminalFontSize = Schema.Int.check( - Schema.isBetween({ minimum: MIN_TERMINAL_FONT_SIZE, maximum: MAX_TERMINAL_FONT_SIZE }), + Schema.isBetween({ + minimum: MIN_TERMINAL_FONT_SIZE, + maximum: MAX_TERMINAL_FONT_SIZE, + }), ); export type TerminalFontSize = typeof TerminalFontSize.Type; export const DEFAULT_TERMINAL_FONT_SIZE: TerminalFontSize = 12; @@ -224,13 +236,19 @@ const makeBinaryPathSetting = (fallback: string) => Schema.withDecodingDefault(Effect.succeed(fallback)), ); -export type ProviderSettingsFormControl = "text" | "password" | "textarea" | "switch"; +export interface ProviderSettingsFormSelectOption { + readonly value: string; + readonly label: string; +} + +export type ProviderSettingsFormControl = "text" | "password" | "textarea" | "switch" | "select"; export interface ProviderSettingsFormAnnotation { readonly control?: ProviderSettingsFormControl | undefined; readonly placeholder?: string | undefined; readonly hidden?: boolean | undefined; readonly clearWhenEmpty?: "omit" | "persist" | undefined; + readonly options?: ReadonlyArray | undefined; } export interface ProviderSettingsFormSchemaAnnotation { @@ -338,7 +356,10 @@ export const ClaudeSettings = makeProviderSettingsSchema( title: "CLAUDE_CONFIG_DIR path", description: "Custom Claude home and config directory. Keeps .claude.json and .claude separate.", - providerSettingsForm: { placeholder: "~/.claude", clearWhenEmpty: "omit" }, + providerSettingsForm: { + placeholder: "~/.claude", + clearWhenEmpty: "omit", + }, }), ), customModels: Schema.Array(Schema.String).pipe( @@ -373,7 +394,10 @@ export const CursorSettings = makeProviderSettingsSchema( Schema.annotateKey({ title: "Binary path", description: "Path to the Cursor agent binary.", - providerSettingsForm: { placeholder: "cursor-agent", clearWhenEmpty: "omit" }, + providerSettingsForm: { + placeholder: "cursor-agent", + clearWhenEmpty: "omit", + }, }), ), apiEndpoint: TrimmedString.pipe( @@ -472,6 +496,81 @@ export const OpenCodeSettings = makeProviderSettingsSchema( ); export type OpenCodeSettings = typeof OpenCodeSettings.Type; +const DevinPermissionMode = Schema.Literals([ + "normal", + "accept-edits", + "smart", + "dangerous", + "autonomous", +]); + +export const DevinSettings = makeProviderSettingsSchema( + { + enabled: Schema.Boolean.pipe( + Schema.withDecodingDefault(Effect.succeed(true)), + Schema.annotateKey({ providerSettingsForm: { hidden: true } }), + ), + binaryPath: makeBinaryPathSetting("devin").pipe( + Schema.annotateKey({ + title: "Binary path", + description: "Path to the Devin CLI binary (or `devin-desktop` if installed).", + providerSettingsForm: { + placeholder: "devin or devin-desktop", + clearWhenEmpty: "omit", + }, + }), + ), + homePath: TrimmedString.pipe( + Schema.withDecodingDefault(Effect.succeed("")), + Schema.annotateKey({ + title: "Devin home path", + description: "Custom Devin home and config directory.", + providerSettingsForm: { + placeholder: "~/.devin", + clearWhenEmpty: "omit", + }, + }), + ), + launchArgs: TrimmedString.pipe( + Schema.withDecodingDefault(Effect.succeed("")), + Schema.annotateKey({ + title: "Launch arguments", + description: "Additional CLI arguments passed to `devin acp` on session start.", + providerSettingsForm: { + placeholder: "e.g. --verbose", + clearWhenEmpty: "omit", + }, + }), + ), + permissionMode: DevinPermissionMode.pipe( + Schema.withDecodingDefault(Effect.succeed("normal" as const)), + Schema.annotateKey({ + title: "Permission mode", + description: "Permission mode passed to `devin` via DEVIN_PERMISSION_MODE.", + providerSettingsForm: { + control: "select", + options: [ + { value: "normal", label: "Normal" }, + { value: "accept-edits", label: "Accept edits" }, + { value: "smart", label: "Smart" }, + { value: "dangerous", label: "Dangerous" }, + { value: "autonomous", label: "Autonomous" }, + ], + clearWhenEmpty: "omit", + }, + }), + ), + customModels: Schema.Array(Schema.String).pipe( + Schema.withDecodingDefault(Effect.succeed([])), + Schema.annotateKey({ providerSettingsForm: { hidden: true } }), + ), + }, + { + order: ["binaryPath", "homePath", "launchArgs", "permissionMode"], + }, +); +export type DevinSettings = typeof DevinSettings.Type; + export const ObservabilitySettings = Schema.Struct({ otlpTracesUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))), otlpMetricsUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))), @@ -602,6 +701,7 @@ export const ServerSettings = Schema.Struct({ cursor: CursorSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), grok: GrokSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), opencode: OpenCodeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), + devin: DevinSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))), }).pipe(Schema.withDecodingDefault(Effect.succeed({}))), // New driver-agnostic instance map. Keyed by `ProviderInstanceId`; values // are `ProviderInstanceConfig` envelopes. The driver-specific config blob @@ -705,6 +805,15 @@ const OpenCodeSettingsPatch = Schema.Struct({ customModels: Schema.optionalKey(Schema.Array(Schema.String)), }); +const DevinSettingsPatch = Schema.Struct({ + enabled: Schema.optionalKey(Schema.Boolean), + binaryPath: Schema.optionalKey(TrimmedString), + homePath: Schema.optionalKey(TrimmedString), + launchArgs: Schema.optionalKey(TrimmedString), + permissionMode: Schema.optionalKey(DevinPermissionMode), + customModels: Schema.optionalKey(Schema.Array(Schema.String)), +}); + export const ServerSettingsPatch = Schema.Struct({ // Server settings enableLegacyTokenStreaming: Schema.optionalKey(Schema.Boolean), @@ -745,6 +854,7 @@ export const ServerSettingsPatch = Schema.Struct({ cursor: Schema.optionalKey(CursorSettingsPatch), grok: Schema.optionalKey(GrokSettingsPatch), opencode: Schema.optionalKey(OpenCodeSettingsPatch), + devin: Schema.optionalKey(DevinSettingsPatch), }), ), // Whole-map replacement for the new instance config. Patching individual diff --git a/packages/contracts/src/usage.ts b/packages/contracts/src/usage.ts index cde888a6153e..788b2fb0c1b3 100644 --- a/packages/contracts/src/usage.ts +++ b/packages/contracts/src/usage.ts @@ -23,7 +23,7 @@ import { NonNegativeInt, TrimmedNonEmptyString } from "./baseSchemas.ts"; */ export const USAGE_CONTRACT_VERSION = 4 as const; -export const UsageProviderKind = Schema.Literals(["claude", "codex"]); +export const UsageProviderKind = Schema.Literals(["claude", "codex", "devin"]); export type UsageProviderKind = typeof UsageProviderKind.Type; /**