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.
feat(providers): add Kimi For Coding runtime (#29)
Leo17f6d329c2a8
diff --git a/apps/server/package.json b/apps/server/package.jsonindex 052b5ff60..afde9af9b 100644--- a/apps/server/package.json+++ b/apps/server/package.json@@ -22,6 +22,7 @@"test": "vp test run"},"dependencies": {+ "@ai-sdk/anthropic": "3.0.113","@anthropic-ai/claude-agent-sdk": "^0.3.170","@effect/platform-bun": "catalog:","@effect/platform-node": "catalog:",diff --git a/apps/server/src/provider/AkeruKimiProvider.test.ts b/apps/server/src/provider/AkeruKimiProvider.test.tsnew file mode 100644index 000000000..2c0205119--- /dev/null+++ b/apps/server/src/provider/AkeruKimiProvider.test.ts@@ -0,0 +1,54 @@+import { describe, expect, it, vi } from "vite-plus/test";++import { akeruKimiProvider, buildAkeruKimiFetch } from "./AkeruKimiProvider.ts";++const access = {+ accessToken: "kimi-access",+ deviceId: "0123456789abcdef0123456789abcdef",+};++describe("AkeruKimiProvider", () => {+ it("builds the Kimi Anthropic model without changing the saved model", () => {+ expect(akeruKimiProvider("k3-256k", async () => access)).toMatchObject({+ provider: "anthropic.messages",+ modelId: "k3-256k",+ });+ });++ it("uses the saved OAuth token and device identity for every request", async () => {+ const request = vi.fn(async (_input: string | Request | URL, init?: RequestInit) => {+ const headers = new Headers(init?.headers);+ expect(headers.get("authorization")).toBe("Bearer kimi-access");+ expect(headers.get("x-api-key")).toBeNull();+ expect(headers.get("x-msh-device-id")).toBe(access.deviceId);+ expect(headers.get("x-msh-platform")).toBe("akeru");+ expect(headers.get("x-msh-version")).toBe("0.0.34");+ return new Response("{}", { status: 200 });+ });+ const fetch = buildAkeruKimiFetch(async () => access, request);++ await fetch("https://api.kimi.com/coding/v1/messages", {+ method: "POST",+ headers: { Authorization: "stale", "x-api-key": "stale" },+ });++ expect(request).toHaveBeenCalledOnce();+ });++ it("fails closed when the account or device identity is unavailable", async () => {+ const request = vi.fn();+ await expect(+ buildAkeruKimiFetch(+ async () => undefined,+ request,+ )("https://api.kimi.com/coding/v1/messages"),+ ).rejects.toThrow("not connected");+ await expect(+ buildAkeruKimiFetch(+ async () => ({ accessToken: "token", deviceId: "invalid" }),+ request,+ )("https://api.kimi.com/coding/v1/messages"),+ ).rejects.toThrow("Invalid Kimi For Coding device id");+ expect(request).not.toHaveBeenCalled();+ });+});diff --git a/apps/server/src/provider/AkeruKimiProvider.ts b/apps/server/src/provider/AkeruKimiProvider.tsnew file mode 100644index 000000000..bf21309d4--- /dev/null+++ b/apps/server/src/provider/AkeruKimiProvider.ts@@ -0,0 +1,46 @@+import { createAnthropic } from "@ai-sdk/anthropic";+import type { MastraModelConfig } from "@mastra/core/llm";++import { getKimiCodingDeviceHeaders } from "../subscription-auth/providers/kimi.ts";++const KIMI_CODING_BASE_URL = "https://api.kimi.com/coding/v1";+type AkeruKimiFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;++export interface AkeruKimiAccess {+ readonly accessToken: string;+ readonly deviceId: string;+}++export function buildAkeruKimiFetch(+ getAccess: () => Promise<AkeruKimiAccess | undefined>,+ request: AkeruKimiFetch = globalThis.fetch,+): AkeruKimiFetch {+ return async (input, init) => {+ const access = await getAccess();+ if (!access) throw new Error("Kimi For Coding is not connected. Reconnect the account.");+ const headers = new Headers(input instanceof Request ? input.headers : undefined);+ if (init?.headers) {+ new Headers(init.headers).forEach((value, key) => headers.set(key, value));+ }+ headers.delete("authorization");+ headers.delete("x-api-key");+ headers.set("Authorization", `Bearer ${access.accessToken}`);+ for (const [key, value] of Object.entries(getKimiCodingDeviceHeaders(access.deviceId))) {+ headers.set(key, value);+ }+ return request(input, { ...init, headers });+ };+}++export function akeruKimiProvider(+ modelId: string,+ getAccess: () => Promise<AkeruKimiAccess | undefined>,+): MastraModelConfig {+ return createAnthropic({+ apiKey: "oauth-placeholder",+ baseURL: KIMI_CODING_BASE_URL,+ fetch: buildAkeruKimiFetch(getAccess) as NonNullable<+ NonNullable<Parameters<typeof createAnthropic>[0]>["fetch"]+ >,+ })(modelId);+}diff --git a/apps/server/src/provider/AkeruMastraHarness.test.ts b/apps/server/src/provider/AkeruMastraHarness.test.tsindex 66f1a478a..4f9a3c54f 100644--- a/apps/server/src/provider/AkeruMastraHarness.test.ts+++ b/apps/server/src/provider/AkeruMastraHarness.test.ts@@ -3,14 +3,33 @@ import type { ToolsInput } from "@mastra/core/agent";import { TOOL_NAME_OVERRIDES } from "@mastra/code-sdk/tool-names";import { RequestContext } from "@mastra/core/request-context";import { LocalFilesystem, LocalSandbox, Workspace } from "@mastra/core/workspace";-import { AKERU_PRODUCT_FEEDBACK_TOOL_NAME } from "@t3tools/contracts";+import { AKERU_PRODUCT_FEEDBACK_TOOL_NAME, ProviderDriverKind } from "@t3tools/contracts";import { assert, describe, it } from "vite-plus/test";import { AKERU_AGENT_INSTRUCTIONS } from "./AkeruAgentInstructions.ts";-import { resolveAkeruTools } from "./AkeruMastraHarness.ts";+import { mastraModelId, resolveAkeruMastraModel, resolveAkeruTools } from "./AkeruMastraHarness.ts";import { productFeedbackToolInputSchema } from "./AkeruMastraHarness.ts";describe("AkeruMastraHarness", () => {+ it("keeps Kimi model names on the Kimi subscription transport", () => {+ const authStorage = new AuthStorage("/tmp/akeru-unused-auth.json");+ assert.equal(+ mastraModelId(ProviderDriverKind.make("kimi"), "k3-256k"),+ "kimi-for-coding/k3-256k",+ );+ assert.deepInclude(+ resolveAkeruMastraModel("kimi-for-coding/k3-256k", authStorage, async () => ({+ accessToken: "kimi-access",+ deviceId: "0123456789abcdef0123456789abcdef",+ })),+ { provider: "anthropic.messages", modelId: "k3-256k" },+ );+ assert.throws(+ () => resolveAkeruMastraModel("kimi-for-coding/k3-256k", authStorage),+ "subscription access is unavailable",+ );+ });+it("configures Akeru as a general-purpose assistant with plugin awareness", () => {assert.include(AKERU_AGENT_INSTRUCTIONS, "general-purpose assistant");assert.include(AKERU_AGENT_INSTRUCTIONS, "enabled plugin tools");diff --git a/apps/server/src/provider/AkeruMastraHarness.ts b/apps/server/src/provider/AkeruMastraHarness.tsindex 9c4026a97..355703133 100644--- a/apps/server/src/provider/AkeruMastraHarness.ts+++ b/apps/server/src/provider/AkeruMastraHarness.ts@@ -13,12 +13,14 @@ import { createWorkspaceTools, type Workspace } from "@mastra/core/workspace";import {AKERU_PRODUCT_FEEDBACK_TOOL_NAME,ProductFeedbackToolDraft,+ type ProviderDriverKind,type ProductFeedbackToolDraft as ProductFeedbackToolDraftValue,} from "@t3tools/contracts";import * as Exit from "effect/Exit";import * as Schema from "effect/Schema";import { AKERU_AGENT_INSTRUCTIONS } from "./AkeruAgentInstructions.ts";+import { akeruKimiProvider, type AkeruKimiAccess } from "./AkeruKimiProvider.ts";const DEFAULT_MODEL_ID = "openai/gpt-5.6-sol";const decodeProductFeedbackToolDraft = Schema.decodeUnknownExit(ProductFeedbackToolDraft, {@@ -69,6 +71,7 @@ export type AkeruMastraSession = Session<AkeruMastraState>;export interface AkeruMastraHarnessOptions {readonly authStorage: AuthStorage;+ readonly getKimiAccess?: () => Promise<AkeruKimiAccess | undefined>;readonly getThreadTools: (threadId: string) => ToolsInput;readonly getThreadWorkspace: (threadId: string) => Workspace | undefined;}@@ -103,8 +106,33 @@ function controllerResourceId(requestContext: RequestContext): string | undefinereturn typeof value === "string" ? value : undefined;}-function codexModelName(modelId: string): string {- return modelId.startsWith("openai/") ? modelId.slice("openai/".length) : modelId;+const MASTRA_MODEL_PREFIX = {+ codex: "openai",+ kimi: "kimi-for-coding",+} as const;++export function mastraModelId(provider: ProviderDriverKind, model: string): string {+ const trimmed = 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}/`;+ return trimmed.startsWith(token) ? trimmed : `${token}${trimmed}`;+}++export function resolveAkeruMastraModel(+ modelId: string,+ authStorage: AuthStorage,+ getKimiAccess?: () => Promise<AkeruKimiAccess | undefined>,+) {+ const trimmed = modelId.trim();+ if (trimmed.startsWith("openai/")) {+ return openaiCodexProvider(trimmed.slice("openai/".length), { authStorage });+ }+ if (trimmed.startsWith("kimi-for-coding/")) {+ if (!getKimiAccess) throw new Error("Kimi For Coding subscription access is unavailable.");+ return akeruKimiProvider(trimmed.slice("kimi-for-coding/".length), getKimiAccess);+ }+ throw new Error(`Mastra has no subscription transport for model '${modelId}'.`);}export async function resolveAkeruTools(@@ -273,9 +301,11 @@ export async function createAkeruMastraHarness(name: "Akeru",instructions: AKERU_AGENT_INSTRUCTIONS,model: ({ requestContext }) =>- openaiCodexProvider(codexModelName(controllerModelId(requestContext)), {- authStorage: options.authStorage,- }),+ resolveAkeruMastraModel(+ controllerModelId(requestContext),+ options.authStorage,+ options.getKimiAccess,+ ),tools: ({ requestContext }) => resolveAkeruTools(requestContext, options),workspace: undefined,});diff --git a/apps/server/src/provider/Drivers/KimiDriver.test.ts b/apps/server/src/provider/Drivers/KimiDriver.test.tsnew file mode 100644index 000000000..72160a451--- /dev/null+++ b/apps/server/src/provider/Drivers/KimiDriver.test.ts@@ -0,0 +1,104 @@+// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off+import * as NodeFS from "node:fs";+import * as NodePath from "node:path";++import { NodeServices } from "@effect/platform-node";+import { describe, expect, it } from "@effect/vitest";+import { ProviderInstanceId } from "@t3tools/contracts";+import * as Effect from "effect/Effect";+import * as Layer from "effect/Layer";++import { ServerConfig } from "../../config.ts";+import { BUILT_IN_DRIVERS } from "../builtInDrivers.ts";+import { KimiDriver } from "./KimiDriver.ts";++describe("KimiDriver", () => {+ it.effect("registers one Mastra-native Kimi provider with offline model metadata", () => {+ expect(BUILT_IN_DRIVERS.map((driver) => String(driver.driverKind))).toContain("kimi");+ const program = Effect.scoped(+ Effect.gen(function* () {+ const instance = yield* KimiDriver.create({+ instanceId: ProviderInstanceId.make("kimi"),+ displayName: undefined,+ environment: [],+ enabled: true,+ config: KimiDriver.defaultConfig(),+ });+ const snapshot = yield* instance.snapshot.getSnapshot;+ return { instance, snapshot };+ }),+ );+ return program.pipe(+ Effect.provide(+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-kimi-driver-test-" }).pipe(+ Layer.provide(NodeServices.layer),+ ),+ ),+ Effect.tap((result) =>+ Effect.sync(() => {+ expect(result.instance.adapter).toBeUndefined();+ expect(result.instance.textGeneration).toBeUndefined();+ expect(result.snapshot).toMatchObject({+ instanceId: "kimi",+ driver: "kimi",+ displayName: "Kimi For Coding",+ installed: true,+ auth: { status: "unauthenticated", type: "oauth" },+ models: expect.arrayContaining([+ expect.objectContaining({ slug: "k3" }),+ expect.objectContaining({ slug: "k3-256k" }),+ ]),+ });+ }),+ ),+ );+ });++ it.effect("refreshes the snapshot after subscription auth changes", () => {+ const program = Effect.scoped(+ Effect.gen(function* () {+ const config = yield* ServerConfig;+ const instance = yield* KimiDriver.create({+ instanceId: ProviderInstanceId.make("kimi"),+ displayName: undefined,+ environment: [],+ enabled: true,+ config: KimiDriver.defaultConfig(),+ });+ const before = yield* instance.snapshot.getSnapshot;+ NodeFS.mkdirSync(config.secretsDir, { recursive: true });+ NodeFS.writeFileSync(+ NodePath.join(config.secretsDir, "subscription-auth.json"),+ JSON.stringify({+ "kimi-for-coding": {+ type: "oauth",+ access: "offline-test-token",+ refresh: "offline-test-refresh",+ expires: 4_102_444_800_000,+ deviceId: "0123456789abcdef0123456789abcdef",+ },+ }),+ );+ const after = yield* instance.snapshot.refresh;+ return { before, after, continuationIdentity: instance.continuationIdentity };+ }),+ );+ return program.pipe(+ Effect.provide(+ ServerConfig.layerTest(process.cwd(), { prefix: "akeru-kimi-refresh-test-" }).pipe(+ Layer.provide(NodeServices.layer),+ ),+ ),+ Effect.tap((result) =>+ Effect.sync(() => {+ expect(result.before.auth.status).toBe("unauthenticated");+ expect(result.after.auth.status).toBe("authenticated");+ expect(result.after.status).toBe("ready");+ expect(result.after.continuation?.groupKey).toBe(+ result.continuationIdentity.continuationKey,+ );+ }),+ ),+ );+ });+});diff --git a/apps/server/src/provider/Drivers/KimiDriver.ts b/apps/server/src/provider/Drivers/KimiDriver.tsnew file mode 100644index 000000000..033b3e3e8--- /dev/null+++ b/apps/server/src/provider/Drivers/KimiDriver.ts@@ -0,0 +1,102 @@+import {+ KimiSettings,+ ProviderDriverKind,+ type ServerProvider,+ type ServerProviderModel,+} from "@t3tools/contracts";+import * as DateTime from "effect/DateTime";+import * as Effect from "effect/Effect";+import * as PubSub from "effect/PubSub";+import * as Schema from "effect/Schema";+import * as Stream from "effect/Stream";++import { ServerConfig } from "../../config.ts";+import { SubscriptionAuthService } from "../../subscription-auth/service.ts";+import type { ProviderDriver } from "../ProviderDriver.ts";+import { defaultProviderContinuationIdentity } from "../ProviderDriver.ts";+import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts";++const DRIVER_KIND = ProviderDriverKind.make("kimi");+const decodeSettings = Schema.decodeSync(KimiSettings);+const BUILT_IN_MODELS = ["k3", "k3-256k", "kimi-for-coding", "kimi-for-coding-highspeed"] as const;++function models(customModels: readonly string[]): ServerProviderModel[] {+ return [...new Set([...BUILT_IN_MODELS, ...customModels.map((model) => model.trim())])]+ .filter((model) => model.length > 0)+ .map((model, index) => ({+ slug: model,+ name: model,+ isCustom: !BUILT_IN_MODELS.includes(model as (typeof BUILT_IN_MODELS)[number]),+ ...(index === 0 ? { isDefault: true } : {}),+ capabilities: null,+ }));+}++export type KimiDriverEnv = ServerConfig;++export const KimiDriver: ProviderDriver<KimiSettings, KimiDriverEnv> = {+ driverKind: DRIVER_KIND,+ metadata: { displayName: "Kimi For Coding", supportsMultipleInstances: false },+ configSchema: KimiSettings,+ defaultConfig: () => decodeSettings({}),+ create: ({ instanceId, displayName, accentColor, enabled, config }) =>+ Effect.gen(function* () {+ const serverConfig = yield* ServerConfig;+ const auth = SubscriptionAuthService.forSecretsDir(serverConfig.secretsDir);+ const changes = yield* Effect.acquireRelease(+ PubSub.unbounded<ServerProvider>(),+ PubSub.shutdown,+ );+ const effectiveEnabled = enabled && config.enabled;+ const continuationIdentity = defaultProviderContinuationIdentity({+ driverKind: DRIVER_KIND,+ instanceId,+ });+ const readSnapshot = Effect.sync(() => {+ auth.reload();+ const connected = auth.isConnected("kimi-for-coding");+ return {+ instanceId,+ driver: DRIVER_KIND,+ displayName: displayName ?? "Kimi For Coding",+ ...(accentColor ? { accentColor } : {}),+ continuation: { groupKey: continuationIdentity.continuationKey },+ enabled: effectiveEnabled,+ installed: true,+ version: null,+ status: !effectiveEnabled ? "disabled" : connected ? "ready" : "warning",+ auth: { status: connected ? "authenticated" : "unauthenticated", type: "oauth" },+ checkedAt: DateTime.formatIso(DateTime.nowUnsafe()),+ ...(!connected && effectiveEnabled+ ? { message: "Connect Kimi For Coding in Settings." }+ : {}),+ availability: "available",+ models: models(config.customModels),+ slashCommands: [],+ skills: [],+ } satisfies ServerProvider;+ });+ const refresh = readSnapshot.pipe(+ Effect.tap((snapshot) => PubSub.publish(changes, snapshot)),+ );+ return {+ instanceId,+ driverKind: DRIVER_KIND,+ continuationIdentity,+ displayName,+ accentColor,+ enabled: effectiveEnabled,+ adapter: undefined,+ textGeneration: undefined,+ snapshot: {+ maintenanceCapabilities: makeManualOnlyProviderMaintenanceCapabilities({+ provider: DRIVER_KIND,+ packageName: null,+ }),+ getSnapshot: readSnapshot,+ refresh,+ streamChanges: Stream.fromPubSub(changes),+ },+ };+ }),+};diff --git a/apps/server/src/provider/Layers/AgentController.test.ts b/apps/server/src/provider/Layers/AgentController.test.tsindex a45df932e..063292f03 100644--- a/apps/server/src/provider/Layers/AgentController.test.ts+++ b/apps/server/src/provider/Layers/AgentController.test.ts@@ -40,8 +40,10 @@ import { SubscriptionAuthService } from "../../subscription-auth/service.ts";const codexThreadId = ThreadId.make("thread-mastra-codex");const claudeThreadId = ThreadId.make("thread-legacy-claude");+const kimiThreadId = ThreadId.make("thread-mastra-kimi");const codexInstanceId = ProviderInstanceId.make("codex");const claudeInstanceId = ProviderInstanceId.make("claudeAgent");+const kimiInstanceId = ProviderInstanceId.make("kimi");const codexSelection = {instanceId: codexInstanceId,@@ -284,7 +286,7 @@ describe("provider access health", () => {["claudeAgent", "anthropic"],["cursor", "cursor"],["grok", "xai"],- ["opencode", "kimi-for-coding"],+ ["kimi", "kimi-for-coding"],] as const)("maps %s runtime requests to %s access health", (driver, provider) => {const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-access-map-"));const authPath = NodePath.join(directory, "subscription-auth.json");@@ -843,6 +845,39 @@ describe("AgentControllerLive", () => {);});+ it.effect("runs the saved Kimi model through Mastra without provider fallback", () => {+ const bridge = makeBridge();+ const mastra = makeMastraHarness();+ return provideController(+ Effect.gen(function* () {+ const controller = yield* AgentController;+ yield* controller.resolveEngine({+ threadId: kimiThreadId,+ engine: { provider: "kimi", model: "k3-256k" },+ fallback: codexSelection,+ mode: "default",+ });+ const session = yield* controller.startSession(kimiThreadId, {+ threadId: kimiThreadId,+ provider: ProviderDriverKind.make("kimi"),+ providerInstanceId: kimiInstanceId,+ cwd: process.cwd(),+ modelSelection: { instanceId: kimiInstanceId, model: "k3-256k" },+ runtimeMode: "approval-required",+ });++ assert.equal(session.provider, "kimi");+ assert.equal(session.model, "k3-256k");+ expect(mastra.session.model.switch).toHaveBeenCalledWith({+ modelId: "kimi-for-coding/k3-256k",+ });+ expect(bridge.startSession).not.toHaveBeenCalled();+ }),+ bridge.service,+ mastra.factory,+ );+ });+it.effect("stops a legacy session after resolving the thread to Codex", () => {const bridge = makeBridge();const mastra = makeMastraHarness();diff --git a/apps/server/src/provider/Layers/AgentController.ts b/apps/server/src/provider/Layers/AgentController.tsindex 13e47588c..ca8086696 100644--- a/apps/server/src/provider/Layers/AgentController.ts+++ b/apps/server/src/provider/Layers/AgentController.ts@@ -45,6 +45,7 @@ import {} from "../../subscription-auth/service.ts";import {createAkeruMastraHarness,+ mastraModelId,type AkeruMastraHarness,type AkeruMastraHarnessOptions,type AkeruMastraSession,@@ -127,19 +128,6 @@ function mastraModeId(mode: "default" | "plan"): string {return mode === "plan" ? PLAN_MODE_ID : DEFAULT_MODE_ID;}-function mastraModelId(provider: ProviderDriverKind, model: string): string {- switch (String(provider)) {- case "codex":- return `openai/${model}`;- case "claudeAgent":- return `anthropic/${model}`;- case "grok":- return `xai/${model}`;- default:- return model.includes("/") ? model : `${provider}/${model}`;- }-}-export function toMcpServerConfigs(servers: readonly McpServer[]): Record<string, McpServerConfig> {return Object.fromEntries(servers.map((server) => [@@ -162,7 +150,7 @@ function permissionPolicy(}function usesMastraCode(provider: ProviderDriverKind): boolean {- return String(provider) === "codex";+ return provider === "codex" || provider === "kimi";}function subscriptionProviderForDriver(@@ -177,7 +165,7 @@ function subscriptionProviderForDriver(return "cursor";case "grok":return "xai";- case "opencode":+ case "kimi":return "kimi-for-coding";default:return undefined;@@ -263,6 +251,7 @@ const make = (options?: AgentControllerLiveOptions) =>const bundle = yield* runMastra("construct", () =>makeMastraHarness({authStorage,+ getKimiAccess: () => subscriptionAuth.getKimiForCodingAccess(),getThreadTools: (threadId) => mcpManagers.get(threadId)?.getTools() ?? {},getThreadWorkspace: (threadId) => workspaces.get(threadId),}),diff --git a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts b/apps/server/src/provider/Layers/ProviderAdapterRegistry.tsindex b492399b1..469d433f7 100644--- a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts+++ b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts@@ -36,7 +36,7 @@ const makeProviderAdapterRegistry = Effect.fn("makeProviderAdapterRegistry")(funconst getByInstance: ProviderAdapterRegistryShape["getByInstance"] = (instanceId) =>registry.getInstance(instanceId).pipe(Effect.flatMap((instance) =>- instance === undefined+ instance?.adapter === undefined? Effect.fail(new ProviderUnsupportedError({provider: instanceId,diff --git a/apps/server/src/provider/Layers/ProviderRegistry.test.ts b/apps/server/src/provider/Layers/ProviderRegistry.test.tsindex 663ee9036..4f1bcb18d 100644--- a/apps/server/src/provider/Layers/ProviderRegistry.test.ts+++ b/apps/server/src/provider/Layers/ProviderRegistry.test.ts@@ -1747,6 +1747,7 @@ it.layer(Layer.mergeAll(NodeServices.layer, ServerSettingsModule.layerTest(), Te"codex","cursor","grok",+ "kimi","opencode",]);assert.strictEqual(cursorProvider?.enabled, false);diff --git a/apps/server/src/provider/ProviderDriver.ts b/apps/server/src/provider/ProviderDriver.tsindex c738882c2..c01e374e1 100644--- a/apps/server/src/provider/ProviderDriver.ts+++ b/apps/server/src/provider/ProviderDriver.ts@@ -69,8 +69,10 @@ export interface ProviderInstance {readonly accentColor?: string | undefined;readonly enabled: boolean;readonly snapshot: ServerProviderShape;- readonly adapter: ProviderAdapterShape<ProviderAdapterError>;- readonly textGeneration: TextGeneration.TextGeneration["Service"];+ /** Present for legacy/provider-native session transports. Mastra-native drivers omit it. */+ readonly adapter: ProviderAdapterShape<ProviderAdapterError> | undefined;+ /** Present when the provider supports app-level title and source-control writing. */+ readonly textGeneration: TextGeneration.TextGeneration["Service"] | undefined;}export interface ProviderContinuationIdentity {diff --git a/apps/server/src/provider/builtInDrivers.ts b/apps/server/src/provider/builtInDrivers.tsindex 791a96e1d..622b48944 100644--- a/apps/server/src/provider/builtInDrivers.ts+++ b/apps/server/src/provider/builtInDrivers.ts@@ -24,6 +24,7 @@ import { ClaudeDriver, type ClaudeDriverEnv } from "./Drivers/ClaudeDriver.ts";import { CodexDriver, type CodexDriverEnv } from "./Drivers/CodexDriver.ts";import { CursorDriver, type CursorDriverEnv } from "./Drivers/CursorDriver.ts";import { GrokDriver, type GrokDriverEnv } from "./Drivers/GrokDriver.ts";+import { KimiDriver, type KimiDriverEnv } from "./Drivers/KimiDriver.ts";import { OpenCodeDriver, type OpenCodeDriverEnv } from "./Drivers/OpenCodeDriver.ts";import type { AnyProviderDriver } from "./ProviderDriver.ts";@@ -37,6 +38,7 @@ export type BuiltInDriversEnv =| CodexDriverEnv| CursorDriverEnv| GrokDriverEnv+ | KimiDriverEnv| OpenCodeDriverEnv;/**@@ -49,5 +51,6 @@ export const BUILT_IN_DRIVERS: ReadonlyArray<AnyProviderDriver<BuiltInDriversEnvClaudeDriver,CursorDriver,GrokDriver,+ KimiDriver,OpenCodeDriver,];diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.tsindex 0d5e90cf5..e0f6c5fc0 100644--- a/apps/server/src/serverSettings.ts+++ b/apps/server/src/serverSettings.ts@@ -236,6 +236,7 @@ const PersistedOptionalProviderSettings = Schema.Struct({Schema.Struct({cursor: Schema.optionalKey(Schema.Struct({ enabled: Schema.optionalKey(Schema.Boolean) })),grok: Schema.optionalKey(Schema.Struct({ enabled: Schema.optionalKey(Schema.Boolean) })),+ kimi: Schema.optionalKey(Schema.Struct({ enabled: Schema.optionalKey(Schema.Boolean) })),opencode: Schema.optionalKey(Schema.Struct({ enabled: Schema.optionalKey(Schema.Boolean) })),}),),@@ -283,6 +284,10 @@ function restoreUsedProviders(...settings.providers.grok,enabled: persisted.providers?.grok?.enabled ?? usedProviders.has("grok"),},+ kimi: {+ ...settings.providers.kimi,+ enabled: persisted.providers?.kimi?.enabled ?? true,+ },opencode: {...settings.providers.opencode,enabled: persisted.providers?.opencode?.enabled ?? usedProviders.has("opencode"),diff --git a/apps/server/src/subscription-auth/providers/kimi.test.ts b/apps/server/src/subscription-auth/providers/kimi.test.tsnew file mode 100644index 000000000..1c2286ee6--- /dev/null+++ b/apps/server/src/subscription-auth/providers/kimi.test.ts@@ -0,0 +1,21 @@+import { describe, expect, it } from "vite-plus/test";++import { createDeviceCodePollState } from "../deviceCode.ts";+import { pollKimiDeviceLogin, type KimiDeviceLoginPending } from "./kimi.ts";++describe("Kimi For Coding OAuth", () => {+ it("fails legacy pending logins without throwing", async () => {+ const pending = {+ deviceCode: "legacy-device-code",+ userCode: "ABCD-EFGH",+ url: "https://auth.kimi.com/device",+ instructions: "Enter code: ABCD-EFGH",+ state: createDeviceCodePollState({ intervalSeconds: 5, expiresInSeconds: 900 }),+ } as KimiDeviceLoginPending;++ await expect(pollKimiDeviceLogin(pending)).resolves.toEqual({+ status: "failed",+ error: "Kimi For Coding login is missing its device identity. Restart the login.",+ });+ });+});diff --git a/apps/server/src/subscription-auth/providers/kimi.ts b/apps/server/src/subscription-auth/providers/kimi.tsindex 96900e333..609b97643 100644--- a/apps/server/src/subscription-auth/providers/kimi.ts+++ b/apps/server/src/subscription-auth/providers/kimi.ts@@ -225,6 +225,12 @@ export async function pollKimiDeviceLogin(pending: KimiDeviceLoginPending,options?: { signal?: AbortSignal },): Promise<KimiDevicePollResult> {+ if (!isKimiCodingDeviceId(pending.deviceId)) {+ return {+ status: "failed",+ error: "Kimi For Coding login is missing its device identity. Restart the login.",+ };+ }const step = await stepDeviceCodePoll(pending.state, () =>pollKimiTokenOnce(pending, options?.signal),);diff --git a/apps/server/src/textGeneration/TextGeneration.ts b/apps/server/src/textGeneration/TextGeneration.tsindex 3b3513899..f42072e13 100644--- a/apps/server/src/textGeneration/TextGeneration.ts+++ b/apps/server/src/textGeneration/TextGeneration.ts@@ -129,15 +129,15 @@ const resolveInstance = (registry: ProviderInstanceRegistry.ProviderInstanceRegistry["Service"],operation: TextGenerationOp,instanceId: ProviderInstanceId,-): Effect.Effect<ProviderInstance["textGeneration"], TextGenerationError> =>+): Effect.Effect<NonNullable<ProviderInstance["textGeneration"]>, TextGenerationError> =>registry.getInstance(instanceId).pipe(Effect.flatMap((instance) =>- instance+ instance?.textGeneration? Effect.succeed(instance.textGeneration): Effect.fail(new TextGenerationError({operation,- detail: `No provider instance registered for id '${instanceId}'.`,+ detail: `Provider instance '${instanceId}' does not support text generation.`,}),),),diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsxindex cd0854e17..e0574de73 100644--- a/apps/web/src/components/Icons.tsx+++ b/apps/web/src/components/Icons.tsx@@ -214,6 +214,12 @@ export const GrokIcon: Icon = ({ className, ...props }) => (</svg>);+export const KimiIcon: Icon = (props) => (+ <svg {...props} viewBox="0 0 24 24">+ <image href="/provider-icons/kimi-for-coding.svg" width="24" height="24" />+ </svg>+);+export const TraeIcon: Icon = (props) => (<svg {...props} viewBox="0 0 24 24" fill="currentColor">{/* Back rectangle: left strip + bottom strip drawn separately — empty bottom-left corner is the gap between them */}diff --git a/apps/web/src/components/chat/providerIconUtils.ts b/apps/web/src/components/chat/providerIconUtils.tsindex 842c616fe..504c80be3 100644--- a/apps/web/src/components/chat/providerIconUtils.ts+++ b/apps/web/src/components/chat/providerIconUtils.ts@@ -1,5 +1,5 @@import { ProviderDriverKind } from "@t3tools/contracts";-import { ClaudeAI, CursorIcon, GrokIcon, Icon, OpenAI, OpenCodeIcon } from "../Icons";+import { ClaudeAI, CursorIcon, GrokIcon, Icon, KimiIcon, OpenAI, OpenCodeIcon } from "../Icons";import { PROVIDER_OPTIONS } from "../../session-logic";export const PROVIDER_ICON_BY_PROVIDER: Partial<Record<ProviderDriverKind, Icon>> = {@@ -8,6 +8,7 @@ export const PROVIDER_ICON_BY_PROVIDER: Partial<Record<ProviderDriverKind, Icon>[ProviderDriverKind.make("opencode")]: OpenCodeIcon,[ProviderDriverKind.make("cursor")]: CursorIcon,[ProviderDriverKind.make("grok")]: GrokIcon,+ [ProviderDriverKind.make("kimi")]: KimiIcon,};function isAvailableProviderOption(option: (typeof PROVIDER_OPTIONS)[number]): option is {diff --git a/apps/web/src/components/settings/ProviderModelsSection.tsx b/apps/web/src/components/settings/ProviderModelsSection.tsxindex 9a42961d1..e4fddd068 100644--- a/apps/web/src/components/settings/ProviderModelsSection.tsx+++ b/apps/web/src/components/settings/ProviderModelsSection.tsx@@ -34,6 +34,7 @@ const CUSTOM_MODEL_PLACEHOLDER_BY_KIND: Partial<Record<ProviderDriverKind, strin[ProviderDriverKind.make("codex")]: "gpt-6.7-codex-ultra-preview",[ProviderDriverKind.make("claudeAgent")]: "claude-sonnet-5",[ProviderDriverKind.make("cursor")]: "claude-sonnet-4-6",+ [ProviderDriverKind.make("kimi")]: "k3-256k",[ProviderDriverKind.make("opencode")]: "openai/gpt-5",};diff --git a/apps/web/src/components/settings/ProviderSettingsForm.test.ts b/apps/web/src/components/settings/ProviderSettingsForm.test.tsindex af460824c..72ff2313a 100644--- a/apps/web/src/components/settings/ProviderSettingsForm.test.ts+++ b/apps/web/src/components/settings/ProviderSettingsForm.test.ts@@ -49,6 +49,13 @@ describe("ProviderSettingsForm helpers", () => {]);});+ it("registers Kimi settings in the provider picker", () => {+ const kimi = DRIVER_OPTION_BY_VALUE[ProviderDriverKind.make("kimi")];++ expect(kimi).toMatchObject({ label: "Kimi For Coding" });+ expect(deriveProviderSettingsFields(kimi!)).toEqual([]);+ });+it("preserves unknown config keys while omitting empty configurable fields", () => {const opencode = DRIVER_OPTION_BY_VALUE[ProviderDriverKind.make("opencode")];expect(opencode).toBeDefined();diff --git a/apps/web/src/components/settings/providerDriverMeta.ts b/apps/web/src/components/settings/providerDriverMeta.tsindex bfee6a8d6..60b753152 100644--- a/apps/web/src/components/settings/providerDriverMeta.ts+++ b/apps/web/src/components/settings/providerDriverMeta.ts@@ -3,11 +3,20 @@ import {CodexSettings,CursorSettings,GrokSettings,+ KimiSettings,OpenCodeSettings,ProviderDriverKind,} from "@t3tools/contracts";import type * as Schema from "effect/Schema";-import { ClaudeAI, CursorIcon, GrokIcon, type Icon, OpenAI, OpenCodeIcon } from "../Icons";+import {+ ClaudeAI,+ CursorIcon,+ GrokIcon,+ KimiIcon,+ type Icon,+ OpenAI,+ OpenCodeIcon,+} from "../Icons";type ProviderSettingsSchema = {readonly fields: Readonly<Record<string, Schema.Top>>;@@ -61,6 +70,13 @@ export const PROVIDER_CLIENT_DEFINITIONS: readonly ProviderClientDefinition[] =badgeLabel: "Early Access",settingsSchema: GrokSettings,},+ {+ value: ProviderDriverKind.make("kimi"),+ label: "Kimi For Coding",+ icon: KimiIcon,+ badgeLabel: "Early Access",+ settingsSchema: KimiSettings,+ },{value: ProviderDriverKind.make("opencode"),label: "OpenCode",diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.tsindex c2bb7687a..ad4ddc5d5 100644--- a/apps/web/src/session-logic.ts+++ b/apps/web/src/session-logic.ts@@ -55,6 +55,12 @@ export const PROVIDER_OPTIONS: Array<{available: true,pickerSidebarBadge: "new",},+ {+ value: ProviderDriverKind.make("kimi"),+ label: "Kimi For Coding",+ available: true,+ pickerSidebarBadge: "new",+ },];export type WorkLogToolLifecycleStatus =diff --git a/packages/contracts/src/model.ts b/packages/contracts/src/model.tsindex 9fcd0d266..22d1aab71 100644--- a/packages/contracts/src/model.ts+++ b/packages/contracts/src/model.ts@@ -131,6 +131,7 @@ const CODEX_DRIVER_KIND = ProviderDriverKind.make("codex");const CLAUDE_DRIVER_KIND = ProviderDriverKind.make("claudeAgent");const CURSOR_DRIVER_KIND = ProviderDriverKind.make("cursor");const GROK_DRIVER_KIND = ProviderDriverKind.make("grok");+const KIMI_DRIVER_KIND = ProviderDriverKind.make("kimi");const OPENCODE_DRIVER_KIND = ProviderDriverKind.make("opencode");export const DEFAULT_MODEL = "gpt-5.6-sol";@@ -152,6 +153,7 @@ export const DEFAULT_MODEL_BY_PROVIDER: Partial<Record<ProviderDriverKind, strin[CLAUDE_DRIVER_KIND]: "claude-sonnet-5",[CURSOR_DRIVER_KIND]: "auto",[GROK_DRIVER_KIND]: "grok-build",+ [KIMI_DRIVER_KIND]: "k3",[OPENCODE_DRIVER_KIND]: "openai/gpt-5",};@@ -221,5 +223,6 @@ export const PROVIDER_DISPLAY_NAMES: Partial<Record<ProviderDriverKind, string>>[CLAUDE_DRIVER_KIND]: "Claude",[CURSOR_DRIVER_KIND]: "Cursor",[GROK_DRIVER_KIND]: "Grok",+ [KIMI_DRIVER_KIND]: "Kimi For Coding",[OPENCODE_DRIVER_KIND]: "OpenCode",};diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.tsindex 887cfe178..1032377ec 100644--- a/packages/contracts/src/settings.ts+++ b/packages/contracts/src/settings.ts@@ -526,6 +526,18 @@ export const GrokSettings = makeProviderSettingsSchema();export type GrokSettings = typeof GrokSettings.Type;+export const KimiSettings = makeProviderSettingsSchema({+ enabled: Schema.Boolean.pipe(+ Schema.withDecodingDefault(Effect.succeed(true)),+ Schema.annotateKey({ providerSettingsForm: { hidden: true } }),+ ),+ customModels: Schema.Array(Schema.String).pipe(+ Schema.withDecodingDefault(Effect.succeed([])),+ Schema.annotateKey({ providerSettingsForm: { hidden: true } }),+ ),+});+export type KimiSettings = typeof KimiSettings.Type;+export const OpenCodeSettings = makeProviderSettingsSchema({// Off by default (like Cursor and Grok): the binding is not yet stable@@ -727,6 +739,7 @@ export const ServerSettings = Schema.Struct({claudeAgent: ClaudeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),cursor: CursorSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),grok: GrokSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),+ kimi: KimiSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),opencode: OpenCodeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),}).pipe(Schema.withDecodingDefault(Effect.succeed({}))),// New driver-agnostic instance map. Keyed by `ProviderInstanceId`; values@@ -873,6 +886,11 @@ const GrokSettingsPatch = Schema.Struct({customModels: Schema.optionalKey(Schema.Array(Schema.String)),});+const KimiSettingsPatch = Schema.Struct({+ enabled: Schema.optionalKey(Schema.Boolean),+ customModels: Schema.optionalKey(Schema.Array(Schema.String)),+});+const OpenCodeSettingsPatch = Schema.Struct({enabled: Schema.optionalKey(Schema.Boolean),binaryPath: Schema.optionalKey(TrimmedString),@@ -931,6 +949,7 @@ export const ServerSettingsPatch = Schema.Struct({claudeAgent: Schema.optionalKey(ClaudeSettingsPatch),cursor: Schema.optionalKey(CursorSettingsPatch),grok: Schema.optionalKey(GrokSettingsPatch),+ kimi: Schema.optionalKey(KimiSettingsPatch),opencode: Schema.optionalKey(OpenCodeSettingsPatch),}),),diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex cfc849a78..f62b99648 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -457,6 +457,9 @@ importers:apps/server:dependencies:+ '@ai-sdk/anthropic':+ specifier: 3.0.113+ version: 3.0.113([email protected])'@anthropic-ai/claude-agent-sdk':specifier: ^0.3.170version: 0.3.170(@anthropic-ai/[email protected]([email protected]))(@modelcontextprotocol/[email protected]([email protected]))([email protected])