Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

fix(server): sign in to ChatGPT, Claude, and Grok without their CLIs (#341)

Leo3b141ca6b2f6
diff --git a/.changeset/harness-native-provider-readiness.md b/.changeset/harness-native-provider-readiness.md
new file mode 100644
index 000000000..c456fa0ff
--- /dev/null
+++ b/.changeset/harness-native-provider-readiness.md
@@ -0,0 +1,7 @@
+---
+"akeru-bot": patch
+---
+
+ChatGPT, Claude, and Grok sign-ins no longer require their CLIs to be installed. Chat titles and branch names use the saved Akeru connection too.
+
+Existing Codex, Claude, and Grok model selections remain usable, connection status updates immediately after sign-in or sign-out, and generated titles and branch names retain model options and screenshot context. Writing requests have a three-minute deadline and continue with text when a screenshot is unavailable.
diff --git a/apps/server/src/provider/AkeruMastraHarness.test.ts b/apps/server/src/provider/AkeruMastraHarness.test.ts
index ad6c03849..062dc5839 100644
--- a/apps/server/src/provider/AkeruMastraHarness.test.ts
+++ b/apps/server/src/provider/AkeruMastraHarness.test.ts
@@ -6,6 +6,7 @@ import * as NodePath from "node:path";
import * as NodeSqlite from "node:sqlite";
import { AuthStorage } from "@mastra/code-sdk/auth/storage";
+import type { createAnthropic } from "@ai-sdk/anthropic";
import { MessageList, type Agent } from "@mastra/core/agent";
import { RequestContext } from "@mastra/core/request-context";
import { Memory } from "@mastra/memory";
@@ -1866,6 +1867,85 @@ describe("AkeruMastraHarness", () => {
expect(getCredential).not.toHaveBeenCalled();
});
+ it("uses the first nonempty trimmed Claude auth token", () => {
+ const authStorage = new AuthStorage("/tmp/akeru-unused-empty-token-auth.json");
+ for (const token of ["", " "]) {
+ expect(
+ resolveAkeruMastraModel(
+ "anthropic/claude-opus-4-6",
+ authStorage,
+ undefined,
+ undefined,
+ undefined,
+ undefined,
+ {
+ environment: {},
+ instanceEnvironment: {
+ ANTHROPIC_AUTH_TOKEN: token,
+ CLAUDE_CODE_OAUTH_TOKEN: " valid-token ",
+ },
+ useSavedCredential: false,
+ },
+ ),
+ ).toMatchObject({ modelId: "claude-opus-4-6", provider: "anthropic.messages" });
+ }
+ });
+
+ it("translates Claude 1M model selections into API headers for every credential transport", async () => {
+ const authStorage = new AuthStorage("/tmp/akeru-unused-context-auth.json");
+ const requests: Array<{ body: unknown; beta: string | null }> = [];
+ vi.stubGlobal(
+ "fetch",
+ vi.fn<(input: string | URL | Request, init?: RequestInit) => Promise<Response>>(
+ async (_input, init) => {
+ requests.push({
+ body: init?.body,
+ beta: new Headers(init?.headers).get("anthropic-beta"),
+ });
+ return Response.json({
+ id: "msg-context",
+ type: "message",
+ role: "assistant",
+ model: "claude-opus-4-6",
+ content: [{ type: "text", text: "Done" }],
+ stop_reason: "end_turn",
+ stop_sequence: null,
+ usage: { input_tokens: 1, output_tokens: 1 },
+ });
+ },
+ ),
+ );
+ try {
+ for (const transport of ["environment", "saved-key", "oauth"] as const) {
+ const model = resolveAkeruMastraModel(
+ "anthropic/claude-opus-4-6[1m]",
+ authStorage,
+ undefined,
+ undefined,
+ undefined,
+ transport === "saved-key" ? () => ({ type: "api-key", access: "saved-key" }) : undefined,
+ {
+ environment: transport === "environment" ? { ANTHROPIC_API_KEY: "env-key" } : {},
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ ) as ReturnType<ReturnType<typeof createAnthropic>>;
+ await model.doGenerate({
+ prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+ maxOutputTokens: 32,
+ });
+ }
+ expect(requests).toHaveLength(3);
+ for (const request of requests) {
+ expect(request.body).toContain('"model":"claude-opus-4-6"');
+ expect(request.body).not.toContain("[1m]");
+ expect(request.beta).toContain("context-1m-2025-08-07");
+ }
+ } finally {
+ vi.unstubAllGlobals();
+ }
+ });
+
it("keeps Kimi model names on the Kimi subscription transport", () => {
const authStorage = new AuthStorage("/tmp/akeru-unused-auth.json");
assert.equal(
@@ -1960,6 +2040,7 @@ describe("AkeruMastraHarness", () => {
{ provider: "anthropic.messages", modelId: "claude-sonnet-4-5" },
);
assert.equal(mastraModelId(ProviderDriverKind.make("grok"), "grok-4"), "xai/grok-4");
+ assert.equal(mastraModelId(ProviderDriverKind.make("grok"), "grok-build"), "xai/grok-4.6");
assert.deepInclude(
resolveAkeruMastraModel(
"xai/grok-4",
diff --git a/apps/server/src/provider/AkeruMastraHarness.ts b/apps/server/src/provider/AkeruMastraHarness.ts
index 1a9927d77..78320e725 100644
--- a/apps/server/src/provider/AkeruMastraHarness.ts
+++ b/apps/server/src/provider/AkeruMastraHarness.ts
@@ -546,7 +546,7 @@ const MASTRA_MODEL_PREFIX = {
} as const;
export function mastraModelId(provider: ProviderDriverKind, model: string): string {
- const trimmed = model.trim();
+ const trimmed = provider === "grok" && model.trim() === "grok-build" ? "grok-4.6" : model.trim();
const prefix = MASTRA_MODEL_PREFIX[provider as keyof typeof MASTRA_MODEL_PREFIX];
if (!prefix) return trimmed.includes("/") ? trimmed : `${provider}/${trimmed}`;
const token = `${prefix}/`;
@@ -645,12 +645,18 @@ export function resolveAkeruMastraModel(
});
}
if (trimmed.startsWith("anthropic/")) {
- const model = trimmed.slice("anthropic/".length);
+ const selectedModel = trimmed.slice("anthropic/".length);
+ const extendedContext = selectedModel.endsWith("[1m]");
+ const model = extendedContext ? selectedModel.slice(0, -4) : selectedModel;
+ const contextHeaders = extendedContext
+ ? { headers: { "anthropic-beta": "context-1m-2025-08-07" } }
+ : {};
const instanceApiKey = environment?.ANTHROPIC_API_KEY?.trim();
const instanceAuthToken =
- environment?.ANTHROPIC_AUTH_TOKEN?.trim() ?? environment?.CLAUDE_CODE_OAUTH_TOKEN?.trim();
+ environment?.ANTHROPIC_AUTH_TOKEN?.trim() || environment?.CLAUDE_CODE_OAUTH_TOKEN?.trim();
if (instanceApiKey || instanceAuthToken) {
return createAnthropic({
+ ...contextHeaders,
...(instanceApiKey ? { apiKey: instanceApiKey } : { authToken: instanceAuthToken! }),
...(environment?.ANTHROPIC_BASE_URL?.trim()
? { baseURL: environment.ANTHROPIC_BASE_URL.trim() }
@@ -660,6 +666,7 @@ export function resolveAkeruMastraModel(
const credential = useSavedCredential ? savedApiKey("anthropic") : undefined;
if (credential) {
return createAnthropic({
+ ...contextHeaders,
apiKey: credential.access,
...(credential.baseUrl ? { baseURL: credential.baseUrl } : {}),
})(model);
@@ -669,7 +676,7 @@ export function resolveAkeruMastraModel(
"This Claude instance has no API key or auth token transport for Akeru Mastra.",
);
}
- return opencodeClaudeMaxProvider(model, { authStorage: scopedAuthStorage });
+ return opencodeClaudeMaxProvider(model, { ...contextHeaders, authStorage: scopedAuthStorage });
}
if (trimmed.startsWith("xai/")) {
const model = trimmed.slice("xai/".length);
diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts
index 07c4a35c4..c9b465a20 100644
--- a/apps/server/src/provider/Drivers/ClaudeDriver.ts
+++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts
@@ -1,20 +1,4 @@
-/**
- * ClaudeDriver — `ProviderDriver` for the Claude Agent SDK runtime.
- *
- * Mirrors `CodexDriver`: a plain value whose `create()` returns one
- * `ProviderInstance` bundling `snapshot` / `adapter` / `textGeneration`
- * closures captured over the per-instance `ClaudeSettings`.
- *
- * Unlike Codex, the Claude snapshot probe may invoke a secondary probe
- * (`probeClaudeCapabilities`) to read Anthropic account + slash-command
- * metadata. That probe is per-instance and keyed by binary + resolved HOME so
- * two concurrent Claude instances don't cross-contaminate account metadata.
- *
- * @module provider/Drivers/ClaudeDriver
- */
import { ClaudeSettings, ProviderDriverKind, type ServerProvider } from "@akeru/contracts";
-import * as Cache from "effect/Cache";
-import * as Duration from "effect/Duration";
import * as Crypto from "effect/Crypto";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
@@ -23,18 +7,14 @@ import * as Schema from "effect/Schema";
import { HttpClient } from "effect/unstable/http";
import { ChildProcessSpawner } from "effect/unstable/process";
-import { makeClaudeTextGeneration } from "../../textGeneration/ClaudeTextGeneration.ts";
+import { makeHarnessTextGeneration } from "../../textGeneration/HarnessTextGeneration.ts";
import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts";
import { ServerConfig } from "../../config.ts";
import { instanceUsesSavedCredential } from "../../subscription-auth/runtime.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
import { ProviderDriverError } from "../Errors.ts";
-import { makeClaudeAdapter } from "../Layers/ClaudeAdapter.ts";
-import {
- checkClaudeProviderStatus,
- makePendingClaudeProvider,
- probeClaudeCapabilities,
-} from "../Layers/ClaudeProvider.ts";
+import { makeHarnessProviderStatus } from "../HarnessProviderStatus.ts";
+import { makePendingClaudeProvider } from "../Layers/ClaudeProvider.ts";
import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
import * as ModelManifest from "../ModelManifest.ts";
@@ -57,11 +37,11 @@ import {
makeProviderSnapshotSettingsSource,
type ProviderSnapshotSettings,
} from "../providerUpdateSettings.ts";
-import { makeClaudeCapabilitiesCacheKey, makeClaudeContinuationGroupKey } from "./ClaudeHome.ts";
+import { makeClaudeContinuationGroupKey } from "./ClaudeHome.ts";
+import { discoverClaudeSkills } from "./ClaudeSkills.ts";
const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings);
const DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
-const CAPABILITIES_PROBE_TTL = Duration.minutes(5);
function isClaudeNativeCommandPath(commandPath: string): boolean {
const normalized = normalizeCommandPath(commandPath);
@@ -122,20 +102,26 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
defaultConfig: (): ClaudeSettings => decodeClaudeSettings({}),
create: ({ instanceId, displayName, accentColor, environment, enabled, config }) =>
Effect.gen(function* () {
- const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const { cwd, secretsDir } = yield* ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
- const { cwd, secretsDir } = yield* ServerConfig;
const httpClient = yield* HttpClient.HttpClient;
const serverSettings = yield* ServerSettingsService;
- const eventLoggers = yield* ProviderEventLoggers;
- const modelManifest = yield* ModelManifest.ModelManifest;
const processEnv = mergeSubscriptionInstanceEnvironment(environment);
const fallbackContinuationIdentity = defaultProviderContinuationIdentity({
driverKind: DRIVER_KIND,
instanceId,
});
const effectiveConfig = { ...config, enabled } satisfies ClaudeSettings;
+ const connection = {
+ environment: processEnv,
+ instanceEnvironment: explicitProviderInstanceEnvironment(environment),
+ useSavedCredential: instanceUsesSavedCredential("anthropic", {
+ driver: DRIVER_KIND,
+ environment,
+ config,
+ }),
+ };
const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE, {
binaryPath: effectiveConfig.binaryPath,
env: processEnv,
@@ -148,50 +134,27 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
continuationGroupKey,
});
- const adapterOptions = {
- instanceId,
- environment: processEnv,
- ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}),
- };
- const adapter = yield* makeClaudeAdapter(effectiveConfig, adapterOptions);
- const textGeneration = yield* makeClaudeTextGeneration(
- effectiveConfig,
- processEnv,
+ const adapter = undefined;
+ const textGeneration = yield* makeHarnessTextGeneration({
secretsDir,
+ driver: DRIVER_KIND,
instanceId,
- );
-
- // Per-instance capabilities cache: keyed on binary + resolved HOME so
- // account-specific probes never share auth metadata across instances.
- const capabilitiesProbeCache = yield* Cache.make({
- capacity: 1,
- timeToLive: CAPABILITIES_PROBE_TTL,
- lookup: () =>
- probeClaudeCapabilities(effectiveConfig, processEnv, cwd).pipe(
- Effect.provideService(Path.Path, path),
- ),
+ connection,
});
- const capabilitiesCacheKey = yield* makeClaudeCapabilitiesCacheKey(effectiveConfig, cwd);
- // Kick the TTL-gated manifest refresh in the background and classify
- // with the in-memory manifest, so a slow or hung fetch never delays the
- // provider check. A refresh that lands mid-probe applies on the next one.
- const checkProvider = modelManifest.refreshInBackground.pipe(
- Effect.andThen(
- Effect.zipWith(
- checkClaudeProviderStatus(
- effectiveConfig,
- () => Cache.get(capabilitiesProbeCache, capabilitiesCacheKey),
- processEnv,
- cwd,
- ),
- modelManifest.current,
- (draft, manifest) =>
- stampIdentity(ModelManifest.applyModelManifest(draft, manifest, DRIVER_KIND)),
- { concurrent: true },
+ const checkProvider = (yield* makeHarnessProviderStatus({
+ secretsDir,
+ provider: "anthropic",
+ driver: DRIVER_KIND,
+ instanceId,
+ connection,
+ draft: makePendingClaudeProvider(effectiveConfig),
+ })).pipe(
+ Effect.flatMap((draft) =>
+ discoverClaudeSkills(effectiveConfig, cwd, processEnv).pipe(
+ Effect.map((skills) => stampIdentity({ ...draft, skills })),
),
),
- Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
Effect.provideService(FileSystem.FileSystem, fileSystem),
Effect.provideService(Path.Path, path),
);
@@ -202,13 +165,7 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
getSettings: snapshotSettings.getSettings,
streamSettings: snapshotSettings.streamSettings,
haveSettingsChanged: haveProviderSnapshotSettingsChanged,
- initialSnapshot: (settings) =>
- Effect.zipWith(
- makePendingClaudeProvider(settings.provider),
- modelManifest.current,
- (draft, manifest) =>
- stampIdentity(ModelManifest.applyModelManifest(draft, manifest, DRIVER_KIND)),
- ),
+ initialSnapshot: () => checkProvider,
checkProvider,
enrichSnapshot: ({ settings, snapshot, publishSnapshot }) =>
enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities, {
@@ -239,15 +196,7 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
displayName,
accentColor,
enabled,
- mastraConnection: {
- environment: processEnv,
- instanceEnvironment: explicitProviderInstanceEnvironment(environment),
- useSavedCredential: instanceUsesSavedCredential("anthropic", {
- driver: DRIVER_KIND,
- environment,
- config,
- }),
- },
+ mastraConnection: connection,
snapshot,
adapter,
textGeneration,
diff --git a/apps/server/src/provider/Drivers/CodexDriver.ts b/apps/server/src/provider/Drivers/CodexDriver.ts
index f3825d5fe..9574034c1 100644
--- a/apps/server/src/provider/Drivers/CodexDriver.ts
+++ b/apps/server/src/provider/Drivers/CodexDriver.ts
@@ -1,26 +1,3 @@
-/**
- * CodexDriver — first concrete `ProviderDriver` in the new per-instance model.
- *
- * A driver is a plain value (not a Context.Service) whose `create()` returns
- * one `ProviderInstance` bundling:
- * - `snapshot` — the live `ServerProviderShape` for this instance;
- * - `adapter` — the Codex session/turn/approval runtime;
- * - `textGeneration` — commit/PR/branch/title generation via `codex exec`.
- *
- * Each call to `create()` captures the `codexConfig` argument in closures
- * owned by the returned instance. Two instances created with different
- * `homePath`s (e.g. `codex_personal` + `codex_work`) therefore run with
- * fully independent Codex app-server processes and `CODEX_HOME`
- * environments — no shared mutable state.
- *
- * Resource lifecycle: `create()` runs in a scope handed in by the registry.
- * Closing that scope releases the adapter's child processes, the managed
- * snapshot's refresh fibre, and the text-generation binaries' transient
- * scratch files. The registry uses this to tear down an instance when its
- * `providerInstances` entry disappears or its config changes.
- *
- * @module provider/Drivers/CodexDriver
- */
import { CodexSettings, ProviderDriverKind, type ServerProvider } from "@akeru/contracts";
import * as Crypto from "effect/Crypto";
import * as Effect from "effect/Effect";
@@ -30,14 +7,14 @@ import * as Schema from "effect/Schema";
import { HttpClient } from "effect/unstable/http";
import { ChildProcessSpawner } from "effect/unstable/process";
-import { makeCodexTextGeneration } from "../../textGeneration/CodexTextGeneration.ts";
+import { makeHarnessTextGeneration } from "../../textGeneration/HarnessTextGeneration.ts";
import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts";
import { ServerConfig } from "../../config.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
import { instanceUsesSavedCredential } from "../../subscription-auth/runtime.ts";
import { ProviderDriverError } from "../Errors.ts";
-import { makeCodexAdapter } from "../Layers/CodexAdapter.ts";
-import { checkCodexProviderStatus, makePendingCodexProvider } from "../Layers/CodexProvider.ts";
+import { makePendingCodexProvider } from "../Layers/CodexProvider.ts";
+import { makeHarnessProviderStatus } from "../HarnessProviderStatus.ts";
import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
import * as ModelManifest from "../ModelManifest.ts";
@@ -57,11 +34,7 @@ import {
makeProviderSnapshotSettingsSource,
type ProviderSnapshotSettings,
} from "../providerUpdateSettings.ts";
-import {
- codexContinuationIdentity,
- materializeCodexShadowHome,
- resolveCodexHomeLayout,
-} from "./CodexHomeLayout.ts";
+import { codexContinuationIdentity, resolveCodexHomeLayout } from "./CodexHomeLayout.ts";
const decodeCodexSettings = Schema.decodeSync(CodexSettings);
const DRIVER_KIND = ProviderDriverKind.make("codex");
@@ -121,12 +94,8 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = {
defaultConfig: (): CodexSettings => decodeCodexSettings({}),
create: ({ instanceId, displayName, accentColor, environment, enabled, config }) =>
Effect.gen(function* () {
- const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
- const fileSystem = yield* FileSystem.FileSystem;
const httpClient = yield* HttpClient.HttpClient;
const serverSettings = yield* ServerSettingsService;
- const eventLoggers = yield* ProviderEventLoggers;
- const modelManifest = yield* ModelManifest.ModelManifest;
const processEnv = mergeProviderInstanceEnvironment(environment);
const homeLayout = yield* resolveCodexHomeLayout(config);
const continuationIdentity = codexContinuationIdentity(homeLayout);
@@ -136,73 +105,48 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = {
accentColor,
continuationGroupKey: continuationIdentity.continuationKey,
});
- yield* materializeCodexShadowHome(homeLayout).pipe(
- Effect.mapError(
- (cause) =>
- new ProviderDriverError({
- driver: DRIVER_KIND,
- instanceId,
- detail: cause.message,
- cause,
- }),
- ),
- );
const effectiveConfig = {
...config,
enabled,
homePath: homeLayout.effectiveHomePath ?? "",
} satisfies CodexSettings;
+ const connection = {
+ environment: processEnv,
+ instanceEnvironment: explicitProviderInstanceEnvironment(environment),
+ useSavedCredential: instanceUsesSavedCredential("openai-codex", {
+ driver: DRIVER_KIND,
+ environment,
+ config,
+ }),
+ };
const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE, {
binaryPath: effectiveConfig.binaryPath,
env: processEnv,
});
- // `makeCodexAdapter` and `makeCodexTextGeneration` have `never` error
- // channels at construction time — their failure modes are all on the
- // per-operation closures they return. No `mapError` wrapper is needed
- // here; the registry only has to worry about snapshot-build and
- // spawner-availability failures surfaced from `checkCodexProviderStatus`
- // below.
- const adapter = yield* makeCodexAdapter(effectiveConfig, {
+ const adapter = undefined;
+ const textGeneration = yield* makeHarnessTextGeneration({
+ secretsDir: (yield* ServerConfig).secretsDir,
+ driver: DRIVER_KIND,
instanceId,
- environment: processEnv,
- ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}),
+ connection,
});
- const textGeneration = yield* makeCodexTextGeneration(effectiveConfig, processEnv);
- // Build a managed snapshot whose settings never change — mutations come
- // in as instance rebuilds from the registry rather than in-place
- // updates. Pre-provide `ChildProcessSpawner` so the check fits
- // `makeManagedServerProvider.checkProvider`'s `R = never`.
- // Kick the TTL-gated manifest refresh in the background and classify
- // with the in-memory manifest, so a slow or hung fetch never delays the
- // provider check. A refresh that lands mid-probe applies on the next one.
- const checkProvider = modelManifest.refreshInBackground.pipe(
- Effect.andThen(
- Effect.zipWith(
- checkCodexProviderStatus(effectiveConfig, undefined, processEnv),
- modelManifest.current,
- (draft, manifest) =>
- stampIdentity(ModelManifest.applyModelManifest(draft, manifest, DRIVER_KIND)),
- { concurrent: true },
- ),
- ),
- Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
- Effect.provideService(FileSystem.FileSystem, fileSystem),
- );
+ const checkProvider = (yield* makeHarnessProviderStatus({
+ secretsDir: (yield* ServerConfig).secretsDir,
+ provider: "openai-codex",
+ driver: DRIVER_KIND,
+ instanceId,
+ connection,
+ draft: makePendingCodexProvider(effectiveConfig),
+ })).pipe(Effect.map(stampIdentity));
const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
const snapshot = yield* makeManagedServerProvider<ProviderSnapshotSettings<CodexSettings>>({
maintenanceCapabilities,
getSettings: snapshotSettings.getSettings,
streamSettings: snapshotSettings.streamSettings,
haveSettingsChanged: haveProviderSnapshotSettingsChanged,
- initialSnapshot: (settings) =>
- Effect.zipWith(
- makePendingCodexProvider(settings.provider),
- modelManifest.current,
- (draft, manifest) =>
- stampIdentity(ModelManifest.applyModelManifest(draft, manifest, DRIVER_KIND)),
- ),
+ initialSnapshot: () => checkProvider,
checkProvider,
enrichSnapshot: ({ settings, snapshot, publishSnapshot }) =>
enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities, {
@@ -230,15 +174,7 @@ export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv> = {
displayName,
accentColor,
enabled,
- mastraConnection: {
- environment: processEnv,
- instanceEnvironment: explicitProviderInstanceEnvironment(environment),
- useSavedCredential: instanceUsesSavedCredential("openai-codex", {
- driver: DRIVER_KIND,
- environment,
- config,
- }),
- },
+ mastraConnection: connection,
snapshot,
adapter,
textGeneration,
diff --git a/apps/server/src/provider/Drivers/GrokDriver.test.ts b/apps/server/src/provider/Drivers/GrokDriver.test.ts
index bb05a507d..d9159bd58 100644
--- a/apps/server/src/provider/Drivers/GrokDriver.test.ts
+++ b/apps/server/src/provider/Drivers/GrokDriver.test.ts
@@ -6,6 +6,7 @@ import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
import * as Path from "effect/Path";
import * as Stream from "effect/Stream";
import { HttpClient, HttpClientResponse } from "effect/unstable/http";
@@ -13,10 +14,9 @@ import { HttpClient, HttpClientResponse } from "effect/unstable/http";
import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts";
import { ServerConfig } from "../../config.ts";
import { layerTest as serverSettingsLayerTest } from "../../serverSettings.ts";
-import { ProviderDriverError } from "../Errors.ts";
+import * as ModelManifest from "../ModelManifest.ts";
import { NoOpProviderEventLoggers, ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
import { GrokDriver } from "./GrokDriver.ts";
-import { GrokSkillsProbeError } from "./GrokSkills.ts";
const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");
@@ -64,6 +64,7 @@ const grokDriverTestLayer = Layer.mergeAll(
TestHttpClientLive,
Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers),
BackgroundPolicyAlwaysRunLayer,
+ ModelManifest.layerTest,
);
const LOGGED_IN_MODELS_OUTPUT = [
@@ -187,7 +188,7 @@ it.layer(grokDriverTestLayer)("GrokDriver.snapshotForCwd", (it) => {
const machine = yield* instance.snapshot.refresh;
const workspace = yield* instance.snapshotForCwd!(workspaceCwd);
- expect(machine.skills?.map((skill) => skill.name)).toEqual(["machine-skill"]);
+ expect(machine.skills ?? []).toEqual([]);
expect(workspace.skills).toEqual([
{
name: "project-skill",
@@ -200,7 +201,7 @@ it.layer(grokDriverTestLayer)("GrokDriver.snapshotForCwd", (it) => {
),
);
- it.effect("propagates inspect failures as ProviderDriverError", () =>
+ it.effect("logs inspect failures while falling back to an empty catalog", () =>
Effect.scoped(
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
@@ -213,12 +214,36 @@ it.layer(grokDriverTestLayer)("GrokDriver.snapshotForCwd", (it) => {
const machine = yield* instance.snapshot.refresh;
expect(machine.skills ?? []).toEqual([]);
- const error = yield* instance.snapshotForCwd!(workspaceCwd).pipe(Effect.flip);
- expect(error._tag).toBe("ProviderDriverError");
- expect(error).toBeInstanceOf(ProviderDriverError);
- expect(error.detail).toContain(`Failed to discover Grok skills for '${workspaceCwd}'`);
- expect(error.cause).toBeInstanceOf(GrokSkillsProbeError);
- expect((error.cause as GrokSkillsProbeError).stage).toBe("exit");
+ const messages: unknown[] = [];
+ const logger = Logger.make(({ message }) => {
+ messages.push(message);
+ });
+ const workspace = yield* instance.snapshotForCwd!(workspaceCwd).pipe(
+ Effect.provide(Logger.layer([logger], { mergeWithExisting: false })),
+ );
+ expect(workspace.skills).toEqual([]);
+ expect(workspace.auth).toEqual(machine.auth);
+ expect(messages.flat()).toContain("Grok skill discovery failed");
+ }),
+ ),
+ );
+
+ it.effect("keeps missing CLI skill discovery silent", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const instance = yield* createGrokInstance({
+ enabled: true,
+ binaryPath: "/no/provider/grok",
+ });
+ const messages: unknown[] = [];
+ const logger = Logger.make(({ message }) => {
+ messages.push(message);
+ });
+ const workspace = yield* instance.snapshotForCwd!(process.cwd()).pipe(
+ Effect.provide(Logger.layer([logger], { mergeWithExisting: false })),
+ );
+ expect(workspace.skills).toEqual([]);
+ expect(messages).toEqual([]);
}),
),
);
diff --git a/apps/server/src/provider/Drivers/GrokDriver.ts b/apps/server/src/provider/Drivers/GrokDriver.ts
index 7cfaad6a8..c6cb35e2f 100644
--- a/apps/server/src/provider/Drivers/GrokDriver.ts
+++ b/apps/server/src/provider/Drivers/GrokDriver.ts
@@ -11,14 +11,11 @@ import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts";
import { ServerConfig } from "../../config.ts";
import { instanceUsesSavedCredential } from "../../subscription-auth/runtime.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
-import { makeGrokTextGeneration } from "../../textGeneration/GrokTextGeneration.ts";
+import { makeHarnessTextGeneration } from "../../textGeneration/HarnessTextGeneration.ts";
import { ProviderDriverError } from "../Errors.ts";
-import { makeGrokAdapter } from "../Layers/GrokAdapter.ts";
-import {
- buildInitialGrokProviderSnapshot,
- checkGrokProviderStatus,
- enrichGrokSnapshot,
-} from "../Layers/GrokProvider.ts";
+import { makeHarnessProviderStatus } from "../HarnessProviderStatus.ts";
+import * as ModelManifest from "../ModelManifest.ts";
+import { buildInitialGrokProviderSnapshot, enrichGrokSnapshot } from "../Layers/GrokProvider.ts";
import { discoverGrokSkills } from "./GrokSkills.ts";
import { ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
@@ -27,7 +24,7 @@ import {
type ProviderDriver,
type ProviderInstance,
} from "../ProviderDriver.ts";
-import type { ServerProviderDraft } from "../providerSnapshot.ts";
+import { isCommandMissingCause, type ServerProviderDraft } from "../providerSnapshot.ts";
import { explicitProviderInstanceEnvironment } from "../ProviderInstanceEnvironment.ts";
import { mergeSubscriptionInstanceEnvironment } from "../../subscription-auth/runtime.ts";
import {
@@ -56,6 +53,7 @@ export type GrokDriverEnv =
| Crypto.Crypto
| FileSystem.FileSystem
| HttpClient.HttpClient
+ | ModelManifest.ModelManifest
| Path.Path
| ProviderEventLoggers
| ServerConfig
@@ -87,12 +85,10 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
defaultConfig: (): GrokSettings => decodeGrokSettings({}),
create: ({ instanceId, displayName, accentColor, environment, enabled, config }) =>
Effect.gen(function* () {
- const crypto = yield* Crypto.Crypto;
const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
const httpClient = yield* HttpClient.HttpClient;
const serverSettings = yield* ServerSettingsService;
const { secretsDir } = yield* ServerConfig;
- const eventLoggers = yield* ProviderEventLoggers;
const processEnv = mergeSubscriptionInstanceEnvironment(environment);
const continuationIdentity = defaultProviderContinuationIdentity({
driverKind: DRIVER_KIND,
@@ -105,28 +101,36 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
continuationGroupKey: continuationIdentity.continuationKey,
});
const effectiveConfig = { ...config, enabled } satisfies GrokSettings;
+ const connection = {
+ environment: processEnv,
+ instanceEnvironment: explicitProviderInstanceEnvironment(environment),
+ useSavedCredential: instanceUsesSavedCredential("xai", {
+ driver: DRIVER_KIND,
+ environment,
+ config,
+ }),
+ };
const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE, {
binaryPath: effectiveConfig.binaryPath,
env: processEnv,
});
- const adapter = yield* makeGrokAdapter(effectiveConfig, {
- environment: processEnv,
- ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}),
+ const adapter = undefined;
+ const textGeneration = yield* makeHarnessTextGeneration({
+ secretsDir,
+ driver: DRIVER_KIND,
instanceId,
+ connection,
});
- const textGeneration = yield* makeGrokTextGeneration(
- effectiveConfig,
- processEnv,
+
+ const checkProvider = (yield* makeHarnessProviderStatus({
secretsDir,
+ provider: "xai",
+ driver: DRIVER_KIND,
instanceId,
- );
-
- const checkProvider = checkGrokProviderStatus(effectiveConfig, processEnv).pipe(
- Effect.map(stampIdentity),
- Effect.provideService(Crypto.Crypto, crypto),
- Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
- );
+ connection,
+ draft: buildInitialGrokProviderSnapshot(effectiveConfig),
+ })).pipe(Effect.map(stampIdentity));
const snapshotSettings = makeProviderSnapshotSettingsSource(effectiveConfig, serverSettings);
const snapshot = yield* makeManagedServerProvider<ProviderSnapshotSettings<GrokSettings>>({
@@ -134,8 +138,7 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
getSettings: snapshotSettings.getSettings,
streamSettings: snapshotSettings.streamSettings,
haveSettingsChanged: haveProviderSnapshotSettingsChanged,
- initialSnapshot: (settings) =>
- buildInitialGrokProviderSnapshot(settings.provider).pipe(Effect.map(stampIdentity)),
+ initialSnapshot: () => checkProvider,
checkProvider,
enrichSnapshot: ({ settings, snapshot: currentSnapshot, publishSnapshot }) =>
enrichGrokSnapshot({
@@ -164,14 +167,10 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
snapshot.getSnapshot,
discoverGrokSkills(effectiveConfig, processEnv, workspaceCwd).pipe(
Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
- Effect.mapError(
- (cause) =>
- new ProviderDriverError({
- driver: DRIVER_KIND,
- instanceId,
- detail: `Failed to discover Grok skills for '${workspaceCwd}'`,
- cause,
- }),
+ Effect.catch((error) =>
+ error.stage === "spawn" && isCommandMissingCause(error.cause)
+ ? Effect.succeed([])
+ : Effect.logWarning("Grok skill discovery failed", error).pipe(Effect.as([])),
),
),
]).pipe(Effect.map(([machineSnapshot, skills]) => ({ ...machineSnapshot, skills })));
@@ -183,15 +182,7 @@ export const GrokDriver: ProviderDriver<GrokSettings, GrokDriverEnv> = {
displayName,
accentColor,
enabled,
- mastraConnection: {
- environment: processEnv,
- instanceEnvironment: explicitProviderInstanceEnvironment(environment),
- useSavedCredential: instanceUsesSavedCredential("xai", {
- driver: DRIVER_KIND,
- environment,
- config,
- }),
- },
+ mastraConnection: connection,
snapshot,
snapshotForCwd,
adapter,
diff --git a/apps/server/src/provider/Drivers/HarnessProviderDrivers.test.ts b/apps/server/src/provider/Drivers/HarnessProviderDrivers.test.ts
new file mode 100644
index 000000000..ed1ce6ee0
--- /dev/null
+++ b/apps/server/src/provider/Drivers/HarnessProviderDrivers.test.ts
@@ -0,0 +1,488 @@
+// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off
+import * as NodePath from "node:path";
+import { NodeServices } from "@effect/platform-node";
+import { describe, expect, it } from "@effect/vitest";
+import { ProviderInstanceId } from "@akeru/contracts";
+import * as DateTime from "effect/DateTime";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Fiber from "effect/Fiber";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { HttpClient } from "effect/unstable/http";
+import { vi } from "vite-plus/test";
+import { fakeJwt } from "../../subscription-auth/testUtils/scriptedHttpClient.ts";
+
+import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts";
+import { ServerConfig } from "../../config.ts";
+import { layerTest as settingsLayer, ServerSettingsService } from "../../serverSettings.ts";
+import { SubscriptionAuthService } from "../../subscription-auth/service.ts";
+import { makeSubscriptionProviderMutation } from "../../subscription-auth/providerMutation.ts";
+import { makeProviderInstanceRegistry } from "../Layers/ProviderInstanceRegistryLive.ts";
+import { deriveProviderInstanceConfigMap } from "../Layers/ProviderInstanceRegistryHydration.ts";
+import { ProviderRegistryLive } from "../Layers/ProviderRegistry.ts";
+import { ProviderInstanceRegistry } from "../Services/ProviderInstanceRegistry.ts";
+import { ProviderRegistry } from "../Services/ProviderRegistry.ts";
+import { NoOpProviderEventLoggers, ProviderEventLoggers } from "../Layers/ProviderEventLoggers.ts";
+import * as ModelManifest from "../ModelManifest.ts";
+import type { ProviderDriver, ProviderDriverCreateInput } from "../ProviderDriver.ts";
+import { CodexDriver } from "./CodexDriver.ts";
+import { ClaudeDriver } from "./ClaudeDriver.ts";
+import { GrokDriver } from "./GrokDriver.ts";
+
+const epoch = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");
+const testLayer = Layer.mergeAll(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-harness-driver-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ settingsLayer(),
+ ModelManifest.layerTest,
+ Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers),
+ Layer.succeed(
+ HttpClient.HttpClient,
+ HttpClient.make(() => Effect.die("No HTTP probes expected")),
+ ),
+ Layer.mock(BackgroundPolicy.BackgroundPolicy)({
+ reportClientActivity: () => Effect.void,
+ removeRpcClient: () => Effect.void,
+ reportHostPowerState: () => Effect.void,
+ snapshot: Effect.succeed({
+ hostPower: {
+ source: "unknown",
+ idle: "unknown",
+ locked: "unknown",
+ suspended: false,
+ onBattery: "unknown",
+ lowPowerMode: "unknown",
+ stale: true,
+ idleSeconds: null,
+ thermalState: "unknown",
+ updatedAt: epoch,
+ },
+ leases: [],
+ activeForegroundLeaseCount: 0,
+ activeScopeKeys: [],
+ shouldRunOpportunisticWork: true,
+ updatedAt: epoch,
+ }),
+ streamChanges: Stream.empty,
+ hasDemand: () => Effect.succeed(true),
+ shouldRunScopeWork: () => Effect.succeed(true),
+ shouldRunOpportunisticWork: Effect.succeed(true),
+ }),
+);
+
+function driverCase<Config, Environment>(driver: ProviderDriver<Config, Environment>) {
+ return {
+ rawDriver: driver,
+ driverKind: driver.driverKind,
+ create: (input: Omit<ProviderDriverCreateInput<Config>, "config"> & { homePath?: string }) =>
+ driver.create({
+ ...input,
+ config: {
+ ...driver.defaultConfig(),
+ binaryPath: "/no/provider/cli",
+ customModels: ["custom-model", "gpt-6-sol"],
+ ...(input.homePath ? { homePath: input.homePath } : {}),
+ },
+ }),
+ };
+}
+
+const cases = [
+ {
+ driver: driverCase(CodexDriver),
+ provider: "openai-codex",
+ name: "ChatGPT",
+ key: "OPENAI_API_KEY",
+ },
+ {
+ driver: driverCase(ClaudeDriver),
+ provider: "anthropic",
+ name: "Claude",
+ key: "ANTHROPIC_API_KEY",
+ },
+ { driver: driverCase(GrokDriver), provider: "xai", name: "Grok", key: "XAI_API_KEY" },
+] as const;
+
+// Ambient provider keys would count as explicit credentials and mask saved-credential readiness.
+for (const name of [
+ "OPENAI_API_KEY",
+ "ANTHROPIC_API_KEY",
+ "ANTHROPIC_AUTH_TOKEN",
+ "CLAUDE_CODE_OAUTH_TOKEN",
+ "XAI_API_KEY",
+]) {
+ vi.stubEnv(name, "");
+}
+
+const undefinedValuePaths = (value: unknown, path = "$"): string[] =>
+ value === undefined
+ ? [path]
+ : value !== null && typeof value === "object"
+ ? Object.entries(value).flatMap(([key, child]) =>
+ undefinedValuePaths(child, `${path}.${key}`),
+ )
+ : [];
+
+it.layer(testLayer)("Harness provider drivers without CLIs", (it) => {
+ it.effect("merges manifest models into Claude and Grok's built-in catalogs", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const fs = yield* FileSystem.FileSystem;
+ yield* fs.makeDirectory(config.secretsDir, { recursive: true });
+ yield* fs.writeFileString(
+ NodePath.join(config.secretsDir, "subscription-auth.json"),
+ JSON.stringify({
+ anthropic: { type: "api-key", access: "test-key" },
+ xai: { type: "api-key", access: "test-key" },
+ }),
+ );
+ for (const driver of [driverCase(ClaudeDriver), driverCase(GrokDriver)]) {
+ const added = driver.driverKind === "claudeAgent" ? "claude-next" : "grok-next";
+ const manifest = {
+ ...ModelManifest.BUNDLED_MODEL_MANIFEST,
+ currentModels: {
+ ...ModelManifest.BUNDLED_MODEL_MANIFEST.currentModels,
+ [driver.driverKind]: [added],
+ },
+ };
+ const instance = yield* driver
+ .create({
+ instanceId: ProviderInstanceId.make(String(driver.driverKind)),
+ displayName: undefined,
+ enabled: true,
+ environment: [{ name: "PATH", value: "", sensitive: false }],
+ })
+ .pipe(
+ Effect.provideService(ModelManifest.ModelManifest, {
+ current: Effect.succeed(manifest),
+ refresh: Effect.succeed(manifest),
+ refreshInBackground: Effect.void,
+ }),
+ );
+ const snapshot = yield* instance.snapshot.refresh;
+ expect(snapshot.status).toBe("ready");
+ expect(snapshot.models).toContainEqual(
+ expect.objectContaining({ slug: added, isCustom: false }),
+ );
+ expect(undefinedValuePaths(snapshot)).toEqual([]);
+ }
+ }),
+ ),
+ );
+
+ for (const { driver, provider, name, key } of cases) {
+ describe(name, () => {
+ it.effect(
+ "publishes login and logout immediately for default and named instances with health refresh disabled",
+ () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const settings = yield* ServerSettingsService;
+ const auth = yield* SubscriptionAuthService.forSecretsDir(config.secretsDir);
+ const namedId = ProviderInstanceId.make(`${driver.driverKind}_mutation`);
+ const defaultId = ProviderInstanceId.make(String(driver.driverKind));
+ yield* Effect.promise(() => auth.logout(provider));
+ yield* Effect.promise(() => auth.logout(provider, namedId));
+ const initial = yield* settings.updateSettings({
+ providerHealthRefreshInterval: Duration.millis(0),
+ providers: {
+ codex: { enabled: false, binaryPath: "/no/provider/cli" },
+ claudeAgent: { enabled: false, binaryPath: "/no/provider/cli" },
+ grok: { enabled: false, binaryPath: "/no/provider/cli" },
+ },
+ providerInstances: {
+ [namedId]: {
+ driver: driver.driverKind,
+ displayName: "Named mutation account",
+ enabled: true,
+ environment: [{ name: "PATH", value: "", sensitive: false }],
+ config: { binaryPath: "/no/provider/cli" },
+ },
+ },
+ });
+ const built = yield* makeProviderInstanceRegistry({
+ drivers: [driver.rawDriver],
+ configMap: deriveProviderInstanceConfigMap(initial),
+ });
+ const context = yield* Layer.build(
+ ProviderRegistryLive.pipe(
+ Layer.provide(Layer.succeed(ProviderInstanceRegistry, built.registry)),
+ ),
+ );
+ const registry = Context.get(context, ProviderRegistry);
+ const mutate = makeSubscriptionProviderMutation(
+ auth,
+ settings,
+ built.mutator,
+ registry,
+ );
+ for (const instanceId of [namedId, defaultId]) {
+ const receive = (status: "authenticated" | "unauthenticated") =>
+ registry.streamChanges.pipe(
+ Stream.filter((providers) =>
+ providers.some(
+ (snapshot) =>
+ snapshot.instanceId === instanceId && snapshot.auth.status === status,
+ ),
+ ),
+ Stream.runHead,
+ Effect.forkChild({ startImmediately: true }),
+ );
+ const connected = yield* receive("authenticated");
+ const deviceLogin = provider === "openai-codex" && instanceId === defaultId;
+ if (deviceLogin) {
+ let polls = 0;
+ yield* Effect.acquireRelease(
+ Effect.sync(() =>
+ vi.stubGlobal(
+ "fetch",
+ vi.fn(async (input: string | URL | Request) => {
+ const url = input instanceof Request ? input.url : String(input);
+ if (url.endsWith("/deviceauth/usercode"))
+ return Response.json({
+ device_auth_id: "mutation-device",
+ user_code: "TEST-CODE",
+ interval: "5",
+ });
+ if (url.endsWith("/deviceauth/token"))
+ return ++polls === 1
+ ? new Response("", { status: 403 })
+ : Response.json({
+ authorization_code: "test-code",
+ code_verifier: "test-verifier",
+ });
+ if (url.endsWith("/oauth/token"))
+ return Response.json({
+ access_token: "oauth-mutation-key",
+ refresh_token: "oauth-refresh",
+ expires_in: 3600,
+ id_token: fakeJwt({
+ "https://api.openai.com/auth": {
+ chatgpt_account_id: "test-account",
+ },
+ }),
+ });
+ throw new Error(`Unexpected OAuth request: ${url}`);
+ }),
+ ),
+ ),
+ () => Effect.sync(() => vi.unstubAllGlobals()),
+ );
+ }
+ const login = yield* Effect.promise(() =>
+ auth.startLogin(provider, {
+ authMode: deviceLogin ? "oauth" : "api-key",
+ ...(instanceId === namedId ? { instanceId } : {}),
+ }),
+ );
+ if (deviceLogin) {
+ expect(
+ yield* mutate(Effect.promise(() => auth.pollLogin(login.loginId))),
+ ).toMatchObject({ status: "pending" });
+ expect(
+ (yield* registry.getProviders).find(
+ (snapshot) => snapshot.instanceId === instanceId,
+ )?.auth.status,
+ ).toBe("unauthenticated");
+ }
+ const result = yield* mutate(
+ Effect.promise(() =>
+ deviceLogin
+ ? auth.pollLogin(login.loginId)
+ : auth.completeLogin(login.loginId, "mutation-test-key"),
+ ),
+ );
+ expect(result.status).toBe("connected");
+ expect(
+ (yield* registry.getProviders).find(
+ (snapshot) => snapshot.instanceId === instanceId,
+ ),
+ ).toMatchObject({
+ enabled: true,
+ status: "ready",
+ auth: { status: "authenticated" },
+ });
+ expect((yield* Fiber.join(connected))._tag).toBe("Some");
+ const disconnected = yield* receive("unauthenticated");
+ yield* mutate(
+ Effect.promise(() =>
+ auth.logout(provider, instanceId === namedId ? instanceId : undefined),
+ ),
+ );
+ expect(
+ (yield* registry.getProviders).find(
+ (snapshot) => snapshot.instanceId === instanceId,
+ )?.auth.status,
+ ).toBe("unauthenticated");
+ expect((yield* Fiber.join(disconnected))._tag).toBe("Some");
+ }
+ }),
+ ),
+ );
+
+ it.effect("uses saved credentials for initial readiness and refresh, without a CLI", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const fs = yield* FileSystem.FileSystem;
+ yield* fs.makeDirectory(config.secretsDir, { recursive: true });
+ const create = () =>
+ driver.create({
+ instanceId: ProviderInstanceId.make(String(driver.driverKind)),
+ displayName: undefined,
+ environment: [{ name: "PATH", value: "", sensitive: false }],
+ enabled: true,
+ });
+ const instance = yield* create();
+ const before = yield* instance.snapshot.getSnapshot;
+ expect(before).toMatchObject({
+ installed: true,
+ availability: "available",
+ status: "warning",
+ auth: { status: "unauthenticated" },
+ message: `Connect ${name} in Settings.`,
+ });
+ expect(before.models.length).toBeGreaterThan(1);
+ yield* fs.writeFileString(
+ NodePath.join(config.secretsDir, "subscription-auth.json"),
+ JSON.stringify({
+ [provider]: {
+ type: "oauth",
+ access: "test-access",
+ refresh: "test-refresh",
+ expires: 4_102_444_800_000,
+ },
+ }),
+ );
+ const after = yield* instance.snapshot.refresh;
+ expect(after).toMatchObject({
+ installed: true,
+ availability: "available",
+ status: "ready",
+ auth: { status: "authenticated" },
+ });
+ expect(after.message).toBeUndefined();
+ // The RPC transport rejects present-but-undefined keys as non-JSON.
+ expect(undefinedValuePaths(before)).toEqual([]);
+ expect(undefinedValuePaths(after)).toEqual([]);
+ expect(after.models).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ slug: "custom-model", isCustom: true }),
+ ]),
+ );
+ expect(after.models.some((model) => !model.isCustom && !model.isLegacy)).toBe(true);
+ expect(new Set(after.models.map((model) => model.slug)).size).toBe(after.models.length);
+ if (driver.driverKind === "codex") {
+ expect(after.models).toContainEqual(
+ expect.objectContaining({ slug: "gpt-5.4", isCustom: false, isLegacy: true }),
+ );
+ expect(
+ after.models.find((model) => model.slug === "gpt-6-sol")?.capabilities
+ ?.optionDescriptors,
+ ).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ id: "reasoningEffort", currentValue: "medium" }),
+ expect.objectContaining({ id: "serviceTier", currentValue: "default" }),
+ ]),
+ );
+ }
+ if (driver.driverKind === "grok") {
+ expect(after.models).toContainEqual(
+ expect.objectContaining({ slug: "grok-build", name: "Grok 4.6", isDefault: true }),
+ );
+ for (const slug of ["grok-4.6", "grok-4.5", "grok-code-fast-1"]) {
+ expect(after.models).toContainEqual(
+ expect.objectContaining({ slug, isCustom: false }),
+ );
+ }
+ }
+ if (driver.driverKind === "claudeAgent") {
+ expect(after.models).toContainEqual(
+ expect.objectContaining({ slug: "claude-opus-4-6", isLegacy: true }),
+ );
+ }
+ const connectedInstance = yield* create();
+ expect((yield* connectedInstance.snapshot.getSnapshot).status).toBe("ready");
+ expect(connectedInstance.adapter).toBeUndefined();
+ expect(connectedInstance.textGeneration).toBeDefined();
+ if (instance.snapshotForCwd)
+ expect((yield* instance.snapshotForCwd(config.cwd)).skills).toEqual([]);
+ }),
+ ),
+ );
+
+ it.effect("keeps a named instance's saved account separate from the default account", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const fs = yield* FileSystem.FileSystem;
+ yield* fs.makeDirectory(config.secretsDir, { recursive: true });
+ const instanceId = ProviderInstanceId.make(`${driver.driverKind}_named`);
+ yield* fs.writeFileString(
+ NodePath.join(config.secretsDir, "subscription-auth.json"),
+ JSON.stringify({ [provider]: { type: "api-key", access: "default-test-key" } }),
+ );
+ const instance = yield* driver.create({
+ instanceId,
+ displayName: "Named account",
+ environment: [{ name: "PATH", value: "", sensitive: false }],
+ enabled: true,
+ });
+ expect(instance.mastraConnection?.useSavedCredential).toBe(true);
+ expect((yield* instance.snapshot.getSnapshot).auth.status).toBe("unauthenticated");
+ yield* fs.writeFileString(
+ NodePath.join(config.secretsDir, "subscription-auth.json"),
+ JSON.stringify({
+ [`instance:${provider}:${instanceId}`]: {
+ type: "api-key",
+ access: "named-test-key",
+ },
+ }),
+ );
+ expect((yield* instance.snapshot.refresh).status).toBe("ready");
+ }),
+ ),
+ );
+
+ it.effect(
+ "uses explicit credentials without falling back to a saved account or CLI home",
+ () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const fs = yield* FileSystem.FileSystem;
+ yield* fs.makeDirectory(config.secretsDir, { recursive: true });
+ yield* fs.writeFileString(
+ NodePath.join(config.secretsDir, "subscription-auth.json"),
+ JSON.stringify({ [provider]: { type: "api-key", access: "saved-key" } }),
+ );
+ for (const value of ["", "explicit-key"]) {
+ const instance = yield* driver.create({
+ instanceId: ProviderInstanceId.make(`${driver.driverKind}_custom`),
+ displayName: undefined,
+ environment: [
+ { name: "PATH", value: "", sensitive: false },
+ { name: key, value, sensitive: true },
+ ],
+ enabled: true,
+ homePath: "/no/provider/home",
+ });
+ const snapshot = yield* instance.snapshot.getSnapshot;
+ expect(instance.mastraConnection?.useSavedCredential).toBe(false);
+ expect(snapshot.installed).toBe(true);
+ expect(snapshot.status).toBe(value ? "ready" : "warning");
+ expect(snapshot.auth.status).toBe(value ? "authenticated" : "unauthenticated");
+ if (!value) expect(snapshot.message).toContain("Akeru harness");
+ }
+ }),
+ ),
+ );
+ });
+ }
+});
diff --git a/apps/server/src/provider/HarnessProviderStatus.ts b/apps/server/src/provider/HarnessProviderStatus.ts
new file mode 100644
index 000000000..7b31a7eee
--- /dev/null
+++ b/apps/server/src/provider/HarnessProviderStatus.ts
@@ -0,0 +1,184 @@
+import {
+ MODEL_SLUG_ALIASES_BY_PROVIDER,
+ ProviderDriverKind,
+ type ProviderInstanceId,
+} from "@akeru/contracts";
+import { getAvailableThinkingLevelsForModel } from "@mastra/code-sdk/thinking";
+import { createModelCapabilities } from "@akeru/shared/model";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+
+import {
+ SubscriptionAuthService,
+ type SubscriptionProviderId,
+} from "../subscription-auth/service.ts";
+import type { ProviderInstance } from "./ProviderDriver.ts";
+import * as ModelManifest from "./ModelManifest.ts";
+import type { ServerProviderDraft } from "./providerSnapshot.ts";
+import { getClaudeModelCapabilities } from "./Layers/ClaudeProvider.ts";
+
+export const GROK_HARNESS_MODELS = [
+ "grok-4.6",
+ "grok-4.5",
+ "grok-4",
+ "grok-4.20-beta",
+ "grok-code-fast-1",
+] as const;
+
+export const CODEX_HARNESS_HISTORICAL_MODELS = [
+ ...Object.values(MODEL_SLUG_ALIASES_BY_PROVIDER[ProviderDriverKind.make("codex")] ?? {}),
+ "gpt-5.4-mini",
+ "gpt-5.4-pro",
+ "gpt-5.5",
+ "gpt-5.2-codex",
+ "gpt-5.2",
+ "gpt-5.1-codex-max",
+ "gpt-5.1-codex-mini",
+ "gpt-5.1-codex",
+ "gpt-5.1",
+ "gpt-5-codex",
+ "gpt-5",
+ "codex-mini-latest",
+] as const;
+
+export function codexHarnessModelIds(currentModels: ReadonlyArray<string>): string[] {
+ return [
+ ...new Set([
+ ...currentModels,
+ ...(ModelManifest.BUNDLED_MODEL_MANIFEST.currentModels.codex ?? []),
+ ...CODEX_HARNESS_HISTORICAL_MODELS,
+ ]),
+ ];
+}
+
+export function harnessCredentialIssue(
+ driver: ProviderDriverKind,
+ connection: NonNullable<ProviderInstance["mastraConnection"]>,
+ savedCredentialConnected: boolean,
+): string | undefined {
+ const environment = connection.useSavedCredential
+ ? connection.environment
+ : connection.instanceEnvironment;
+ const connected =
+ driver === "codex"
+ ? Boolean(environment.OPENAI_API_KEY?.trim())
+ : driver === "claudeAgent"
+ ? Boolean(
+ environment.ANTHROPIC_API_KEY?.trim() ||
+ environment.ANTHROPIC_AUTH_TOKEN?.trim() ||
+ environment.CLAUDE_CODE_OAUTH_TOKEN?.trim(),
+ )
+ : Boolean(environment.XAI_API_KEY?.trim());
+ if (connected || (connection.useSavedCredential && savedCredentialConnected)) return undefined;
+ if (connection.useSavedCredential) {
+ const name = driver === "codex" ? "ChatGPT" : driver === "claudeAgent" ? "Claude" : "Grok";
+ return `Connect ${name} in Settings.`;
+ }
+ if (driver === "codex") return "This Codex instance needs OPENAI_API_KEY for the Akeru harness.";
+ if (driver === "claudeAgent")
+ return "This Claude instance needs an API key or auth token for the Akeru harness.";
+ return "This Grok instance needs XAI_API_KEY for the Akeru harness.";
+}
+
+export const makeHarnessProviderStatus = Effect.fn("makeHarnessProviderStatus")(function* (input: {
+ readonly secretsDir: string;
+ readonly provider: SubscriptionProviderId;
+ readonly driver: ProviderDriverKind;
+ readonly instanceId: ProviderInstanceId;
+ readonly connection: NonNullable<ProviderInstance["mastraConnection"]>;
+ readonly draft: Effect.Effect<ServerProviderDraft>;
+}) {
+ const auth = yield* SubscriptionAuthService.forSecretsDir(input.secretsDir);
+ const manifest = yield* ModelManifest.ModelManifest;
+ return Effect.gen(function* () {
+ yield* auth.reload();
+ yield* manifest.refreshInBackground;
+ const current = yield* manifest.current;
+ const { message: _draftMessage, ...draft } = yield* input.draft;
+ const message = harnessCredentialIssue(
+ input.driver,
+ input.connection,
+ auth.isConnected(input.provider, input.instanceId),
+ );
+ const currentModelIds = current.currentModels[input.driver];
+ const modelIds =
+ input.driver === "codex"
+ ? codexHarnessModelIds(currentModelIds ?? [])
+ : [
+ ...new Set([
+ ...(currentModelIds ?? []),
+ ...(ModelManifest.BUNDLED_MODEL_MANIFEST.currentModels[input.driver] ?? []),
+ ...(input.driver === "grok" ? GROK_HARNESS_MODELS : []),
+ ]),
+ ];
+ const models = [
+ ...draft.models.filter((model) => !model.isCustom || !modelIds.includes(model.slug)),
+ ...modelIds
+ .filter((slug) => !draft.models.some((model) => !model.isCustom && model.slug === slug))
+ .map((slug, index) => ({
+ slug,
+ name: slug,
+ isCustom: false,
+ ...(index === 0 && !draft.models.some((model) => !model.isCustom)
+ ? { isDefault: true }
+ : {}),
+ capabilities:
+ input.driver === "codex"
+ ? createModelCapabilities({
+ optionDescriptors: [
+ {
+ id: "reasoningEffort",
+ label: "Reasoning",
+ type: "select",
+ currentValue: "medium",
+ options: getAvailableThinkingLevelsForModel(`openai/${slug}`).map(
+ (level) => ({
+ id: level,
+ label: level[0]!.toUpperCase() + level.slice(1),
+ ...(level === "medium" ? { isDefault: true } : {}),
+ }),
+ ),
+ },
+ {
+ id: "serviceTier",
+ label: "Service Tier",
+ type: "select",
+ currentValue: "default",
+ options: [
+ { id: "default", label: "Standard", isDefault: true },
+ { id: "priority", label: "Fast" },
+ ],
+ },
+ ],
+ })
+ : input.driver === "claudeAgent"
+ ? getClaudeModelCapabilities(slug)
+ : null,
+ })),
+ ];
+ return ModelManifest.applyModelManifest(
+ {
+ ...draft,
+ installed: true,
+ availability: "available",
+ version: null,
+ checkedAt: DateTime.formatIso(yield* DateTime.now),
+ status: !draft.enabled ? "disabled" : message ? "warning" : "ready",
+ auth: { status: message ? "unauthenticated" : "authenticated" },
+ ...(draft.enabled && message ? { message } : {}),
+ models:
+ input.driver === "grok"
+ ? models.map((model) =>
+ model.slug === "grok-build" && !model.isCustom
+ ? { ...model, name: "Grok 4.6", isDefault: true }
+ : model,
+ )
+ : models,
+ slashCommands: [],
+ skills: [],
+ },
+ current,
+ input.driver,
+ );
+ });
+});
diff --git a/apps/server/src/provider/Layers/AgentController.test.ts b/apps/server/src/provider/Layers/AgentController.test.ts
index 56c56139f..948be6a58 100644
--- a/apps/server/src/provider/Layers/AgentController.test.ts
+++ b/apps/server/src/provider/Layers/AgentController.test.ts
@@ -1,5 +1,6 @@
// @effect-diagnostics globalDate:off globalFetch:off globalFetchInEffect:off nodeBuiltinImport:off preferSchemaOverJson:off
import * as NodeCrypto from "node:crypto";
+import { codexHarnessModelIds, GROK_HARNESS_MODELS } from "../HarnessProviderStatus.ts";
import * as NodeFS from "node:fs";
import * as NodeHttp from "node:http";
import type * as NodeNet from "node:net";
@@ -7884,7 +7885,7 @@ describe("AgentControllerLive", () => {
expect(bridge.sendTurn).not.toHaveBeenCalled();
expect(mastra.createSession).toHaveBeenCalledOnce();
expect(mastra.session.model.switch).toHaveBeenCalledWith({
- modelId: "anthropic/claude-fable-5",
+ modelId: "anthropic/claude-fable-5[1m]",
});
expect(mastra.sendMessage).toHaveBeenCalledOnce();
}),
@@ -8700,12 +8701,12 @@ describe("AgentControllerLive", () => {
mastra.finishSend();
yield* Effect.yieldNow;
expect(mastra.session.model.switch).toHaveBeenCalledWith({
- modelId: `${testCase.wirePrefix}/${testCase.from}`,
+ modelId: `${testCase.wirePrefix}/${testCase.from}${testCase.provider === "claudeAgent" ? "[1m]" : ""}`,
});
yield* resolve(testCase.to);
expect(mastra.session.model.switch).toHaveBeenCalledWith({
- modelId: `${testCase.wirePrefix}/${testCase.to}`,
+ modelId: `${testCase.wirePrefix}/${testCase.to}${testCase.provider === "claudeAgent" ? "[1m]" : ""}`,
});
expect(mastra.createSession).toHaveBeenCalledOnce();
@@ -8738,6 +8739,90 @@ describe("AgentControllerLive", () => {
);
}
+ it.effect(
+ "continues an existing engine using a historical Codex model outside currentModels",
+ () => {
+ const bridge = makeBridge();
+ const mastra = makeMastraHarness();
+ instanceModelCatalog.set(String(codexInstanceId), {
+ models: codexHarnessModelIds(["gpt-6-sol"]),
+ });
+ return provideController(
+ Effect.gen(function* () {
+ const controller = yield* AgentController;
+ const resolved = yield* controller.resolveEngine({
+ threadId: codexThreadId,
+ engine: { provider: "codex", model: "gpt-5.4" },
+ fallback: codexSelection,
+ mode: "default",
+ botConversation: true,
+ });
+ assert.equal(resolved.modelSelection.model, "gpt-5.4");
+ }),
+ bridge.service,
+ mastra.factory,
+ );
+ },
+ );
+
+ for (const model of ["grok-4.6", "grok-4.5"] as const) {
+ it.effect(`continues an existing ready Grok engine using ${model}`, () => {
+ const bridge = makeBridge();
+ const mastra = makeMastraHarness();
+ instanceModelCatalog.set(String(grokInstanceId), { models: [...GROK_HARNESS_MODELS] });
+ return provideController(
+ Effect.gen(function* () {
+ const controller = yield* AgentController;
+ const resolved = yield* controller.resolveEngine({
+ threadId: grokThreadId,
+ engine: { provider: "grok", model },
+ fallback: { instanceId: grokInstanceId, model: "grok-build" },
+ mode: "default",
+ botConversation: true,
+ });
+ assert.equal(resolved.modelSelection.model, model);
+ }),
+ bridge.service,
+ mastra.factory,
+ );
+ });
+ }
+
+ it.effect("preserves an existing Claude engine and its 1M context selection", () => {
+ const bridge = makeBridge();
+ const mastra = makeMastraHarness();
+ instanceModelCatalog.set(String(claudeInstanceId), { models: ["claude-opus-4-6"] });
+ return provideController(
+ Effect.gen(function* () {
+ const controller = yield* AgentController;
+ const resolved = yield* controller.resolveEngine({
+ threadId: claudeThreadId,
+ engine: {
+ provider: "claudeAgent",
+ model: "claude-opus-4-6",
+ options: [{ id: "contextWindow", value: "1m" }],
+ },
+ fallback: { instanceId: claudeInstanceId, model: "claude-fable-5" },
+ mode: "default",
+ botConversation: true,
+ });
+ assert.equal(resolved.modelSelection.model, "claude-opus-4-6");
+ yield* controller.startSession(claudeThreadId, {
+ threadId: claudeThreadId,
+ provider: ProviderDriverKind.make("claudeAgent"),
+ providerInstanceId: claudeInstanceId,
+ cwd: process.cwd(),
+ runtimeMode: "approval-required",
+ });
+ expect(mastra.session.model.switch).toHaveBeenCalledWith({
+ modelId: "anthropic/claude-opus-4-6[1m]",
+ });
+ }),
+ bridge.service,
+ mastra.factory,
+ );
+ });
+
it.effect("fails closed when the saved model is not in the instance snapshot", () => {
const bridge = makeBridge();
const mastra = makeMastraHarness();
@@ -9707,7 +9792,7 @@ describe("AgentControllerLive", () => {
instanceId: claudeInstanceId,
model: "claude-opus-4-6",
options: [{ id: "effort", value: "max" }] as const,
- wireModelId: "anthropic/claude-opus-4-6",
+ wireModelId: "anthropic/claude-opus-4-6[1m]",
modelOptions: undefined,
},
{
diff --git a/apps/server/src/provider/Layers/AgentController.ts b/apps/server/src/provider/Layers/AgentController.ts
index 2d62dd962..7d86ee4ae 100644
--- a/apps/server/src/provider/Layers/AgentController.ts
+++ b/apps/server/src/provider/Layers/AgentController.ts
@@ -4,6 +4,8 @@ import * as NodeFS from "node:fs";
import * as NodePath from "node:path";
import { AuthStorage } from "@mastra/code-sdk/auth/storage";
+import { harnessCredentialIssue } from "../HarnessProviderStatus.ts";
+import { resolveClaudeApiModelId } from "./ClaudeProvider.ts";
import {
createMcpManager,
type McpManager,
@@ -648,22 +650,15 @@ export function mastraConnectionIssue(
savedCredentialConnected: boolean,
): string | undefined {
if (!connection) return undefined;
+ if (provider === "codex" || provider === "claudeAgent" || provider === "grok") {
+ return harnessCredentialIssue(provider, connection, savedCredentialConnected);
+ }
const env = connection.useSavedCredential
? connection.environment
: connection.instanceEnvironment;
if (connection.useSavedCredential) {
const hasAmbientCredential = (() => {
switch (String(provider)) {
- case "codex":
- return Boolean(env.OPENAI_API_KEY?.trim());
- case "claudeAgent":
- return Boolean(
- env.ANTHROPIC_API_KEY?.trim() ||
- env.ANTHROPIC_AUTH_TOKEN?.trim() ||
- env.CLAUDE_CODE_OAUTH_TOKEN?.trim(),
- );
- case "grok":
- return Boolean(env.XAI_API_KEY?.trim());
case "opencodeGo":
return Boolean(env.OPENCODE_API_KEY?.trim() || openCodeGoInlineConnection(env).apiKey);
default:
@@ -676,20 +671,6 @@ export function mastraConnectionIssue(
: `Connect ${provider} in Settings before starting.`;
}
switch (String(provider)) {
- case "codex":
- return env.OPENAI_API_KEY?.trim()
- ? undefined
- : "This Codex instance needs OPENAI_API_KEY for the Akeru harness.";
- case "claudeAgent":
- return env.ANTHROPIC_API_KEY?.trim() ||
- env.ANTHROPIC_AUTH_TOKEN?.trim() ||
- env.CLAUDE_CODE_OAUTH_TOKEN?.trim()
- ? undefined
- : "This Claude instance needs an API key or auth token for the Akeru harness.";
- case "grok":
- return env.XAI_API_KEY?.trim()
- ? undefined
- : "This Grok instance needs XAI_API_KEY for the Akeru harness.";
case "kimi":
return "Custom Kimi credentials are not supported by the Akeru harness.";
case "opencodeGo":
@@ -2840,7 +2821,12 @@ const make = (options?: AgentControllerLiveOptions) =>
modelSelection,
provider: inspected.routing.driverKind,
providerInstanceId: modelSelection.instanceId,
- mastraModelId: mastraModelId(inspected.routing.driverKind, modelSelection.model),
+ mastraModelId: mastraModelId(
+ inspected.routing.driverKind,
+ inspected.routing.driverKind === "claudeAgent"
+ ? resolveClaudeApiModelId(modelSelection)
+ : modelSelection.model,
+ ),
mode: input.mode,
botConversation: input.botConversation,
...(previous?.botName ? { botName: previous.botName } : {}),
diff --git a/apps/server/src/provider/Layers/ProviderInstanceRegistryHydration.ts b/apps/server/src/provider/Layers/ProviderInstanceRegistryHydration.ts
index 161822fe4..bfe7fc1ec 100644
--- a/apps/server/src/provider/Layers/ProviderInstanceRegistryHydration.ts
+++ b/apps/server/src/provider/Layers/ProviderInstanceRegistryHydration.ts
@@ -149,11 +149,11 @@ const SettingsWatcherLive = Layer.effectDiscard(
*
* Composing via `Layer.provideMerge` makes the watcher's deps available
* from the mutable layer while still surfacing the registry as an output.
- * The mutator tag is technically also exposed; only this module imports
- * it, so the visibility leak is harmless in practice.
+ * The mutator is also exposed so credential mutations can await reconciliation
+ * before refreshing and publishing the affected provider snapshots.
*/
export const ProviderInstanceRegistryHydrationLive: Layer.Layer<
- ProviderInstanceRegistry,
+ ProviderInstanceRegistry | ProviderInstanceRegistryMutator,
never,
BuiltInDriversEnv | ServerSettingsService
> = Layer.unwrap(
@@ -174,4 +174,8 @@ export const ProviderInstanceRegistryHydrationLive: Layer.Layer<
return SettingsWatcherLive.pipe(Layer.provideMerge(mutableLayer));
}),
-) as Layer.Layer<ProviderInstanceRegistry, never, BuiltInDriversEnv | ServerSettingsService>;
+) as Layer.Layer<
+ ProviderInstanceRegistry | ProviderInstanceRegistryMutator,
+ never,
+ BuiltInDriversEnv | ServerSettingsService
+>;
diff --git a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts
index fe5d0b916..13332a4fa 100644
--- a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts
+++ b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts
@@ -211,7 +211,9 @@ describe("ProviderInstanceRegistryLive — multi-instance codex slice", () => {
const work = yield* registry.getInstance(workId);
expect(personal).toBeDefined();
expect(work).toBeDefined();
- expect(personal!.adapter).not.toBe(work!.adapter);
+ expect(personal!.adapter).toBeUndefined();
+ expect(work!.adapter).toBeUndefined();
+ expect(personal!.mastraConnection).not.toBe(work!.mastraConnection);
expect(personal!.textGeneration).not.toBe(work!.textGeneration);
expect(personal!.snapshot).not.toBe(work!.snapshot);
@@ -464,12 +466,11 @@ describe("ProviderInstanceRegistryLive — all drivers slice", () => {
expect(kimi?.displayName).toBe("Kimi For Coding");
expect(openCode?.displayName).toBe("OpenCode");
- // Every instance owns its own set of closures — no sharing across
- // drivers. `adapter` / `textGeneration` / `snapshot` are all
- // distinct references. Kimi is Mastra-native, so it intentionally has
- // no legacy adapter or text-generation closure.
- const adapters = [codex!.adapter, claude!.adapter, grok!.adapter, openCode!.adapter];
- expect(new Set(adapters).size).toBe(adapters.length);
+ for (const instance of [codex!, claude!, grok!, kimi!]) {
+ expect(instance.adapter).toBeUndefined();
+ expect(instance.mastraConnection).toBeDefined();
+ }
+ expect(openCode!.adapter).toBeDefined();
const textGenerations = [
codex!.textGeneration,
claude!.textGeneration,
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.test.ts b/apps/server/src/provider/Layers/ProviderRegistry.test.ts
index 7eda87f42..911ad0d45 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.test.ts
@@ -1722,133 +1722,97 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te
}),
);
- // This test intentionally avoids `mockCommandSpawnerLayer` so the real
- // `probeCodexAppServerProvider` path runs — including the full
- // `codex app-server` RPC handshake via `CodexClient.layerChildProcess`.
- // We point `binaryPath` at a name that cannot exist on any machine so
- // the real `ChildProcessSpawner` deterministically returns ENOENT; the
- // probe wraps that as `CodexAppServerSpawnError` and
- // `checkCodexProviderStatus` turns it into the user-visible "not
- // installed" error snapshot. If the aggregator's `syncLiveSources`
- // breaks — the `codex_personal`-never-probes bug we are guarding
- // against — that snapshot never lands in `getProviders` and the
- // assertions below fail.
- it.effect("propagates real Codex probe failures to the aggregator at boot", () =>
- Effect.gen(function* () {
- const missingBinary = `t3code_codex_missing_`;
- const serverSettings = yield* makeMutableServerSettingsService(
- decodeServerSettings(
- deepMerge(encodedDefaultServerSettings, {
- providers: {
- // Disable every built-in probe that would otherwise spawn
- // on the CI host. `enabled: false` short-circuits each
- // driver's probe *before* it touches the spawner, so the
- // test environment stays isolated from the dev
- // machine's PATH.
- codex: { enabled: false },
- claudeAgent: { enabled: false },
- grok: { enabled: false },
- opencode: { enabled: false },
- },
- // `providerInstances` keys are branded `ProviderInstanceId`;
- // the branded index signature rejects plain string literals
- // at the TS level even though the runtime schema happily
- // accepts + decodes them. Cast the patch to `unknown` so
- // the `Schema.decodeSync` below does the real validation.
- providerInstances: {
- // Matches the shape the user had in `.t3/dev/settings.json`
- // when the bug was reported: a custom enabled Codex instance
- // pointing at a binary the server has to actually spawn.
- codex_personal: {
- driver: "codex",
- displayName: "Codex Personal",
- enabled: true,
- config: {
- binaryPath: missingBinary,
- homePath: `/tmp/${missingBinary}_home`,
- },
+ it.effect(
+ "publishes harness credential readiness even when the Codex binary is missing",
+ () =>
+ Effect.gen(function* () {
+ const missingBinary = `t3code_codex_missing_`;
+ const serverSettings = yield* makeMutableServerSettingsService(
+ decodeServerSettings(
+ deepMerge(encodedDefaultServerSettings, {
+ providers: {
+ // Disable every built-in probe that would otherwise spawn
+ // on the CI host. `enabled: false` short-circuits each
+ // driver's probe *before* it touches the spawner, so the
+ // test environment stays isolated from the dev
+ // machine's PATH.
+ codex: { enabled: false },
+ claudeAgent: { enabled: false },
+ grok: { enabled: false },
+ opencode: { enabled: false },
},
- } as unknown as ContractServerSettings["providerInstances"],
- }),
- ),
- );
- const scope = yield* Scope.make();
- yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
- const providerRegistryLayer = ProviderRegistryLive.pipe(
- Layer.provideMerge(ProviderInstanceRegistryHydrationLive),
- Layer.provideMerge(
- Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings),
- ),
- Layer.provideMerge(
- ServerConfig.layerTest(process.cwd(), {
- prefix: "t3-provider-registry-",
- }),
- ),
- Layer.provideMerge(TestHttpClientLive),
- Layer.provideMerge(
- Layer.succeed(
- ProviderEventLoggers.ProviderEventLoggers,
- ProviderEventLoggers.NoOpProviderEventLoggers,
+ // `providerInstances` keys are branded `ProviderInstanceId`;
+ // the branded index signature rejects plain string literals
+ // at the TS level even though the runtime schema happily
+ // accepts + decodes them. Cast the patch to `unknown` so
+ // the `Schema.decodeSync` below does the real validation.
+ providerInstances: {
+ codex_personal: {
+ driver: "codex",
+ displayName: "Codex Personal",
+ enabled: true,
+ config: {
+ binaryPath: missingBinary,
+ homePath: `/tmp/${missingBinary}_home`,
+ },
+ },
+ } as unknown as ContractServerSettings["providerInstances"],
+ }),
),
- ),
- Layer.provideMerge(ModelManifest.layerTest),
- Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive),
- Layer.provideMerge(BackgroundPolicyAlwaysRunLayer),
- // NO spawner mock — `ChildProcessSpawner` is supplied by the
- // outer `NodeServices.layer` on `it.layer(...)` and will
- // genuinely spawn a subprocess. The missing-binary ENOENT is
- // what exercises the same failure mode as a misconfigured
- // production `binaryPath`.
- );
- const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe(
- Scope.provide(scope),
- );
-
- yield* Effect.gen(function* () {
- const registry = yield* ProviderRegistry.ProviderRegistry;
- let providers = yield* registry.getProviders;
- for (
- let attempts = 0;
- attempts < 50 &&
- providers.find((provider) => provider.instanceId === "codex_personal")?.status !==
- "error";
- attempts += 1
- ) {
- yield* Effect.yieldNow;
- providers = yield* registry.getProviders;
- }
- const codexPersonal = providers.find(
- (provider) => provider.instanceId === "codex_personal",
- );
- assert.notStrictEqual(
- codexPersonal,
- undefined,
- `Expected the aggregator to know about codex_personal; instead saw: ${providers
- .map((provider) => provider.instanceId)
- .join(", ")}`,
);
- assert.strictEqual(
- codexPersonal?.status,
- "error",
- "Real Codex probe against a missing binary should surface as 'error' in the aggregator",
+ const scope = yield* Scope.make();
+ yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
+ const providerRegistryLayer = ProviderRegistryLive.pipe(
+ Layer.provideMerge(ProviderInstanceRegistryHydrationLive),
+ Layer.provideMerge(
+ Layer.succeed(ServerSettingsModule.ServerSettingsService, serverSettings),
+ ),
+ Layer.provideMerge(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3-provider-registry-",
+ }),
+ ),
+ Layer.provideMerge(TestHttpClientLive),
+ Layer.provideMerge(
+ Layer.succeed(
+ ProviderEventLoggers.ProviderEventLoggers,
+ ProviderEventLoggers.NoOpProviderEventLoggers,
+ ),
+ ),
+ Layer.provideMerge(ModelManifest.layerTest),
+ Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive),
+ Layer.provideMerge(BackgroundPolicyAlwaysRunLayer),
);
- assert.strictEqual(codexPersonal?.installed, false);
- assert.strictEqual(
- codexPersonal?.message,
- "Codex CLI (`codex`) was not found on PATH.",
+ const runtimeServices = yield* Layer.build(providerRegistryLayer).pipe(
+ Scope.provide(scope),
);
- }).pipe(Effect.provide(runtimeServices));
- }),
+
+ yield* Effect.gen(function* () {
+ const registry = yield* ProviderRegistry.ProviderRegistry;
+ yield* registry.refreshInstance(ProviderInstanceId.make("codex_personal"));
+ const providers = yield* registry.getProviders;
+ const codexPersonal = providers.find(
+ (provider) => provider.instanceId === "codex_personal",
+ );
+ assert.notStrictEqual(
+ codexPersonal,
+ undefined,
+ `Expected the aggregator to know about codex_personal; instead saw: ${providers
+ .map((provider) => provider.instanceId)
+ .join(", ")}`,
+ );
+ assert.strictEqual(codexPersonal?.status, "warning");
+ assert.strictEqual(codexPersonal?.installed, true);
+ assert.strictEqual(
+ codexPersonal?.message,
+ "This Codex instance needs OPENAI_API_KEY for the Akeru harness.",
+ );
+ assert.ok((codexPersonal?.models.length ?? 0) > 0);
+ }).pipe(Effect.provide(runtimeServices));
+ }),
);
- // Guards the second half of the reported bug: changing
- // `providers.codex.binaryPath` in settings must tear down the live
- // instance and rebuild it so a fresh probe runs with the new binary.
- // This test drives the real settings stream → registry reconcile →
- // aggregator sync pipeline and asserts that `getProviders` reflects
- // the new background probe's outcome.
- //
- it.effect("re-probes when settings change the codex binaryPath", () =>
+ it.effect("refreshes harness readiness when settings change Codex credentials", () =>
Effect.gen(function* () {
const firstMissing = `t3code_codex_first_`;
const secondMissing = `t3code_codex_second_`;
@@ -1901,62 +1865,43 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
- // Boot-time probe: the default codex instance is enabled with
- // `firstMissing`, so the real spawner yields ENOENT and the
- // snapshot should be `status: "error"`.
- let initialProviders = yield* registry.getProviders;
- for (
- let attempts = 0;
- attempts < 50 &&
- initialProviders.find((provider) => provider.instanceId === "codex")?.status !==
- "error";
- attempts += 1
- ) {
- yield* TestClock.adjust("10 millis");
- yield* Effect.yieldNow;
- initialProviders = yield* registry.getProviders;
- }
+ yield* registry.refreshInstance(ProviderInstanceId.make("codex"));
+ const initialProviders = yield* registry.getProviders;
const initialCodex = initialProviders.find(
(provider) => provider.instanceId === "codex",
);
- assert.strictEqual(initialCodex?.status, "error");
- assert.strictEqual(initialCodex?.installed, false);
- assert.deepStrictEqual(spawnedCommands, [firstMissing]);
-
- // Drive a settings change. The Hydration layer's
- // `SettingsWatcherLive` consumes this via `streamChanges`,
- // calls `reconcile`, which rebuilds the codex instance (the
- // envelope changed because `binaryPath` differs → `entryEqual`
- // is false). The registry's `Stream.runForEach(
- // instanceRegistry.streamChanges, () => syncLiveSources)`
- // fires `syncLiveSources`, which subscribes and launches a fresh
- // background refresh on the rebuilt instance.
+ assert.strictEqual(initialCodex?.status, "warning");
+ assert.strictEqual(initialCodex?.installed, true);
+ assert.deepStrictEqual(spawnedCommands, []);
+
const nextProbe = yield* Stream.runHead(
registry.streamChanges.pipe(
Stream.filter(
(providers) =>
- spawnedCommands.includes(secondMissing) &&
providers.find((provider) => provider.instanceId === "codex")?.status ===
- "error",
+ "ready",
),
),
).pipe(Effect.forkChild({ startImmediately: true }));
yield* Effect.yieldNow;
yield* serverSettings.updateSettings({
- providers: {
- codex: { enabled: true, binaryPath: secondMissing },
- },
+ providerInstances: {
+ codex: {
+ driver: "codex",
+ displayName: "Codex",
+ enabled: true,
+ config: { binaryPath: secondMissing },
+ environment: [{ name: "OPENAI_API_KEY", value: "test-key" }],
+ },
+ } as unknown as ContractServerSettings["providerInstances"],
});
- // The registry publishes the completed probe after updating its
- // snapshot. Wait for that receipt instead of racing the real
- // child-process event against a fixed number of scheduler turns.
const refreshed = Option.getOrThrow(yield* Fiber.join(nextProbe));
const reprobedCodex = refreshed.find((provider) => provider.instanceId === "codex");
- assert.deepStrictEqual(spawnedCommands, [firstMissing, secondMissing]);
- assert.strictEqual(reprobedCodex?.status, "error");
- assert.strictEqual(reprobedCodex?.installed, false);
+ assert.deepStrictEqual(spawnedCommands, []);
+ assert.strictEqual(reprobedCodex?.status, "ready");
+ assert.strictEqual(reprobedCodex?.installed, true);
}).pipe(Effect.provide(runtimeServices));
}),
);
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.ts b/apps/server/src/provider/Layers/ProviderRegistry.ts
index 60d4e013f..38f939a42 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.ts
@@ -40,6 +40,7 @@ import * as PubSub from "effect/PubSub";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import * as Semaphore from "effect/Semaphore";
+import * as Scope from "effect/Scope";
import { ServerConfig } from "../../config.ts";
import { ProviderInstanceRegistry } from "../Services/ProviderInstanceRegistry.ts";
@@ -228,6 +229,7 @@ export const ProviderRegistryLive = Layer.effect(
ProviderRegistry,
Effect.gen(function* () {
const instanceRegistry = yield* ProviderInstanceRegistry;
+ const scope = yield* Scope.Scope;
const config = yield* ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
@@ -763,7 +765,11 @@ export const ProviderRegistryLive = Layer.effect(
refresh: (provider?: ProviderDriverKind) =>
refresh(provider).pipe(Effect.catchCause(recoverRefreshFailure)),
refreshInstance: (instanceId: ProviderInstanceId) =>
- refreshInstance(instanceId).pipe(Effect.catchCause(recoverRefreshFailure)),
+ syncLiveSources.pipe(
+ Effect.andThen(refreshInstance(instanceId)),
+ Effect.provideService(Scope.Scope, scope),
+ Effect.catchCause(recoverRefreshFailure),
+ ),
getProviderMaintenanceCapabilitiesForInstance,
setProviderMaintenanceActionState,
get streamChanges() {
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
index 1f37a713e..1cace0f1c 100644
--- a/apps/server/src/server.test.ts
+++ b/apps/server/src/server.test.ts
@@ -151,6 +151,7 @@ import { encodeMemoryArchiveJson } from "./memory/MemoryArchiveJson.ts";
import { memoryRevisionArchivePath, renderMemoryRevision } from "./memory/MemoryExport.ts";
import * as AgentController from "./provider/Services/AgentController.ts";
import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts";
+import { ProviderInstanceRegistryMutator } from "./provider/Services/ProviderInstanceRegistryMutator.ts";
import { ProviderAdapterRequestError } from "./provider/Errors.ts";
import { makeManualOnlyProviderMaintenanceCapabilities } from "./provider/providerMaintenance.ts";
import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
@@ -741,6 +742,7 @@ const buildAppUnderTest = (options?: {
streamChanges: Stream.empty,
...options?.layers?.providerRegistry,
}),
+ Layer.succeed(ProviderInstanceRegistryMutator, { reconcile: () => Effect.void }),
Layer.mock(AgentController.AgentController)({
uploadFeedback: () => Effect.die("Provider feedback is not stubbed in this test"),
...options?.layers?.agentController,
diff --git a/apps/server/src/subscription-auth/providerMutation.ts b/apps/server/src/subscription-auth/providerMutation.ts
new file mode 100644
index 000000000..6993285ed
--- /dev/null
+++ b/apps/server/src/subscription-auth/providerMutation.ts
@@ -0,0 +1,71 @@
+import { ProviderInstanceId, SubscriptionAuthError } from "@akeru/contracts";
+import * as Effect from "effect/Effect";
+
+import { deriveProviderInstanceConfigMap } from "../provider/Layers/ProviderInstanceRegistryHydration.ts";
+import type { ProviderInstanceRegistryMutatorShape } from "../provider/Services/ProviderInstanceRegistryMutator.ts";
+import type { ProviderRegistryShape } from "../provider/Services/ProviderRegistry.ts";
+import type { ServerSettingsService } from "../serverSettings.ts";
+import { instanceUsesSavedCredential, subscriptionProviderSettingsPatch } from "./runtime.ts";
+import type { SubscriptionAuthService, SubscriptionProviderId } from "./service.ts";
+
+const providersByDriver: Readonly<Record<string, SubscriptionProviderId>> = {
+ codex: "openai-codex",
+ claudeAgent: "anthropic",
+ grok: "xai",
+ kimi: "kimi-for-coding",
+ opencodeGo: "opencode-go",
+};
+
+export function makeSubscriptionProviderMutation(
+ auth: SubscriptionAuthService,
+ settings: ServerSettingsService["Service"],
+ mutator: ProviderInstanceRegistryMutatorShape,
+ registry: Pick<ProviderRegistryShape, "refreshInstance">,
+) {
+ return Effect.fn("subscriptionAuth.refreshChangedProviders")(function* <
+ Value,
+ Error,
+ Environment,
+ >(operation: Effect.Effect<Value, Error, Environment>) {
+ const beforeSettings = yield* settings.getSettings.pipe(
+ Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message })),
+ );
+ const bindings = Object.entries(deriveProviderInstanceConfigMap(beforeSettings)).flatMap(
+ ([instanceId, instance]) => {
+ const provider = providersByDriver[instance.driver];
+ if (!provider || !instanceUsesSavedCredential(provider, instance)) return [];
+ return [
+ {
+ provider,
+ instanceId: ProviderInstanceId.make(instanceId),
+ credential:
+ auth.getOAuthCredential(provider, instanceId) ??
+ auth.getApiKeyCredential(provider, instanceId),
+ },
+ ];
+ },
+ );
+ const result = yield* operation;
+ const changed = bindings.filter(({ provider, instanceId, credential }) => {
+ const current =
+ auth.getOAuthCredential(provider, instanceId) ??
+ auth.getApiKeyCredential(provider, instanceId);
+ return credential?.type !== current?.type || credential?.access !== current?.access;
+ });
+ if (changed.length === 0) return result;
+ const currentSettings = yield* settings.getSettings.pipe(
+ Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message })),
+ );
+ const patch = subscriptionProviderSettingsPatch(currentSettings, auth.statuses());
+ const nextSettings = patch
+ ? yield* settings
+ .updateSettings(patch)
+ .pipe(Effect.mapError((cause) => new SubscriptionAuthError({ reason: cause.message })))
+ : currentSettings;
+ yield* mutator.reconcile(deriveProviderInstanceConfigMap(nextSettings));
+ yield* Effect.forEach(changed, ({ instanceId }) => registry.refreshInstance(instanceId), {
+ discard: true,
+ });
+ return result;
+ });
+}
diff --git a/apps/server/src/textGeneration/HarnessTextGeneration.test.ts b/apps/server/src/textGeneration/HarnessTextGeneration.test.ts
new file mode 100644
index 000000000..6a65983f2
--- /dev/null
+++ b/apps/server/src/textGeneration/HarnessTextGeneration.test.ts
@@ -0,0 +1,410 @@
+// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off
+import * as NodePath from "node:path";
+import { NodeServices } from "@effect/platform-node";
+import { describe, expect, it } from "@effect/vitest";
+import { ProviderDriverKind, ProviderInstanceId, TextGenerationError } from "@akeru/contracts";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Fiber from "effect/Fiber";
+import * as TestClock from "effect/testing/TestClock";
+import { beforeEach, vi } from "vite-plus/test";
+
+import { ServerConfig } from "../config.ts";
+import { makeHarnessTextGeneration } from "./HarnessTextGeneration.ts";
+import * as Harness from "../provider/AkeruMastraHarness.ts";
+import { resolveAttachmentPath } from "../attachmentStore.ts";
+
+const { generate, agents } = vi.hoisted(() => ({ generate: vi.fn(), agents: vi.fn() }));
+vi.mock("@mastra/core/agent", () => ({
+ Agent: class {
+ constructor(options: unknown) {
+ agents(options);
+ }
+ generate = generate;
+ },
+}));
+
+beforeEach(() => {
+ vi.restoreAllMocks();
+ generate.mockReset();
+ agents.mockReset();
+});
+
+describe("HarnessTextGeneration", () => {
+ for (const operation of ["generateThreadTitle", "generateBranchName"] as const) {
+ it.effect(`bounds ${operation} to 180 seconds and aborts generation`, () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const instanceId = ProviderInstanceId.make("codex");
+ const writer = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make("codex"),
+ instanceId,
+ connection: {
+ environment: { OPENAI_API_KEY: "test-key" },
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ });
+ const started = Promise.withResolvers<AbortSignal>();
+ generate.mockImplementationOnce((_message, options) => {
+ started.resolve(options.abortSignal);
+ return new Promise(() => {});
+ });
+ const input = {
+ cwd: config.cwd,
+ message: "Fix this",
+ modelSelection: { instanceId, model: "gpt-6-sol" },
+ };
+ const request =
+ operation === "generateThreadTitle"
+ ? writer.generateThreadTitle(input).pipe(Effect.asVoid)
+ : writer.generateBranchName(input).pipe(Effect.asVoid);
+ const fiber = yield* request.pipe(
+ Effect.flip,
+ Effect.forkChild({ startImmediately: true }),
+ );
+ const signal = yield* Effect.tryPromise({
+ try: () => started.promise,
+ catch: (cause) =>
+ new TextGenerationError({ operation, detail: "Generation did not start.", cause }),
+ });
+ yield* TestClock.adjust("180 seconds");
+ expect(yield* Fiber.join(fiber)).toMatchObject({
+ _tag: "TextGenerationError",
+ operation,
+ detail: "Akeru writing request timed out.",
+ });
+ expect(signal.aborted).toBe(true);
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-writing-timeout-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+ }
+
+ it.effect("preserves Claude's selected 1M context window for titles and branches", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const instanceId = ProviderInstanceId.make("claudeAgent");
+ const writer = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make("claudeAgent"),
+ instanceId,
+ connection: {
+ environment: { ANTHROPIC_API_KEY: "test-key" },
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ });
+ const request = {
+ cwd: config.cwd,
+ message: "Fix this",
+ modelSelection: {
+ instanceId,
+ model: "claude-opus-4-6",
+ options: [
+ { id: "contextWindow", value: "1m" },
+ { id: "effort", value: "max" },
+ ],
+ },
+ };
+ generate.mockResolvedValueOnce({ text: '{"title":"Fix This"}' });
+ yield* writer.generateThreadTitle(request);
+ generate.mockResolvedValueOnce({ text: '{"branch":"fix-this"}' });
+ yield* writer.generateBranchName(request);
+ expect(agents.mock.calls.map((call) => call[0].model.modelId)).toEqual([
+ "claude-opus-4-6",
+ "claude-opus-4-6",
+ ]);
+ expect(generate.mock.calls.map((call) => call[1].providerOptions)).toEqual([
+ { anthropic: { effort: "max" } },
+ { anthropic: { effort: "max" } },
+ ]);
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-writing-claude-context-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+
+ it.effect("falls back to text when screenshots are missing or have invalid paths", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const instanceId = ProviderInstanceId.make("codex");
+ const writer = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make("codex"),
+ instanceId,
+ connection: {
+ environment: { OPENAI_API_KEY: "test-key" },
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ });
+ const request = {
+ cwd: config.cwd,
+ message: "Fix this",
+ modelSelection: { instanceId, model: "gpt-6-sol" },
+ attachments: ["chat-12345678-1234-1234-1234-123456789abc", "../invalid"].map((id) => ({
+ type: "image" as const,
+ id,
+ name: "missing.png",
+ mimeType: "image/png",
+ sizeBytes: 4,
+ })),
+ };
+ generate.mockResolvedValueOnce({ text: '{"title":"Fix This"}' });
+ expect(yield* writer.generateThreadTitle(request)).toEqual({ title: "Fix This" });
+ generate.mockResolvedValueOnce({ text: '{"branch":"fix-this"}' });
+ expect(yield* writer.generateBranchName(request)).toEqual({ branch: "fix-this" });
+ expect(generate.mock.calls.every((call) => typeof call[0] === "string")).toBe(true);
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-writing-missing-images-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+
+ for (const [driver, provider, model, transport] of [
+ ["codex", "openai-codex", "gpt-6-sol", "gpt-6-sol"],
+ ["claudeAgent", "anthropic", "claude-sonnet-5", "claude-sonnet-5"],
+ ["grok", "xai", "grok-build", "grok-4.6"],
+ ] as const) {
+ it.effect(
+ `generates ${driver} titles and branches with a saved credential, without a CLI`,
+ () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const fs = yield* FileSystem.FileSystem;
+ yield* fs.makeDirectory(config.secretsDir, { recursive: true });
+ const instanceId = ProviderInstanceId.make(driver);
+ const textGeneration = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make(driver),
+ instanceId,
+ connection: {
+ environment: { PATH: "" },
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ });
+ yield* fs.writeFileString(
+ NodePath.join(config.secretsDir, "subscription-auth.json"),
+ JSON.stringify({ [provider]: { type: "api-key", access: "saved-test-key" } }),
+ );
+ const request = {
+ cwd: config.cwd,
+ message: "Fix provider onboarding",
+ modelSelection: { instanceId, model },
+ };
+ generate.mockResolvedValueOnce({ text: '{"title":"Fix Provider Onboarding"}' });
+ expect(yield* textGeneration.generateThreadTitle(request)).toEqual({
+ title: "Fix Provider Onboarding",
+ });
+ generate.mockResolvedValueOnce({ text: '{"branch":"Fix Provider Onboarding"}' });
+ expect(yield* textGeneration.generateBranchName(request)).toEqual({
+ branch: "fix-provider-onboarding",
+ });
+ expect(agents).toHaveBeenCalledTimes(2);
+ expect(agents.mock.calls[0]?.[0].model.modelId).toBe(transport);
+ expect(generate.mock.calls[0]?.[0]).toContain("Fix provider onboarding");
+ expect(generate.mock.calls[0]?.[1].abortSignal).toBeInstanceOf(AbortSignal);
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-harness-writing-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+ }
+
+ it.effect("honors Codex reasoning and service-tier selections for both writing operations", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const resolver = vi.spyOn(Harness, "resolveAkeruMastraModel");
+ const instanceId = ProviderInstanceId.make("codex");
+ const writer = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make("codex"),
+ instanceId,
+ connection: {
+ environment: { OPENAI_API_KEY: "test-key" },
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ });
+ const request = {
+ cwd: config.cwd,
+ message: "Fix provider onboarding",
+ modelSelection: {
+ instanceId,
+ model: "gpt-6-sol",
+ options: [
+ { id: "reasoningEffort", value: "high" },
+ { id: "serviceTier", value: "priority" },
+ ],
+ },
+ };
+ generate.mockResolvedValueOnce({ text: '{"title":"Provider Onboarding"}' });
+ yield* writer.generateThreadTitle(request);
+ generate.mockResolvedValueOnce({ text: '{"branch":"provider-onboarding"}' });
+ yield* writer.generateBranchName(request);
+ expect(resolver.mock.calls.map((call) => call[4])).toEqual([
+ { reasoningEffort: "high", serviceTier: "priority" },
+ { reasoningEffort: "high", serviceTier: "priority" },
+ ]);
+ expect(generate.mock.calls.map((call) => call[1].providerOptions)).toEqual([
+ { openai: { reasoningEffort: "high", serviceTier: "priority" } },
+ { openai: { reasoningEffort: "high", serviceTier: "priority" } },
+ ]);
+ generate.mockResolvedValueOnce({ text: '{"title":"Provider Onboarding"}' });
+ yield* writer.generateThreadTitle({
+ ...request,
+ modelSelection: {
+ ...request.modelSelection,
+ options: [
+ { id: "reasoningEffort", value: "off" },
+ { id: "fastMode", value: true },
+ ],
+ },
+ });
+ expect(resolver.mock.calls[2]?.[4]).toEqual({
+ reasoningEffort: "off",
+ serviceTier: "priority",
+ });
+ expect(generate.mock.calls[2]?.[1].providerOptions).toEqual({
+ openai: { reasoningEffort: "none", serviceTier: "priority" },
+ });
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-writing-options-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+
+ it.effect("passes stored screenshot bytes to title and branch generation", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const fs = yield* FileSystem.FileSystem;
+ const instanceId = ProviderInstanceId.make("codex");
+ const image = {
+ type: "image" as const,
+ id: "chat-12345678-1234-1234-1234-123456789abc",
+ name: "screenshot.png",
+ mimeType: "image/png",
+ sizeBytes: 4,
+ };
+ const imagePath = resolveAttachmentPath({
+ attachmentsDir: config.attachmentsDir,
+ attachment: image,
+ });
+ expect(imagePath).not.toBeNull();
+ yield* fs.makeDirectory(config.attachmentsDir, { recursive: true });
+ const bytes = new Uint8Array([137, 80, 78, 71]);
+ yield* fs.writeFile(imagePath!, bytes);
+ const writer = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make("codex"),
+ instanceId,
+ connection: {
+ environment: { OPENAI_API_KEY: "test-key" },
+ instanceEnvironment: {},
+ useSavedCredential: true,
+ },
+ });
+ const request = {
+ cwd: config.cwd,
+ message: "fix this",
+ attachments: [
+ image,
+ { ...image, id: "chat-12345678-1234-1234-1234-123456789abd" },
+ { ...image, id: "../invalid" },
+ ],
+ modelSelection: { instanceId, model: "gpt-6-sol" },
+ };
+ generate.mockResolvedValueOnce({ text: '{"title":"Repair Screenshot Layout"}' });
+ yield* writer.generateThreadTitle(request);
+ generate.mockResolvedValueOnce({ text: '{"branch":"repair-screenshot-layout"}' });
+ yield* writer.generateBranchName(request);
+ for (const call of generate.mock.calls) {
+ expect(call[0]).toEqual([
+ {
+ role: "user",
+ content: [
+ expect.objectContaining({ type: "text" }),
+ { type: "image", image: expect.any(Uint8Array), mediaType: "image/png" },
+ ],
+ },
+ ]);
+ expect(Array.from(call[0][0].content[1].image)).toEqual(Array.from(bytes));
+ }
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-writing-images-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+
+ it.effect("returns a typed error for invalid output", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const config = yield* ServerConfig;
+ const instanceId = ProviderInstanceId.make("codex_custom");
+ const textGeneration = yield* makeHarnessTextGeneration({
+ secretsDir: config.secretsDir,
+ driver: ProviderDriverKind.make("codex"),
+ instanceId,
+ connection: {
+ environment: {},
+ instanceEnvironment: { OPENAI_API_KEY: "explicit-test-key" },
+ useSavedCredential: false,
+ },
+ });
+ generate.mockResolvedValueOnce({ text: "not JSON" });
+ const error = yield* textGeneration
+ .generateThreadTitle({
+ cwd: config.cwd,
+ message: "Fix readiness",
+ modelSelection: { instanceId, model: "gpt-6-sol" },
+ })
+ .pipe(Effect.flip);
+ expect(error).toMatchObject({
+ _tag: "TextGenerationError",
+ operation: "generateThreadTitle",
+ });
+ }),
+ ).pipe(
+ Effect.provide(
+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-harness-writing-error-" }).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ),
+ ),
+ );
+});
diff --git a/apps/server/src/textGeneration/HarnessTextGeneration.ts b/apps/server/src/textGeneration/HarnessTextGeneration.ts
new file mode 100644
index 000000000..ca7753b46
--- /dev/null
+++ b/apps/server/src/textGeneration/HarnessTextGeneration.ts
@@ -0,0 +1,245 @@
+// @effect-diagnostics nodeBuiltinImport:off
+import * as NodePath from "node:path";
+import { AuthStorage } from "@mastra/code-sdk/auth/storage";
+import { Agent } from "@mastra/core/agent";
+import {
+ TextGenerationError,
+ DEFAULT_TEXT_GENERATION_REASONING_EFFORT,
+ type ModelSelection,
+ type ChatAttachment,
+ type ProviderDriverKind,
+ type ProviderInstanceId,
+} from "@akeru/contracts";
+import { sanitizeBranchFragment } from "@akeru/shared/git";
+import { getModelSelectionStringOptionValue } from "@akeru/shared/model";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+
+import { mastraModelId, resolveAkeruMastraModel } from "../provider/AkeruMastraHarness.ts";
+import { ServerConfig } from "../config.ts";
+import { resolveAttachmentPath } from "../attachmentStore.ts";
+import { getCodexServiceTierOptionValue } from "../codexModelOptions.ts";
+import type { ProviderInstance } from "../provider/ProviderDriver.ts";
+import { SubscriptionAuthService } from "../subscription-auth/service.ts";
+import type { TextGeneration } from "./TextGeneration.ts";
+import { buildBranchNamePrompt, buildThreadTitlePrompt } from "./TextGenerationPrompts.ts";
+import { sanitizeThreadTitle } from "./TextGenerationUtils.ts";
+import {
+ getClaudeModelCapabilities,
+ normalizeClaudeCliEffort,
+ resolveClaudeApiModelId,
+ resolveClaudeEffort,
+} from "../provider/Layers/ClaudeProvider.ts";
+
+const decodeServiceTier = Schema.decodeUnknownEffect(
+ Schema.Literals(["auto", "default", "flex", "priority"]),
+);
+const decodeReasoningEffort = Schema.decodeUnknownEffect(
+ Schema.Literals(["none", "minimal", "low", "medium", "high", "xhigh", "max"]),
+);
+const decodeClaudeEffort = Schema.decodeUnknownEffect(
+ Schema.Literals(["low", "medium", "high", "xhigh", "max"]),
+);
+
+export const makeHarnessTextGeneration = Effect.fn("makeHarnessTextGeneration")(function* (input: {
+ readonly secretsDir: string;
+ readonly driver: ProviderDriverKind;
+ readonly instanceId: ProviderInstanceId;
+ readonly connection: NonNullable<ProviderInstance["mastraConnection"]>;
+}) {
+ const auth = yield* SubscriptionAuthService.forSecretsDir(input.secretsDir);
+ const fileSystem = yield* FileSystem.FileSystem;
+ const serverConfig = yield* ServerConfig;
+ const authStorage = new AuthStorage(NodePath.join(input.secretsDir, "subscription-auth.json"));
+ const generate = <Output>(
+ operation: "generateBranchName" | "generateThreadTitle",
+ modelSelection: ModelSelection,
+ prompt: string,
+ outputSchema: Schema.Codec<Output>,
+ attachments: ReadonlyArray<ChatAttachment> = [],
+ ) =>
+ Effect.gen(function* () {
+ yield* auth.reload();
+ const imageResults = yield* Effect.forEach(
+ attachments.filter((attachment) => attachment.type === "image"),
+ (attachment) =>
+ Effect.gen(function* () {
+ const path = resolveAttachmentPath({
+ attachmentsDir: serverConfig.attachmentsDir,
+ attachment,
+ });
+ if (path === null) return Option.none();
+ return yield* fileSystem.readFile(path).pipe(
+ Effect.map((bytes) => ({
+ type: "image" as const,
+ image: bytes,
+ mediaType: attachment.mimeType,
+ })),
+ Effect.option,
+ );
+ }),
+ );
+ const images = imageResults.flatMap((image) => (Option.isSome(image) ? [image.value] : []));
+ const selectedTier =
+ input.driver === "codex" ? getCodexServiceTierOptionValue(modelSelection) : undefined;
+ const serviceTier =
+ selectedTier === undefined
+ ? undefined
+ : yield* decodeServiceTier(selectedTier === "fast" ? "priority" : selectedTier).pipe(
+ Effect.mapError(
+ (cause) =>
+ new TextGenerationError({
+ operation,
+ detail: "The selected service tier is not supported by the Akeru harness.",
+ cause,
+ }),
+ ),
+ );
+ const selectedEffort =
+ input.driver === "codex"
+ ? (getModelSelectionStringOptionValue(modelSelection, "reasoningEffort") ??
+ DEFAULT_TEXT_GENERATION_REASONING_EFFORT)
+ : undefined;
+ const reasoningEffort =
+ selectedEffort === undefined
+ ? undefined
+ : yield* decodeReasoningEffort(selectedEffort === "off" ? "none" : selectedEffort).pipe(
+ Effect.mapError(
+ (cause) =>
+ new TextGenerationError({
+ operation,
+ detail: "The selected reasoning effort is not supported by the Akeru harness.",
+ cause,
+ }),
+ ),
+ );
+ const modelOptions = reasoningEffort
+ ? {
+ reasoningEffort: reasoningEffort === "none" ? "off" : reasoningEffort,
+ ...(serviceTier ? { serviceTier } : {}),
+ }
+ : undefined;
+ const selectedClaudeEffort =
+ input.driver === "claudeAgent"
+ ? normalizeClaudeCliEffort(
+ resolveClaudeEffort(
+ getClaudeModelCapabilities(modelSelection.model),
+ getModelSelectionStringOptionValue(modelSelection, "effort"),
+ ),
+ modelSelection.model,
+ )
+ : undefined;
+ const claudeEffort =
+ selectedClaudeEffort === undefined
+ ? undefined
+ : yield* decodeClaudeEffort(selectedClaudeEffort).pipe(
+ Effect.mapError(
+ (cause) =>
+ new TextGenerationError({
+ operation,
+ detail: "The selected Claude effort is not supported by the Akeru harness.",
+ cause,
+ }),
+ ),
+ );
+ const text = yield* Effect.tryPromise({
+ try: async (abortSignal) => {
+ const resolved = resolveAkeruMastraModel(
+ mastraModelId(
+ input.driver,
+ input.driver === "claudeAgent"
+ ? resolveClaudeApiModelId(modelSelection)
+ : modelSelection.model,
+ ),
+ authStorage,
+ undefined,
+ undefined,
+ modelOptions,
+ (provider, instanceId) => auth.getApiKeyCredential(provider, instanceId),
+ { ...input.connection, instanceId: input.instanceId },
+ (provider, instanceId) => auth.getOAuthCredential(provider, instanceId),
+ (provider, instanceId) => auth.getAccessToken(provider, instanceId),
+ );
+ const agent = new Agent({
+ id: `akeru-${operation}-${input.instanceId}`,
+ name: "Akeru writing",
+ instructions: "Return only the requested JSON object.",
+ model: resolved,
+ });
+ const message =
+ images.length === 0
+ ? prompt
+ : [
+ {
+ role: "user" as const,
+ content: [{ type: "text" as const, text: prompt }, ...images],
+ },
+ ];
+ const runOptions = reasoningEffort
+ ? {
+ providerOptions: {
+ openai: {
+ reasoningEffort,
+ ...(serviceTier ? { serviceTier } : {}),
+ },
+ },
+ }
+ : claudeEffort
+ ? { providerOptions: { anthropic: { effort: claudeEffort } } }
+ : {};
+ const result = await agent.generate(message, { ...runOptions, abortSignal });
+ return result.text;
+ },
+ catch: (cause) =>
+ new TextGenerationError({
+ operation,
+ detail: "Akeru harness text generation failed.",
+ cause,
+ }),
+ });
+ return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(outputSchema))(
+ text.trim(),
+ ).pipe(
+ Effect.mapError(
+ (cause) =>
+ new TextGenerationError({
+ operation,
+ detail: "Akeru harness returned invalid writing output.",
+ cause,
+ }),
+ ),
+ );
+ }).pipe(
+ Effect.timeoutOrElse({
+ duration: "180 seconds",
+ orElse: () =>
+ Effect.fail(
+ new TextGenerationError({ operation, detail: "Akeru writing request timed out." }),
+ ),
+ }),
+ );
+ return {
+ generateBranchName: (request) => {
+ const { prompt, outputSchema } = buildBranchNamePrompt(request);
+ return generate(
+ "generateBranchName",
+ request.modelSelection,
+ prompt,
+ outputSchema,
+ request.attachments,
+ ).pipe(Effect.map((result) => ({ branch: sanitizeBranchFragment(result.branch) })));
+ },
+ generateThreadTitle: (request) => {
+ const { prompt, outputSchema } = buildThreadTitlePrompt(request);
+ return generate(
+ "generateThreadTitle",
+ request.modelSelection,
+ prompt,
+ outputSchema,
+ request.attachments,
+ ).pipe(Effect.map((result) => ({ title: sanitizeThreadTitle(result.title) })));
+ },
+ } satisfies TextGeneration["Service"];
+});
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 379c50a6e..09f429b51 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -83,6 +83,8 @@ import {
} from "@akeru/contracts";
import { SubscriptionAuthService } from "./subscription-auth/service.ts";
import { makeApiKeySessionReset } from "./subscription-auth/sessionReset.ts";
+import { makeSubscriptionProviderMutation } from "./subscription-auth/providerMutation.ts";
+import { ProviderInstanceRegistryMutator } from "./provider/Services/ProviderInstanceRegistryMutator.ts";
import { subscriptionProviderSettingsPatch } from "./subscription-auth/runtime.ts";
import { imageProviderStatuses, runImageProviderHealthTest } from "./image-generation/service.ts";
import { deriveProviderInstanceConfigMap } from "./provider/Layers/ProviderInstanceRegistryHydration.ts";
@@ -696,6 +698,12 @@ const makeWsRpcLayer = (
const botInbox = BotInboxService.forSecretsDir(config.secretsDir);
const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents;
const serverSettings = yield* ServerSettings.ServerSettingsService;
+ const refreshChangedSubscriptionProviders = makeSubscriptionProviderMutation(
+ subscriptionAuth,
+ serverSettings,
+ yield* ProviderInstanceRegistryMutator,
+ providerRegistry,
+ );
const syncSubscriptionProviderSettings = Effect.gen(function* () {
const settings = yield* serverSettings.getSettings;
const patch = subscriptionProviderSettingsPatch(settings, subscriptionAuth.statuses());
@@ -2867,10 +2875,7 @@ const makeWsRpcLayer = (
new SubscriptionAuthError({
reason: cause instanceof Error ? cause.message : String(cause),
}),
- }).pipe(
- resetChangedApiKeySessions,
- Effect.tap(() => syncSubscriptionProviderSettings),
- ),
+ }).pipe(refreshChangedSubscriptionProviders, resetChangedApiKeySessions),
{ "rpc.aggregate": "server" },
),
[WS_METHODS.subscriptionAuthComplete]: ({ loginId, code }) =>
@@ -2882,10 +2887,7 @@ const makeWsRpcLayer = (
new SubscriptionAuthError({
reason: cause instanceof Error ? cause.message : String(cause),
}),
- }).pipe(
- resetChangedApiKeySessions,
- Effect.tap(() => syncSubscriptionProviderSettings),
- ),
+ }).pipe(refreshChangedSubscriptionProviders, resetChangedApiKeySessions),
{ "rpc.aggregate": "server" },
),
[WS_METHODS.subscriptionAuthCancel]: ({ loginId }) =>
@@ -2906,7 +2908,11 @@ const makeWsRpcLayer = (
new SubscriptionAuthError({
reason: cause instanceof Error ? cause.message : String(cause),
}),
- }).pipe(resetChangedApiKeySessions, Effect.andThen(getAccessHealthSnapshot())),
+ }).pipe(
+ refreshChangedSubscriptionProviders,
+ resetChangedApiKeySessions,
+ Effect.andThen(getAccessHealthSnapshot()),
+ ),
{ "rpc.aggregate": "server" },
),
[WS_METHODS.subscriptionAuthHealthTest]: ({ provider, instanceId }) =>
diff --git a/docs/internals/providers.md b/docs/internals/providers.md
index 5c4805ad6..a04d7e01b 100644
--- a/docs/internals/providers.md
+++ b/docs/internals/providers.md
@@ -18,8 +18,9 @@ orchestration layer does not know which one is behind a thread.
| `opencode` | [`Drivers/OpenCodeDriver.ts`][opencode] |
| `opencodeGo` | [`Drivers/OpenCodeGoDriver.ts`][opencode-go] |
-Each driver declares its `driverKind`, a `configSchema`, and a `create` function that builds an
-adapter in a child scope. Adapter implementations live beside them in
+Each driver declares its `driverKind`, a `configSchema`, and a `create` function that builds a
+provider instance in a child scope. The five subscription drivers supply a Mastra connection;
+standard OpenCode supplies a legacy adapter. Adapter implementations live beside them in
`apps/server/src/provider/Layers/` (`CodexAdapter.ts`, `ClaudeAdapter.ts`, and so on) and conform to
[`ProviderAdapter.ts`][adapter]. Read the driver plus its adapter to see how a specific agent's
transport, config, and event shapes are mapped.
@@ -152,9 +153,59 @@ revert boundary. OpenCode keeps reverted messages in the transcript until the ne
`readThread` stops at `session.revert.messageID` rather than slicing the local copy. OpenCode Go
stays on Mastra and does not use this adapter path.
-### Grok health check
-
-`checkGrokProviderStatus` never opens an ACP session. It runs `grok --version`, then `grok models`
+### Harness-native readiness
+
+Codex, Claude, and Grok use `HarnessProviderStatus.ts`, not their CLI health checks, to publish
+readiness. Like Kimi and OpenCode Go, they report the bundled runtime as installed even when no
+provider binary exists. The initial snapshot and each refresh reload `SubscriptionAuthService`
+from the environment's `subscription-auth.json`. A connected saved credential makes the instance
+ready; a missing credential reports unauthenticated and asks the user to connect in Settings.
+
+The model list comes from built-in metadata and `ModelManifest.applyModelManifest`. Codex combines
+current manifest IDs with bundled and historical compatibility models. The manifest classifies
+models as current or legacy; it is not an exhaustive allowlist. The OAuth transport forwards the
+selected ID to the Codex API without a local catalog restriction. Account access is still checked
+by the provider when a request runs. Thinking levels come from the harness SDK, without a CLI
+`model/list` request.
+Standard and Fast service tiers remain selectable. Claude merges manifest additions into its
+built-in capability catalog without dropping historical models. Grok includes its API model IDs
+alongside manifest additions. It labels the compatibility `grok-build` selection as Grok 4.6 and maps it to `grok-4.6` in
+`mastraModelId`, because the product slug is not an API model ID. Keeping the selection slug lets
+existing bots and the default model pass catalog validation. Custom models are retained.
+
+Successful credential mutations through poll, completion, and logout RPCs reconcile default
+provider settings and refresh each affected saved-credential instance before returning. The
+registry publishes the updated snapshot immediately, including for named instances and when
+periodic health refresh is disabled.
+
+Explicit connection variables or a custom home disable saved-credential fallback. Codex then
+requires `OPENAI_API_KEY`, Claude requires `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, or
+`CLAUDE_CODE_OAUTH_TOKEN`, and Grok requires `XAI_API_KEY` in the instance's explicit environment.
+A CLI login or custom CLI home alone cannot make that instance ready. Ambient credentials remain
+available to saved-credential instances, matching the harness's transport precedence.
+
+`HarnessTextGeneration.ts` generates chat titles and branch names through
+`resolveAkeruMastraModel`, the same transport resolver as turns. It reloads saved credentials for
+each operation and preserves instance scoping, Codex reasoning effort and service tier, and Claude
+effort and context-window selections. Claude's 1M context selection uses the same `[1m]` model
+suffix in turns and writing requests. The transport strips this CLI-style suffix from the API
+model ID and sets the extended-context beta header for API keys and OAuth alike.
+Each writing operation has a 180-second deadline and aborts
+the generation request when it expires. Stored
+image attachments are resolved through the attachment store and sent as multimodal image parts,
+not just filenames. Invalid or unreadable image attachments are skipped; available images and
+text still reach generation.
+It does not spawn a provider CLI. These drivers no
+longer construct legacy adapters. CLI skill catalogs and maintenance remain optional extras;
+catalog failures do not fail a workspace snapshot or change readiness. A missing Grok CLI stays
+silent; other skill discovery failures are logged as warnings. Claude still reads skill
+files directly, without a CLI. Codex's CLI-only skills and Claude's CLI slash-command discovery are
+not part of readiness snapshots. Version checks are skipped when there is no CLI version.
+
+### Legacy Grok CLI probe
+
+`checkGrokProviderStatus` is retained for legacy probe tests and is not used by `GrokDriver`.
+It never opens an ACP session. It runs `grok --version`, then `grok models`
for login state and model slugs, then a single ACP `initialize` and reads models from
`_meta.modelState`. `authenticate` and `session/new` are skipped on purpose: `authenticate` can open
a browser login and `session/new` boots every configured MCP server, both of which made background
@@ -174,10 +225,9 @@ request and drops, so Stop did not stop. `AcpSessionRuntime.cancel` now waits fo
write before returning so a replacement prompt cannot race ahead of it. Grok mid-turn sends cancel
the in-flight prompt and continue the same turn instead of queueing.
-Grok skill discovery uses `grok inspect --json`. Machine-level health checks recover probe
-failures to an empty skill list. `ProviderInstance.snapshotForCwd` re-runs inspect in the
-thread workspace so a failed probe is not cached as empty. Composer cwd refresh still uses the
-machine snapshot until a client calls `snapshotForCwd`.
+Grok skill discovery uses `grok inspect --json` only for optional workspace catalogs.
+`ProviderInstance.snapshotForCwd` recovers missing binaries and failed inspect requests to an empty
+skill list. Machine snapshots do not probe the CLI.
`ServerProviderSkill` carries an optional `icon` (an emoji or a short glyph name from skill
frontmatter or provider metadata, e.g. the Codex app-server's interface icon paths). Clients
diff --git a/docs/user/providers-claude.md b/docs/user/providers-claude.md
index d3e5e2d13..4ec5a5897 100644
--- a/docs/user/providers-claude.md
+++ b/docs/user/providers-claude.md
@@ -1,8 +1,7 @@
# Claude
-Connect a Claude Pro or Max subscription from Akeru. Claude chats run through Akeru's Claude
-adapter, which keeps Claude-specific session behavior behind the same chat controls as other
-providers.
+Connect a Claude Pro or Max subscription from Akeru. Claude chats run through Akeru's built-in
+runtime, with the same chat controls as other providers. The Claude CLI is not required.
## Connect Claude
@@ -24,14 +23,14 @@ real provider request succeeds.
- Select **Reconnect** after an expired or revoked login.
- Disconnect the account to remove its stored credential from this environment.
-If a Claude chat fails because the login expired, Akeru names that cause instead of a generic API error and tells you to run `claude auth login` on the environment machine. A usage-limit failure says the limit was reached and to send the message again after it resets.
+If the login expires or is revoked, reconnect Claude in **Settings > Providers**. A usage-limit
+failure means you should send the message again after the limit resets.
Sign-in state belongs to one environment. Connect Claude again on each separate Akeru server that
should use the account.
-Claude Code's verbose mode can stay enabled when you use Claude for text generation, including
-chat titles and worktree branch names. On a remote connection,
-Akeru uses the Claude configuration on the connected server.
+Chat titles and worktree branch names use the same Akeru connection as Claude chats, not a separate
+Claude Code login. On a remote connection, credentials stay on the connected environment server.
## Continue a Claude chat
diff --git a/docs/user/providers.md b/docs/user/providers.md
index 7067cae30..b8577b2df 100644
--- a/docs/user/providers.md
+++ b/docs/user/providers.md
@@ -2,6 +2,15 @@
Akeru Bot connects to provider subscriptions and API keys from **Settings → Providers**. Credentials stay in the environment that owns the connection.
+ChatGPT, Claude, Grok, Kimi For Coding, and OpenCode Go run through Akeru's built-in runtime.
+You do not need their command-line tools installed or signed in to create a bot, chat, or generate
+chat titles and branch names with ChatGPT, Claude, or Grok. After connecting an account in Akeru,
+choose its models in onboarding or the bot's settings. If the account is disconnected, reconnect
+it in **Settings → Providers**.
+
+An instance configured with its own credentials uses those credentials rather than the shared
+connection. A custom configuration directory alone does not connect an account to Akeru's runtime.
+
## Subscription login health
After a login or API key save completes, the environment server sends one request that costs nothing, to confirm the account can reach its models or usage endpoint. The check runs on the server, so closing the app or losing the connection right after login does not stop it. While it runs, the provider row shows **Checking health…**. It then changes to **Connected** when the request succeeds or **Failed** when it does not. A failed check does not undo a successful login. Repair the provider account, then use **Reconnect** or **Check OAuth**.