@cjhyy/code-shell-core 0.8.13 → 0.8.20

package/dist/cli/agent-server-stdio.js

@@ -333,9 +333,10 @@ setDefaultCredentialAccess(createIpcCredentialAccess(stdioTransport));
 setCronChangedSink(() => {
     stdioTransport.send(createNotification("agent/cronChanged", {}));
 });
-// EditModelCatalog writes in this worker process, while the mounted settings
-// and connection pages live in the desktop renderer. Notify them immediately
-// after a successful write instead of relying on a later turn_complete event.
+// Catalog and model-connection tools write in this worker process, while the
+// mounted settings/connection pages live in the desktop renderer. Notify them
+// immediately after a successful write instead of relying on a later
+// turn_complete event.
 setModelCatalogChangedSink(() => {
     stdioTransport.send(createNotification(Methods.SettingsChanged, {}));
 });

package/dist/engine/engine.js

@@ -1104,7 +1104,7 @@ export class Engine {
         // the entire old topic. Fail open to full history if summarization fails.
         if (options?.archiveBeforeCurrentTurn && options.clientMessageId) {
             try {
-                const archived = await this.archiveTurnRange(session.state.sessionId, { start: 0, end: 0 }, {
+                const anchors = {
                     toClientMessageId: options.clientMessageId,
                     ...(options.archiveBeforeCurrentTurn.fromClientMessageId
                         ? {
@@ -1114,7 +1114,24 @@ export class Engine {
                     ...(options.archiveBeforeCurrentTurn.segmentId
                         ? { segmentId: options.archiveBeforeCurrentTurn.segmentId }
                         : {}),
-                });
+                };
+                const before = estimateTokens(messages);
+                if (options.archiveBeforeCurrentTurn.summary) {
+                    await this.appendArchiveMarker(session.state.sessionId, {
+                        ...anchors,
+                        summary: options.archiveBeforeCurrentTurn.summary,
+                    });
+                }
+                else {
+                    await this.archiveTurnRange(session.state.sessionId, { start: 0, end: 0 }, anchors);
+                }
+                // openRunSession captured the pre-marker replay. Rebuild from the
+                // persisted marker so this very first post-boundary model call gets
+                // the archived view rather than waiting until the following turn.
+                messages =
+                    this.compactedMessagesBySession.get(session.state.sessionId) ??
+                        this.sessionManager.resumeForRun(session.state.sessionId).transcript.toMessages();
+                const archived = { before, after: estimateTokens(messages) };
                 if (archived.before > archived.after) {
                     options.onStream?.({
                         type: "context_compact",
@@ -1123,12 +1140,6 @@ export class Engine {
                         after: archived.after,
                     });
                 }
-                // openRunSession captured the pre-marker replay. Rebuild from the
-                // persisted marker so this very first post-boundary model call gets
-                // the archived view rather than waiting until the following turn.
-                messages =
-                    this.compactedMessagesBySession.get(session.state.sessionId) ??
-                        this.sessionManager.resume(session.state.sessionId).transcript.toMessages();
             }
             catch (error) {
                 logger.warn("engine.pre_run_archive.failed", {
@@ -2018,9 +2029,11 @@ export class Engine {
                 runAllowedToolNames.has("cancel_goal")
                 ? { hasGoal: hasRunnableGoal }
                 : undefined,
-            capabilityPromptSections: profile?.disableCapabilityContext
-                ? {}
-                : this.capabilityPromptSections,
+            // Static sections named by the active preset are part of that preset's
+            // contract. `disableCapabilityContext` suppresses ambient/dynamic
+            // capability context, but removing these definitions leaves presets
+            // with dangling section names (for example terminal-coding → coding).
+            capabilityPromptSections: this.capabilityPromptSections,
             dynamicContextProviders: this.capabilityDynamicContextProviders,
             getSettingsManager: () => this.getSettingsManager(),
             toolCatalog: this.toolCatalog,

package/dist/engine/run-session-open.js

@@ -29,7 +29,7 @@ export function openRunSession(args) {
     };
     if (options?.sessionId && args.sessionManager.exists(options.sessionId)) {
         resumedFromDisk = true;
-        session = args.sessionManager.resume(options.sessionId);
+        session = args.sessionManager.resumeForRun(options.sessionId);
         const cachedCompacted = args.cachedCompactedMessages;
         messages = cachedCompacted ? [...cachedCompacted] : session.transcript.toMessages();
         // If the previous run was Ctrl+C'd or crashed between an assistant

package/dist/engine/run-types.d.ts

@@ -106,6 +106,8 @@ export interface EngineRunOptions {
     archiveBeforeCurrentTurn?: {
         fromClientMessageId?: string;
         segmentId?: string;
+        /** Host-authored replacement for the archived span; skips the summarizer. */
+        summary?: string;
     };
     attachments?: InputAttachmentMeta[];
     /** Named per-run behavior profile supplied by interactive product surfaces. */

package/dist/engine/turn-loop.js

@@ -836,6 +836,23 @@ export class TurnLoop {
                     if (response.text) {
                         messages.push({ role: "assistant", content: response.text });
                     }
+                    // Anthropic streams tool_use_start as soon as the content block
+                    // opens. If max_tokens cuts the JSON arguments off, we deliberately
+                    // do not execute that call, but the renderer still needs a terminal
+                    // event for the already-open card. Without it Claude tool cards stay
+                    // "working" forever (often until a later context compaction hides
+                    // them), even though the loop has moved on to a retry.
+                    for (const toolCall of response.toolCalls) {
+                        this.config.onStream?.({
+                            type: "tool_result",
+                            result: {
+                                id: toolCall.id,
+                                toolName: toolCall.toolName,
+                                error: "Tool call was not executed because its arguments were truncated.",
+                                isError: true,
+                            },
+                        });
+                    }
                     messages.push({
                         role: "user",
                         content: "<system-reminder>Your previous response was truncated by the max output token limit before the tool call finished, so its arguments are incomplete. Do not assume it ran. Either retry with a smaller/more focused tool call (e.g. write the file in sections via Edit), or raise this model's maxOutputTokens.</system-reminder>",

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export declare const VERSION = "0.8.13";
+export declare const VERSION = "0.8.20";
 export type { Message, ContentBlock, ToolDefinition, ToolCall, ToolResult, RegisteredTool, TranscriptEvent, TranscriptEventType, SessionState, SessionKind, SessionWorkspace, SessionForkLineage, ContextUsageAnchor, SessionStatus, TokenUsage, CompiledInput, PermissionDecision, PermissionMode, PermissionRule, TurnPhase, TurnResult, TerminalReason, TurnCompletionKind, StreamEvent, StreamCallback, LLMConfig, ClientDefaults, LLMResponse, Settings, MCPServerConfig, } from "./types.js";
 export type { GoalConfig, GoalLifecycleConfig, GoalLifecyclePhase, GoalLifecycleTerminalReason, GoalLifecycleV1, } from "./goal/lifecycle.js";
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, CompositionError, SandboxUnavailableError, } from "./exceptions.js";
@@ -98,7 +98,7 @@ export { mergePluginMcpServers, readPluginMcp } from "./plugins/installer/loadPl
 export { approvePluginMcp, listPluginMcpTrust, revokePluginMcp, type PluginMcpApprovalResult, type PluginMcpTrustEntry, } from "./plugins/pluginMcpApproval.js";
 export { pluginMcpApprovalState, type PluginMcpApprovalState, } from "./plugins/pluginMcpIntegrity.js";
 export { pluginsRoot } from "./plugins/installer/paths.js";
-export { PANEL_APP_ICONS, PANEL_APP_MANIFEST_FILE, PANEL_APP_PERMISSIONS, PanelAppManifest, PanelAppAlreadyInstalledError, PanelAppInstallError, PanelAppReviewChangedError, assertSafePanelAppId, installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, panelAppInstallDir, panelAppsRegistryPath, panelAppsRoot, previewLocalPanelApp, previewInstalledPanelAppUpdate, isPanelAppBound, resolvePanelAppBindingPolicy, resolvePanelAppBindingProjectPath, uninstallPanelApp, type InstalledPanelApp, type InstalledPanelAppSource, type GitPanelAppSourceInput, type LocalPanelAppSourceInput, type PanelAppSourceInput, type PanelAppManifestData, type PanelAppBindingPolicy, type PanelAppPreview, } from "./panel-apps/index.js";
+export { PANEL_APP_ICONS, PANEL_APP_MANIFEST_FILE, PANEL_APP_PERMISSIONS, PanelAppManifest, PanelAppAlreadyInstalledError, PanelAppInstallError, PanelAppReviewChangedError, assertSafePanelAppId, discoverGitPanelApps, installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, panelAppInstallDir, panelAppsRegistryPath, panelAppsRoot, previewLocalPanelApp, previewInstalledPanelAppUpdate, isPanelAppBound, resolvePanelAppBindingPolicy, resolvePanelAppBindingProjectPath, uninstallPanelApp, type InstalledPanelApp, type InstalledPanelAppSource, type GitPanelAppDiscovery, type GitPanelAppDiscoveryCandidate, type GitPanelAppDiscoveryIssue, type GitPanelAppSourceInput, type LocalPanelAppSourceInput, type PanelAppSourceInput, type PanelAppManifestData, type PanelAppBindingPolicy, type PanelAppPreview, } from "./panel-apps/index.js";
 export { previewLocalTheme, installReviewedLocalTheme, listInstalledThemes, uninstallTheme, themesRoot, themeInstallDir, assertSafeThemeName, ThemeInstallError, ThemeReviewChangedError, THEME_ASSET_DIR, THEME_VAR_NAMES, detectThemeImage, type ThemePreview, type InstalledTheme, type ThemeManifest, } from "./themes/index.js";
 export { resolveSafePluginPath } from "./plugins/pluginInstaller.js";
 export { listPluginHooks, pluginHookKey, type PluginHookEntry } from "./plugins/loadPluginHooks.js";

package/dist/index.internal.d.ts

@@ -26,6 +26,7 @@ export { recordUIEvent } from "./logging/session-recorder.js";
 export { getInteractiveApprovalBackend } from "./tool-system/permission.js";
 export { defaultSandboxConfig, type SandboxConfig } from "./tool-system/sandbox/index.js";
 export { buildNotificationMessage, buildNotificationSummary, notificationQueue, agentNotificationBus, notificationItemToStreamEvent, type NotificationItem, } from "./tool-system/builtin/agent-notifications.js";
+export { backgroundJobRegistry } from "./tool-system/builtin/background-jobs.js";
 export type { BackgroundAgentCompletedEvent } from "./types.js";
 export { startAutomation, type StartAutomationDeps, type AutomationHandle, CronScheduler, cronScheduler, type CronExecutionOutcome, type CronJob, type CronJobLifecycleEvent, type CronPermissionLevel, type CronTemplateSource, type CreateJobOptions, type UpdateJobPatch, CronStore, defaultCronStorePath, bindCronToEngine, bindCronToRunManager, type CronRunner, type CronRunRequest, type CronRunResult, type RunSubmitter, isCronExpression, parseCronExpression, nextCronTime, validateSchedule, type ParsedCron, resolveWritePolicy, wrapUntrustedInput, type WritePolicy, runWriteJobInWorktree, type WriteJobGitOps, type RunWriteJobInput, type RunWriteJobResult, } from "./automation/index.js";
 export { asyncAgentRegistry, type AsyncAgentEntry } from "./tool-system/builtin/agent-registry.js";

package/dist/index.internal.js

@@ -29,6 +29,7 @@ export { recordUIEvent } from "./logging/session-recorder.js";
 export { getInteractiveApprovalBackend } from "./tool-system/permission.js";
 export { defaultSandboxConfig } from "./tool-system/sandbox/index.js";
 export { buildNotificationMessage, buildNotificationSummary, notificationQueue, agentNotificationBus, notificationItemToStreamEvent, } from "./tool-system/builtin/agent-notifications.js";
+export { backgroundJobRegistry } from "./tool-system/builtin/background-jobs.js";
 export { startAutomation, CronScheduler, cronScheduler, CronStore, defaultCronStorePath, bindCronToEngine, bindCronToRunManager, isCronExpression, parseCronExpression, nextCronTime, validateSchedule, resolveWritePolicy, wrapUntrustedInput, runWriteJobInWorktree, } from "./automation/index.js";
 export { asyncAgentRegistry } from "./tool-system/builtin/agent-registry.js";
 export { backgroundShellManager, BackgroundShellManager, } from "./runtime/background-shell.js";

package/dist/index.js

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export const VERSION = "0.8.13";
+export const VERSION = "0.8.20";
 // ─── Exceptions ──────────────────────────────────────────────────
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, CompositionError, SandboxUnavailableError, } from "./exceptions.js";
 // ─── Composition (AgentModule / ResolvedComposition) ─────────────
@@ -82,7 +82,7 @@ export { mergePluginMcpServers, readPluginMcp } from "./plugins/installer/loadPl
 export { approvePluginMcp, listPluginMcpTrust, revokePluginMcp, } from "./plugins/pluginMcpApproval.js";
 export { pluginMcpApprovalState, } from "./plugins/pluginMcpIntegrity.js";
 export { pluginsRoot } from "./plugins/installer/paths.js";
-export { PANEL_APP_ICONS, PANEL_APP_MANIFEST_FILE, PANEL_APP_PERMISSIONS, PanelAppManifest, PanelAppAlreadyInstalledError, PanelAppInstallError, PanelAppReviewChangedError, assertSafePanelAppId, installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, panelAppInstallDir, panelAppsRegistryPath, panelAppsRoot, previewLocalPanelApp, previewInstalledPanelAppUpdate, isPanelAppBound, resolvePanelAppBindingPolicy, resolvePanelAppBindingProjectPath, uninstallPanelApp, } from "./panel-apps/index.js";
+export { PANEL_APP_ICONS, PANEL_APP_MANIFEST_FILE, PANEL_APP_PERMISSIONS, PanelAppManifest, PanelAppAlreadyInstalledError, PanelAppInstallError, PanelAppReviewChangedError, assertSafePanelAppId, discoverGitPanelApps, installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, panelAppInstallDir, panelAppsRegistryPath, panelAppsRoot, previewLocalPanelApp, previewInstalledPanelAppUpdate, isPanelAppBound, resolvePanelAppBindingPolicy, resolvePanelAppBindingProjectPath, uninstallPanelApp, } from "./panel-apps/index.js";
 export { previewLocalTheme, installReviewedLocalTheme, listInstalledThemes, uninstallTheme, themesRoot, themeInstallDir, assertSafeThemeName, ThemeInstallError, ThemeReviewChangedError, THEME_ASSET_DIR, THEME_VAR_NAMES, detectThemeImage, } from "./themes/index.js";
 export { resolveSafePluginPath } from "./plugins/pluginInstaller.js";
 export { listPluginHooks, pluginHookKey } from "./plugins/loadPluginHooks.js";

package/dist/llm/client-base.d.ts

@@ -12,6 +12,7 @@ export declare abstract class LLMClientBase {
     readonly timeout: number;
     readonly retryMaxAttempts: number;
     readonly imageDetail?: ClientDefaults["imageDetail"];
+    protected readonly fetch?: ClientDefaults["fetch"];
     /**
      * Process-wide hook fired on every LLM response. The CLI installs this in
      * main.ts to feed the cost tracker; lives on the base class so every code
@@ -23,7 +24,7 @@ export declare abstract class LLMClientBase {
     /**
      * `config` carries model identity (provider/model/apiKey/baseUrl/maxTokens/
      * thinking/providerKind). `defaults` carries cross-model runtime knobs
-     * (temperature/timeout/retryMaxAttempts/imageDetail) — those are owned by
+     * (temperature/timeout/retryMaxAttempts/imageDetail/fetch) — those are owned by
      * the Engine and stay stable across hot model switches.
      */
     constructor(config: LLMConfig, defaults?: ClientDefaults);

package/dist/llm/client-base.js

@@ -23,6 +23,7 @@ export class LLMClientBase {
     timeout;
     retryMaxAttempts;
     imageDetail;
+    fetch;
     /**
      * Process-wide hook fired on every LLM response. The CLI installs this in
      * main.ts to feed the cost tracker; lives on the base class so every code
@@ -34,7 +35,7 @@ export class LLMClientBase {
     /**
      * `config` carries model identity (provider/model/apiKey/baseUrl/maxTokens/
      * thinking/providerKind). `defaults` carries cross-model runtime knobs
-     * (temperature/timeout/retryMaxAttempts/imageDetail) — those are owned by
+     * (temperature/timeout/retryMaxAttempts/imageDetail/fetch) — those are owned by
      * the Engine and stay stable across hot model switches.
      */
     constructor(config, defaults) {
@@ -51,6 +52,7 @@ export class LLMClientBase {
         this.timeout = defaults?.timeout ?? 120_000;
         this.retryMaxAttempts = defaults?.retryMaxAttempts ?? 3;
         this.imageDetail = defaults?.imageDetail;
+        this.fetch = defaults?.fetch;
         this.initClient();
     }
     recordUsage(usage, options) {

package/dist/llm/providers/anthropic.js

@@ -21,6 +21,25 @@ const ANTHROPIC_FALLBACK_MAX_TOKENS = 4096;
  * no explicit token budget was given. Clamped up to the model's minimum.
  */
 const ANTHROPIC_DEFAULT_THINKING_BUDGET = 4096;
+/**
+ * Anthropic reports uncached input, cache writes, and cache reads as three
+ * disjoint counters. `TokenUsage.promptTokens` is the whole prompt throughout
+ * CodeShell (OpenAI includes cached tokens in prompt_tokens), so normalize the
+ * Anthropic shape before context accounting, compaction, cache-hit math, and
+ * cost tracking consume it.
+ */
+function tokenUsageFromAnthropic(usage) {
+    const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+    const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+    const promptTokens = usage.input_tokens + cacheReadTokens + cacheCreationTokens;
+    return {
+        promptTokens,
+        completionTokens: usage.output_tokens,
+        totalTokens: promptTokens + usage.output_tokens,
+        ...(usage.cache_read_input_tokens != null ? { cacheReadTokens } : {}),
+        ...(usage.cache_creation_input_tokens != null ? { cacheCreationTokens } : {}),
+    };
+}
 export class AnthropicClient extends LLMClientBase {
     _client = null;
     constructor(config, defaults) {
@@ -37,6 +56,7 @@ export class AnthropicClient extends LLMClientBase {
                 apiKey: resolveApiKey(this.config, process.env.ANTHROPIC_API_KEY),
                 ...(this.config.baseUrl ? { baseURL: this.config.baseUrl } : {}),
                 ...(Object.keys(headers).length > 0 ? { defaultHeaders: headers } : {}),
+                ...(this.fetch ? { fetch: this.fetch } : {}),
                 timeout: this.timeout,
             });
         }
@@ -106,9 +126,7 @@ export class AnthropicClient extends LLMClientBase {
         if (ceiling < min) {
             return undefined;
         }
-        let budget = reasoning.mode === "budget"
-            ? reasoning.budgetTokens
-            : ANTHROPIC_DEFAULT_THINKING_BUDGET; // "on" or "effort" → default budget
+        let budget = reasoning.mode === "budget" ? reasoning.budgetTokens : ANTHROPIC_DEFAULT_THINKING_BUDGET; // "on" or "effort" → default budget
         // Clamp into [min, ceiling] — both bounds are now guaranteed ≥ min.
         budget = Math.min(Math.max(budget, min), ceiling);
         return { type: "enabled", budget_tokens: budget };
@@ -172,13 +190,7 @@ export class AnthropicClient extends LLMClientBase {
                     ? { temperature: options.temperature }
                     : { temperature: this.temperature }),
             }, { signal: requestSignal ?? options.signal });
-            const usage = {
-                promptTokens: response.usage.input_tokens,
-                completionTokens: response.usage.output_tokens,
-                totalTokens: response.usage.input_tokens + response.usage.output_tokens,
-                cacheReadTokens: response.usage.cache_read_input_tokens,
-                cacheCreationTokens: response.usage.cache_creation_input_tokens,
-            };
+            const usage = tokenUsageFromAnthropic(response.usage);
             this.recordUsage(usage, options);
             return this.processResponse(response, usage);
         }
@@ -209,10 +221,8 @@ export class AnthropicClient extends LLMClientBase {
                     ? { temperature: options.temperature }
                     : { temperature: this.temperature }),
             }, { signal: requestSignal ?? options.signal });
-            let currentText = "";
             let currentToolName = "";
             let currentToolId = "";
-            let currentToolInput = "";
             // Abort-guarded emit: once the turn is cancelled, stop forwarding chunks
             // to the UI. The SDK's event emitter can keep firing buffered text/
             // contentBlock/inputJson events after abort() until its HTTP stream tears
@@ -249,14 +259,12 @@ export class AnthropicClient extends LLMClientBase {
                         ttft_ms: Date.now() - streamStartedAt,
                     });
                 }
-                currentText += text;
                 emit({ type: "text", text, tokens: countTokens(text) });
             });
             stream.on("contentBlock", (block) => {
                 if (block.type === "tool_use") {
                     currentToolName = block.name;
                     currentToolId = block.id;
-                    currentToolInput = "";
                     emit({
                         type: "tool_use_start",
                         toolCall: { id: block.id, toolName: block.name, args: {} },
@@ -264,7 +272,6 @@ export class AnthropicClient extends LLMClientBase {
                 }
             });
             stream.on("inputJson", (_delta, snapshot) => {
-                currentToolInput = JSON.stringify(snapshot);
                 if (currentToolId) {
                     emit({
                         type: "tool_use_delta",
@@ -277,13 +284,7 @@ export class AnthropicClient extends LLMClientBase {
                 }
             });
             const finalMessage = await stream.finalMessage();
-            const usage = {
-                promptTokens: finalMessage.usage.input_tokens,
-                completionTokens: finalMessage.usage.output_tokens,
-                totalTokens: finalMessage.usage.input_tokens + finalMessage.usage.output_tokens,
-                cacheReadTokens: finalMessage.usage.cache_read_input_tokens,
-                cacheCreationTokens: finalMessage.usage.cache_creation_input_tokens,
-            };
+            const usage = tokenUsageFromAnthropic(finalMessage.usage);
             this.recordUsage(usage, options);
             options.onChunk?.({ type: "stop", stopReason: finalMessage.stop_reason ?? undefined });
             return this.processResponse(finalMessage, usage);
@@ -415,9 +416,7 @@ export class AnthropicClient extends LLMClientBase {
                 // marking them would 400. buildMessages never emits them today (thinking
                 // is a top-level request field, not history content), but guard anyway
                 // so a future block type can't silently break the request.
-                if (lastBlock &&
-                    lastBlock.type !== "thinking" &&
-                    lastBlock.type !== "redacted_thinking") {
+                if (lastBlock && lastBlock.type !== "thinking" && lastBlock.type !== "redacted_thinking") {
                     lastBlock.cache_control = { type: "ephemeral" };
                 }
             }

package/dist/llm/providers/openai.d.ts

@@ -49,9 +49,12 @@ interface RunStreamOpts {
 export declare function runStreamWithWatchdog<T = any>(stream: AsyncIterable<T>, opts?: RunStreamOpts): Promise<string>;
 export declare class OpenAIClient extends LLMClientBase {
     private _client;
+    private readonly dangerouslyAllowBrowser;
     private _forceMaxCompletionTokens;
     private _dropReasoningEffort;
-    constructor(config: LLMConfig, defaults?: ClientDefaults);
+    constructor(config: LLMConfig, defaults?: ClientDefaults, runtimeOptions?: {
+        dangerouslyAllowBrowser?: boolean;
+    });
     protected initClient(): void;
     private get client();
     /**

package/dist/llm/providers/openai.js

@@ -41,6 +41,24 @@ function cachedTokensOf(usage) {
         out.cacheCreationTokens = details.cache_write_tokens;
     return out;
 }
+/** Read the effective output-token ceiling from a built Chat Completions request. */
+function outputTokenLimitOf(requestBody) {
+    const value = requestBody.max_completion_tokens ?? requestBody.max_tokens;
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+/**
+ * Some OpenAI-compatible gateways return finish_reason `tool_calls` when the
+ * output ceiling cuts a function-argument JSON string off. The malformed JSON
+ * plus exact cap usage is the evidence that distinguishes this from an ordinary
+ * completed tool call.
+ */
+function didHitToolArgumentOutputLimit(input) {
+    return (input.finishReason === "tool_calls" &&
+        input.malformedToolArguments &&
+        input.outputTokenLimit !== undefined &&
+        input.completionTokens !== undefined &&
+        input.completionTokens >= input.outputTokenLimit);
+}
 /**
  * Consume an async iterable of stream chunks with an idle watchdog.
  * Returns the accumulated text — either from onChunk return values, or
@@ -193,6 +211,7 @@ function normalizeOpenAIToolMessagePairs(messages) {
 }
 export class OpenAIClient extends LLMClientBase {
     _client = null;
+    dangerouslyAllowBrowser;
     // Sticky override: once the endpoint tells us `max_tokens` is rejected for
     // this model, switch to `max_completion_tokens` for the lifetime of the
     // client. Cheaper and more reliable than re-deriving from the model id when
@@ -205,8 +224,9 @@ export class OpenAIClient extends LLMClientBase {
     // succeed. Omitting the field just means "model default reasoning", which is
     // fine for our background/aux calls.
     _dropReasoningEffort = false;
-    constructor(config, defaults) {
+    constructor(config, defaults, runtimeOptions = {}) {
         super(config, defaults);
+        this.dangerouslyAllowBrowser = runtimeOptions.dangerouslyAllowBrowser === true;
     }
     initClient() {
         // Lazy init — client created on first use
@@ -222,6 +242,8 @@ export class OpenAIClient extends LLMClientBase {
                     (Object.keys(headers).length > 0 ? "x-headers-auth" : undefined),
                 ...(this.config.baseUrl ? { baseURL: this.config.baseUrl } : {}),
                 ...(Object.keys(headers).length > 0 ? { defaultHeaders: headers } : {}),
+                ...(this.fetch ? { fetch: this.fetch } : {}),
+                ...(this.dangerouslyAllowBrowser ? { dangerouslyAllowBrowser: true } : {}),
                 timeout: this.timeout,
             });
         }
@@ -473,7 +495,8 @@ export class OpenAIClient extends LLMClientBase {
     }
     async nonStreamMessage(options, messages, tools, reasoning, requestSignal) {
         try {
-            const response = await this.client.chat.completions.create(this.buildRequestBody(options, messages, tools, reasoning, false), { signal: requestSignal ?? options.signal });
+            const requestBody = this.buildRequestBody(options, messages, tools, reasoning, false);
+            const response = await this.client.chat.completions.create(requestBody, { signal: requestSignal ?? options.signal });
             const choice = response.choices[0];
             if (!choice)
                 throw new LLMError("No response from OpenAI", "openai");
@@ -486,7 +509,7 @@ export class OpenAIClient extends LLMClientBase {
                 ...cachedTokensOf(response.usage),
             };
             this.recordUsage(usage, options);
-            return this.processChoice(choice, usage);
+            return this.processChoice(choice, usage, outputTokenLimitOf(requestBody));
         }
         catch (err) {
             this.handleApiError(err);
@@ -496,7 +519,9 @@ export class OpenAIClient extends LLMClientBase {
     async streamMessage(options, messages, tools, reasoning, requestSignal) {
         const sdkSignal = requestSignal ?? options.signal;
         try {
-            const stream = await this.client.chat.completions.create(this.buildRequestBody(options, messages, tools, reasoning, true), { signal: sdkSignal });
+            const requestBody = this.buildRequestBody(options, messages, tools, reasoning, true);
+            const stream = await this.client.chat.completions.create(requestBody, { signal: sdkSignal });
+            const outputTokenLimit = outputTokenLimitOf(requestBody);
             let text = "";
             let reasoningContent = "";
             const toolCallsMap = new Map();
@@ -605,6 +630,7 @@ export class OpenAIClient extends LLMClientBase {
                 signal: sdkSignal,
             });
             const toolCalls = [];
+            let malformedToolArguments = false;
             for (const [, tc] of toolCallsMap) {
                 // Drop incomplete tool calls: an empty id or name (the fallbacks set
                 // when a delta never delivered them) would become a malformed call
@@ -621,9 +647,16 @@ export class OpenAIClient extends LLMClientBase {
                     args = JSON.parse(tc.args || "{}");
                 }
                 catch {
-                    /* intentional: model emitted malformed tool-call JSON — fall back to
-                       empty args rather than crashing the stream; the tool layer reports
-                       the resulting validation error back to the model. */
+                    malformedToolArguments = true;
+                    // Keep the historical empty-args fallback for genuinely malformed
+                    // model output. If usage also proves the configured output ceiling was
+                    // reached, the stop reason is normalized to "length" below so the turn
+                    // loop retries instead of executing this misleading empty call.
+                    logger.warn("openai.malformed_tool_arguments", {
+                        id: tc.id,
+                        name: tc.name,
+                        argumentChars: tc.args.length,
+                    });
                 }
                 toolCalls.push({ id: tc.id, toolName: tc.name, args });
             }
@@ -634,11 +667,31 @@ export class OpenAIClient extends LLMClientBase {
                 ...cachedTokensOf(streamUsage),
             };
             this.recordUsage(usage, options);
+            const inferredToolArgumentTruncation = didHitToolArgumentOutputLimit({
+                finishReason,
+                malformedToolArguments,
+                completionTokens: usage.completionTokens,
+                outputTokenLimit,
+            });
+            if (inferredToolArgumentTruncation) {
+                logger.warn("openai.tool_arguments_truncation_inferred", {
+                    provider: this.provider,
+                    model: this.model,
+                    finishReason,
+                    completionTokens: usage.completionTokens,
+                    outputTokenLimit,
+                    toolCount: toolCalls.length,
+                });
+            }
             return {
                 text,
                 toolCalls,
                 usage,
-                stopReason: finishReason ?? "stop",
+                // OpenRouter can report `tool_calls` even when max_tokens cuts a tool's
+                // argument JSON off. Normalize that proven cap hit to the standard
+                // OpenAI `length` spelling so the shared continuation guard can skip
+                // execution and ask the model to retry with a smaller call.
+                stopReason: inferredToolArgumentTruncation ? "length" : (finishReason ?? "stop"),
                 ...(reasoningContent ? { reasoningContent } : {}),
             };
         }
@@ -647,9 +700,10 @@ export class OpenAIClient extends LLMClientBase {
             throw err;
         }
     }
-    processChoice(choice, usage) {
+    processChoice(choice, usage, outputTokenLimit) {
         const text = choice.message.content ?? "";
         const toolCalls = [];
+        let malformedToolArguments = false;
         if (choice.message.tool_calls) {
             for (const tc of choice.message.tool_calls) {
                 let args = {};
@@ -657,9 +711,12 @@ export class OpenAIClient extends LLMClientBase {
                     args = JSON.parse(tc.function.arguments || "{}");
                 }
                 catch {
-                    /* intentional: model emitted malformed tool-call JSON — fall back to
-                       empty args rather than crashing; the tool layer reports the
-                       resulting validation error back to the model. */
+                    malformedToolArguments = true;
+                    logger.warn("openai.malformed_tool_arguments", {
+                        id: tc.id,
+                        name: tc.function.name,
+                        argumentChars: tc.function.arguments?.length ?? 0,
+                    });
                 }
                 toolCalls.push({
                     id: tc.id,
@@ -669,11 +726,17 @@ export class OpenAIClient extends LLMClientBase {
             }
         }
         const reasoningContent = extractReasoningContent(choice.message);
+        const inferredToolArgumentTruncation = didHitToolArgumentOutputLimit({
+            finishReason: choice.finish_reason ?? undefined,
+            malformedToolArguments,
+            completionTokens: usage.completionTokens,
+            outputTokenLimit,
+        });
         return {
             text,
             toolCalls,
             usage,
-            stopReason: choice.finish_reason ?? undefined,
+            stopReason: inferredToolArgumentTruncation ? "length" : (choice.finish_reason ?? undefined),
             ...(reasoningContent ? { reasoningContent } : {}),
         };
     }

package/dist/panel-apps/index.d.ts

@@ -1,4 +1,4 @@
 export { PANEL_APP_ICONS, PANEL_APP_MANIFEST_FILE, PANEL_APP_PERMISSIONS, PanelAppAgentContribution, PanelAppAgentTool, PanelAppManifest, type PanelAppAgentContribution as PanelAppAgentContributionData, type PanelAppAgentTool as PanelAppAgentToolData, type PanelAppManifest as PanelAppManifestData, } from "./manifest.js";
 export { PanelAppAlreadyInstalledError, PanelAppInstallError, PanelAppReviewChangedError, assertSafePanelAppId, panelAppInstallDir, panelAppsRegistryPath, panelAppsRoot, } from "./paths.js";
-export { installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, previewInstalledPanelAppUpdate, previewLocalPanelApp, uninstallPanelApp, type InstalledPanelApp, type InstalledPanelAppSource, type GitPanelAppSourceInput, type LocalPanelAppSourceInput, type PanelAppSourceInput, type PanelAppPreview, } from "./installer.js";
+export { discoverGitPanelApps, installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, previewInstalledPanelAppUpdate, previewLocalPanelApp, uninstallPanelApp, type InstalledPanelApp, type InstalledPanelAppSource, type GitPanelAppSourceInput, type GitPanelAppDiscovery, type GitPanelAppDiscoveryCandidate, type GitPanelAppDiscoveryIssue, type LocalPanelAppSourceInput, type PanelAppSourceInput, type PanelAppPreview, } from "./installer.js";
 export { isPanelAppBound, resolvePanelAppBindingPolicy, resolvePanelAppBindingProjectPath, type PanelAppBindingPolicy, } from "./bindings.js";

package/dist/panel-apps/index.js

@@ -1,4 +1,4 @@
 export { PANEL_APP_ICONS, PANEL_APP_MANIFEST_FILE, PANEL_APP_PERMISSIONS, PanelAppAgentContribution, PanelAppAgentTool, PanelAppManifest, } from "./manifest.js";
 export { PanelAppAlreadyInstalledError, PanelAppInstallError, PanelAppReviewChangedError, assertSafePanelAppId, panelAppInstallDir, panelAppsRegistryPath, panelAppsRoot, } from "./paths.js";
-export { installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, previewInstalledPanelAppUpdate, previewLocalPanelApp, uninstallPanelApp, } from "./installer.js";
+export { discoverGitPanelApps, installReviewedLocalPanelApp, installReviewedPanelAppUpdate, listInstalledPanelApps, previewInstalledPanelAppUpdate, previewLocalPanelApp, uninstallPanelApp, } from "./installer.js";
 export { isPanelAppBound, resolvePanelAppBindingPolicy, resolvePanelAppBindingProjectPath, } from "./bindings.js";

package/dist/panel-apps/installer.d.ts

@@ -33,6 +33,29 @@ export interface PanelAppPreview {
     };
     warnings: string[];
 }
+export interface GitPanelAppDiscoveryCandidate {
+    /** Repository-relative path, or "." when the repository root is the app. */
+    subdir: string;
+    source: GitPanelAppSourceInput;
+    id: string;
+    version: string;
+    title: {
+        default: string;
+        en?: string;
+        "zh-CN"?: string;
+    };
+    description?: string;
+    icon: PanelAppManifest["icon"];
+}
+export interface GitPanelAppDiscoveryIssue {
+    subdir: string;
+    error: string;
+}
+export interface GitPanelAppDiscovery {
+    source: GitPanelAppSourceInput;
+    panels: GitPanelAppDiscoveryCandidate[];
+    issues: GitPanelAppDiscoveryIssue[];
+}
 export interface InstalledPanelApp {
     id: string;
     version: string;
@@ -52,6 +75,12 @@ export interface InstalledPanelApp {
     installedAt: string;
     lastUpdated: string;
 }
+/**
+ * Download a public GitHub repository once and enumerate every independently
+ * installable Panel App beneath it. Discovery is read-only: selecting a result
+ * still runs the normal full review and digest-bound install flow.
+ */
+export declare function discoverGitPanelApps(input: GitPanelAppSourceInput): Promise<GitPanelAppDiscovery>;
 export declare function previewLocalPanelApp(input: PanelAppSourceInput): Promise<PanelAppPreview>;
 /**
  * Re-open the original folder, archive, or GitHub source through the same