maka-agent 0.2.0-dev.42.20260918 → 0.2.0-dev.44.20260920

package/dist/acp/session-registry.js

@@ -28,6 +28,7 @@ import { RuntimeHostSessionUpdateError, getRuntimeHostSession, requireRuntimeHos
 import { AcpSessionConfigInputError, createAcpSessionConfigPatch, projectAcpSessionConfigOptions, validateAcpSessionConfigOptionRequest, } from './session-configuration.js';
 import { AcpSessionEventMapper } from './session-event-mapper.js';
 import { mapAcpPromptContent, publishAcpPromptAttachments } from './prompt-content.js';
+import { AcpSessionInteractions } from './session-interactions.js';
 const ACP_SESSION_CURSOR_MAX_BYTES = 8 * 1024;
 const ADMISSION_QUERY_MAX_ATTEMPTS = 5;
 const ADMISSION_QUERY_TIMEOUT_MS = 1_000;
@@ -39,6 +40,7 @@ export class AcpSessionRegistry {
     #newTurnId;
     #inFlightOperations = new Set();
     #ownedSessionIds = new Set();
+    #attachmentInteractions = new Map();
     #attachments = new Map();
     #attachmentOpenControllers = new Map();
     #attachmentConfigurations = new Map();
@@ -181,7 +183,7 @@ export class AcpSessionRegistry {
             const connection = await this.#getConnection('subscription.open');
             let attachment;
             try {
-                attachment = await this.#ensureAttachment(params.sessionId, connection, context.notify);
+                attachment = await this.#ensureAttachment(params.sessionId, connection, context);
             }
             catch (error) {
                 if (active.cancelled)
@@ -274,6 +276,11 @@ export class AcpSessionRegistry {
             active.projectionAbort.abort();
             active.reconciliationAbort.abort();
             active.transcript?.dispose();
+            this.#attachmentInteractions.get(active.sessionId)?.settleTurn(active.turnId);
+            const observed = active.attachment?.snapshot.rootTurn;
+            if (observed?.turnId === active.turnId && isRuntimeHostTerminalTurn(observed)) {
+                this.#attachmentInteractions.get(active.sessionId)?.terminalTurn(active.turnId);
+            }
             active.finished = true;
             this.#wake(active);
             this.#removeActivePrompt(active);
@@ -366,6 +373,7 @@ export class AcpSessionRegistry {
         }
         active.projectionAbort.abort();
         active.reconciliationAbort.abort();
+        this.#attachmentInteractions.get(active.sessionId)?.cancelTurn(active.turnId);
         active.stopTask ??= this.#stopPromptWhenObservable(active);
         await Promise.all([
             active.mapper.flush().catch(() => undefined),
@@ -468,14 +476,14 @@ export class AcpSessionRegistry {
         }, 'Runtime Host Turn admission could not be established; Stop could not be confirmed');
         this.#wake(active);
     }
-    async #ensureAttachment(sessionId, connection, notify) {
+    async #ensureAttachment(sessionId, connection, context) {
         const existing = this.#attachments.get(sessionId);
         if (existing)
             return existing;
         const openingController = new AbortController();
         this.#attachmentOpenControllers.set(sessionId, openingController);
         const configuration = {
-            notify,
+            notify: context.notify,
             // Setters can outlive an absent or failed attachment. Their responses
             // must precede refreshes delivered by the new attachment's queue.
             tail: Promise.allSettled([...(this.#pendingConfigSets.get(sessionId) ?? [])]),
@@ -491,6 +499,50 @@ export class AcpSessionRegistry {
             }
             this.#retireFailedAttachment(sessionId, task, attachment, error);
         };
+        const interactions = new AcpSessionInteractions({
+            sessionId,
+            connection,
+            client: context.interactions ?? {
+                capabilities: {},
+                requestPermission: async () => {
+                    throw RequestError.methodNotFound('session/request_permission');
+                },
+                createElicitation: async () => {
+                    throw RequestError.methodNotFound('elicitation/create');
+                },
+            },
+            onPending: async (pending) => {
+                for (const active of this.#activePrompts.get(sessionId) ?? []) {
+                    if (active.turnId === pending.turnId && !active.cancelled) {
+                        await active.mapper.pendingInteraction(pending);
+                    }
+                }
+            },
+            onAnswered: (answered, pending) => attachment?.publishInteractionAnswer(answered, pending),
+            onResolved: async (resolved, pending) => {
+                for (const active of this.#activePrompts.get(sessionId) ?? []) {
+                    if (active.turnId === pending.turnId && !active.cancelled && !active.finished) {
+                        await active.mapper.resolvedInteraction(resolved, pending);
+                    }
+                }
+            },
+            onFailure: (pending, error) => {
+                const active = [...(this.#activePrompts.get(sessionId) ?? [])].find((prompt) => prompt.turnId === pending.turnId && !prompt.finished);
+                if (active?.attachment) {
+                    active.projectionFailure ??= error;
+                    active.attachment.failTurn(active.turnId, error);
+                }
+                else if (!attachment)
+                    failAttachment(error);
+            },
+            onCancelled: (pending) => {
+                for (const active of this.#activePrompts.get(sessionId) ?? []) {
+                    if (active.turnId === pending.turnId)
+                        void this.#cancelPrompt(active).catch(() => undefined);
+                }
+            },
+        });
+        this.#attachmentInteractions.set(sessionId, interactions);
         task = RuntimeHostSessionChannel.open({
             connection,
             signal: openingController.signal,
@@ -501,6 +553,9 @@ export class AcpSessionRegistry {
             onRuntimeResourceChanged: () => undefined,
             onSnapshotChanged: (snapshot) => {
                 this.#wakeSession(sessionId);
+                if (snapshot.rootTurn && isRuntimeHostTerminalTurn(snapshot.rootTurn)) {
+                    interactions.terminalTurn(snapshot.rootTurn.turnId);
+                }
                 if (configuration.metadataRevision === undefined) {
                     configuration.metadataRevision = snapshot.session.metadataRevision;
                     return;
@@ -534,15 +589,20 @@ export class AcpSessionRegistry {
                 }
             },
             onInteractionPending: (pending) => {
-                if (![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted)) {
-                    // An idle attachment may observe another client's Turn. Retain its
-                    // identity so a later ACP cancel/close can still stop that root.
+                if (!interactions.fencesTurn(pending.turnId) &&
+                    ![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted)) {
+                    // Idle attachments may observe a Turn started by another client. Do not
+                    // present its interaction through this ACP connection's client.
                     return;
                 }
-                // Interaction mapping is added by the next independently reviewable ACP increment.
-                failAttachment(RequestError.internalError({ source: 'adapter', code: 'unsupported_interaction', kind: pending.request.kind }, 'This ACP adapter does not support interactions yet; the prompt failed'));
+                void interactions.pending(pending);
+            },
+            onInteractionResolved: (pending) => {
+                if (!interactions.fencesTurn(pending.turnId) &&
+                    ![...(this.#activePrompts.get(sessionId) ?? [])].some((active) => active.turnId === pending.turnId && active.dispatchStarted))
+                    return;
+                void interactions.resolved(pending);
             },
-            onInteractionResolved: () => undefined,
             onTranscriptSettlement: (turnId) => {
                 for (const active of this.#activePrompts.get(sessionId) ?? []) {
                     if (active.turnId === turnId)
@@ -583,6 +643,10 @@ export class AcpSessionRegistry {
             return channel;
         })
             .catch((error) => {
+            interactions.close();
+            if (this.#attachmentInteractions.get(sessionId) === interactions) {
+                this.#attachmentInteractions.delete(sessionId);
+            }
             if (this.#attachments.get(sessionId) === task) {
                 this.#attachments.delete(sessionId);
                 this.#attachmentConfigurations.delete(sessionId);
@@ -603,6 +667,8 @@ export class AcpSessionRegistry {
         if (this.#attachments.get(sessionId) === task) {
             this.#attachments.delete(sessionId);
             this.#attachmentConfigurations.delete(sessionId);
+            this.#attachmentInteractions.get(sessionId)?.close();
+            this.#attachmentInteractions.delete(sessionId);
         }
         for (const active of this.#activePrompts.get(sessionId) ?? []) {
             if (active.attachment !== attachment)
@@ -616,6 +682,8 @@ export class AcpSessionRegistry {
     }
     async #closeSession(sessionId, delivery) {
         const cancellation = await this.#cancelSession(sessionId);
+        this.#attachmentInteractions.get(sessionId)?.close();
+        this.#attachmentInteractions.delete(sessionId);
         const attachmentTask = this.#attachments.get(sessionId);
         this.#attachments.delete(sessionId);
         let closeError;
@@ -814,6 +882,9 @@ export class AcpSessionRegistry {
             ...(this.#activePrompts.get(sessionId) ?? []),
         ]);
         const cancellations = [...sessionIds].map((sessionId) => this.#cancelSession(sessionId));
+        for (const interactions of this.#attachmentInteractions.values())
+            interactions.close();
+        this.#attachmentInteractions.clear();
         const attachments = [...this.#attachments.values()];
         this.#attachments.clear();
         const configurations = [...this.#attachmentConfigurations.values()];

package/dist/acp/tool-event-mapper.js

@@ -96,6 +96,59 @@ export class AcpToolEventMapper {
             await this.#result(this.#ensure(message.turnId, message.toolUseId), message.isError, message.content, message.durationMs, false);
         }
     }
+    async pendingInteraction(pending) {
+        const tool = this.#ensure(pending.turnId, interactionToolId(pending));
+        if (pending.request.kind === 'sandbox_boundary')
+            tool.synthetic = true;
+        if (tool.terminal)
+            return;
+        tool.status = 'pending';
+        tool.meta.interaction = {
+            id: pending.interactionId,
+            kind: pending.request.kind,
+            status: 'pending',
+        };
+        if (!tool.name)
+            tool.title = `Awaiting ${pending.request.kind.replaceAll('_', ' ')}`;
+        await this.#publish(tool);
+    }
+    async resolvedInteraction(resolved, pending) {
+        if (resolved.status === 'pending')
+            return;
+        const tool = this.#ensure(pending.turnId, interactionToolId(pending));
+        if (pending.request.kind === 'sandbox_boundary')
+            tool.synthetic = true;
+        const outcome = resolved.outcome;
+        tool.meta.interaction = {
+            id: pending.interactionId,
+            kind: pending.request.kind,
+            status: resolved.status,
+            ...(outcome.kind === 'closure' ? { reason: outcome.reason } : {}),
+            ...('decision' in outcome ? { decision: outcome.decision } : {}),
+            ...('action' in outcome ? { action: outcome.action } : {}),
+        };
+        if (!tool.terminal) {
+            if (pending.request.kind === 'sandbox_boundary') {
+                tool.terminal = true;
+                tool.status =
+                    outcome.kind === 'sandbox_boundary_decision' && outcome.decision === 'allow'
+                        ? 'completed'
+                        : 'failed';
+            }
+            else
+                tool.status = 'in_progress';
+        }
+        const closure = outcome.kind === 'closure' ? `Interaction closed: ${outcome.reason}` : undefined;
+        if (closure && !tool.terminal) {
+            tool.progress ??= progressBuffer();
+            tool.progress.append(closure);
+        }
+        await this.#publish(tool, closure && pending.request.kind === 'sandbox_boundary'
+            ? { content: textContent(closure) }
+            : {});
+        if (tool.terminal)
+            this.#release(tool);
+    }
     /** Called only after authoritative turn settlement and transcript reconciliation. */
     async finishTools(turnId, terminalStatus) {
         let missingResult = false;
@@ -112,8 +165,8 @@ export class AcpToolEventMapper {
             }
             // A live result announcement promises a durable result. A start, delta or
             // progress event alone does not: completed turns can contain unfinished
-            // tool calls, and those should remain visible as interrupted cards.
-            if (terminalStatus === 'completed' && tool.resultAnnounced)
+            // tool calls, and synthetic interaction cards have no tool result.
+            if (terminalStatus === 'completed' && !tool.synthetic && tool.resultAnnounced)
                 missingResult = true;
             this.#release(tool);
         }
@@ -308,6 +361,11 @@ function fixedStateChars(tool) {
 function digestValue(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
+function interactionToolId(pending) {
+    return pending.request.kind === 'sandbox_boundary'
+        ? pending.interactionId
+        : pending.request.toolUseId;
+}
 function rawInput(toolName, args) {
     // The shared transcript intentionally projects these two tools' arguments.
     if (args === undefined || toolName === 'WriteStdin' || toolName === 'todo_write')

package/dist/mcp-capability-provider.js

@@ -76,6 +76,13 @@ export function createMcpCapabilityProvider(manager) {
             return projectMcpResult(await manager.callTool(binding, frame.arguments, {
                 signal: options.signal,
                 requestInteraction: options.requestInteraction,
+                ...(options.progress
+                    ? {
+                        onProgress: (current, total) => {
+                            options.progress?.(current, total);
+                        },
+                    }
+                    : {}),
             }));
         },
     };

package/dist/pi-tui-runner.js

@@ -18,6 +18,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { Key, ProcessTerminal, SelectList, TuiMainScreen, isKeyRelease, isKeyRepeat, matchesKey, } from '@earendil-works/pi-tui';
+import { normalizeExternalSessionQueryText, } from '@maka/core/external-session';
 import { CurrentTodoStore, TodoOverlay, renderTodoIndicator } from './pi-tui-todo.js';
 import { isThinkingLevel } from '@maka/core/model-thinking';
 import { deriveConnectionSlug } from '@maka/core/llm-connections';
@@ -53,6 +54,7 @@ import { formatMakaResumeCommand } from './cli-invocation.js';
 import { goalAttachedNoticeText, goalPausedNoticeText, goalStatusLabel, goalSummaryLines, isLiveGoalStatus, } from './pi-goal.js';
 import { getTuiPrimaryGuidance } from './tui-primary-guidance.js';
 import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
+const EXTERNAL_SESSION_SEARCH_DEBOUNCE_MS = 120;
 function externalSourceLabel(adapterId) {
     switch (adapterId) {
         case 'claude-code':
@@ -203,6 +205,7 @@ export async function runMakaPiTui(input) {
     let connectionIdentityNotice;
     let busy = false;
     let closed = false;
+    const cancelScheduledExternalSearches = new Set();
     let currentActivityCompletion;
     let permissionResponseInFlightRequestId = null;
     // Session recap (issue #1055): an in-flight lock shared by manual and
@@ -718,6 +721,9 @@ export async function runMakaPiTui(input) {
         attention.reset();
         // Stop asking the terminal for focus reports before handing it back.
         terminal.write(DISABLE_FOCUS_REPORTING);
+        for (const cancel of cancelScheduledExternalSearches)
+            cancel();
+        cancelScheduledExternalSearches.clear();
         tui.stop();
     };
     const beginClose = (error) => {
@@ -2580,17 +2586,41 @@ export async function runMakaPiTui(input) {
         let sessions = [];
         let nextCursor = null;
         let revision = 0;
+        let normalizedQuery = normalizeExternalSessionQueryText(query);
+        let cancelScheduledSearch;
+        let pageClosed = false;
         let overlay;
         let search;
         let byValue = new Map();
-        const closeOverlay = () => overlay?.hide();
+        const dropScheduledSearch = () => {
+            const hadScheduledSearch = cancelScheduledSearch !== undefined;
+            if (cancelScheduledSearch)
+                cancelScheduledExternalSearches.delete(cancelScheduledSearch);
+            cancelScheduledSearch?.();
+            cancelScheduledSearch = undefined;
+            return hadScheduledSearch;
+        };
+        const resetCatalogPage = () => {
+            sessions = [];
+            nextCursor = null;
+            byValue = new Map();
+            render();
+        };
+        const closeOverlay = () => {
+            pageClosed = true;
+            dropScheduledSearch();
+            revision += 1;
+            overlay?.hide();
+        };
         const toggleScope = () => {
             const alternate = input.externalSessions
                 ?.listScopes()
                 .find((candidate) => candidate !== scope);
             if (!alternate)
                 return;
+            dropScheduledSearch();
             scope = alternate;
+            resetCatalogPage();
             void load(false);
         };
         const render = () => {
@@ -2647,8 +2677,29 @@ export async function runMakaPiTui(input) {
                 emptyText: sessions.length === 0 ? copy.externalEmpty : copy.externalUnavailable,
                 notice,
                 onQuery: (text) => {
+                    const nextNormalizedQuery = normalizeExternalSessionQueryText(text);
                     query = text;
-                    void load(false);
+                    if (nextNormalizedQuery === normalizedQuery)
+                        return;
+                    normalizedQuery = nextNormalizedQuery;
+                    dropScheduledSearch();
+                    resetCatalogPage();
+                    // Retire an older in-flight response immediately. Waiting until the
+                    // debounce fires would let it repaint results for the previous query.
+                    const requestRevision = ++revision;
+                    let cancel;
+                    const handle = setTimeout(() => {
+                        if (cancel)
+                            cancelScheduledExternalSearches.delete(cancel);
+                        cancelScheduledSearch = undefined;
+                        if (closed || pageClosed)
+                            return;
+                        void load(false, undefined, requestRevision);
+                    }, EXTERNAL_SESSION_SEARCH_DEBOUNCE_MS);
+                    handle.unref();
+                    cancel = () => clearTimeout(handle);
+                    cancelScheduledSearch = cancel;
+                    cancelScheduledExternalSearches.add(cancel);
                 },
                 onSelect: (item) => {
                     if (item.value === 'external:load-more' && nextCursor) {
@@ -2702,8 +2753,8 @@ export async function runMakaPiTui(input) {
             });
             overlay = showBottomPicker(search);
         };
-        const load = async (append, cursor) => {
-            const requestRevision = ++revision;
+        const load = async (append, cursor, scheduledRevision) => {
+            const requestRevision = scheduledRevision ?? ++revision;
             try {
                 const page = await input.externalSessions.listSessions({
                     adapterId,
@@ -2711,14 +2762,14 @@ export async function runMakaPiTui(input) {
                     ...(cursor ? { cursor } : {}),
                     ...(query ? { text: query } : {}),
                 });
-                if (requestRevision !== revision || closed || turnRunning)
+                if (requestRevision !== revision || pageClosed || closed || turnRunning)
                     return;
                 sessions = append ? [...sessions, ...page.sessions] : page.sessions;
                 nextCursor = page.nextCursor;
                 render();
             }
             catch {
-                if (requestRevision !== revision)
+                if (requestRevision !== revision || pageClosed || closed)
                     return;
                 state.entries.push({ kind: 'notice', level: 'error', text: copy.externalCatalogFailed });
                 requestRender();

package/dist/runtime-host-tui-command.js

@@ -50,7 +50,7 @@ export async function runRuntimeHostTui(input) {
             throw error;
         const configured = await runFirstRunOnboarding(input.clientDataRoot, input.workspaceRoot, input.cwd, input.locale, input.hostProfileId);
         if (!configured)
-            throw error;
+            return 0;
         context = await createRuntimeHostTuiContext(contextInput);
     }
     let ownerAction;

package/node_modules/@maka/core/dist/chat-model-choice.js

@@ -37,6 +37,9 @@ export function buildChatModelChoices(connections) {
                 ...(provider.authKind === 'oauth_token' ? {} : { connectionName: connection.name }),
                 isDefault: entry.isDefault,
                 thinkingLevels: entry.thinkingLevels,
+                ...(entry.defaultThinkingLevel === undefined
+                    ? {}
+                    : { defaultThinkingLevel: entry.defaultThinkingLevel }),
                 supportsVision: entry.supportsVision,
                 ...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
                 ...(declaredWindow !== undefined ? { declaredContextWindow: declaredWindow } : {}),

package/node_modules/@maka/core/dist/connection-usage.js

@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * The providers Maka can read account usage from. The single source of truth
+ * for both the settings section's visibility and the runtime dispatch, so a
+ * provider that gains a mapper is offered the card in the same change.
+ */
+const USAGE_PROVIDERS = new Set(['commandcode-go']);
+export function providerReportsUsage(providerType) {
+    return USAGE_PROVIDERS.has(providerType);
+}

package/node_modules/@maka/core/dist/external-session.js

@@ -72,8 +72,8 @@ export function externalSessionMatchesQuery(summary, query = {}) {
     const text = normalizeExternalSessionQueryText(query.text);
     if (text === undefined)
         return true;
-    // Title and path, because those are the two things a user remembers about a
-    // conversation they are looking for. Both already sit on the summary, so
+    // Source id, title, and path are the bounded summary fields a user can paste
+    // or remember about a conversation. All already sit on the summary, so
     // matching costs no extra reads. Message content is deliberately excluded:
     // it would mean opening every transcript on every keystroke.
     //
@@ -86,7 +86,8 @@ export function externalSessionMatchesQuery(summary, query = {}) {
     // literal backslash-n, and folding the term without the title would stop
     // `\\n` from finding the very title it names. The path pair has no such
     // ambiguity: a separator there is a separator.
-    return (normalizeExternalSessionMatchText(summary.name).includes(text) ||
+    return (normalizeExternalSessionMatchText(summary.id).includes(text) ||
+        normalizeExternalSessionMatchText(summary.name).includes(text) ||
         foldExternalSessionPathSeparators(normalizeExternalSessionMatchText(summary.cwd)).includes(foldExternalSessionPathSeparators(text)));
 }
 /**

package/node_modules/@maka/core/dist/llm-connections.js

@@ -17,9 +17,9 @@
  * under the License.
  */
 import { CODEX_SUBSCRIPTION_UNSUPPORTED_CHATGPT_MODELS } from './codex-model-compatibility.js';
-import { CATALOG_PROVIDER_TYPES, OPENCODE_FREE_DEFAULT_MODEL, PROVIDER_REGISTRY, RECOMMENDED_PROVIDER_TYPES, providerDefaultsOf, providerFallbackModelIds, providerMenuLabel, } from './provider-registry.js';
+import { CATALOG_PROVIDER_TYPES, PROVIDER_REGISTRY, RECOMMENDED_PROVIDER_TYPES, providerDefaultsOf, providerFallbackModelIds, providerMenuLabel, } from './provider-registry.js';
 export { CODEX_SUBSCRIPTION_UNSUPPORTED_CHATGPT_MODELS };
-export { CATALOG_PROVIDER_TYPES, OPENCODE_FREE_DEFAULT_MODEL, PROVIDER_REGISTRY, RECOMMENDED_PROVIDER_TYPES, providerDefaultsOf, providerFallbackModelIds, providerMenuLabel, };
+export { CATALOG_PROVIDER_TYPES, PROVIDER_REGISTRY, RECOMMENDED_PROVIDER_TYPES, providerDefaultsOf, providerFallbackModelIds, providerMenuLabel, };
 export function isRelayProviderType(providerType) {
     return providerType === 'openai-compatible' || providerType === 'openai-responses-compatible';
 }
@@ -69,7 +69,7 @@ export function connectionEnabledModelIds(connection) {
  *   3. the Host's entry says the connection can hold a chat on it.
  *
  * (3) already subsumes what clients used to re-derive locally: a retired
- * provider, a quarantined `brokenModelIds` id, and a model whose metadata says
+ * provider and a model whose metadata says
  * it cannot chat are all non-offerable before a client sees them. A client
  * re-testing any of those against its OWN registry answers for a build that is
  * not the one running the send.
@@ -135,12 +135,6 @@ export function authorizeConnectionModel(connection, modelId) {
     const model = modelId.trim();
     if (!model || !connectionEnabledModelIds(connection).includes(model))
         return undefined;
-    // The one veto: quarantined ids fail in a shape the send cannot surface
-    // (e.g. a billed 200 with an empty completion), so the request settling it
-    // is not available as the arbiter. See ProviderDefaults.brokenModelIds.
-    if (providerDefaultsOf(connection.providerType)?.brokenModelIds?.includes(model)) {
-        return undefined;
-    }
     // The observed row wins wherever it exists: it carries wire metadata such as
     // `apiProtocol`, and capabilities, which a synthesized entry cannot. Absent
     // capabilities already mean "unknown", not "unsupported".
@@ -268,18 +262,6 @@ export function reconcileConnectionAfterModelFetch(connection, models, options)
         }),
     };
 }
-/**
- * The models a connection created without an explicit selection starts with,
- * or undefined when the provider seeds nothing. Derived from the provider's
- * shipped baseline rather than listed a second time: the two can then never
- * disagree about what "all of them" means.
- */
-export function defaultEnabledModelIdsWhenOmitted(providerType) {
-    const defaults = providerDefaultsOf(providerType);
-    if (!defaults?.enableShippedModelsByDefault)
-        return undefined;
-    return providerFallbackModelIds(defaults);
-}
 export function providerAuthRequiresSecret(providerType) {
     const authKind = providerDefaultsOf(providerType)?.authKind;
     return authKind === 'api_key' || authKind === 'oauth_token';

package/node_modules/@maka/core/dist/model-catalog.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { applyModelOverride, resolveModelLimits } from './model-thinking.js';
+import { applyModelOverride, defaultThinkingLevelForConnection, resolveModelLimits, } from './model-thinking.js';
 import { CODEX_SUBSCRIPTION_UNSUPPORTED_CHATGPT_MODELS, PROVIDER_REGISTRY, providerDefaultsOf, providerFallbackModelIds, providerSupportsModelDiscovery, } from './llm-connections.js';
 import { lookupModelMetadata, resolveModelVisionSupport } from './model-metadata.js';
 import { thinkingVariantsForConnection, } from './model-thinking.js';
@@ -95,36 +95,22 @@ export function buildConnectionModelCatalogEntries(input) {
     if (!defaults)
         return [];
     const supportsModelDiscovery = providerSupportsModelDiscovery(connection.providerType);
-    // Quarantined ids never surface as offerable entries — from any source,
-    // including inventories stored or selections made before the quarantine —
-    // mirroring the `authorizeConnectionModel` veto.
-    const broken = new Set(defaults.brokenModelIds ?? []);
     const fallbackModels = providerFallbackModelIds(defaults);
-    // A quarantined id persisted as this connection's `defaultModel` must not
-    // re-enter the catalog either. `models` and `enabledModelIds` are filtered
-    // below, but a broken default reaches `makeMissingDefaultEntry` unfiltered and
-    // would be re-added as a selectable `provider_default` row — picker-visible
-    // and default-capable while `authorizeConnectionModel` vetoes the same id. A
-    // reachable persisted state: the id was picker-visible before the quarantine.
-    // Dropping it leaves the connection with no valid default (readiness reports
-    // `missing_model`), which is what a model that can no longer send warrants.
-    const defaultModel = broken.has((connection.defaultModel ?? '').trim())
-        ? undefined
-        : connection.defaultModel;
+    const defaultModel = connection.defaultModel;
     const fallbackModelIds = new Set(fallbackModels);
-    const projectedModelsById = new Map((connection.models ?? []).filter(({ id }) => !broken.has(id)).map((model) => [model.id, model]));
+    const projectedModelsById = new Map((connection.models ?? []).map((model) => [model.id, model]));
     // Fallback providers have no live inventory, but a projected connection can
     // still carry enabled model-facts entries that are absent from the static
     // list. Keep both sets in the catalog so those user-declared models retain
     // their metadata.
     const models = supportsModelDiscovery
-        ? connection.models?.filter(({ id }) => !broken.has(id))
+        ? connection.models
         : [
             ...fallbackModels.map((id) => projectedModelsById.get(id) ?? {
                 id,
                 ...displayNameForKnownModel(connection.providerType, id),
             }),
-            ...(connection.models ?? []).filter((model) => !broken.has(model.id) && !fallbackModelIds.has(model.id)),
+            ...(connection.models ?? []).filter((model) => !fallbackModelIds.has(model.id)),
         ];
     return buildModelCatalogEntries({
         providerType: connection.providerType,
@@ -143,7 +129,7 @@ export function buildConnectionModelCatalogEntries(input) {
         savedModelIds: [
             ...(connection.enabledModelIds ?? []),
             ...Object.keys(connection.modelOverrides ?? {}),
-        ].filter((id) => !broken.has(id)),
+        ],
     });
 }
 /**
@@ -239,6 +225,7 @@ function makeEntry(ctx, model, overrides = {}) {
             capabilities,
             ...(modalities !== undefined ? { modalities } : {}),
         });
+    const defaultThinkingLevel = defaultThinkingLevelForConnection(thinkingContext, normalizedModel.id);
     return {
         id: normalizedModel.id,
         ...displayNameForModel(input.providerType, normalizedModel),
@@ -253,6 +240,7 @@ function makeEntry(ctx, model, overrides = {}) {
             ? {}
             : { compactionThreshold: input.modelOverrides[normalizedModel.id].compactionThreshold }),
         thinkingLevels: thinkingVariantsForConnection(thinkingContext, normalizedModel.id),
+        ...(defaultThinkingLevel === undefined ? {} : { defaultThinkingLevel }),
         ...limits,
         ...(defaults.contextWindow === undefined
             ? {}