@velum-labs/routekit-daemon 1.4.0 → 1.5.0

package/dist/account-mutation-service.js

@@ -1,6 +1,7 @@
 import { chmodSync, existsSync, lstatSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { cliproxyAccountEntries, cliproxyAccountMatchesKind, defaultSubscriptionAccountDirectory, RateLimitTracker, removeCliproxyAccount, removeSubscriptionAccount, renameSubscriptionAccount, sanitizeSubscriptionLabel, subscriptionAccountIdentity } from "@velum-labs/routekit-accounts";
+import { AccountActivity, AccountAuth } from "@velum-labs/routekit-accounts/effect";
 import { resolveAccountConnector } from "@velum-labs/routekit-registry";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { writeFileAtomic } from "@velum-labs/routekit-runtime/filesystem";
@@ -9,8 +10,12 @@ import { Effect } from "effect";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { cleanupAccountTransaction, markAccountTransactionCommitted, prepareAccountTransaction, rollbackAccountTransaction } from "./account-transaction.js";
 import { DaemonHost } from "./daemon-host-context.js";
-import { daemonAccountServices } from "./account-services.js";
+import { DaemonEnv } from "./daemon-env-context.js";
 import { accountEntries, parseConfigDocument } from "./daemon-maintenance.js";
+import { DaemonState } from "./daemon-state-context.js";
+import { ActiveGateway } from "./services/active-gateway/service.js";
+import { Generations } from "./services/generations/service.js";
+import { Sidecar } from "./sidecar-context.js";
 function rollbackAccountCoordinators(transaction, home, activity, authHealth, error, message) {
     return Effect.gen(function* () {
         yield* Effect.try({
@@ -25,298 +30,312 @@ function rollbackAccountCoordinators(transaction, home, activity, authHealth, er
     });
 }
 /** Owns account removal, rename, sync, and credit redemption. */
-export class AccountMutationService {
-    handlers() {
-        return {
-            "accounts.remove": (params) => Effect.gen(function* () {
-                const { env: daemonEnv, state: runtimeState, generations, activity, auth: authHealth, sidecar } = yield* daemonAccountServices;
-                const env = daemonEnv.env;
-                const home = daemonEnv.home;
-                const configPath = daemonEnv.configPath;
-                const replaceRouter = generations.replace;
-                const resolved = resolveAccountConnector(params.kind);
-                if (resolved === undefined) {
-                    return yield* Effect.fail(new ControlError({
-                        code: "bad_request",
-                        message: `unknown subscription kind: ${params.kind}`
-                    }));
-                }
-                const kind = resolved.kind;
-                let removed = false;
-                yield* runtimeState.serializeEffect(Effect.gen(function* () {
-                    const directory = resolved.info.connector === "native"
-                        ? defaultSubscriptionAccountDirectory(kind, env)
-                        : undefined;
-                    const nativePath = directory === undefined ? undefined : join(directory, `${params.label}.json`);
-                    if (nativePath !== undefined && existsSync(nativePath)) {
-                        const nativeKind = kind;
-                        const hasRemainingAccount = accountEntries(env).some((entry) => entry.connector === "native" &&
-                            entry.subscriptionKind === nativeKind &&
-                            entry.label !== params.label);
-                        const raw = parseYaml(runtimeState.document);
-                        const providers = typeof raw.providers === "object" &&
-                            raw.providers !== null &&
-                            !Array.isArray(raw.providers)
-                            ? { ...raw.providers }
-                            : {};
-                        const disableProvider = !hasRemainingAccount && runtimeState.config.providers[nativeKind] !== undefined;
-                        if (disableProvider) {
-                            delete providers[nativeKind];
-                            raw.providers = providers;
-                            if (typeof raw.defaultModel === "string" &&
-                                raw.defaultModel.startsWith(`${nativeKind}/`)) {
-                                delete raw.defaultModel;
-                            }
+export const accountMutationHandlers = {
+    "accounts.remove": (params) => Effect.gen(function* () {
+        const daemonEnv = yield* DaemonEnv;
+        const runtimeState = yield* DaemonState;
+        const generations = yield* Generations;
+        const activity = yield* AccountActivity;
+        const authHealth = yield* AccountAuth;
+        const sidecar = yield* Sidecar;
+        const env = daemonEnv.env;
+        const home = daemonEnv.home;
+        const configPath = daemonEnv.configPath;
+        const replaceRouter = generations.replace;
+        const resolved = resolveAccountConnector(params.kind);
+        if (resolved === undefined) {
+            return yield* Effect.fail(new ControlError({
+                code: "bad_request",
+                message: `unknown subscription kind: ${params.kind}`
+            }));
+        }
+        const kind = resolved.kind;
+        let removed = false;
+        yield* runtimeState.serializeEffect(Effect.gen(function* () {
+            const directory = resolved.info.connector === "native"
+                ? defaultSubscriptionAccountDirectory(kind, env)
+                : undefined;
+            const nativePath = directory === undefined ? undefined : join(directory, `${params.label}.json`);
+            if (nativePath !== undefined && existsSync(nativePath)) {
+                const nativeKind = kind;
+                const hasRemainingAccount = accountEntries(env).some((entry) => entry.connector === "native" &&
+                    entry.subscriptionKind === nativeKind &&
+                    entry.label !== params.label);
+                const raw = parseYaml(runtimeState.document);
+                const sources = typeof raw.sources === "object" && raw.sources !== null && !Array.isArray(raw.sources)
+                    ? { ...raw.sources }
+                    : Object.fromEntries(Object.entries(runtimeState.config.sources).map(([sourceId, source]) => [
+                        sourceId,
+                        source
+                    ]));
+                const disableProvider = !hasRemainingAccount &&
+                    Object.values(runtimeState.config.sources).some((source) => source.use === nativeKind);
+                if (disableProvider) {
+                    for (const [sourceId, source] of Object.entries(sources)) {
+                        if (typeof source === "object" &&
+                            source !== null &&
+                            !Array.isArray(source) &&
+                            source.use === nativeKind) {
+                            delete sources[sourceId];
                         }
-                        const document = disableProvider ? stringifyYaml(raw) : runtimeState.document;
-                        const config = disableProvider
-                            ? parseConfigDocument(document)
-                            : runtimeState.config;
-                        const transaction = prepareAccountTransaction({
-                            home,
-                            configPath,
-                            accountPaths: [
-                                nativePath,
-                                join(home, "usage", "account-activity.v1.json"),
-                                join(home, "subscriptions", "account-auth.v1.json")
-                            ],
-                            accountRoots: [dirname(nativePath), home, join(home, "subscriptions")],
-                            kind: nativeKind,
-                            provider: nativeKind,
-                            labels: [params.label]
-                        });
-                        const rollbackMessage = `could not remove ${kind}/${params.label}; rollback failed`;
-                        yield* Effect.gen(function* () {
-                            const outcome = yield* Effect.try({
-                                try: () => {
-                                    const result = removeSubscriptionAccount(nativeKind, params.label, {
-                                        accountsDirectory: dirname(nativePath)
-                                    });
-                                    if (!result.removed)
-                                        cleanupAccountTransaction(transaction);
-                                    return result;
-                                },
-                                catch: toRouteKitFailure
-                            });
-                            removed = outcome.removed;
-                            if (!removed)
-                                return;
-                            yield* replaceRouter(config, document, {
-                                write: disableProvider,
-                                configRevision: disableProvider,
-                                accountRevision: true,
-                                persist: () => Effect.gen(function* () {
-                                    yield* activity.remove(subscriptionAccountIdentity(nativeKind, params.label));
-                                    yield* authHealth.remove(subscriptionAccountIdentity(nativeKind, params.label));
-                                    markAccountTransactionCommitted(transaction);
-                                })
-                            });
-                            yield* Effect.try({
-                                try: () => cleanupAccountTransaction(transaction),
-                                catch: toRouteKitFailure
-                            }).pipe(Effect.ignore);
-                        }).pipe(Effect.catch((error) => rollbackAccountCoordinators(transaction, home, activity, authHealth, error, rollbackMessage)));
-                        return;
                     }
-                    const entry = cliproxyAccountEntries(env).find((candidate) => candidate.label === params.label && cliproxyAccountMatchesKind(candidate, kind));
-                    if (entry === undefined)
-                        return;
-                    const previous = yield* Effect.try({
-                        try: () => readFileSync(entry.path),
-                        catch: toRouteKitFailure
-                    });
-                    const cliproxyResult = yield* Effect.try({
-                        try: () => removeCliproxyAccount(params.label, env),
-                        catch: toRouteKitFailure
-                    });
-                    removed = cliproxyResult.removed;
-                    if (!removed)
-                        return;
-                    yield* Effect.gen(function* () {
-                        yield* sidecar.refresh;
-                        yield* replaceRouter(runtimeState.config, runtimeState.document, {
-                            write: false,
-                            accountRevision: true
-                        });
-                    }).pipe(Effect.catch((error) => Effect.gen(function* () {
-                        yield* Effect.try({
-                            try: () => {
-                                writeFileAtomic(entry.path, previous.toString("utf8"), { mode: 0o600 });
-                                chmodSync(entry.path, 0o600);
-                            },
-                            catch: toRouteKitFailure
-                        });
-                        yield* sidecar.refresh.pipe(Effect.ignore);
-                        return yield* Effect.fail(routeKitError(error));
-                    })));
-                }));
-                return { removed, revision: runtimeState.revisions.accounts };
-            }),
-            "accounts.rename": (params) => Effect.gen(function* () {
-                const { env: daemonEnv, state: runtimeState, generations, activity, auth: authHealth } = yield* daemonAccountServices;
-                const host = yield* DaemonHost;
-                const env = daemonEnv.env;
-                const home = daemonEnv.home;
-                const configPath = daemonEnv.configPath;
-                const replaceRouter = generations.replace;
-                const resolved = resolveAccountConnector(params.kind);
-                if (resolved === undefined || resolved.info.connector !== "native") {
-                    return yield* Effect.fail(new ControlError({
-                        code: "bad_request",
-                        message: "account rename supports only claude-code and codex"
-                    }));
-                }
-                for (const [field, label] of [
-                    ["source", params.source],
-                    ["target", params.target]
-                ]) {
-                    if (sanitizeSubscriptionLabel(label) !== label || label.startsWith(".")) {
-                        return yield* Effect.fail(new ControlError({
-                            code: "bad_request",
-                            message: `${field} account label must already be normalized`
-                        }));
+                    raw.sources = sources;
+                    delete raw.providers;
+                    if (typeof raw.defaultModel === "string" &&
+                        raw.defaultModel.startsWith(`${nativeKind}/`)) {
+                        delete raw.defaultModel;
                     }
                 }
-                const kind = resolved.kind;
-                yield* runtimeState.serializeEffect(Effect.gen(function* () {
-                    const directory = defaultSubscriptionAccountDirectory(kind, env);
-                    const sourcePath = join(directory, `${params.source}.json`);
-                    const targetPath = join(directory, `${params.target}.json`);
-                    yield* Effect.try({
+                const document = disableProvider ? stringifyYaml(raw) : runtimeState.document;
+                const config = disableProvider ? parseConfigDocument(document) : runtimeState.config;
+                const transaction = prepareAccountTransaction({
+                    home,
+                    configPath,
+                    accountPaths: [
+                        nativePath,
+                        join(home, "usage", "account-activity.v1.json"),
+                        join(home, "subscriptions", "account-auth.v1.json")
+                    ],
+                    accountRoots: [dirname(nativePath), home, join(home, "subscriptions")],
+                    kind: nativeKind,
+                    provider: nativeKind,
+                    labels: [params.label]
+                });
+                const rollbackMessage = `could not remove ${kind}/${params.label}; rollback failed`;
+                yield* Effect.gen(function* () {
+                    const outcome = yield* Effect.try({
                         try: () => {
-                            if (!existsSync(sourcePath)) {
-                                throw new ControlError({
-                                    code: "not_found",
-                                    message: `${kind}/${params.source} is not enrolled`
-                                });
-                            }
-                            try {
-                                lstatSync(targetPath);
-                                throw new ControlError({
-                                    code: "conflict",
-                                    message: `${kind}/${params.target} is already enrolled`
-                                });
-                            }
-                            catch (error) {
-                                if (error instanceof ControlError ||
-                                    typeof error !== "object" ||
-                                    error === null ||
-                                    !("code" in error) ||
-                                    error.code !== "ENOENT") {
-                                    throw error;
-                                }
-                            }
+                            const result = removeSubscriptionAccount(nativeKind, params.label, {
+                                accountsDirectory: dirname(nativePath)
+                            });
+                            if (!result.removed)
+                                cleanupAccountTransaction(transaction);
+                            return result;
                         },
                         catch: toRouteKitFailure
                     });
-                    const transaction = prepareAccountTransaction({
-                        home,
-                        configPath,
-                        accountPaths: [
-                            sourcePath,
-                            targetPath,
-                            join(directory, ".state.json"),
-                            join(home, "usage", "account-activity.v1.json"),
-                            join(home, "subscriptions", "account-auth.v1.json")
-                        ],
-                        accountRoots: [directory, home, join(home, "subscriptions")],
-                        kind,
-                        provider: kind,
-                        labels: [params.source, params.target]
-                    });
-                    yield* Effect.gen(function* () {
-                        yield* Effect.try({
-                            try: () => {
-                                renameSubscriptionAccount(kind, params.source, params.target, {
-                                    accountsDirectory: directory
-                                });
-                            },
-                            catch: toRouteKitFailure
-                        });
-                        const tracker = yield* RateLimitTracker.open(join(directory, ".state.json"), kind);
-                        yield* tracker.renameMember(params.source, params.target);
-                        host.onAccountTransactionPhase?.("credentials-written");
-                        yield* replaceRouter(runtimeState.config, runtimeState.document, {
-                            write: false,
-                            accountRevision: true,
-                            persist: () => Effect.gen(function* () {
-                                yield* activity.rename(subscriptionAccountIdentity(kind, params.source), subscriptionAccountIdentity(kind, params.target));
-                                yield* authHealth.rename(subscriptionAccountIdentity(kind, params.source), subscriptionAccountIdentity(kind, params.target));
-                                markAccountTransactionCommitted(transaction);
-                            })
-                        });
-                        yield* Effect.try({
-                            try: () => cleanupAccountTransaction(transaction),
-                            catch: toRouteKitFailure
-                        }).pipe(Effect.ignore);
-                    }).pipe(Effect.catch((error) => rollbackAccountCoordinators(transaction, home, activity, authHealth, error, `could not rename ${kind}/${params.source}; rollback failed`)));
-                }));
-                return { renamed: true, revision: runtimeState.revisions.accounts };
-            }),
-            "accounts.sync": () => Effect.gen(function* () {
-                const { state: runtimeState, generations, sidecar } = yield* daemonAccountServices;
-                return yield* runtimeState.serializeEffect(Effect.gen(function* () {
-                    yield* sidecar.refresh;
-                    yield* generations.replace(runtimeState.config, runtimeState.document, {
-                        write: false,
-                        accountRevision: true
+                    removed = outcome.removed;
+                    if (!removed)
+                        return;
+                    yield* replaceRouter(config, document, {
+                        write: disableProvider,
+                        configRevision: disableProvider,
+                        accountRevision: true,
+                        persist: () => Effect.gen(function* () {
+                            yield* activity.remove(subscriptionAccountIdentity(nativeKind, params.label));
+                            yield* authHealth.remove(subscriptionAccountIdentity(nativeKind, params.label));
+                            markAccountTransactionCommitted(transaction);
+                        })
                     });
-                    return { synced: true, revision: runtimeState.revisions.accounts };
+                    yield* Effect.try({
+                        try: () => cleanupAccountTransaction(transaction),
+                        catch: toRouteKitFailure
+                    }).pipe(Effect.ignore);
+                }).pipe(Effect.catch((error) => rollbackAccountCoordinators(transaction, home, activity, authHealth, error, rollbackMessage)));
+                return;
+            }
+            const entry = cliproxyAccountEntries(env).find((candidate) => candidate.label === params.label && cliproxyAccountMatchesKind(candidate, kind));
+            if (entry === undefined)
+                return;
+            const previous = yield* Effect.try({
+                try: () => readFileSync(entry.path),
+                catch: toRouteKitFailure
+            });
+            const cliproxyResult = yield* Effect.try({
+                try: () => removeCliproxyAccount(params.label, env),
+                catch: toRouteKitFailure
+            });
+            removed = cliproxyResult.removed;
+            if (!removed)
+                return;
+            yield* Effect.gen(function* () {
+                yield* sidecar.refresh;
+                yield* replaceRouter(runtimeState.config, runtimeState.document, {
+                    write: false,
+                    accountRevision: true
+                });
+            }).pipe(Effect.catch((error) => Effect.gen(function* () {
+                yield* Effect.try({
+                    try: () => {
+                        writeFileAtomic(entry.path, previous.toString("utf8"), { mode: 0o600 });
+                        chmodSync(entry.path, 0o600);
+                    },
+                    catch: toRouteKitFailure
+                });
+                yield* sidecar.refresh.pipe(Effect.ignore);
+                return yield* Effect.fail(routeKitError(error));
+            })));
+        }));
+        return { removed, revision: runtimeState.revisions.accounts };
+    }),
+    "accounts.rename": (params) => Effect.gen(function* () {
+        const daemonEnv = yield* DaemonEnv;
+        const runtimeState = yield* DaemonState;
+        const generations = yield* Generations;
+        const activity = yield* AccountActivity;
+        const authHealth = yield* AccountAuth;
+        const host = yield* DaemonHost;
+        const env = daemonEnv.env;
+        const home = daemonEnv.home;
+        const configPath = daemonEnv.configPath;
+        const replaceRouter = generations.replace;
+        const resolved = resolveAccountConnector(params.kind);
+        if (resolved === undefined || resolved.info.connector !== "native") {
+            return yield* Effect.fail(new ControlError({
+                code: "bad_request",
+                message: "account rename supports only claude-code and codex"
+            }));
+        }
+        for (const [field, label] of [
+            ["source", params.source],
+            ["target", params.target]
+        ]) {
+            if (sanitizeSubscriptionLabel(label) !== label || label.startsWith(".")) {
+                return yield* Effect.fail(new ControlError({
+                    code: "bad_request",
+                    message: `${field} account label must already be normalized`
                 }));
-            }),
-            "accounts.resetCredits": (params, context) => Effect.gen(function* () {
-                const { gateway } = yield* daemonAccountServices;
-                return yield* gateway
-                    .router()
-                    .listResetCredits(params.kind, params.label, context.signal)
-                    .pipe(Effect.map((resetCredits) => ({
-                    kind: params.kind,
-                    label: params.label,
-                    resetCredits
-                })), Effect.catch((error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (message.includes("is not enrolled") ||
-                        message.includes("no codex account pool")) {
-                        return Effect.fail(new ControlError({ code: "not_found", message }));
+            }
+        }
+        const kind = resolved.kind;
+        yield* runtimeState.serializeEffect(Effect.gen(function* () {
+            const directory = defaultSubscriptionAccountDirectory(kind, env);
+            const sourcePath = join(directory, `${params.source}.json`);
+            const targetPath = join(directory, `${params.target}.json`);
+            yield* Effect.try({
+                try: () => {
+                    if (!existsSync(sourcePath)) {
+                        throw new ControlError({
+                            code: "not_found",
+                            message: `${kind}/${params.source} is not enrolled`
+                        });
                     }
-                    return Effect.fail(routeKitError(error));
-                }));
-            }),
-            "accounts.redeemReset": (params, context) => Effect.gen(function* () {
-                const { gateway } = yield* daemonAccountServices;
-                return yield* gateway
-                    .router()
-                    .redeemReset({
-                    kind: params.kind,
-                    label: params.label,
-                    ...(params.creditId !== undefined ? { creditId: params.creditId } : {}),
-                    ...(params.redeemRequestId !== undefined
-                        ? { redeemRequestId: params.redeemRequestId }
-                        : {})
-                }, context.signal)
-                    .pipe(Effect.map((result) => ({
-                    ok: result.ok,
-                    code: result.code,
-                    kind: "codex",
-                    label: result.label,
-                    redeemRequestId: result.redeemRequestId,
-                    ...(result.creditId !== undefined ? { creditId: result.creditId } : {}),
-                    ...(result.windowsReset !== undefined ? { windowsReset: result.windowsReset } : {}),
-                    usage: result.usage
-                })), Effect.catch((error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (message.includes("is not enrolled") || message.includes("no redeemable")) {
-                        return Effect.fail(new ControlError({ code: "not_found", message }));
+                    try {
+                        lstatSync(targetPath);
+                        throw new ControlError({
+                            code: "conflict",
+                            message: `${kind}/${params.target} is already enrolled`
+                        });
                     }
-                    if (message.includes("does not support") ||
-                        message.includes("no codex account pool") ||
-                        message.includes("creditId must not be empty") ||
-                        message.includes("account label is required")) {
-                        return Effect.fail(new ControlError({ code: "bad_request", message }));
+                    catch (error) {
+                        if (error instanceof ControlError ||
+                            typeof error !== "object" ||
+                            error === null ||
+                            !("code" in error) ||
+                            error.code !== "ENOENT") {
+                            throw error;
+                        }
                     }
-                    return Effect.fail(new ControlError({ code: "internal", message }));
-                }));
-            })
-        };
-    }
-}
+                },
+                catch: toRouteKitFailure
+            });
+            const transaction = prepareAccountTransaction({
+                home,
+                configPath,
+                accountPaths: [
+                    sourcePath,
+                    targetPath,
+                    join(directory, ".state.json"),
+                    join(home, "usage", "account-activity.v1.json"),
+                    join(home, "subscriptions", "account-auth.v1.json")
+                ],
+                accountRoots: [directory, home, join(home, "subscriptions")],
+                kind,
+                provider: kind,
+                labels: [params.source, params.target]
+            });
+            yield* Effect.gen(function* () {
+                yield* Effect.try({
+                    try: () => {
+                        renameSubscriptionAccount(kind, params.source, params.target, {
+                            accountsDirectory: directory
+                        });
+                    },
+                    catch: toRouteKitFailure
+                });
+                const tracker = yield* RateLimitTracker.open(join(directory, ".state.json"), kind);
+                yield* tracker.renameMember(params.source, params.target);
+                host.onAccountTransactionPhase?.("credentials-written");
+                yield* replaceRouter(runtimeState.config, runtimeState.document, {
+                    write: false,
+                    accountRevision: true,
+                    persist: () => Effect.gen(function* () {
+                        yield* activity.rename(subscriptionAccountIdentity(kind, params.source), subscriptionAccountIdentity(kind, params.target));
+                        yield* authHealth.rename(subscriptionAccountIdentity(kind, params.source), subscriptionAccountIdentity(kind, params.target));
+                        markAccountTransactionCommitted(transaction);
+                    })
+                });
+                yield* Effect.try({
+                    try: () => cleanupAccountTransaction(transaction),
+                    catch: toRouteKitFailure
+                }).pipe(Effect.ignore);
+            }).pipe(Effect.catch((error) => rollbackAccountCoordinators(transaction, home, activity, authHealth, error, `could not rename ${kind}/${params.source}; rollback failed`)));
+        }));
+        return { renamed: true, revision: runtimeState.revisions.accounts };
+    }),
+    "accounts.sync": () => Effect.gen(function* () {
+        const runtimeState = yield* DaemonState;
+        const generations = yield* Generations;
+        const sidecar = yield* Sidecar;
+        return yield* runtimeState.serializeEffect(Effect.gen(function* () {
+            yield* sidecar.refresh;
+            yield* generations.replace(runtimeState.config, runtimeState.document, {
+                write: false,
+                accountRevision: true
+            });
+            return { synced: true, revision: runtimeState.revisions.accounts };
+        }));
+    }),
+    "accounts.resetCredits": (params, context) => Effect.gen(function* () {
+        const gateway = yield* ActiveGateway;
+        return yield* gateway
+            .router()
+            .listResetCredits(params.kind, params.label, context.signal)
+            .pipe(Effect.map((resetCredits) => ({
+            kind: params.kind,
+            label: params.label,
+            resetCredits
+        })), Effect.catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("is not enrolled") || message.includes("no codex account pool")) {
+                return Effect.fail(new ControlError({ code: "not_found", message }));
+            }
+            return Effect.fail(routeKitError(error));
+        }));
+    }),
+    "accounts.redeemReset": (params, context) => Effect.gen(function* () {
+        const gateway = yield* ActiveGateway;
+        return yield* gateway
+            .router()
+            .redeemReset({
+            kind: params.kind,
+            label: params.label,
+            ...(params.creditId !== undefined ? { creditId: params.creditId } : {}),
+            ...(params.redeemRequestId !== undefined
+                ? { redeemRequestId: params.redeemRequestId }
+                : {})
+        }, context.signal)
+            .pipe(Effect.map((result) => ({
+            ok: result.ok,
+            code: result.code,
+            kind: "codex",
+            label: result.label,
+            redeemRequestId: result.redeemRequestId,
+            ...(result.creditId !== undefined ? { creditId: result.creditId } : {}),
+            ...(result.windowsReset !== undefined ? { windowsReset: result.windowsReset } : {}),
+            usage: result.usage
+        })), Effect.catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("is not enrolled") || message.includes("no redeemable")) {
+                return Effect.fail(new ControlError({ code: "not_found", message }));
+            }
+            if (message.includes("does not support") ||
+                message.includes("no codex account pool") ||
+                message.includes("creditId must not be empty") ||
+                message.includes("account label is required")) {
+                return Effect.fail(new ControlError({ code: "bad_request", message }));
+            }
+            return Effect.fail(new ControlError({ code: "internal", message }));
+        }));
+    })
+};

package/dist/account-query-service.d.ts

@@ -1,7 +1,5 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 type AccountQueryHandlers = Pick<EffectRouteKitControlHandlers, "accounts.list" | "accounts.status" | "accounts.usage">;
 /** Owns account inventory, live status, and usage queries. */
-export declare class AccountQueryService {
-    handlers(): AccountQueryHandlers;
-}
+export declare const accountQueryHandlers: AccountQueryHandlers;
 export {};