praxis-agent 0.62.6 → 0.63.0

package/dist/application/session-service.d.ts

@@ -72,6 +72,8 @@ export interface ClaudeSessionServiceOptions {
     providerForMainModel?: (model: string) => ModelProvider;
     /** Creates one fresh main-turn provider per outer user turn; never used for auxiliary model calls. */
     providerForTurn?: (model?: string) => ModelProvider;
+    /** Creates one fresh provider for each automatic session-name suggestion. */
+    sessionNameProviderFactory?: () => ModelProvider;
     /** Creates a provider adapter dedicated to Session memory requests so
      *  adapter-local cache and retry state are not shared with the foreground. */
     sessionMemoryProviderFactory?: () => ModelProvider;

package/dist/application/session-service.js

@@ -1534,7 +1534,7 @@ export class ClaudeSessionService {
         }
     }
     async sessionNameSuggestion(sessionId, signal) {
-        const provider = this.provider();
+        const provider = this.options.sessionNameProviderFactory?.() ?? this.provider();
         {
             const transcript = new NativeSessionTranscript({
                 sessionId,

package/dist/cli-runtime.js

@@ -1047,6 +1047,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     let providerForModel;
     let providerForMainModel;
     let providerForTurn;
+    let sessionNameProviderFactory;
     let providerBillingMode;
     const context = parseContextEnvironment(runtimeEnvironment);
     const apiKey = runtimeEnvironment.PRAXIS_API_KEY;
@@ -1186,6 +1187,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     ? defaultProvider
                     : createProviderStack(selectedModel, 'turn');
             };
+            if (registry.hasExplicitModelAlias('haiku')) {
+                sessionNameProviderFactory = () => createProviderStack('haiku', 'completion');
+            }
         }
         catch (error) {
             const optionalProviderError = error instanceof ProviderAuthenticationError ||
@@ -1238,6 +1242,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         ...(!experimentalNativeTranscriptWrites && sessionMemoryProviderFactory
             ? { sessionMemoryProviderFactory }
             : {}),
+        ...(!experimentalNativeTranscriptWrites && sessionNameProviderFactory
+            ? { sessionNameProviderFactory }
+            : {}),
         ...(!experimentalNativeTranscriptWrites && sessionKind !== undefined
             ? { sessionKind }
             : {}),

package/dist/providers/anthropic-model-alias.d.ts

@@ -0,0 +1,4 @@
+export type AnthropicModelAliasOverrides = Readonly<Partial<Record<'sonnet' | 'opus' | 'haiku', string>>>;
+export declare function anthropicModelAliasOverridesFromEnvironment(environment: Readonly<Record<string, string | undefined>>): AnthropicModelAliasOverrides;
+export declare function resolveAnthropicModelAlias(model: string, overrides?: AnthropicModelAliasOverrides): string;
+//# sourceMappingURL=anthropic-model-alias.d.ts.map

package/dist/providers/anthropic-model-alias.js

@@ -0,0 +1,37 @@
+const DEFAULTS = {
+    sonnet: 'claude-sonnet-5',
+    opus: 'claude-opus-5',
+    haiku: 'claude-haiku-4-5-20251001',
+};
+const ENVIRONMENT_KEYS = {
+    sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+};
+export function anthropicModelAliasOverridesFromEnvironment(environment) {
+    const overrides = {};
+    for (const family of ['sonnet', 'opus', 'haiku']) {
+        const value = environment[ENVIRONMENT_KEYS[family]];
+        if (value === undefined || value.trim().length === 0)
+            continue;
+        if (value.length > 256) {
+            throw new Error(`${ENVIRONMENT_KEYS[family]} must be at most 256 characters`);
+        }
+        overrides[family] = value;
+    }
+    return overrides;
+}
+export function resolveAnthropicModelAlias(model, overrides = {}) {
+    const longContext = model.endsWith('[1m]');
+    const family = longContext ? model.slice(0, -'[1m]'.length) : model;
+    if (family !== 'sonnet' && family !== 'opus' && family !== 'haiku') {
+        return model;
+    }
+    if (longContext && family === 'haiku')
+        return model;
+    const resolved = overrides[family] ?? DEFAULTS[family];
+    if (!longContext || resolved.endsWith('[1m]'))
+        return resolved;
+    return `${resolved}[1m]`;
+}
+//# sourceMappingURL=anthropic-model-alias.js.map

package/dist/providers/provider-registry.d.ts

@@ -1,6 +1,7 @@
 import type { ModelProvider, ModelThinkingConfig } from '../core/runtime.js';
 import { type CodexOAuthVault } from './codex-oauth.js';
 import { type ProviderProtocol, type ProviderTarget } from './provider-settings.js';
+import { type AnthropicModelAliasOverrides } from './anthropic-model-alias.js';
 import type { ProviderCredentialSourceMetadata, ProviderCredentialReader, ResolvedProviderCredential } from './provider-auth.js';
 import { parseProviderEnvironment, type ContextEnvironment } from './environment.js';
 import { type AnthropicPromptCachePolicy } from './anthropic-prompt-cache.js';
@@ -22,6 +23,7 @@ export interface ProviderRegistryOptions {
     }) => AnthropicPromptCachePolicy;
     fetchImplementation?: typeof fetch;
     providerEnvironment?: ReturnType<typeof parseProviderEnvironment>;
+    anthropicModelAliasOverrides?: AnthropicModelAliasOverrides;
     vault?: CodexOAuthVault;
 }
 export interface ResolveProviderRegistryOptions {
@@ -45,6 +47,7 @@ export type ProviderRegistrySourceMetadata = ProviderCredentialSourceMetadata;
 export interface ProviderRegistry {
     readonly target: ProviderTarget;
     readonly credentialSource: ProviderRegistrySourceMetadata;
+    hasExplicitModelAlias(modelId: string): boolean;
     create(modelId?: string): ModelProvider;
 }
 export declare function resolveProviderContextWindowTokens(options: {

package/dist/providers/provider-registry.js

@@ -7,6 +7,7 @@ import { NonStreamingFallbackModelProvider } from './non-streaming-fallback-prov
 import { CodexOAuthCredentialManager, } from './codex-oauth.js';
 import { resolveProviderTarget, } from './provider-settings.js';
 import { resolveAnthropicModelSpec } from './anthropic-model-spec.js';
+import { anthropicModelAliasOverridesFromEnvironment, resolveAnthropicModelAlias, } from './anthropic-model-alias.js';
 import { ProviderAuthenticationError, resolveProviderCredential, } from './provider-auth.js';
 import { parseContextEnvironment, parseProviderEnvironment, } from './environment.js';
 import { createAnthropicPromptCachePolicyResolver, } from './anthropic-prompt-cache.js';
@@ -55,6 +56,10 @@ export async function resolveProviderRegistry(options) {
         PRAXIS_BASE_URL: target.baseUrl,
     };
     const providerEnvironment = parseProviderEnvironment(controlsEnvironment);
+    const anthropicModelAliasOverrides = target.providerId === 'anthropic' &&
+        target.protocol === 'anthropic-messages'
+        ? anthropicModelAliasOverridesFromEnvironment(environment)
+        : undefined;
     const promptCacheResolver = target.protocol === 'anthropic-messages'
         ? createAnthropicPromptCachePolicyResolver(controlsEnvironment)
         : undefined;
@@ -74,6 +79,9 @@ export async function resolveProviderRegistry(options) {
         ...(promptCacheResolver === undefined
             ? {}
             : { anthropicPromptCacheResolver: promptCacheResolver }),
+        ...(anthropicModelAliasOverrides === undefined
+            ? {}
+            : { anthropicModelAliasOverrides }),
         ...(options.fetchImplementation === undefined
             ? {}
             : { fetchImplementation: options.fetchImplementation }),
@@ -91,7 +99,7 @@ class NativeProviderRegistry {
     codexManager;
     constructor(options) {
         this.options = options;
-        this.target = options.target;
+        this.target = this.resolveTarget(options.target);
         this.credentialSource = options.credential.source;
         if (options.target.protocol === 'codex-subscription') {
             if (options.credential.type !== 'oauth') {
@@ -106,7 +114,7 @@ class NativeProviderRegistry {
         }
     }
     create(modelId = this.target.modelId) {
-        const target = { ...this.target, modelId };
+        const target = this.resolveTarget({ ...this.target, modelId });
         if (target.protocol === 'codex-subscription') {
             if (!this.codexManager)
                 throw new ProviderAuthenticationError('invalid_credential', 'Provider authentication failed: Codex subscription credentials are unavailable');
@@ -220,6 +228,24 @@ class NativeProviderRegistry {
         }
         throw new ProviderRegistryError('unsupported_provider', `Unsupported provider protocol: ${target.protocol}`);
     }
+    hasExplicitModelAlias(modelId) {
+        if (this.target.providerId !== 'anthropic' ||
+            this.target.protocol !== 'anthropic-messages')
+            return false;
+        if (modelId !== 'sonnet' && modelId !== 'opus' && modelId !== 'haiku')
+            return false;
+        const override = this.options.anthropicModelAliasOverrides?.[modelId];
+        return override !== undefined && override.trim().length > 0;
+    }
+    resolveTarget(target) {
+        if (target.providerId !== 'anthropic' ||
+            target.protocol !== 'anthropic-messages')
+            return target;
+        return {
+            ...target,
+            modelId: resolveAnthropicModelAlias(target.modelId, this.options.anthropicModelAliasOverrides),
+        };
+    }
     withDeadline(provider) {
         const environment = this.options.providerEnvironment;
         return environment === undefined

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.62.6",
+  "version": "0.63.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",