@psnext/slingcli 2.4.20260601-1 → 2.5.20260602-2

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/github-copilot.js

@@ -122,7 +122,7 @@ async function pollForGitHubAccessToken(domain, device, signal) {
                 }),
             });
             if (raw && typeof raw === "object" && typeof raw.access_token === "string") {
-                return { status: "complete", accessToken: raw.access_token };
+                return { status: "complete", value: raw.access_token };
             }
             if (raw && typeof raw === "object" && typeof raw.error === "string") {
                 const { error, error_description: description } = raw;

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/index.js

@@ -12,7 +12,7 @@ export * from "./device-code.js";
 // GitHub Copilot
 export { getGitHubCopilotBaseUrl, githubCopilotOAuthProvider, loginGitHubCopilot, normalizeDomain, refreshGitHubCopilotToken, } from "./github-copilot.js";
 // OpenAI Codex (ChatGPT OAuth)
-export { loginOpenAICodex, openaiCodexOAuthProvider, refreshOpenAICodexToken } from "./openai-codex.js";
+export { loginOpenAICodex, loginOpenAICodexDeviceCode, OPENAI_CODEX_BROWSER_LOGIN_METHOD, OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD, openaiCodexOAuthProvider, refreshOpenAICodexToken, } from "./openai-codex.js";
 export * from "./types.js";
 // ============================================================================
 // Provider Registry

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/openai-codex.js

@@ -15,13 +15,22 @@ if (typeof process !== "undefined" && (process.versions?.node || process.version
         _http = m;
     });
 }
+import { pollOAuthDeviceCodeFlow } from "./device-code.js";
 import { oauthErrorHtml, oauthSuccessHtml } from "./oauth-page.js";
 import { generatePKCE } from "./pkce.js";
 const CALLBACK_HOST = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-const AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
-const TOKEN_URL = "https://auth.openai.com/oauth/token";
+const AUTH_BASE_URL = "https://auth.openai.com";
+const AUTHORIZE_URL = `${AUTH_BASE_URL}/oauth/authorize`;
+const TOKEN_URL = `${AUTH_BASE_URL}/oauth/token`;
 const REDIRECT_URI = "http://localhost:1455/auth/callback";
+const DEVICE_USER_CODE_URL = `${AUTH_BASE_URL}/api/accounts/deviceauth/usercode`;
+const DEVICE_TOKEN_URL = `${AUTH_BASE_URL}/api/accounts/deviceauth/token`;
+const DEVICE_VERIFICATION_URI = `${AUTH_BASE_URL}/codex/device`;
+const DEVICE_REDIRECT_URI = `${AUTH_BASE_URL}/deviceauth/callback`;
+const DEVICE_CODE_TIMEOUT_SECONDS = 15 * 60;
+export const OPENAI_CODEX_BROWSER_LOGIN_METHOD = "browser";
+export const OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD = "device_code";
 const SCOPE = "openid profile email offline_access";
 const JWT_CLAIM_PATH = "https://api.openai.com/auth";
 function createState() {
@@ -70,8 +79,35 @@ function decodeJwt(token) {
         return null;
     }
 }
-async function exchangeAuthorizationCode(code, verifier, redirectUri = REDIRECT_URI) {
-    const response = await fetch(TOKEN_URL, {
+async function fetchWithLoginCancellation(input, init) {
+    try {
+        return await fetch(input, init);
+    }
+    catch (error) {
+        if (init.signal?.aborted) {
+            throw new Error("Login cancelled");
+        }
+        throw error;
+    }
+}
+async function readTokenResponse(response, operation) {
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(`OpenAI Codex token ${operation} failed (${response.status}): ${text || response.statusText}`);
+    }
+    const rawJson = await response.json();
+    const json = rawJson;
+    if (!json?.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
+        throw new Error(`OpenAI Codex token ${operation} response missing fields: ${JSON.stringify(json)}`);
+    }
+    return {
+        access: json.access_token,
+        refresh: json.refresh_token,
+        expires: Date.now() + json.expires_in * 1000,
+    };
+}
+async function exchangeAuthorizationCode(code, verifier, redirectUri = REDIRECT_URI, signal) {
+    const response = await fetchWithLoginCancellation(TOKEN_URL, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded" },
         body: new URLSearchParams({
@@ -81,32 +117,14 @@ async function exchangeAuthorizationCode(code, verifier, redirectUri = REDIRECT_
             code_verifier: verifier,
             redirect_uri: redirectUri,
         }),
+        signal,
     });
-    if (!response.ok) {
-        const text = await response.text().catch(() => "");
-        return {
-            type: "failed",
-            status: response.status,
-            message: `OpenAI Codex token exchange failed (${response.status}): ${text || response.statusText}`,
-        };
-    }
-    const json = (await response.json());
-    if (!json.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
-        return {
-            type: "failed",
-            message: `OpenAI Codex token exchange response missing fields: ${JSON.stringify(json)}`,
-        };
-    }
-    return {
-        type: "success",
-        access: json.access_token,
-        refresh: json.refresh_token,
-        expires: Date.now() + json.expires_in * 1000,
-    };
+    return readTokenResponse(response, "exchange");
 }
 async function refreshAccessToken(refreshToken) {
+    let response;
     try {
-        const response = await fetch(TOKEN_URL, {
+        response = await fetch(TOKEN_URL, {
             method: "POST",
             headers: { "Content-Type": "application/x-www-form-urlencoded" },
             body: new URLSearchParams({
@@ -115,34 +133,94 @@ async function refreshAccessToken(refreshToken) {
                 client_id: CLIENT_ID,
             }),
         });
-        if (!response.ok) {
-            const text = await response.text().catch(() => "");
-            return {
-                type: "failed",
-                status: response.status,
-                message: `OpenAI Codex token refresh failed (${response.status}): ${text || response.statusText}`,
-            };
-        }
-        const json = (await response.json());
-        if (!json.access_token || !json.refresh_token || typeof json.expires_in !== "number") {
-            return {
-                type: "failed",
-                message: `OpenAI Codex token refresh response missing fields: ${JSON.stringify(json)}`,
-            };
-        }
-        return {
-            type: "success",
-            access: json.access_token,
-            refresh: json.refresh_token,
-            expires: Date.now() + json.expires_in * 1000,
-        };
     }
     catch (error) {
-        return {
-            type: "failed",
-            message: `OpenAI Codex token refresh error: ${error instanceof Error ? error.message : String(error)}`,
-        };
+        throw new Error(`OpenAI Codex token refresh error: ${error instanceof Error ? error.message : String(error)}`);
     }
+    return readTokenResponse(response, "refresh");
+}
+async function startOpenAICodexDeviceAuth(signal) {
+    const response = await fetchWithLoginCancellation(DEVICE_USER_CODE_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ client_id: CLIENT_ID }),
+        signal,
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new Error("OpenAI Codex device code login is not enabled for this server. Use browser login or verify the server URL.");
+        }
+        const responseBody = await response.text().catch(() => "");
+        throw new Error(`OpenAI Codex device code request failed with status ${response.status}${responseBody ? `: ${responseBody}` : ""}`);
+    }
+    const rawJson = await response.json();
+    const json = rawJson;
+    const intervalSeconds = typeof json?.interval === "string" ? Number(json.interval.trim()) : json?.interval;
+    if (!json?.device_auth_id ||
+        !json.user_code ||
+        typeof intervalSeconds !== "number" ||
+        !Number.isFinite(intervalSeconds) ||
+        intervalSeconds < 0) {
+        throw new Error(`Invalid OpenAI Codex device code response: ${JSON.stringify(json)}`);
+    }
+    return {
+        deviceAuthId: json.device_auth_id,
+        userCode: json.user_code,
+        intervalSeconds,
+    };
+}
+async function pollOpenAICodexDeviceAuth(device, signal) {
+    return pollOAuthDeviceCodeFlow({
+        intervalSeconds: device.intervalSeconds,
+        expiresInSeconds: DEVICE_CODE_TIMEOUT_SECONDS,
+        signal,
+        poll: async () => {
+            const response = await fetchWithLoginCancellation(DEVICE_TOKEN_URL, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    device_auth_id: device.deviceAuthId,
+                    user_code: device.userCode,
+                }),
+                signal,
+            });
+            if (response.ok) {
+                const rawJson = await response.json();
+                const json = rawJson;
+                if (!json?.authorization_code || !json.code_verifier) {
+                    return {
+                        status: "failed",
+                        message: `Invalid OpenAI Codex device auth token response: ${JSON.stringify(json)}`,
+                    };
+                }
+                return {
+                    status: "complete",
+                    value: { authorizationCode: json.authorization_code, codeVerifier: json.code_verifier },
+                };
+            }
+            if (response.status === 403 || response.status === 404) {
+                return { status: "pending" };
+            }
+            const responseBody = await response.text().catch(() => "");
+            let errorCode;
+            try {
+                const json = JSON.parse(responseBody);
+                const error = json?.error;
+                errorCode = typeof error === "object" ? error?.code : error;
+            }
+            catch { }
+            if (errorCode === "deviceauth_authorization_pending") {
+                return { status: "pending" };
+            }
+            if (errorCode === "slow_down") {
+                return { status: "slow_down" };
+            }
+            return {
+                status: "failed",
+                message: `OpenAI Codex device auth failed with status ${response.status}${responseBody ? `: ${responseBody}` : ""}`,
+            };
+        },
+    });
 }
 async function createAuthorizationFlow(originator = "pi") {
     const { verifier, challenge } = await generatePKCE();
@@ -241,6 +319,35 @@ function getAccountId(accessToken) {
     const accountId = auth?.chatgpt_account_id;
     return typeof accountId === "string" && accountId.length > 0 ? accountId : null;
 }
+function credentialsFromToken(token) {
+    const accountId = getAccountId(token.access);
+    if (!accountId) {
+        throw new Error("Failed to extract accountId from token");
+    }
+    return {
+        access: token.access,
+        refresh: token.refresh,
+        expires: token.expires,
+        accountId,
+    };
+}
+async function exchangeAuthorizationCodeForCredentials(code, verifier, redirectUri, signal) {
+    return credentialsFromToken(await exchangeAuthorizationCode(code, verifier, redirectUri, signal));
+}
+/**
+ * Login with OpenAI Codex OAuth using the Codex device-code flow.
+ */
+export async function loginOpenAICodexDeviceCode(options) {
+    const device = await startOpenAICodexDeviceAuth(options.signal);
+    options.onDeviceCode({
+        userCode: device.userCode,
+        verificationUri: DEVICE_VERIFICATION_URI,
+        intervalSeconds: device.intervalSeconds,
+        expiresInSeconds: DEVICE_CODE_TIMEOUT_SECONDS,
+    });
+    const code = await pollOpenAICodexDeviceAuth(device, options.signal);
+    return exchangeAuthorizationCodeForCredentials(code.authorizationCode, code.codeVerifier, DEVICE_REDIRECT_URI, options.signal);
+}
 /**
  * Login with OpenAI Codex OAuth
  *
@@ -325,20 +432,7 @@ export async function loginOpenAICodex(options) {
         if (!code) {
             throw new Error("Missing authorization code");
         }
-        const tokenResult = await exchangeAuthorizationCode(code, verifier);
-        if (tokenResult.type !== "success") {
-            throw new Error(tokenResult.message);
-        }
-        const accountId = getAccountId(tokenResult.access);
-        if (!accountId) {
-            throw new Error("Failed to extract accountId from token");
-        }
-        return {
-            access: tokenResult.access,
-            refresh: tokenResult.refresh,
-            expires: tokenResult.expires,
-            accountId,
-        };
+        return exchangeAuthorizationCodeForCredentials(code, verifier, REDIRECT_URI);
     }
     finally {
         server.close();
@@ -348,26 +442,32 @@ export async function loginOpenAICodex(options) {
  * Refresh OpenAI Codex OAuth token
  */
 export async function refreshOpenAICodexToken(refreshToken) {
-    const result = await refreshAccessToken(refreshToken);
-    if (result.type !== "success") {
-        throw new Error(result.message);
-    }
-    const accountId = getAccountId(result.access);
-    if (!accountId) {
-        throw new Error("Failed to extract accountId from token");
-    }
-    return {
-        access: result.access,
-        refresh: result.refresh,
-        expires: result.expires,
-        accountId,
-    };
+    return credentialsFromToken(await refreshAccessToken(refreshToken));
 }
 export const openaiCodexOAuthProvider = {
     id: "openai-codex",
     name: "ChatGPT Plus/Pro (Codex Subscription)",
     usesCallbackServer: true,
     async login(callbacks) {
+        const loginMethod = await callbacks.onSelect({
+            message: "Select OpenAI Codex login method:",
+            options: [
+                { id: OPENAI_CODEX_BROWSER_LOGIN_METHOD, label: "Browser login (default)" },
+                { id: OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD, label: "Device code login (headless)" },
+            ],
+        });
+        if (!loginMethod) {
+            throw new Error("Login cancelled");
+        }
+        if (loginMethod === OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD) {
+            return loginOpenAICodexDeviceCode({
+                onDeviceCode: callbacks.onDeviceCode,
+                signal: callbacks.signal,
+            });
+        }
+        if (loginMethod !== OPENAI_CODEX_BROWSER_LOGIN_METHOD) {
+            throw new Error(`Unknown OpenAI Codex login method: ${loginMethod}`);
+        }
         return loginOpenAICodex({
             onAuth: callbacks.onAuth,
             onPrompt: callbacks.onPrompt,

package/node_modules/@earendil-works/pi-ai/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-ai",
-	"version": "0.75.5",
+	"version": "0.78.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -92,7 +92,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/earendil-works/pi-mono.git",
+		"url": "git+https://github.com/earendil-works/pi.git",
 		"directory": "packages/ai"
 	},
 	"engines": {

package/node_modules/@earendil-works/pi-coding-agent/dist/cli/args.js

@@ -50,12 +50,23 @@ export function parseArgs(args) {
             result.appendSystemPrompt = result.appendSystemPrompt ?? [];
             result.appendSystemPrompt.push(args[++i]);
         }
+        else if (arg === "--name" || arg === "-n") {
+            if (i + 1 < args.length) {
+                result.name = args[++i];
+            }
+            else {
+                result.diagnostics.push({ type: "error", message: "--name requires a value" });
+            }
+        }
         else if (arg === "--no-session") {
             result.noSession = true;
         }
         else if (arg === "--session" && i + 1 < args.length) {
             result.session = args[++i];
         }
+        else if (arg === "--session-id" && i + 1 < args.length) {
+            result.sessionId = args[++i];
+        }
         else if (arg === "--fork" && i + 1 < args.length) {
             result.fork = args[++i];
         }
@@ -77,6 +88,12 @@ export function parseArgs(args) {
                 .map((s) => s.trim())
                 .filter((name) => name.length > 0);
         }
+        else if ((arg === "--exclude-tools" || arg === "-xt") && i + 1 < args.length) {
+            result.excludeTools = args[++i]
+                .split(",")
+                .map((s) => s.trim())
+                .filter((name) => name.length > 0);
+        }
         else if (arg === "--thinking" && i + 1 < args.length) {
             const level = args[++i];
             if (isValidThinkingLevel(level)) {
@@ -210,15 +227,19 @@ ${chalk.bold("Options:")}
   --continue, -c                 Continue previous session
   --resume, -r                   Select a session to resume
   --session <path|id>            Use specific session file or partial UUID
+  --session-id <id>              Use exact project session ID, creating it if missing
   --fork <path|id>               Fork specific session file or partial UUID into a new session
   --session-dir <dir>            Directory for session storage and lookup
   --no-session                   Don't save session (ephemeral)
+  --name, -n <name>              Set session display name
   --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
                                  Supports globs (anthropic/*, *sonnet*) and fuzzy matching
   --no-tools, -nt                Disable all tools by default (built-in and extension)
   --no-builtin-tools, -nbt       Disable built-in tools by default but keep extension/custom tools enabled
   --tools, -t <tools>            Comma-separated allowlist of tool names to enable
                                  Applies to built-in, extension, and custom tools
+  --exclude-tools, -xt <tools>   Comma-separated denylist of tool names to disable
+                                 Applies to built-in, extension, and custom tools
   --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
   --extension, -e <path>         Load an extension file (can be used multiple times)
   --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
@@ -257,6 +278,9 @@ ${chalk.bold("Examples:")}
   # Continue previous session
   ${APP_NAME} --continue "What did we discuss?"
 
+  # Start a named session
+  ${APP_NAME} --name "Refactor auth module"
+
   # Use different model
   ${APP_NAME} --provider openai --model gpt-4o-mini "Help me refactor this code"
 
@@ -281,6 +305,9 @@ ${chalk.bold("Examples:")}
   # Read-only mode (no file modifications possible)
   ${APP_NAME} --tools read,grep,find,ls -p "Review the code in src/"
 
+  # Disable one tool while keeping the rest available
+  ${APP_NAME} --exclude-tools ask_question
+
   # Export a session file to HTML
   ${APP_NAME} --export ~/${CONFIG_DIR_NAME}/agent/sessions/--path--/session.jsonl
   ${APP_NAME} --export session.jsonl output.html

package/node_modules/@earendil-works/pi-coding-agent/dist/config.js

@@ -359,7 +359,15 @@ export function getInteractiveAssetsDir() {
 export function getBundledInteractiveAssetPath(name) {
     return join(getInteractiveAssetsDir(), name);
 }
-const pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+let pkg = {};
+try {
+    pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+}
+catch (e) {
+    const err = e;
+    if (err.code !== "ENOENT")
+        throw e;
+}
 const piConfigName = pkg.piConfig?.name;
 export const PACKAGE_NAME = pkg.name || "@earendil-works/pi-coding-agent";
 export const APP_NAME = piConfigName || "pi";

package/node_modules/@earendil-works/pi-coding-agent/dist/core/agent-session-services.js

@@ -110,6 +110,7 @@ export async function createAgentSessionFromServices(options) {
         thinkingLevel: options.thinkingLevel,
         scopedModels: options.scopedModels,
         tools: options.tools,
+        excludeTools: options.excludeTools,
         noTools: options.noTools,
         customTools: options.customTools,
         sessionStartEvent: options.sessionStartEvent,

package/node_modules/@earendil-works/pi-coding-agent/dist/core/agent-session.js

@@ -93,9 +93,11 @@ export class AgentSession {
     _extensionRunnerRef;
     _initialActiveToolNames;
     _allowedToolNames;
+    _excludedToolNames;
     _baseToolsOverride;
     _sessionStartEvent;
     _extensionUIContext;
+    _extensionMode = "print";
     _extensionCommandContextActions;
     _extensionAbortHandler;
     _extensionShutdownHandler;
@@ -123,6 +125,7 @@ export class AgentSession {
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
+        this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
         // Always subscribe to agent events for internal handling
@@ -467,6 +470,16 @@ export class AgentSession {
      * Call this when completely done with the session.
      */
     dispose() {
+        try {
+            this.abortRetry();
+            this.abortCompaction();
+            this.abortBranchSummary();
+            this.abortBash();
+            this.agent.abort();
+        }
+        catch {
+            // Dispose must succeed even if an abort hook throws.
+        }
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         this._disconnectFromAgent();
         this._eventListeners = [];
@@ -507,13 +520,14 @@ export class AgentSession {
         return this.agent.state.tools.map((t) => t.name);
     }
     /**
-     * Get all configured tools with name, description, parameter schema, and source metadata.
+     * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
      */
     getAllTools() {
         return Array.from(this._toolDefinitions.values()).map(({ definition, sourceInfo }) => ({
             name: definition.name,
             description: definition.description,
             parameters: definition.parameters,
+            promptGuidelines: definition.promptGuidelines,
             sourceInfo,
         }));
     }
@@ -668,7 +682,12 @@ export class AgentSession {
             });
             this._retryAttempt = 0;
         }
-        return await this._checkCompaction(msg);
+        if (await this._checkCompaction(msg)) {
+            return true;
+        }
+        // The agent loop drains both queues before emitting agent_end. Any messages
+        // here were queued by agent_end extension handlers and need a continuation.
+        return this.agent.hasQueuedMessages();
     }
     /**
      * Send a prompt to the agent.
@@ -698,7 +717,7 @@ export class AgentSession {
             let currentText = text;
             let currentImages = options?.images;
             if (this._extensionRunner.hasHandlers("input")) {
-                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive");
+                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive", this.isStreaming ? options?.streamingBehavior : undefined);
                 if (inputResult.action === "handled") {
                     preflightResult?.(true);
                     return;
@@ -1611,6 +1630,9 @@ export class AgentSession {
         if (bindings.uiContext !== undefined) {
             this._extensionUIContext = bindings.uiContext;
         }
+        if (bindings.mode !== undefined) {
+            this._extensionMode = bindings.mode;
+        }
         if (bindings.commandContextActions !== undefined) {
             this._extensionCommandContextActions = bindings.commandContextActions;
         }
@@ -1668,7 +1690,7 @@ export class AgentSession {
         return `extension:${name}`;
     }
     _applyExtensionBindings(runner) {
-        runner.setUIContext(this._extensionUIContext);
+        runner.setUIContext(this._extensionUIContext, this._extensionMode);
         runner.bindCommandContext(this._extensionCommandContextActions);
         this._extensionErrorUnsubscriber?.();
         this._extensionErrorUnsubscriber = this._extensionErrorListener
@@ -1781,6 +1803,7 @@ export class AgentSession {
                 })();
             },
             getSystemPrompt: () => this.systemPrompt,
+            getSystemPromptOptions: () => this._baseSystemPromptOptions,
         }, {
             registerProvider: (name, config) => {
                 this._modelRegistry.registerProvider(name, config);
@@ -1796,7 +1819,8 @@ export class AgentSession {
         const previousRegistryNames = new Set(this._toolRegistry.keys());
         const previousActiveToolNames = this.getActiveToolNames();
         const allowedToolNames = this._allowedToolNames;
-        const isAllowedTool = (name) => !allowedToolNames || allowedToolNames.has(name);
+        const excludedToolNames = this._excludedToolNames;
+        const isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name);
         const registeredTools = this._extensionRunner.getAllRegisteredTools();
         const allCustomTools = [
             ...registeredTools,

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/runner.js

@@ -92,6 +92,7 @@ export class ExtensionRunner {
     extensions;
     runtime;
     uiContext;
+    mode = "print";
     cwd;
     sessionManager;
     modelRegistry;
@@ -105,6 +106,7 @@ export class ExtensionRunner {
     getContextUsageFn = () => undefined;
     compactFn = () => { };
     getSystemPromptFn = () => "";
+    getSystemPromptOptionsFn = () => ({ cwd: this.cwd });
     newSessionHandler = async () => ({ cancelled: false });
     forkHandler = async () => ({ cancelled: false });
     navigateTreeHandler = async () => ({ cancelled: false });
@@ -148,6 +150,7 @@ export class ExtensionRunner {
         this.getContextUsageFn = contextActions.getContextUsage;
         this.compactFn = contextActions.compact;
         this.getSystemPromptFn = contextActions.getSystemPrompt;
+        this.getSystemPromptOptionsFn = contextActions.getSystemPromptOptions ?? (() => ({ cwd: this.cwd }));
         // Flush provider registrations queued during extension loading
         for (const { name, config, extensionPath } of this.runtime.pendingProviderRegistrations) {
             try {
@@ -202,8 +205,9 @@ export class ExtensionRunner {
         this.switchSessionHandler = async () => ({ cancelled: false });
         this.reloadHandler = async () => { };
     }
-    setUIContext(uiContext) {
+    setUIContext(uiContext, mode = "print") {
         this.uiContext = uiContext ?? noOpUIContext;
+        this.mode = mode;
     }
     getUIContext() {
         return this.uiContext;
@@ -382,6 +386,10 @@ export class ExtensionRunner {
                 runner.assertActive();
                 return runner.uiContext;
             },
+            get mode() {
+                runner.assertActive();
+                return runner.mode;
+            },
             get hasUI() {
                 runner.assertActive();
                 return runner.hasUI();
@@ -441,6 +449,10 @@ export class ExtensionRunner {
         // createContext() stay lazy. A spread would eagerly read them once and freeze the
         // old values into the returned object, bypassing stale-instance checks.
         const context = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
+        context.getSystemPromptOptions = () => {
+            this.assertActive();
+            return this.getSystemPromptOptionsFn();
+        };
         context.waitForIdle = () => {
             this.assertActive();
             return this.waitForIdleFn();
@@ -790,14 +802,20 @@ export class ExtensionRunner {
         return { skillPaths, promptPaths, themePaths };
     }
     /** Emit input event. Transforms chain, "handled" short-circuits. */
-    async emitInput(text, images, source) {
+    async emitInput(text, images, source, streamingBehavior) {
         const ctx = this.createContext();
         let currentText = text;
         let currentImages = images;
         for (const ext of this.extensions) {
             for (const handler of ext.handlers.get("input") ?? []) {
                 try {
-                    const event = { type: "input", text: currentText, images: currentImages, source };
+                    const event = {
+                        type: "input",
+                        text: currentText,
+                        images: currentImages,
+                        source,
+                        streamingBehavior,
+                    };
                     const result = (await handler(event, ctx));
                     if (result?.action === "handled")
                         return result;