zigmini 0.8.0-beta.6 → 0.9.0-beta.1

package/host/omo-check/patches/omo-5.1.35-compaction-model.patch

@@ -0,0 +1,299 @@
+--- a/@code-yeongyu/senpi/dist/core/agent-session.js
++++ b/@code-yeongyu/senpi/dist/core/agent-session.js
+@@ -758,2 +758,2 @@
+-     * Unset, malformed, or unknown overrides keep a usable session model.
+-     * A spent account instead uses the held target or another authenticated model.
++     * Auto selection stays within the active provider; explicit values never fall back.
++     * Selection uses the availability snapshot. Authentication remains request-time.
+@@ -761,27 +761,50 @@
+-    _resolveCompactionModel(sessionModel) {
+-        const override = this._getCompactionSettings().model;
+-        const slash = override?.indexOf("/") ?? -1;
+-        const configured = override && slash > 0
+-            ? this._modelRuntime.getModel(override.slice(0, slash), override.slice(slash + 1))
+-            : undefined;
+-        const usable = (model) => !this._retryFallback.isProviderSpent(model.provider);
+-        // Preserve the explicit override and original-model geometry on healthy sessions.
+-        // A held downswitch uses its target only when the original account cannot serve.
+-        if (usable(sessionModel))
+-            return configured && usable(configured) ? configured : sessionModel;
+-        const pending = this._pendingModelSwitch?.model;
+-        if (pending && usable(pending))
+-            return pending;
+-        if (configured && usable(configured))
+-            return configured;
+-        const requiredContextWindow = estimateMessagesTokens(filterContextExcludedMessages(this._runtimeMessages())) +
+-            this._getCompactionSettings().reserveTokens;
+-        const available = this._modelRuntime
+-            .getModels()
+-            .find((model) => usable(model) &&
+-            model.contextWindow >= requiredContextWindow &&
+-            this._modelRuntime.hasConfiguredAuth(model.provider));
+-        if (available)
+-            return available;
+-        throw new AccountUsageLimitError(sessionModel.provider, this._retryFallback.accountError(sessionModel.provider));
+-    }
++    _resolveCompactionModel(sessionModel, inputTokens = 0) {
++        const settings = this._getCompactionSettings();
++        const override = settings.model;
++        const explicit = override !== undefined && override !== "auto";
++        const fail = (kind, model = sessionModel) => {
++            throw Object.assign(new Error(
++                explicit ? "Compaction model unavailable; check compaction.model or set it to auto."
++                    : "No usable compaction model within the active provider."),
++                { failure: { kind, provider: model.provider, model: model.id } });
++        };
++        const chat = this._modelRuntime.getModels();
++        const available = this._modelRuntime.getAvailableSnapshot();
++        const same = (left, right) => left.provider === right.provider && left.id === right.id;
++        const usable = (model) => chat.some((entry) => same(entry, model)) && (!available.some((entry) => entry.provider === model.provider) || available.some((entry) => same(entry, model))) &&
++            !this._retryFallback.isProviderSpent(model.provider) &&
++            this._modelRuntime.isFallbackEligible(model.provider);
++        const fits = (model) => {
++            const output = Math.min(32768, model.maxTokens > 0 ? model.maxTokens : 32768, Math.floor(model.contextWindow / 2));
++            return model.contextWindow > 0 && inputTokens + Math.max(settings.reserveTokens, output) <= model.contextWindow;
++        };
++        if (explicit) {
++            if (typeof override !== "string" || !/^[^/\s]+\/\S+$/.test(override))
++                return fail("invalid_model");
++            const slash = override.indexOf("/");
++            const configured = this._modelRuntime.getModel(override.slice(0, slash), override.slice(slash + 1));
++            if (!configured || !chat.some((model) => same(model, configured)))
++                return fail("invalid_model");
++            if (this._retryFallback.isProviderSpent(configured.provider))
++                return fail("quota", configured);
++            if (!usable(configured))
++                return fail("model_unavailable", configured);
++            if (!fits(configured))
++                return fail("context_budget", configured);
++            return configured;
++        }
++        if (this._retryFallback.isProviderSpent(sessionModel.provider))
++            return fail("quota");
++        const family = ["anthropic", "anthropic-subscription"].includes(sessionModel.provider) && /^claude-/.test(sessionModel.id) ? /^claude-sonnet-/
++            : ["openai", "chatgpt-subscription"].includes(sessionModel.provider) && /^gpt-/.test(sessionModel.id) ? /^gpt-.*-luna(?:-fast)?$/ : undefined;
++        const preferred = family ? available.filter((model) =>
++            model.provider === sessionModel.provider && family.test(model.id)) : [];
++        // Stable sort preserves registry order within the regular and fast Luna groups.
++        preferred.sort((left, right) => Number(/-luna-fast$/.test(left.id)) - Number(/-luna-fast$/.test(right.id)));
++        const candidates = [...(family?.test(sessionModel.id) ? [sessionModel] : []), ...preferred, sessionModel];
++        for (const candidate of candidates) {
++            if (candidate.provider === sessionModel.provider && usable(candidate) && fits(candidate))
++                return candidate;
++        }
++        return fail(usable(sessionModel) ? "context_budget" : "model_unavailable");
++    }
+@@ -788,7 +811,6 @@
+-    async _getCompactionRequestAuth(model, signal, callbacks) {
+-        const auth = await this._getSummarizationRequestAuth(model, signal, callbacks);
+-        return {
+-            ...auth,
+-            extraBody: this._modelRuntime.getCompatibilityRequestConfig(model).extraBody,
+-        };
+-    }
++    async _getCompactionRequestAuth(model, signal, callbacks) {
++        const prepared = await retryTransientCall(() => this._modelRuntime.prepareRequest(model, { signal }),
++            isOAuthRefreshUnavailableError, this.settingsManager.getRetrySettings(), signal,
++            callbacks ?? this._summarizationRetryCallbacks({ source: "compaction" }));
++        return { ...prepared.options, model: prepared.model, thinkingLevel: this.thinkingLevel };
++    }
+@@ -6305,1 +6327,0 @@
+-                const compactionModel = this._resolveCompactionModel(model);
+@@ -6336,5 +6357,6 @@
+-                    // A configured compaction.model override redirects only the
+-                    // summarization call to that model; every other part of the session
+-                    // (lifecycle record, preparation, branch) still tracks the session
+-                    // model. Falls back to the session model when the override is unset
+-                    // or cannot be resolved.
++                    // Size the complete source, including control text, before selecting a model.
++                    // The final serialized request is checked again at the dispatch boundary.
++                    const inputTokens = estimateMessagesTokens([...preparation.messagesToSummarize, ...preparation.turnPrefixMessages]) +
++                        Math.ceil(JSON.stringify([this.agent.state.systemPrompt, this.agent.state.tools,
++                            preparation.previousSummary, request.customInstructions]).length / 4) + 8192;
++                    const compactionModel = this._resolveCompactionModel(model, inputTokens);
+@@ -6342,1 +6364,4 @@
+-                    compactionResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, extraBody, request.customInstructions, signal, env, request.reason, thinkingLevel);
++                    compactionResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, extraBody, request.customInstructions, signal, env, request.reason, thinkingLevel);
++                    compactionResult.details = { ...compactionResult.details,
++                        selectionMode: settings.model === undefined || settings.model === "auto" ? "auto" : "explicit",
++                        requestedProvider: compactionModel.provider, requestedModel: compactionModel.id };
+@@ -7704,3 +7729,4 @@
+-            getCompactionModel: () => this.model && this._retryFallback.isProviderSpent(this.model.provider)
+-                ? this._resolveCompactionModel(this.model)
+-                : this.model,
++            getCompactionModel: (inputTokens) => {
++                const model = this._limitsModel();
++                return model && this._resolveCompactionModel(model, inputTokens);
++            },
+--- a/@code-yeongyu/senpi/dist/core/extensions/runner.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/runner.js
+@@ -987,3 +987,3 @@
+-                    ? () => {
+-                        runner.assertActive();
+-                        return runner.getCompactionModelFn?.();
++                    ? (inputTokens) => {
++                        runner.assertActive();
++                        return runner.getCompactionModelFn?.(inputTokens);
+--- a/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
+@@ -446,1 +446,1 @@
+-    getCompactionModel?(): Model<Api> | undefined;
++    getCompactionModel?(inputTokens?: number): Model<Api> | undefined;
+@@ -2415,1 +2415,1 @@
+-    getCompactionModel?: () => Model<Api> | undefined;
++    getCompactionModel?: (inputTokens?: number) => Model<Api> | undefined;
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/lane-policy.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/lane-policy.js
+@@ -94,2 +94,3 @@
+-        if (context.getCompactionSettings?.().model)
+-            return false;
++        const override = context.getCompactionSettings?.().model;
++        if (typeof override === "string" && /^[^/\s]+\/\S+$/.test(override))
++            return false;
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
+@@ -8,1 +8,1 @@
+-import { allowOverflowRetry, boundSummarizationInput, SUMMARIZATION_INPUT_BUDGET_RATIO, SummarizationOverflowExhaustedError, shrinkSummarizationInputForOverflowRetry, } from "./overflow-retry.js";
++import { estimateTotalTokens, SummarizationOverflowExhaustedError } from "./overflow-retry.js";
+@@ -143,26 +143,44 @@
+-    const selectedModel = context.getCompactionModel?.() ?? snapshot.model;
+-    const selectedSnapshot = selectedModel === snapshot.model
+-        ? snapshot
+-        : { ...snapshot, model: selectedModel, contextWindow: selectedModel.contextWindow };
+-    const auth = await context.modelRegistry?.getApiKeyAndHeaders(selectedModel);
+-    if (signal?.aborted)
+-        return undefined;
+-    // A provider is authenticated for summarization by a resolved key, a credential
+-    // request header, or ambient request-time auth. The ambient marker comes from the
+-    // same provider resolution normal turns use; an unconfigured keyed provider still
+-    // has none of these and is rejected before a request.
+-    if (!auth?.ok || !(auth.apiKey || hasCredentialHeaders(auth.headers) || auth.ambient)) {
+-        const detail = auth && !auth.ok ? auth.error : `no credentials resolved for provider "${selectedModel.provider}"`;
+-        throw new SummaryGenerationError("auth", `summarization credentials unavailable: ${detail}`);
+-    }
+-    const requestSnapshot = auth.baseUrl
+-        ? { ...selectedSnapshot, model: { ...selectedModel, baseUrl: auth.baseUrl } }
+-        : selectedSnapshot;
+-    const prompt = buildPrompt({
+-        variant: requestSnapshot.promptVariant,
+-        previousSummary: requestSnapshot.preparation.previousSummary,
+-        taskIntent: resolveInheritedTaskIntent(requestSnapshot.branchEntries ?? []),
+-        customInstructions: requestSnapshot.customInstructions,
+-    });
+-    const promptTokens = approxTokens(prompt.user);
+-    let messages = boundSummarizationInput(pruneToolResults([...requestSnapshot.preparation.messagesToSummarize, ...requestSnapshot.preparation.turnPrefixMessages], requestSnapshot.contextWindow, SUMMARIZATION_INPUT_BUDGET_RATIO), requestSnapshot.contextWindow, promptTokens);
++    const prompt = buildPrompt({
++        variant: snapshot.promptVariant,
++        previousSummary: snapshot.preparation.previousSummary,
++        taskIntent: resolveInheritedTaskIntent(snapshot.branchEntries ?? []),
++        customInstructions: snapshot.customInstructions,
++    });
++    const messages = [...snapshot.preparation.messagesToSummarize, ...snapshot.preparation.turnPrefixMessages];
++    const inputTokens = estimateTotalTokens([
++        ...messages,
++        { role: "user", content: prompt.user },
++        { role: "user", content: snapshot.systemPrompt ?? prompt.system },
++        { role: "user", content: JSON.stringify(snapshot.tools ?? []) },
++    ]);
++    const selectedModel = context.getCompactionModel?.(inputTokens) ?? snapshot.model;
++    const selectedSnapshot = { ...snapshot, model: selectedModel, contextWindow: selectedModel.contextWindow, selectionMode: context.getCompactionSettings?.().model === undefined || context.getCompactionSettings?.().model === "auto" ? "auto" : "explicit" };
++    let auth;
++    try {
++        const runtime = context.modelRegistry?.modelRuntime;
++        if (runtime) {
++            const prepared = await runtime.prepareRequest(selectedModel, { signal });
++            auth = { ok: true, ...prepared.options, baseUrl: prepared.model.baseUrl, ambient: true };
++        }
++        else {
++            auth = await context.modelRegistry?.getApiKeyAndHeaders(selectedModel);
++        }
++    }
++    catch (error) {
++        if (signal?.aborted)
++            return undefined;
++        const kind = error?.failure?.kind ?? error?.kind;
++        const known = ["auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable"];
++        const failure = { kind: kind === "auth" ? "auth_missing" : known.includes(kind) ? kind : "provider",
++            provider: selectedModel.provider, model: selectedModel.id };
++        throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction request authentication failed"), { failure, cause: error });
++    }
++    if (signal?.aborted)
++        return undefined;
++    if (!auth?.ok || !(auth.apiKey || hasCredentialHeaders(auth.headers) || auth.ambient)) {
++        const failure = { kind: "auth_missing", provider: selectedModel.provider, model: selectedModel.id };
++        throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction request authentication unavailable"), { failure });
++    }
++    const requestSnapshot = auth.baseUrl
++        ? { ...selectedSnapshot, model: { ...selectedModel, baseUrl: auth.baseUrl } }
++        : selectedSnapshot;
+@@ -173,2 +191,0 @@
+-    const overflowRetryStartMs = Date.now();
+-    let overflowAttempts = 0;
+@@ -216,1 +232,2 @@
+-                        extraBody: auth.extraBody,
++                        extraBody: auth.extraBody,
++                        env: auth.env,
+@@ -223,1 +240,1 @@
+-                    !isContextOverflow(attempt, snapshot.contextWindow)) {
++                    !isContextOverflow(attempt, requestSnapshot.contextWindow)) {
+@@ -240,12 +257,4 @@
+-        if (isAssistantMessage(response) && isContextOverflow(response, snapshot.contextWindow)) {
+-            overflowAttempts++;
+-            const elapsedMs = Date.now() - overflowRetryStartMs;
+-            const retryMessages = allowOverflowRetry(overflowAttempts, elapsedMs)
+-                ? shrinkSummarizationInputForOverflowRetry(messages, snapshot.contextWindow, promptTokens)
+-                : undefined;
+-            if (!retryMessages) {
+-                throw new SummarizationOverflowExhaustedError(overflowAttempts, elapsedMs);
+-            }
+-            messages = retryMessages;
+-            continue;
+-        }
++        if (isAssistantMessage(response) && isContextOverflow(response, requestSnapshot.contextWindow)) {
++            const failure = { kind: "context_budget", provider: selectedModel.provider, model: selectedModel.id };
++            throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction input exceeds the provider context budget"), { failure });
++        }
+@@ -303,1 +312,6 @@
+-                schema: SUMMARY_SCHEMA,
++                schema: SUMMARY_SCHEMA,
++                selectionMode: selectedSnapshot.selectionMode,
++                requestedProvider: selectedModel.provider,
++                requestedModel: selectedModel.id,
++                ...(isAssistantMessage(response) && response.provider && response.responseModel
++                    ? { observedProvider: response.provider, observedModel: response.responseModel } : {}),
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
+@@ -6,1 +6,2 @@
+-import { repairOrphanedToolResults } from "./repair-tool-pairs.js";
++import { repairOrphanedToolResults } from "./repair-tool-pairs.js";
++import { estimateTotalTokens } from "./overflow-retry.js";
+@@ -109,1 +110,10 @@
+-        const headers = providerRequest
++        const inputTokens = estimateTotalTokens([
++            ...requestContext.messages,
++            { role: "user", content: requestContext.systemPrompt },
++            { role: "user", content: JSON.stringify(requestContext.tools ?? []) },
++        ]);
++        if (inputTokens + summaryMaxTokens(options.snapshot.model, options.snapshot.contextWindow) > options.snapshot.contextWindow) {
++            throw Object.assign(new Error("Compaction request exceeds the selected model context budget"),
++                { failure: { kind: "context_budget", provider: options.snapshot.model.provider, model: options.snapshot.model.id } });
++        }
++        const headers = providerRequest
+@@ -115,1 +125,3 @@
+-            extraBody: options.auth.extraBody,
++            extraBody: options.auth.extraBody,
++            env: options.auth.env,
++            streamKind: "auxiliary",
+--- a/@code-yeongyu/senpi/dist/core/compaction/compaction.js
++++ b/@code-yeongyu/senpi/dist/core/compaction/compaction.js
+@@ -635,1 +635,2 @@
+-        affinitySessionId: options.affinitySessionId ?? options.sessionId,
++        affinitySessionId: options.affinitySessionId ?? options.sessionId,
++        streamKind: "auxiliary",
+@@ -638,1 +639,5 @@
+-    const callerSignal = options.signal;
++    if (model.contextWindow <= 0 || estimateProviderContextTokens(context).tokens + options.maxTokens > model.contextWindow) {
++        throw Object.assign(new Error("Compaction request exceeds the selected model context budget"),
++            { failure: { kind: "context_budget", provider: model.provider, model: model.id } });
++    }
++    const callerSignal = options.signal;