@zergai/ztc 0.3.1-dev.36465749722 → 0.4.1-dev.36919234045

package/README.md

@@ -68,7 +68,7 @@ selecting the same provider preserves your current model.
 Type `/model ` to search providers and current-provider models by ID, name, or alias.
 Search is fuzzy, so `/model dskfl` finds DeepSeek Flash. Use Up/Down to select,
 Tab or Enter to complete a provider and continue to its models. Enter on a model
-suggestion fills its ID; press Enter again to apply it. Escape dismisses suggestions.
+suggestion applies the selected model immediately; Tab fills its ID. Escape dismisses suggestions.
 Custom model IDs can still be entered directly.
 After a provider is entered, the picker names it and lists only its models. A successful
 live catalog replaces bundled suggestions, including when the catalog is empty;
@@ -577,6 +577,13 @@ When a saved session includes `zmux` state, `ztc resume` restores the pane layou
 
 Custom config profiles keep settings and sign-ins separate. Start one with `ztc --profile work`, or switch the running session with `/profile work`. `/profile create work` starts a new profile. Switching keeps the session ID and conversation while rebuilding the agent. A later `ztc resume` restores the session's saved profile unless you specify `--profile`. The default config stays at `~/.ztc/config.json`; custom named configs live at `~/.ztc/profiles/<name>/config.json`. Session history stays shared. Switching does not rewrite settings after the one-time migration described below.
 
+The source `scripts/ztc-dev` launcher defaults to the `dev` config profile. It uses
+the same `~/.ztc/profiles/dev/` settings and Router sign-in as `ztc --profile dev`.
+Set its Router URL and sign in separately when creating that profile; the name
+does not select a development endpoint by itself. An explicit `--profile default`
+or `ZTC_PROFILE=default` overrides the launcher default. `ZTC_CONFIG_DIR` still
+selects the shared config root. `ztc-dev resume` also selects `dev` unless overridden.
+
 On first use of this release, each existing config profile adopts the new default settings once. Its account registrations, authentication, API keys, and credential-bearing integration settings are retained. Later edits to that profile are kept. New profiles start with the same defaults. The migration writes only the active profile's config file, so switching to an unused profile applies its migration then.
 
 #### Bottom status line

package/THIRD_PARTY_NOTICES.md

@@ -14,6 +14,10 @@ or—when neither ships a license file—the crate's Cargo attribution plus the
 official SPDX license text. A choice such as `MIT OR Apache-2.0` means a recipient
 may use the component under either listed license.
 
+The internal `@zerg/model-contracts` package is first-party Zerg code, version
+0.1.0, under the Zerg Source Available License 1.0. Its distribution includes
+`LICENSE.md`; it adds no third-party dependencies.
+
 ## Direct npm dependencies
 
 | Package | Locked version | License | Upstream |

package/dist/App.js

@@ -237,8 +237,8 @@ export const App = () => {
     // the provider-reported window (Codex) as the denominator. Only before the
     // first API response (no real count yet) do we fall back to the char/4 estimate.
     const contextStatus = useMemo(() => (agentState.contextTokens && agentState.contextTokens > 0)
-        ? contextStatusFromUsed(agentState.contextTokens, currentModel, agentState.contextWindow)
-        : getContextStatus(messages, currentModel), [agentState.contextTokens, agentState.contextWindow, messages, currentModel]);
+        ? contextStatusFromUsed(agentState.contextTokens, currentModel, agentState.contextWindow ?? configStore.getModelContextWindow(currentModel))
+        : getContextStatus(messages, currentModel, configStore.getModelContextWindow(currentModel)), [agentState.contextTokens, agentState.contextWindow, messages, currentModel]);
     const spinnerVerbs = configStore.get().spinnerVerbs || DEFAULT_SPINNER_VERBS;
     const spinnerVerbsKey = spinnerVerbs.join('|');
     const queuePreview = useMemo(() => getQueuePreview(queue), [queue]);

package/dist/agent/agent.js

@@ -242,6 +242,10 @@ export class Agent {
             this.alwaysLoadedToolNames.add(name);
         }
         this.backend = this.config.backend;
+        if (this.backend.getModelCapabilities?.(this.config.model)?.tools === false) {
+            this.config.tools = [];
+            this.config.autoContinue = false;
+        }
         this.policy = this.config.policy;
         this.tracer = this.config.tracer;
         this._cwd = this.config.cwd;
@@ -257,7 +261,7 @@ export class Agent {
         this._hasCustomSystemPrompt = typeof config.systemPrompt === 'string' && config.systemPrompt.trim().length > 0;
     }
     setAutoContinue(enabled) {
-        this._autoContinue = enabled;
+        this._autoContinue = enabled && this.backend.getModelCapabilities?.(this.config.model)?.tools !== false;
     }
     /** Override the agent's system prompt (e.g., for simulation persona injection). */
     setSystemPrompt(prompt) {
@@ -409,7 +413,7 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
         this._currentRequestToolIds = currentTurnToolIds;
         if (allToolIds.length > 0) {
             const activeModel = this.config.model || 'default';
-            const budget = this.toolResponseStore.effectiveBudget(activeModel);
+            const budget = this.toolResponseStore.effectiveBudget(activeModel, this.backend.getModelCapabilities?.(activeModel) ? this.backend.getModelCapabilities(activeModel)?.context_window ?? null : undefined);
             this._selectorVerdict = this.toolResponseStore.selectInlineSet(allToolIds, currentTurnToolIds, budget);
         }
         else {
@@ -1192,6 +1196,27 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
                         // Skip the buffered pacing when the text was already streamed live.
                         if (!this._lastResponseStreamed)
                             await this.emitStreamText(iterationText, signal);
+                        // Deliver busy input before automatic continuation or ending this turn.
+                        // At the iteration cap leave the queue intact for the renderer's next turn.
+                        if (iterations < this.config.maxIterations) {
+                            const steering = takeSteering?.() ?? [];
+                            if (steering.length > 0) {
+                                if (iterationText.trim()) {
+                                    const answer = {
+                                        id: `assistant_${Date.now()}_${iterations}`, role: 'assistant', content: iterationText, timestamp: new Date(),
+                                        ...(response.reasoning ? { metadata: { reasoningContent: response.reasoning } } : {}),
+                                    };
+                                    messages.push(answer);
+                                    turnMessages.push(answer);
+                                }
+                                messages.push(...steering);
+                                turnMessages.push(...steering);
+                                this.emit({ type: 'history_checkpoint', messages: [...turnMessages] });
+                                finalContent = '';
+                                finalReasoning = undefined;
+                                continue;
+                            }
+                        }
                         // Check if we should auto-continue. Bounded: every continuation is a
                         // full-context request, so a model that keeps narrating an intention
                         // instead of calling a tool must not be able to spend maxIterations
@@ -1811,7 +1836,8 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
         let errorMessage = '';
         let admissionMessage = '';
         try {
-            const jsonMatch = message.match(/:\s*(\{[\s\S]*\})\s*$/);
+            const bodyMessage = message.replace(/ \[(?:(?:fly-request-id|x-request-id|cf-ray|x-zerg-error-code)=[^\]\r\n ]+ ?)+\]$/, '');
+            const jsonMatch = bodyMessage.match(/:\s*(\{[\s\S]*\})\s*$/);
             if (jsonMatch) {
                 const parsed = JSON.parse(jsonMatch[1]);
                 const errorPayload = parsed.error;
@@ -1848,6 +1874,11 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
         catch {
             // Not valid JSON, use raw message
         }
+        if (statusCode === 410 && message.startsWith('ZRouter API error (')
+            && ['stream_producer_lost', 'stream_producer_failed', 'stream_resume_expired'].includes(errorCode)) {
+            return { retryable: false, reason: 'The Router stream was interrupted and cannot be resumed. '
+                    + 'Send a message to continue from the existing conversation.' };
+        }
         // Detected before the generic 400 bucket so the host can dump the request.
         if (errorCode === 'context_length_exceeded' || isContextOverflowMessage(`${errorMessage} ${message}`)) {
             return { retryable: false, reason: 'Context window exceeded', kind: 'context_overflow' };
@@ -1860,7 +1891,12 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
             return { retryable: true, reason: 'Rate limit exceeded' };
         }
         if (statusCode === 503 || statusCode === 502 || statusCode === 500 || errorType === 'UNAVAILABLE' || errorType === 'INTERNAL') {
-            return { retryable: true, reason: 'Server temporarily unavailable' };
+            // Only Router admission guidance is public. Provider diagnostics stay
+            // private; a bounded response-header ID supplies support correlation.
+            const requestId = /(?:fly-request-id|x-request-id)=([A-Za-z0-9._:-]{1,128})(?:[ \]]|$)/.exec(message)?.[1];
+            const detail = [admissionMessage.trim().replace(/\s+/g, ' '), requestId && `request_id: ${requestId}`].filter(Boolean).join('; ');
+            const cause = detail ? `: ${detail.length > 160 ? `${detail.slice(0, 159)}…` : detail}` : '';
+            return { retryable: true, reason: `Upstream server error (${statusCode || 'no status'})${cause}` };
         }
         // Non-retryable errors with clean messages
         if (statusCode === 401 || errorType === 'authentication_error' || errorType === 'UNAUTHENTICATED') {
@@ -1876,7 +1912,7 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
         // unsubscribed user hits on the default route, so say what to do. Only the
         // Router's H3 envelope may supply its public wording; any other 402 body
         // stays private behind the canonical message.
-        if (statusCode === 402) {
+        if (statusCode === 402 || errorCode === 'billing_required') {
             const guidance = 'Subscribe in Zerg Router (Dashboard → Billing), or choose another model with /model.';
             return {
                 retryable: false,

package/dist/agent/backends/anthropic.js

@@ -1,5 +1,5 @@
+import { modelContract } from '@zerg/model-contracts';
 import { parseSSEStream } from './sse.js';
-import { getSupportedClaudeReasoningEfforts } from '../../utils/models.js';
 // The TRUE context size for a request = uncached input + cache-read + cache-write.
 // Reading only input_tokens makes the context bar jump BACKWARDS on a cache hit
 // (input_tokens is then just the small uncached delta), which looks non-monotonic.
@@ -99,16 +99,11 @@ export class AnthropicBackend {
                 tools[tools.length - 1] = { ...tools[tools.length - 1], cache_control: cc };
             }
         }
-        // Reasoning effort (GA on Opus 4.5+/Sonnet 4.6): output_config.effort. The
-        // value rides on request.codexEffort (the generic per-pane effort). 'minimal'
-        // is codex-only; the Anthropic API accepts low|medium|high|xhigh|max. Gate on
-        // the target model too: Haiku exposes NO effort parameter, so sending one
-        // hard-400s every turn — getSupportedClaudeReasoningEfforts returns [] for it
-        // (drop) and undefined for unrecognized ids (stay permissive).
+        // Exact reviewed families, including dated aliases, own the effort ladder.
+        // Unknown families and Haiku expose no unverified effort parameter.
         const effort = request.codexEffort;
-        const supportedEfforts = getSupportedClaudeReasoningEfforts(request.model);
-        const modelAllowsEffort = supportedEfforts === undefined ||
-            (effort !== undefined && supportedEfforts.includes(effort));
+        const supportedEfforts = modelContract('anthropic', request.model)?.reasoningEfforts ?? [];
+        const modelAllowsEffort = effort !== undefined && supportedEfforts.includes(effort);
         const outputConfig = effort && ['low', 'medium', 'high', 'xhigh', 'max'].includes(effort) && modelAllowsEffort
             ? { output_config: { effort } }
             : {};

package/dist/agent/backends/gemini.js

@@ -1,3 +1,4 @@
+import { reasoningRequestParams } from '@zerg/model-contracts';
 import { BaseBackend } from './base.js';
 export class GeminiBackend extends BaseBackend {
     apiKey;
@@ -33,6 +34,7 @@ export class GeminiBackend extends BaseBackend {
             });
         };
         const body = {
+            ...reasoningRequestParams('gemini', request.model, request.codexEffort),
             systemInstruction: { parts: [{ text: request.system }] },
             contents: request.messages.map(m => ({
                 role: m.role === 'assistant' ? 'model' : 'user',

package/dist/agent/backends/index.d.ts

@@ -59,6 +59,7 @@ export declare class TracedBackend implements AgentBackend {
     private readonly provider;
     private readonly backend;
     constructor(provider: string, backend: AgentBackend);
+    getModelCapabilities(model: string): import("../../utils/router_catalog.js").RouterModelCapabilities | undefined;
     steerUserMessage(message: Message): Promise<boolean>;
     /** Forward disposal so a process-backed inner (RotatingBackend, codex child)
      * is closed when the agent is. Without this, tracing (ZTC_BACKEND_TRACE=1)

package/dist/agent/backends/index.js

@@ -38,6 +38,7 @@ export class TracedBackend {
         this.provider = provider;
         this.backend = backend;
     }
+    getModelCapabilities(model) { return this.backend.getModelCapabilities?.(model); }
     async steerUserMessage(message) {
         return this.backend.steerUserMessage?.(message) ?? false;
     }
@@ -148,10 +149,17 @@ export function createBackendForProvider(provider, opts) {
             return traced(provider, new KimiBackend({ apiKey: opts.apiKey }));
         case 'deepseek':
             return traced(provider, new OpenAICompatibleBackend({
+                provider: 'deepseek',
                 apiKey: opts.apiKey,
                 baseUrl: opts.baseUrl || 'https://api.deepseek.com/v1',
                 requestBodyExtras: deepseekRequestParams,
             }));
+        case 'fireworks':
+            return traced(provider, new OpenAICompatibleBackend({
+                apiKey: opts.apiKey,
+                baseUrl: opts.baseUrl || 'https://api.fireworks.ai/inference/v1',
+                provider: 'fireworks',
+            }));
         case 'clarifai':
             return traced(provider, new ClarifaiBackend({ apiKey: opts.apiKey, headers: opts.extraHeaders }));
         case CODEX_APP_SERVER_PROVIDER:
@@ -206,7 +214,8 @@ export function createBackendForProvider(provider, opts) {
         }
         case 'anthropic':
         case 'claude':
-        default:
             return traced(provider, new AnthropicBackend({ apiKey: opts.apiKey, apiEndpoint: opts.apiEndpoint }));
+        default:
+            throw new Error(`Unknown provider: ${provider}. Select a Router integration or a supported direct provider.`);
     }
 }

package/dist/agent/backends/openai.d.ts

@@ -1,9 +1,3 @@
-/**
- * OpenAI backend — smart router between Chat Completions and Responses API.
- *
- * Codex models and GPT-6 Sol/Luna use Responses so reasoning and tool calls
- * can be combined. Everything else goes through Chat Completions.
- */
 import { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 interface OpenAIConfig {
     apiKey: string;

package/dist/agent/backends/openai.js

@@ -1,7 +1,8 @@
+import { modelContract } from '@zerg/model-contracts';
 /**
  * OpenAI backend — smart router between Chat Completions and Responses API.
  *
- * Codex models and GPT-6 Sol/Luna use Responses so reasoning and tool calls
+ * Codex models and reviewed Responses tool models use Responses so reasoning and tool calls
  * can be combined. Everything else goes through Chat Completions.
  */
 import { OpenAICompatibleBackend } from './openai_compatible.js';
@@ -12,7 +13,8 @@ const RESPONSES_API_PATTERNS = [
     /^gpt-6-(?:sol|luna)$/i,
 ];
 function needsResponsesAPI(model) {
-    return RESPONSES_API_PATTERNS.some(p => p.test(model));
+    return modelContract('openai', model)?.chatToolReasoningEfforts !== undefined
+        || RESPONSES_API_PATTERNS.some(p => p.test(model));
 }
 export class OpenAIBackend {
     chatBackend;
@@ -23,6 +25,7 @@ export class OpenAIBackend {
             apiKey: config.apiKey,
             baseUrl,
             apiPath: '/chat/completions',
+            provider: 'openai',
         });
         this.responsesBackend = new OpenAIResponsesBackend({
             apiKey: config.apiKey,

package/dist/agent/backends/openai_compatible.d.ts

@@ -18,6 +18,7 @@ interface OpenAICompatibleConfig {
      * Cannot override `model`/`messages`/`tools`/the token limit — those are set
      * after this spread.
      */
+    provider?: string;
     requestBodyExtras?: (request: BackendRequest) => Record<string, unknown>;
 }
 export declare class OpenAICompatibleApiError extends Error {
@@ -31,6 +32,7 @@ export declare class OpenAICompatibleBackend implements AgentBackend {
     private apiPath;
     private headers;
     private extraBody;
+    private provider?;
     private requestBodyExtras?;
     private authTokenProvider?;
     constructor(config: OpenAICompatibleConfig);

package/dist/agent/backends/openai_compatible.js

@@ -1,3 +1,4 @@
+import { fireworksRequestModel, modelContract, reasoningRequestParams } from '@zerg/model-contracts';
 import { measureResponse, measureStream } from './request_metrics.js';
 import { parseSSEStream } from './sse.js';
 import { parseTokenUsage } from './token_usage.js';
@@ -21,6 +22,7 @@ export class OpenAICompatibleBackend {
     apiPath;
     headers;
     extraBody;
+    provider;
     requestBodyExtras;
     authTokenProvider;
     constructor(config) {
@@ -29,6 +31,7 @@ export class OpenAICompatibleBackend {
         this.apiPath = config.apiPath || '/chat/completions';
         this.headers = config.headers || {};
         this.extraBody = config.extraBody || {};
+        this.provider = config.provider;
         this.requestBodyExtras = config.requestBodyExtras;
         this.authTokenProvider = config.authTokenProvider;
     }
@@ -39,29 +42,36 @@ export class OpenAICompatibleBackend {
         // O-series (o1, o3, o4-mini) and GPT-5/6 use max_completion_tokens instead of
         // max_tokens; Moonshot marks max_tokens "Deprecated, please refer to
         // max_completion_tokens" for the Kimi models too.
-        const useCompletionTokens = /^o\d/.test(request.model)
+        const useCompletionTokens = this.provider === 'fireworks' ? false : /^o\d/.test(request.model)
             || /^gpt-[56]/.test(request.model)
             || isKimiModel(request.model);
         // Cap max_tokens for models with lower limits (gpt-4o: 16384)
         const isGpt4o = request.model.startsWith('gpt-4o');
-        const limit = isGpt4o ? 16384 : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity;
+        const reviewedLimit = this.provider ? modelContract(this.provider, request.model)?.maxOutputTokens?.max : undefined;
+        const limit = reviewedLimit ?? (isGpt4o ? 16384 : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity);
         const effectiveMaxTokens = request.maxTokens === undefined ? undefined : Math.min(request.maxTokens, limit);
         const tokenParam = effectiveMaxTokens === undefined ? {} : useCompletionTokens
             ? { max_completion_tokens: effectiveMaxTokens }
             : { max_tokens: effectiveMaxTokens };
-        const isGpt6Model = /^gpt-6-(?:sol|luna)$/i.test(request.model);
-        const reasoningEffort = (request.model === 'gpt-5.6-sol' || isGpt6Model) && request.tools.length > 0
-            ? 'none'
-            : isGpt6Model ? request.codexEffort : undefined;
+        // Chat tool support differs from Responses. Never silently downgrade an
+        // explicit grade; default Chat requests use the reviewed tool-safe value.
+        const policyProvider = this.provider ?? 'openai';
+        const chatEfforts = modelContract(policyProvider, request.model)?.chatToolReasoningEfforts;
+        const toolRestricted = request.tools.length > 0 && chatEfforts !== undefined;
+        if (toolRestricted && request.codexEffort !== undefined && !chatEfforts.includes(request.codexEffort)) {
+            throw new Error('Use Responses for graded reasoning with tools on this model. Chat Completions supports effort none.');
+        }
+        const reasoningEffort = toolRestricted ? request.codexEffort ?? 'none' : request.codexEffort;
         const body = {
             ...this.extraBody,
+            ...reasoningRequestParams(policyProvider, request.model, reasoningEffort),
             ...(this.requestBodyExtras?.(request) ?? {}),
-            model: request.model,
+            model: this.provider === 'fireworks' ? fireworksRequestModel(request.model) : request.model,
             ...tokenParam,
             // Chat Completions accepts GPT-6 Sol/Luna function tools only with
             // reasoning disabled. The direct OpenAI backend uses Responses instead;
             // keep this rule for explicitly configured compatible endpoints.
-            ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+            ...(toolRestricted ? { reasoning_effort: reasoningEffort } : {}),
             messages: buildOpenAIMessages(request),
             ...(request.tools.length > 0 ? { tools: buildOpenAIToolDefs(request.tools) } : {})
         };

package/dist/agent/backends/provider_ids.d.ts

@@ -7,3 +7,4 @@ export declare function normalizeProviderId(provider: string): string;
 export declare function isCodexAppServerProvider(provider: string): boolean;
 export declare function isCodexLegacyProvider(provider: string): boolean;
 export declare function getProviderDisplayName(provider: string): string;
+export declare function isLocalSubscriptionProvider(provider: string): boolean;

package/dist/agent/backends/provider_ids.js

@@ -37,3 +37,7 @@ export function getProviderDisplayName(provider) {
             return provider;
     }
 }
+export function isLocalSubscriptionProvider(provider) {
+    return ['codex_app_server', 'codex_legacy', 'claude_code', 'claude-code', 'claude_code_direct', 'claude-code-direct', 'kimi_code', 'kimi-code']
+        .includes(normalizeProviderId(provider));
+}

package/dist/agent/backends/types.d.ts

@@ -259,6 +259,7 @@ export type StreamEvent = {
     stopReason: string;
 };
 export interface AgentBackend {
+    getModelCapabilities?(model: string): import('../../utils/router_catalog.js').RouterModelCapabilities | undefined;
     /** Deliver user input into a provider-owned active turn when supported. */
     steerUserMessage?(message: Message): Promise<boolean>;
     /**

package/dist/agent/backends/zrouter_stream.d.ts

@@ -1,5 +1,7 @@
+import type { RouterCatalog, RouterModelCapabilities } from '../../utils/router_catalog.js';
 import { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 export interface ZRouterStreamConfig {
+    catalog?: RouterCatalog;
     apiKey: string;
     proxyUrl: string;
     provider: string;
@@ -26,6 +28,7 @@ export interface ZRouterStreamConfig {
  * uses the unified chat endpoint so routing can fall back across providers.
  */
 export declare class ZRouterStreamBackend implements AgentBackend {
+    private readonly catalog?;
     private apiKey;
     private proxyUrl;
     private provider;
@@ -38,8 +41,9 @@ export declare class ZRouterStreamBackend implements AgentBackend {
     isAuthenticationConfigured(): boolean;
     allowsBufferedFallbackAfterStreamFailure(): boolean;
     handlesTransportRetries(): boolean;
+    getModelCapabilities(model: string): RouterModelCapabilities | undefined;
     private buildOpenAIBody;
-    private buildBody;
+    private serializeBody;
     private buildHeaders;
     /**
      * The conversation identity this turn declares to Router, which forwards it to