From e43ca294dca9c9f1924db03cf1b6239a4958c6ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristijan=20Luka=C4=8Din?= Date: Sun, 8 Nov 2026 21:15:31 +0100 Subject: [PATCH 1/2] feat(omp): add native RPC provider and session imports --- .../src/features/usage/usageProviders.ts | 3 + apps/server/package.json | 1 + .../src/project/AgentSessionImporter.test.ts | 34 +- .../src/project/AgentSessionImporter.ts | 4 +- .../src/project/AgentSessionScanner.test.ts | 67 + .../server/src/project/AgentSessionScanner.ts | 37 +- apps/server/src/provider/builtInDrivers.ts | 5 + .../components/onboarding/WelcomeWizard.tsx | 1 + .../src/components/usage/usageProviders.ts | 1 + docs/user/install.md | 3 +- docs/user/providers-omp.md | 15 + packages/client-runtime/package.json | 1 + .../client-runtime/src/providerClients.ts | 2 + packages/contracts/src/agentSessions.ts | 2 +- packages/contracts/src/settings.ts | 2 +- packages/contracts/src/usage.ts | 1 + packages/provider-omp/package.json | 40 + packages/provider-omp/src/client.ts | 21 + packages/provider-omp/src/server.ts | 2 + .../provider-omp/src/server/adapter.test.ts | 468 ++ packages/provider-omp/src/server/adapter.ts | 3778 +++++++++++++++++ .../provider-omp/src/server/commands.test.ts | 64 + packages/provider-omp/src/server/commands.ts | 102 + packages/provider-omp/src/server/driver.ts | 212 + .../provider-omp/src/server/lifecycle.test.ts | 55 + packages/provider-omp/src/server/lifecycle.ts | 34 + .../src/server/maintenance.test.ts | 47 + .../provider-omp/src/server/maintenance.ts | 16 + .../src/server/mcpExtensionSource.test.ts | 65 + .../src/server/mcpExtensionSource.ts | 277 ++ .../provider-omp/src/server/mcpInjection.ts | 325 ++ .../provider-omp/src/server/questions.test.ts | 23 + packages/provider-omp/src/server/questions.ts | 51 + packages/provider-omp/src/server/rpc.ts | 449 ++ packages/provider-omp/src/server/status.ts | 491 +++ .../src/server/textGeneration.test.ts | 198 + .../provider-omp/src/server/textGeneration.ts | 152 + .../src/server/thinkingCapabilities.test.ts | 17 + .../src/server/thinkingCapabilities.ts | 76 + packages/provider-omp/src/server/usage.ts | 176 + packages/provider-omp/src/settings.ts | 41 + packages/provider-omp/tsconfig.json | 7 + pnpm-lock.yaml | 37 + 43 files changed, 7381 insertions(+), 22 deletions(-) create mode 100644 docs/user/providers-omp.md create mode 100644 packages/provider-omp/package.json create mode 100644 packages/provider-omp/src/client.ts create mode 100644 packages/provider-omp/src/server.ts create mode 100644 packages/provider-omp/src/server/adapter.test.ts create mode 100644 packages/provider-omp/src/server/adapter.ts create mode 100644 packages/provider-omp/src/server/commands.test.ts create mode 100644 packages/provider-omp/src/server/commands.ts create mode 100644 packages/provider-omp/src/server/driver.ts create mode 100644 packages/provider-omp/src/server/lifecycle.test.ts create mode 100644 packages/provider-omp/src/server/lifecycle.ts create mode 100644 packages/provider-omp/src/server/maintenance.test.ts create mode 100644 packages/provider-omp/src/server/maintenance.ts create mode 100644 packages/provider-omp/src/server/mcpExtensionSource.test.ts create mode 100644 packages/provider-omp/src/server/mcpExtensionSource.ts create mode 100644 packages/provider-omp/src/server/mcpInjection.ts create mode 100644 packages/provider-omp/src/server/questions.test.ts create mode 100644 packages/provider-omp/src/server/questions.ts create mode 100644 packages/provider-omp/src/server/rpc.ts create mode 100644 packages/provider-omp/src/server/status.ts create mode 100644 packages/provider-omp/src/server/textGeneration.test.ts create mode 100644 packages/provider-omp/src/server/textGeneration.ts create mode 100644 packages/provider-omp/src/server/thinkingCapabilities.test.ts create mode 100644 packages/provider-omp/src/server/thinkingCapabilities.ts create mode 100644 packages/provider-omp/src/server/usage.ts create mode 100644 packages/provider-omp/src/settings.ts create mode 100644 packages/provider-omp/tsconfig.json diff --git a/apps/mobile/src/features/usage/usageProviders.ts b/apps/mobile/src/features/usage/usageProviders.ts index ce9c778a77762..46d20ef4c95f8 100644 --- a/apps/mobile/src/features/usage/usageProviders.ts +++ b/apps/mobile/src/features/usage/usageProviders.ts @@ -9,6 +9,7 @@ export const PROVIDER_ORDER: readonly UsageProviderKind[] = [ "opencode", "antigravity", "pi", + "omp", "muse", ]; @@ -25,6 +26,7 @@ export const PROVIDER_LABEL: Record = { opencode: "OpenCode", antigravity: "Antigravity", pi: "Pi", + omp: "OMP", muse: "Muse Code", }; @@ -38,6 +40,7 @@ export function useProviderColors(): Record { opencode: "#5b9bbd", antigravity: "#8c7bd1", pi: "#4d9f8a", + omp: "#c78b42", muse: "#0866ff", }; } diff --git a/apps/server/package.json b/apps/server/package.json index 3a6797d90da28..49fb69c36eb97 100644 --- a/apps/server/package.json +++ b/apps/server/package.json @@ -51,6 +51,7 @@ "@t3tools/provider-grok": "workspace:*", "@t3tools/provider-kiro": "workspace:*", "@t3tools/provider-muse": "workspace:*", + "@t3tools/provider-omp": "workspace:*", "@t3tools/provider-opencode": "workspace:*", "@t3tools/provider-pi": "workspace:*", "@t3tools/source-control-azure-devops": "workspace:*", diff --git a/apps/server/src/project/AgentSessionImporter.test.ts b/apps/server/src/project/AgentSessionImporter.test.ts index 140dff31486b1..595540647260f 100644 --- a/apps/server/src/project/AgentSessionImporter.test.ts +++ b/apps/server/src/project/AgentSessionImporter.test.ts @@ -90,7 +90,9 @@ const PI_MODEL_SELECTION = { instanceId: ProviderInstanceId.make("pi"), model: " // Pi threads are owned by their session file path, not the session UUID. const nativeId = ({ source }: ReturnType) => - source.provider === "pi" ? source.filePath : source.providerSessionId; + source.provider === "pi" || source.provider === "omp" + ? source.filePath + : source.providerSessionId; function importId(source: ReturnType) { return ThreadId.make( @@ -266,11 +268,14 @@ it.effect( ); const deleted = candidate(CODEX_MODEL_SELECTION, "deleted"); const ownedPi = candidate(PI_MODEL_SELECTION, "owned-pi", "pi"); + const ompSelection = { instanceId: ProviderInstanceId.make("omp"), model: "default" }; + const ownedOmp = candidate(ompSelection, "owned-omp", "omp"); const owners = [ yield* seedOwner(active), yield* seedOwner(archived, "archived"), yield* seedOwner(deleted, "deleted"), yield* seedOwner(ownedPi), + yield* seedOwner(ownedOmp), ]; const before = yield* Effect.forEach(owners, (id) => projections.getThreadRecords(id, ["providerThreads"]), @@ -283,18 +288,21 @@ it.effect( const unowned = candidate(CODEX_MODEL_SELECTION, "unowned"); unowned.thread.omittedMessageCount = 1; const unownedPi = candidate(PI_MODEL_SELECTION, "unowned-pi", "pi"); + const unownedOmp = candidate(ompSelection, "unowned-omp", "omp"); const importer = yield* makeImporter([ active, archived, deleted, ownedPi, + ownedOmp, otherInstance, unowned, unownedPi, + unownedOmp, ]); - expect(yield* importer.run).toEqual({ importedCount: 3, skippedCount: 0 }); - for (const source of [active, archived, deleted, ownedPi]) { + expect(yield* importer.run).toEqual({ importedCount: 4, skippedCount: 0 }); + for (const source of [active, archived, deleted, ownedPi, ownedOmp]) { const threadId = importId(source); expect(yield* Effect.option(projections.getThread(threadId))).toEqual(Option.none()); expect(yield* events.read({ threadId }).pipe(Stream.runCollect)).toEqual([]); @@ -311,8 +319,15 @@ it.effect( "event" in stored ? [stored.event.threadId] : [], ), ), - ).toEqual(new Set([importId(otherInstance), importId(unowned), importId(unownedPi)])); - for (const source of [otherInstance, unowned, unownedPi]) { + ).toEqual( + new Set([ + importId(otherInstance), + importId(unowned), + importId(unownedPi), + importId(unownedOmp), + ]), + ); + for (const source of [otherInstance, unowned, unownedPi, unownedOmp]) { const threadId = importId(source); const records = yield* projections.getThreadRecords(threadId, [ "messages", @@ -345,6 +360,15 @@ it.effect( runtimePayload: { importedTranscripts: [source.source] }, }); } + const publishedBeforeRepeat = [...importer.published]; + const ompBeforeRepeat = yield* events + .read({ threadId: importId(unownedOmp) }) + .pipe(Stream.runCollect); + expect(yield* importer.run).toEqual({ importedCount: 4, skippedCount: 0 }); + expect(importer.published).toEqual(publishedBeforeRepeat); + expect( + yield* events.read({ threadId: importId(unownedOmp) }).pipe(Stream.runCollect), + ).toEqual(ompBeforeRepeat); }).pipe(Effect.scoped, Effect.provide(persistence)), ); diff --git a/apps/server/src/project/AgentSessionImporter.ts b/apps/server/src/project/AgentSessionImporter.ts index 211ad06fc267a..de0777c46f820 100644 --- a/apps/server/src/project/AgentSessionImporter.ts +++ b/apps/server/src/project/AgentSessionImporter.ts @@ -272,7 +272,9 @@ const make = Effect.gen(function* () { const driver = ProviderDriverKind.make(thread.source); // Pi resumes by session file path; its session UUID only names the thread. const nativeThreadId = - thread.source === "pi" ? source.filePath : thread.providerSessionId; + thread.source === "pi" || thread.source === "omp" + ? source.filePath + : thread.providerSessionId; const persistRuntime = runtimes.upsert( { threadId, diff --git a/apps/server/src/project/AgentSessionScanner.test.ts b/apps/server/src/project/AgentSessionScanner.test.ts index f9c7aaf3fd3d4..8af2626b18b0f 100644 --- a/apps/server/src/project/AgentSessionScanner.test.ts +++ b/apps/server/src/project/AgentSessionScanner.test.ts @@ -94,6 +94,10 @@ const layerScannerTest = (input: ScannerTestInput) => ], config: {}, }, + [ProviderInstanceId.make("omp")]: { + driver: ProviderDriverKind.make("omp"), + enabled: false, + }, ...input.providerInstances, }, }), @@ -2262,6 +2266,69 @@ describe.skipIf(HostProcess.Platform.defaultValue() === "win32")( ); describe("parseAgentSessionTranscript", () => { + it("reads OMP model changes and the active branch without modifying the native transcript", () => { + const contents = [ + { + type: "session", + version: 3, + id: "omp-native", + cwd: "/project", + timestamp: "2026-11-08T12:00:00Z", + }, + { + type: "model_change", + id: "m", + parentId: null, + model: "openai/gpt-4.1-mini", + runtime: { version: "18.16.0" }, + }, + { + type: "message", + id: "u", + parentId: "m", + message: { role: "user", content: [{ type: "text", text: "Review this" }] }, + }, + { + type: "message", + id: "old", + parentId: "u", + message: { role: "assistant", content: [{ type: "text", text: "Abandoned" }] }, + }, + { + type: "message", + id: "a", + parentId: "u", + message: { + role: "assistant", + content: [ + { type: "thinking", thinking: "private" }, + { type: "text", text: "Reviewed" }, + ], + }, + }, + { type: "session_info", id: "n", parentId: "a", name: "OMP review" }, + ] + .map((entry) => JSON.stringify(entry)) + .join("\n"); + const input = { + contents, + source: "omp" as const, + providerInstanceId: ProviderInstanceId.make("omp"), + fallbackSessionId: "unused", + lastActiveAtMs: Date.parse("2026-11-08T12:00:00Z"), + }; + const first = AgentSessionScanner.parseAgentSessionTranscript(input); + expect(first).toMatchObject({ + source: "omp", + providerSessionId: "omp-native", + title: "OMP review", + model: "openai/gpt-4.1-mini", + }); + expect(first?.messages.map((message) => message.text)).toEqual(["Review this", "Reviewed"]); + expect(AgentSessionScanner.parseAgentSessionTranscript(input)).toEqual(first); + expect(input.contents).toBe(contents); + }); + it.each([false, true])( "handles the exact record limit and an interior blank overflow=%s", (overflow) => { diff --git a/apps/server/src/project/AgentSessionScanner.ts b/apps/server/src/project/AgentSessionScanner.ts index dc67bd9387e04..d4938e2f38fbc 100644 --- a/apps/server/src/project/AgentSessionScanner.ts +++ b/apps/server/src/project/AgentSessionScanner.ts @@ -36,6 +36,7 @@ import * as ProjectStore from "../orchestration-v2/ProjectStore.ts"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; +import { resolveOmpSessionsDir } from "@t3tools/provider-omp/server/usage"; import { resolvePiSessionsDir } from "@t3tools/provider-pi/server/usage"; import * as ServerSettings from "../serverSettings.ts"; import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts"; @@ -111,6 +112,7 @@ const TranscriptRecord = Schema.Struct({ id: Schema.optional(Schema.String), parentId: Schema.optional(Schema.NullOr(Schema.String)), name: Schema.optional(Schema.String), + model: Schema.optional(Schema.String), timestamp: Schema.optional(Schema.String), cwd: Schema.optional(Schema.String), sessionId: Schema.optional(Schema.String), @@ -430,14 +432,13 @@ function parseAgentSessionRecords( let providerSessionId = input.source === "codex" ? "" - : input.source === "pi" + : isTreeSession(input.source) ? records.find((record) => record.type === "session")?.id?.trim() || input.fallbackSessionId : (claudeFields.sessionId ?? input.fallbackSessionId); // Pi titles a session by its latest session_info on any branch; an empty name clears it. - const title = - input.source === "pi" - ? records.findLast((record) => record.type === "session_info")?.name?.trim() || null - : (claudeFields.title ?? null); + const title = isTreeSession(input.source) + ? records.findLast((record) => record.type === "session_info")?.name?.trim() || null + : (claudeFields.title ?? null); let model = claudeFields.model ?? null; let derivedTitle: string | undefined; let hasCodexSessionId = false; @@ -530,9 +531,11 @@ function parseAgentSessionRecords( }; let recordIndex = -1; - for (const record of input.source === "pi" ? activePiBranch(records) : records) { + for (const record of isTreeSession(input.source) ? activePiBranch(records) : records) { recordIndex += 1; - if (input.source === "pi") { + if (isTreeSession(input.source)) { + if (input.source === "omp" && record.type === "model_change" && record.model?.trim()) + model = record.model.trim(); if (!isPiConversationRecord(record)) continue; const text = extractText(record.message.content); if (text.length === 0) continue; @@ -649,7 +652,7 @@ function shouldRetainDecodedRecord( record: DecodedTranscriptRecord, ): boolean { // Any Pi entry can be a link on the active branch. - if (source === "pi") return true; + if (isTreeSession(source)) return true; if (source === "claudeAgent") { if (isHiddenClaudeRecord(record) || (record.type !== "user" && record.type !== "assistant")) { return false; @@ -1065,7 +1068,7 @@ export const make = Effect.gen(function* () { if (recordCount > MAX_IMPORT_RECORDS) return false; const value = reader.finish(); const decoded = decodeTranscriptValue(value); - if (Option.isNone(decoded) && source === "pi") { + if (Option.isNone(decoded) && isTreeSession(source)) { // Pi accepts messages this schema rejects, such as null content; keep their tree links. records.push(...Option.toArray(decodePiEntryLinks(value))); } else if (Option.isSome(decoded)) { @@ -1075,7 +1078,7 @@ export const make = Effect.gen(function* () { } if (shouldRetainDecodedRecord(source, decoded.value)) { if ( - source === "pi" && + isTreeSession(source) && decoded.value.type === "message" && !isPiConversationRecord(decoded.value) ) { @@ -1407,7 +1410,7 @@ export const make = Effect.gen(function* () { const raw: Array = []; let truncated = false; - for (const source of ["claudeAgent", "codex", "pi"] as const) { + for (const source of ["claudeAgent", "codex", "pi", "omp"] as const) { const instances: Array<{ readonly instanceId: ProviderInstanceId; readonly config: ProviderInstanceConfig; @@ -1445,12 +1448,16 @@ export const make = Effect.gen(function* () { }; let homePath: string; - if (source === "pi") { + if (isTreeSession(source)) { const environment = yield* mergeProviderInstanceEnvironment( instance.environment, hostEnvironment, ).pipe(Effect.provideService(HostProcess.HomeDirectory, homeDir)); - homePath = resolvePiSessionsDir(environment, homeDir, path); + homePath = (source === "omp" ? resolveOmpSessionsDir : resolvePiSessionsDir)( + environment, + homeDir, + path, + ); } else if (source === "claudeAgent") { const config = decodeClaudeSettings(instance.config ?? {}); if (Option.isNone(config)) continue; @@ -1879,3 +1886,7 @@ export const make = Effect.gen(function* () { export const layer = Layer.effect(AgentSessionScanner, make).pipe( Layer.provide(ProcessRunner.layer), ); + +function isTreeSession(source: AgentSessionSource): boolean { + return source === "pi" || source === "omp"; +} diff --git a/apps/server/src/provider/builtInDrivers.ts b/apps/server/src/provider/builtInDrivers.ts index 342a6780e9ad0..29ac3ca471f55 100644 --- a/apps/server/src/provider/builtInDrivers.ts +++ b/apps/server/src/provider/builtInDrivers.ts @@ -11,6 +11,7 @@ import { GrokDriver, type GrokDriverEnv } from "@t3tools/provider-grok/server"; import { OpenCodeDriver, type OpenCodeDriverEnv } from "@t3tools/provider-opencode/server"; import { MuseDriver, type MuseDriverEnv } from "@t3tools/provider-muse/server"; import { PiDriver, type PiDriverEnv } from "@t3tools/provider-pi/server"; +import { OmpDriver, type OmpDriverEnv } from "@t3tools/provider-omp/server"; import type { AnyProviderDriver, ProviderUsageReaderEnv, @@ -28,6 +29,7 @@ export type BuiltInDriversEnv = | KiroDriverEnv | OpenCodeDriverEnv | PiDriverEnv + | OmpDriverEnv | MuseDriverEnv; export const BUILT_IN_DRIVERS: ReadonlyArray> = [ @@ -40,6 +42,7 @@ export const BUILT_IN_DRIVERS: ReadonlyArray | ProviderUsageReaderEnv | ProviderUsageReaderEnv + | ProviderUsageReaderEnv | ProviderUsageReaderEnv; /** Order matters: aggregation keeps the first duplicate record. */ @@ -62,6 +66,7 @@ export const BUILT_IN_USAGE_DRIVERS: ReadonlyArray< CodexDriver, GrokDriver, PiDriver, + OmpDriver, OpenCodeDriver, MuseDriver, AntigravityDriver, diff --git a/apps/web/src/components/onboarding/WelcomeWizard.tsx b/apps/web/src/components/onboarding/WelcomeWizard.tsx index 2eb6bcd673957..de302147cfbdd 100644 --- a/apps/web/src/components/onboarding/WelcomeWizard.tsx +++ b/apps/web/src/components/onboarding/WelcomeWizard.tsx @@ -1761,6 +1761,7 @@ const IMPORT_SOURCE_NAMES: Record = { claudeAgent: "Claude Code", codex: "Codex", pi: "Pi", + omp: "OMP", }; function ImportRowMeta({ diff --git a/apps/web/src/components/usage/usageProviders.ts b/apps/web/src/components/usage/usageProviders.ts index ba86171e87a4c..deaabf61300b9 100644 --- a/apps/web/src/components/usage/usageProviders.ts +++ b/apps/web/src/components/usage/usageProviders.ts @@ -37,6 +37,7 @@ export const PROVIDER_PRESENTATION = { color: "#8c7bd1", driverKind: ProviderDriverKind.make("antigravity"), }, + omp: { label: "OMP", color: "#c78b42", driverKind: ProviderDriverKind.make("omp") }, pi: { label: "Pi", color: "#4d9f8a", diff --git a/docs/user/install.md b/docs/user/install.md index 4689a2965889b..76323993be93c 100644 --- a/docs/user/install.md +++ b/docs/user/install.md @@ -186,6 +186,7 @@ computer. | Kiro | Install [Kiro CLI](https://kiro.dev/docs/cli/), then run `kiro-cli login`. | | OpenCode | Install [OpenCode](https://opencode.ai), then run `opencode auth login`. | | Antigravity | Install and sign in with Google from T3 Code's provider settings. | +| OMP | Install [OMP](./providers-omp.md) on the server and configure its model provider, then enable OMP in Settings. | | Pi | Install [Pi](./providers-pi.md#set-up-pi) with Node.js 22.19 or newer, then run `pi` and `/login`. | | Muse Code | Install [Muse Code](https://dev.meta.ai/docs/muse-code) on the server, run `muse login`, then enable it in Settings → Providers. | | fx | Install [fx](https://fx.sh) with `curl -fsSL https://fx.sh/setup.sh \| bash`, then run `fx login`. | @@ -221,7 +222,7 @@ their original values. For provider-specific setup and accounts, see [Codex](./providers-codex.md), [Claude](./providers-claude.md), [OpenCode](./providers-opencode.md), [Antigravity](./providers-antigravity.md), [Kiro](./providers-kiro.md), -[Pi](./providers-pi.md), [Muse Code](./providers-muse.md), and [fx](./providers-fx.md). +[Pi](./providers-pi.md), [OMP](./providers-omp.md), [Muse Code](./providers-muse.md), and [fx](./providers-fx.md). ## Next steps diff --git a/docs/user/providers-omp.md b/docs/user/providers-omp.md new file mode 100644 index 0000000000000..94edb5c171545 --- /dev/null +++ b/docs/user/providers-omp.md @@ -0,0 +1,15 @@ +# OMP + +T3 Code connects directly to the Oh My Pi (`omp`) native RPC interface. Install OMP 18.16.0 or newer on the machine running your T3 server, configure its model provider there, then enable **OMP** in Settings. If `omp` is not on that server's PATH, set its binary path. + +OMP keeps its configured models, authentication, project context, extensions, and skills. The model picker uses OMP's discovered models and thinking levels. Workspace slash commands and skills appear in the composer. Terminal-only widgets and editors that require a custom terminal renderer are not displayed. + +Assistant text, reasoning, tool output, compaction, usage, and native subagent progress appear in the conversation. You can stop or steer a running turn and queue subsequent messages. A yielded model response remains active while OMP reports pending asynchronous work. OMP confirmation, selection, text-input, editor, and structured question dialogs appear in T3 Code; pending dialogs do not survive a process restart. + +Supervised mode asks before commands and changes. Auto-accept edits allows the built-in edit and write tools; Full access runs without T3 confirmations. These controls use OMP's blocking extension hook. Native subagent approval forwarding is not supported; use the OMP terminal for workflows requiring separate child approval dialogs. + +Native OMP sessions can be discovered and imported. Import creates a snapshot, not a live synchronization. Repeating an import preserves the existing T3 history. Resuming an imported session uses a private copy under T3's state directory, leaving the original transcript unchanged. Native conversation forks and rollback use OMP's session tree. Project paths must exist on the server that owns the provider. + +Provider settings show version advisories and an update action when the installation supports it. Native installations use `omp update`; package-managed installations use their owning manager. Updates run separately from existing agent processes and refresh provider metadata afterward. Existing processes retain the version they started with; start a new session to use the updated binary. T3 does not automatically update OMP, change its release channel, or update plugins. + +T3's MCP tools are available to the agent. Native OMP subagents appear in the work log, but separate child thread browsing, child stop/wait/fork controls, structured plan review and TODO panels are not available through this provider. Use OMP's own commands and tools for those workflows. Terminal UI themes, widgets, live voice, and terminal input shortcuts remain terminal features. diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json index f52115577f108..7b83d0ef509d0 100644 --- a/packages/client-runtime/package.json +++ b/packages/client-runtime/package.json @@ -554,6 +554,7 @@ "@t3tools/provider-grok": "workspace:*", "@t3tools/provider-kiro": "workspace:*", "@t3tools/provider-muse": "workspace:*", + "@t3tools/provider-omp": "workspace:*", "@t3tools/provider-opencode": "workspace:*", "@t3tools/provider-pi": "workspace:*", "@t3tools/secret-provider-definitions": "workspace:*", diff --git a/packages/client-runtime/src/providerClients.ts b/packages/client-runtime/src/providerClients.ts index 3759cecbc7c7d..652ce842ec24a 100644 --- a/packages/client-runtime/src/providerClients.ts +++ b/packages/client-runtime/src/providerClients.ts @@ -15,6 +15,7 @@ import { kiroClient } from "@t3tools/provider-kiro/client"; import { museClient } from "@t3tools/provider-muse/client"; import { openCodeClient } from "@t3tools/provider-opencode/client"; import { piClient } from "@t3tools/provider-pi/client"; +import { ompClient } from "@t3tools/provider-omp/client"; // OpenRouter's Ink and Cloud glyphs from https://openrouter.ai/brand. export const openRouterIcon: ProviderIcon = { @@ -56,6 +57,7 @@ export const providerClients = makeProviderClientRegistry([ kiroClient, museClient, piClient, + ompClient, acpRegistryClient, ]); diff --git a/packages/contracts/src/agentSessions.ts b/packages/contracts/src/agentSessions.ts index 93e0e36e4fbd4..6d134795f4d57 100644 --- a/packages/contracts/src/agentSessions.ts +++ b/packages/contracts/src/agentSessions.ts @@ -2,7 +2,7 @@ import * as Schema from "effect/Schema"; import { IsoDateTime, NonNegativeInt, ProjectId, TrimmedNonEmptyString } from "./baseSchemas.ts"; import { ProviderInstanceId } from "./providerInstance.ts"; -export const AgentSessionSource = Schema.Literals(["claudeAgent", "codex", "pi"]); +export const AgentSessionSource = Schema.Literals(["claudeAgent", "codex", "pi", "omp"]); export type AgentSessionSource = typeof AgentSessionSource.Type; export const AgentSessionImportSource = Schema.Struct({ diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts index f6409a87074fd..0356900bf1feb 100644 --- a/packages/contracts/src/settings.ts +++ b/packages/contracts/src/settings.ts @@ -1475,7 +1475,7 @@ export const providerInstanceConfigEnabledFlag = (config: unknown): boolean | un // Must match each driver's enabled decoding default. const DEFAULT_DISABLED_PROVIDER_DRIVERS: ReadonlySet = new Set( - ["cursor", "grok", "fx", "kiro", "muse", "pi", "opencode", "antigravity"].map((driver) => + ["cursor", "grok", "fx", "kiro", "muse", "pi", "omp", "opencode", "antigravity"].map((driver) => ProviderDriverKind.make(driver), ), ); diff --git a/packages/contracts/src/usage.ts b/packages/contracts/src/usage.ts index b473a7264b1a4..4222e7c05530d 100644 --- a/packages/contracts/src/usage.ts +++ b/packages/contracts/src/usage.ts @@ -15,6 +15,7 @@ export const UsageProviderKind = Schema.Literals([ "opencode", "antigravity", "pi", + "omp", "muse", ]); export type UsageProviderKind = typeof UsageProviderKind.Type; diff --git a/packages/provider-omp/package.json b/packages/provider-omp/package.json new file mode 100644 index 0000000000000..c6905a315e4bf --- /dev/null +++ b/packages/provider-omp/package.json @@ -0,0 +1,40 @@ +{ + "name": "@t3tools/provider-omp", + "private": true, + "type": "module", + "exports": { + "./client": { + "types": "./src/client.ts", + "import": "./src/client.ts" + }, + "./settings": { + "types": "./src/settings.ts", + "import": "./src/settings.ts" + }, + "./server": { + "types": "./src/server.ts", + "import": "./src/server.ts" + }, + "./server/usage": { + "types": "./src/server/usage.ts", + "import": "./src/server/usage.ts" + } + }, + "scripts": { + "typecheck": "effect-tsgo tsrs --noEmit", + "test": "vp test run --config ../../vite.config.ts --dir ." + }, + "dependencies": { + "@t3tools/contracts": "workspace:*", + "@t3tools/provider-core": "workspace:*", + "@t3tools/shared": "workspace:*", + "effect": "catalog:" + }, + "devDependencies": { + "@effect/platform-node": "catalog:", + "@effect/vitest": "catalog:", + "@t3tools/provider-testing": "workspace:*", + "@types/node": "catalog:", + "vite-plus": "catalog:" + } +} diff --git a/packages/provider-omp/src/client.ts b/packages/provider-omp/src/client.ts new file mode 100644 index 0000000000000..7fa6c61db074e --- /dev/null +++ b/packages/provider-omp/src/client.ts @@ -0,0 +1,21 @@ +import { ProviderDriverKind } from "@t3tools/contracts"; +import { defineProviderClient } from "@t3tools/provider-core/client"; + +import { OmpSettings } from "./settings.ts"; + +export const ompClient = defineProviderClient({ + driverKind: ProviderDriverKind.make("omp"), + label: "OMP", + acpRegistryAgentIds: ["omp-acp"], + settingsSchema: OmpSettings, + icon: { + viewBox: "0 0 24 24", + fill: { light: "#0F0F0F", dark: "#F5F5F5" }, + paths: [ + { + d: "M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20Zm0 5a5 5 0 1 1 0 10 5 5 0 0 1 0-10Z", + fillRule: "evenodd", + }, + ], + }, +}); diff --git a/packages/provider-omp/src/server.ts b/packages/provider-omp/src/server.ts new file mode 100644 index 0000000000000..cb42789e05dce --- /dev/null +++ b/packages/provider-omp/src/server.ts @@ -0,0 +1,2 @@ +export { OmpDriver, type OmpDriverEnv } from "./server/driver.ts"; +export { OMP_PROVIDER, OmpAdapterV2Driver, type OmpAdapterV2DriverEnv } from "./server/adapter.ts"; diff --git a/packages/provider-omp/src/server/adapter.test.ts b/packages/provider-omp/src/server/adapter.test.ts new file mode 100644 index 0000000000000..916e36f436327 --- /dev/null +++ b/packages/provider-omp/src/server/adapter.test.ts @@ -0,0 +1,468 @@ +import { assert, describe, it } from "@effect/vitest"; +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { + NodeId, + ProviderInstanceId, + ProviderSessionId, + RunAttemptId, + RunId, + ThreadId, + type ChatAttachment, + type ModelSelection, + type OrchestrationV2AppThread, + type OrchestrationV2ProviderThread, +} from "@t3tools/contracts"; +import * as Cause from "effect/Cause"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Queue from "effect/Queue"; +import * as Schema from "effect/Schema"; +import * as Sink from "effect/Sink"; +import * as Stream from "effect/Stream"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; + +import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost"; +import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; +import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator"; +import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import { makeOmpAdapterV2 } from "./adapter.ts"; +import { makeOmpRpcConnection, type OmpRpcRecord } from "./rpc.ts"; + +const layerTest = Layer.mergeAll( + NodeServices.layer, + IdAllocator.layer, + McpProviderSessions.layer, + TestProviderHost.layer().pipe(Layer.provide(NodeServices.layer)), +); + +const decodeJsonLine = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown)); +const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown)); + +const OMP_INSTANCE_ID = ProviderInstanceId.make("omp"); +const THREAD_ID = ThreadId.make("thread-omp-test"); +const SESSION_ID = ProviderSessionId.make("provider-session-omp-test"); +const FAKE_SESSION_FILE = "/fake/.omp/agent/sessions/--workspace--/0001_abc.jsonl"; +/** Deliberately outside the valid pid range so a group-kill can never land. */ +const FAKE_PID = 999_999_999; + +const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ + runtimeMode: "full-access", + interactionMode: "default", + cwd: null, +}); + +const modelSelection = (model: string): ModelSelection => ({ + instanceId: OMP_INSTANCE_ID, + model, +}); + +const makeFakeOmp = Effect.gen(function* () { + const stdout = yield* Queue.unbounded(); + const requests = yield* Queue.unbounded(); + const emit = (record: OmpRpcRecord) => + Queue.offer(stdout, new TextEncoder().encode(`${encodeJsonLine(record)}\n`)); + let buffered = ""; + const spawner = ChildProcessSpawner.make(() => + Effect.succeed( + ChildProcessSpawner.makeHandle({ + pid: ChildProcessSpawner.ProcessId(FAKE_PID), + exitCode: Effect.never, + isRunning: Effect.succeed(true), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.forEach((chunk: Uint8Array) => + Effect.gen(function* () { + buffered += new TextDecoder().decode(chunk); + const lines = buffered.split("\n"); + buffered = lines.pop() ?? ""; + for (const line of lines.filter(Boolean)) { + const record = decodeJsonLine(line) as OmpRpcRecord; + yield* Queue.offer(requests, record); + if (record["type"] === "extension_ui_response") continue; + const data = + record["type"] === "get_state" + ? { + sessionFile: FAKE_SESSION_FILE, + isStreaming: false, + isSettled: true, + hasPendingAsyncWork: false, + queuedMessageCount: 0, + } + : record["type"] === "get_entries" + ? { entries: [], leafId: null } + : record["type"] === "get_available_models" + ? { models: [] } + : {}; + yield* emit({ + type: "response", + id: record["id"], + command: record["type"], + success: true, + data, + }); + } + }), + ), + stdout: Stream.fromQueue(stdout), + stderr: Stream.empty, + all: Stream.empty, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.empty, + }), + ), + ); + const takeRequest = (type: string) => + Effect.gen(function* () { + while (true) { + const request = yield* Queue.take(requests); + if (request["type"] === type) return request; + } + }); + return { spawner, emit, takeRequest, closeStdout: Queue.end(stdout) }; +}); +type FakeOmp = Effect.Success; +const makeAdapter = (fake: FakeOmp) => + makeOmpAdapterV2({ + instanceId: OMP_INSTANCE_ID, + settings: { enabled: true, binaryPath: "omp", launchArgs: "", customModels: [] }, + environment: {}, + }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, fake.spawner)); + +const openRuntime = Effect.fnUntraced(function* ( + fake: FakeOmp, + model = "default", + threadId = THREAD_ID, + providerSessionId = SESSION_ID, +) { + const adapter = yield* makeAdapter(fake); + const runtime = yield* adapter.openSession({ + threadId, + providerSessionId, + modelSelection: modelSelection(model), + runtimePolicy, + }); + const emitted = yield* Queue.unbounded(); + yield* runtime.events.pipe( + Stream.runForEach((event) => Queue.offer(emitted, event)), + Effect.forkScoped, + ); + const takeEvent = (predicate: (event: ProviderAdapter.ProviderAdapterV2Event) => boolean) => + Effect.gen(function* () { + while (true) { + const event = yield* Queue.take(emitted); + if (predicate(event)) return event; + } + }); + return { runtime, takeEvent }; +}); + +const makeAppThread = Effect.fnUntraced(function* (model: string, threadId = THREAD_ID) { + const now = yield* DateTime.now; + return { + createdBy: "user", + creationSource: "web", + id: threadId, + projectId: "project:fixture:omp" as OrchestrationV2AppThread["projectId"], + title: "Omp test thread", + providerInstanceId: OMP_INSTANCE_ID, + modelSelection: modelSelection(model), + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: null, + activeProviderThreadId: null, + lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId }, + forkedFrom: null, + createdAt: now, + updatedAt: now, + archivedAt: null, + settledOverride: null, + settledAt: null, + lastVisitedAt: null, + deletedAt: null, + } satisfies OrchestrationV2AppThread; +}); + +const startTurn = Effect.fnUntraced(function* ( + runtime: ProviderAdapter.ProviderAdapterV2SessionRuntime, + providerThread: OrchestrationV2ProviderThread, + model = "default", + attachments: ReadonlyArray = [], + text = "Hello omp", + selection?: ModelSelection, + runOrdinal = 1, + threadId = THREAD_ID, + continuation = false, +) { + const appThread = yield* makeAppThread(model, threadId); + const runId = RunId.make(`run:${threadId}:${runOrdinal}`); + yield* runtime.startTurn({ + appThread, + threadId, + runId, + runOrdinal, + providerTurnOrdinal: runOrdinal, + attemptId: RunAttemptId.make(`run-attempt:${runId}:1`), + rootNodeId: NodeId.make(`node:${runId}:root`), + providerThread, + message: { + messageId: `message:${threadId}:${runOrdinal}` as never, + text, + attachments, + createdBy: continuation ? "agent" : "user", + creationSource: continuation ? "provider" : "web", + }, + modelSelection: selection ?? modelSelection(model), + runtimePolicy, + }); +}); + +describe("OmpAdapterV2", () => { + it.effect("keeps background work open until OMP reports session settlement", () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake); + const providerThread = yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("default"), + runtimePolicy, + }); + yield* startTurn(runtime, providerThread); + yield* fake.takeRequest("prompt"); + yield* fake.emit({ type: "agent_start" }); + yield* fake.emit({ type: "agent_end", isTerminal: false, messages: [] }); + yield* fake.emit({ type: "prompt_result", status: "completed", sessionSettled: false }); + yield* fake.emit({ + type: "subagent_lifecycle", + payload: { + id: "native-child", + agent: "explore", + description: "Inspect files", + status: "started", + parentToolCallId: "spawn", + }, + }); + const child = yield* takeEvent( + (event) => event.type === "subagent.updated" || event.type === "turn.terminal", + ); + assert.isTrue(child.type === "subagent.updated" && child.subagent.status === "running"); + yield* fake.emit({ + type: "subagent_lifecycle", + payload: { + id: "native-child", + agent: "explore", + status: "completed", + parentToolCallId: "spawn", + }, + }); + yield* fake.emit({ type: "session_settled" }); + const terminal = yield* takeEvent((event) => event.type === "turn.terminal"); + assert.equal(terminal.type, "turn.terminal"); + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); + + it.effect("cancels a native question when OMP sends its targetId", () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake); + yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("default"), + runtimePolicy, + }); + yield* fake.emit({ + type: "extension_ui_request", + id: "question", + method: "ask", + questions: [{ id: "q", question: "Continue?", options: [{ label: "Yes" }] }], + }); + yield* takeEvent( + (event) => + event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending", + ); + yield* fake.emit({ + type: "extension_ui_request", + id: "cancel", + method: "cancel", + targetId: "question", + }); + const cancelled = yield* takeEvent( + (event) => + event.type === "runtime_request.updated" && event.runtimeRequest.status === "cancelled", + ); + assert.equal(cancelled.type, "runtime_request.updated"); + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); + + it.effect("emits session-start dialogs before a turn exists", () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake); + yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("default"), + runtimePolicy, + }); + yield* fake.emit({ + type: "extension_ui_request", + id: "ui-trust", + method: "confirm", + title: "Run project extensions?", + message: "This project has .omp/extensions.", + }); + const pending = yield* takeEvent( + (event) => + event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending", + ); + const requestId = + pending.type === "runtime_request.updated" ? pending.runtimeRequest.id : undefined; + yield* runtime.respondToRuntimeRequest({ requestId: requestId!, decision: "accept" }); + const uiResponse = yield* fake.takeRequest("extension_ui_response"); + assert.equal(uiResponse["id"], "ui-trust"); + assert.equal(uiResponse["confirmed"], true); + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); + + it.effect("cancels startup dialogs when Omp exits before a turn exists", () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake); + yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("default"), + runtimePolicy, + }); + yield* fake.emit({ + type: "extension_ui_request", + id: "startup", + method: "confirm", + title: "Trust project?", + }); + const pending = yield* takeEvent( + (event) => + event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending", + ); + if (pending.type !== "runtime_request.updated") return; + yield* fake.closeStdout; + const cancelled = yield* takeEvent( + (event) => + event.type === "runtime_request.updated" && + event.runtimeRequest.id === pending.runtimeRequest.id && + event.runtimeRequest.status === "cancelled", + ); + assert.isTrue(cancelled.type === "runtime_request.updated"); + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); + + it.effect("raises bridge edit confirmations as file-change approvals", () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake); + const providerThread = yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("default"), + runtimePolicy, + }); + yield* startTurn(runtime, providerThread); + yield* fake.takeRequest("prompt"); + for (const [id, title, requestKind] of [ + ["ui-edit", "Allow edit?", "file-change"], + ["ui-bash", "Allow bash?", "command"], + ["ui-ext", "Deploy to staging?", "command"], + ] as const) { + yield* fake.emit({ type: "extension_ui_request", id, method: "confirm", title }); + const item = yield* takeEvent( + (event) => + event.type === "turn_item.updated" && event.turnItem.type === "approval_request", + ); + assert.isTrue( + item.type === "turn_item.updated" && + item.turnItem.type === "approval_request" && + item.turnItem.requestKind === requestKind, + `${title} should be ${requestKind}`, + ); + } + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); + + const makeHandle = (options: { + readonly exitCode: Effect.Effect; + readonly stderr: Stream.Stream; + }) => + ChildProcessSpawner.makeHandle({ + pid: ChildProcessSpawner.ProcessId(FAKE_PID), + exitCode: options.exitCode, + isRunning: Effect.succeed(true), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.drain, + stdout: Stream.empty, + stderr: options.stderr, + all: Stream.empty, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.empty, + }); + + it.effect("fails closed when OMP cannot load the required permission bridge", () => + Effect.gen(function* () { + const requiredExtensionPath = "/fixture/omp-t3-mcp-extension.ts"; + const connection = yield* makeOmpRpcConnection({ + command: "omp", + args: [], + cwd: undefined, + env: {}, + requiredExtensionPath, + }).pipe( + Effect.provideService( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make(() => + Effect.succeed({ + ...makeHandle({ + exitCode: Effect.never, + stderr: Stream.succeed( + new TextEncoder().encode( + `Failed to load extension ${requiredExtensionPath}: unavailable dependency secret-token`, + ), + ), + }), + stdout: Stream.never, + }), + ), + ), + ); + const error = yield* Queue.take(connection.events).pipe(Effect.flip); + assert.equal(error.operation, "extension"); + assert.notInclude(error.message, "secret-token"); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); + + it.effect("reports a nonzero exit code instead of an unexplained stdout close", () => + Effect.gen(function* () { + const secret = "API_KEY=super-secret\n"; + const spawner = ChildProcessSpawner.make(() => + Effect.succeed( + makeHandle({ + exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)), + stderr: Stream.fromIterable([new TextEncoder().encode(secret)]), + }), + ), + ); + const connection = yield* makeOmpRpcConnection({ + command: "omp", + args: ["--mode", "rpc"], + cwd: undefined, + env: {}, + }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner)); + + const error = yield* Queue.take(connection.events).pipe(Effect.flip); + assert.equal(error._tag, "OmpRpcError"); + assert.equal(error.operation, "read"); + assert.equal(error.detail, "omp process exited with code 1"); + assert.isFalse((error.detail ?? "").includes("API_KEY")); + assert.isFalse((error.detail ?? "").includes("super-secret")); + assert.isFalse(error.message.includes("API_KEY")); + assert.isFalse(error.message.includes("super-secret")); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); +}); diff --git a/packages/provider-omp/src/server/adapter.ts b/packages/provider-omp/src/server/adapter.ts new file mode 100644 index 0000000000000..f53cf9655bff6 --- /dev/null +++ b/packages/provider-omp/src/server/adapter.ts @@ -0,0 +1,3778 @@ +import { ompAskQuestions, ompAskResponse } from "./questions.ts"; +import { isOmpSessionSettled, ompPromptFailure, ompForkMessageParent } from "./lifecycle.ts"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as NodeUtil from "node:util"; +import { AgentScope } from "@t3tools/shared/AgentScope"; +import { getModelSelectionStringOptionValue } from "@t3tools/shared/model"; +import { readToolOutputImage } from "@t3tools/shared/toolOutput"; +import * as Predicate from "effect/Predicate"; +import { + ProviderDriverKind, + type ChatAttachment, + type ModelSelection, + type OrchestrationV2ExecutionNode, + type OrchestrationV2ProviderCapabilities, + type OrchestrationV2ProviderFailure, + type OrchestrationV2ProviderRef, + type OrchestrationV2ProviderRetry, + type OrchestrationV2ProviderSession, + type OrchestrationV2ProviderThread, + type OrchestrationV2ProviderTurn, + type OrchestrationV2RuntimeRequest, + type OrchestrationV2TurnItem, + type OrchestrationV2UserInputQuestion, + type ProviderApprovalDecision, + type ProviderInstanceId, + type OrchestrationV2ProviderTurnTokenUsage, +} from "@t3tools/contracts"; +import { OmpSettings } from "../settings.ts"; +import * as Cause from "effect/Cause"; +import * as DateTime from "effect/DateTime"; +import * as Deferred from "effect/Deferred"; +import * as Option from "effect/Option"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Fiber from "effect/Fiber"; +import * as Queue from "effect/Queue"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; +import * as Stream from "effect/Stream"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; + +import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; +import { providerMessageTextWithAttachmentPaths } from "@t3tools/provider-core/server/attachmentPrompt"; +import { mcpToolPresentation } from "@t3tools/provider-core/server/mcpToolPresentation"; +import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; +import { parseOmpCompactCommand, type OmpCompactCommand } from "./commands.ts"; +import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; +import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator"; +import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter"; +import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests"; +import { + ProviderAdapterDriverCreateError, + type ProviderAdapterDriver, + type ProviderAdapterDriverCreateInput, +} from "@t3tools/provider-core/server/adapterDriver"; +import { + makeProviderFailure, + makeProviderRetryTurnItem, +} from "@t3tools/provider-core/server/failure"; +import { turnScopedSelectionTransition } from "@t3tools/provider-core/server/selectionTransition"; +import { + makeOmpRpcConnection, + parseOmpModelSlug, + ompRecordField as recordField, + ompRecordNumber as recordNumber, + ompRecordString as recordString, + type OmpRpcConnection, + type OmpRpcRecord, +} from "./rpc.ts"; +import { + buildOmpRpcLaunch, + materializeOmpT3McpExtension, + resolveOmpLaunchArgs, +} from "./mcpInjection.ts"; +import { OMP_FILE_CHANGE_TOOLS } from "./mcpExtensionSource.ts"; + +export const OMP_PROVIDER = ProviderDriverKind.make("omp"); +const OMP_DRIVER_KIND = OMP_PROVIDER; +const DEFAULT_OMP_SETTINGS = Schema.decodeSync(OmpSettings)({}); + +// Inherit Omp's configured defaultProvider/defaultModel without calling set_model. +const OMP_INHERIT_MODEL_SLUG = "default"; + +const STREAM_FLUSH_MS = 50; +const OMP_REQUEST_TIMEOUT_MS = 15_000; +const OMP_SESSION_TIMEOUT_MS = 60_000; +const MAX_EXTENSION_STATUSES = 32; +const MAX_EXTENSION_STATUS_KEY_LENGTH = 256; +const MAX_EXTENSION_STATUS_TEXT_LENGTH = 4096; +const OMP_UNSOLICITED_ACTIVITY_ERROR = + "Omp started agent work outside an active T3 turn. The session was stopped to prevent invisible tool execution."; +const SETTLE_PROBE_MAX_ATTEMPTS = 3; +const SETTLE_PROBE_RETRY_DELAY = Duration.millis(100); + +const OmpProviderCapabilitiesV2 = { + runtimePolicy: { enforcement: "client-boundary" }, + sessions: { + supportsMultipleProviderThreadsPerSession: false, + supportsModelSwitchInSession: true, + supportsProviderSwitchingViaHandoff: true, + // Restart on mode changes so the permission hook retains one immutable lifetime policy. + supportsRuntimeModeSwitchInSession: false, + pendingRequestsSurviveRestart: false, + }, + threads: { + canCreateEmptyThread: true, + canReadThreadSnapshot: true, + canRollbackThread: true, + canForkThread: true, + canForkFromTurn: true, + canForkFromSubagentThread: false, + exposesNativeThreadId: true, + }, + turns: { + exposesNativeTurnId: false, + emitsTurnStarted: true, + emitsTurnCompleted: true, + supportsInterrupt: true, + supportsActiveSteering: true, + supportsSteeringByInterruptRestart: false, + supportsQueuedMessages: true, + terminalStatusQuality: "strong", + }, + streaming: { + streamsAssistantText: true, + streamsReasoning: true, + streamsToolOutput: true, + streamsPlanText: false, + emitsMessageCompleted: true, + }, + tools: { + exposesToolItemIds: true, + emitsToolStarted: true, + emitsToolCompleted: true, + emitsToolOutput: true, + supportsMcpTools: true, + supportsDynamicToolCallbacks: false, + }, + approvals: { + supportsCommandApproval: true, + supportsFileReadApproval: false, + supportsFileChangeApproval: true, + supportsApplyPatchApproval: false, + approvalsHaveNativeRequestIds: true, + approvalCallbacksAreLiveOnly: true, + approvalsCanOriginateFromSubagents: false, + }, + planning: { + emitsPlanUpdated: false, + emitsTodoList: false, + emitsProposedPlan: false, + supportsStructuredQuestions: true, + planDeltasHaveItemIds: false, + }, + subagents: { + supportsSubagents: true, + exposesSubagentThreadIds: false, + emitsSubagentLifecycle: true, + canWaitForSubagents: false, + canCloseSubagents: false, + canForkSubagentThread: false, + }, + context: { + acceptsSystemContext: false, + acceptsDeveloperContext: false, + acceptsSyntheticUserContext: true, + canGenerateSummaries: false, + canConsumeHandoffSummaries: true, + supportsDeltaHandoff: true, + supportsFullThreadHandoff: true, + maxRecommendedHandoffChars: null, + }, + checkpointing: { + appCanCheckpointFilesystem: true, + supportsNestedCheckpointScopes: false, + providerCanRollbackConversation: true, + // CommandPolicy requires a snapshot for rollback; rollbackThread returns the updated provider thread. + providerRollbackReturnsSnapshot: true, + providerCanReadConversationSnapshot: true, + }, + identity: { + nativeThreadIds: "strong", + nativeTurnIds: "weak", + nativeItemIds: "strong", + nativeRequestIds: "strong", + }, +} satisfies OrchestrationV2ProviderCapabilities; + +export interface OmpAdapterV2Options { + readonly instanceId: ProviderInstanceId; + readonly settings: OmpSettings; + readonly environment: NodeJS.ProcessEnv; + readonly continuationRequests?: { + readonly offer: ( + request: ProviderContinuationRequests.ProviderContinuationRequest, + ) => Effect.Effect; + }; +} + +function contentText(content: unknown): string { + if (!Array.isArray(content)) { + return typeof content === "string" ? content : ""; + } + return content + .map((block) => { + if (recordField(block, "type") === "text") return recordString(block, "text") ?? ""; + return ""; + }) + .join(""); +} + +const MAX_STRUCTURED_TOOL_OUTPUT_BYTES = 64 * 1024; + +function isBoundedStructuredToolValue(value: unknown): boolean { + let bytes = MAX_STRUCTURED_TOOL_OUTPUT_BYTES; + let nodes = 4_096; + const visit = (entry: unknown, depth: number): boolean => { + if (depth > 32 || --nodes < 0 || bytes < 0) return false; + if (Array.isArray(entry)) { + bytes -= 2 + entry.length; + return entry.every((item) => visit(item, depth + 1)); + } + if (Predicate.isObject(entry)) { + bytes -= 2; + for (const key in entry) { + if (!Object.hasOwn(entry, key)) continue; + if (key.length > bytes) return false; + bytes -= Buffer.byteLength(JSON.stringify(key), "utf8") + 2; + if (!visit(entry[key], depth + 1)) return false; + } + return bytes >= 0; + } + if (typeof entry === "string" && entry.length > bytes) return false; + bytes -= Buffer.byteLength(JSON.stringify(entry) ?? "null", "utf8"); + return bytes >= 0; + }; + return visit(value, 0); +} + +function ompToolOutput(result: unknown, toolName: string): unknown { + const rawContent = recordField(result, "content"); + const content = Array.isArray(rawContent) + ? rawContent + : typeof rawContent === "string" + ? [{ type: "text", text: rawContent }] + : []; + let structured = recordField(result, "structuredContent"); + const details = recordField(result, "details"); + const isMcpResult = + toolName.startsWith("mcp__") && + recordString(details, "server") !== undefined && + recordString(details, "tool") !== undefined && + Array.isArray(recordField(structured, "content")); + if (isMcpResult) { + structured = recordField(structured, "structuredContent"); + } + if (typeof structured === "string" && structured === contentText(content)) { + structured = undefined; + } + // Native read mirrors image/note in structured output; drop only that mirror, retaining extension metadata. + if (toolName === "read" && Predicate.isObject(structured)) { + const image = readToolOutputImage(structured); + const note = + recordString( + content.find((block) => recordField(block, "type") === "text"), + "text", + ) ?? ""; + if ( + image !== null && + Object.keys(structured).every((key) => ["type", "data", "mimeType", "note"].includes(key)) && + recordString(structured, "note") === note && + content.some((block) => { + const match = readToolOutputImage(block); + return match !== null && match.mimeType === image.mimeType && match.data === image.data; + }) + ) { + structured = undefined; + } + } + if (structured !== undefined && !isBoundedStructuredToolValue(structured)) { + return { + content: [ + ...content, + { + type: "text", + text: "Structured output omitted because it exceeds the stored result limit.", + }, + ], + }; + } + if ( + !isMcpResult && + structured === undefined && + content.every((block) => recordField(block, "type") === "text") + ) { + const text = contentText(content); + return text.length > 0 ? text : undefined; + } + return { + content, + ...(structured === undefined ? {} : { structuredContent: structured }), + }; +} + +function providerRef( + nativeId: string, + strength: "strong" | "weak" = "strong", +): OrchestrationV2ProviderRef { + return { driver: OMP_PROVIDER, nativeId, strength }; +} + +const OMP_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]); + +interface OmpStreamItemState { + readonly nativeItemId: string; + readonly kind: "assistant_message" | "reasoning"; + text: string; + completed: boolean; + flushScheduled: boolean; + readonly startedAt: DateTime.Utc; +} + +type OmpCompactionStatus = "running" | "completed" | "failed" | "cancelled"; + +interface OmpCompactionState { + readonly nativeItemId: string; + readonly startedAt: DateTime.Utc; +} + +interface OmpProviderRetryState { + readonly retry: OrchestrationV2ProviderRetry; + readonly failure: OrchestrationV2ProviderFailure; + readonly startedAt: DateTime.Utc; + readonly itemOrdinal: number; +} + +function compactionTitle(status: OmpCompactionStatus): string { + switch (status) { + case "running": + return "Compacting context..."; + case "completed": + return "Context compacted"; + case "failed": + return "Context compaction failed"; + case "cancelled": + return "Context compaction stopped"; + } +} + +interface ActiveOmpTurn { + readonly turnInput: ProviderAdapter.ProviderAdapterV2TurnInput; + readonly providerTurn: OrchestrationV2ProviderTurn; + readonly startedAt: DateTime.Utc; + readonly itemOrdinals: Map; + nextItemOrdinal: number; + messageOrdinal: number; + readonly streamItems: Map; + readonly toolArgs: Map; + readonly toolStartedAt: Map; + interrupted: boolean; + nativeAborted: boolean; + sawAgentActivity: boolean; + adoptedWake: boolean; + readonly promptMayBeCommandOnly: boolean; + latestCompactionAfterTokens: number | null; + lastLiveUsedTokens: number | null; + settleProbeGeneration: number; + /** An extension may start compaction immediately after Omp emits session_settled. */ + settleWhenIdle: boolean; + sawCompaction: boolean; + manualCompactInFlight: boolean; + activeCompaction: OmpCompactionState | null; + activeProviderRetry: OmpProviderRetryState | null; + failure: ReturnType | null; + rejectedPromptFailure: ReturnType | null; + stopTreeRefs?: OmpTurnTreeRefs | null; +} + +interface OmpTurnTreeRefs { + /** Omitted keeps the synthetic ref; null means the turn left nothing on the active branch. */ + readonly nativeTurnRef: OrchestrationV2ProviderRef | null | undefined; + readonly leafId: string | null; + readonly retainedNativeTurnIds: ReadonlyArray | undefined; +} + +interface PendingOmpPrompt { + readonly nativeRequestId: string; + readonly method: "select" | "confirm" | "input" | "editor" | "ask"; + readonly questions: ReadonlyArray; + readonly questionId: string; + readonly approvalKey: string; + readonly expiresAt: number | null; + expirationFiber: Fiber.Fiber | null; + runtimeRequest: OrchestrationV2RuntimeRequest; + readonly node: OrchestrationV2ExecutionNode; + readonly turnItem: OrchestrationV2TurnItem; +} + +function ompApprovalRequestKind(title: string): "command" | "file-change" { + const toolName = /^Allow (\S+)\?$/.exec(title)?.[1]; + return toolName !== undefined && + (OMP_FILE_CHANGE_TOOLS as ReadonlyArray).includes(toolName) + ? "file-change" + : "command"; +} + +// Native prompt errors are retained until the compaction releases queued input. +const OMP_COMPACTING_PROMPT_REJECTION = "Cannot submit a prompt while compaction is in progress"; + +interface OmpPromptSend { + readonly providerTurnId: OrchestrationV2ProviderTurn["id"]; + readonly kind: "turn_start" | "steer"; + readonly record: OmpRpcRecord; +} + +interface OmpThreadState { + providerThread: OrchestrationV2ProviderThread; + activeTurn: ActiveOmpTurn | null; +} + +interface OmpWake { + readonly state: OmpThreadState; + readonly events: Array; +} + +export const makeOmpAdapterV2 = Effect.fn("makeOmpAdapterV2")(function* ( + options: OmpAdapterV2Options, +) { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const agentScope = yield* AgentScope; + const fileSystem = yield* FileSystem.FileSystem; + const idAllocator = yield* IdAllocator.IdAllocatorV2; + const host = yield* ProviderHost.ProviderHost; + const mcpSessions = yield* McpProviderSessions.McpProviderSessions; + const { continuationRequests } = options; + + const protocolError = (detail: string, payload?: unknown) => + new ProviderAdapter.ProviderAdapterProtocolError({ + driver: OMP_PROVIDER, + detail, + ...(payload === undefined ? {} : { payload }), + }); + + return ProviderAdapter.ProviderAdapterV2.of({ + instanceId: options.instanceId, + driver: OMP_PROVIDER, + getCapabilities: Effect.fn("OmpAdapter.getCapabilities")(function () { + return Effect.succeed(OmpProviderCapabilitiesV2); + }), + planSelectionTransition: Effect.fn("OmpAdapter.planSelectionTransition")(function () { + return Effect.succeed(turnScopedSelectionTransition()); + }), + openSession: Effect.fn("OmpAdapterV2.openSession")(function* ( + input: ProviderAdapter.ProviderAdapterV2OpenSessionInput, + ) { + const scope = yield* Effect.scope; + const cwd = input.runtimePolicy.cwd ?? host.paths.cwd; + const mcpSession = yield* mcpSessions.read(input.threadId); + const provideCacheFs = (effect: Effect.Effect) => + effect.pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterOpenSessionError({ + driver: OMP_PROVIDER, + providerSessionId: input.providerSessionId, + cause, + }), + ), + ); + // Always inject the permission hook even without MCP credentials; otherwise Supervised becomes unrestricted. + const extensionPath = yield* provideCacheFs( + materializeOmpT3McpExtension(host.paths.providerStatusCacheDir), + ); + const resolvedLaunchArgs = resolveOmpLaunchArgs(options.settings.launchArgs); + if (!resolvedLaunchArgs.ok) { + return yield* protocolError(resolvedLaunchArgs.message); + } + const launch = buildOmpRpcLaunch({ + launchArgs: resolvedLaunchArgs.args, + environment: options.environment, + mcpSession, + extensionPath, + runtimeMode: input.runtimePolicy.runtimeMode, + }); + const scopedLaunch = yield* agentScope.wrap({ + command: options.settings.binaryPath || "omp", + args: launch.args, + name: "omp", + threadId: input.threadId, + env: launch.env, + }); + // Finalizers run in reverse order: reap detached work after terminating Omp. + const scopeUnit = scopedLaunch.unit; + const stopScope = + scopeUnit === undefined ? Effect.void : yield* Effect.cached(agentScope.stop(scopeUnit)); + yield* Effect.addFinalizer(() => stopScope); + const connection: OmpRpcConnection = yield* makeOmpRpcConnection({ + command: scopedLaunch.command, + requiredExtensionPath: extensionPath, + args: scopedLaunch.args, + cwd, + env: launch.env, + }).pipe( + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterOpenSessionError({ + driver: OMP_PROVIDER, + providerSessionId: input.providerSessionId, + cause, + }), + ), + ); + // Detached children can keep stdout open after Omp exits. + if (scopeUnit !== undefined) { + yield* connection.exited.pipe( + Effect.matchEffect({ onFailure: () => stopScope, onSuccess: () => stopScope }), + Effect.forkIn(scope), + ); + } + const now = yield* DateTime.now; + let sessionEntity: OrchestrationV2ProviderSession = { + id: input.providerSessionId, + driver: OMP_PROVIDER, + providerInstanceId: options.instanceId, + status: "ready", + cwd, + model: input.modelSelection.model, + capabilities: OmpProviderCapabilitiesV2, + extensionStatuses: [], + createdAt: now, + updatedAt: now, + lastError: null, + }; + const events = yield* Queue.unbounded< + ProviderAdapter.ProviderAdapterV2Event, + ProviderAdapter.ProviderAdapterV2Error | Cause.Done + >(); + const pendingPrompts = new Map(); + const sessionApprovals = new Set(); + // Omp can settle immediately after dialog response; serialize so terminal cannot overtake request resolution. + const sessionEventPermit = yield* Semaphore.make(1); + let threadState: OmpThreadState | null = null; + let registrationAttempted = false; + let lastNativeThreadId: string | null = null; + let stopRequested = false; + let unsolicitedActivityDetected = false; + // Turn failures can leave Omp alive; pump termination retires the runtime. + let runtimeRetired = false; + let pendingWake: OmpWake | null = null; + let extensionStatusReset: { + previous: NonNullable; + readonly touched: Set; + readonly ready: Deferred.Deferred; + } | null = null; + let rollbackBarrier: Deferred.Deferred< + void, + ProviderAdapter.ProviderAdapterProtocolError + > | null = null; + let closed = false; + yield* Effect.addFinalizer(() => + Effect.gen(function* () { + closed = true; + sessionEntity = { ...sessionEntity, extensionStatuses: [] }; + pendingWake = null; + if (extensionStatusReset !== null) + yield* Deferred.fail( + extensionStatusReset.ready, + protocolError("Omp session closed during status reset"), + ); + if (rollbackBarrier !== null) + yield* Deferred.fail( + rollbackBarrier, + protocolError("Omp session closed during rollback"), + ); + }), + ); + let appliedModel: string | null = null; + let appliedThinking: string | null = null; + let appliedSessionName: string | null = null; + const outOfTurnExtensionErrors: Array = []; + let lastKnownLeaf: string | null = null; + // Failed get_entries leaves an untrustworthy turn boundary; re-sync the cursor on next capture. + let leafCursorStale = false; + // Omp has no unset commands; capture initial defaults so Omp default can replay them. + let baselineModel: { provider: string; modelId: string } | null = null; + let baselineThinking: string | null = null; + let contextWindow: number | null = null; + const modelContextWindows = new Map(); + let modelsDiscovered = false; + // Prompt ACKs lack IDs; retain session send order and ownership so late ACKs cannot affect new turns. + const pendingPromptResponses: Array = []; + const pendingCompactResponses: Array<{ + readonly providerTurnId: OrchestrationV2ProviderTurn["id"]; + readonly kind: "turn_start" | "steer"; + }> = []; + // Omp rejects every prompt while it compacts, including compaction an + // extension starts after the turn settled. Hold prompts until it ends. + let nativeCompacting = false; + const heldPrompts: Array = []; + // Prompts sent before the pump observed compaction_start are rejected + // after it; they precede every prompt held since. + let rejectedHeldCount = 0; + + const sendPrompt = Effect.fnUntraced(function* (prompt: OmpPromptSend) { + if (nativeCompacting) { + heldPrompts.push(prompt); + return; + } + yield* connection.send(prompt.record); + pendingPromptResponses.push(prompt); + }); + // A just-released prompt has not started its run yet, so a settle probe + // racing it would see Omp idle. Its ack re-arms the probe instead. + let releasedPromptTurnId: OrchestrationV2ProviderTurn["id"] | null = null; + + const compactRpcRecord = (command: OmpCompactCommand): OmpRpcRecord => + command.customInstructions === undefined + ? { type: "compact" } + : { type: "compact", customInstructions: command.customInstructions }; + + const emit = (event: ProviderAdapter.ProviderAdapterV2Event) => + Queue.offer(events, event).pipe(Effect.asVoid); + + const updateProviderSession = + /* Provider events include streaming deltas; avoid a span for each update. */ + Effect.fnUntraced(function* ( + status: OrchestrationV2ProviderSession["status"], + lastError: string | null = sessionEntity.lastError, + ) { + const updatedAt = yield* DateTime.now; + sessionEntity = { + ...sessionEntity, + status, + lastError, + updatedAt, + ...(status === "stopped" || runtimeRetired || unsolicitedActivityDetected + ? { extensionStatuses: [] } + : {}), + }; + yield* emit({ + type: "provider_session.updated", + driver: OMP_PROVIDER, + providerSession: sessionEntity, + }); + }); + + // Frequent notifications share the event pump's tracing boundary and outlive individual turns. + const updateExtensionStatus = Effect.fnUntraced(function* (event: OmpRpcRecord) { + if ( + closed || + stopRequested || + runtimeRetired || + unsolicitedActivityDetected || + sessionEntity.status === "stopped" + ) + return; + const key = recordString(event, "statusKey"); + const rawText = recordField(event, "statusText"); + if ( + key === undefined || + key.trim().length === 0 || + key.length > MAX_EXTENSION_STATUS_KEY_LENGTH || + (rawText !== undefined && typeof rawText !== "string") + ) + return; + const text = + typeof rawText === "string" + ? NodeUtil.stripVTControlCharacters( + rawText.slice(0, MAX_EXTENSION_STATUS_TEXT_LENGTH * 4), + ) + .replaceAll(/\p{Cc}/gu, " ") + .trim() + .slice(0, MAX_EXTENSION_STATUS_TEXT_LENGTH) + : ""; + const statuses = sessionEntity.extensionStatuses ?? []; + if (extensionStatusReset?.previous.some((status) => status.key === key)) { + extensionStatusReset.touched.add(key); + } + const index = statuses.findIndex((status) => status.key === key); + if ( + index < 0 + ? text.length === 0 || statuses.length >= MAX_EXTENSION_STATUSES + : statuses[index]?.text === text + ) + return; + sessionEntity = { + ...sessionEntity, + extensionStatuses: + text.length === 0 + ? statuses.filter((status) => status.key !== key) + : index < 0 + ? [...statuses, { key, text }] + : statuses.map((status) => (status.key === key ? { key, text } : status)), + }; + yield* updateProviderSession(sessionEntity.status); + }); + + const clearExtensionStatuses = Effect.fn("OmpAdapter.clearExtensionStatuses")(function* () { + if (sessionEntity.extensionStatuses?.length === 0) return; + sessionEntity = { ...sessionEntity, extensionStatuses: [] }; + yield* updateProviderSession(sessionEntity.status); + }); + + const updateProviderThread = + /* Provider events include streaming deltas; avoid a span for each update. */ + Effect.fnUntraced(function* ( + state: OmpThreadState, + patch: Partial, + retainedNativeTurnIds?: ReadonlyArray, + ) { + const updatedAt = yield* DateTime.now; + state.providerThread = { ...state.providerThread, ...patch, updatedAt }; + yield* emit({ + type: "provider_thread.updated", + driver: OMP_PROVIDER, + providerThread: state.providerThread, + ...(retainedNativeTurnIds === undefined ? {} : { retainedNativeTurnIds }), + }); + }); + + const itemOrdinal = (turn: ActiveOmpTurn, nativeItemId: string): number => { + const existing = turn.itemOrdinals.get(nativeItemId); + if (existing !== undefined) return existing; + const ordinal = turn.nextItemOrdinal++; + turn.itemOrdinals.set(nativeItemId, ordinal); + return ordinal; + }; + + const request = (record: OmpRpcRecord, timeoutMs = OMP_REQUEST_TIMEOUT_MS) => + connection.request(record, timeoutMs); + + const nonNegativeInteger = (input: unknown, key: string): number | undefined => { + const value = recordNumber(input, key); + return value === undefined ? undefined : Math.max(0, Math.trunc(value)); + }; + + const rememberModelContextWindow = (model: unknown): number | null => { + const provider = recordString(model, "provider"); + const id = recordString(model, "id"); + const capacity = nonNegativeInteger(model, "contextWindow"); + if (provider !== undefined && id !== undefined && capacity !== undefined && capacity > 0) { + modelContextWindows.set(`${provider}/${id}`, capacity); + return capacity; + } + return null; + }; + + const lifecycleRequest = Effect.fn("OmpAdapter.lifecycleRequest")( + function* (record: OmpRpcRecord) { + if (extensionStatusReset !== null) + return yield* protocolError("A Omp session lifecycle request is already pending"); + const reset = { + previous: sessionEntity.extensionStatuses ?? [], + touched: new Set(), + ready: yield* Deferred.make(), + }; + extensionStatusReset = reset; + return yield* Effect.gen(function* () { + // RPC responses bypass the pump. Reset after all earlier native notifications. + if ( + !(yield* Queue.offer(connection.events, { type: "t3.extension_status_reset", reset })) + ) + return yield* protocolError("Omp transport closed during status reset"); + yield* Deferred.await(reset.ready); + const result = yield* request(record, OMP_SESSION_TIMEOUT_MS); + if (recordField(result, "cancelled") === true) { + yield* sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + if (closed || stopRequested) return; + const current = sessionEntity.extensionStatuses ?? []; + // A veto keeps the old session. Preserve updates and clears from its lifecycle hooks. + const restored = reset.previous.flatMap((status) => { + if (!reset.touched.has(status.key)) return [status]; + const updated = current.find((candidate) => candidate.key === status.key); + return updated === undefined ? [] : [updated]; + }); + restored.push( + ...current.filter( + (status) => !reset.previous.some((previous) => previous.key === status.key), + ), + ); + const statuses = restored.slice(0, MAX_EXTENSION_STATUSES); + if ( + statuses.length === current.length && + statuses.every( + (status, index) => + status.key === current[index]?.key && status.text === current[index]?.text, + ) + ) + return; + sessionEntity = { ...sessionEntity, extensionStatuses: statuses }; + yield* updateProviderSession(sessionEntity.status); + }), + ); + } + return result; + }).pipe( + Effect.ensuring( + Effect.sync(() => { + if (extensionStatusReset === reset) extensionStatusReset = null; + }), + ), + ); + }, + (effect, record) => + effect.pipe( + Effect.tapError((error) => + Effect.logWarning("Omp session lifecycle request failed", { + providerSessionId: input.providerSessionId, + operation: record["type"], + errorTag: error._tag, + }), + ), + // A failed lifecycle RPC can leave Omp's previous native session disposed. + Effect.tapError((error) => + error._tag === "OmpRpcError" || error._tag === "OmpRpcTimeoutError" + ? connection.terminate + : Effect.void, + ), + Effect.onInterrupt(() => connection.terminate), + ), + ); + + const tokenUsageFromStats = ( + stats: unknown, + fallbackUsedTokens: number | null, + updatedAt: DateTime.Utc, + ): OrchestrationV2ProviderTurnTokenUsage | undefined => { + const contextUsage = recordField(stats, "contextUsage"); + const maxTokens = nonNegativeInteger(contextUsage, "contextWindow"); + const usedTokens = + nonNegativeInteger(contextUsage, "tokens") ?? fallbackUsedTokens ?? undefined; + if (usedTokens === undefined || maxTokens === undefined || maxTokens === 0) + return undefined; + + const totals = recordField(stats, "tokens"); + const inputTokens = nonNegativeInteger(totals, "input"); + const cachedInputTokens = nonNegativeInteger(totals, "cacheRead"); + const outputTokens = nonNegativeInteger(totals, "output"); + return { + usedTokens, + maxTokens, + ...(inputTokens === undefined ? {} : { inputTokens }), + ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }), + ...(outputTokens === undefined ? {} : { outputTokens }), + updatedAt: DateTime.formatIso(updatedAt), + }; + }; + + const readTokenUsage = (fallbackUsedTokens: number | null, updatedAt: DateTime.Utc) => + Effect.all([ + request({ type: "get_session_stats" }, 2_000), + request({ type: "get_state" }, 2_000), + ]).pipe( + Effect.map(([stats, state]) => + tokenUsageFromStats( + { + tokens: recordField(stats, "tokens"), + contextUsage: + recordField(state, "contextUsage") ?? recordField(stats, "contextUsage"), + }, + fallbackUsedTokens, + updatedAt, + ), + ), + Effect.orElseSucceed(() => undefined), + ); + + const reportLiveUsage = + /* Provider events include streaming deltas; avoid a span for each update. */ + Effect.fnUntraced(function* (turn: ActiveOmpTurn, usage: unknown) { + const usedTokens = nonNegativeInteger(usage, "totalTokens"); + if ( + usedTokens === undefined || + usedTokens === 0 || + usedTokens === turn.lastLiveUsedTokens || + contextWindow === null || + contextWindow === 0 + ) { + return; + } + turn.lastLiveUsedTokens = usedTokens; + const inputTokens = nonNegativeInteger(usage, "input"); + const cachedInputTokens = nonNegativeInteger(usage, "cacheRead"); + const outputTokens = nonNegativeInteger(usage, "output"); + const updatedAt = yield* DateTime.now; + yield* emit({ + type: "provider_turn.updated", + driver: OMP_PROVIDER, + threadId: turn.turnInput.threadId, + providerTurn: { + ...turn.providerTurn, + tokenUsage: { + usedTokens, + maxTokens: contextWindow, + ...(inputTokens === undefined ? {} : { inputTokens }), + ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }), + ...(outputTokens === undefined ? {} : { outputTokens }), + updatedAt: DateTime.formatIso(updatedAt), + }, + }, + }); + }); + + const baseItemFields = ( + turn: ActiveOmpTurn, + nativeItemId: string, + startedAt: DateTime.Utc, + updatedAt: DateTime.Utc, + parentNativeItemId?: string, + ) => ({ + id: idAllocator.derive.turnItemFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId, + }), + threadId: turn.turnInput.threadId, + runId: turn.turnInput.runId, + nodeId: idAllocator.derive.nodeFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId, + }), + providerThreadId: turn.turnInput.providerThread.id, + providerTurnId: turn.providerTurn.id, + nativeItemRef: providerRef(nativeItemId), + parentItemId: + parentNativeItemId === undefined + ? null + : idAllocator.derive.turnItemFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: parentNativeItemId, + }), + ordinal: itemOrdinal(turn, nativeItemId), + startedAt, + updatedAt, + }); + + const emitItemNode = ( + turn: ActiveOmpTurn, + nativeItemId: string, + kind: OrchestrationV2ExecutionNode["kind"], + status: OrchestrationV2ExecutionNode["status"], + startedAt: DateTime.Utc, + completedAt: DateTime.Utc | null, + parentNativeItemId?: string, + ) => + emit({ + type: "node.updated", + driver: OMP_PROVIDER, + node: { + id: idAllocator.derive.nodeFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId, + }), + threadId: turn.turnInput.threadId, + runId: turn.turnInput.runId, + parentNodeId: + parentNativeItemId === undefined + ? turn.turnInput.rootNodeId + : idAllocator.derive.nodeFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: parentNativeItemId, + }), + rootNodeId: turn.turnInput.rootNodeId, + kind, + status, + countsForRun: false, + providerThreadId: turn.turnInput.providerThread.id, + providerTurnId: turn.providerTurn.id, + nativeItemRef: providerRef(nativeItemId), + runtimeRequestId: null, + checkpointScopeId: null, + startedAt, + completedAt, + }, + }); + + const emitProviderRetry = Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + providerRetry: OmpProviderRetryState, + status: "running" | "completed" | "failed" | "interrupted" | "cancelled", + updatedAt: DateTime.Utc, + ) { + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: makeProviderRetryTurnItem({ + driver: OMP_PROVIDER, + threadId: turn.turnInput.threadId, + runId: turn.turnInput.runId, + nodeId: turn.turnInput.rootNodeId, + providerThreadId: turn.turnInput.providerThread.id, + providerTurnId: turn.providerTurn.id, + itemOrdinal: providerRetry.itemOrdinal, + failure: providerRetry.failure, + retry: providerRetry.retry, + status, + startedAt: providerRetry.startedAt, + updatedAt, + }), + }); + }); + + const compactionNativeItemId = (turn: ActiveOmpTurn): string => + `compaction:${turn.providerTurn.id}:${turn.nextItemOrdinal}`; + + const emitCompaction = Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + compaction: OmpCompactionState, + status: OmpCompactionStatus, + details: { + readonly summary?: string; + readonly beforeTokenCount?: number; + readonly afterTokenCount?: number; + } = {}, + ) { + const emittedAt = yield* DateTime.now; + const completedAt = status === "running" ? null : emittedAt; + yield* emitItemNode( + turn, + compaction.nativeItemId, + "system", + status, + compaction.startedAt, + completedAt, + ); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...baseItemFields(turn, compaction.nativeItemId, compaction.startedAt, emittedAt), + status, + title: compactionTitle(status), + completedAt, + type: "compaction", + driver: OMP_PROVIDER, + ...details, + }, + }); + }); + + const emitStreamItem = + /* Provider events include streaming deltas; avoid a span for each update. */ + Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + item: OmpStreamItemState, + streaming: boolean, + ) { + const emittedAt = yield* DateTime.now; + const base = baseItemFields(turn, item.nativeItemId, item.startedAt, emittedAt); + yield* emitItemNode( + turn, + item.nativeItemId, + item.kind, + streaming ? "running" : "completed", + item.startedAt, + streaming ? null : emittedAt, + ); + if (item.kind === "assistant_message") { + const messageId = idAllocator.derive.messageFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: item.nativeItemId, + }); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...base, + status: streaming ? "running" : "completed", + title: null, + completedAt: streaming ? null : emittedAt, + type: "assistant_message", + messageId, + text: item.text, + streaming, + }, + }); + yield* emit({ + type: "message.updated", + driver: OMP_PROVIDER, + message: { + id: messageId, + threadId: turn.turnInput.threadId, + runId: turn.turnInput.runId, + nodeId: idAllocator.derive.nodeFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: item.nativeItemId, + }), + role: "assistant", + text: item.text, + attachments: [], + streaming, + createdBy: "agent", + creationSource: "provider", + createdAt: item.startedAt, + updatedAt: emittedAt, + }, + }); + return; + } + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...base, + status: streaming ? "running" : "completed", + title: null, + completedAt: streaming ? null : emittedAt, + type: "reasoning", + text: item.text, + streaming, + }, + }); + }); + + const scheduleStreamFlush = + /* Provider events include streaming deltas; avoid a span for each update. */ + Effect.fnUntraced(function* (turn: ActiveOmpTurn, item: OmpStreamItemState) { + if (item.flushScheduled || item.completed) return; + item.flushScheduled = true; + yield* Effect.sleep(Duration.millis(STREAM_FLUSH_MS)).pipe( + Effect.andThen( + Effect.suspend(() => { + item.flushScheduled = false; + return item.completed ? Effect.void : emitStreamItem(turn, item, true); + }), + ), + Effect.forkIn(scope), + ); + }); + + const streamItemFor = Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + kind: OmpStreamItemState["kind"], + contentIndex: number, + ) { + const nativeItemId = `${turn.providerTurn.id}:m${turn.messageOrdinal}:c${contentIndex}`; + const existing = turn.streamItems.get(nativeItemId); + if (existing !== undefined) return existing; + const startedAt = yield* DateTime.now; + const item: OmpStreamItemState = { + nativeItemId, + kind, + text: "", + completed: false, + flushScheduled: false, + startedAt, + }; + turn.streamItems.set(nativeItemId, item); + itemOrdinal(turn, nativeItemId); + return item; + }); + + const completeStreamItem = (turn: ActiveOmpTurn, item: OmpStreamItemState, text?: string) => + Effect.suspend(() => { + if (item.completed) return Effect.void; + item.completed = true; + if (text !== undefined && text.length > 0) item.text = text; + return item.text.length === 0 ? Effect.void : emitStreamItem(turn, item, false); + }); + + const completeOpenStreamItems = (turn: ActiveOmpTurn) => + Effect.forEach( + Array.from(turn.streamItems.values()).filter((item) => !item.completed), + (item) => completeStreamItem(turn, item), + { discard: true }, + ); + + const emitToolItem = Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + event: OmpRpcRecord, + phase: "start" | "update" | "end", + ) { + const toolCallId = recordString(event, "toolCallId"); + const toolName = recordString(event, "toolName") ?? "tool"; + // Omp tags every phase of a call made through ctx.executeTool, such as from a codemode script. + const parentToolCallId = recordString(event, "parentToolCallId"); + if (toolCallId === undefined) return; + if (phase === "start") { + turn.toolArgs.set(toolCallId, event["args"]); + } + const args = event["args"] ?? turn.toolArgs.get(toolCallId); + const emittedAt = yield* DateTime.now; + const startedAt = turn.toolStartedAt.get(toolCallId) ?? emittedAt; + turn.toolStartedAt.set(toolCallId, startedAt); + const completed = phase === "end"; + const isError = event["isError"] === true; + const resultRecord = completed ? event["result"] : event["partialResult"]; + const outputText = contentText(recordField(resultRecord, "content")); + const status = completed + ? isError + ? turn.interrupted + ? "interrupted" + : "failed" + : "completed" + : "running"; + const base = baseItemFields(turn, toolCallId, startedAt, emittedAt, parentToolCallId); + yield* emitItemNode( + turn, + toolCallId, + "tool_call", + status, + startedAt, + completed ? emittedAt : null, + parentToolCallId, + ); + const shared = { + ...base, + status, + completedAt: completed ? emittedAt : null, + } as const; + if (toolName === "bash" || toolName === "powershell") { + const exitCode = + recordNumber(recordField(resultRecord, "structuredContent"), "exit_code") ?? + recordNumber(recordField(resultRecord, "details"), "exitCode"); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...shared, + title: toolName, + type: "command_execution", + input: recordString(args, "command") ?? "", + ...(outputText.length > 0 ? { output: outputText } : {}), + ...(exitCode === undefined ? {} : { exitCode }), + }, + }); + return; + } + if (toolName === "edit" || toolName === "write") { + const fileName = recordString(args, "path") ?? recordString(args, "file_path"); + if (fileName !== undefined) { + const diffStr = + recordString(recordField(resultRecord, "details"), "patch") ?? + (isError && outputText.trim().length > 0 ? outputText : undefined); + const newStr = toolName === "write" ? recordString(args, "content") : undefined; + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...shared, + title: toolName, + type: "file_change", + fileName, + ...(diffStr === undefined ? {} : { diffStr }), + ...(newStr === undefined ? {} : { newStr }), + }, + }); + return; + } + } + const output = ompToolOutput(resultRecord, toolName); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...shared, + title: toolName, + type: "dynamic_tool", + ...mcpToolPresentation({ toolName }), + toolName, + input: args ?? {}, + ...(output === undefined ? {} : { output }), + }, + }); + if (toolName === "subagent") { + yield* emitSubagentTasks(turn, toolCallId, resultRecord, completed); + } + }); + + const emitSubagentTasks = Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + toolCallId: string, + resultRecord: unknown, + completed: boolean, + ) { + const results = recordField(recordField(resultRecord, "details"), "results"); + if (!Array.isArray(results)) return; + const emittedAt = yield* DateTime.now; + const parentNodeId = idAllocator.derive.nodeFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: toolCallId, + }); + for (const [index, result] of results.entries()) { + const agent = recordString(result, "agent"); + const task = recordString(result, "task"); + if (agent === undefined || task === undefined) continue; + const nativeTaskId = + recordString(result, "nativeId") ?? + `${toolCallId}:subagent:${recordNumber(result, "step") ?? index}`; + const subagentId = idAllocator.derive.nodeFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: nativeTaskId, + }); + const startedAt = turn.toolStartedAt.get(nativeTaskId) ?? emittedAt; + turn.toolStartedAt.set(nativeTaskId, startedAt); + const finished = completed || recordField(result, "finished") === true; + const stopReason = recordString(result, "stopReason"); + const interrupted = finished && stopReason === "aborted"; + const failed = + finished && + !interrupted && + ((recordNumber(result, "exitCode") ?? 0) !== 0 || stopReason === "error"); + const status = interrupted + ? "interrupted" + : failed + ? "failed" + : finished + ? "completed" + : "running"; + const outputText = ompSubagentOutput(result); + const progress = + !finished && outputText.length > 0 ? { progress: outputText.slice(0, 200) } : {}; + const resultText = finished && outputText.length > 0 ? outputText.slice(0, 10_000) : null; + yield* emit({ + type: "subagent.updated", + driver: OMP_PROVIDER, + subagent: { + id: subagentId, + threadId: turn.turnInput.threadId, + runId: turn.turnInput.runId, + parentNodeId, + origin: "provider_native", + createdBy: "agent", + driver: OMP_PROVIDER, + providerInstanceId: options.instanceId, + providerThreadId: turn.turnInput.providerThread.id, + childThreadId: null, + nativeTaskRef: providerRef(nativeTaskId), + prompt: task, + title: agent, + model: recordString(result, "model") ?? null, + status, + ...progress, + result: resultText, + startedAt, + completedAt: finished ? emittedAt : null, + updatedAt: emittedAt, + }, + }); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...baseItemFields(turn, nativeTaskId, startedAt, emittedAt), + status, + title: agent, + completedAt: finished ? emittedAt : null, + type: "subagent", + subagentId, + origin: "provider_native", + driver: OMP_PROVIDER, + providerInstanceId: options.instanceId, + childThreadId: null, + prompt: task, + ...progress, + result: resultText, + }, + }); + } + }); + + const cancelPrompt = Effect.fn("OmpAdapter.cancelPrompt")(function* ( + pending: PendingOmpPrompt, + resolvedAt: DateTime.Utc, + ) { + if (pending.expirationFiber !== null) yield* Fiber.interrupt(pending.expirationFiber); + yield* connection + .send({ + type: "extension_ui_response", + id: pending.nativeRequestId, + cancelled: true, + }) + .pipe(Effect.ignore); + pending.runtimeRequest = { + ...pending.runtimeRequest, + status: "cancelled", + resolvedAt, + }; + yield* emit({ + type: "runtime_request.updated", + driver: OMP_PROVIDER, + threadId: pending.node.threadId, + runtimeRequest: pending.runtimeRequest, + }); + yield* emit({ + type: "node.updated", + driver: OMP_PROVIDER, + node: { ...pending.node, status: "cancelled", completedAt: resolvedAt }, + }); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...pending.turnItem, + status: "cancelled", + completedAt: resolvedAt, + updatedAt: resolvedAt, + }, + }); + }); + + const cancelPendingPrompts = Effect.fn("OmpAdapter.cancelPendingPrompts")(function* ( + resolvedAt: DateTime.Utc, + ) { + const pending = Array.from(pendingPrompts.values()); + pendingPrompts.clear(); + yield* Effect.forEach(pending, (prompt) => cancelPrompt(prompt, resolvedAt), { + discard: true, + }); + }); + + const emitSystemNotice = Effect.fnUntraced(function* ( + turn: ActiveOmpTurn, + nativeItemId: string, + message: string, + ) { + const emittedAt = yield* DateTime.now; + yield* emitItemNode(turn, nativeItemId, "system", "completed", emittedAt, emittedAt); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...baseItemFields(turn, nativeItemId, emittedAt, emittedAt), + status: "completed", + completedAt: emittedAt, + title: message, + type: "system_notice", + message, + }, + }); + }); + + const clearNativeQueue = Effect.fnUntraced(function* (turn: ActiveOmpTurn) { + const current = yield* request({ type: "get_state" }, 2_000); + const queue = recordField(current, "queuedMessages"); + const cleared: string[] = []; + for (const key of ["steering", "followUp"]) { + const entries = recordField(queue, key); + if (!Array.isArray(entries)) continue; + for (const entry of entries) { + const message = typeof entry === "string" ? entry : recordString(entry, "message"); + if (message === undefined) continue; + yield* request({ type: "remove_queued_message", message, queue: key }, 2_000); + cleared.push(message); + } + } + if (cleared.length === 0) return; + yield* sessionEventPermit.withPermits(1)( + threadState?.activeTurn === turn + ? emitSystemNotice( + turn, + `queue-cleared:${turn.providerTurn.id}`, + [ + `Stop cleared ${cleared.length} queued ${cleared.length === 1 ? "message" : "messages"} Omp had not read:`, + // Image-only messages come back as empty text. + ...cleared.filter((text) => text.length > 0), + ] + .join("\n\n") + .slice(0, 2_000), + ) + : Effect.void, + ); + }); + + const handleExtensionUiRequest = Effect.fnUntraced(function* (event: OmpRpcRecord) { + const method = recordString(event, "method"); + const nativeRequestId = recordString(event, "id"); + if (method === undefined) return; + if (method === "cancel") { + const targetId = recordString(event, "targetId"); + for (const [id, pending] of pendingPrompts) { + if (pending.nativeRequestId !== targetId) continue; + pendingPrompts.delete(id); + yield* cancelPrompt(pending, yield* DateTime.now); + } + return; + } + if (method === "notify") { + const state = threadState; + const turn = state?.activeTurn ?? null; + const message = recordString(event, "message") ?? ""; + if (turn === null || message.length === 0) return; + yield* emitSystemNotice( + turn, + `notify:${turn.providerTurn.id}:${turn.nextItemOrdinal}`, + message, + ); + return; + } + if ( + method !== "select" && + method !== "confirm" && + method !== "input" && + method !== "editor" && + method !== "ask" + ) { + yield* Effect.logDebug("Ignoring omp extension UI update.", { method }); + return; + } + if (nativeRequestId === undefined) return; + const approvalTitle = recordString(event, "title") ?? ""; + const approvalKey = `${approvalTitle.length}:${approvalTitle}${recordString(event, "message") ?? ""}`; + if (method === "confirm" && sessionApprovals.has(approvalKey)) { + yield* connection.send({ + type: "extension_ui_response", + id: nativeRequestId, + confirmed: true, + }); + return; + } + const state = threadState; + const turn = state?.activeTurn ?? null; + const createdAt = yield* DateTime.now; + const timeout = recordNumber(event, "timeout"); + // Omp treats zero as no timeout and negative durations as immediate expiry. + const expiresAt = + timeout === undefined || timeout === 0 + ? null + : DateTime.toEpochMillis(createdAt) + Math.max(0, timeout); + const requestId = yield* idAllocator.allocate.runtimeRequest({ + driver: OMP_PROVIDER, + ...(turn === null ? {} : { providerTurnId: turn.providerTurn.id }), + nativeRequestId, + }); + const nodeId = idAllocator.derive.approvalNode({ requestId }); + const title = recordString(event, "title") ?? method; + const threadId = + turn?.turnInput.threadId ?? state?.providerThread.appThreadId ?? input.threadId; + const providerThreadId = state?.providerThread.id ?? null; + const providerTurnId = turn?.providerTurn.id ?? null; + const runtimeRequest: OrchestrationV2RuntimeRequest = { + id: requestId, + nodeId, + providerTurnId, + nativeRequestRef: providerRef(nativeRequestId), + kind: method === "confirm" ? "command" : "user_input", + status: "pending", + responseCapability: { type: "live", providerSessionId: input.providerSessionId }, + createdAt, + resolvedAt: null, + }; + const node: OrchestrationV2ExecutionNode = { + id: nodeId, + threadId, + runId: turn?.turnInput.runId ?? null, + parentNodeId: turn?.turnInput.rootNodeId ?? null, + rootNodeId: turn?.turnInput.rootNodeId ?? nodeId, + kind: method === "confirm" ? "approval_request" : "user_input_request", + status: "waiting", + countsForRun: false, + providerThreadId, + providerTurnId, + nativeItemRef: providerRef(nativeRequestId), + runtimeRequestId: requestId, + checkpointScopeId: null, + startedAt: createdAt, + completedAt: null, + }; + const itemBase = { + id: idAllocator.derive.approvalTurnItem({ requestId }), + threadId, + runId: turn?.turnInput.runId ?? null, + nodeId, + providerThreadId, + providerTurnId, + nativeItemRef: providerRef(nativeRequestId), + parentItemId: null, + ordinal: turn === null ? 0 : itemOrdinal(turn, nativeRequestId), + status: "waiting" as const, + title, + startedAt: createdAt, + completedAt: null, + updatedAt: createdAt, + }; + const turnItem: OrchestrationV2TurnItem = + method === "confirm" + ? { + ...itemBase, + type: "approval_request", + requestId, + requestKind: ompApprovalRequestKind(title), + prompt: recordString(event, "message") ?? title, + } + : { + ...itemBase, + type: "user_input_request", + requestId, + questions: + method === "ask" + ? ompAskQuestions(event) + : [ompQuestion(nativeRequestId, method, title, event)], + }; + const pending: PendingOmpPrompt = { + nativeRequestId, + method, + questionId: nativeRequestId, + questions: method === "ask" ? ompAskQuestions(event) : [], + approvalKey, + expiresAt, + expirationFiber: null, + runtimeRequest, + node, + turnItem, + }; + pendingPrompts.set(String(requestId), pending); + yield* emit({ + type: "runtime_request.updated", + driver: OMP_PROVIDER, + threadId, + runtimeRequest, + }); + yield* emit({ type: "node.updated", driver: OMP_PROVIDER, node }); + yield* emit({ type: "turn_item.updated", driver: OMP_PROVIDER, turnItem }); + if (expiresAt !== null) { + const now = yield* DateTime.now; + pending.expirationFiber = yield* Effect.sleep( + Duration.millis(Math.max(0, expiresAt - DateTime.toEpochMillis(now))), + ).pipe( + Effect.andThen( + Queue.offer(connection.events, { + type: "t3.ui_request_expired", + requestId: String(requestId), + pending, + }), + ), + Effect.asVoid, + Effect.forkIn(scope), + ); + } + }); + + const emitExtensionError = Effect.fnUntraced(function* (event: OmpRpcRecord) { + const state = threadState; + const turn = state?.activeTurn ?? null; + if (turn === null) { + outOfTurnExtensionErrors.push(event); + return; + } + const emittedAt = yield* DateTime.now; + const nativeItemId = `extension-error:${turn.providerTurn.id}:${turn.nextItemOrdinal}`; + const extensionName = ompExtensionDisplayName(recordString(event, "extensionPath")); + const extensionEvent = recordString(event, "event"); + const detail = recordString(event, "error")?.trim(); + const message = [ + `${extensionName} failed${extensionEvent === undefined ? "" : ` during ${extensionEvent}`}.`, + detail === undefined || detail.length === 0 ? undefined : detail.slice(0, 2_000), + ] + .filter((part): part is string => part !== undefined) + .join("\n\n"); + const failure = makeProviderFailure({ + message, + class: "provider_error", + retryable: false, + }); + yield* emitItemNode(turn, nativeItemId, "system", "failed", emittedAt, emittedAt); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...baseItemFields(turn, nativeItemId, emittedAt, emittedAt), + status: "failed", + title: extensionName, + completedAt: emittedAt, + type: "error", + failure, + }, + }); + }); + + const listSessionEntries = (since: string | null, timeoutMs: number) => + request({ type: "get_entries", ...(since === null ? {} : { since }) }, timeoutMs).pipe( + Effect.map(ompSessionListing), + Effect.orElseSucceed(() => null), + ); + + // get_entries includes abandoned branches in append order; follow leaf parentId ancestry instead. + const captureTurnTreeRefs = Effect.fnUntraced(function* ( + timeoutMs = OMP_REQUEST_TIMEOUT_MS, + ): Effect.fn.Return { + const cursorWasStale = leafCursorStale; + const previousLeaf = lastKnownLeaf; + const fullListing = cursorWasStale || previousLeaf === null; + const listing = yield* listSessionEntries(fullListing ? null : previousLeaf, timeoutMs); + const turnWalk = + listing === null ? null : walkOmpBranch(listing.entries, listing.leafId, previousLeaf); + const rewound = turnWalk !== null && previousLeaf !== null && !turnWalk.reachedStop; + // since ends at the previous leaf; rewound ancestry requires the whole tree. + const tree = rewound && !fullListing ? yield* listSessionEntries(null, timeoutMs) : listing; + if (listing === null || turnWalk === null || tree === null) { + leafCursorStale = true; + return null; + } + lastKnownLeaf = listing.leafId; + leafCursorStale = false; + const turnStartEntryId = turnWalk.userEntryIds.at(-1); + // Only a complete acyclic root walk proves all survivors. + // The old leaf must remain in this tree to prove rewind rather than session replacement. + const branch = + rewound && previousLeaf !== null && tree.entries.has(previousLeaf) + ? walkOmpBranch(tree.entries, listing.leafId, null) + : undefined; + return { + // Stale cursors span earlier turns; keep a synthetic ref to avoid rolling back too far. + nativeTurnRef: cursorWasStale + ? undefined + : turnStartEntryId !== undefined + ? providerRef(turnStartEntryId) + : turnWalk.entryCount === 0 + ? null + : undefined, + leafId: listing.leafId, + retainedNativeTurnIds: branch?.reachedStop === true ? branch.userEntryIds : undefined, + }; + }); + + const finalizeTurn = Effect.fnUntraced(function* (state: OmpThreadState, readUsage = true) { + const turn = state.activeTurn; + if (turn === null) return; + state.activeTurn = null; + const interrupted = turn.interrupted || turn.nativeAborted; + const completedAt = yield* DateTime.now; + yield* completeOpenStreamItems(turn); + if (turn.activeCompaction !== null) { + const status = interrupted ? "cancelled" : turn.failure === null ? "completed" : "failed"; + yield* emitCompaction(turn, turn.activeCompaction, status); + turn.activeCompaction = null; + } + if (turn.activeProviderRetry !== null) { + if (interrupted) { + yield* emitProviderRetry(turn, turn.activeProviderRetry, "interrupted", completedAt); + turn.activeProviderRetry = null; + } else if (turn.failure === null) { + yield* emitProviderRetry(turn, turn.activeProviderRetry, "completed", completedAt); + turn.activeProviderRetry = null; + } + } + yield* cancelPendingPrompts(completedAt); + const treeRefs = + turn.stopTreeRefs !== undefined ? turn.stopTreeRefs : yield* captureTurnTreeRefs(); + const tokenUsage = readUsage + ? yield* readTokenUsage(turn.latestCompactionAfterTokens, completedAt) + : undefined; + const failure = interrupted ? null : (turn.rejectedPromptFailure ?? turn.failure); + yield* emit({ + type: "provider_turn.updated", + driver: OMP_PROVIDER, + threadId: turn.turnInput.threadId, + providerTurn: { + ...turn.providerTurn, + ...(treeRefs === null || treeRefs.nativeTurnRef === undefined + ? {} + : { nativeTurnRef: treeRefs.nativeTurnRef }), + status: interrupted ? "interrupted" : failure !== null ? "failed" : "completed", + completedAt, + ...(tokenUsage === undefined ? {} : { tokenUsage }), + }, + }); + yield* updateProviderThread( + state, + { + status: "idle", + ...(treeRefs === null + ? {} + : { + nativeConversationHeadRef: + treeRefs.leafId === null ? null : providerRef(treeRefs.leafId), + }), + }, + treeRefs?.retainedNativeTurnIds, + ); + yield* updateProviderSession( + failure !== null ? "error" : "ready", + failure?.message ?? null, + ); + if (failure !== null) { + const failureItemId = `terminal-failure:${turn.providerTurn.id}`; + if (turn.activeProviderRetry !== null) { + yield* emitProviderRetry( + turn, + { ...turn.activeProviderRetry, failure }, + "failed", + completedAt, + ); + } else { + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...baseItemFields(turn, failureItemId, completedAt, completedAt), + status: "failed", + title: null, + completedAt, + type: "error", + failure, + }, + }); + } + yield* emit({ + type: "turn.terminal", + driver: OMP_PROVIDER, + providerThreadId: state.providerThread.id, + providerTurnId: turn.providerTurn.id, + runOrdinal: turn.turnInput.runOrdinal, + failureItemOrdinal: itemOrdinal(turn, failureItemId), + status: "failed", + failure, + ...(turn.activeProviderRetry === null + ? {} + : { + retry: turn.activeProviderRetry.retry, + retryStartedAt: turn.activeProviderRetry.startedAt, + }), + threadDisposition: "reusable", + }); + } else { + yield* emit({ + type: "turn.terminal", + driver: OMP_PROVIDER, + providerThreadId: state.providerThread.id, + providerTurnId: turn.providerTurn.id, + runOrdinal: turn.turnInput.runOrdinal, + status: interrupted ? "interrupted" : "completed", + failure: null, + threadDisposition: "reusable", + }); + } + }); + + const scheduleSettleProbe = ( + turn: ActiveOmpTurn, + settleAfterAgentActivity = false, + attempt = 1, + ) => { + const providerTurnId = turn.providerTurn.id; + const settleProbeGeneration = turn.settleProbeGeneration; + return request({ type: "get_state" }, 2_000).pipe( + Effect.matchEffect({ + onSuccess: (data) => + Queue.offer(connection.events, { + type: "t3.settle_probe", + providerTurnId, + settleAfterAgentActivity, + settleProbeGeneration, + attempt, + data, + }), + // Failed probes must reach the pump; command-only turns emit no agent events to settle them. + onFailure: () => + Queue.offer(connection.events, { + type: "t3.settle_probe", + providerTurnId, + settleAfterAgentActivity, + settleProbeGeneration, + attempt, + probeFailed: true, + }), + }), + Effect.ignore, + Effect.forkIn(scope), + ); + }; + + const stopPendingWake = Effect.fnUntraced(function* (wake: OmpWake) { + if (pendingWake !== wake || threadState !== wake.state || closed) return; + pendingWake = null; + stopRequested = true; + yield* cancelPendingPrompts(yield* DateTime.now); + yield* connection.terminate; + }); + + const handleSessionEvent = Effect.fnUntraced(function* (event: OmpRpcRecord) { + if (event["type"] === "t3.extension_status_reset") { + const reset = extensionStatusReset; + if (reset !== null && event["reset"] === reset) { + reset.previous = sessionEntity.extensionStatuses ?? []; + reset.touched.clear(); + yield* clearExtensionStatuses(); + yield* Deferred.succeed(reset.ready, undefined); + } + return; + } + // A native wake may wait for a turn owner; status belongs to the live session immediately. + if (event["type"] === "extension_ui_request" && event["method"] === "setStatus") { + yield* updateExtensionStatus(event); + return; + } + // Model hooks can show dialogs before turn ownership; keep requests session-scoped and buffer output. + const interactiveUiRequest = + event["type"] === "extension_ui_request" && + ["select", "confirm", "input", "editor"].includes(String(event["method"])); + if ( + threadState?.activeTurn === null && + pendingWake !== null && + !interactiveUiRequest && + !String(event["type"]).startsWith("t3.") && + event["type"] !== "response" + ) { + pendingWake.events.push(event); + if (event["type"] === "agent_start") yield* updateProviderSession("running", null); + if (event["type"] === "session_settled") yield* updateProviderSession("ready", null); + return; + } + const state = threadState; + const turn = state?.activeTurn ?? null; + switch (event["type"]) { + case "agent_start": { + if ( + turn === null && + state?.providerThread.appThreadId != null && + continuationRequests !== undefined && + !closed && + !stopRequested + ) { + const wake: OmpWake = { state, events: [event] }; + pendingWake = wake; + if (rollbackBarrier !== null) { + yield* stopPendingWake(wake); + return; + } + yield* updateProviderSession("running", null); + yield* continuationRequests + .offer({ + threadId: state.providerThread.appThreadId, + providerThreadId: state.providerThread.id, + driver: OMP_PROVIDER, + detail: null, + delivery: "adapter_buffered", + dispatchIfCurrent: (dispatch) => + sessionEventPermit.withPermits(1)( + Effect.suspend(() => + pendingWake === wake && threadState === state && !closed + ? dispatch.pipe( + Effect.asSome, + Effect.tapError(() => stopPendingWake(wake)), + ) + : Effect.succeedNone, + ), + ), + clearIfCurrent: () => sessionEventPermit.withPermits(1)(stopPendingWake(wake)), + }) + .pipe(Effect.tapError(() => stopPendingWake(wake))); + return; + } + if (turn === null) { + unsolicitedActivityDetected = true; + yield* updateProviderSession("error", OMP_UNSOLICITED_ACTIVITY_ERROR); + yield* connection.terminate; + return; + } + turn.sawAgentActivity = true; + turn.nativeAborted = false; + turn.settleProbeGeneration += 1; + return; + } + case "message_start": { + if (turn !== null && recordString(event["message"], "role") === "assistant") { + turn.sawAgentActivity = true; + turn.messageOrdinal += 1; + } + return; + } + case "message_update": { + if (turn === null) return; + turn.sawAgentActivity = true; + yield* reportLiveUsage(turn, event["usage"]); + const delta = event["assistantMessageEvent"]; + const deltaType = recordString(delta, "type"); + const contentIndex = recordNumber(delta, "contentIndex") ?? 0; + if (deltaType === "text_delta" || deltaType === "thinking_delta") { + const item = yield* streamItemFor( + turn, + deltaType === "text_delta" ? "assistant_message" : "reasoning", + contentIndex, + ); + item.text += recordString(delta, "delta") ?? ""; + yield* scheduleStreamFlush(turn, item); + return; + } + if (deltaType === "text_end" || deltaType === "thinking_end") { + const item = yield* streamItemFor( + turn, + deltaType === "text_end" ? "assistant_message" : "reasoning", + contentIndex, + ); + yield* completeStreamItem( + turn, + item, + recordString(delta, "content") ?? recordString(delta, "thinking"), + ); + return; + } + return; + } + case "message_end": { + if (turn === null) return; + const message = event["message"]; + if (recordString(message, "role") !== "assistant") return; + yield* completeOpenStreamItems(turn); + if (recordString(message, "stopReason") === "error" && turn.failure === null) { + turn.failure = makeProviderFailure({ + message: recordString(message, "errorMessage") ?? "Omp reported a model error.", + class: "provider_error", + }); + } + return; + } + case "tool_execution_start": + if (turn !== null) { + turn.sawAgentActivity = true; + yield* emitToolItem(turn, event, "start"); + } + return; + case "tool_execution_update": + if (turn !== null) yield* emitToolItem(turn, event, "update"); + return; + case "tool_execution_end": + if (turn !== null) yield* emitToolItem(turn, event, "end"); + return; + case "compaction_start": { + if (turn === null) return; + turn.settleProbeGeneration += 1; + turn.sawCompaction = true; + if (turn.activeCompaction !== null) { + yield* emitCompaction(turn, turn.activeCompaction, "cancelled"); + } + const startedAt = yield* DateTime.now; + const compaction = { + nativeItemId: compactionNativeItemId(turn), + startedAt, + } satisfies OmpCompactionState; + turn.activeCompaction = compaction; + yield* emitCompaction(turn, compaction, "running"); + return; + } + case "compaction_end": { + if (turn === null) return; + const observedAt = yield* DateTime.now; + const compaction = turn.activeCompaction ?? { + nativeItemId: compactionNativeItemId(turn), + startedAt: observedAt, + }; + turn.activeCompaction = null; + const result = event["result"]; + if (result === null || result === undefined) { + if (event["aborted"] === true) { + yield* emitCompaction(turn, compaction, "cancelled"); + if ( + (turn.settleWhenIdle || !turn.sawAgentActivity) && + releasedPromptTurnId !== turn.providerTurn.id + ) { + yield* scheduleSettleProbe(turn, turn.settleWhenIdle); + } + return; + } + const errorMessage = + recordString(event, "errorMessage") ?? "Omp context compaction failed."; + yield* emitCompaction(turn, compaction, "failed", { + summary: errorMessage.slice(0, 1_000), + }); + if ( + (turn.settleWhenIdle || !turn.sawAgentActivity) && + releasedPromptTurnId !== turn.providerTurn.id + ) { + yield* scheduleSettleProbe(turn, turn.settleWhenIdle); + } + return; + } + // Clear overflow failures only when compaction will retry; ordinary compaction must retain exhausted retries. + if (event["willRetry"] === true) turn.failure = null; + turn.latestCompactionAfterTokens = + nonNegativeInteger(result, "estimatedTokensAfter") ?? null; + const summary = recordString(result, "summary"); + const beforeTokenCount = nonNegativeInteger(result, "tokensBefore"); + const afterTokenCount = nonNegativeInteger(result, "estimatedTokensAfter"); + yield* emitCompaction(turn, compaction, "completed", { + ...(summary === undefined ? {} : { summary }), + ...(beforeTokenCount === undefined ? {} : { beforeTokenCount }), + ...(afterTokenCount === undefined ? {} : { afterTokenCount }), + }); + if ( + (turn.settleWhenIdle || !turn.sawAgentActivity) && + releasedPromptTurnId !== turn.providerTurn.id + ) { + yield* scheduleSettleProbe(turn, turn.settleWhenIdle); + } + return; + } + case "auto_retry_start": { + if (turn === null) return; + const emittedAt = yield* DateTime.now; + const attempt = Math.max(1, Math.trunc(recordNumber(event, "attempt") ?? 1)); + const maxAttempts = Math.max( + attempt, + Math.trunc(recordNumber(event, "maxAttempts") ?? attempt), + ); + const retryDelayMs = Math.max(0, Math.trunc(recordNumber(event, "delayMs") ?? 0)); + const failure = makeProviderFailure({ + message: recordString(event, "errorMessage") ?? "Omp provider request failed.", + class: "provider_error", + retryable: true, + }); + const current = turn.activeProviderRetry; + const providerRetry = { + retry: { attempt, maxAttempts, retryDelayMs }, + failure, + startedAt: current?.startedAt ?? emittedAt, + itemOrdinal: + current?.itemOrdinal ?? + itemOrdinal(turn, `terminal-failure:${turn.providerTurn.id}`), + } satisfies OmpProviderRetryState; + turn.activeProviderRetry = providerRetry; + yield* emitProviderRetry(turn, providerRetry, "running", emittedAt); + return; + } + case "auto_retry_end": { + if (turn === null) return; + const emittedAt = yield* DateTime.now; + if (event["success"] === true) { + // Successful retries supersede the failure session_settled would reuse. + if (turn.activeProviderRetry !== null) { + const attempt = Math.max( + 1, + Math.trunc( + recordNumber(event, "attempt") ?? turn.activeProviderRetry.retry.attempt, + ), + ); + const recoveredRetry = { + ...turn.activeProviderRetry, + retry: { ...turn.activeProviderRetry.retry, attempt }, + }; + yield* emitProviderRetry(turn, recoveredRetry, "completed", emittedAt); + turn.activeProviderRetry = null; + } + turn.failure = null; + return; + } + const failure = makeProviderFailure({ + message: recordString(event, "finalError") ?? "Omp auto-retry failed.", + class: "provider_error", + retryable: false, + }); + const attempt = Math.max(1, Math.trunc(recordNumber(event, "attempt") ?? 1)); + const current = turn.activeProviderRetry; + const providerRetry = { + retry: { + attempt, + maxAttempts: current?.retry.maxAttempts ?? attempt, + retryDelayMs: current?.retry.retryDelayMs ?? null, + }, + failure, + startedAt: current?.startedAt ?? emittedAt, + itemOrdinal: + current?.itemOrdinal ?? + itemOrdinal(turn, `terminal-failure:${turn.providerTurn.id}`), + } satisfies OmpProviderRetryState; + turn.activeProviderRetry = providerRetry; + turn.failure = failure; + yield* emitProviderRetry(turn, providerRetry, "failed", emittedAt); + return; + } + case "extension_ui_request": + yield* handleExtensionUiRequest(event); + return; + case "extension_error": { + yield* emitExtensionError(event); + return; + } + case "subagent_lifecycle": + case "subagent_progress": { + if (turn === null) return; + const payload = recordField(event, "payload"); + const progress = recordField(payload, "progress"); + const id = recordString(payload, "id") ?? recordString(progress, "id"); + if (id === undefined) return; + const status = recordString(payload, "status") ?? recordString(progress, "status"); + const finished = status === "completed" || status === "failed" || status === "aborted"; + yield* emitSubagentTasks( + turn, + recordString(payload, "parentToolCallId") ?? id, + { + details: { + results: [ + { + nativeId: id, + agent: recordString(payload, "agent") ?? "OMP subagent", + task: + recordString(payload, "task") ?? recordString(payload, "description") ?? "", + finished, + stopReason: + status === "failed" + ? "error" + : status === "aborted" + ? "aborted" + : undefined, + messages: [ + { + role: "assistant", + content: [ + { type: "text", text: recordString(progress, "lastText") ?? "" }, + ], + }, + ], + }, + ], + }, + }, + finished, + ); + return; + } + case "prompt_result": { + if (turn === null) return; + const failure = ompPromptFailure(event); + if (failure !== undefined) + turn.failure = makeProviderFailure({ message: failure, class: "provider_error" }); + if (event["status"] === "aborted") turn.nativeAborted = true; + if (event["sessionSettled"] === true) { + turn.settleWhenIdle = true; + yield* scheduleSettleProbe(turn, true); + } + return; + } + case "session_settled": { + if (turn?.interrupted === true) { + if (state !== null) yield* finalizeTurn(state); + return; + } + if (turn !== null) { + turn.nativeAborted = event["aborted"] === true; + turn.settleWhenIdle = true; + turn.settleProbeGeneration += 1; + if ( + turn.adoptedWake && + pendingPromptResponses.some( + (pending) => + pending.providerTurnId === turn.providerTurn.id && + pending.kind === "turn_start", + ) + ) + return; + yield* scheduleSettleProbe(turn, true); + } + return; + } + case "response": { + const command = recordString(event, "command"); + if (command === "compact") { + const pendingCompact = pendingCompactResponses.shift(); + const compactTurn = + pendingCompact?.providerTurnId === turn?.providerTurn.id ? turn : null; + if (compactTurn !== null) compactTurn.manualCompactInFlight = false; + if (event["success"] === true) { + if ( + pendingCompact?.kind === "turn_start" && + compactTurn !== null && + compactTurn.promptMayBeCommandOnly && + !compactTurn.sawAgentActivity + ) { + yield* scheduleSettleProbe(compactTurn); + } + return; + } + if (event["success"] !== false) return; + if (compactTurn === null) return; + if (compactTurn.activeCompaction !== null) return; + if (pendingCompact?.kind === "steer") { + yield* Effect.logWarning("Omp rejected a compact steer.", { + errorLength: recordString(event, "error")?.length, + }); + return; + } + if (!compactTurn.sawCompaction) { + compactTurn.failure = makeProviderFailure({ + message: recordString(event, "error") ?? "Omp compact failed.", + class: "provider_error", + }); + if (state !== null) yield* finalizeTurn(state); + return; + } + if (!compactTurn.sawAgentActivity) { + yield* scheduleSettleProbe(compactTurn); + } + return; + } + const pendingPrompt = command === "prompt" ? pendingPromptResponses.shift() : undefined; + const responseTurn = + pendingPrompt?.providerTurnId === turn?.providerTurn.id ? turn : null; + if ( + event["success"] === false && + nativeCompacting && + recordString(event, "error")?.startsWith(OMP_COMPACTING_PROMPT_REJECTION) === true && + pendingPrompt !== undefined && + responseTurn !== null + ) { + heldPrompts.splice(rejectedHeldCount++, 0, pendingPrompt); + return; + } + // Settlement is not probed while a steer awaits its ack (see + // compaction_end); once Omp answers, the run it may have started is + // visible to get_state. + if (pendingPrompt?.kind === "steer" && responseTurn?.settleWhenIdle === true) { + yield* scheduleSettleProbe(responseTurn, true); + } + if (event["success"] === true) { + // Command-only prompts emit no session_settled; probe idle and re-queue behind preceding native events. + if ( + pendingPrompt?.kind === "turn_start" && + responseTurn !== null && + ((responseTurn.promptMayBeCommandOnly && !responseTurn.sawAgentActivity) || + (responseTurn.adoptedWake && + (responseTurn.settleWhenIdle || responseTurn.promptMayBeCommandOnly))) + ) { + yield* scheduleSettleProbe(responseTurn, responseTurn.adoptedWake); + } + return; + } + if (event["success"] !== false) return; + if (command === "steer" || pendingPrompt?.kind === "steer") { + // A rejected steer refuses only that message; its target turn keeps running. + yield* Effect.logWarning("Omp rejected a steer message.", { + errorLength: recordString(event, "error")?.length, + }); + return; + } + const failedTurn = + command === "prompt" && pendingPrompt?.kind === "turn_start" + ? responseTurn + : command === "parse" + ? turn + : null; + if (failedTurn !== null) { + const failure = makeProviderFailure({ + message: recordString(event, "error") ?? "Omp rejected the prompt.", + class: "provider_error", + }); + if (failedTurn.adoptedWake && command === "prompt") { + failedTurn.rejectedPromptFailure = failure; + failedTurn.settleWhenIdle = true; + yield* scheduleSettleProbe(failedTurn, true); + } else { + failedTurn.failure = failure; + if (state !== null) yield* finalizeTurn(state); + } + } + return; + } + case "t3.ui_request_expired": { + const requestId = recordString(event, "requestId"); + if (requestId === undefined) return; + const pending = pendingPrompts.get(requestId); + if (pending === undefined || pending !== event["pending"]) return; + pendingPrompts.delete(requestId); + yield* cancelPrompt(pending, yield* DateTime.now); + return; + } + case "t3.flush_extension_errors": { + for (const extensionError of outOfTurnExtensionErrors.splice(0)) { + yield* emitExtensionError(extensionError); + } + return; + } + case "t3.rollback_barrier": { + if (rollbackBarrier !== null && event["barrier"] === rollbackBarrier) + yield* Deferred.succeed(rollbackBarrier, undefined); + return; + } + case "t3.settle_probe": { + const data = event["data"]; + const probeFailed = event["probeFailed"] === true; + const settleAfterAgentActivity = event["settleAfterAgentActivity"] === true; + const attempt = Math.max(1, Math.trunc(recordNumber(event, "attempt") ?? 1)); + if ( + turn === null || + turn.providerTurn.id !== event["providerTurnId"] || + turn.settleProbeGeneration !== event["settleProbeGeneration"] || + (!settleAfterAgentActivity && turn.sawAgentActivity) || + turn.activeCompaction !== null + ) { + return; + } + if (probeFailed) { + if (!settleAfterAgentActivity) { + if (state !== null) yield* finalizeTurn(state); + return; + } + if (attempt < SETTLE_PROBE_MAX_ATTEMPTS) { + yield* Effect.sleep(SETTLE_PROBE_RETRY_DELAY).pipe( + Effect.andThen(scheduleSettleProbe(turn, true, attempt + 1)), + Effect.forkIn(scope), + ); + return; + } + stopRequested = true; + yield* connection.terminate; + return; + } + if (isOmpSessionSettled(data)) { + turn.settleWhenIdle = false; + if (state !== null) yield* finalizeTurn(state); + } + return; + } + default: + return; + } + }); + + yield* Effect.gen(function* () { + while (true) { + const nativeEvent = yield* Queue.take(connection.events); + const event = + nativeEvent["type"] === "auto_compaction_start" + ? { ...nativeEvent, type: "compaction_start" } + : nativeEvent["type"] === "auto_compaction_end" + ? { ...nativeEvent, type: "compaction_end" } + : nativeEvent; + yield* sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + // Tracked here rather than in handleSessionEvent, which also + // replays buffered wake events after they were observed. + if (event["type"] === "compaction_start") nativeCompacting = true; + if (event["type"] === "compaction_end") { + nativeCompacting = false; + // Send before the handler can probe settlement, so Omp sees the + // prompt first. Prompts whose turn ended or is stopping are dropped. + rejectedHeldCount = 0; + for (const held of heldPrompts.splice(0)) { + const turn = threadState?.activeTurn; + if ( + turn?.providerTurn.id !== held.providerTurnId || + turn.interrupted || + stopRequested + ) + continue; + yield* sendPrompt(held); + releasedPromptTurnId = held.providerTurnId; + } + } + yield* handleSessionEvent(event).pipe( + Effect.ensuring(Effect.sync(() => (releasedPromptTurnId = null))), + ); + }), + ); + } + }).pipe( + Effect.catchCause((cause) => + sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + runtimeRetired = true; + const state = threadState; + if (extensionStatusReset !== null) + yield* Deferred.fail( + extensionStatusReset.ready, + protocolError("Omp transport closed during status reset"), + ); + if (rollbackBarrier !== null) + yield* Deferred.fail( + rollbackBarrier, + protocolError("Omp transport closed during rollback"), + ); + pendingWake = null; + const interrupted = state?.activeTurn?.interrupted === true; + if (state?.activeTurn != null) { + state.activeTurn.failure = interrupted + ? null + : makeProviderFailure({ + cause, + message: "Omp process exited unexpectedly.", + class: "transport_error", + }); + yield* finalizeTurn(state, false); + } else { + yield* cancelPendingPrompts(yield* DateTime.now); + } + if (unsolicitedActivityDetected) { + yield* updateProviderSession("error", OMP_UNSOLICITED_ACTIVITY_ERROR); + yield* Queue.end(events); + } else if (stopRequested) { + yield* updateProviderSession("stopped", null); + yield* Queue.end(events); + } else { + yield* updateProviderSession( + "error", + interrupted ? "Omp process was stopped." : "Omp process exited unexpectedly.", + ); + yield* Queue.fail( + events, + new ProviderAdapter.ProviderAdapterEventStreamError({ + driver: OMP_PROVIDER, + providerSessionId: input.providerSessionId, + cause, + }), + ); + } + }), + ), + ), + Effect.forkIn(scope), + ); + + const registerThread = Effect.fnUntraced(function* ( + threadInput: ProviderAdapter.ProviderAdapterV2EnsureThreadInput, + publish = true, + ) { + if (rollbackBarrier !== null) + return yield* protocolError("Cannot register a Omp thread during rollback"); + if (threadState !== null && threadState.activeTurn !== null) { + return yield* protocolError("Cannot register a Omp thread while a turn is active"); + } + if (pendingWake !== null) { + const state = threadState; + if ( + state !== null && + state === pendingWake.state && + state.providerThread.appThreadId === threadInput.threadId && + (threadInput.existingProviderThread === undefined || + threadInput.existingProviderThread.nativeThreadRef?.nativeId === + state.providerThread.nativeThreadRef?.nativeId) + ) + return state.providerThread; + return yield* protocolError( + "Cannot switch Omp threads while native work is awaiting a turn", + ); + } + const existing = threadInput.existingProviderThread; + let resumeId = existing?.nativeThreadRef?.nativeId; + if (resumeId != null) { + const sessionDir = `${host.paths.stateDir}/omp-sessions`; + if (!resumeId.startsWith(`${sessionDir}/`)) { + const sourceIdentity = idAllocator.derive.providerThread({ + driver: OMP_PROVIDER, + nativeThreadId: resumeId, + }); + const copy = `${sessionDir}/${encodeURIComponent(threadInput.threadId)}-${encodeURIComponent(sourceIdentity)}.jsonl`; + yield* fileSystem + .makeDirectory(sessionDir, { recursive: true }) + .pipe( + Effect.mapError((cause) => protocolError("Cannot prepare OMP session copy", cause)), + ); + if (!(yield* fileSystem.exists(copy))) { + yield* fileSystem + .copyFile(resumeId, copy) + .pipe( + Effect.mapError((cause) => + protocolError("Cannot copy the native OMP session", cause), + ), + ); + } + resumeId = copy; + } + } + const needsNewSession = resumeId == null && registrationAttempted; + registrationAttempted = true; + if (resumeId != null || needsNewSession) { + lastNativeThreadId = resumeId ?? lastNativeThreadId; + // Failed lifecycle operations can still change native sessions; invalidate bindings and defaults. + threadState = null; + appliedModel = null; + appliedThinking = null; + appliedSessionName = null; + baselineModel = null; + baselineThinking = null; + contextWindow = null; + const result = yield* lifecycleRequest( + resumeId != null + ? { type: "switch_session", sessionPath: resumeId } + : { type: "new_session" }, + ); + if (recordField(result, "cancelled") === true) { + return yield* protocolError("A Omp extension cancelled the session switch"); + } + } + yield* request({ type: "set_ask_dialog", enabled: true }); + yield* request({ type: "set_subagent_subscription", level: "progress" }); + const stateData = yield* request({ type: "get_state" }); + if (!modelsDiscovered) { + const modelsData = yield* request({ type: "get_available_models" }).pipe( + Effect.orElseSucceed(() => undefined), + ); + const models = recordField(modelsData, "models"); + if (Array.isArray(models)) { + for (const model of models) rememberModelContextWindow(model); + modelsDiscovered = true; + } + } + contextWindow = rememberModelContextWindow(recordField(stateData, "model")); + // Capture each baseline before applying selections so our own choices cannot become Omp defaults. + if (baselineModel === null && appliedModel === null) { + const stateModel = recordField(stateData, "model"); + const provider = recordString(stateModel, "provider"); + const modelId = recordString(stateModel, "id"); + if (provider !== undefined && modelId !== undefined) { + baselineModel = { provider, modelId }; + } + } + if (baselineThinking === null && appliedThinking === null) { + baselineThinking = recordString(stateData, "thinkingLevel") ?? null; + appliedThinking = baselineThinking; + } + // switch_session accepts a file path, not Omp's display session UUID. + const nativeId = recordString(stateData, "sessionFile"); + if (nativeId === undefined) { + return yield* protocolError("get_state returned no persisted sessionFile", stateData); + } + if (needsNewSession && nativeId === lastNativeThreadId) { + return yield* protocolError("Omp did not create a distinct session file"); + } + lastNativeThreadId = nativeId; + const createdAt = yield* DateTime.now; + const providerThread: OrchestrationV2ProviderThread = + existing !== undefined + ? { + ...existing, + providerSessionId: input.providerSessionId, + nativeThreadRef: providerRef(nativeId), + ...(needsNewSession ? { nativeConversationHeadRef: null, contextUsage: null } : {}), + status: "idle", + updatedAt: createdAt, + } + : { + id: idAllocator.derive.providerThread({ + driver: OMP_PROVIDER, + nativeThreadId: nativeId, + }), + driver: OMP_PROVIDER, + providerInstanceId: options.instanceId, + providerSessionId: input.providerSessionId, + appThreadId: threadInput.threadId, + ownerNodeId: null, + nativeThreadRef: providerRef(nativeId), + nativeConversationHeadRef: null, + status: "idle", + firstRunOrdinal: null, + lastRunOrdinal: null, + handoffIds: [], + forkedFrom: null, + pendingBackgroundTasks: [], + createdAt, + updatedAt: createdAt, + }; + threadState = { providerThread, activeTurn: null }; + const baselineEntries = yield* request({ type: "get_entries" }).pipe( + Effect.orElseSucceed(() => undefined), + ); + lastKnownLeaf = recordString(baselineEntries, "leafId") ?? null; + leafCursorStale = baselineEntries === undefined; + if (publish) + yield* emit({ + type: "provider_thread.updated", + driver: OMP_PROVIDER, + providerThread, + }); + return providerThread; + }); + + const applySelection = Effect.fnUntraced(function* (modelSelection: ModelSelection) { + const thinking = getModelSelectionStringOptionValue(modelSelection, "thinking"); + if (modelSelection.model === OMP_INHERIT_MODEL_SLUG) { + if (appliedModel !== null && baselineModel !== null) { + const restoredModel = yield* request({ type: "set_model", ...baselineModel }); + appliedThinking = null; + contextWindow = rememberModelContextWindow(restoredModel); + appliedModel = null; + const updatedAt = yield* DateTime.now; + sessionEntity = { ...sessionEntity, model: OMP_INHERIT_MODEL_SLUG, updatedAt }; + yield* emit({ + type: "provider_session.updated", + driver: OMP_PROVIDER, + providerSession: sessionEntity, + }); + } + if ( + thinking === undefined && + baselineThinking !== null && + appliedThinking !== baselineThinking + ) { + yield* request({ type: "set_thinking_level", level: baselineThinking }); + appliedThinking = baselineThinking; + } + } else if (modelSelection.model !== appliedModel) { + const parsed = parseOmpModelSlug(modelSelection.model); + if (parsed === null) { + return yield* protocolError( + `Omp model '${modelSelection.model}' must use provider/model format`, + ); + } + const selectedModel = yield* request({ + type: "set_model", + provider: parsed.provider, + modelId: parsed.modelId, + }); + // Omp resets thinking to the target model's configured default on set_model. + appliedThinking = null; + contextWindow = rememberModelContextWindow(selectedModel); + appliedModel = modelSelection.model; + const updatedAt = yield* DateTime.now; + sessionEntity = { ...sessionEntity, model: modelSelection.model, updatedAt }; + yield* emit({ + type: "provider_session.updated", + driver: OMP_PROVIDER, + providerSession: sessionEntity, + }); + } + if ( + thinking !== undefined && + thinking !== appliedThinking && + OMP_THINKING_LEVELS.has(thinking) + ) { + yield* request({ type: "set_thinking_level", level: thinking }); + appliedThinking = thinking; + } + }); + + const resolvePromptPayload = Effect.fnUntraced(function* ( + text: string, + attachments: ReadonlyArray, + ) { + const images: Array<{ type: "image"; data: string; mimeType: string }> = []; + const message = yield* providerMessageTextWithAttachmentPaths({ + text, + attachments, + resolveAttachmentPath: host.resolveAttachmentPath, + resolveExtractedTextPath: host.resolveExtractedTextPath, + }); + for (const attachment of attachments) { + const path = host.resolveAttachmentPath(attachment); + if (path === null) continue; + if (attachment.mimeType.startsWith("image/")) { + const bytes = yield* fileSystem.readFile(path); + images.push({ + type: "image", + data: Buffer.from(bytes).toString("base64"), + mimeType: attachment.mimeType, + }); + } + } + return { message, images }; + }); + + const runtime: ProviderAdapter.ProviderAdapterV2SessionRuntime = { + instanceId: options.instanceId, + driver: OMP_PROVIDER, + providerSessionId: input.providerSessionId, + get providerSession() { + return sessionEntity; + }, + events: Stream.fromQueue(events), + hasPendingBackgroundWork: Effect.sync(() => pendingWake !== null), + hasPendingBackgroundWorkForThread: (providerThread) => + Effect.sync( + () => pendingWake !== null && pendingWake.state.providerThread.id === providerThread.id, + ), + getModelContextWindow: (selection) => { + if (selection.instanceId !== options.instanceId) return undefined; + const slug = + selection.model === OMP_INHERIT_MODEL_SLUG + ? baselineModel === null + ? undefined + : `${baselineModel.provider}/${baselineModel.modelId}` + : selection.model; + return slug === undefined ? undefined : modelContextWindows.get(slug); + }, + ensureThread: (threadInput) => + registerThread(threadInput).pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterEnsureThreadError({ + driver: OMP_PROVIDER, + threadId: threadInput.threadId, + cause, + }), + ), + ), + resumeThread: (threadInput) => + registerThread({ + threadId: + threadInput.threadId ?? threadInput.providerThread.appThreadId ?? input.threadId, + modelSelection: threadInput.modelSelection ?? input.modelSelection, + runtimePolicy: threadInput.runtimePolicy ?? input.runtimePolicy, + existingProviderThread: threadInput.providerThread, + }).pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterResumeThreadError({ + driver: OMP_PROVIDER, + providerSessionId: input.providerSessionId, + providerThreadId: threadInput.providerThread.id, + cause, + }), + ), + ), + compactThread: (turnInput) => + runtime.startTurn({ + ...turnInput, + message: { ...turnInput.message, text: "/compact" }, + }), + startTurn: Effect.fn("OmpAdapter.startTurn")( + function* (turnInput) { + if (rollbackBarrier !== null) + return yield* protocolError("Cannot start a Omp turn during rollback"); + const state = threadState; + if (state === null) { + return yield* protocolError("Omp session has no registered thread"); + } + if (state.activeTurn !== null) { + return yield* new ProviderAdapter.ProviderAdapterProtocolError({ + driver: OMP_PROVIDER, + detail: `Omp provider thread ${turnInput.providerThread.id} already has an active turn`, + reason: "previous_turn_active", + }); + } + if ( + state.providerThread.nativeThreadRef?.nativeId !== + turnInput.providerThread.nativeThreadRef?.nativeId + ) { + return yield* protocolError("Omp turn requested for a different native session"); + } + // Fork adoption uses the orchestrator-allocated row; preserve that identity in later updates. + const continuation = + turnInput.message.createdBy === "agent" && + turnInput.message.creationSource === "provider"; + if (!continuation) yield* applySelection(turnInput.modelSelection); + if (turnInput.appThread.title !== appliedSessionName) { + yield* request({ + type: "set_session_name", + name: turnInput.appThread.title, + }).pipe( + Effect.tap(() => + Effect.sync(() => (appliedSessionName = turnInput.appThread.title)), + ), + Effect.ignore, + ); + } + // Resolve attachments before turn installation so failures cannot strand activeTurn. + // Inject instructions through before_agent_start; wrapping user text breaks slash-command expansion. + const compactCommand = continuation + ? null + : parseOmpCompactCommand(turnInput.message.text); + const payload = + !continuation && compactCommand === null + ? yield* resolvePromptPayload(turnInput.message.text, turnInput.message.attachments) + : null; + const startedAt = yield* DateTime.now; + const syntheticNativeTurnId = `${state.providerThread.id}:attempt:${turnInput.attemptId}`; + const providerTurn: OrchestrationV2ProviderTurn = { + id: idAllocator.derive.providerTurn({ + driver: OMP_PROVIDER, + nativeTurnId: syntheticNativeTurnId, + }), + providerThreadId: turnInput.providerThread.id, + nodeId: turnInput.rootNodeId, + runAttemptId: turnInput.attemptId, + nativeTurnRef: providerRef(syntheticNativeTurnId, "weak"), + ordinal: turnInput.providerTurnOrdinal, + status: "running", + startedAt, + completedAt: null, + }; + const activeTurn: ActiveOmpTurn = { + turnInput, + providerTurn, + startedAt, + itemOrdinals: new Map(), + nextItemOrdinal: turnInput.providerTurnOrdinal * 100 + 1, + messageOrdinal: 0, + streamItems: new Map(), + toolArgs: new Map(), + toolStartedAt: new Map(), + interrupted: false, + nativeAborted: false, + sawAgentActivity: false, + adoptedWake: false, + promptMayBeCommandOnly: + compactCommand !== null || (payload?.message.trimStart().startsWith("/") ?? false), + latestCompactionAfterTokens: null, + lastLiveUsedTokens: null, + settleProbeGeneration: 0, + settleWhenIdle: false, + sawCompaction: false, + manualCompactInFlight: compactCommand !== null, + activeCompaction: null, + activeProviderRetry: null, + failure: null, + rejectedPromptFailure: null, + }; + // Lock only install/send/start events; correlated setup must leave the pump free for dialogs. + yield* Effect.gen(function* () { + if ( + threadState !== state || + state.activeTurn !== null || + closed || + stopRequested || + rollbackBarrier !== null || + state.providerThread.nativeThreadRef?.nativeId !== + turnInput.providerThread.nativeThreadRef?.nativeId + ) { + return yield* protocolError("Omp turn ownership changed before it could start"); + } + const wake = pendingWake?.state === state ? pendingWake : null; + if (wake !== null && wake.state.providerThread.appThreadId !== turnInput.threadId) { + return yield* protocolError("Omp native wake belongs to a different app thread"); + } + pendingWake = null; + state.providerThread = turnInput.providerThread; + state.activeTurn = activeTurn; + activeTurn.adoptedWake = wake !== null && !continuation; + if (compactCommand !== null) { + yield* connection.send(compactRpcRecord(compactCommand)); + pendingCompactResponses.push({ + providerTurnId: providerTurn.id, + kind: "turn_start", + }); + } else if (payload !== null) { + yield* sendPrompt({ + providerTurnId: providerTurn.id, + kind: "turn_start", + record: { + type: "prompt", + message: payload.message, + streamingBehavior: "steer", + ...(payload.images.length === 0 ? {} : { images: payload.images }), + }, + }); + } + yield* emit({ + type: "provider_turn.updated", + driver: OMP_PROVIDER, + threadId: turnInput.threadId, + providerTurn, + }); + yield* updateProviderThread(state, { + status: "active", + firstRunOrdinal: state.providerThread.firstRunOrdinal ?? turnInput.runOrdinal, + lastRunOrdinal: turnInput.runOrdinal, + }); + yield* updateProviderSession("running", null); + if (wake !== null) { + for (const event of wake.events) { + if (!continuation && event["type"] === "session_settled") { + activeTurn.nativeAborted = event["aborted"] === true; + activeTurn.settleWhenIdle = true; + continue; + } + yield* handleSessionEvent(event); + } + } else if (continuation) { + yield* finalizeTurn(state); + } + if (outOfTurnExtensionErrors.length > 0) { + yield* Queue.offer(connection.events, { type: "t3.flush_extension_errors" }); + } + }).pipe( + sessionEventPermit.withPermits(1), + Effect.tapError(() => + Effect.sync(() => { + if (state.activeTurn === activeTurn) state.activeTurn = null; + }), + ), + ); + // Native prompt_result owns completion; the prompt acknowledgement only admits the request. + }, + (effect, turnInput) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterTurnStartError({ + driver: OMP_PROVIDER, + threadId: turnInput.threadId, + providerThreadId: turnInput.providerThread.id, + runId: turnInput.runId, + cause, + }), + ), + ), + ), + steerTurn: Effect.fn("OmpAdapter.steerTurn")( + function* (steerInput: ProviderAdapter.ProviderAdapterV2SteerInput) { + const turn = threadState?.activeTurn ?? null; + if (turn === null || turn.providerTurn.id !== steerInput.providerTurnId) { + return yield* protocolError(`Omp turn ${steerInput.providerTurnId} is not active`); + } + const compactCommand = parseOmpCompactCommand(steerInput.message.text); + const payload = + compactCommand === null + ? yield* resolvePromptPayload( + steerInput.message.text, + steerInput.message.attachments, + ) + : null; + // prompt with steer atomically queues or starts; fire-and-forget under the permit avoids dialog deadlocks. + // /compact uses its RPC, which aborts the agent first. + yield* sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + if (threadState?.activeTurn !== turn) { + return yield* protocolError( + `Omp turn ${steerInput.providerTurnId} is not active`, + ); + } + if (compactCommand !== null) { + turn.manualCompactInFlight = true; + yield* connection.send(compactRpcRecord(compactCommand)); + pendingCompactResponses.push({ + providerTurnId: turn.providerTurn.id, + kind: "steer", + }); + } else if (payload !== null) { + yield* sendPrompt({ + providerTurnId: turn.providerTurn.id, + kind: "steer", + record: { + type: "prompt", + message: payload.message, + streamingBehavior: "steer", + ...(payload.images.length === 0 ? {} : { images: payload.images }), + }, + }); + } + turn.settleProbeGeneration += 1; + }), + ); + }, + (effect, steerInput) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterSteerRunError({ + driver: OMP_PROVIDER, + providerThreadId: steerInput.providerThread.id, + providerTurnId: steerInput.providerTurnId, + cause, + }), + ), + ), + ), + interruptTurn: Effect.fn("OmpAdapter.interruptTurn")( + function* (interruptInput) { + const turn = threadState?.activeTurn ?? null; + if (turn === null && interruptInput.requestRuntimeRestart === true) { + if (pendingWake !== null) + yield* sessionEventPermit.withPermits(1)(stopPendingWake(pendingWake)); + return; + } + if (turn === null || turn.providerTurn.id !== interruptInput.providerTurnId) { + return yield* protocolError( + `Omp turn ${interruptInput.providerTurnId} is not active`, + ); + } + turn.interrupted = true; + if ( + interruptInput.requestRuntimeRestart === true || + turn.settleWhenIdle || + turn.activeCompaction !== null || + turn.manualCompactInFlight || + nativeCompacting + ) { + // Generic abort misses manual compaction; terminate so Stop covers /compact and recovery. + stopRequested = true; + if (interruptInput.requestRuntimeRestart === true && !turn.settleWhenIdle) { + yield* clearNativeQueue(turn); + yield* request({ type: "abort" }, 2_000).pipe(Effect.ignore); + } + // Read rollback tree refs before termination breaks requests; the permit lets in-flight capture finish. + yield* sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + if (threadState?.activeTurn === turn && turn.stopTreeRefs === undefined) { + turn.stopTreeRefs = yield* captureTurnTreeRefs(2_000); + } + yield* connection.terminate; + }), + ); + return; + } + yield* clearNativeQueue(turn); + yield* request({ type: "abort" }).pipe( + Effect.tapError(() => Effect.sync(() => (turn.interrupted = false))), + ); + }, + (effect, interruptInput) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterInterruptError({ + driver: OMP_PROVIDER, + providerThreadId: interruptInput.providerThread.id, + providerTurnId: interruptInput.providerTurnId, + cause, + }), + ), + ), + ), + respondToRuntimeRequest: Effect.fn("OmpAdapter.respondToRuntimeRequest")( + function* (requestInput) { + const pending = pendingPrompts.get(String(requestInput.requestId)); + if (pending === undefined) { + return yield* protocolError( + `No pending Omp extension request ${requestInput.requestId}`, + ); + } + const answeredAt = yield* DateTime.now; + if ( + pending.expiresAt !== null && + DateTime.toEpochMillis(answeredAt) >= pending.expiresAt + ) { + pendingPrompts.delete(String(requestInput.requestId)); + yield* cancelPrompt(pending, answeredAt); + return yield* protocolError( + `Omp extension request ${requestInput.requestId} has expired`, + ); + } + const response = ompUiResponse(pending, requestInput.decision, requestInput.answers); + yield* connection.send({ + type: "extension_ui_response", + id: pending.nativeRequestId, + ...response, + }); + pendingPrompts.delete(String(requestInput.requestId)); + if (pending.expirationFiber !== null) yield* Fiber.interrupt(pending.expirationFiber); + if (pending.method === "confirm" && requestInput.decision === "acceptForSession") { + sessionApprovals.add(pending.approvalKey); + } + const resolvedAt = yield* DateTime.now; + pending.runtimeRequest = { + ...pending.runtimeRequest, + status: "resolved", + resolvedAt, + }; + yield* emit({ + type: "runtime_request.updated", + driver: OMP_PROVIDER, + threadId: pending.node.threadId, + runtimeRequest: pending.runtimeRequest, + }); + yield* emit({ + type: "node.updated", + driver: OMP_PROVIDER, + node: { ...pending.node, status: "completed", completedAt: resolvedAt }, + }); + yield* emit({ + type: "turn_item.updated", + driver: OMP_PROVIDER, + turnItem: { + ...pending.turnItem, + status: "completed", + completedAt: resolvedAt, + updatedAt: resolvedAt, + }, + }); + }, + (effect, requestInput) => + effect.pipe( + sessionEventPermit.withPermits(1), + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterRuntimeRequestResponseError({ + driver: OMP_PROVIDER, + requestId: requestInput.requestId, + cause, + }), + ), + ), + ), + readThreadSnapshot: Effect.fn("OmpAdapter.readThreadSnapshot")( + function* (snapshotInput) { + const state = threadState; + const boundNativeId = state?.providerThread.nativeThreadRef?.nativeId; + const wantedNativeId = snapshotInput.providerThread.nativeThreadRef?.nativeId; + if (state === null || wantedNativeId == null || boundNativeId !== wantedNativeId) { + return yield* protocolError( + "Omp snapshot requested for a thread this session does not host", + ); + } + // get_messages contains only the active branch; get_entries would leak abandoned branches into handoffs. + const messagesData = yield* request({ type: "get_messages" }); + const activeMessages = recordField(messagesData, "messages"); + const threadId = state.providerThread.appThreadId ?? input.threadId; + const messages = (Array.isArray(activeMessages) ? activeMessages : []).flatMap( + (message, index) => { + const role = recordString(message, "role"); + if (role !== "user" && role !== "assistant") return []; + const text = contentText(recordField(message, "content")); + if (text.length === 0) return []; + const timestamp = recordNumber(message, "timestamp"); + const at = Option.getOrElse( + DateTime.make(timestamp ?? Number.NaN), + () => state.providerThread.createdAt, + ); + return [ + { + id: idAllocator.derive.messageFromProviderItem({ + driver: OMP_PROVIDER, + nativeItemId: `${wantedNativeId}:snapshot-message:${index}`, + }), + threadId, + runId: null, + nodeId: null, + role: role as "user" | "assistant", + text, + attachments: [], + streaming: false, + createdBy: role === "user" ? ("user" as const) : ("agent" as const), + creationSource: "provider" as const, + createdAt: at, + updatedAt: at, + }, + ]; + }, + ); + return { + providerThread: state.providerThread, + providerTurns: [], + messages, + runtimeRequests: [], + }; + }, + (effect, snapshotInput) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterReadThreadSnapshotError({ + driver: OMP_PROVIDER, + providerThreadId: snapshotInput.providerThread.id, + cause, + }), + ), + ), + ), + rollbackThread: Effect.fn("OmpAdapter.rollbackThread")( + function* (rollbackInput) { + const state = threadState; + if (state === null) { + return yield* protocolError("Omp session has no registered thread"); + } + if (state.providerThread.id !== rollbackInput.providerThread.id) { + return yield* protocolError( + "Omp rollback requested for a thread this session does not host", + ); + } + if (state.activeTurn !== null) { + return yield* protocolError("Cannot roll back while a Omp turn is active"); + } + if (pendingWake !== null) { + return yield* protocolError("Cannot roll back while native Omp work awaits a turn"); + } + const boundary = ompForkBoundary(rollbackInput); + if (boundary.type === "nothing") { + return ompThreadSnapshot(state.providerThread); + } + const forkEntryId = yield* ompForkEntry( + boundary, + rollbackInput.providerThread.createdAt, + request({ type: "get_entries" }), + ); + return yield* Effect.acquireUseRelease( + sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + if ( + rollbackBarrier !== null || + threadState !== state || + state.activeTurn !== null || + pendingWake !== null || + closed || + stopRequested + ) + return yield* protocolError( + "Omp rollback ownership changed before its fork could start", + ); + const barrier = yield* Deferred.make< + void, + ProviderAdapter.ProviderAdapterProtocolError + >(); + rollbackBarrier = barrier; + return barrier; + }), + ), + (barrier) => + Effect.gen(function* () { + const forkData = yield* lifecycleRequest( + forkEntryId === null + ? { type: "new_session" } + : { type: "fork", entryId: forkEntryId }, + ); + if (recordField(forkData, "cancelled") === true) + return yield* protocolError("A Omp extension cancelled the session fork"); + const forkState = yield* request({ type: "get_state" }).pipe( + Effect.onError(() => + Effect.sync(() => { + threadState = null; + }), + ), + ); + const forkSessionFile = recordString(forkState, "sessionFile"); + if (forkSessionFile === undefined) { + threadState = null; + return yield* protocolError("Omp fork did not return a persisted session file"); + } + const entriesData = yield* request({ type: "get_entries" }).pipe( + Effect.orElseSucceed(() => undefined), + ); + const leafId = recordString(entriesData, "leafId") ?? null; + // RPC responses bypass the pump; drain prior native events before replacing their binding. + const queued = yield* Queue.offer(connection.events, { + type: "t3.rollback_barrier", + barrier, + }); + if (!queued) return yield* protocolError("Omp transport closed during rollback"); + yield* Deferred.await(barrier); + return yield* sessionEventPermit.withPermits(1)( + Effect.gen(function* () { + if (pendingWake !== null) { + yield* stopPendingWake(pendingWake); + return yield* protocolError( + "Native Omp work started while rollback was changing the session", + ); + } + if ( + threadState !== state || + state.activeTurn !== null || + closed || + stopRequested + ) + return yield* protocolError( + "Omp rollback ownership changed during its fork", + ); + lastNativeThreadId = forkSessionFile; + appliedModel = null; + appliedThinking = null; + appliedSessionName = null; + lastKnownLeaf = leafId; + leafCursorStale = entriesData === undefined; + yield* updateProviderThread(state, { + nativeThreadRef: providerRef(forkSessionFile), + nativeConversationHeadRef: leafId === null ? null : providerRef(leafId), + }); + rollbackBarrier = null; + return ompThreadSnapshot(state.providerThread); + }), + ); + }).pipe(Effect.onInterrupt(() => connection.terminate)), + (barrier) => + Effect.sync(() => { + if (rollbackBarrier === barrier) rollbackBarrier = null; + }), + ); + }, + (effect, rollbackInput) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterRollbackThreadError({ + driver: OMP_PROVIDER, + providerThreadId: rollbackInput.providerThread.id, + checkpointId: rollbackInput.target.checkpointId, + cause, + }), + ), + ), + ), + forkThread: Effect.fn("OmpAdapter.forkThread")( + function* (forkInput) { + if (threadState?.activeTurn != null) { + return yield* protocolError("Cannot fork while a Omp turn is active"); + } + const source = forkInput.sourceProviderThread; + const sourceFile = source.nativeThreadRef?.nativeId; + if (sourceFile == null) + return yield* protocolError("Omp fork source has no session file"); + const sourceTurns = (forkInput.sourceProviderTurns ?? []).filter( + (turn) => turn.providerThreadId === source.id, + ); + const target = sourceTurns.find((turn) => turn.id === forkInput.providerTurnId); + if (forkInput.providerTurnId !== undefined && target === undefined) { + return yield* protocolError("Omp fork target turn is missing"); + } + const boundary: OmpForkBoundary = + target === undefined + ? { type: "nothing" } + : ompForkBoundary({ + target: { type: "provider_turn", providerTurn: target }, + providerThreadTurns: sourceTurns, + }); + const forkDirectory = `${host.paths.stateDir}/omp-sessions`; + const forkCopy = `${forkDirectory}/${encodeURIComponent(forkInput.targetThreadId)}.jsonl`; + yield* fileSystem.makeDirectory(forkDirectory, { recursive: true }); + yield* fileSystem.copyFile(sourceFile, forkCopy); + const forkLaunch = buildOmpRpcLaunch({ + launchArgs: resolvedLaunchArgs.args, + environment: options.environment, + mcpSession: undefined, + extensionPath: undefined, + shortLived: true, + disableExtensions: true, + disableTools: true, + }); + const nativeId = yield* Effect.scoped( + Effect.gen(function* () { + const forkConnection = yield* makeOmpRpcConnection({ + command: options.settings.binaryPath || "omp", + args: [...forkLaunch.args, "--session-dir", forkDirectory, "--resume", forkCopy], + cwd, + env: forkLaunch.env, + }); + yield* Stream.fromQueue(forkConnection.events).pipe( + Stream.runDrain, + Effect.ignore, + Effect.forkScoped, + ); + const beforeEntry = + boundary.type === "nothing" + ? null + : yield* ompForkEntry( + boundary, + source.createdAt, + forkConnection.request({ type: "get_entries" }), + ); + { + const result = yield* forkConnection.request( + boundary.type === "nothing" + ? { type: "fork" } + : beforeEntry === null + ? { type: "new_session" } + : { + type: "fork", + entryId: beforeEntry, + }, + ); + if (recordField(result, "cancelled") === true) { + return yield* protocolError("A Omp extension cancelled the session fork"); + } + } + const state = yield* forkConnection.request({ type: "get_state" }); + const file = recordString(state, "sessionFile"); + if (file === undefined || file === sourceFile) { + return yield* protocolError("Omp fork did not create a distinct session file"); + } + return file; + }), + ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner)); + const now = yield* DateTime.now; + return yield* registerThread( + { + threadId: forkInput.targetThreadId, + modelSelection: forkInput.modelSelection ?? input.modelSelection, + runtimePolicy: forkInput.runtimePolicy ?? input.runtimePolicy, + existingProviderThread: { + ...source, + id: idAllocator.derive.providerThread({ + driver: OMP_PROVIDER, + nativeThreadId: nativeId, + }), + appThreadId: forkInput.targetThreadId, + providerSessionId: input.providerSessionId, + providerInstanceId: options.instanceId, + ownerNodeId: forkInput.ownerNodeId ?? null, + nativeThreadRef: providerRef(nativeId), + nativeConversationHeadRef: null, + firstRunOrdinal: null, + lastRunOrdinal: null, + handoffIds: [], + pendingBackgroundTasks: [], + forkedFrom: { + providerThreadId: source.id, + ...(forkInput.providerTurnId === undefined + ? {} + : { providerTurnId: forkInput.providerTurnId }), + }, + createdAt: now, + updatedAt: now, + }, + }, + false, + ); + }, + (effect, forkInput) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapter.ProviderAdapterForkThreadError({ + driver: OMP_PROVIDER, + providerThreadId: forkInput.sourceProviderThread.id, + cause, + }), + ), + ), + ), + }; + return runtime; + }), + }); +}); + +interface OmpSessionEntry { + readonly parentId: string | null; + readonly isUserMessage: boolean; + readonly isMessage: boolean; + /** Omp's `timestamp` as epoch milliseconds; null when missing or unparsable. */ + readonly timestamp: number | null; +} + +interface OmpSessionListing { + readonly entries: ReadonlyMap; + readonly leafId: string | null; +} + +function ompSessionListing(data: unknown): OmpSessionListing | null { + const leafId = recordField(data, "leafId"); + const entries = ompSessionEntries(recordField(data, "entries")); + return entries !== null && (typeof leafId === "string" || leafId === null) + ? { entries, leafId } + : null; +} + +function ompSessionEntries(entries: unknown): ReadonlyMap | null { + const byId = new Map(); + if (!Array.isArray(entries)) return null; + for (const entry of entries) { + const id = recordString(entry, "id"); + const parentId = recordField(entry, "parentId"); + if (id === undefined || byId.has(id) || (parentId !== null && typeof parentId !== "string")) + return null; + const timestamp = recordString(entry, "timestamp"); + byId.set(id, { + parentId, + isMessage: recordField(entry, "type") === "message", + isUserMessage: + recordField(entry, "type") === "message" && + recordString(recordField(entry, "message"), "role") === "user", + timestamp: + timestamp === undefined + ? null + : Option.getOrNull(Option.map(DateTime.make(timestamp), DateTime.toEpochMillis)), + }); + } + return byId; +} + +function walkOmpBranch( + entries: ReadonlyMap, + leafId: string | null, + stopAt: string | null, +): { + readonly entryCount: number; + readonly userEntryIds: ReadonlyArray; + readonly reachedStop: boolean; +} | null { + const visited = new Set(); + const userEntryIds: Array = []; + let current = leafId; + while (current !== null && current !== stopAt) { + const entry = entries.get(current); + if (entry === undefined) break; + if (visited.has(current)) return null; + visited.add(current); + if (entry.isUserMessage) userEntryIds.push(current); + current = entry.parentId; + } + return { entryCount: visited.size, userEntryIds, reachedStop: current === stopAt }; +} + +type OmpForkBoundary = + | { readonly type: "entry"; readonly entryId: string } + | { readonly type: "nothing" } + | { + readonly type: "uncaptured"; + readonly turn: OrchestrationV2ProviderTurn; + readonly target: OrchestrationV2ProviderTurn | null; + }; + +/** + * Turns without a ref left nothing on the active branch, so the boundary is the first discarded + * turn that has one. `uncaptured` is a boundary turn still carrying its synthetic ref (only + * `captureTurnTreeRefs` records strong ones); `ompForkEntry` locates it in the session tree. + */ +function ompForkBoundary(input: { + readonly target: + | { readonly type: "thread_start" } + | { readonly type: "provider_turn"; readonly providerTurn: OrchestrationV2ProviderTurn }; + readonly providerThreadTurns: ReadonlyArray; +}): OmpForkBoundary { + const target = input.target.type === "thread_start" ? null : input.target.providerTurn; + const boundary = input.providerThreadTurns + .filter((turn) => turn.ordinal > (target?.ordinal ?? 0) && turn.nativeTurnRef !== null) + .sort((a, b) => a.ordinal - b.ordinal)[0]; + const ref = boundary?.nativeTurnRef; + if (boundary === undefined || ref == null) return { type: "nothing" }; + return ref.strength === "strong" && ref.nativeId !== null + ? { type: "entry", entryId: ref.nativeId } + : { type: "uncaptured", turn: boundary, target }; +} + +// OMP fork includes the selected entry; T3 discards the boundary user message. +function ompForkEntry( + boundary: Exclude, + providerThreadCreatedAt: DateTime.Utc, + readEntries: Effect.Effect, +): Effect.Effect { + return readEntries.pipe( + Effect.flatMap((data) => { + const listing = ompSessionListing(data); + const entryId = + listing === null + ? undefined + : boundary.type === "entry" + ? boundary.entryId + : ompUncapturedForkEntry(listing, boundary, providerThreadCreatedAt); + return entryId === undefined || !listing?.entries.has(entryId) + ? Effect.fail( + new ProviderAdapter.ProviderAdapterProtocolError({ + driver: OMP_PROVIDER, + detail: "OMP rollback boundary was not found in its session tree", + }), + ) + : Effect.succeed(ompForkMessageParent(listing.entries, entryId)); + }), + ); +} + +/** + * Omp shares the server clock. An adopted wake can precede its T3 turn, so search from the target + * turn's end through the boundary turn's end. A boundary turn still running has no end yet, so + * the window stays open through the tree read. At thread start, use the earlier of thread + * creation and turn start to include adopted wakes while preserving inherited session history. + */ +function ompUncapturedForkEntry( + listing: OmpSessionListing, + boundary: Extract, + providerThreadCreatedAt: DateTime.Utc, +): string | undefined { + const { startedAt, completedAt } = boundary.turn; + if (startedAt === null) return undefined; + const from = + boundary.target === null + ? Math.min(DateTime.toEpochMillis(providerThreadCreatedAt), DateTime.toEpochMillis(startedAt)) + : DateTime.toEpochMillis(boundary.target.completedAt ?? startedAt); + const to = completedAt === null ? Infinity : DateTime.toEpochMillis(completedAt); + const targetRef = boundary.target?.nativeTurnRef; + const stopAt = targetRef?.strength === "strong" ? targetRef.nativeId : null; + if (stopAt !== null && !listing.entries.has(stopAt)) return undefined; + const walk = walkOmpBranch(listing.entries, listing.leafId, stopAt); + if (walk === null || !walk.reachedStop) return undefined; + let earliest: string | undefined; + for (const id of walk.userEntryIds) { + const timestamp = listing.entries.get(id)?.timestamp; + if (timestamp == null) return undefined; + if (timestamp >= from && timestamp <= to) earliest = id; + } + return earliest; +} + +function ompSubagentOutput(result: unknown): string { + const stopReason = recordString(result, "stopReason"); + const failed = + (recordNumber(result, "exitCode") ?? 0) !== 0 || + stopReason === "error" || + stopReason === "aborted"; + if (failed) { + const failure = recordString(result, "errorMessage") || recordString(result, "stderr"); + if (failure !== undefined && failure.length > 0) return failure; + } + const messages = recordField(result, "messages"); + if (!Array.isArray(messages)) return ""; + for (let index = messages.length - 1; index >= 0; index -= 1) { + const message = messages[index]; + if (recordString(message, "role") !== "assistant") continue; + const text = contentText(recordField(message, "content")); + if (text.length > 0) return text; + } + return ""; +} + +function ompExtensionDisplayName(extensionPath: string | undefined): string { + if (extensionPath === undefined) return "Omp extension"; + const segments = extensionPath.replace(/\\/g, "/").split("/").filter(Boolean); + const fileName = segments.at(-1)?.replace(/\.[^.]+$/, "") ?? ""; + // Omp loads a directory extension from its index file; the folder names it. + const name = fileName === "index" ? (segments.at(-2) ?? fileName) : fileName; + return name.length === 0 ? "Omp extension" : name; +} + +function ompThreadSnapshot( + providerThread: OrchestrationV2ProviderThread, +): ProviderAdapter.ProviderAdapterV2ThreadSnapshot { + return { providerThread, providerTurns: [], messages: [], runtimeRequests: [] }; +} + +function ompQuestion( + questionId: string, + method: "select" | "input" | "editor", + title: string, + event: OmpRpcRecord, +): OrchestrationV2UserInputQuestion { + const options = + method === "select" && Array.isArray(event["options"]) + ? event["options"] + .filter((option): option is string => typeof option === "string") + .map((option) => ({ + label: option || "Empty value", + description: option || "Empty value", + value: option, + })) + : method === "editor" + ? [] + : [ + { + label: "Submit empty value", + description: "Send an empty string to the extension.", + value: "", + }, + ]; + // Omp's select and editor dialogs carry only a title, so show it once, as the question. + // Extensions may send a blank placeholder, which is not a valid question. + const detail = [recordString(event, "message"), recordString(event, "placeholder")].find( + (text) => text !== undefined && text.trim().length > 0, + ); + return { + id: questionId, + header: detail === undefined ? "Question" : title, + question: detail ?? title, + ...(method === "editor" ? { initialAnswer: recordString(event, "prefill") ?? "" } : {}), + options, + }; +} + +function ompUiResponse( + pending: PendingOmpPrompt, + decision: ProviderApprovalDecision | undefined, + answers: Record | undefined, +): OmpRpcRecord { + if (pending.method === "confirm") { + if (decision === "accept" || decision === "acceptForSession") return { confirmed: true }; + if (decision === "decline") return { confirmed: false }; + return { cancelled: true }; + } + if (pending.method === "ask") return ompAskResponse(pending.questions, answers); + const answer = answers?.[pending.questionId]; + // RPC distinguishes empty dialog values from cancellation (undefined). + if (typeof answer === "string") return { value: answer }; + return { cancelled: true }; +} + +export type OmpAdapterV2DriverEnv = + | ChildProcessSpawner.ChildProcessSpawner + | FileSystem.FileSystem + | IdAllocator.IdAllocatorV2 + | McpProviderSessions.McpProviderSessions + | ProviderHost.ProviderHost; + +export const OmpAdapterV2Driver: ProviderAdapterDriver = { + driverKind: OMP_DRIVER_KIND, + configSchema: OmpSettings, + defaultConfig: (): OmpSettings => DEFAULT_OMP_SETTINGS, + create: Effect.fn("OmpAdapterV2Driver.create")( + function* (input: ProviderAdapterDriverCreateInput) { + const hostEnvironment = yield* HostProcess.Environment; + const continuationRequests = yield* ProviderContinuationRequests.ProviderContinuationRequests; + return yield* makeOmpAdapterV2({ + instanceId: input.instanceId, + settings: { ...input.config, enabled: input.enabled }, + environment: yield* mergeProviderInstanceEnvironment(input.environment, hostEnvironment), + continuationRequests, + }); + }, + (effect, input) => + effect.pipe( + Effect.mapError( + (cause) => + new ProviderAdapterDriverCreateError({ + driver: OMP_DRIVER_KIND, + instanceId: input.instanceId, + detail: "Failed to create Omp adapter.", + cause, + }), + ), + ), + ), +}; diff --git a/packages/provider-omp/src/server/commands.test.ts b/packages/provider-omp/src/server/commands.test.ts new file mode 100644 index 0000000000000..3cff7c07e73bf --- /dev/null +++ b/packages/provider-omp/src/server/commands.test.ts @@ -0,0 +1,64 @@ +import { expect, it } from "@effect/vitest"; + +import { parseOmpDiscoveredCommands } from "./commands.ts"; + +it("maps current Omp skill metadata to T3's user and project skill scopes", () => { + expect( + parseOmpDiscoveredCommands({ + commands: [ + { + name: "skill:global-review", + description: "Review changes.", + source: "skill", + sourceInfo: { + path: "/home/test/.agents/skills/global-review/SKILL.md", + scope: "user", + }, + }, + { + name: "skill:project-deploy", + description: "Deploy this project.", + source: "skill", + sourceInfo: { + path: "/workspace/.agents/skills/project-deploy/SKILL.md", + scope: "project", + }, + }, + { name: "hello", description: "Say hello.", source: "extension" }, + ], + }), + ).toEqual({ + skills: [ + { + name: "global-review", + description: "Review changes.", + path: "/home/test/.agents/skills/global-review/SKILL.md", + scope: "user", + enabled: true, + }, + { + name: "project-deploy", + description: "Deploy this project.", + path: "/workspace/.agents/skills/project-deploy/SKILL.md", + scope: "project", + enabled: true, + }, + ], + slashCommands: [{ name: "hello", description: "Say hello." }], + }); +}); + +it("preserves OMP native command hints and exact thinking metadata", () => { + expect( + parseOmpDiscoveredCommands({ + commands: [ + { + name: "switch", + source: "builtin", + description: "Switch model", + input: { hint: "[model]" }, + }, + ], + }).slashCommands, + ).toEqual([{ name: "switch", description: "Switch model", input: { hint: "[model]" } }]); +}); diff --git a/packages/provider-omp/src/server/commands.ts b/packages/provider-omp/src/server/commands.ts new file mode 100644 index 0000000000000..47b41b9e4270f --- /dev/null +++ b/packages/provider-omp/src/server/commands.ts @@ -0,0 +1,102 @@ +import { type ServerProviderSkill, type ServerProviderSlashCommand } from "@t3tools/contracts"; +import * as Predicate from "effect/Predicate"; + +// T3 routes /compact to the dedicated RPC command. +const OMP_COMPACT_SLASH_COMMAND: ServerProviderSlashCommand = { + name: "compact", + description: "Summarize the conversation and reduce context usage", + input: { hint: "Optional instructions" }, +}; + +export interface OmpCompactCommand { + readonly customInstructions?: string; +} + +export function parseOmpCompactCommand(text: string): OmpCompactCommand | null { + const trimmed = text.trim(); + if (trimmed === "/compact") return {}; + if (!trimmed.startsWith("/compact")) return null; + const rest = trimmed.slice("/compact".length); + if (rest.length === 0) return {}; + if (!/^\s/.test(rest)) return null; + const customInstructions = rest.trim(); + return customInstructions.length === 0 ? {} : { customInstructions }; +} + +export function withOmpBuiltinSlashCommands( + commands: ReadonlyArray, +): ReadonlyArray { + return [OMP_COMPACT_SLASH_COMMAND, ...commands.filter((command) => command.name !== "compact")]; +} + +export interface OmpDiscoveredCommands { + readonly slashCommands: ReadonlyArray; + readonly skills: ReadonlyArray; +} + +function normalizeOmpSkillScope(scope: string | undefined): string | undefined { + if (scope === undefined) return undefined; + const normalized = scope.trim().toLowerCase(); + if (normalized === "global" || normalized === "personal") return "user"; + if (normalized === "workspace" || normalized === "local") return "project"; + return scope; +} + +export function parseOmpDiscoveredCommands(data: unknown): OmpDiscoveredCommands { + const commands = recordField(data, "commands"); + if (!Array.isArray(commands)) return { slashCommands: [], skills: [] }; + const slashCommands: Array = []; + const skills: Array = []; + for (const command of commands) { + const commandName = recordString(command, "name"); + if (commandName === undefined || commandName.length === 0) continue; + const description = recordString(command, "description"); + if (recordString(command, "source") === "skill") { + const name = commandName.startsWith("skill:") + ? commandName.slice("skill:".length) + : commandName; + if (name.length === 0) continue; + const sourceInfo = recordField(command, "sourceInfo"); + const commandInterface = recordField(command, "interface"); + const path = + recordString(sourceInfo, "path") ?? recordString(command, "path") ?? `omp:skill:${name}`; + const scope = normalizeOmpSkillScope( + recordString(sourceInfo, "scope") ?? recordString(command, "location"), + ); + const displayName = + recordString(command, "displayName") ?? + recordString(sourceInfo, "displayName") ?? + recordString(commandInterface, "displayName"); + const shortDescription = + recordString(command, "shortDescription") ?? + recordString(sourceInfo, "shortDescription") ?? + recordString(commandInterface, "shortDescription"); + skills.push({ + name, + path, + enabled: true, + ...(description === undefined ? {} : { description }), + ...(scope === undefined ? {} : { scope }), + ...(displayName === undefined ? {} : { displayName }), + ...(shortDescription === undefined ? {} : { shortDescription }), + }); + continue; + } + const hint = recordString(recordField(command, "input"), "hint"); + slashCommands.push({ + name: commandName, + ...(hint === undefined ? {} : { input: { hint } }), + ...(description === undefined ? {} : { description }), + }); + } + return { slashCommands, skills }; +} + +function recordField(input: unknown, key: string): unknown { + return Predicate.isObject(input) ? input[key] : undefined; +} + +function recordString(input: unknown, key: string): string | undefined { + const value = recordField(input, key); + return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined; +} diff --git a/packages/provider-omp/src/server/driver.ts b/packages/provider-omp/src/server/driver.ts new file mode 100644 index 0000000000000..f6e080e62793b --- /dev/null +++ b/packages/provider-omp/src/server/driver.ts @@ -0,0 +1,212 @@ +import { ompMaintenance } from "./maintenance.ts"; +import { ProviderDriverKind, type ServerProvider } from "@t3tools/contracts"; +import { OmpSettings } from "../settings.ts"; +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 * as HttpClient from "effect/http/HttpClient"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; + +import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; +import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; +import { ompUsageReader } from "./usage.ts"; +import { makeOmpTextGeneration } from "./textGeneration.ts"; +import { OmpAdapterV2Driver, type OmpAdapterV2DriverEnv } from "./adapter.ts"; +import { ProviderDriverError } from "@t3tools/provider-core/server/errors"; +import { + buildInitialOmpProviderSnapshot, + checkOmpProviderStatus, + discoverOmpCommandsForCwd, + enrichOmpSnapshot, +} from "./status.ts"; +import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider"; +import { + defaultProviderContinuationIdentity, + type ProviderDriver, + type ProviderInstance, +} from "@t3tools/provider-core/server/driver"; +import type { ServerProviderDraft } from "@t3tools/provider-core/server/snapshotProbe"; +import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; +import { + makeCachedProviderMaintenanceResolution, + resolveProviderMaintenanceCapabilitiesEffect, +} from "@t3tools/provider-core/server/maintenanceResolver"; +import { + haveProviderSnapshotSettingsChanged, + makeProviderSnapshotSettingsSource, + type ProviderSnapshotSettings, +} from "@t3tools/provider-core/server/snapshotSettings"; + +const decodeOmpSettings = Schema.decodeSync(OmpSettings); + +const DRIVER_KIND = ProviderDriverKind.make("omp"); + +export type OmpDriverEnv = + | OmpAdapterV2DriverEnv + | ProviderHost.ProviderHost + | ChildProcessSpawner.ChildProcessSpawner + | FileSystem.FileSystem + | HttpClient.HttpClient + | ProviderLatestVersions.ProviderLatestVersions + | Path.Path; + +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 OmpDriver: ProviderDriver = { + driverKind: DRIVER_KIND, + metadata: { + displayName: "OMP", + supportsMultipleInstances: true, + }, + usage: ompUsageReader, + configSchema: OmpSettings, + defaultConfig: (): OmpSettings => decodeOmpSettings({}), + create: Effect.fn("OmpDriver.create")(function* ({ + instanceId, + displayName, + accentColor, + environment, + enabled, + config, + }) { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + const httpClient = yield* HttpClient.HttpClient; + const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions; + const host = yield* ProviderHost.ProviderHost; + const { cwd } = host.paths; + const processEnv = yield* mergeProviderInstanceEnvironment(environment); + const continuationIdentity = defaultProviderContinuationIdentity({ + driverKind: DRIVER_KIND, + instanceId, + }); + const stampIdentity = withInstanceIdentity({ + instanceId, + displayName, + accentColor, + continuationGroupKey: continuationIdentity.continuationKey, + }); + const effectiveConfig = { ...config, enabled } satisfies OmpSettings; + const resolveMaintenance = yield* makeCachedProviderMaintenanceResolution( + resolveProviderMaintenanceCapabilitiesEffect(ompMaintenance, { + binaryPath: effectiveConfig.binaryPath, + env: processEnv, + }).pipe( + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, pathService), + ), + ); + + const orchestrationAdapter = yield* OmpAdapterV2Driver.create({ + instanceId, + displayName, + accentColor, + environment, + enabled, + config, + }).pipe( + Effect.mapError( + (cause) => + new ProviderDriverError({ + driver: DRIVER_KIND, + instanceId, + detail: "Failed to build Omp orchestration adapter.", + cause, + }), + ), + ); + const textGeneration = yield* makeOmpTextGeneration(effectiveConfig, processEnv); + + const checkProvider = checkOmpProviderStatus(effectiveConfig, processEnv, cwd).pipe( + Effect.map(stampIdentity), + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + ); + + const snapshotSettings = yield* makeProviderSnapshotSettingsSource(effectiveConfig); + const snapshot = yield* makeManagedServerProvider>({ + resolveMaintenance, + getSettings: snapshotSettings.getSettings, + streamSettings: snapshotSettings.streamSettings, + haveSettingsChanged: haveProviderSnapshotSettingsChanged, + initialSnapshot: (settings) => + buildInitialOmpProviderSnapshot(settings.provider).pipe(Effect.map(stampIdentity)), + checkProvider, + enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) => + resolveMaintenance().pipe( + Effect.flatMap((maintenanceCapabilities) => + enrichOmpSnapshot({ + snapshot: currentSnapshot, + maintenanceCapabilities, + enableProviderUpdateChecks: settings.enableProviderUpdateChecks, + publishSnapshot, + }), + ), + Effect.provideService(HttpClient.HttpClient, httpClient), + Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions), + ), + }).pipe( + Effect.mapError( + (cause) => + new ProviderDriverError({ + driver: DRIVER_KIND, + instanceId, + detail: "Failed to build Omp snapshot.", + cause, + }), + ), + ); + + return { + instanceId, + driverKind: DRIVER_KIND, + continuationIdentity, + displayName, + accentColor, + enabled, + snapshot, + snapshotForCwd: (workspaceCwd) => + !effectiveConfig.enabled + ? snapshot.getSnapshot + : Effect.all([ + snapshot.getSnapshot, + discoverOmpCommandsForCwd(effectiveConfig, processEnv, workspaceCwd).pipe( + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), + Effect.mapError( + (cause) => + new ProviderDriverError({ + driver: DRIVER_KIND, + instanceId, + detail: "Failed to discover Omp workspace commands.", + cause, + }), + ), + ), + ]).pipe( + Effect.map(([machineSnapshot, commands]) => ({ + ...machineSnapshot, + ...commands, + slashCommandsPending: false, + })), + ), + orchestrationAdapter, + textGeneration, + } satisfies ProviderInstance; + }), +}; diff --git a/packages/provider-omp/src/server/lifecycle.test.ts b/packages/provider-omp/src/server/lifecycle.test.ts new file mode 100644 index 0000000000000..47a97baebfb6f --- /dev/null +++ b/packages/provider-omp/src/server/lifecycle.test.ts @@ -0,0 +1,55 @@ +import { expect, it } from "@effect/vitest"; +import { isOmpSessionSettled, ompPromptFailure, ompForkMessageParent } from "./lifecycle.ts"; + +it("keeps yielded OMP turns open while background work remains", () => { + expect( + isOmpSessionSettled({ + isStreaming: false, + isSettled: false, + hasPendingAsyncWork: true, + queuedMessageCount: 0, + }), + ).toBe(false); + expect( + isOmpSessionSettled({ + isStreaming: false, + isSettled: true, + hasPendingAsyncWork: false, + queuedMessageCount: 0, + }), + ).toBe(true); + expect(isOmpSessionSettled({ isStreaming: false })).toBe(false); + expect( + isOmpSessionSettled({ + isStreaming: false, + isSettled: true, + hasPendingAsyncWork: false, + queuedMessageCount: 1, + }), + ).toBe(false); +}); +it("reads native prompt-result failures without interpreting acceptance as completion", () => { + expect(ompPromptFailure({ type: "response", command: "prompt", success: true })).toBeUndefined(); + expect( + ompPromptFailure({ + type: "prompt_result", + status: "error", + error: { message: "Cost cap reached" }, + }), + ).toBe("Cost cap reached"); + expect( + ompPromptFailure({ type: "prompt_result", status: "completed", sessionSettled: false }), + ).toBeUndefined(); +}); + +it("forks at the preceding message because native OMP rejects metadata entries", () => { + const entries = new Map([ + ["model", { parentId: null, isMessage: false }], + ["first", { parentId: "model", isMessage: true }], + ["answer", { parentId: "first", isMessage: true }], + ["settings", { parentId: "answer", isMessage: false }], + ["next", { parentId: "settings", isMessage: true }], + ]); + expect(ompForkMessageParent(entries, "first")).toBeNull(); + expect(ompForkMessageParent(entries, "next")).toBe("answer"); +}); diff --git a/packages/provider-omp/src/server/lifecycle.ts b/packages/provider-omp/src/server/lifecycle.ts new file mode 100644 index 0000000000000..9a8ed7267540f --- /dev/null +++ b/packages/provider-omp/src/server/lifecycle.ts @@ -0,0 +1,34 @@ +import { ompRecordField, ompRecordString } from "./rpc.ts"; + +export function isOmpSessionSettled(state: unknown): boolean { + return ( + ompRecordField(state, "isSettled") === true && + ompRecordField(state, "hasPendingAsyncWork") === false && + ompRecordField(state, "isStreaming") === false && + (ompRecordField(state, "queuedMessageCount") ?? 0) === 0 + ); +} + +export function ompPromptFailure(event: unknown): string | undefined { + if ( + ompRecordField(event, "type") !== "prompt_result" || + ompRecordField(event, "status") !== "error" + ) + return undefined; + return ompRecordString(ompRecordField(event, "error"), "message") ?? "OMP prompt failed."; +} + +export function ompForkMessageParent( + entries: ReadonlyMap, + boundaryId: string, +): string | null { + const visited = new Set(); + let current = entries.get(boundaryId)?.parentId ?? null; + while (current !== null && !visited.has(current)) { + visited.add(current); + const entry = entries.get(current); + if (entry?.isMessage) return current; + current = entry?.parentId ?? null; + } + return null; +} diff --git a/packages/provider-omp/src/server/maintenance.test.ts b/packages/provider-omp/src/server/maintenance.test.ts new file mode 100644 index 0000000000000..f31a97a703d6d --- /dev/null +++ b/packages/provider-omp/src/server/maintenance.test.ts @@ -0,0 +1,47 @@ +import { expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as NodeServices from "@effect/platform-node/NodeServices"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; +import { resolvePackageManagedProviderMaintenance } from "@t3tools/provider-core/server/maintenanceResolver"; +import { ompMaintenanceDefinition } from "./maintenance.ts"; + +it.effect.each([ + { + resolved: "/home/test/.bun/bin/omp", + real: "/home/test/.bun/bin/omp", + args: ["update"], + executable: "/home/test/.bun/bin/omp", + }, + { + resolved: "/usr/local/bin/omp", + real: "/usr/local/lib/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js", + args: [ + "install", + "-g", + "--prefix", + "/usr/local", + "--allow-scripts=@oh-my-pi/pi-coding-agent", + "@oh-my-pi/pi-coding-agent@latest", + ], + executable: "npm", + }, +])("resolves the OMP install owner without launching an update: $resolved", (fixture) => + Effect.gen(function* () { + const capabilities = yield* resolvePackageManagedProviderMaintenance(ompMaintenanceDefinition, { + binaryPath: fixture.resolved, + resolvedCommandPath: fixture.resolved, + realCommandPath: fixture.real, + env: {}, + platform: "darwin", + }); + expect(capabilities.packageName).toBe("@oh-my-pi/pi-coding-agent"); + expect(capabilities.update?.executable).toBe(fixture.executable); + expect(capabilities.update?.args).toEqual(fixture.args); + }).pipe( + Effect.provide(NodeServices.layer), + Effect.provideService( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make(() => Effect.die("Resolver must not run an update")), + ), + ), +); diff --git a/packages/provider-omp/src/server/maintenance.ts b/packages/provider-omp/src/server/maintenance.ts new file mode 100644 index 0000000000000..e31a0cef5a9ab --- /dev/null +++ b/packages/provider-omp/src/server/maintenance.ts @@ -0,0 +1,16 @@ +import { ProviderDriverKind } from "@t3tools/contracts"; +import { + makePackageManagedProviderMaintenanceResolver, + type PackageManagedProviderMaintenanceDefinition, +} from "@t3tools/provider-core/server/maintenanceResolver"; + +export const ompMaintenanceDefinition: PackageManagedProviderMaintenanceDefinition = { + provider: ProviderDriverKind.make("omp"), + npmPackageName: "@oh-my-pi/pi-coding-agent", + nativeUpdate: { + args: ["update"], + isCommandPath: (commandPath) => /(?:^|[\\/])omp(?:\.exe)?$/.test(commandPath), + }, +}; +export const ompMaintenance = + makePackageManagedProviderMaintenanceResolver(ompMaintenanceDefinition); diff --git a/packages/provider-omp/src/server/mcpExtensionSource.test.ts b/packages/provider-omp/src/server/mcpExtensionSource.test.ts new file mode 100644 index 0000000000000..bbfe5084caddc --- /dev/null +++ b/packages/provider-omp/src/server/mcpExtensionSource.test.ts @@ -0,0 +1,65 @@ +// @effect-diagnostics nodeBuiltinImport:off -- Execute the shipped extension at its native JavaScript boundary. +import { expect, it } from "@effect/vitest"; +import * as NodeModule from "node:module"; +import * as NodeVM from "node:vm"; +import { OMP_T3_MCP_EXTENSION_SOURCE } from "./mcpExtensionSource.ts"; + +it("registers MCP tools and blocks declined mutations through native confirmation", async () => { + type Hook = ( + event: { toolName: string; input: unknown }, + ctx: { ui: { confirm: () => Promise } }, + ) => Promise; + const hooks = new Map(); + const registered: Array<{ + name: string; + execute: (id: string, params: unknown) => Promise; + }> = []; + const calls: string[] = []; + const source = NodeModule.stripTypeScriptTypes( + OMP_T3_MCP_EXTENSION_SOURCE.replace(/^import .*;$/gm, "").replace( + "export default async function", + "async function", + ), + ); + await NodeVM.runInNewContext(`${source}\nt3McpExtension(omp)`, { + process: { + env: { + T3_MCP_URL: "https://fixture.invalid/mcp", + T3_MCP_BEARER_TOKEN: "fixture", + T3_OMP_RUNTIME_MODE: "approval-required", + }, + }, + AbortSignal, + Type: { Unsafe: (schema: unknown) => schema }, + omp: { + on: (name: string, hook: Hook) => hooks.set(name, hook), + registerTool: (tool: (typeof registered)[number]) => registered.push(tool), + }, + fetch: async (_url: string, options: { body: string }) => { + const request = JSON.parse(options.body) as { id: number; method: string }; + calls.push(request.method); + return new Response( + JSON.stringify({ + id: request.id, + result: + request.method === "tools/list" + ? { tools: [{ name: "write_note", inputSchema: { type: "object", properties: {} } }] } + : { content: [{ type: "text", text: "done" }] }, + }), + { headers: { "content-type": "application/json" } }, + ); + }, + }); + expect(registered.map((tool) => tool.name)).toEqual(["mcp__t3-code__write_note"]); + const hook = hooks.get("tool_call")!; + expect( + await hook({ toolName: "write", input: { path: "a" } }, { ui: { confirm: async () => false } }), + ).toEqual({ block: true, reason: "write was declined in T3 Code." }); + expect( + await hook({ toolName: "write", input: {} }, { ui: { confirm: async () => true } }), + ).toBeUndefined(); + expect(await registered[0]!.execute("tool-1", {})).toMatchObject({ + content: [{ type: "text", text: "done" }], + }); + expect(calls).toEqual(["initialize", "notifications/initialized", "tools/list", "tools/call"]); +}); diff --git a/packages/provider-omp/src/server/mcpExtensionSource.ts b/packages/provider-omp/src/server/mcpExtensionSource.ts new file mode 100644 index 0000000000000..6b42d056aeaf1 --- /dev/null +++ b/packages/provider-omp/src/server/mcpExtensionSource.ts @@ -0,0 +1,277 @@ +// No T3 imports inside the string; resolve Omp and typebox from the user's Omp install. +import { T3_CODE_ORCHESTRATION_INSTRUCTIONS } from "@t3tools/provider-core/server/orchestrationInstructions"; + +export const OMP_T3_MCP_EXTENSION_FILENAME = "omp-t3-mcp-extension.ts"; + +export const T3_MCP_URL_ENV = "T3_MCP_URL"; +export const T3_MCP_BEARER_ENV = "T3_MCP_BEARER_TOKEN"; +export const T3_OMP_RUNTIME_MODE_ENV = "T3_OMP_RUNTIME_MODE"; +export const T3_OMP_MCP_EXTENSION_PATH_ENV = "T3_OMP_MCP_EXTENSION_PATH"; + +// These tools trigger file-change approvals, bypassed by Auto-accept edits. +export const OMP_FILE_CHANGE_TOOLS = ["edit", "write"] as const; + +export const OMP_T3_MCP_EXTENSION_SOURCE = `\ +import { type ExtensionAPI } from "@oh-my-pi/pi-coding-agent"; +import * as NodeFSP from "node:fs/promises"; +import { Type } from "@sinclair/typebox"; + +const URL_ENV = ${JSON.stringify(T3_MCP_URL_ENV)}; +const TOKEN_ENV = ${JSON.stringify(T3_MCP_BEARER_ENV)}; +const RUNTIME_MODE_ENV = ${JSON.stringify(T3_OMP_RUNTIME_MODE_ENV)}; +const ORCHESTRATION_INSTRUCTIONS = ${JSON.stringify(T3_CODE_ORCHESTRATION_INSTRUCTIONS.trim())}; +const PROTOCOL = "2025-06-18"; +const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]); +const FILE_CHANGE_TOOLS = new Set(${JSON.stringify(OMP_FILE_CHANGE_TOOLS)}); + +type RuntimeMode = "approval-required" | "auto-accept-edits" | "auto" | "full-access"; + +type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue }; + +type JsonRpcResponse = { + readonly id?: number | string; + readonly result?: JsonValue; + readonly error?: { readonly message?: string }; +}; + +type McpTool = { + readonly name: string; + readonly description?: string; + readonly inputSchema?: Record; + readonly annotations?: { readonly readOnlyHint?: boolean }; + readonly outputSchema?: Record; +}; + +function env(name: string): string | undefined { + const value = process.env[name]; + return value && value.length > 0 ? value : undefined; +} + +function runtimeMode(): RuntimeMode { + const value = env(RUNTIME_MODE_ENV); + return value === "approval-required" || + value === "auto-accept-edits" || + value === "auto" || + value === "full-access" + ? value + : "full-access"; +} + +function toolInputSummary(input: unknown): string { + try { + return JSON.stringify(input, null, 2).slice(0, 4_000); + } catch { + return String(input).slice(0, 4_000); + } +} + +function parseSseOrJson(body: string, contentType: string): JsonRpcResponse { + if (contentType.includes("text/event-stream")) { + for (const line of body.split("\\n")) { + const trimmed = line.startsWith("data:") ? line.slice(5).trim() : ""; + if (trimmed.length === 0) continue; + const parsed = JSON.parse(trimmed) as JsonRpcResponse; + if (parsed.id !== undefined || parsed.result !== undefined || parsed.error !== undefined) { + return parsed; + } + } + throw new Error("MCP SSE response had no JSON-RPC payload."); + } + return JSON.parse(body) as JsonRpcResponse; +} + +function jsonSchemaToTypebox(schema: Record | undefined) { + const unsafe = (Type as { Unsafe?: (value: unknown) => unknown }).Unsafe; + if (typeof unsafe === "function" && schema !== undefined) { + // Zero-argument MCP tools may omit "properties", which some OpenAI-compatible + // servers reject. Declare it, as Omp does for its own MCP tools. + return unsafe({ + ...schema, + type: schema.type ?? "object", + ...(schema.properties === undefined ? { properties: {} } : {}), + }); + } + return Type.Object({}, { additionalProperties: true }); +} + +type ModelContent = + | { type: "text"; text: string } + | { type: "image"; data: string; mimeType: string }; + +function mcpModelContent(result: unknown): ModelContent[] { + if (result === null || result === undefined) return []; + if (typeof result !== "object") return [{ type: "text", text: String(result) }]; + const record = result as { + readonly content?: ReadonlyArray<{ + readonly type?: string; + readonly text?: string; + readonly data?: string; + readonly mimeType?: string; + }>; + readonly structuredContent?: unknown; + }; + const content: ModelContent[] = []; + if (Array.isArray(record.content)) { + for (const part of record.content) { + if (part?.type === "text" && typeof part.text === "string") { + content.push({ type: "text", text: part.text }); + } else if (part?.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string") { + content.push({ type: "image", data: part.data, mimeType: part.mimeType }); + } + } + } + // Structured output belongs to scripts. Only use it as model text when + // the server supplied no model-facing blocks, matching Omp's native MCP tools. + if (content.length === 0) { + content.push({ type: "text", text: JSON.stringify(record.structuredContent ?? result) }); + } + return content; +} + +function isMcpToolError(result: unknown): boolean { + return ( + typeof result === "object" && + result !== null && + "isError" in result && + result.isError === true + ); +} + +function createMcpClient(endpoint: string, token: string) { + let nextId = 1; + let sessionId: string | undefined; + + const headers = (): Record => { + const next: Record = { + accept: "application/json, text/event-stream", + authorization: token.startsWith("Bearer ") ? token : \`Bearer \${token}\`, + "content-type": "application/json", + // Effect's HTTP MCP rejects post-initialize requests without this + // (400). The worktree client in McpHttpServer tests sends the same + // header; initialize itself does not require it. + "mcp-protocol-version": PROTOCOL, + }; + if (sessionId !== undefined) next["mcp-session-id"] = sessionId; + return next; + }; + + const request = async (method: string, params?: unknown, signal?: AbortSignal) => { + const id = nextId++; + const response = await fetch(endpoint, { + method: "POST", + headers: headers(), + body: JSON.stringify({ jsonrpc: "2.0", id, method, params }), + signal, + }); + const nextSession = response.headers.get("mcp-session-id"); + if (nextSession) sessionId = nextSession; + const body = await response.text(); + if (!response.ok) { + throw new Error(\`MCP \${method} failed (\${response.status}): \${body.slice(0, 400)}\`); + } + if (body.length === 0) return undefined; + const parsed = parseSseOrJson(body, response.headers.get("content-type") ?? ""); + if (parsed.error) { + throw new Error(parsed.error.message ?? \`MCP \${method} returned an error\`); + } + return parsed.result; + }; + + const notify = async (method: string, params?: unknown, signal?: AbortSignal) => { + await fetch(endpoint, { + method: "POST", + headers: headers(), + body: JSON.stringify({ jsonrpc: "2.0", method, params }), + signal, + }); + }; + + return { + async connect(signal?: AbortSignal) { + await request( + "initialize", + { + protocolVersion: PROTOCOL, + capabilities: {}, + clientInfo: { name: "t3-omp-mcp", version: "1.0.0" }, + }, + signal, + ); + await notify("notifications/initialized", {}, signal).catch(() => undefined); + }, + async listTools(signal?: AbortSignal) { + const tools: McpTool[] = []; + let cursor: string | undefined; + do { + const result = (await request( + "tools/list", + cursor === undefined ? {} : { cursor }, + signal, + )) as { tools?: McpTool[]; nextCursor?: string } | undefined; + tools.push(...(result?.tools ?? [])); + cursor = result?.nextCursor; + } while (cursor); + return tools; + }, + async callTool(name: string, args: Record, signal?: AbortSignal) { + return request("tools/call", { name, arguments: args }, signal); + }, + }; +} + +export default async function t3McpExtension(omp: ExtensionAPI) { + omp.on("input", async (event) => { + if (!event.text.includes("$")) return; + const commands = omp.getCommands().filter((command) => command.source === "skill"); + const blocks: string[] = []; + const seen = new Set(); + for (const match of event.text.matchAll(/(^|\\s)\\$([^\\s]+)(?=\\s|$)/g)) { + const name = match[2]; + if (!name || seen.has(name)) continue; + const command = commands.find((candidate) => candidate.name === "skill:" + name || candidate.name === name); + const path = command?.sourceInfo?.path ?? command?.path; + if (!path) continue; + seen.add(name); + const body = await NodeFSP.readFile(path, "utf8"); + blocks.push(\`\\n\${body}\\n\`); + } + if (blocks.length > 0) return { action: "transform", text: event.text + "\\n\\n" + blocks.join("\\n\\n"), images: event.images }; + }); + const readOnlyMcpTools = new Set(); + omp.on("tool_call", async (event, ctx) => { + const mode = runtimeMode(); + if (mode === "full-access" || READ_ONLY_TOOLS.has(event.toolName) || readOnlyMcpTools.has(event.toolName)) return; + if (mode === "auto-accept-edits" && FILE_CHANGE_TOOLS.has(event.toolName)) return; + const approved = await ctx.ui.confirm( + \`Allow \${event.toolName}?\`, toolInputSummary(event.input), { signal: ctx.signal }, + ); + if (!approved) return { block: true, reason: \`\${event.toolName} was declined in T3 Code.\` }; + }); + const endpoint = env(URL_ENV); + const token = env(TOKEN_ENV); + if (endpoint === undefined || token === undefined) return; + const client = createMcpClient(endpoint, token); + await client.connect(AbortSignal.timeout(10_000)); + const catalog = await client.listTools(AbortSignal.timeout(10_000)); + for (const tool of catalog) { + const name = "mcp__t3-code__" + tool.name; + if (tool.annotations?.readOnlyHint === true) readOnlyMcpTools.add(name); + omp.registerTool({ + name, label: tool.name, description: tool.description ?? tool.name, + parameters: jsonSchemaToTypebox(tool.inputSchema), + loadMode: ["orchestrator_capabilities", "delegate_task", "task_status"].includes(tool.name) ? "essential" : "discoverable", + approval: tool.annotations?.readOnlyHint === true ? "read" : "exec", + async execute(_toolCallId, params, signal) { + const result = await client.callTool(tool.name, (params ?? {}) as Record, signal); + return { + content: mcpModelContent(result), details: { server: "t3-code", tool: tool.name }, + ...(isMcpToolError(result) ? { isError: true } : {}), + }; + }, + }); + } + omp.on("before_agent_start", (event) => ({ + systemPrompt: event.systemPrompt + "\\n\\n" + ORCHESTRATION_INSTRUCTIONS, + })); +} +`; diff --git a/packages/provider-omp/src/server/mcpInjection.ts b/packages/provider-omp/src/server/mcpInjection.ts new file mode 100644 index 0000000000000..288911ade81c0 --- /dev/null +++ b/packages/provider-omp/src/server/mcpInjection.ts @@ -0,0 +1,325 @@ +import { tokenizeCliArgs } from "@t3tools/shared/cliArgs"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; + +import type { McpProviderSessionConfig } from "@t3tools/provider-core/server/mcpSession"; +import { + OMP_T3_MCP_EXTENSION_FILENAME, + OMP_T3_MCP_EXTENSION_SOURCE, + T3_MCP_BEARER_ENV, + T3_MCP_URL_ENV, + T3_OMP_RUNTIME_MODE_ENV, + T3_OMP_MCP_EXTENSION_PATH_ENV, +} from "./mcpExtensionSource.ts"; + +const RESERVED_OMP_LAUNCH_ARGUMENTS = new Set([ + "--continue", + "-c", + "--export", + "--fork", + "--help", + "-h", + "--list-models", + "--mode", + "--no-session", + "--print", + "-p", + "--resume", + "-r", + "--session", + "--session-id", + "--version", + "-v", +]); + +export const OMP_ARGUMENTS_WITH_VALUES = new Set([ + "--api-key", + "--append-system-prompt", + "--exclude-tools", + "-xt", + "--extension", + "-e", + "--model", + "--models", + "--name", + "-n", + "--prompt-template", + "--provider", + "--session-dir", + "--skill", + "--system-prompt", + "--theme", + "--thinking", + "--tools", + "-t", + "--tui-mode", + "--use-theme", +]); + +const OMP_ARGUMENTS_WITHOUT_VALUES = new Set([ + "--approve", + "-a", + "--no-approve", + "-na", + "--no-builtin-tools", + "-nbt", + "--no-context-files", + "-nc", + "--no-extensions", + "-ne", + "--no-prompt-templates", + "-np", + "--no-skills", + "-ns", + "--no-themes", + "--no-tools", + "-nt", + "--offline", + "--verbose", +]); + +export type OmpLaunchArgsResolution = + | { readonly ok: true; readonly args: ReadonlyArray } + | { readonly ok: false; readonly message: string }; + +function reservedOmpArgument(arg: string): string | undefined { + for (const reserved of RESERVED_OMP_LAUNCH_ARGUMENTS) { + if (arg === reserved || (reserved.startsWith("--") && arg.startsWith(`${reserved}=`))) { + return reserved; + } + } + return undefined; +} + +function normalizeOmpBuiltInEqualsArguments(args: ReadonlyArray): ReadonlyArray { + return args.flatMap((arg) => { + const equalsIndex = arg.indexOf("="); + if (equalsIndex <= 0) return [arg]; + const option = arg.slice(0, equalsIndex); + return OMP_ARGUMENTS_WITH_VALUES.has(option) ? [option, arg.slice(equalsIndex + 1)] : [arg]; + }); +} + +export function resolveOmpLaunchArgs(launchArgs: string): OmpLaunchArgsResolution { + // Omp treats equals-form tokens as extension flags; split only known built-ins. + const args = normalizeOmpBuiltInEqualsArguments(tokenizeCliArgs(launchArgs)); + let hasProvider = false; + let hasModel = false; + for (let index = 0; index < args.length; index += 1) { + const arg = args[index]; + if (arg === undefined) continue; + const reserved = reservedOmpArgument(arg); + if (reserved !== undefined) { + return { + ok: false, + message: `Omp launch argument '${reserved}' is controlled by T3 Code and cannot be overridden.`, + }; + } + if (arg === "--") { + return { + ok: false, + message: "Omp launch arguments cannot include positional prompts.", + }; + } + if (OMP_ARGUMENTS_WITH_VALUES.has(arg)) { + const value = args[index + 1]; + if (value === undefined) { + return { ok: false, message: `Omp launch argument '${arg}' requires a value.` }; + } + if (arg === "--provider") hasProvider = true; + if (arg === "--model") hasModel = true; + index += 1; + continue; + } + if (OMP_ARGUMENTS_WITHOUT_VALUES.has(arg) || (arg.startsWith("--") && arg.includes("="))) { + continue; + } + if (arg.startsWith("--")) { + // Arbitrary extension flags may consume one following non-flag token. + if ( + args[index + 1] !== undefined && + !args[index + 1]!.startsWith("-") && + !args[index + 1]!.startsWith("@") + ) { + index += 1; + } + continue; + } + if (arg.startsWith("-")) { + return { ok: false, message: `Omp launch argument '${arg}' is not supported by T3 Code.` }; + } + return { + ok: false, + message: `Omp launch arguments cannot include positional prompt '${arg}'.`, + }; + } + if (hasProvider && !hasModel) { + return { ok: false, message: "Omp launch argument '--provider' requires '--model'." }; + } + return { ok: true, args }; +} + +function bearerTokenFromAuthorizationHeader(header: string): string { + return header.startsWith("Bearer ") ? header.slice("Bearer ".length) : header; +} + +function normalizedOmpPath(value: string): string { + return value.replace(/\\/g, "/").replace(/\/+$/, ""); +} + +function hasExplicitExtension(args: ReadonlyArray, extensionPath: string): boolean { + const wanted = normalizedOmpPath(extensionPath); + for (let index = 0; index < args.length; index += 1) { + const arg = args[index]; + if (arg !== "--extension" && arg !== "-e") continue; + const configured = args[index + 1]; + if (configured !== undefined && normalizedOmpPath(configured) === wanted) return true; + index += 1; + } + return false; +} + +function withoutExplicitExtensions(args: ReadonlyArray): ReadonlyArray { + const filtered: string[] = []; + for (let index = 0; index < args.length; index += 1) { + const arg = args[index]; + if (arg === undefined) continue; + if (arg === "--extension" || arg === "-e") { + index += 1; + continue; + } + if (arg.startsWith("--extension=") || arg.startsWith("-e=")) continue; + filtered.push(arg); + } + return filtered; +} + +function withoutToolSelectionArgs(args: ReadonlyArray): ReadonlyArray { + const filtered: string[] = []; + for (let index = 0; index < args.length; index += 1) { + const arg = args[index]; + if (arg === undefined) continue; + if (arg === "--tools" || arg === "-t" || arg === "--exclude-tools" || arg === "-xt") { + index += 1; + continue; + } + if ( + arg === "--no-tools" || + arg === "-nt" || + arg === "--no-builtin-tools" || + arg === "-nbt" || + arg.startsWith("--tools=") || + arg.startsWith("-t=") || + arg.startsWith("--exclude-tools=") || + arg.startsWith("-xt=") + ) { + continue; + } + filtered.push(arg); + } + return filtered; +} + +function ompT3McpExtensionDestPath(cacheDir: string): string { + return `${cacheDir.replace(/\\/g, "/")}/${OMP_T3_MCP_EXTENSION_FILENAME}`; +} + +export const materializeOmpT3McpExtension = Effect.fn("materializeOmpT3McpExtension")(function* ( + cacheDir: string, +) { + const fs = yield* FileSystem.FileSystem; + yield* fs.makeDirectory(cacheDir, { recursive: true }); + const dest = ompT3McpExtensionDestPath(cacheDir); + const existing = yield* fs.readFileString(dest).pipe(Effect.orElseSucceed(() => "")); + if (existing !== OMP_T3_MCP_EXTENSION_SOURCE) { + // Concurrent omp launches read this file: stage it in a per-call directory + // and rename so readers and other writers never see a partial file. + yield* Effect.scoped( + Effect.gen(function* () { + const stagingDir = yield* fs.makeTempDirectoryScoped({ directory: cacheDir }); + const staging = `${stagingDir.replace(/\\/g, "/")}/${OMP_T3_MCP_EXTENSION_FILENAME}`; + yield* fs.writeFileString(staging, OMP_T3_MCP_EXTENSION_SOURCE); + yield* fs.rename(staging, dest).pipe(Effect.retry({ times: 3 })); + }), + ); + } + return dest; +}); + +export function buildOmpRpcLaunch(input: { + readonly launchArgs: ReadonlyArray; + readonly environment: NodeJS.ProcessEnv; + readonly mcpSession: McpProviderSessionConfig | undefined; + readonly extensionPath: string | undefined; + readonly sessionPath?: string | undefined; + readonly ephemeral?: boolean; + // T3 stops these processes as soon as they answer. They run --offline because Omp's startup + // catalog refresh renews expired OAuth tokens, and a stop mid-request loses the rotated one. + readonly shortLived?: boolean; + readonly disableExtensions?: boolean; + readonly disableTools?: boolean; + readonly runtimeMode?: "approval-required" | "auto-accept-edits" | "auto" | "full-access"; +}): { + readonly args: ReadonlyArray; + readonly env: NodeJS.ProcessEnv; +} { + const hasT3Extension = input.disableExtensions !== true && input.extensionPath !== undefined; + const hasT3Mcp = hasT3Extension && input.mcpSession !== undefined; + const extensionSafeArgs = + input.disableExtensions === true + ? withoutExplicitExtensions(input.launchArgs) + : input.launchArgs; + const launchArgs = + input.disableTools === true ? withoutToolSelectionArgs(extensionSafeArgs) : extensionSafeArgs; + const args = [ + "--mode", + "rpc-ui", + ...(input.ephemeral === true + ? ["--no-session"] + : input.sessionPath !== undefined + ? ["--resume", input.sessionPath] + : []), + ...launchArgs, + "--no-title", + "--no-lsp", + // Restrictions must follow launch args so user flags cannot re-enable unattended tools/extensions. + ...(input.disableExtensions === true ? ["--no-extensions"] : []), + ...(input.disableTools === true ? ["--no-tools"] : []), + ]; + if ( + hasT3Extension && + input.extensionPath !== undefined && + !hasExplicitExtension(args, input.extensionPath) + ) { + args.push("--extension", input.extensionPath); + } + const environment = { ...input.environment }; + // MCP credentials belong to this T3 session; discard inherited server/parent credentials. + delete environment[T3_MCP_URL_ENV]; + delete environment[T3_MCP_BEARER_ENV]; + delete environment[T3_OMP_MCP_EXTENSION_PATH_ENV]; + + return { + args, + env: { + ...environment, + ...(hasT3Extension && input.extensionPath !== undefined + ? { [T3_OMP_MCP_EXTENSION_PATH_ENV]: input.extensionPath } + : {}), + ...(hasT3Extension && input.runtimeMode !== undefined + ? { + [T3_OMP_RUNTIME_MODE_ENV]: + input.runtimeMode === "auto" ? "approval-required" : input.runtimeMode, + } + : {}), + ...(hasT3Mcp && input.mcpSession !== undefined + ? { + [T3_MCP_URL_ENV]: input.mcpSession.endpoint, + [T3_MCP_BEARER_ENV]: bearerTokenFromAuthorizationHeader( + input.mcpSession.authorizationHeader, + ), + } + : {}), + }, + }; +} diff --git a/packages/provider-omp/src/server/questions.test.ts b/packages/provider-omp/src/server/questions.test.ts new file mode 100644 index 0000000000000..a6589475df31b --- /dev/null +++ b/packages/provider-omp/src/server/questions.test.ts @@ -0,0 +1,23 @@ +import { expect, it } from "@effect/vitest"; +import { ompAskQuestions, ompAskResponse } from "./questions.ts"; +it("preserves native ask order, multi selection, custom input and cancellation", () => { + const questions = ompAskQuestions({ + questions: [ + { + id: "scope", + question: "Which scopes?", + multi: true, + options: [{ label: "Web" }, { label: "Mobile" }], + }, + { id: "name", question: "Name?", options: [] }, + ], + }); + expect(questions[0]?.multiSelect).toBe(true); + expect(ompAskResponse(questions, { name: "Demo", scope: ["Web", "Mobile"] })).toEqual({ + answers: [ + { id: "scope", selectedOptions: ["Web", "Mobile"] }, + { id: "name", selectedOptions: [], customInput: "Demo" }, + ], + }); + expect(ompAskResponse(questions, undefined)).toEqual({ cancelled: true }); +}); diff --git a/packages/provider-omp/src/server/questions.ts b/packages/provider-omp/src/server/questions.ts new file mode 100644 index 0000000000000..f938770828e2c --- /dev/null +++ b/packages/provider-omp/src/server/questions.ts @@ -0,0 +1,51 @@ +import type { OrchestrationV2UserInputQuestion } from "@t3tools/contracts"; +import { ompRecordField as field, ompRecordString as string } from "./rpc.ts"; + +export function ompAskQuestions(event: unknown): ReadonlyArray { + const questions = field(event, "questions"); + if (!Array.isArray(questions)) return []; + return questions.flatMap((question) => { + const id = string(question, "id"); + const text = string(question, "question"); + if (!id || !text) return []; + const options = field(question, "options"); + return [ + { + id, + header: string(question, "header") ?? "Question", + question: text, + multiSelect: field(question, "multi") === true, + allowCustomAnswer: true, + options: Array.isArray(options) + ? options.flatMap((option) => { + const label = string(option, "label"); + return label + ? [{ label, value: label, description: string(option, "description") ?? label }] + : []; + }) + : [], + }, + ]; + }); +} + +export function ompAskResponse( + questions: ReadonlyArray, + answers: Record | undefined, +) { + if (answers === undefined) return { cancelled: true }; + return { + answers: questions.map((question) => { + const answer = answers[question.id]; + const values = Array.isArray(answer) + ? answer.filter((value): value is string => typeof value === "string") + : typeof answer === "string" + ? [answer] + : []; + const labels = new Set(question.options.map((option) => option.label)); + const selectedOptions = values.filter((value) => labels.has(value)); + const customInput = values.filter((value) => !labels.has(value)).join("\n"); + return { id: question.id, selectedOptions, ...(customInput ? { customInput } : {}) }; + }), + }; +} diff --git a/packages/provider-omp/src/server/rpc.ts b/packages/provider-omp/src/server/rpc.ts new file mode 100644 index 0000000000000..ffe49fcd75ccc --- /dev/null +++ b/packages/provider-omp/src/server/rpc.ts @@ -0,0 +1,449 @@ +// Omp frames are LF-delimited with trailing CR stripped; readline also splits U+2028/U+2029 and corrupts them. +import * as Clock from "effect/Clock"; +import * as Deferred from "effect/Deferred"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Predicate from "effect/Predicate"; +import * as Queue from "effect/Queue"; +import * as Scope from "effect/Scope"; +import * as Schema from "effect/Schema"; +import * as Stream from "effect/Stream"; +import * as ChildProcess from "effect/process/ChildProcess"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import { resolveSpawnCommand } from "@t3tools/shared/shell"; +import { + MAX_TOOL_OUTPUT_IMAGES, + MAX_TOOL_OUTPUT_IMAGE_BASE64_LENGTH, +} from "@t3tools/shared/toolOutput"; + +import { signalProcessGroup } from "@t3tools/provider-core/server/processGroup"; + +export class OmpRpcError extends Schema.TaggedError()("OmpRpcError", { + operation: Schema.String, + detail: Schema.optional(Schema.String), + cause: Schema.optional(Schema.Defect()), +}) { + override get message(): string { + return `Omp RPC ${this.operation} failed${this.detail === undefined ? "" : `: ${this.detail}`}.`; + } +} + +export class OmpRpcTimeoutError extends Schema.TaggedError()( + "OmpRpcTimeoutError", + { + operation: Schema.String, + timeoutMs: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER })), + }, +) { + override get message(): string { + return `Omp RPC ${this.operation} failed: timed out after ${this.timeoutMs}ms.`; + } +} + +export type OmpRpcRecord = Record; + +export function ompRecordField(input: unknown, key: string): unknown { + return Predicate.isObject(input) ? input[key] : undefined; +} + +export function ompRecordString(input: unknown, key: string): string | undefined { + const value = ompRecordField(input, key); + return Predicate.isString(value) ? value : undefined; +} + +export function ompRecordNumber(input: unknown, key: string): number | undefined { + const value = ompRecordField(input, key); + return Predicate.isNumber(value) && Number.isFinite(value) ? value : undefined; +} + +export function parseOmpModelSlug(slug: string): { provider: string; modelId: string } | null { + const separator = slug.indexOf("/"); + if (separator <= 0 || separator === slug.length - 1) return null; + return { provider: slug.slice(0, separator), modelId: slug.slice(separator + 1) }; +} + +export interface OmpRpcSpawnOptions { + readonly command: string; + readonly requiredExtensionPath?: string; + readonly args: ReadonlyArray; + readonly cwd: string | undefined; + readonly env: NodeJS.ProcessEnv; +} + +export interface OmpRpcConnection { + readonly send: (record: OmpRpcRecord) => Effect.Effect; + readonly request: ( + record: OmpRpcRecord, + timeoutMs?: number, + ) => Effect.Effect; + readonly events: Queue.Queue; + readonly exited: Effect.Effect; + readonly terminate: Effect.Effect; +} + +const DEFAULT_REQUEST_TIMEOUT_MS = 30_000; +const TERMINATION_GRACE = Duration.seconds(1); + +interface PendingOmpRequest { + readonly deferred: Deferred.Deferred; +} + +// MCP duplicates images in model content and CallToolResult; budget both plus bounded overhead. +const MAX_OMP_RECORD_CHARS = + 2 * MAX_TOOL_OUTPUT_IMAGES * MAX_TOOL_OUTPUT_IMAGE_BASE64_LENGTH + 8 * 1024 * 1024; + +function makeJsonlFramer() { + let buffer = ""; + let dropping = false; + return (chunk: string) => { + const lines: string[] = []; + const droppedLengths: number[] = []; + let start = 0; + while (start < chunk.length) { + const newline = chunk.indexOf("\n", start); + const end = newline < 0 ? chunk.length : newline; + if (!dropping) { + if (buffer.length + end - start > MAX_OMP_RECORD_CHARS) { + droppedLengths.push(buffer.length + end - start); + buffer = ""; + dropping = true; + } else { + buffer += chunk.slice(start, end); + } + } + if (newline < 0) break; + if (!dropping && buffer.length > 0) { + lines.push(buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer); + } + buffer = ""; + dropping = false; + start = newline + 1; + } + return { lines, droppedLengths }; + }; +} + +// Report the observed length before LF arrives; an unterminated response can time out first. +const logDroppedOmpRecords = (droppedLengths: ReadonlyArray) => + Effect.forEach( + droppedLengths, + (recordLength) => + Effect.logWarning("Dropping oversized omp stdout record.", { + recordLength, + maxRecordLength: MAX_OMP_RECORD_CHARS, + }), + { discard: true }, + ); + +const UnknownFromJsonString = Schema.fromJsonString(Schema.Unknown); +const decodeJsonLine = Schema.decodeSync(UnknownFromJsonString); +const encodeJsonLine = Schema.encodeSync(UnknownFromJsonString); + +const OMP_ERROR_DETAIL_MAX_CHARS = 200; + +function summarizeOmpError(error: unknown): string { + const text = typeof error === "string" ? error : JSON.stringify(error); + if (text === undefined) return "unknown error"; + return text.length > OMP_ERROR_DETAIL_MAX_CHARS + ? `${text.slice(0, OMP_ERROR_DETAIL_MAX_CHARS)}…` + : text; +} + +function describeOmpStdoutClosure(exitCode: number | undefined): string { + if (exitCode === undefined || !Number.isFinite(exitCode)) { + return "omp process closed stdout"; + } + return `omp process exited with code ${exitCode}`; +} + +function parseOmpRecord(line: string): OmpRpcRecord | undefined { + try { + const parsed: unknown = decodeJsonLine(line); + return Predicate.isObject(parsed) ? parsed : undefined; + } catch { + return undefined; + } +} + +/** + * `hasExited` is consulted before each signal. Once the original child is + * gone its pid/pgid can be recycled by the OS, so escalating blindly could + * deliver SIGKILL to an unrelated process. + */ +const terminateOmpProcess = Effect.fn("OmpRpc.terminateOmpProcess")(function* ( + kill: (signal: NodeJS.Signals) => boolean, + hasExited: () => boolean, +) { + if (hasExited()) return; + if (!kill("SIGTERM")) return; + yield* Effect.sleep(TERMINATION_GRACE); + if (hasExited()) return; + kill("SIGKILL"); +}); + +export const makeOmpRpcConnection = Effect.fnUntraced(function* (options: OmpRpcSpawnOptions) { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const platform = yield* HostProcess.Platform; + const scope = yield* Effect.scope; + + const spawnCommand = yield* resolveSpawnCommand(options.command, [...options.args], { + env: options.env, + }).pipe(Effect.mapError((cause) => new OmpRpcError({ operation: "spawn", cause }))); + const child = yield* spawner + .spawn( + ChildProcess.make(spawnCommand.command, spawnCommand.args, { + ...(options.cwd === undefined ? {} : { cwd: options.cwd }), + env: options.env, + extendEnv: false, + shell: spawnCommand.shell, + detached: platform !== "win32", + // On stdin EOF Omp quits without its SIGTERM handler, so the later SIGTERM kills it mid-cleanup. + stdin: { stream: "pipe", endOnDone: false }, + }), + ) + .pipe(Effect.mapError((cause) => new OmpRpcError({ operation: "spawn", cause }))); + + let childExited = false; + let diagnosingStdoutClose = false; + + const killProcessGroup = (signal: NodeJS.Signals): boolean => { + try { + if (platform === "win32") { + process.kill(Number(child.pid), signal); + } else { + signalProcessGroup(Number(child.pid), signal); + } + return true; + } catch { + return false; + } + }; + + const hasExited = (): boolean => { + if (childExited) return true; + try { + if (platform === "win32") process.kill(Number(child.pid), 0); + else signalProcessGroup(Number(child.pid), 0); + return false; + } catch { + return true; + } + }; + + // Windows process.kill leaves extension children and pipes alive; taskkill /T reaps the tree. + const terminateWindowsTree = Effect.gen(function* () { + if (hasExited()) return; + const taskkill = yield* spawner.spawn( + ChildProcess.make("taskkill", ["/PID", String(child.pid), "/T", "/F"]), + ); + yield* taskkill.exitCode; + }).pipe(Effect.scoped, Effect.ignore); + + const terminateProcess = + platform === "win32" ? terminateWindowsTree : terminateOmpProcess(killProcessGroup, hasExited); + + // Register teardown immediately after spawn so interrupted setup cannot leak a detached process. + yield* Scope.addFinalizer(scope, terminateProcess.pipe(Effect.ignore, Effect.uninterruptible)); + + const pendingRequests = new Map(); + const events = yield* Queue.unbounded(); + const outgoing = yield* Queue.unbounded(); + const transportDown = yield* Deferred.make(); + const exitDeferred = yield* Deferred.make(); + let nextRequestId = 0; + + const failTransport = Effect.fn("OmpRpc.failTransport")(function* (error: OmpRpcError) { + const claimed = yield* Deferred.fail(transportDown, error); + if (!claimed) return; + for (const [key, pending] of pendingRequests) { + pendingRequests.delete(key); + yield* Deferred.fail(pending.deferred, error); + } + yield* Queue.fail(outgoing, error); + yield* Queue.fail(events, error); + }); + + const routeRecord = + /* Protocol records and writes include streaming deltas; avoid a span per record. */ + Effect.fnUntraced(function* (record: OmpRpcRecord) { + if (record["type"] === "response" && typeof record["id"] === "string") { + const pending = pendingRequests.get(record["id"]); + if (pending !== undefined) { + pendingRequests.delete(record["id"]); + if (record["success"] === true) { + yield* Deferred.succeed(pending.deferred, record["data"]); + } else { + yield* Deferred.fail( + pending.deferred, + new OmpRpcError({ + operation: String(record["command"] ?? "request"), + detail: summarizeOmpError(record["error"]), + ...(record["error"] === undefined ? {} : { cause: record["error"] }), + }), + ); + } + return; + } + } + yield* Queue.offer(events, record); + }); + + // Watch exit before reading stdout so immediate crashes populate exitDeferred for diagnosis. + yield* child.exitCode.pipe( + Effect.matchEffect({ + onFailure: (cause) => + Deferred.fail(exitDeferred, new OmpRpcError({ operation: "exit", cause })), + onSuccess: (code) => + Effect.suspend(() => { + childExited = true; + return Deferred.succeed(exitDeferred, Number(code)); + }), + }), + Effect.forkIn(scope), + ); + + yield* Effect.gen(function* () { + const frame = makeJsonlFramer(); + yield* child.stdout.pipe( + Stream.decodeText(), + Stream.runForEach((chunk) => + Effect.gen(function* () { + const { lines, droppedLengths } = frame(chunk); + yield* logDroppedOmpRecords(droppedLengths); + for (const line of lines) { + const record = parseOmpRecord(line); + if (record === undefined) { + yield* Effect.logDebug("Dropping non-JSON omp stdout line.", { + lineLength: line.length, + }); + continue; + } + yield* routeRecord(record); + } + }), + ), + ); + const flushed = frame("\n"); + yield* logDroppedOmpRecords(flushed.droppedLengths); + for (const line of flushed.lines) { + const trailing = parseOmpRecord(line); + if (trailing !== undefined) yield* routeRecord(trailing); + } + }).pipe( + Effect.matchCauseEffect({ + onFailure: (cause) => failTransport(new OmpRpcError({ operation: "read", cause })), + // The enclosing operation owns the span for this inline handler. + onSuccess: Effect.fnUntraced(function* () { + // Claim stdout-close diagnosis before waiting so broken stdin cannot replace the exit error. + diagnosingStdoutClose = true; + const polled = yield* Deferred.poll(exitDeferred); + const maybeExitCode = Option.isSome(polled) + ? yield* polled.value.pipe( + Effect.asSome, + Effect.orElseSucceed(() => Option.none()), + ) + : yield* Deferred.await(exitDeferred).pipe( + Effect.timeoutOption(Duration.millis(250)), + // Stdout-close waits need wall time; TestClock would strand Stop-with-restart without an exit. + Effect.provideService(Clock.Clock, Clock.Clock.defaultValue()), + Effect.orElseSucceed(() => Option.none()), + ); + return yield* failTransport( + new OmpRpcError({ + operation: "read", + detail: describeOmpStdoutClosure( + Option.isSome(maybeExitCode) ? maybeExitCode.value : undefined, + ), + }), + ); + }), + }), + Effect.forkIn(scope), + ); + + let stderrTail = ""; + yield* child.stderr.pipe( + Stream.decodeText(), + Stream.runForEach((chunk) => { + stderrTail = (stderrTail + chunk).slice(-8192); + if ( + options.requiredExtensionPath !== undefined && + stderrTail.includes("Failed to load extension") && + stderrTail.includes(options.requiredExtensionPath) + ) { + return failTransport( + new OmpRpcError({ + operation: "extension", + detail: "OMP could not load the T3 permission and MCP bridge.", + }), + ); + } + return chunk.trim().length === 0 + ? Effect.void + : Effect.logDebug("omp stderr", { stderrLength: chunk.length }); + }), + Effect.ignore, + Effect.forkIn(scope), + ); + + // Start the reader first so stdout-close diagnosis can win over broken-pipe stdin. + yield* Stream.fromQueue(outgoing).pipe( + Stream.run(child.stdin), + Effect.catchCause((cause) => + diagnosingStdoutClose + ? Effect.void + : failTransport(new OmpRpcError({ operation: "write", cause })), + ), + Effect.forkIn(scope), + ); + + const send = + /* Protocol records and writes include streaming deltas; avoid a span per record. */ + Effect.fnUntraced(function* (record: OmpRpcRecord): Effect.fn.Return { + const accepted = yield* Queue.offer( + outgoing, + new TextEncoder().encode(`${encodeJsonLine(record)}\n`), + ); + if (!accepted) { + return yield* Deferred.await(transportDown); + } + }); + + const request = Effect.fn("OmpRpc.request")(function* ( + record: OmpRpcRecord, + timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, + ): Effect.fn.Return { + const id = `t3-${nextRequestId++}`; + const deferred = yield* Deferred.make(); + pendingRequests.set(id, { deferred }); + yield* send({ ...record, id }).pipe( + Effect.tapError(() => Effect.sync(() => pendingRequests.delete(id))), + ); + return yield* Effect.raceFirst(Deferred.await(deferred), Deferred.await(transportDown)).pipe( + Effect.timeoutOrElse({ + duration: Duration.millis(timeoutMs), + orElse: () => + Effect.fail( + new OmpRpcTimeoutError({ + operation: String(record["type"] ?? "request"), + timeoutMs, + }), + ), + }), + Effect.onInterrupt(() => Effect.sync(() => pendingRequests.delete(id))), + Effect.onError(() => Effect.sync(() => pendingRequests.delete(id))), + ); + }); + + return { + send, + request, + events, + exited: Deferred.await(exitDeferred), + terminate: failTransport( + new OmpRpcError({ operation: "terminate", detail: "omp process was stopped" }), + ).pipe(Effect.andThen(terminateProcess), Effect.ignore, Effect.uninterruptible), + } satisfies OmpRpcConnection; +}); diff --git a/packages/provider-omp/src/server/status.ts b/packages/provider-omp/src/server/status.ts new file mode 100644 index 0000000000000..cc0f111eb6cd9 --- /dev/null +++ b/packages/provider-omp/src/server/status.ts @@ -0,0 +1,491 @@ +import { + type CustomModelSetting, + type ServerProvider, + type ServerProviderModel, +} from "@t3tools/contracts"; +import type { OmpSettings } from "../settings.ts"; +import { causeErrorTag } from "@t3tools/shared/observability"; +import { resolveSpawnCommand } from "@t3tools/shared/shell"; +import { compareSemverVersions } from "@t3tools/shared/semver"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Stream from "effect/Stream"; +import * as Exit from "effect/Exit"; +import * as Option from "effect/Option"; +import * as Result from "effect/Result"; +import * as HttpClient from "effect/http/HttpClient"; +import * as ChildProcess from "effect/process/ChildProcess"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; + +import { buildOmpRpcLaunch, resolveOmpLaunchArgs } from "./mcpInjection.ts"; +import { + makeOmpRpcConnection, + OmpRpcError, + OmpRpcTimeoutError, + ompRecordField as recordField, + ompRecordString as recordString, +} from "./rpc.ts"; +import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; +import { + buildServerProvider, + isCommandMissingCause, + parseGenericCliVersion, + providerModelsFromSettings, + spawnAndCollect, + type ServerProviderDraft, +} from "@t3tools/provider-core/server/snapshotProbe"; +import { + enrichProviderSnapshotWithVersionAdvisory, + type ProviderMaintenanceCapabilities, +} from "@t3tools/provider-core/server/maintenanceResolver"; +import { + EMPTY_OMP_MODEL_CAPABILITIES, + thinkingCapabilitiesForOmpModel, +} from "./thinkingCapabilities.ts"; +import { + parseOmpDiscoveredCommands, + withOmpBuiltinSlashCommands, + type OmpDiscoveredCommands, +} from "./commands.ts"; + +const OMP_PRESENTATION = { + displayName: "OMP", + showInteractionModeToggle: false, + supportedRuntimeModes: ["approval-required", "auto-accept-edits", "full-access"], + reportsContextWindow: true, +} as const; + +const VERSION_PROBE_TIMEOUT_MS = 10_000; +const OMP_RPC_DISCOVERY_TIMEOUT_MS = 30_000; +// Minimum version verified against the native RPC protocol. +export const MINIMUM_OMP_VERSION = "18.16.0"; + +const OMP_DEFAULT_MODEL: ServerProviderModel = { + slug: "default", + name: "Omp default", + isCustom: false, + capabilities: EMPTY_OMP_MODEL_CAPABILITIES, +}; + +interface OmpDiscovery extends OmpDiscoveredCommands { + readonly models: ReadonlyArray; + readonly authenticated: boolean; + /** Omp's active model when Omp lists no model of its provider, so it cannot start a turn. */ + readonly unavailableActiveModel: { readonly provider: string; readonly id: string } | undefined; +} + +function ompModelsFromSettings( + customModels: ReadonlyArray | undefined, + discovered: ReadonlyArray = [], +): ReadonlyArray { + return providerModelsFromSettings( + [OMP_DEFAULT_MODEL, ...discovered], + customModels ?? [], + EMPTY_OMP_MODEL_CAPABILITIES, + ); +} + +function parseDiscoveredModels( + data: unknown, + state: unknown, +): Result.Result, OmpRpcError> { + const models = recordField(data, "models"); + if (!Array.isArray(models)) { + return Result.fail( + new OmpRpcError({ operation: "get_available_models", detail: "Invalid model inventory" }), + ); + } + const activeModel = recordField(state, "model"); + const activeProvider = recordString(activeModel, "provider"); + const activeModelId = recordString(activeModel, "id"); + const seen = new Set(); + const parsed: Array = []; + for (const model of models) { + const provider = recordString(model, "provider"); + const id = recordString(model, "id"); + if (provider === undefined || id === undefined || provider.trim() === "" || id.trim() === "") { + return Result.fail( + new OmpRpcError({ operation: "get_available_models", detail: "Invalid model identity" }), + ); + } + const slug = `${provider}/${id}`; + if (seen.has(slug)) continue; + seen.add(slug); + parsed.push({ + slug, + name: recordString(model, "name") ?? slug, + subProvider: provider, + isCustom: false, + capabilities: thinkingCapabilitiesForOmpModel( + model, + provider === activeProvider && id === activeModelId + ? recordString(state, "thinkingLevel") + : undefined, + ), + }); + } + return Result.succeed(parsed); +} + +const makeOmpDiscoveryConnection = Effect.fnUntraced(function* ( + ompSettings: OmpSettings, + environment: NodeJS.ProcessEnv, + launchArgs: ReadonlyArray, + cwd?: string, +) { + const launch = buildOmpRpcLaunch({ + launchArgs, + environment, + mcpSession: undefined, + extensionPath: undefined, + ephemeral: true, + shortLived: true, + }); + const connection = yield* makeOmpRpcConnection({ + command: ompSettings.binaryPath || "omp", + args: launch.args, + cwd, + env: launch.env, + }); + yield* Stream.fromQueue(connection.events).pipe( + Stream.runDrain, + Effect.ignore, + Effect.forkScoped, + ); + return connection; +}); + +const discoverOmpViaRpc = Effect.fn("OmpProviderStatus.discoverOmpViaRpc")(function* ( + ompSettings: OmpSettings, + environment: NodeJS.ProcessEnv, + launchArgs: ReadonlyArray, + cwd?: string, +) { + const connection = yield* makeOmpDiscoveryConnection(ompSettings, environment, launchArgs, cwd); + const stateData = yield* connection.request({ type: "get_state" }); + const modelsData = yield* connection.request({ type: "get_available_models" }); + const commandsData = yield* connection + .request({ type: "get_available_commands" }) + .pipe(Effect.orElseSucceed(() => undefined)); + const discoveredModels = yield* Effect.fromResult(parseDiscoveredModels(modelsData, stateData)); + const { slashCommands, skills } = parseOmpDiscoveredCommands(commandsData); + // Omp lists only models of providers it holds credentials for, including extension, virtual and + // --api-key ones. Turns need only the provider's credentials, so uncatalogued model ids still run. + const activeModel = recordField(stateData, "model"); + const activeProvider = recordString(activeModel, "provider"); + const activeModelId = recordString(activeModel, "id"); + return { + models: discoveredModels, + slashCommands: withOmpBuiltinSlashCommands(slashCommands), + skills, + authenticated: discoveredModels.length > 0, + unavailableActiveModel: + activeProvider !== undefined && + activeModelId !== undefined && + !discoveredModels.some((model) => model.subProvider === activeProvider) + ? { provider: activeProvider, id: activeModelId } + : undefined, + } satisfies OmpDiscovery; +}, Effect.scoped); + +export const discoverOmpCommandsForCwd = Effect.fn("discoverOmpCommandsForCwd")( + function* (ompSettings: OmpSettings, environment: NodeJS.ProcessEnv, cwd: string) { + const launchArgs = resolveOmpLaunchArgs(ompSettings.launchArgs); + if (!launchArgs.ok) { + return yield* new OmpRpcError({ operation: "launch", detail: launchArgs.message }); + } + const connection = yield* makeOmpDiscoveryConnection( + ompSettings, + environment, + launchArgs.args, + cwd, + ); + // A failed read must not replace a previously usable workspace catalog with an empty one. + const commandsData = yield* connection.request({ type: "get_available_commands" }); + const { slashCommands, skills } = parseOmpDiscoveredCommands(commandsData); + return { slashCommands: withOmpBuiltinSlashCommands(slashCommands), skills }; + }, + Effect.scoped, + Effect.timeoutOrElse({ + duration: OMP_RPC_DISCOVERY_TIMEOUT_MS, + orElse: () => + Effect.fail( + new OmpRpcTimeoutError({ operation: "discovery", timeoutMs: OMP_RPC_DISCOVERY_TIMEOUT_MS }), + ), + }), +); + +const runOmpVersionCommand = Effect.fn("OmpProviderStatus.runOmpVersionCommand")(function* ( + ompSettings: OmpSettings, + environment: NodeJS.ProcessEnv, +) { + const command = ompSettings.binaryPath || "omp"; + 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 buildInitialOmpProviderSnapshot = Effect.fn( + "OmpProviderStatus.buildInitialOmpProviderSnapshot", +)(function* (ompSettings: OmpSettings): Effect.fn.Return { + const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso); + const models = ompModelsFromSettings(ompSettings.customModels); + if (!ompSettings.enabled) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: false, + checkedAt, + models, + probe: { + installed: false, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Omp is disabled in T3 Code settings.", + }, + }); + } + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: true, + checkedAt, + models, + probe: { + installed: true, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Checking Omp CLI availability...", + }, + }); +}); + +export const checkOmpProviderStatus = Effect.fn("checkOmpProviderStatus")(function* ( + ompSettings: OmpSettings, + environment: NodeJS.ProcessEnv = process.env, + cwd?: string, +): Effect.fn.Return { + const checkedAt = DateTime.formatIso(yield* DateTime.now); + const fallbackModels = ompModelsFromSettings(ompSettings.customModels); + + if (!ompSettings.enabled) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: false, + checkedAt, + models: fallbackModels, + probe: { + installed: false, + version: null, + status: "warning", + auth: { status: "unknown" }, + message: "Omp is disabled in T3 Code settings.", + }, + }); + } + + const versionResult = yield* runOmpVersionCommand(ompSettings, environment).pipe( + Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), + Effect.result, + ); + + if (Result.isFailure(versionResult)) { + const error = versionResult.failure; + yield* Effect.logWarning("Omp CLI health check failed.", { errorTag: error._tag }); + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: !isCommandMissingCause(error), + version: null, + status: "error", + auth: { status: "unknown" }, + message: isCommandMissingCause(error) + ? "Omp CLI (`omp`) is not installed or not on PATH. Install OMP using its official installer, then set its binary path in provider settings." + : "Failed to execute Omp CLI health check.", + }, + }); + } + + if (Option.isNone(versionResult.success)) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version: null, + status: "error", + auth: { status: "unknown" }, + message: "Omp CLI is installed but timed out while running `omp --version`.", + }, + }); + } + + const versionOutput = versionResult.success.value; + const version = parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`); + if (versionOutput.code !== 0) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "error", + auth: { status: "unknown" }, + message: "Omp CLI is installed but failed to run.", + }, + }); + } + + if (version === null) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version: null, + status: "error", + auth: { status: "unknown" }, + message: `T3 Code could not determine the Omp version. Omp ${MINIMUM_OMP_VERSION} or newer is required.`, + }, + }); + } + + if (compareSemverVersions(version, MINIMUM_OMP_VERSION) < 0) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "error", + auth: { status: "unknown" }, + message: `Omp ${version} is unsupported. Update to Omp ${MINIMUM_OMP_VERSION} or newer.`, + }, + }); + } + + const resolvedLaunchArgs = resolveOmpLaunchArgs(ompSettings.launchArgs); + if (!resolvedLaunchArgs.ok) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "error", + auth: { status: "unknown" }, + message: resolvedLaunchArgs.message, + }, + }); + } + + const discoveryExit = yield* discoverOmpViaRpc( + ompSettings, + environment, + resolvedLaunchArgs.args, + cwd, + ).pipe(Effect.timeoutOption(OMP_RPC_DISCOVERY_TIMEOUT_MS), Effect.exit); + if (Exit.isFailure(discoveryExit)) { + yield* Effect.logWarning("Omp RPC discovery failed.", { + errorTag: causeErrorTag(discoveryExit.cause), + }); + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "ready", + auth: { status: "unknown" }, + message: + "Omp is available, but T3 Code could not refresh its models and commands. The live session will retry startup.", + }, + }); + } + if (Option.isNone(discoveryExit.value)) { + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models: fallbackModels, + probe: { + installed: true, + version, + status: "ready", + auth: { status: "unknown" }, + message: + "Omp is available, but model and command discovery needs interactive input. The live session will handle it.", + }, + }); + } + + const discovery = discoveryExit.value.value; + const models = ompModelsFromSettings(ompSettings.customModels, discovery.models); + const message = !discovery.authenticated + ? "Omp has no usable models. Run `omp` in a terminal and use /login, or configure an API key in ~/.omp/agent." + : discovery.unavailableActiveModel === undefined + ? undefined + : `Omp default (${discovery.unavailableActiveModel.provider}/${discovery.unavailableActiveModel.id}) is unavailable. Choose another model or configure that provider in OMP.`; + return buildServerProvider({ + presentation: OMP_PRESENTATION, + enabled: ompSettings.enabled, + checkedAt, + models, + slashCommands: discovery.slashCommands, + skills: discovery.skills, + probe: { + installed: true, + version, + // Other Omp models still work when only the default is unavailable, so keep the picker usable. + status: discovery.authenticated ? "ready" : "warning", + auth: { status: discovery.authenticated ? "authenticated" : "unauthenticated", type: "omp" }, + ...(message === undefined ? {} : { message }), + }, + }); +}); + +export const enrichOmpSnapshot = (input: { + readonly snapshot: ServerProvider; + readonly maintenanceCapabilities: ProviderMaintenanceCapabilities; + readonly enableProviderUpdateChecks?: boolean; + readonly publishSnapshot: (snapshot: ServerProvider) => Effect.Effect; +}): Effect.Effect< + void, + never, + HttpClient.HttpClient | ProviderLatestVersions.ProviderLatestVersions +> => { + const { snapshot, publishSnapshot } = input; + return enrichProviderSnapshotWithVersionAdvisory(snapshot, input.maintenanceCapabilities, { + enableProviderUpdateChecks: input.enableProviderUpdateChecks, + }).pipe( + Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)), + Effect.catchCause((cause) => + Effect.logWarning("Omp version advisory enrichment failed", { + errorTag: causeErrorTag(cause), + }), + ), + Effect.asVoid, + ); +}; diff --git a/packages/provider-omp/src/server/textGeneration.test.ts b/packages/provider-omp/src/server/textGeneration.test.ts new file mode 100644 index 0000000000000..f7ca5af09d73c --- /dev/null +++ b/packages/provider-omp/src/server/textGeneration.test.ts @@ -0,0 +1,198 @@ +import { assert, it } from "@effect/vitest"; +import { ProviderInstanceId } from "@t3tools/contracts"; +import { createModelSelection } from "@t3tools/shared/model"; +import * as Cause from "effect/Cause"; +import * as Effect from "effect/Effect"; +import * as Queue from "effect/Queue"; +import * as Schema from "effect/Schema"; +import * as Sink from "effect/Sink"; +import * as Stream from "effect/Stream"; +import * as ChildProcess from "effect/process/ChildProcess"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; + +import { makeOmpTextGeneration } from "./textGeneration.ts"; + +const decodeJsonLine = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); +const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown)); + +const makeFakeOmp = ( + reply: string, + setModelError?: string, + turnEvents: ReadonlyArray> = [], +) => + Effect.gen(function* () { + const stdout = yield* Queue.unbounded(); + const received: Array> = []; + const emit = (record: Record) => + Queue.offer(stdout, new TextEncoder().encode(`${encodeJsonLine(record)}\n`)); + let buffered = ""; + const onStdin = (chunk: Uint8Array) => + Effect.gen(function* () { + buffered += new TextDecoder().decode(chunk); + const lines = buffered.split("\n"); + buffered = lines.pop() ?? ""; + for (const line of lines.filter((candidate) => candidate.length > 0)) { + const record = decodeJsonLine(line) as Record; + received.push(record); + const response = { type: "response", id: record["id"], command: record["type"] }; + if (record["type"] === "prompt") { + yield* emit({ ...response, success: true }); + for (const event of turnEvents) yield* emit(event); + yield* emit({ type: "session_settled" }); + } else if (record["type"] === "get_last_assistant_text") { + yield* emit({ ...response, success: true, data: { text: reply } }); + } else if (record["type"] === "set_model" && setModelError !== undefined) { + yield* emit({ ...response, success: false, error: setModelError }); + } else { + yield* emit({ ...response, success: true }); + } + } + }); + const spawner = ChildProcessSpawner.make(() => + Effect.succeed( + ChildProcessSpawner.makeHandle({ + // Outside the valid pid range, so OmpRpc's process-group kill never lands. + pid: ChildProcessSpawner.ProcessId(999_999_999), + exitCode: Effect.never, + isRunning: Effect.succeed(true), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.forEach(onStdin), + stdout: Stream.fromQueue(stdout), + stderr: Stream.empty, + all: Stream.empty, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.empty, + }), + ), + ); + return { spawner, received }; + }); + +it.effect("runs OMP helpers without tools or persistent sessions", () => + Effect.gen(function* () { + const omp = yield* makeFakeOmp(JSON.stringify({ subject: "Update README", body: "" })); + const launches: Array> = []; + const spawner = ChildProcessSpawner.make((command) => { + if (ChildProcess.isStandardCommand(command)) launches.push(command.args.map(String)); + return omp.spawner.spawn(command); + }); + const textGeneration = yield* makeOmpTextGeneration( + { enabled: true, binaryPath: "omp", launchArgs: "", customModels: [] }, + {}, + ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner)); + + const result = yield* textGeneration.generateCommitMessage({ + cwd: process.cwd(), + branch: "main", + stagedSummary: "M README.md", + stagedPatch: "diff --git a/README.md b/README.md", + modelSelection: createModelSelection(ProviderInstanceId.make("omp"), "default"), + }); + + assert.equal(result.subject, "Update README"); + assert.deepEqual( + launches.map((args) => args.filter((arg) => arg === "--no-session" || arg === "--no-tools")), + [["--no-session", "--no-tools"]], + ); + }), +); + +it.effect("names the model and the disabled extensions when Omp cannot load it", () => + Effect.gen(function* () { + const omp = yield* makeFakeOmp("", "Model not found: demo/demo-model"); + const textGeneration = yield* makeOmpTextGeneration( + { enabled: true, binaryPath: "omp", launchArgs: "", customModels: [] }, + {}, + ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, omp.spawner)); + + const error = yield* textGeneration + .generateCommitMessage({ + cwd: process.cwd(), + branch: "main", + stagedSummary: "M README.md", + stagedPatch: "diff --git a/README.md b/README.md", + modelSelection: createModelSelection(ProviderInstanceId.make("omp"), "demo/demo-model"), + }) + .pipe(Effect.flip); + + assert.equal(error._tag, "TextGenerationError"); + assert.include(error.detail, "Omp rejected model 'demo/demo-model'"); + assert.include(error.detail, "Model not found: demo/demo-model"); + assert.include(error.detail, "--no-extensions"); + assert.isUndefined(omp.received.find((record) => record["type"] === "prompt")); + }), +); + +const failedTurnWith = (errorMessage: string) => ({ + type: "message_end", + message: { role: "assistant", stopReason: "error", errorMessage }, +}); + +const failedTurn = failedTurnWith( + '401: {"error":{"message":"Incorrect API key provided: sk-test-SECRET123"}}', +); + +const generateCommitMessage = (turnEvents: ReadonlyArray>, reply = "") => + Effect.gen(function* () { + const omp = yield* makeFakeOmp(reply, undefined, turnEvents); + const textGeneration = yield* makeOmpTextGeneration( + { enabled: true, binaryPath: "omp", launchArgs: "", customModels: [] }, + {}, + ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, omp.spawner)); + return yield* textGeneration.generateCommitMessage({ + cwd: process.cwd(), + branch: "main", + stagedSummary: "M README.md", + stagedPatch: "diff --git a/README.md b/README.md", + modelSelection: createModelSelection(ProviderInstanceId.make("omp"), "default"), + }); + }); + +it.effect("reports Omp's turn error when the reply is empty", () => + Effect.gen(function* () { + const error = yield* generateCommitMessage([failedTurn]).pipe(Effect.flip); + + assert.equal(error._tag, "TextGenerationError"); + assert.equal( + error.detail, + "Omp could not generate text: the model provider returned HTTP 401.", + ); + }), +); + +it.effect("keeps Omp's raw error text out of the error", () => + Effect.gen(function* () { + const error = yield* generateCommitMessage([ + failedTurnWith("Invalid API key sk-test-SECRET123"), + ]).pipe(Effect.flip); + + assert.equal( + error.detail, + "Omp could not generate text: the model provider reported an error.", + ); + assert.notInclude(error.message, "SECRET123"); + }), +); + +it.effect("keeps the reply when Omp answers after a failed attempt", () => + Effect.gen(function* () { + const result = yield* generateCommitMessage( + [failedTurn, { type: "message_end", message: { role: "assistant", stopReason: "stop" } }], + JSON.stringify({ subject: "Update README", body: "" }), + ); + + assert.equal(result.subject, "Update README"); + }), +); + +it.effect("drops an earlier error once a later attempt succeeds", () => + Effect.gen(function* () { + const error = yield* generateCommitMessage([ + failedTurn, + { type: "message_end", message: { role: "assistant", stopReason: "stop" } }, + ]).pipe(Effect.flip); + + assert.equal(error.detail, "Omp returned empty output."); + }), +); diff --git a/packages/provider-omp/src/server/textGeneration.ts b/packages/provider-omp/src/server/textGeneration.ts new file mode 100644 index 0000000000000..d24e9859d4427 --- /dev/null +++ b/packages/provider-omp/src/server/textGeneration.ts @@ -0,0 +1,152 @@ +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Queue from "effect/Queue"; +import * as Schema from "effect/Schema"; +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; + +import { TextGenerationError } from "@t3tools/contracts"; +import type { OmpSettings } from "../settings.ts"; + +import { makeOmpRpcConnection, parseOmpModelSlug, ompRecordString } from "./rpc.ts"; +import { buildOmpRpcLaunch, resolveOmpLaunchArgs } from "./mcpInjection.ts"; +import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations"; + +const OMP_TIMEOUT_MS = 180_000; + +const isTextGenerationError = Schema.is(TextGenerationError); + +// Omp's `errorMessage` is the provider's raw response text and can echo +// credentials, so only a leading HTTP status reaches the error detail. +const ompTurnErrorDetail = (errorMessage: string | undefined) => { + const status = errorMessage?.match(/^([45]\d\d)\b/)?.[1]; + return status === undefined + ? "Omp could not generate text: the model provider reported an error." + : `Omp could not generate text: the model provider returned HTTP ${status}.`; +}; + +export const makeOmpTextGeneration = Effect.fn("makeOmpTextGeneration")(function* ( + ompSettings: OmpSettings, + environment: NodeJS.ProcessEnv = process.env, +) { + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + + const runOmpJson: TextGenerationOperations.Runner = Effect.fn("OmpTextGeneration.runOmpJson")( + function* (request) { + const { operation, cwd, prompt, modelSelection } = request; + + const resolvedLaunchArgs = resolveOmpLaunchArgs(ompSettings.launchArgs); + if (!resolvedLaunchArgs.ok) { + return yield* new TextGenerationError({ + operation, + detail: resolvedLaunchArgs.message, + }); + } + const launch = buildOmpRpcLaunch({ + launchArgs: resolvedLaunchArgs.args, + environment, + mcpSession: undefined, + extensionPath: undefined, + ephemeral: true, + shortLived: true, + disableExtensions: true, + // Background naming/content helpers must never mutate the workspace. + disableTools: true, + }); + const connection = yield* makeOmpRpcConnection({ + command: ompSettings.binaryPath || "omp", + args: launch.args, + cwd, + env: launch.env, + }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner)); + + if (modelSelection.model !== "default") { + // Reject unusable custom slugs; silently using Omp's default would misreport the requested model. + const parsed = parseOmpModelSlug(modelSelection.model); + if (parsed === null) { + return yield* new TextGenerationError({ + operation, + detail: `Omp model '${modelSelection.model}' must use provider/model format.`, + }); + } + yield* connection + .request({ type: "set_model", provider: parsed.provider, modelId: parsed.modelId }) + .pipe( + // Model discovery loads extensions that this background helper disables. + Effect.mapError((error) => + error._tag === "OmpRpcError" && error.operation === "set_model" + ? new TextGenerationError({ + operation, + detail: + `Omp rejected model '${modelSelection.model}': ${error.detail ?? "unknown error"}. ` + + "If the model comes from a Omp extension or package, text generation cannot use it " + + "because it runs Omp with --no-extensions. Pick a built-in Omp model or one defined " + + "in Omp's models.json.", + cause: error, + }) + : error, + ), + ); + } + + yield* connection.request({ type: "prompt", message: prompt }); + // Provider failures (bad key, rate limit, 5xx) arrive on the assistant + // `message_end`. Keep only the latest, since Omp can retry and still answer. + let turnError: string | undefined; + yield* Effect.gen(function* () { + while (true) { + const event = yield* Queue.take(connection.events); + if (event["type"] === "session_settled") return; + const message = event["message"]; + if (event["type"] === "message_end" && ompRecordString(message, "role") === "assistant") { + turnError = + ompRecordString(message, "stopReason") === "error" + ? ompTurnErrorDetail(ompRecordString(message, "errorMessage")) + : undefined; + } + } + }); + const data = yield* connection.request({ type: "get_last_assistant_text" }); + const text = + typeof data === "object" && + data !== null && + typeof (data as { text?: unknown }).text === "string" + ? (data as { text: string }).text.trim() + : ""; + if (!text) { + return yield* new TextGenerationError({ + operation, + detail: turnError ?? "Omp returned empty output.", + }); + } + return yield* TextGenerationOperations.decodeJsonReply(request, "Omp", text); + }, + (effect, request) => { + const { operation } = request; + return effect.pipe( + Effect.timeoutOption(OMP_TIMEOUT_MS), + Effect.flatMap( + Option.match({ + onNone: () => + Effect.fail(new TextGenerationError({ operation, detail: "Omp request timed out." })), + onSome: (value) => Effect.succeed(value), + }), + ), + Effect.mapError((cause) => + isTextGenerationError(cause) + ? cause + : new TextGenerationError({ + operation, + detail: "Omp text generation failed.", + cause, + }), + ), + Effect.scoped, + ); + }, + ); + + return TextGenerationOperations.fromRunner( + "OmpTextGeneration", + TextGenerationOperations.withoutInvestigation("Omp", runOmpJson), + ); +}); diff --git a/packages/provider-omp/src/server/thinkingCapabilities.test.ts b/packages/provider-omp/src/server/thinkingCapabilities.test.ts new file mode 100644 index 0000000000000..f6e252184f1b5 --- /dev/null +++ b/packages/provider-omp/src/server/thinkingCapabilities.test.ts @@ -0,0 +1,17 @@ +import { expect, it } from "@effect/vitest"; +import { thinkingCapabilitiesForOmpModel } from "./thinkingCapabilities.ts"; +it("uses OMP thinking.efforts without inventing unsupported levels", () => { + const capabilities = thinkingCapabilitiesForOmpModel( + { reasoning: true, thinking: { efforts: ["low", "high", "max"] } }, + "high", + ); + const thinking = capabilities.optionDescriptors?.[0]; + expect(thinking?.type === "select" ? thinking.options.map((option) => option.id) : []).toEqual([ + "low", + "high", + "max", + ]); + expect(thinkingCapabilitiesForOmpModel({ reasoning: true }, undefined).optionDescriptors).toEqual( + [], + ); +}); diff --git a/packages/provider-omp/src/server/thinkingCapabilities.ts b/packages/provider-omp/src/server/thinkingCapabilities.ts new file mode 100644 index 0000000000000..ff2f2a95c7b10 --- /dev/null +++ b/packages/provider-omp/src/server/thinkingCapabilities.ts @@ -0,0 +1,76 @@ +import { type ModelCapabilities, type ProviderOptionChoice } from "@t3tools/contracts"; +import { createModelCapabilities } from "@t3tools/shared/model"; +import * as Predicate from "effect/Predicate"; + +// OMP declares the model-specific effort vocabulary in thinking.efforts. +const OMP_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const; + +export type OmpThinkingLevel = (typeof OMP_THINKING_LEVELS)[number]; + +const OMP_THINKING_LEVEL_LABELS: Record = { + off: "Off", + minimal: "Minimal", + low: "Low", + medium: "Medium", + high: "High", + xhigh: "Extra High", + max: "Max", +}; + +export const EMPTY_OMP_MODEL_CAPABILITIES: ModelCapabilities = createModelCapabilities({ + optionDescriptors: [], +}); + +export function thinkingCapabilitiesForOmpModel( + model: unknown, + defaultThinkingLevel: unknown, +): ModelCapabilities { + const levels = supportedOmpThinkingLevelsFromModel(model); + if (levels.length === 0) return EMPTY_OMP_MODEL_CAPABILITIES; + const defaultLevel = clampOmpThinkingLevel(defaultThinkingLevel, levels); + return createModelCapabilities({ + optionDescriptors: [ + { + id: "thinking", + label: "Thinking", + type: "select", + options: levels.map((level): ProviderOptionChoice => ({ + id: level, + label: OMP_THINKING_LEVEL_LABELS[level], + ...(level === defaultLevel ? { isDefault: true } : {}), + })), + }, + ], + }); +} + +function clampOmpThinkingLevel( + input: unknown, + availableLevels: ReadonlyArray, +): OmpThinkingLevel | undefined { + if (typeof input !== "string") return undefined; + const requestedIndex = OMP_THINKING_LEVELS.findIndex((level) => level === input); + if (requestedIndex === -1) return undefined; + const exact = availableLevels.find((level) => level === input); + if (exact !== undefined) return exact; + for (let index = requestedIndex + 1; index < OMP_THINKING_LEVELS.length; index += 1) { + const higher = availableLevels.find((level) => level === OMP_THINKING_LEVELS[index]); + if (higher !== undefined) return higher; + } + for (let index = requestedIndex - 1; index >= 0; index -= 1) { + const lower = availableLevels.find((level) => level === OMP_THINKING_LEVELS[index]); + if (lower !== undefined) return lower; + } + return availableLevels[0]; +} + +function supportedOmpThinkingLevelsFromModel(model: unknown): ReadonlyArray { + if (recordField(model, "reasoning") !== true) return []; + const efforts = recordField(recordField(model, "thinking"), "efforts"); + if (!Array.isArray(efforts)) return []; + return OMP_THINKING_LEVELS.filter((level) => efforts.includes(level)); +} + +function recordField(input: unknown, key: string): unknown { + return Predicate.isObject(input) ? input[key] : undefined; +} diff --git a/packages/provider-omp/src/server/usage.ts b/packages/provider-omp/src/server/usage.ts new file mode 100644 index 0000000000000..309fb261773bf --- /dev/null +++ b/packages/provider-omp/src/server/usage.ts @@ -0,0 +1,176 @@ +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; + +import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; +import { + parseTimestampMs, + tokenCount, + totalTokens, + type ProviderUsageReader, + type TranscriptUsageFormat, + type UsageRecord, +} from "@t3tools/provider-core/server/usage"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import type { OmpSettings } from "../settings.ts"; +import { OMP_ARGUMENTS_WITH_VALUES, resolveOmpLaunchArgs } from "./mcpInjection.ts"; + +const OmpScanState = Schema.Struct({ sessionId: Schema.mutableKey(Schema.String) }); +const Usage = Schema.Struct({ + input: Schema.optional(Schema.Unknown), + output: Schema.optional(Schema.Unknown), + cacheRead: Schema.optional(Schema.Unknown), + cacheWrite: Schema.optional(Schema.Unknown), + reasoning: Schema.optional(Schema.Unknown), + cost: Schema.optional(Schema.Struct({ total: Schema.Unknown })), +}); +const Identity = { id: Schema.NonEmptyString, timestamp: Schema.String }; +const Model = { provider: Schema.NonEmptyString, model: Schema.NonEmptyString }; +const Entry = Schema.Union([ + Schema.Struct({ type: Schema.Literal("session"), id: Schema.NonEmptyString }), + Schema.Struct({ + ...Identity, + type: Schema.Literal("message"), + message: Schema.Union([ + Schema.Struct({ + ...Model, + role: Schema.Literal("assistant"), + responseModel: Schema.optional(Schema.NonEmptyString), + usage: Usage, + }), + Schema.Struct({ role: Schema.Literal("toolResult"), usage: Usage }), + ]), + }), + Schema.Struct({ ...Identity, ...Model, type: Schema.Literal("usage"), usage: Usage }), + Schema.Struct({ + ...Identity, + type: Schema.Literals(["compaction", "branch_summary"]), + usage: Usage, + }), +]); +const decodeEntry = Schema.decodeUnknownOption(Entry); + +function parseRecord(parsed: unknown, state: typeof OmpScanState.Type): readonly UsageRecord[] { + const decoded = decodeEntry(parsed); + if (Option.isNone(decoded)) return []; + const entry = decoded.value; + if (entry.type === "session") { + state.sessionId = entry.id; + return []; + } + const timestampMs = parseTimestampMs(entry.timestamp); + if (timestampMs === null) return []; + const source = entry.type === "message" ? entry.message : entry; + const usage = source.usage; + // Auxiliary tool/summary records lack model attribution; match Omp's breakdown. + const rateModel = + "model" in source + ? "responseModel" in source + ? (source.responseModel ?? source.model) + : source.model + : undefined; + const model = "provider" in source ? `${source.provider}/${rateModel}` : "Tools/summaries"; + const outputTokens = tokenCount(usage.output); + const totals = { + // Omp's input/cache counters are already disjoint. + uncachedInputTokens: tokenCount(usage.input), + cachedInputTokens: tokenCount(usage.cacheRead), + cacheCreationTokens: tokenCount(usage.cacheWrite), + outputTokens, + reasoningTokens: Math.min(outputTokens, tokenCount(usage.reasoning)), + }; + const cost = usage.cost?.total; + // Omitted Omp rates default to zero; use shared estimates without positive transcript cost. + const reportedCostUsd = + typeof cost === "number" && Number.isFinite(cost) && cost > 0 ? cost : null; + if (totalTokens(totals) === 0 && reportedCostUsd === null) return []; + return [ + { + provider: "omp", + timestampMs, + model, + ...(rateModel === undefined ? {} : { rateModel }), + sessionId: state.sessionId, + totals, + reportedCostUsd, + speed: "standard", + // Forks preserve IDs/timestamps; short random IDs need timestamp/model to avoid cross-session collisions. + dedupeKey: JSON.stringify(["omp", entry.id, entry.timestamp, model]), + }, + ]; +} + +export const ompUsageFormat: TranscriptUsageFormat = { + selectFields: { + type: true, + id: true, + timestamp: true, + provider: true, + model: true, + usage: true, + message: { role: true, provider: true, model: true, responseModel: true, usage: true }, + }, + usageMarkers: ['"usage"', '"session"'], + parseLine: (line, state) => { + let parsed: unknown; + try { + parsed = JSON.parse(line); + } catch { + return []; + } + return parseRecord(parsed, state); + }, + parseProjected: parseRecord, + state: { initial: () => ({ sessionId: "" }), schema: OmpScanState }, +}; + +export const ompUsageReader: ProviderUsageReader = { + kind: "transcripts", + provider: "omp", + format: ompUsageFormat, + directories: Effect.fn("ompUsageReader.directories")(function* ({ config, environment }) { + const path = yield* Path.Path; + const home = yield* HostProcess.HomeDirectory; + const platform = yield* HostProcess.Platform; + const launchHome = (platform === "win32" ? environment.USERPROFILE : environment.HOME) || home; + const sessionDirArg = config === undefined ? undefined : ompLaunchSessionDir(config.launchArgs); + const launchDir = + sessionDirArg === undefined ? undefined : expandHomePath(sessionDirArg, launchHome); + // --session-dir moves only T3-launched sessions; terminal sessions stay in Omp's own directory. + return [ + ...(launchDir !== undefined && path.isAbsolute(launchDir) + ? [{ dir: path.resolve(launchDir) }] + : []), + { dir: resolveOmpSessionsDir(environment, home, path) }, + ]; + }), +}; + +function ompLaunchSessionDir(launchArgs: string): string | undefined { + const resolved = resolveOmpLaunchArgs(launchArgs); + if (!resolved.ok) return undefined; + let sessionDir: string | undefined; + for (let index = 0; index < resolved.args.length; index += 1) { + const arg = resolved.args[index]; + if (arg === undefined || !OMP_ARGUMENTS_WITH_VALUES.has(arg)) continue; + index += 1; + if (arg === "--session-dir") sessionDir = resolved.args[index] || undefined; + } + return sessionDir; +} + +/** Where Omp stores session JSONL files for a provider environment, matching Omp's own lookup. */ +export function resolveOmpSessionsDir( + environment: NodeJS.ProcessEnv, + home: string, + path: Path.Path, +): string { + const sessionDir = environment.PI_CODING_AGENT_SESSION_DIR?.trim(); + if (sessionDir) return path.resolve(expandHomePath(sessionDir, home)); + const agentDir = environment.PI_CODING_AGENT_DIR?.trim(); + return path.resolve( + agentDir ? expandHomePath(agentDir, home) : path.join(home, ".omp", "agent"), + "sessions", + ); +} diff --git a/packages/provider-omp/src/settings.ts b/packages/provider-omp/src/settings.ts new file mode 100644 index 0000000000000..a9f59329a4b8a --- /dev/null +++ b/packages/provider-omp/src/settings.ts @@ -0,0 +1,41 @@ +// Shared with the client settings form; keep schema code browser-safe. +import { + CustomModelSetting, + makeBinaryPathSetting, + makeProviderSettingsSchema, + TrimmedString, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; + +export const OmpSettings = makeProviderSettingsSchema( + { + enabled: Schema.Boolean.pipe( + Schema.withDecodingDefault(Effect.succeed(false)), + Schema.annotateKey({ providerSettingsForm: { hidden: true } }), + ), + binaryPath: makeBinaryPathSetting("omp").pipe( + Schema.annotateKey({ + title: "Binary path", + description: "Path to the Omp coding agent binary.", + providerSettingsForm: { placeholder: "omp", clearWhenEmpty: "omit" }, + }), + ), + launchArgs: TrimmedString.pipe( + Schema.withDecodingDefault(Effect.succeed("")), + Schema.annotateKey({ + title: "Launch arguments", + description: "Additional CLI arguments passed to omp --mode rpc-ui on session start.", + providerSettingsForm: { clearWhenEmpty: "omit" }, + }), + ), + customModels: Schema.Array(CustomModelSetting).pipe( + Schema.withDecodingDefault(Effect.succeed([])), + Schema.annotateKey({ providerSettingsForm: { hidden: true } }), + ), + }, + { + order: ["binaryPath", "launchArgs"], + }, +); +export type OmpSettings = typeof OmpSettings.Type; diff --git a/packages/provider-omp/tsconfig.json b/packages/provider-omp/tsconfig.json new file mode 100644 index 0000000000000..374bac55202dd --- /dev/null +++ b/packages/provider-omp/tsconfig.json @@ -0,0 +1,7 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "types": ["node"] + }, + "include": ["src"] +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 697191c410823..60e98792972ab 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -871,6 +871,9 @@ importers: '@t3tools/provider-muse': specifier: workspace:* version: link:../../packages/provider-muse + '@t3tools/provider-omp': + specifier: workspace:* + version: link:../../packages/provider-omp '@t3tools/provider-opencode': specifier: workspace:* version: link:../../packages/provider-opencode @@ -1510,6 +1513,9 @@ importers: '@t3tools/provider-muse': specifier: workspace:* version: link:../provider-muse + '@t3tools/provider-omp': + specifier: workspace:* + version: link:../provider-omp '@t3tools/provider-opencode': specifier: workspace:* version: link:../provider-opencode @@ -1877,6 +1883,37 @@ importers: specifier: 1.4.0 version: 1.4.0(@astrojs/compiler-rs@0.5.1)(@types/node@24.12.4)(@vitest/browser-playwright@5.0.5)(@vitest/ui@5.0.5)(@volar/typescript@2.4.28(typescript@6.0.3))(bufferutil@4.1.0)(esbuild@0.28.2)(jiti@2.7.0)(jsdom@30.1.0(@noble/hashes@1.8.0))(playwright@1.60.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + packages/provider-omp: + dependencies: + '@t3tools/contracts': + specifier: workspace:* + version: link:../contracts + '@t3tools/provider-core': + specifier: workspace:* + version: link:../provider-core + '@t3tools/shared': + specifier: workspace:* + version: link:../shared + effect: + specifier: 4.1.2 + version: 4.1.2 + devDependencies: + '@effect/platform-node': + specifier: 4.1.2 + version: 4.1.2(bufferutil@4.1.0)(effect@4.1.2)(redis@6.2.1)(utf-8-validate@6.0.6) + '@effect/vitest': + specifier: 4.1.2 + version: 4.1.2(patch_hash=299510b71c36537a832a67e9d160a5f112a5f326a29e95c41cb45fc8234e47c7)(@astrojs/compiler-rs@0.5.1)(@types/node@24.12.4)(@vitest/browser-playwright@5.0.5)(@vitest/ui@5.0.5)(@volar/typescript@2.4.28(typescript@6.0.3))(bufferutil@4.1.0)(effect@4.1.2)(esbuild@0.28.2)(jiti@2.7.0)(jsdom@30.1.0(@noble/hashes@1.8.0))(playwright@1.60.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + '@t3tools/provider-testing': + specifier: workspace:* + version: link:../provider-testing + '@types/node': + specifier: 24.12.4 + version: 24.12.4 + vite-plus: + specifier: 1.4.0 + version: 1.4.0(@astrojs/compiler-rs@0.5.1)(@types/node@24.12.4)(@vitest/browser-playwright@5.0.5)(@vitest/ui@5.0.5)(@volar/typescript@2.4.28(typescript@6.0.3))(bufferutil@4.1.0)(esbuild@0.28.2)(jiti@2.7.0)(jsdom@30.1.0(@noble/hashes@1.8.0))(playwright@1.60.0)(terser@5.48.0)(typescript@6.0.3)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0) + packages/provider-opencode: dependencies: '@opencode-ai/sdk': From aeef8a3cd035d9457e6b674a047382b7b37307ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristijan=20Luka=C4=8Din?= Date: Sun, 8 Nov 2026 21:30:25 +0100 Subject: [PATCH 2/2] fix(omp): preserve native lifecycle and command semantics --- .../src/project/AgentSessionScanner.test.ts | 73 +++++++++++++++++ .../server/src/project/AgentSessionScanner.ts | 14 ++-- .../provider-omp/src/server/adapter.test.ts | 78 +++++++++++++++++++ packages/provider-omp/src/server/adapter.ts | 34 +++++++- .../provider-omp/src/server/commands.test.ts | 25 +++++- packages/provider-omp/src/server/commands.ts | 9 ++- .../src/server/mcpInjection.test.ts | 16 ++++ .../provider-omp/src/server/mcpInjection.ts | 11 ++- packages/provider-omp/src/server/status.ts | 1 - .../provider-omp/src/server/textGeneration.ts | 1 - .../provider-omp/src/server/usage.test.ts | 41 ++++++++++ packages/provider-omp/src/server/usage.ts | 39 ++++++++-- 12 files changed, 319 insertions(+), 23 deletions(-) create mode 100644 packages/provider-omp/src/server/mcpInjection.test.ts create mode 100644 packages/provider-omp/src/server/usage.test.ts diff --git a/apps/server/src/project/AgentSessionScanner.test.ts b/apps/server/src/project/AgentSessionScanner.test.ts index 8af2626b18b0f..47142332bb9db 100644 --- a/apps/server/src/project/AgentSessionScanner.test.ts +++ b/apps/server/src/project/AgentSessionScanner.test.ts @@ -1094,6 +1094,79 @@ it.layer(NodeServices.layer)("AgentSessionScanner", (it) => { }); describe("recentThreads", () => { + it.effect("keeps two OMP profiles assigned to their own provider instances", () => + Effect.gen(function* () { + const path = yield* Path.Path; + const home = yield* makeTempDir("t3code-omp-profile-home-"); + const workspace = yield* makeTempDir("t3code-omp-profile-workspace-"); + const nowMs = Date.parse("2026-08-24T12:00:00Z"); + yield* TestClock.setTime(nowMs); + for (const profile of ["work", "personal", "default"]) { + yield* writeTranscript({ + filePath: path.join( + home, + ".omp", + ...(profile === "default" ? [] : ["profiles", profile]), + "agent", + "sessions", + `${profile}.jsonl`, + ), + contents: [ + { + type: "session", + version: 3, + id: profile, + cwd: workspace, + timestamp: "2026-08-24T11:00:00Z", + }, + { type: "model_change", id: "m", parentId: null, model: "openai/gpt-4.1-mini" }, + { + type: "message", + id: "u", + parentId: "m", + timestamp: "2026-08-24T11:00:00Z", + message: { role: "user", content: [{ type: "text", text: `From ${profile}` }] }, + }, + ] + .map((record) => encodeTranscriptRecord(record)) + .join("\n"), + mtimeMs: nowMs, + }); + } + const environment = [ + { name: "HOME", value: home, sensitive: false }, + { name: "OMP_PROFILE", value: "personal", sensitive: false }, + { name: "PI_CODING_AGENT_SESSION_DIR", value: "", sensitive: false }, + { name: "XDG_DATA_HOME", value: "", sensitive: false }, + { name: "PI_CONFIG_DIR", value: ".omp", sensitive: false }, + ]; + const threads = yield* runRecentThreads({ + claudeHomePath: home, + codexHomePath: home, + workspaceRoot: workspace, + providerInstances: { + [ProviderInstanceId.make("omp-work")]: { + driver: ProviderDriverKind.make("omp"), + enabled: true, + environment, + config: { launchArgs: "--profile=work" }, + }, + [ProviderInstanceId.make("omp-personal")]: { + driver: ProviderDriverKind.make("omp"), + enabled: true, + environment, + config: {}, + }, + }, + }); + expect( + threads.map((thread) => [thread.providerInstanceId, thread.providerSessionId]).sort(), + ).toEqual([ + ["omp-personal", "personal"], + ["omp-work", "work"], + ]); + }), + ); it.effect("imports recent Claude, Codex, and Pi sessions for the selected project only", () => Effect.gen(function* () { const path = yield* Path.Path; diff --git a/apps/server/src/project/AgentSessionScanner.ts b/apps/server/src/project/AgentSessionScanner.ts index d4938e2f38fbc..d007fdeea8cd2 100644 --- a/apps/server/src/project/AgentSessionScanner.ts +++ b/apps/server/src/project/AgentSessionScanner.ts @@ -36,6 +36,7 @@ import * as ProjectStore from "../orchestration-v2/ProjectStore.ts"; import { resolveCodexHomeLayout } from "../provider/Drivers/CodexHomeLayout.ts"; import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment"; import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; +import { OmpSettings } from "@t3tools/provider-omp/settings"; import { resolveOmpSessionsDir } from "@t3tools/provider-omp/server/usage"; import { resolvePiSessionsDir } from "@t3tools/provider-pi/server/usage"; import * as ServerSettings from "../serverSettings.ts"; @@ -144,6 +145,7 @@ const CodexSessionIndexEntry = Schema.Struct({ }); const decodeClaudeSettings = Schema.decodeUnknownOption(ClaudeSettings); +const decodeOmpSettings = Schema.decodeUnknownOption(OmpSettings); const decodeCodexSettings = Schema.decodeUnknownOption(CodexSettings); const decodeTranscriptRecord = Schema.decodeUnknownOption(Schema.fromJsonString(TranscriptRecord)); const decodeTranscriptValue = Schema.decodeUnknownOption(TranscriptRecord); @@ -1453,11 +1455,13 @@ export const make = Effect.gen(function* () { instance.environment, hostEnvironment, ).pipe(Effect.provideService(HostProcess.HomeDirectory, homeDir)); - homePath = (source === "omp" ? resolveOmpSessionsDir : resolvePiSessionsDir)( - environment, - homeDir, - path, - ); + if (source === "omp") { + const config = decodeOmpSettings(instance.config ?? {}); + if (Option.isNone(config)) continue; + homePath = resolveOmpSessionsDir(environment, homeDir, path, config.value.launchArgs); + } else { + homePath = resolvePiSessionsDir(environment, homeDir, path); + } } else if (source === "claudeAgent") { const config = decodeClaudeSettings(instance.config ?? {}); if (Option.isNone(config)) continue; diff --git a/packages/provider-omp/src/server/adapter.test.ts b/packages/provider-omp/src/server/adapter.test.ts index 916e36f436327..1b22f26c11dab 100644 --- a/packages/provider-omp/src/server/adapter.test.ts +++ b/packages/provider-omp/src/server/adapter.test.ts @@ -219,6 +219,84 @@ const startTurn = Effect.fnUntraced(function* ( }); describe("OmpAdapterV2", () => { + it.effect( + "renders command-only output and reapplies the selected model and thinking after native config changes", + () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake, "openai/selected"); + const providerThread = yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("openai/selected"), + runtimePolicy, + }); + const selection = { + ...modelSelection("openai/selected"), + options: [{ id: "thinking", value: "high" }], + }; + yield* startTurn(runtime, providerThread, "openai/selected", [], "/model", selection); + yield* fake.takeRequest("prompt"); + yield* fake.emit({ type: "command_output", text: "Current model: openai/native" }); + const notice = yield* takeEvent( + (event) => event.type === "turn_item.updated" && event.turnItem.type === "system_notice", + ); + assert.isTrue( + notice.type === "turn_item.updated" && + notice.turnItem.type === "system_notice" && + notice.turnItem.message === "Current model: openai/native", + ); + yield* fake.emit({ + type: "config_update", + model: { provider: "openai", id: "native", contextWindow: 32000 }, + thinkingLevel: "low", + }); + yield* fake.emit({ + type: "prompt_result", + status: "completed", + agentInvoked: false, + sessionSettled: true, + }); + yield* takeEvent((event) => event.type === "turn.terminal"); + yield* startTurn(runtime, providerThread, "openai/selected", [], "Next", selection, 2); + const setModel = yield* fake.takeRequest("set_model"); + assert.equal(setModel["modelId"], "selected"); + const setThinking = yield* fake.takeRequest("set_thinking_level"); + assert.equal(setThinking["level"], "high"); + yield* fake.takeRequest("prompt"); + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); + it.effect("sends native compaction modes as unchanged prompt commands", () => + Effect.gen(function* () { + const fake = yield* makeFakeOmp; + const { runtime, takeEvent } = yield* openRuntime(fake); + const providerThread = yield* runtime.ensureThread({ + threadId: THREAD_ID, + modelSelection: modelSelection("default"), + runtimePolicy, + }); + let ordinal = 0; + for (const mode of ["soft", "remote", "snapcompact"]) { + yield* startTurn( + runtime, + providerThread, + "default", + [], + `/compact ${mode}`, + undefined, + ++ordinal, + ); + const prompt = yield* fake.takeRequest("prompt"); + assert.equal(prompt["message"], `/compact ${mode}`); + yield* fake.emit({ + type: "prompt_result", + status: "completed", + agentInvoked: false, + sessionSettled: true, + }); + yield* takeEvent((event) => event.type === "turn.terminal"); + } + }).pipe(Effect.scoped, Effect.provide(layerTest)), + ); it.effect("keeps background work open until OMP reports session settlement", () => Effect.gen(function* () { const fake = yield* makeFakeOmp; diff --git a/packages/provider-omp/src/server/adapter.ts b/packages/provider-omp/src/server/adapter.ts index f53cf9655bff6..aea06a1cfe04d 100644 --- a/packages/provider-omp/src/server/adapter.ts +++ b/packages/provider-omp/src/server/adapter.ts @@ -1906,6 +1906,39 @@ export const makeOmpAdapterV2 = Effect.fn("makeOmpAdapterV2")(function* ( const state = threadState; const turn = state?.activeTurn ?? null; switch (event["type"]) { + case "command_output": { + const text = recordString(event, "text"); + if (turn !== null && text !== undefined) { + yield* emitSystemNotice( + turn, + `command:${turn.providerTurn.id}:${turn.nextItemOrdinal}`, + text, + ); + } + return; + } + case "config_update": { + const model = recordField(event, "model"); + const provider = recordString(model, "provider"); + const modelId = recordString(model, "id"); + appliedModel = + provider !== undefined && modelId !== undefined ? `${provider}/${modelId}` : null; + baselineModel = + provider !== undefined && modelId !== undefined ? { provider, modelId } : null; + baselineThinking = recordString(event, "thinkingLevel") ?? null; + appliedThinking = baselineThinking; + contextWindow = rememberModelContextWindow(model); + if (appliedModel !== null) { + const updatedAt = yield* DateTime.now; + sessionEntity = { ...sessionEntity, model: appliedModel, updatedAt }; + yield* emit({ + type: "provider_session.updated", + driver: OMP_PROVIDER, + providerSession: sessionEntity, + }); + } + return; + } case "agent_start": { if ( turn === null && @@ -3390,7 +3423,6 @@ export const makeOmpAdapterV2 = Effect.fn("makeOmpAdapterV2")(function* ( environment: options.environment, mcpSession: undefined, extensionPath: undefined, - shortLived: true, disableExtensions: true, disableTools: true, }); diff --git a/packages/provider-omp/src/server/commands.test.ts b/packages/provider-omp/src/server/commands.test.ts index 3cff7c07e73bf..e51f3e074586e 100644 --- a/packages/provider-omp/src/server/commands.test.ts +++ b/packages/provider-omp/src/server/commands.test.ts @@ -1,6 +1,10 @@ import { expect, it } from "@effect/vitest"; -import { parseOmpDiscoveredCommands } from "./commands.ts"; +import { + parseOmpDiscoveredCommands, + parseOmpCompactCommand, + withOmpBuiltinSlashCommands, +} from "./commands.ts"; it("maps current Omp skill metadata to T3's user and project skill scopes", () => { expect( @@ -62,3 +66,22 @@ it("preserves OMP native command hints and exact thinking metadata", () => { }).slashCommands, ).toEqual([{ name: "switch", description: "Switch model", input: { hint: "[model]" } }]); }); + +it.each([ + "soft", + "remote", + "snapcompact", + "soft retain goals", + "remote retain goals", + "snapcompact retain goals", +])("leaves native compact mode %s to the native command dispatcher", (mode) => { + expect(parseOmpCompactCommand(`/compact ${mode}`)).toBeNull(); +}); +it("retains custom compaction instructions and the native advertised mode hints", () => { + expect(parseOmpCompactCommand("/compact")).toEqual({}); + expect(parseOmpCompactCommand("/compact retain goals")).toEqual({ + customInstructions: "retain goals", + }); + const commands = [{ name: "compact", input: { hint: "soft|remote|snapcompact" } }]; + expect(withOmpBuiltinSlashCommands(commands)).toEqual(commands); +}); diff --git a/packages/provider-omp/src/server/commands.ts b/packages/provider-omp/src/server/commands.ts index 47b41b9e4270f..6cfb49a317d1c 100644 --- a/packages/provider-omp/src/server/commands.ts +++ b/packages/provider-omp/src/server/commands.ts @@ -1,11 +1,11 @@ import { type ServerProviderSkill, type ServerProviderSlashCommand } from "@t3tools/contracts"; import * as Predicate from "effect/Predicate"; -// T3 routes /compact to the dedicated RPC command. +// Native mode arguments must reach the command dispatcher rather than become summary instructions. const OMP_COMPACT_SLASH_COMMAND: ServerProviderSlashCommand = { name: "compact", description: "Summarize the conversation and reduce context usage", - input: { hint: "Optional instructions" }, + input: { hint: "[soft|remote|snapcompact] or instructions" }, }; export interface OmpCompactCommand { @@ -20,13 +20,16 @@ export function parseOmpCompactCommand(text: string): OmpCompactCommand | null { if (rest.length === 0) return {}; if (!/^\s/.test(rest)) return null; const customInstructions = rest.trim(); + if (/^(soft|remote|snapcompact)(?:\s|$)/.test(customInstructions)) return null; return customInstructions.length === 0 ? {} : { customInstructions }; } export function withOmpBuiltinSlashCommands( commands: ReadonlyArray, ): ReadonlyArray { - return [OMP_COMPACT_SLASH_COMMAND, ...commands.filter((command) => command.name !== "compact")]; + return commands.some((command) => command.name === "compact") + ? commands + : [OMP_COMPACT_SLASH_COMMAND, ...commands]; } export interface OmpDiscoveredCommands { diff --git a/packages/provider-omp/src/server/mcpInjection.test.ts b/packages/provider-omp/src/server/mcpInjection.test.ts new file mode 100644 index 0000000000000..0827861493ba9 --- /dev/null +++ b/packages/provider-omp/src/server/mcpInjection.test.ts @@ -0,0 +1,16 @@ +import { expect, it } from "@effect/vitest"; +import { resolveOmpLaunchArgs } from "./mcpInjection.ts"; + +it.each([ + "--restore", + "--from-claude", + "--from-codex", + "--goal", + "--alias", + "--cwd", + "--resume", + "--continue", +])("reserves native startup lifecycle argument %s in both forms", (flag) => { + expect(resolveOmpLaunchArgs(`${flag} /fixture/session.jsonl`).ok).toBe(false); + expect(resolveOmpLaunchArgs(`${flag}=/fixture/session.jsonl`).ok).toBe(false); +}); diff --git a/packages/provider-omp/src/server/mcpInjection.ts b/packages/provider-omp/src/server/mcpInjection.ts index 288911ade81c0..534d292db467e 100644 --- a/packages/provider-omp/src/server/mcpInjection.ts +++ b/packages/provider-omp/src/server/mcpInjection.ts @@ -13,6 +13,12 @@ import { } from "./mcpExtensionSource.ts"; const RESERVED_OMP_LAUNCH_ARGUMENTS = new Set([ + "--restore", + "--from-claude", + "--from-codex", + "--goal", + "--alias", + "--cwd", "--continue", "-c", "--export", @@ -45,6 +51,7 @@ export const OMP_ARGUMENTS_WITH_VALUES = new Set([ "-n", "--prompt-template", "--provider", + "--profile", "--session-dir", "--skill", "--system-prompt", @@ -74,7 +81,6 @@ const OMP_ARGUMENTS_WITHOUT_VALUES = new Set([ "--no-themes", "--no-tools", "-nt", - "--offline", "--verbose", ]); @@ -253,9 +259,6 @@ export function buildOmpRpcLaunch(input: { readonly extensionPath: string | undefined; readonly sessionPath?: string | undefined; readonly ephemeral?: boolean; - // T3 stops these processes as soon as they answer. They run --offline because Omp's startup - // catalog refresh renews expired OAuth tokens, and a stop mid-request loses the rotated one. - readonly shortLived?: boolean; readonly disableExtensions?: boolean; readonly disableTools?: boolean; readonly runtimeMode?: "approval-required" | "auto-accept-edits" | "auto" | "full-access"; diff --git a/packages/provider-omp/src/server/status.ts b/packages/provider-omp/src/server/status.ts index cc0f111eb6cd9..ed234be7f72e9 100644 --- a/packages/provider-omp/src/server/status.ts +++ b/packages/provider-omp/src/server/status.ts @@ -139,7 +139,6 @@ const makeOmpDiscoveryConnection = Effect.fnUntraced(function* ( mcpSession: undefined, extensionPath: undefined, ephemeral: true, - shortLived: true, }); const connection = yield* makeOmpRpcConnection({ command: ompSettings.binaryPath || "omp", diff --git a/packages/provider-omp/src/server/textGeneration.ts b/packages/provider-omp/src/server/textGeneration.ts index d24e9859d4427..31f337d431295 100644 --- a/packages/provider-omp/src/server/textGeneration.ts +++ b/packages/provider-omp/src/server/textGeneration.ts @@ -47,7 +47,6 @@ export const makeOmpTextGeneration = Effect.fn("makeOmpTextGeneration")(function mcpSession: undefined, extensionPath: undefined, ephemeral: true, - shortLived: true, disableExtensions: true, // Background naming/content helpers must never mutate the workspace. disableTools: true, diff --git a/packages/provider-omp/src/server/usage.test.ts b/packages/provider-omp/src/server/usage.test.ts new file mode 100644 index 0000000000000..beed48ff5f208 --- /dev/null +++ b/packages/provider-omp/src/server/usage.test.ts @@ -0,0 +1,41 @@ +import { expect, it } from "@effect/vitest"; +import * as NodeServices from "@effect/platform-node/NodeServices"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; +import { resolveOmpSessionsDir } from "./usage.ts"; + +it.effect("resolves profile roots, explicit session overrides and existing XDG data roots", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const home = yield* fs.makeTempDirectoryScoped(); + const env = { HOME: home, OMP_PROFILE: "personal", PI_CODING_AGENT_DIR: "/ignored-agent" }; + expect(resolveOmpSessionsDir(env, home, path, "--profile work")).toBe( + path.join(home, ".omp/profiles/work/agent/sessions"), + ); + expect(resolveOmpSessionsDir(env, home, path)).toBe( + path.join(home, ".omp/profiles/personal/agent/sessions"), + ); + expect( + resolveOmpSessionsDir({ ...env, PI_CODING_AGENT_SESSION_DIR: "~/explicit" }, home, path), + ).toBe(path.join(home, "explicit")); + const dataHome = path.join(home, "data"); + const profileData = path.join(dataHome, "omp/profiles/personal"); + yield* fs.makeDirectory(profileData, { recursive: true }); + expect(resolveOmpSessionsDir({ ...env, XDG_DATA_HOME: dataHome }, home, path)).toBe( + path.join(profileData, "sessions"), + ); + expect(resolveOmpSessionsDir({ HOME: home, PI_PROFILE: "legacy" }, home, path)).toBe( + path.join(home, ".omp/profiles/legacy/agent/sessions"), + ); + expect( + resolveOmpSessionsDir( + { ...env, PI_CODING_AGENT_DIR: path.join(home, "custom") }, + home, + path, + "--profile default", + ), + ).toBe(path.join(home, "custom/sessions")); + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), +); diff --git a/packages/provider-omp/src/server/usage.ts b/packages/provider-omp/src/server/usage.ts index 309fb261773bf..3016b8b9fbcc5 100644 --- a/packages/provider-omp/src/server/usage.ts +++ b/packages/provider-omp/src/server/usage.ts @@ -1,4 +1,6 @@ +// @effect-diagnostics nodeBuiltinImport:off -- Usage directory resolution has no FileSystem service; native OMP selects existing XDG roots synchronously. import * as Effect from "effect/Effect"; +import * as NodeFS from "node:fs"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; @@ -142,7 +144,7 @@ export const ompUsageReader: ProviderUsageReader = { ...(launchDir !== undefined && path.isAbsolute(launchDir) ? [{ dir: path.resolve(launchDir) }] : []), - { dir: resolveOmpSessionsDir(environment, home, path) }, + { dir: resolveOmpSessionsDir(environment, launchHome, path, config?.launchArgs) }, ]; }), }; @@ -165,12 +167,35 @@ export function resolveOmpSessionsDir( environment: NodeJS.ProcessEnv, home: string, path: Path.Path, + launchArgs = "", ): string { + const launchHome = environment.HOME || environment.USERPROFILE || home; const sessionDir = environment.PI_CODING_AGENT_SESSION_DIR?.trim(); - if (sessionDir) return path.resolve(expandHomePath(sessionDir, home)); - const agentDir = environment.PI_CODING_AGENT_DIR?.trim(); - return path.resolve( - agentDir ? expandHomePath(agentDir, home) : path.join(home, ".omp", "agent"), - "sessions", - ); + if (sessionDir) return path.resolve(expandHomePath(sessionDir, launchHome)); + const resolved = resolveOmpLaunchArgs(launchArgs); + let profile = environment.OMP_PROFILE ?? environment.PI_PROFILE; + if (resolved.ok) { + for (let index = 0; index < resolved.args.length; index += 1) { + const arg = resolved.args[index]; + if (arg === undefined || !OMP_ARGUMENTS_WITH_VALUES.has(arg)) continue; + index += 1; + if (arg === "--profile") profile = resolved.args[index]; + } + } + profile = profile?.trim(); + if (profile === "default") profile = undefined; + const configRoot = path.join(launchHome, environment.PI_CONFIG_DIR || ".omp"); + const defaultAgentDir = profile + ? path.join(configRoot, "profiles", profile, "agent") + : path.join(configRoot, "agent"); + // Named profiles ignore agent-dir overrides; existing XDG profile roots own session data. + const agentOverride = profile ? undefined : environment.PI_CODING_AGENT_DIR?.trim(); + const agentDir = agentOverride ? expandHomePath(agentOverride, launchHome) : defaultAgentDir; + if (agentDir === defaultAgentDir && environment.XDG_DATA_HOME) { + const dataRoot = profile + ? path.join(environment.XDG_DATA_HOME, "omp", "profiles", profile) + : path.join(environment.XDG_DATA_HOME, "omp"); + if (NodeFS.existsSync(dataRoot)) return path.join(dataRoot, "sessions"); + } + return path.resolve(agentDir, "sessions"); }