@wingman-ai/gateway 0.5.2 → 0.5.4

package/dist/agent/tools/browser_session.js

@@ -0,0 +1,110 @@
+import { tool } from "langchain";
+import { object, string } from "zod";
+import { BrowserControlInputSchema, BrowserSessionActionInputSchema } from "./browser_runtime.js";
+const CloseBrowserSessionInputSchema = object({
+    session_id: string().min(1).describe("Existing browser session id to close")
+});
+const BrowserSessionListInputSchema = object({});
+const buildResponse = (payload)=>payload;
+const summarizeResult = (snapshot, summary)=>({
+        session_id: snapshot.sessionId,
+        status: snapshot.status,
+        transport_requested: snapshot.transportRequested,
+        transport_used: snapshot.transportUsed,
+        mode: snapshot.mode,
+        persistent_profile: snapshot.persistentProfile,
+        profile_id: snapshot.profileId || null,
+        profile_path: snapshot.profilePath || null,
+        reused_existing_session: snapshot.reusedExistingSession,
+        started_at: snapshot.startedAt,
+        updated_at: snapshot.updatedAt,
+        workspace: snapshot.workspace,
+        config_workspace: snapshot.configWorkspace,
+        final_url: summary?.finalUrl || snapshot.finalUrl || null,
+        title: summary?.title || snapshot.title || null,
+        fallback_reason: summary?.fallbackReason || null,
+        extensions: summary?.extensions || [],
+        action_results: summary?.actionResults || [],
+        browser: summary?.browser || null,
+        transport: summary?.transport || snapshot.transportUsed
+    });
+const createBrowserSessionStartTool = (options, dependencies = {})=>tool(async (input)=>{
+        try {
+            const { snapshot, summary } = await options.sessionManager.startSession({
+                ownerId: options.ownerId,
+                options,
+                dependencies,
+                input
+            });
+            return buildResponse({
+                ok: true,
+                ...summarizeResult(snapshot, summary)
+            });
+        } catch (error) {
+            return buildResponse({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "browser_session_start",
+        description: 'Start a managed browser session that persists across multiple tool calls. Use this for iterative QA/debugging where the same browser state should survive across turns. Transport can be selected per session with "auto", "playwright", or "relay".',
+        schema: BrowserControlInputSchema
+    });
+const createBrowserSessionActionTool = (options)=>tool(async (input)=>{
+        try {
+            const { session_id, ...actionInput } = input;
+            const { snapshot, summary } = await options.sessionManager.runSession({
+                ownerId: options.ownerId,
+                sessionId: session_id,
+                input: actionInput
+            });
+            return buildResponse({
+                ok: true,
+                ...summarizeResult(snapshot, summary)
+            });
+        } catch (error) {
+            return buildResponse({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "browser_session_action",
+        description: "Run browser actions inside an existing managed browser session. Use the session_id returned by browser_session_start to continue the same tab/profile state across multiple calls.",
+        schema: BrowserSessionActionInputSchema
+    });
+const createBrowserSessionCloseTool = (options)=>tool(async ({ session_id })=>{
+        try {
+            const snapshot = await options.sessionManager.closeSession({
+                ownerId: options.ownerId,
+                sessionId: session_id
+            });
+            return buildResponse({
+                ok: true,
+                closed: true,
+                ...summarizeResult(snapshot, null)
+            });
+        } catch (error) {
+            return buildResponse({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "browser_session_close",
+        description: "Close a managed browser session and release any temporary browser resources or profile locks owned by that session.",
+        schema: CloseBrowserSessionInputSchema
+    });
+const createBrowserSessionListTool = (options)=>tool(async ()=>{
+        const sessions = options.sessionManager.listSessions(options.ownerId);
+        return buildResponse({
+            ok: true,
+            sessions: sessions.map((snapshot)=>summarizeResult(snapshot, null))
+        });
+    }, {
+        name: "browser_session_list",
+        description: "List the managed browser sessions currently owned by this agent run. Use this to recover a session_id before continuing or closing a session.",
+        schema: BrowserSessionListInputSchema
+    });
+export { createBrowserSessionActionTool, createBrowserSessionCloseTool, createBrowserSessionListTool, createBrowserSessionStartTool };

package/dist/agent/tools/browser_session_manager.cjs

@@ -0,0 +1,202 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getSharedBrowserSessionManager: ()=>getSharedBrowserSessionManager,
+    BrowserSessionManager: ()=>BrowserSessionManager
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_browser_runtime_cjs_namespaceObject = require("./browser_runtime.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_MAX_SESSIONS_PER_OWNER = 3;
+const DEFAULT_IDLE_TIMEOUT_MS = 900000;
+class BrowserSessionManager {
+    async dispose() {
+        clearInterval(this.cleanupTimer);
+        const sessions = [
+            ...this.sessions.values()
+        ];
+        this.sessions.clear();
+        this.ownerIndex.clear();
+        await Promise.allSettled(sessions.map((record)=>(0, external_browser_runtime_cjs_namespaceObject.closeBrowserSessionRuntime)(record.runtime, record.dependencies)));
+    }
+    async startSession(input) {
+        const ownerId = this.normalizeOwnerId(input.ownerId);
+        const existing = this.ownerIndex.get(ownerId);
+        if ((existing?.size || 0) >= this.maxSessionsPerOwner) throw new Error(`Owner "${ownerId}" reached browser session limit (${this.maxSessionsPerOwner})`);
+        const runtime = await (0, external_browser_runtime_cjs_namespaceObject.openBrowserSessionRuntime)(input.options, input.dependencies, input.input);
+        const now = Date.now();
+        const sessionId = (0, external_node_crypto_namespaceObject.randomUUID)();
+        const record = {
+            sessionId,
+            ownerId,
+            runtime,
+            dependencies: input.dependencies || {},
+            startedAt: now,
+            updatedAt: now,
+            lastSummary: null,
+            closing: false
+        };
+        this.sessions.set(sessionId, record);
+        if (existing) existing.add(sessionId);
+        else this.ownerIndex.set(ownerId, new Set([
+            sessionId
+        ]));
+        try {
+            const summary = await (0, external_browser_runtime_cjs_namespaceObject.executeBrowserSessionRuntime)(runtime, input.input);
+            record.lastSummary = summary;
+            record.updatedAt = Date.now();
+            return {
+                snapshot: this.toSnapshot(record),
+                summary
+            };
+        } catch (error) {
+            await this.closeAndDelete(record);
+            throw error;
+        }
+    }
+    async runSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        const summary = await (0, external_browser_runtime_cjs_namespaceObject.executeBrowserSessionRuntime)(record.runtime, input.input);
+        record.lastSummary = summary;
+        record.updatedAt = Date.now();
+        return {
+            snapshot: this.toSnapshot(record),
+            summary
+        };
+    }
+    async closeSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        const snapshot = this.toSnapshot(record);
+        await this.closeAndDelete(record);
+        return snapshot;
+    }
+    listSessions(ownerId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const sessionIds = this.ownerIndex.get(normalizedOwnerId);
+        if (!sessionIds || 0 === sessionIds.size) return [];
+        return [
+            ...sessionIds
+        ].map((sessionId)=>this.sessions.get(sessionId)).filter((record)=>Boolean(record)).sort((a, b)=>b.updatedAt - a.updatedAt).map((record)=>this.toSnapshot(record));
+    }
+    async cleanupExpiredSessions() {
+        const now = Date.now();
+        const expired = [
+            ...this.sessions.values()
+        ].filter((record)=>!record.closing && now - record.updatedAt > this.idleTimeoutMs);
+        await Promise.allSettled(expired.map((record)=>this.closeAndDelete(record)));
+    }
+    async closeAndDelete(record) {
+        if (record.closing) return;
+        record.closing = true;
+        try {
+            await (0, external_browser_runtime_cjs_namespaceObject.closeBrowserSessionRuntime)(record.runtime, record.dependencies);
+        } finally{
+            this.sessions.delete(record.sessionId);
+            const ownerSessions = this.ownerIndex.get(record.ownerId);
+            if (ownerSessions) {
+                ownerSessions.delete(record.sessionId);
+                if (0 === ownerSessions.size) this.ownerIndex.delete(record.ownerId);
+            }
+        }
+    }
+    getOwnedRecord(ownerId, sessionId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const record = this.sessions.get(sessionId);
+        if (!record) throw new Error(`Browser session ${sessionId} was not found`);
+        if (record.ownerId !== normalizedOwnerId) throw new Error(`Browser session ${sessionId} is not accessible`);
+        if (record.closing) throw new Error(`Browser session ${sessionId} is closing`);
+        return record;
+    }
+    toSnapshot(record) {
+        return {
+            sessionId: record.sessionId,
+            ownerId: record.ownerId,
+            workspace: record.runtime.workspace,
+            configWorkspace: record.runtime.configWorkspace,
+            status: "running",
+            startedAt: record.startedAt,
+            updatedAt: record.updatedAt,
+            transportRequested: record.runtime.transportRequested,
+            transportUsed: record.runtime.browserTransport,
+            mode: record.runtime.headless ? "headless" : "headed",
+            persistentProfile: record.runtime.userDataDirSelection.persistentProfile,
+            ...record.runtime.userDataDirSelection.profileId ? {
+                profileId: record.runtime.userDataDirSelection.profileId
+            } : {},
+            ...record.runtime.userDataDirSelection.persistentProfile ? {
+                profilePath: record.runtime.userDataDirSelection.userDataDir
+            } : {},
+            reusedExistingSession: record.runtime.reusedExistingCdpSession,
+            ...record.lastSummary?.finalUrl ? {
+                finalUrl: record.lastSummary.finalUrl
+            } : {},
+            ...record.lastSummary?.title ? {
+                title: record.lastSummary.title
+            } : {}
+        };
+    }
+    normalizeOwnerId(ownerId) {
+        const trimmed = ownerId.trim();
+        if (!trimmed) throw new Error("Browser ownerId is required");
+        return trimmed;
+    }
+    constructor(options = {}){
+        _define_property(this, "sessions", new Map());
+        _define_property(this, "ownerIndex", new Map());
+        _define_property(this, "cleanupTimer", void 0);
+        _define_property(this, "maxSessionsPerOwner", void 0);
+        _define_property(this, "idleTimeoutMs", void 0);
+        this.maxSessionsPerOwner = options.maxSessionsPerOwner ?? DEFAULT_MAX_SESSIONS_PER_OWNER;
+        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+        this.cleanupTimer = setInterval(()=>{
+            this.cleanupExpiredSessions();
+        }, 60000);
+        this.cleanupTimer.unref?.();
+    }
+}
+let sharedBrowserSessionManager = null;
+const getSharedBrowserSessionManager = ()=>{
+    if (!sharedBrowserSessionManager) sharedBrowserSessionManager = new BrowserSessionManager();
+    return sharedBrowserSessionManager;
+};
+exports.BrowserSessionManager = __webpack_exports__.BrowserSessionManager;
+exports.getSharedBrowserSessionManager = __webpack_exports__.getSharedBrowserSessionManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BrowserSessionManager",
+    "getSharedBrowserSessionManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tools/browser_session_manager.d.ts

@@ -0,0 +1,64 @@
+import { type BrowserControlDependencies, type BrowserControlInput, type BrowserControlToolOptions, type BrowserExecutionSummary, type BrowserRuntimeTransport, type BrowserTransportPreference } from "./browser_runtime.js";
+export interface BrowserSessionSnapshot {
+    sessionId: string;
+    ownerId: string;
+    workspace: string;
+    configWorkspace: string;
+    status: "running";
+    startedAt: number;
+    updatedAt: number;
+    transportRequested: BrowserTransportPreference;
+    transportUsed: BrowserRuntimeTransport;
+    mode: "headless" | "headed";
+    persistentProfile: boolean;
+    profileId?: string;
+    profilePath?: string;
+    reusedExistingSession: boolean;
+    finalUrl?: string;
+    title?: string;
+}
+export interface BrowserSessionManagerOptions {
+    maxSessionsPerOwner?: number;
+    idleTimeoutMs?: number;
+}
+interface StartBrowserSessionInput {
+    ownerId: string;
+    options: BrowserControlToolOptions;
+    dependencies?: Partial<BrowserControlDependencies>;
+    input: BrowserControlInput;
+}
+interface RunBrowserSessionInput {
+    ownerId: string;
+    sessionId: string;
+    input: Pick<BrowserControlInput, "url" | "actions" | "timeoutMs">;
+}
+interface CloseBrowserSessionInput {
+    ownerId: string;
+    sessionId: string;
+}
+export declare class BrowserSessionManager {
+    private readonly sessions;
+    private readonly ownerIndex;
+    private readonly cleanupTimer;
+    private readonly maxSessionsPerOwner;
+    private readonly idleTimeoutMs;
+    constructor(options?: BrowserSessionManagerOptions);
+    dispose(): Promise<void>;
+    startSession(input: StartBrowserSessionInput): Promise<{
+        snapshot: BrowserSessionSnapshot;
+        summary: BrowserExecutionSummary;
+    }>;
+    runSession(input: RunBrowserSessionInput): Promise<{
+        snapshot: BrowserSessionSnapshot;
+        summary: BrowserExecutionSummary;
+    }>;
+    closeSession(input: CloseBrowserSessionInput): Promise<BrowserSessionSnapshot>;
+    listSessions(ownerId: string): BrowserSessionSnapshot[];
+    private cleanupExpiredSessions;
+    private closeAndDelete;
+    private getOwnedRecord;
+    private toSnapshot;
+    private normalizeOwnerId;
+}
+export declare const getSharedBrowserSessionManager: () => BrowserSessionManager;
+export {};

package/dist/agent/tools/browser_session_manager.js

@@ -0,0 +1,165 @@
+import { randomUUID } from "node:crypto";
+import { closeBrowserSessionRuntime, executeBrowserSessionRuntime, openBrowserSessionRuntime } from "./browser_runtime.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_MAX_SESSIONS_PER_OWNER = 3;
+const DEFAULT_IDLE_TIMEOUT_MS = 900000;
+class BrowserSessionManager {
+    async dispose() {
+        clearInterval(this.cleanupTimer);
+        const sessions = [
+            ...this.sessions.values()
+        ];
+        this.sessions.clear();
+        this.ownerIndex.clear();
+        await Promise.allSettled(sessions.map((record)=>closeBrowserSessionRuntime(record.runtime, record.dependencies)));
+    }
+    async startSession(input) {
+        const ownerId = this.normalizeOwnerId(input.ownerId);
+        const existing = this.ownerIndex.get(ownerId);
+        if ((existing?.size || 0) >= this.maxSessionsPerOwner) throw new Error(`Owner "${ownerId}" reached browser session limit (${this.maxSessionsPerOwner})`);
+        const runtime = await openBrowserSessionRuntime(input.options, input.dependencies, input.input);
+        const now = Date.now();
+        const sessionId = randomUUID();
+        const record = {
+            sessionId,
+            ownerId,
+            runtime,
+            dependencies: input.dependencies || {},
+            startedAt: now,
+            updatedAt: now,
+            lastSummary: null,
+            closing: false
+        };
+        this.sessions.set(sessionId, record);
+        if (existing) existing.add(sessionId);
+        else this.ownerIndex.set(ownerId, new Set([
+            sessionId
+        ]));
+        try {
+            const summary = await executeBrowserSessionRuntime(runtime, input.input);
+            record.lastSummary = summary;
+            record.updatedAt = Date.now();
+            return {
+                snapshot: this.toSnapshot(record),
+                summary
+            };
+        } catch (error) {
+            await this.closeAndDelete(record);
+            throw error;
+        }
+    }
+    async runSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        const summary = await executeBrowserSessionRuntime(record.runtime, input.input);
+        record.lastSummary = summary;
+        record.updatedAt = Date.now();
+        return {
+            snapshot: this.toSnapshot(record),
+            summary
+        };
+    }
+    async closeSession(input) {
+        const record = this.getOwnedRecord(input.ownerId, input.sessionId);
+        const snapshot = this.toSnapshot(record);
+        await this.closeAndDelete(record);
+        return snapshot;
+    }
+    listSessions(ownerId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const sessionIds = this.ownerIndex.get(normalizedOwnerId);
+        if (!sessionIds || 0 === sessionIds.size) return [];
+        return [
+            ...sessionIds
+        ].map((sessionId)=>this.sessions.get(sessionId)).filter((record)=>Boolean(record)).sort((a, b)=>b.updatedAt - a.updatedAt).map((record)=>this.toSnapshot(record));
+    }
+    async cleanupExpiredSessions() {
+        const now = Date.now();
+        const expired = [
+            ...this.sessions.values()
+        ].filter((record)=>!record.closing && now - record.updatedAt > this.idleTimeoutMs);
+        await Promise.allSettled(expired.map((record)=>this.closeAndDelete(record)));
+    }
+    async closeAndDelete(record) {
+        if (record.closing) return;
+        record.closing = true;
+        try {
+            await closeBrowserSessionRuntime(record.runtime, record.dependencies);
+        } finally{
+            this.sessions.delete(record.sessionId);
+            const ownerSessions = this.ownerIndex.get(record.ownerId);
+            if (ownerSessions) {
+                ownerSessions.delete(record.sessionId);
+                if (0 === ownerSessions.size) this.ownerIndex.delete(record.ownerId);
+            }
+        }
+    }
+    getOwnedRecord(ownerId, sessionId) {
+        const normalizedOwnerId = this.normalizeOwnerId(ownerId);
+        const record = this.sessions.get(sessionId);
+        if (!record) throw new Error(`Browser session ${sessionId} was not found`);
+        if (record.ownerId !== normalizedOwnerId) throw new Error(`Browser session ${sessionId} is not accessible`);
+        if (record.closing) throw new Error(`Browser session ${sessionId} is closing`);
+        return record;
+    }
+    toSnapshot(record) {
+        return {
+            sessionId: record.sessionId,
+            ownerId: record.ownerId,
+            workspace: record.runtime.workspace,
+            configWorkspace: record.runtime.configWorkspace,
+            status: "running",
+            startedAt: record.startedAt,
+            updatedAt: record.updatedAt,
+            transportRequested: record.runtime.transportRequested,
+            transportUsed: record.runtime.browserTransport,
+            mode: record.runtime.headless ? "headless" : "headed",
+            persistentProfile: record.runtime.userDataDirSelection.persistentProfile,
+            ...record.runtime.userDataDirSelection.profileId ? {
+                profileId: record.runtime.userDataDirSelection.profileId
+            } : {},
+            ...record.runtime.userDataDirSelection.persistentProfile ? {
+                profilePath: record.runtime.userDataDirSelection.userDataDir
+            } : {},
+            reusedExistingSession: record.runtime.reusedExistingCdpSession,
+            ...record.lastSummary?.finalUrl ? {
+                finalUrl: record.lastSummary.finalUrl
+            } : {},
+            ...record.lastSummary?.title ? {
+                title: record.lastSummary.title
+            } : {}
+        };
+    }
+    normalizeOwnerId(ownerId) {
+        const trimmed = ownerId.trim();
+        if (!trimmed) throw new Error("Browser ownerId is required");
+        return trimmed;
+    }
+    constructor(options = {}){
+        _define_property(this, "sessions", new Map());
+        _define_property(this, "ownerIndex", new Map());
+        _define_property(this, "cleanupTimer", void 0);
+        _define_property(this, "maxSessionsPerOwner", void 0);
+        _define_property(this, "idleTimeoutMs", void 0);
+        this.maxSessionsPerOwner = options.maxSessionsPerOwner ?? DEFAULT_MAX_SESSIONS_PER_OWNER;
+        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+        this.cleanupTimer = setInterval(()=>{
+            this.cleanupExpiredSessions();
+        }, 60000);
+        this.cleanupTimer.unref?.();
+    }
+}
+let sharedBrowserSessionManager = null;
+const getSharedBrowserSessionManager = ()=>{
+    if (!sharedBrowserSessionManager) sharedBrowserSessionManager = new BrowserSessionManager();
+    return sharedBrowserSessionManager;
+};
+export { BrowserSessionManager, getSharedBrowserSessionManager };

package/dist/cli/commands/init.cjs

@@ -52,12 +52,16 @@ const schema_cjs_namespaceObject = require("../config/schema.cjs");
 const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
 const DEFAULT_AGENT_ID = "wingman";
 const DEFAULT_AGENT_DESCRIPTION = "General-purpose coding assistant for this workspace.";
-const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.";
+const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.\nUse browser_session_start/browser_session_action/browser_session_close for iterative browser debugging across turns, and browser_control for one-shot browser tasks.";
 const DEFAULT_TOOLS = [
     "code_search",
     "git_status",
     "command_execute",
     "browser_control",
+    "browser_session_start",
+    "browser_session_action",
+    "browser_session_close",
+    "browser_session_list",
     "internet_search",
     "think"
 ];

package/dist/cli/commands/init.js

@@ -11,12 +11,16 @@ import { WingmanConfigSchema } from "../config/schema.js";
 import { OutputManager } from "../core/outputManager.js";
 const DEFAULT_AGENT_ID = "wingman";
 const DEFAULT_AGENT_DESCRIPTION = "General-purpose coding assistant for this workspace.";
-const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.";
+const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.\nUse browser_session_start/browser_session_action/browser_session_close for iterative browser debugging across turns, and browser_control for one-shot browser tasks.";
 const DEFAULT_TOOLS = [
     "code_search",
     "git_status",
     "command_execute",
     "browser_control",
+    "browser_session_start",
+    "browser_session_action",
+    "browser_session_close",
+    "browser_session_list",
     "internet_search",
     "think"
 ];

package/dist/cli/config/loader.cjs

@@ -91,11 +91,6 @@ class WingmanConfigLoader {
         return {
             logLevel: "info",
             recursionLimit: 5000,
-            summarization: {
-                enabled: true,
-                maxTokensBeforeSummary: 12000,
-                messagesToKeep: 8
-            },
             modelRetry: {
                 enabled: true,
                 maxRetries: 2,

package/dist/cli/config/loader.js

@@ -63,11 +63,6 @@ class WingmanConfigLoader {
         return {
             logLevel: "info",
             recursionLimit: 5000,
-            summarization: {
-                enabled: true,
-                maxTokensBeforeSummary: 12000,
-                messagesToKeep: 8
-            },
             modelRetry: {
                 enabled: true,
                 maxRetries: 2,

package/dist/cli/config/schema.cjs

@@ -141,8 +141,8 @@ const BrowserConfigSchema = external_zod_namespaceObject.object({
 });
 const SummarizationConfigSchema = external_zod_namespaceObject.object({
     enabled: external_zod_namespaceObject.boolean().optional().default(true).describe("Enable conversation history summarization"),
-    maxTokensBeforeSummary: external_zod_namespaceObject.number().min(1000).max(1000000).optional().default(12000).describe("Token threshold before summarizing conversation history"),
-    messagesToKeep: external_zod_namespaceObject.number().min(2).max(100).optional().default(8).describe("How many most recent messages to keep after summarization")
+    maxTokensBeforeSummary: external_zod_namespaceObject.number().min(1000).max(1000000).optional().describe("Token threshold before summarizing conversation history"),
+    messagesToKeep: external_zod_namespaceObject.number().min(2).max(100).optional().describe("How many most recent messages to keep after summarization")
 });
 const RetryOnFailureSchema = external_zod_namespaceObject["enum"]([
     "continue",
@@ -382,11 +382,7 @@ const WingmanConfigSchema = external_zod_namespaceObject.object({
     ]).optional().default("info"),
     defaultAgent: external_zod_namespaceObject.string().optional(),
     recursionLimit: external_zod_namespaceObject.number().min(1).max(1000000).optional().default(5000),
-    summarization: SummarizationConfigSchema.optional().default({
-        enabled: true,
-        maxTokensBeforeSummary: 12000,
-        messagesToKeep: 8
-    }),
+    summarization: SummarizationConfigSchema.optional(),
     modelRetry: ModelRetryConfigSchema.optional().default({
         enabled: true,
         maxRetries: 2,

package/dist/cli/config/schema.d.ts

@@ -64,8 +64,8 @@ export declare const BrowserConfigSchema: z.ZodObject<{
 export type BrowserConfig = z.infer<typeof BrowserConfigSchema>;
 export declare const SummarizationConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    maxTokensBeforeSummary: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    messagesToKeep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;
+    messagesToKeep: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type SummarizationConfig = z.infer<typeof SummarizationConfigSchema>;
 export declare const ModelRetryConfigSchema: z.ZodObject<{
@@ -218,11 +218,11 @@ export declare const WingmanConfigSchema: z.ZodObject<{
     }>>>;
     defaultAgent: z.ZodOptional<z.ZodString>;
     recursionLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    summarization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    summarization: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        maxTokensBeforeSummary: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        messagesToKeep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>>>;
+        maxTokensBeforeSummary: z.ZodOptional<z.ZodNumber>;
+        messagesToKeep: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     modelRetry: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;