@zergai/ztc 0.4.0-beta.1 → 0.4.1-dev.36919234045

package/dist/config.d.ts

@@ -1,3 +1,6 @@
+import { type ReasoningWireSurface } from '@zerg/model-contracts';
+import { type RouterCatalog, type RouterCatalogConnection } from './utils/router_catalog.js';
+import type { ReasoningContract } from './utils/reasoning.js';
 import { ZTCConfig, ZTCAuthCredentials, ApiEnvironment, ZTCAuthMode, ZTCConfigScope, CompactionTriggerMode, OpenAICompatibleSettings, ZTCPermissionProfile, IntentLayerSettings, ContextProgressBarSettings, CodexReasoningEffort, WorkflowSettings, Account, AccountRotation } from './config/types.js';
 import type { AuthContext, ResolvedLLMConfig } from './config/resolved.js';
 /** Validate and normalize an OpenAI-compatible inference destination. */
@@ -14,6 +17,12 @@ export declare class ConfigStore {
     private config;
     private profileEmulation;
     private legacyApiKeyFromEnvironment;
+    /**
+     * Whether the routing in `this.config` came from a saved file or an explicit
+     * choice, rather than the built-in default. A config-less process that never
+     * picked a route must not hard-fail on the preset Router route it inherited.
+     */
+    private routingIsConfigured;
     private routerCredentials;
     private routerCredentialsError;
     private routerFallbackWarning;
@@ -21,6 +30,7 @@ export declare class ConfigStore {
     private configScope;
     /** Session-local overrides. Never persisted to config.json. */
     private sessionOverrides;
+    private restoredSessionSelection;
     /** CLI-only overrides. Never persisted to config.json. */
     private cliOverrides;
     /**
@@ -35,6 +45,10 @@ export declare class ConfigStore {
     private applyEnvOverrides;
     load(force?: boolean): Promise<ZTCConfig>;
     refresh(): Promise<void>;
+    /** Copy saved settings and Router credentials, then activate them transactionally.
+     * Account registrations retain their credential paths; account homes are not cloned.
+     */
+    duplicateProfile(requestedName: string, source?: string, activate?: () => void | Promise<void>): Promise<string>;
     /** Load a profile in this process; restore the old view if runtime activation fails. */
     switchProfile(name: string, activate: () => void | Promise<void>): Promise<void>;
     save(): Promise<void>;
@@ -54,6 +68,7 @@ export declare class ConfigStore {
     setConfigScope(scope: ZTCConfigScope): void;
     clearSessionOverrides(): void;
     withConfigScope<T>(scope: ZTCConfigScope, fn: () => T | Promise<T>): Promise<T>;
+    private releaseRestoredSelection;
     set<K extends keyof ZTCConfig>(key: K, value: ZTCConfig[K]): void;
     setGlobal<K extends keyof ZTCConfig>(key: K, value: ZTCConfig[K]): void;
     setAll(next: Partial<ZTCConfig>): void;
@@ -68,7 +83,7 @@ export declare class ConfigStore {
      * `undefined` removes the override instead of shadowing the saved value with
      * an explicit undefined, so the configured setting applies again.
      */
-    setCliOverride<K extends keyof Pick<ZTCConfig, 'provider' | 'model' | 'codexEffort'>>(key: K, value: Pick<ZTCConfig, 'provider' | 'model' | 'codexEffort'>[K]): void;
+    setCliOverride<K extends keyof Pick<ZTCConfig, 'provider' | 'model' | 'codexEffort' | 'authMode' | 'zergProxyUrl'>>(key: K, value: Pick<ZTCConfig, 'provider' | 'model' | 'codexEffort' | 'authMode' | 'zergProxyUrl'>[K]): void;
     getProvider(): string;
     setProvider(provider: string): void;
     /** All registered accounts (empty when no pool is configured). */
@@ -110,7 +125,10 @@ export declare class ConfigStore {
      * Effective Codex effort for the active (or given) provider/model. Priority:
      * per-model > per-provider > global. Defaults to the current provider/model.
      */
+    getReasoningWireSurface(provider?: string, model?: string): ReasoningWireSurface;
     getCodexEffort(provider?: string, model?: string): CodexReasoningEffort | undefined;
+    /** The active transport owns the model's choices, aliases and advertised default. */
+    getReasoningContract(provider?: string, model?: string): ReasoningContract;
     /** Saved effort the active (or given) model rejects; undefined when it applies. */
     getUnsupportedCodexEffort(provider?: string, model?: string): CodexReasoningEffort | undefined;
     /** Effort chosen by a startup `--effort` flag for this process (= none when unset). */
@@ -165,6 +183,21 @@ export declare class ConfigStore {
      * getters stay — they are still used widely.
      */
     getAuthContext(): AuthContext;
+    restoreSessionSelection(metadata: {
+        provider: string;
+        model: string;
+        authMode?: ZTCAuthMode;
+        routerOrigin?: string;
+        configProfile?: string;
+    }): void;
+    getRouterCatalogConnection(destination?: string | undefined): RouterCatalogConnection | undefined;
+    /** New children use configured routing, not a parent's restored inference route. */
+    getChildAuthMode(): ZTCAuthMode;
+    adoptRouterCatalog(catalog: RouterCatalog): Promise<void>;
+    getRouterCatalog(): RouterCatalog | undefined;
+    getResolvedAuthMode(): ZTCAuthMode;
+    getRoutedModelCatalog(): RouterCatalog | undefined;
+    getModelContextWindow(model?: string, provider?: string): number | null | undefined;
     /**
      * Resolve everything a backend factory needs into one struct. Folds in the
      * provider/model override precedence, the direct-key precedence
@@ -179,8 +212,7 @@ export declare class ConfigStore {
      *
      * Reads through `get()` and the env-aware getters (never raw `this.config`)
      * so cli/session overrides stay honored. `apiKey` is the DIRECT provider key;
-     * `authToken`/`useProxy` describe the proxy route separately, so a caller can
-     * still prefer a direct key (e.g. Gemini) over the proxy.
+     * `authToken`/`useProxy` describe the selected proxy route separately.
      */
     resolveLLMBackendConfig(opts?: {
         provider?: string;

package/dist/config.js

@@ -1,7 +1,10 @@
-import { join } from 'path';
-import { readFile, writeFile, mkdir, chmod, unlink, rename, realpath } from 'fs/promises';
+import { modelContract } from '@zerg/model-contracts';
+import { isLocalSubscriptionProvider } from './agent/backends/provider_ids.js';
+import { resolveRouterModel, readRouterCatalog } from './utils/router_catalog.js';
+import { dirname, join } from 'path';
+import { stat, readFile, writeFile, mkdir, chmod, rm, unlink, rename, realpath } from 'fs/promises';
 import { randomUUID } from 'crypto';
-import { activeProfile, builtinProfileEmulation, profileConfigDir, validateProfileName } from './config/profiles.js';
+import { activeProfile, builtinProfileEmulation, listConfigProfiles, profileConfigDir, validateProfileName } from './config/profiles.js';
 import { accountSourceToBackendOptions, canonicalAccountProvider, probeAccountIsolated, resolveActiveAccount, resolveRotation, } from './agent/backends/account_pool.js';
 import { notifyAccountsChanged } from './agent/backends/account_events.js';
 import { inferDefaultProvider, getDefaultApiKeyForProvider, getDefaultModelForProvider, resolveCodexEffort, unsupportedCodexEffort } from './config/defaults.js';
@@ -290,6 +293,20 @@ const ROUTING_SETTING_KEYS = [
 function normalizedOrigin(value) {
     return value?.trim().replace(/\/+$/, '') || undefined;
 }
+/** Explicit deployment routing takes precedence over a saved session origin. */
+function routerOriginFromEnvironment() {
+    if (process.env.ZERG_PROXY_URL)
+        return process.env.ZERG_PROXY_URL;
+    if (process.env.ZERG_ROUTER_BASE_URL)
+        return normalizedOrigin(process.env.ZERG_ROUTER_BASE_URL);
+    const tiers = {
+        local: 'http://host.docker.internal:8000/api/zrouter',
+        dev: 'https://api-dev.zergai.com/api/zrouter', development: 'https://api-dev.zergai.com/api/zrouter',
+        prod: 'https://api.zergai.com/api/zrouter', production: 'https://api.zergai.com/api/zrouter', main: 'https://api.zergai.com/api/zrouter',
+    };
+    const tier = process.env.ZERG_DEPLOY_TIER || '';
+    return Object.hasOwn(tiers, tier) ? tiers[tier] : undefined;
+}
 /**
  * True when the saved provider route can already reach a model: a direct or
  * platform credential, a subscription or account login, a configured
@@ -402,6 +419,12 @@ export class ConfigStore {
     // The legacy slot also carries runtime defaults. Only a configured key may
     // be migrated into apiKeys or written to disk.
     legacyApiKeyFromEnvironment = true;
+    /**
+     * Whether the routing in `this.config` came from a saved file or an explicit
+     * choice, rather than the built-in default. A config-less process that never
+     * picked a route must not hard-fail on the preset Router route it inherited.
+     */
+    routingIsConfigured = false;
     routerCredentials = null;
     routerCredentialsError = null;
     routerFallbackWarning = null;
@@ -409,6 +432,7 @@ export class ConfigStore {
     configScope = 'global';
     /** Session-local overrides. Never persisted to config.json. */
     sessionOverrides = {};
+    restoredSessionSelection = false;
     /** CLI-only overrides. Never persisted to config.json. */
     cliOverrides = {};
     /**
@@ -475,23 +499,10 @@ export class ConfigStore {
             else if (tier === 'prod' || tier === 'production' || tier === 'main')
                 this.config.apiEnvironment = 'production';
         }
-        // LLM proxy URL (routes through platform ZRouter instead of direct API)
-        if (process.env.ZERG_PROXY_URL) {
-            this.config.zergProxyUrl = process.env.ZERG_PROXY_URL;
-        }
-        else if (process.env.ZERG_ROUTER_BASE_URL) {
-            // Standalone ZergRouter (https://zergrouter.com) serves /v1/* at
-            // its root, no /api/zrouter suffix. Lower precedence than ZERG_PROXY_URL.
-            this.config.zergProxyUrl = process.env.ZERG_ROUTER_BASE_URL.replace(/\/+$/, '');
-        }
-        else if (process.env.ZERG_DEPLOY_TIER) {
-            const tier = process.env.ZERG_DEPLOY_TIER;
-            if (tier === 'local')
-                this.config.zergProxyUrl = 'http://host.docker.internal:8000/api/zrouter';
-            else if (tier === 'dev' || tier === 'development')
-                this.config.zergProxyUrl = 'https://api-dev.zergai.com/api/zrouter';
-            else if (tier === 'prod' || tier === 'production' || tier === 'main')
-                this.config.zergProxyUrl = 'https://api.zergai.com/api/zrouter';
+        // Resolve all explicit origin environment variables through one policy.
+        const originOverride = routerOriginFromEnvironment();
+        if (originOverride) {
+            this.config.zergProxyUrl = originOverride;
         }
         else if (!this.config.zergProxyUrl) {
             // Local default: infer ZRouter from the selected API environment.
@@ -599,6 +610,59 @@ export class ConfigStore {
         this.sessionOverrides = sessionOverrides;
         this.configScope = scope;
     }
+    /** Copy saved settings and Router credentials, then activate them transactionally.
+     * Account registrations retain their credential paths; account homes are not cloned.
+     */
+    async duplicateProfile(requestedName, source = activeProfile(), activate = () => { }) {
+        const name = validateProfileName(requestedName.trim());
+        const from = validateProfileName(source);
+        if (name === 'default' || builtinProfileEmulation(name)) {
+            throw new Error(`Cannot duplicate onto "${name}": it is a built-in profile sharing the default settings. Pick another name.`);
+        }
+        if (name === from || (await listConfigProfiles()).includes(name)) {
+            throw new Error(`Config profile "${name}" already exists. Pick another name.`);
+        }
+        const sourceDir = profileConfigDir(from);
+        const emulation = builtinProfileEmulation(from);
+        if (from !== 'default' && !emulation && !(await stat(sourceDir)).isDirectory()) {
+            throw new Error(`Config profile "${from}" does not exist.`);
+        }
+        let saved = {};
+        try {
+            const parsed = JSON.parse(await readFile(join(sourceDir, 'config.json'), 'utf8'));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error(`Invalid config profile "${from}": expected an object.`);
+            }
+            saved = parsed;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (emulation)
+            saved.emulationId = emulation;
+        const destination = profileConfigDir(name);
+        await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
+        // An existing destination, including one created concurrently, is never ours to modify.
+        await mkdir(destination, { mode: 0o700 });
+        try {
+            await writeFile(join(destination, 'config.json'), JSON.stringify(saved, null, 2), { flag: 'wx', mode: 0o600 });
+            try {
+                const auth = await readFile(join(sourceDir, 'router-auth.json'));
+                await writeFile(join(destination, 'router-auth.json'), auth, { flag: 'wx', mode: 0o600 });
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            await this.switchProfile(name, activate);
+        }
+        catch (error) {
+            await rm(destination, { recursive: true, force: true });
+            throw error;
+        }
+        return name;
+    }
     /** Load a profile in this process; restore the old view if runtime activation fails. */
     async switchProfile(name, activate) {
         const next = validateProfileName(name);
@@ -627,6 +691,7 @@ export class ConfigStore {
             routerCredentialsError: this.routerCredentialsError,
             routerFallbackWarning: this.routerFallbackWarning,
             sessionOverrides: this.sessionOverrides,
+            restoredSessionSelection: this.restoredSessionSelection,
             cliOverrides: this.cliOverrides,
             runtimeActivePerProvider: this.runtimeActivePerProvider,
             configScope: this.configScope,
@@ -640,6 +705,7 @@ export class ConfigStore {
         }
         else {
             this.sessionOverrides = {};
+            this.restoredSessionSelection = false;
             this.cliOverrides = {};
             this.runtimeActivePerProvider = {};
             this.configScope = 'global';
@@ -732,6 +798,8 @@ export class ConfigStore {
         return {
             ...(this.cliOverrides.provider !== undefined ? { provider: this.cliOverrides.provider } : {}),
             ...(this.cliOverrides.model !== undefined ? { model: this.cliOverrides.model } : {}),
+            ...(this.cliOverrides.authMode !== undefined ? { authMode: this.cliOverrides.authMode } : {}),
+            ...(this.cliOverrides.zergProxyUrl !== undefined ? { zergProxyUrl: this.cliOverrides.zergProxyUrl } : {}),
         };
     }
     getMaxTokensSource() {
@@ -747,6 +815,7 @@ export class ConfigStore {
     }
     clearSessionOverrides() {
         this.sessionOverrides = {};
+        this.restoredSessionSelection = false;
     }
     async withConfigScope(scope, fn) {
         const previous = this.configScope;
@@ -758,7 +827,15 @@ export class ConfigStore {
             this.configScope = previous;
         }
     }
+    releaseRestoredSelection(key) {
+        if (!this.restoredSessionSelection || !['provider', 'model', 'authMode', 'zergProxyUrl'].includes(key))
+            return;
+        for (const route of ['provider', 'model', 'authMode', 'zergProxyUrl'])
+            delete this.sessionOverrides[route];
+        this.restoredSessionSelection = false;
+    }
     set(key, value) {
+        this.releaseRestoredSelection(key);
         if (this.configScope === 'session' || (key === 'emulationId' && this.profileEmulation)) {
             this.sessionOverrides[key] = value;
             return;
@@ -768,11 +845,14 @@ export class ConfigStore {
             this.legacyApiKeyFromEnvironment = false;
     }
     setGlobal(key, value) {
+        this.releaseRestoredSelection(key);
         this.config[key] = value;
         if (key === 'apiKey')
             this.legacyApiKeyFromEnvironment = false;
     }
     setAll(next) {
+        for (const key of Object.keys(next))
+            this.releaseRestoredSelection(key);
         this.config = { ...build_default_config(), ...this.config, ...next };
         if (Object.hasOwn(next, 'apiKey'))
             this.legacyApiKeyFromEnvironment = false;
@@ -1021,8 +1101,34 @@ export class ConfigStore {
      * Effective Codex effort for the active (or given) provider/model. Priority:
      * per-model > per-provider > global. Defaults to the current provider/model.
      */
+    getReasoningWireSurface(provider = this.getProvider(), model = this.getModel()) {
+        if (provider === 'openai_compatible')
+            return 'chat_tools';
+        if (modelContract(provider, model)?.chatToolReasoningEfforts === undefined)
+            return 'native_api';
+        try {
+            return this.resolveLLMBackendConfig({ provider, model }).useProxy ? 'chat_tools' : 'native_api';
+        }
+        catch (error) {
+            if (error instanceof RouterConfigurationError)
+                return 'chat_tools';
+            throw error;
+        }
+    }
     getCodexEffort(provider, model) {
-        return resolveCodexEffort(this.get(), provider ?? this.getProvider(), model ?? this.getModel());
+        const selectedProvider = provider ?? this.getProvider();
+        const selectedModel = model ?? this.getModel();
+        const catalog = this.getRoutedModelCatalog();
+        const capabilities = catalog ? resolveRouterModel(catalog, selectedProvider, selectedModel)?.capabilities : undefined;
+        return resolveCodexEffort(this.get(), selectedProvider, selectedModel, capabilities
+            ?? this.getReasoningWireSurface(selectedProvider, selectedModel));
+    }
+    /** The active transport owns the model's choices, aliases and advertised default. */
+    getReasoningContract(provider = this.getProvider(), model = this.getModel()) {
+        const catalog = this.getRoutedModelCatalog();
+        if (catalog?.version === 1)
+            return resolveRouterModel(catalog, provider, model)?.capabilities?.reasoning ?? [];
+        return this.getReasoningWireSurface(provider, model);
     }
     /** Saved effort the active (or given) model rejects; undefined when it applies. */
     getUnsupportedCodexEffort(provider, model) {
@@ -1201,6 +1307,84 @@ export class ConfigStore {
             authMode: this.getAuthMode(),
         };
     }
+    restoreSessionSelection(metadata) {
+        // Legacy sessions did not persist routes. Explicit launch overrides retain priority.
+        if (!metadata.authMode || this.cliOverrides.provider || this.cliOverrides.model
+            || (metadata.configProfile && metadata.configProfile !== activeProfile()))
+            return;
+        this.restoredSessionSelection = true;
+        this.sessionOverrides.provider = metadata.provider;
+        this.sessionOverrides.model = metadata.model;
+        this.sessionOverrides.authMode = metadata.authMode;
+        if (metadata.authMode !== 'direct' && metadata.routerOrigin && !routerOriginFromEnvironment())
+            this.sessionOverrides.zergProxyUrl = metadata.routerOrigin;
+    }
+    getRouterCatalogConnection(destination = this.get().zergProxyUrl) {
+        const origin = normalizedOrigin(destination);
+        if (!origin)
+            return undefined;
+        const credentials = this.routerCredentials;
+        if (credentials && !this.routerCredentialsError && credentials.origin === origin) {
+            return { origin, token: credentials.token, workspaceId: credentials.workspaceId };
+        }
+        // Platform sessions are scoped to the platform's proxy, never another Router.
+        const token = origin === this.deriveZRouterUrl(this.getApiBaseUrl()) ? this.getAuthToken() : undefined;
+        return token ? { origin, token, workspaceId: this.getActiveWorkspace()?.id.toString() } : undefined;
+    }
+    /** New children use configured routing, not a parent's restored inference route. */
+    getChildAuthMode() {
+        if (!this.restoredSessionSelection)
+            return this.getAuthMode();
+        const { authMode: _restored, ...session } = this.sessionOverrides;
+        return resolveAuthMode({ ...this.config, ...session, ...this.cliOverrides });
+    }
+    async adoptRouterCatalog(catalog) {
+        if (catalog.version !== 1 || catalog.authRequired || this.getResolvedAuthMode() !== 'zrouter')
+            return;
+        const provider = this.getProvider(), model = this.getModel();
+        const row = resolveRouterModel(catalog, provider, model);
+        if (!row || (row.id === model && row.owned_by === provider))
+            return;
+        if (this.cliOverrides.provider || this.cliOverrides.model) {
+            this.cliOverrides.provider = row.owned_by;
+            this.cliOverrides.model = row.id;
+        }
+        else if (this.sessionOverrides.provider || this.sessionOverrides.model) {
+            this.sessionOverrides.provider = row.owned_by;
+            this.sessionOverrides.model = row.id;
+        }
+        else {
+            this.config.provider = row.owned_by;
+            this.config.model = row.id;
+            await this.save();
+        }
+    }
+    getRouterCatalog() {
+        const connection = this.getRouterCatalogConnection();
+        return connection ? readRouterCatalog(connection) : undefined;
+    }
+    getResolvedAuthMode() {
+        const mode = this.getAuthMode();
+        if (mode !== 'auto')
+            return mode;
+        try {
+            return this.resolveLLMBackendConfig().useProxy ? 'zrouter' : 'direct';
+        }
+        catch {
+            return mode;
+        }
+    }
+    getRoutedModelCatalog() {
+        if (isLocalSubscriptionProvider(this.getProvider()))
+            return undefined;
+        return this.getResolvedAuthMode() === 'zrouter' ? this.getRouterCatalog() : undefined;
+    }
+    getModelContextWindow(model = this.getModel(), provider = this.getProvider()) {
+        const catalog = this.getRoutedModelCatalog();
+        if (catalog?.version !== 1)
+            return undefined;
+        return resolveRouterModel(catalog, provider, model)?.capabilities?.context_window ?? null;
+    }
     /**
      * Resolve everything a backend factory needs into one struct. Folds in the
      * provider/model override precedence, the direct-key precedence
@@ -1215,8 +1399,7 @@ export class ConfigStore {
      *
      * Reads through `get()` and the env-aware getters (never raw `this.config`)
      * so cli/session overrides stay honored. `apiKey` is the DIRECT provider key;
-     * `authToken`/`useProxy` describe the proxy route separately, so a caller can
-     * still prefer a direct key (e.g. Gemini) over the proxy.
+     * `authToken`/`useProxy` describe the selected proxy route separately.
      */
     resolveLLMBackendConfig(opts = {}) {
         // `opts.config` resolves the config reads below (provider, model, authMode,
@@ -1233,15 +1416,15 @@ export class ConfigStore {
         const repoOverride = !opts.provider && !opts.model && !this.hasExplicitModelOverride() && opts.cwd
             ? resolveRepoModelOverride(opts.cwd)
             : null;
-        const provider = repoOverride?.provider
+        let provider = repoOverride?.provider
             ?? normalizeProviderId(opts.provider || cfg.provider || this.getProvider());
         const configProvider = cfg.provider ? normalizeProviderId(cfg.provider) : undefined;
-        const model = repoOverride?.model
+        let model = repoOverride?.model
             ?? opts.model
             ?? (configProvider === provider ? cfg.model : undefined)
             ?? getDefaultModelForProvider(provider);
-        const authMode = resolveAuthMode(cfg);
-        const proxyUrl = cfg.zergProxyUrl;
+        const authMode = isLocalSubscriptionProvider(provider) ? 'direct' : resolveAuthMode(cfg);
+        const proxyUrl = normalizedOrigin(cfg.zergProxyUrl);
         // Legacy platform tokens belong only to its /api/zrouter endpoint. A
         // standalone Router requires its own device login, including after logout.
         // Modal shared endpoints are unavailable through the legacy platform proxy.
@@ -1293,7 +1476,19 @@ export class ConfigStore {
             || this.getOpenAICompatibleSettings(cfg).baseUrl
             || cfg.openaiCompatibleBaseUrl;
         const proxyAvailable = Boolean(proxyUrl && authToken);
-        const useProxy = authMode === 'direct' ? false : proxyAvailable;
+        // Resolve the route here so discovery and backend construction agree. Auto
+        // retains the existing local-subscription and direct-Gemini preferences.
+        const localSubscription = isLocalSubscriptionProvider(provider);
+        const useProxy = authMode === 'direct' ? false : proxyAvailable
+            && !localSubscription && !(authMode === 'auto' && provider === 'gemini' && Boolean(apiKey));
+        if (useProxy) {
+            const catalog = readRouterCatalog({ origin: proxyUrl, token: authToken, workspaceId: this.getRouterCatalogConnection(proxyUrl)?.workspaceId });
+            const descriptor = catalog?.version === 1 ? resolveRouterModel(catalog, provider, model) : undefined;
+            if (descriptor) {
+                provider = descriptor.owned_by;
+                model = descriptor.id;
+            }
+        }
         const compatBaseUrl = provider === 'openai_compatible' && rawCompatBaseUrl
             ? compatEndpoint(rawCompatBaseUrl, { apiKey })
             : rawCompatBaseUrl;
@@ -1314,7 +1509,9 @@ export class ConfigStore {
             codexHome: accountOptions.codexHome,
             codexAuthFilePath: accountOptions.codexAuthFilePath,
             kimiCredsFilePath: accountOptions.kimiCredsFilePath,
-            codexEffort: this.getCodexEffort(provider, model),
+            codexEffort: resolveCodexEffort(cfg, provider, model, (useProxy
+                ? this.getRouterCatalog()?.models.find(row => row.id === model && row.owned_by === provider)?.capabilities : undefined)
+                ?? (useProxy || provider === 'openai_compatible' ? 'chat_tools' : 'native_api')),
         };
     }
     getEnvKey(provider) {
@@ -1335,6 +1532,7 @@ export class ConfigStore {
                     : undefined;
             case 'openai': return process.env.OPENAI_API_KEY;
             case 'deepseek': return process.env.DEEPSEEK_API_KEY;
+            case 'fireworks': return process.env.FIREWORKS_API_KEY;
             case 'gemini': return process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
             case 'inception': return process.env.INCEPTION_API_KEY;
             case 'openai_compatible': return process.env.OPENAI_COMPAT_API_KEY;

package/dist/headless.js

@@ -2736,6 +2736,8 @@ export class HeadlessApp {
      * auto-starts; the user runs /goal resume. Shared by both load branches.
      */
     applyResumedSession(session, restoreRuntimeMode = true) {
+        if (!session.hosted_settings)
+            configStore.restoreSessionSelection(session.metadata);
         this.sessionId = session.metadata.id;
         this.sessionManager.setSessionId(this.sessionId);
         this.sessionName = session.metadata.name;

package/dist/onboarding/first_run.js

@@ -125,8 +125,12 @@ function formatProjectLine(options) {
     return parts.join(' · ');
 }
 function formatRuntimeLine(options) {
+    const providerId = singleLine(options.provider);
+    const modelId = singleLine(options.model);
+    const displayModel = providerId && modelId.startsWith(`${providerId}/`)
+        ? modelId.slice(providerId.length + 1) : modelId;
     const provider = compact(options.provider, 12) || 'not configured';
-    const model = compact(options.model, 24) || 'default';
+    const model = compact(displayModel, 24) || 'default';
     const version = compact(options.version, 12);
     return `Runtime: ${provider}/${model}${version ? ` · ZTC v${version}` : ''}`;
 }

package/dist/panes/model_catalog.d.ts

@@ -1,5 +1,5 @@
 export declare const PANE_PROVIDERS: readonly ["anthropic", "claude_code", "openai", "codex_app_server", "codex_legacy", "gemini", "deepseek", "fireworks", "modal", "kimi", "kimi_code"];
-export type PaneProvider = typeof PANE_PROVIDERS[number];
+export type PaneProvider = string;
 export interface CatalogModel {
     id: string;
     name: string;
@@ -14,13 +14,13 @@ export interface CatalogProviderGroup {
     models: CatalogModel[];
 }
 export declare const MODEL_CATALOG: CatalogProviderGroup[];
-export declare function isPaneProvider(value: string | undefined): value is PaneProvider;
+export declare function isPaneProvider(value: string | undefined, route?: 'auto' | 'direct' | 'zrouter'): value is PaneProvider;
 export declare function getModelDisplayName(modelId: string): string;
 export declare function getProviderForModel(modelId: string): PaneProvider | undefined;
 /** Provider-aware membership for duplicate model IDs such as the Codex catalogs. */
 export declare function isModelAvailableForProvider(provider: string, modelId: string): boolean;
 export declare function isCatalogModelForProvider(provider: PaneProvider, modelId: string): boolean;
-export declare function resolveModelAndProvider(rawModel: string, rawProvider?: string): {
+export declare function resolveModelAndProvider(rawModel: string, rawProvider?: string, route?: 'auto' | 'direct' | 'zrouter'): {
     model: string;
     provider?: PaneProvider | string;
 };

package/dist/panes/model_catalog.js

@@ -1,3 +1,4 @@
+import { configStore } from '../config.js';
 import { GPT_6_API_EFFORTS, getKimiModelInfo, getSupportedCodexReasoningEfforts, KIMI_CODE_MODEL_IDS, KIMI_MODEL_IDS, KIMI_MODEL_INFO, OFFICIAL_CODEX_MODEL_IDS, OFFICIAL_CODEX_MODEL_INFO, } from '../utils/models.js';
 import { DEEPSEEK_FLASH_EFFORTS, DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_EFFORTS, MODAL_DEEPSEEK_FLASH_MODEL } from '../utils/deepseek.js';
 import { FIREWORKS_CHAT_MODELS, FIREWORKS_FUNDED_MODEL } from '../utils/fireworks.js';
@@ -183,8 +184,8 @@ function getCodexModelAliases(id) {
             return [];
     }
 }
-export function isPaneProvider(value) {
-    return !!value && PROVIDER_SET.has(value);
+export function isPaneProvider(value, route) {
+    return !!value && (PROVIDER_SET.has(value) || ((route === 'zrouter' || route === 'auto') && /^[a-z][a-z0-9_-]{0,127}$/.test(value)));
 }
 export function getModelDisplayName(modelId) {
     return MODEL_BY_ID.get(modelId)?.name
@@ -203,8 +204,17 @@ export function isModelAvailableForProvider(provider, modelId) {
 export function isCatalogModelForProvider(provider, modelId) {
     return MODEL_CATALOG.some((group) => group.provider === provider && group.models.some((model) => model.id === modelId));
 }
-export function resolveModelAndProvider(rawModel, rawProvider) {
+export function resolveModelAndProvider(rawModel, rawProvider, route) {
     const trimmed = rawModel.trim();
+    if (route === 'zrouter' && rawProvider)
+        return { model: trimmed, provider: rawProvider };
+    if (route === 'zrouter') {
+        const matches = configStore.getRouterCatalog()?.models.filter(row => row.id === trimmed && row.capabilities?.chat);
+        if (matches?.length === 1)
+            return { model: trimmed, provider: matches[0].owned_by };
+        if (matches && matches.length > 1)
+            throw new Error('Ambiguous Router model. Specify --provider.');
+    }
     const normalized = normalizeLookupValue(trimmed);
     const providerNormalized = (rawProvider || '').toLowerCase();
     // A custom OpenAI-compatible endpoint names its own models, so the id is a
@@ -289,5 +299,19 @@ function getCodexLegacyModelAliases(id) {
     }
 }
 export function getModelCatalogPayload() {
-    return { providers: MODEL_CATALOG };
+    const catalog = configStore.getRoutedModelCatalog();
+    if (catalog?.version !== 1)
+        return { providers: MODEL_CATALOG };
+    const groups = new Map();
+    for (const row of catalog.models) {
+        if (!row.capabilities?.chat)
+            continue;
+        const group = groups.get(row.owned_by) ?? { provider: row.owned_by, label: row.provider_display_name || row.owned_by, models: [] };
+        group.models.push({ id: row.id, name: row.display_name || row.id,
+            description: [row.capabilities.tools === false ? 'Chat only' : '', row.available === false ? 'Access unavailable' : ''].filter(Boolean).join(' · '),
+            supportedReasoningEfforts: row.capabilities.reasoning?.choices,
+            defaultReasoningEffort: row.capabilities.reasoning?.default });
+        groups.set(row.owned_by, group);
+    }
+    return { providers: [...groups.values()] };
 }

package/dist/panes/pane_registry.js

@@ -26,15 +26,19 @@ function inferZtcLaunchSpec(pane) {
     }
     if (!sessionId)
         return undefined;
+    const route = parseFlagValue(args, '--auth-mode');
+    const authMode = route === 'zrouter' || route === 'direct' || route === 'auto' ? route : undefined;
     const explicitProvider = parseFlagValue(args, '--provider');
     const explicitModel = parseFlagValue(args, '--model');
-    const resolved = explicitModel ? resolveModelAndProvider(explicitModel, explicitProvider) : { model: undefined, provider: explicitProvider };
+    const resolved = explicitModel ? resolveModelAndProvider(explicitModel, explicitProvider, authMode) : { model: undefined, provider: explicitProvider };
     return {
         kind: 'ztc',
+        authMode,
+        routerOrigin: parseFlagValue(args, '--router-url'),
         session: { mode: sessionMode, id: sessionId },
         cwd: pane.cwd,
         title: pane.title,
-        providerOverride: isPaneProvider(resolved.provider) ? resolved.provider : undefined,
+        providerOverride: isPaneProvider(resolved.provider, authMode) ? resolved.provider : undefined,
         modelOverride: resolved.model,
     };
 }

package/dist/panes/types.d.ts

@@ -13,6 +13,8 @@ export type PaneSessionSelector = {
     id: string;
 };
 export interface ZtcPaneLaunchSpec {
+    authMode?: 'auto' | 'direct' | 'zrouter';
+    routerOrigin?: string;
     kind: 'ztc';
     session: PaneSessionSelector;
     cwd?: string;