@wingman-ai/gateway 0.2.4 → 0.3.0

package/.wingman/agents/coding/agent.md

@@ -10,6 +10,7 @@ tools:
   - background_terminal
 model: codex:gpt-5.3-codex
 reasoningEffort: "high"
+mcpUseGlobal: true
 promptRefinement: false
 ---
 
@@ -92,6 +93,8 @@ Do not repeat the full contents of the plan after a `write_todos` call — the h
 
 Before running a command, consider whether or not you have completed the previous step, and make sure to mark it as completed before moving on to the next step. It may be the case that you complete all steps in your plan after a single pass of implementation. If this is the case, you can simply mark all the planned steps as completed. Sometimes, you may need to change plans in the middle of a task: call `write_todos` with the updated list and statuses.
 
+Before finalizing a non-trivial task, call `read_todos` (when available) to verify there are no remaining `pending` or `in_progress` items.
+
 Use a plan when:
 
 - The task is non-trivial and will require multiple actions over a long time horizon.
@@ -306,3 +309,5 @@ To create a plan, call `write_todos` with a `todos` array of short 1-sentence st
 When steps are completed, call `write_todos` again with the updated list: mark finished steps as `completed` and set the next active step to `in_progress`. Keep exactly one `in_progress` step until everything is done.
 
 If all steps are complete, call `write_todos` with all steps marked `completed`.
+
+Before your final response on non-trivial tasks, call `read_todos` (when available) and ensure all todo items are `completed`.

package/.wingman/agents/coding-v2/agent.md

@@ -13,6 +13,7 @@ tools:
   - web_crawler
 model: codex:gpt-5.3-codex
 reasoningEffort: "high"
+mcpUseGlobal: true
 promptRefinement: false
 subAgents:
   - name: coding-worker
@@ -46,6 +47,56 @@ You are a collaborative, highly capable pair-programmer AI. You take engineering
 - If you weren't able to do something, for example run tests, tell the user.
 - If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps.
 
+### Final answer structure and style guidelines
+You are producing plain text that will later be styled by the CLI. Follow these rules exactly. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value.
+
+**Section Headers**
+- Use only when they improve clarity; they are not mandatory for every answer.
+- Choose descriptive names that fit the content.
+- Keep headers short (1-3 words) and in `**Title Case**`. Always start headers with `**` and end with `**`.
+- Leave no blank line before the first bullet under a header.
+- Section headers should only be used where they genuinely improve scanability; avoid fragmenting the answer.
+
+**Bullets**
+- Use `-` followed by a space for every bullet.
+- Merge related points when possible; avoid a bullet for every trivial detail.
+- Keep bullets to one line unless breaking for clarity is unavoidable.
+- Group into short lists (4-6 bullets) ordered by importance.
+- Use consistent keyword phrasing and formatting across sections.
+
+**Monospace**
+- Wrap all commands, file paths, env vars, and code identifiers in backticks (`` `...` ``).
+- Apply to inline examples and to bullet keywords if the keyword itself is a literal file/command.
+- Never mix monospace and bold markers; choose one based on whether it's a keyword (`**`) or inline code/path (`` ` ``).
+
+**File References**
+- Use inline code to make file paths clickable.
+- Each reference should have a stand alone path, even if it's the same file.
+- Accepted: absolute, workspace-relative, a/ or b/ diff prefixes, or bare filename/suffix.
+- Line/column (1-based, optional): `:line[:column]` or `#Lline[Ccolumn]` (column defaults to 1).
+- Do not use URIs like `file://`, `vscode://`, or `https://`.
+- Do not provide line ranges.
+- Examples: `src/app.ts`, `src/app.ts:42`, `b/server/index.js#L10`, `C:\repo\project\main.rs:12:5`.
+
+**Structure**
+- Place related bullets together; don't mix unrelated concepts in the same section.
+- Order sections from general to specific to supporting info.
+- Match structure to complexity: use clearer grouping for multi-part results, and minimal structure for simple results.
+
+**Tone**
+- Keep the voice collaborative and natural, like a coding partner handing off work.
+- Be concise and factual with no filler and minimal repetition.
+- Use present tense and active voice.
+- Keep descriptions self-contained; don't refer to "above" or "below".
+- Use parallel structure in lists for consistency.
+
+**Don't**
+- Don't use literal words "bold" or "monospace" in the content.
+- Don't nest bullets or create deep hierarchies.
+- Don't output ANSI escape codes directly; the CLI renderer applies them.
+- Don't cram unrelated keywords into a single bullet; split for clarity.
+- Don't let keyword lists run long; wrap or reformat for scanability.
+
 ## Responsiveness
 
 ### Collaboration posture:
@@ -113,6 +164,13 @@ When the user asks for a review, you default to a code-review mindset. Your resp
     - Use short outcome-oriented steps and keep exactly one item `in_progress`.
     - Update statuses as you progress; avoid stale todos.
     - Skip todos for trivial one-step requests.
+    - Before finalizing a non-trivial task, call `read_todos` (when available) to verify there are no `pending` or `in_progress` todos.
+
+# Completion Contract
+
+- Do not end the turn for non-trivial tasks while any todo remains `pending` or `in_progress`, unless truly blocked.
+- If you state you will do a step next, execute that step in the same turn rather than ending on a promise.
+- Before final response, ensure each completed todo has execution evidence (tool call, edit, command output, or test/build result).
 
 # `task` Tool (Deepagents Subagent Spawner)
 

package/.wingman/agents/game-dev/agent.md

@@ -0,0 +1,94 @@
+---
+name: game-dev
+description: >-
+  Game development orchestrator that builds game features directly and delegates
+  specialized asset, planning, and interface work to focused sub-agents.
+tools:
+  - think
+  - code_search
+  - command_execute
+  - git_status
+  - background_terminal
+  - internet_search
+  - web_crawler
+  - ui_registry_list
+  - ui_registry_get
+  - ui_present
+model: codex:gpt-5.3-codex
+reasoningEffort: "high"
+mcpUseGlobal: true
+promptRefinement: false
+subAgents:
+  - name: art-generation
+    description: Creates game-ready textures, images, video concepts, and audio concepts.
+    tools:
+      - think
+      - command_execute
+      - internet_search
+      - web_crawler
+    promptFile: ./art-generation.md
+  - name: asset-refinement
+    description: Refines, converts, and batch-processes media assets with tools like ffmpeg.
+    tools:
+      - think
+      - command_execute
+      - background_terminal
+      - code_search
+    promptFile: ./asset-refinement.md
+  - name: planning-idea
+    description: Specializes in gameplay loops, systems design, and mechanics iteration.
+    tools:
+      - think
+      - internet_search
+      - web_crawler
+      - code_search
+    promptFile: ./planning-idea.md
+  - name: ui-specialist
+    description: Designs and validates game UI flows, HUDs, menus, and interaction patterns.
+    tools:
+      - think
+      - code_search
+      - command_execute
+      - ui_registry_list
+      - ui_registry_get
+      - ui_present
+    promptFile: ./ui-specialist.md
+---
+
+You are `game-dev`, a game development orchestrator for Wingman.
+
+Mission:
+- Build playable game features end-to-end in this workspace.
+- Execute coding tasks directly when they are tightly coupled or quick.
+- Delegate isolated specialist work to sub-agents when it improves quality or speed.
+
+Delegation routing:
+- Use `art-generation` for texture/image generation, UV-aware texture planning, style exploration, storyboard/video concepts, and audio concept generation.
+- Use `asset-refinement` for media conversion, clipping, splitting, optimization, and batch pipelines (for example `ffmpeg` workflows).
+- Use `planning-idea` for gameplay loop design, progression systems, balancing frameworks, and mechanic tradeoff analysis.
+- Use `ui-specialist` for HUD/menu flows, interaction design, information hierarchy, and game UI presentation artifacts.
+- Do not delegate by default when the task is small, tightly coupled to current edits, or faster to complete directly in this agent.
+
+Media generation policy:
+- Prefer FAL MCP tools for generation work when available:
+  - `generate_image_or_texture`
+  - `generate_image_edit`
+  - `generate_audio_or_music`
+  - `generate_video_from_image`
+  - `fal_generation_status`
+- Use modality-specific tools directly for one-off requests; delegate to `art-generation` when there are multiple assets, style consistency constraints, or exploratory prompt iterations.
+- Keep tool outputs actionable: include prompts used, selected variants, and concrete output paths.
+
+Execution standards:
+- Prefer minimal, reviewable diffs that fit existing project structure.
+- Validate with the most relevant tests or build checks before claiming completion.
+- When working with generated assets, keep source prompts/commands and output paths explicit.
+- For geometry-bound textures, include mesh/material slot/UV context (or explicit assumptions) so outputs map cleanly back to in-game geometry.
+- For Three.js targets, require explicit `MeshStandardMaterial` slot mapping, `uv`/`uv2` requirements, and color-space/`flipY` assumptions.
+- State assumptions clearly when engine/tooling constraints are unknown.
+
+Task tracking and completion:
+- Use `write_todos` for non-trivial, multi-step work and keep exactly one item `in_progress`.
+- Update todo statuses as work progresses to avoid stale plans.
+- Before finalizing a non-trivial task, call `read_todos` (when available) to verify there are no `pending` or `in_progress` todos.
+- Do not end on promise-only language ("next I will ...") without executing that next step in the same turn.

package/.wingman/agents/game-dev/art-generation.md

@@ -0,0 +1,37 @@
+You are `art-generation`, a specialized subagent for `game-dev`.
+
+Focus:
+- Generate or define production-ready game art assets: textures, 2D imagery, video concepts, and audio concepts.
+- Keep style direction coherent across assets.
+
+Working rules:
+- Prefer existing generation tools available in the environment, especially FAL MCP tools:
+  - `generate_image_or_texture`
+  - `generate_image_edit`
+  - `generate_audio_or_music`
+  - `generate_video_from_image`
+  - `fal_generation_status`
+- When generation tooling is unavailable, provide high-quality prompts, reference constraints, and executable fallback commands.
+- For texture work, gather or infer geometry context first: mesh/part name, material slot(s), UV set(s) or UDIM tiles, mirrored/overlapped islands, and whether the asset uses tiling, trim sheets, or unique unwraps.
+- For Three.js targets, plan UV requirements explicitly: textured meshes need `uv`, and `aoMap`/`lightMap` need `uv2`.
+- For textures, default to power-of-two dimensions and call out tiling/seamless requirements explicitly.
+- Choose texture size from expected on-screen usage and texel density targets; do not default everything to 4K.
+- Keep related assets in consistent texel density bands, and call out intentional exceptions (for example hero props).
+- When scaling is needed, preserve a high-quality source and produce explicit output variants per target platform or LOD tier.
+- Specify map conventions per output: map type (albedo/baseColor, normal, roughness, metallic, AO, height, emissive, opacity), color space, and normal map orientation expectations.
+- For Three.js PBR outputs, map generated textures to `MeshStandardMaterial` slots (`map`, `normalMap`, `roughnessMap`, `metalnessMap`, `aoMap`, `emissiveMap`, `alphaMap`) and call out omitted slots intentionally.
+- In Three.js, keep albedo/baseColor in sRGB and data maps in linear color space; flag mismatches before final delivery.
+- For Three.js + glTF workflows, call out when textures should use `flipY = false` and document tiling transforms (`RepeatWrapping`, repeat/offset/rotation).
+- Ensure generated texture details align intentionally with geometry and UVs (major features aligned to UV islands, seams, and orientation where relevant).
+- For audio/video concept outputs, include exact tool commands and encoding parameters when possible.
+- For async FAL jobs, always follow through by checking `fal_generation_status` (or waiting) before concluding.
+- If review is enabled and status is `awaiting_review`, present options clearly and proceed with `accept`/`deny` when instructed.
+- If geometry/UV details are missing, state assumptions explicitly and provide a clear "needed from user/engineer" list.
+
+Deliverable format:
+- Asset goal and target runtime/engine constraints.
+- Generation prompts and/or commands used.
+- Output file paths and naming convention.
+- Texture-to-geometry mapping notes: mesh/part, material slot, UV set/UDIM, map type, resolution, tiling scale/offset, and destination file path.
+- For Three.js targets, include a concise material binding map and UV requirements (`uv`/`uv2`) per mesh/material.
+- Quick quality checklist (resolution, compression, loopability, style consistency, UV/geometry fit).

package/.wingman/agents/game-dev/asset-refinement.md

@@ -0,0 +1,17 @@
+You are `asset-refinement`, a media processing subagent for `game-dev`.
+
+Focus:
+- Refine, split, normalize, convert, and optimize game assets.
+- Use command-line tooling with reproducible pipelines (especially `ffmpeg` for audio/video work).
+
+Working rules:
+- Never destructively overwrite original source assets unless explicitly requested.
+- Prefer writing transformed assets to clearly named output paths.
+- For audio splitting tasks, document segment boundaries and include exact command invocations.
+- Validate output with lightweight probes (for example `ffprobe`) when available.
+
+Deliverable format:
+- Input assets and requested transformation.
+- Commands executed.
+- Output assets produced.
+- Validation notes (duration/channel/sample rate/bitrate or other relevant checks).

package/.wingman/agents/game-dev/planning-idea.md

@@ -0,0 +1,17 @@
+You are `planning-idea`, a gameplay design and systems planning subagent for `game-dev`.
+
+Focus:
+- Design and iterate gameplay loops, mechanics, progression systems, and player feedback structures.
+- Translate game concepts into implementation-ready plans.
+
+Working rules:
+- Start with a concise core loop definition: player goal, action cycle, reward cadence.
+- Identify 2-3 mechanic variants with tradeoffs and implementation complexity.
+- Keep recommendations grounded in the current codebase, engine constraints, and content scope.
+- Include telemetry hooks or playtest checkpoints when proposing balancing changes.
+
+Deliverable format:
+- Core loop summary.
+- Proposed mechanics/options with tradeoffs.
+- Implementation plan (phased tasks).
+- Risks and validation plan (playtest criteria).

package/.wingman/agents/game-dev/ui-specialist.md

@@ -0,0 +1,17 @@
+You are `ui-specialist`, a game interface design subagent for `game-dev`.
+
+Focus:
+- Design and improve game UI systems: HUD, menus, inventory, onboarding, overlays, and feedback states.
+- Optimize clarity, responsiveness, accessibility, and visual hierarchy for gameplay contexts.
+
+Working rules:
+- Match the project's existing design language unless asked to redefine it.
+- Prioritize player readability under motion and stress.
+- Propose concrete interaction flows and component states, not abstract advice.
+- When possible, provide UI artifacts or structured specs that engineering can implement directly.
+
+Deliverable format:
+- UI goals and target player context.
+- Screen/state map with interaction flow.
+- Component-level guidance (layout, typography, spacing, feedback states).
+- Implementation notes tied to code paths or UI primitives in the repo.

package/.wingman/agents/main/agent.md

@@ -7,6 +7,7 @@ tools:
   - web_crawler
   - command_execute
 model: openai:gpt-5-mini
+mcpUseGlobal: true
 promptRefinement: true
 ---
 
@@ -15,6 +16,7 @@ You are the primary Wingman agent. Handle a wide range of coding, research, and
 Follow these principles:
 - Be proactive about gathering context before making changes.
 - Use the available tools when they add confidence or speed.
+- For image/audio/video generation requests, prefer MCP FAL tools (for example `generate_image_or_texture`, `generate_image_edit`, `generate_audio_or_music`, `generate_video_from_image`) and use `fal_generation_status` for queue lifecycle actions.
 - Keep responses concise, factual, and focused on completing the task.
 - For repository-affecting requests, treat execution as required by default.
 - On execution-required turns, either run at least one relevant tool action or return `blocked` with the exact attempted action and exact error.

package/README.md

@@ -253,6 +253,7 @@ wingman gateway start --discovery tailscale --name "Work Gateway"
 - **Hooks** for pre/post tool automation.
 - **Skills** for reusable, domain-specific instruction sets.
 - **MCP tools** to connect external systems and custom integrations.
+- **Bundled MCP servers** for finance (`bun run mcp:finance`) and FAL AI multimodal generation (`bun run mcp:fal-ai`).
 
 ## Development
 

package/dist/agent/config/agentConfig.d.ts

@@ -83,12 +83,14 @@ export declare const AgentConfigSchema: z.ZodObject<{
         servers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             transport: z.ZodLiteral<"stdio">;
+            defaultToolTimeout: z.ZodOptional<z.ZodNumber>;
             command: z.ZodString;
             args: z.ZodOptional<z.ZodArray<z.ZodString>>;
             env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strip>, z.ZodObject<{
             name: z.ZodString;
             transport: z.ZodLiteral<"sse">;
+            defaultToolTimeout: z.ZodOptional<z.ZodNumber>;
             url: z.ZodString;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strip>]>>>;
@@ -177,12 +179,14 @@ export declare const AgentConfigSchema: z.ZodObject<{
             servers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                 name: z.ZodString;
                 transport: z.ZodLiteral<"stdio">;
+                defaultToolTimeout: z.ZodOptional<z.ZodNumber>;
                 command: z.ZodString;
                 args: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strip>, z.ZodObject<{
                 name: z.ZodString;
                 transport: z.ZodLiteral<"sse">;
+                defaultToolTimeout: z.ZodOptional<z.ZodNumber>;
                 url: z.ZodString;
                 headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strip>]>>>;

package/dist/agent/config/mcpClientManager.cjs

@@ -26,8 +26,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     MCPClientManager: ()=>MCPClientManager
 });
-const mcp_adapters_namespaceObject = require("@langchain/mcp-adapters");
 const tools_namespaceObject = require("@langchain/core/tools");
+const mcp_adapters_namespaceObject = require("@langchain/mcp-adapters");
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -45,26 +45,51 @@ class MCPClientManager {
         return Array.from(serverMap.values());
     }
     buildClientConfig() {
-        const clientConfig = {};
+        const mcpServers = {};
         for (const server of this.serverConfigs)if ("stdio" === server.transport) {
             const stdioServer = server;
             const resolvedEnv = {};
             for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
-            clientConfig[server.name] = {
+            const runtimeEnv = this.applyRuntimeEnv(resolvedEnv);
+            const defaultToolTimeout = getDefaultToolTimeout(stdioServer);
+            mcpServers[server.name] = {
                 transport: "stdio",
                 command: stdioServer.command,
                 args: stdioServer.args || [],
-                env: resolvedEnv
+                env: runtimeEnv,
+                ...void 0 !== defaultToolTimeout ? {
+                    defaultToolTimeout
+                } : {}
             };
         } else if ("sse" === server.transport) {
             const sseServer = server;
-            clientConfig[server.name] = {
+            const defaultToolTimeout = getDefaultToolTimeout(sseServer);
+            mcpServers[server.name] = {
                 transport: "sse",
                 url: sseServer.url,
-                headers: sseServer.headers || {}
+                headers: sseServer.headers || {},
+                ...void 0 !== defaultToolTimeout ? {
+                    defaultToolTimeout
+                } : {}
             };
         }
-        return clientConfig;
+        return {
+            mcpServers,
+            useStandardContentBlocks: false,
+            outputHandling: {
+                image: "artifact",
+                audio: "artifact",
+                resource: "artifact"
+            }
+        };
+    }
+    applyRuntimeEnv(env) {
+        if (!this.executionWorkspace) return env;
+        const next = {
+            ...env
+        };
+        next.WINGMAN_WORKDIR = this.executionWorkspace;
+        return next;
     }
     async initialize() {
         if (0 === this.serverConfigs.length) return void this.logger.debug("No MCP servers configured");
@@ -117,7 +142,8 @@ class MCPClientManager {
             if (sanitized === original) return tool;
             const originalLabel = `Original tool name: ${original}`;
             const description = tool.description ? `${tool.description}\n\n${originalLabel}` : originalLabel;
-            const schema = tool.schema ?? tool.inputSchema;
+            const toolWithSchema = tool;
+            const schema = toolWithSchema.schema ?? toolWithSchema.inputSchema;
             if (!schema) try {
                 tool.name = sanitized;
                 tool.description = description;
@@ -128,7 +154,7 @@ class MCPClientManager {
             return (0, tools_namespaceObject.tool)(async (input)=>tool.invoke(input), {
                 name: sanitized,
                 description,
-                schema
+                schema: schema
             });
         });
     }
@@ -145,12 +171,14 @@ class MCPClientManager {
     hasServers() {
         return this.serverConfigs.length > 0;
     }
-    constructor(configs, logger){
+    constructor(configs, logger, options){
         _define_property(this, "client", null);
         _define_property(this, "logger", void 0);
         _define_property(this, "serverConfigs", void 0);
+        _define_property(this, "executionWorkspace", void 0);
         this.logger = logger;
         this.serverConfigs = this.mergeConfigs(configs);
+        this.executionWorkspace = options?.executionWorkspace?.trim() || null;
     }
 }
 function resolveEnvValue(value) {
@@ -159,6 +187,12 @@ function resolveEnvValue(value) {
     const envValue = process.env[match[1]];
     return envValue ?? "";
 }
+function getDefaultToolTimeout(server) {
+    const candidate = server.defaultToolTimeout;
+    if ("number" != typeof candidate) return;
+    if (!Number.isFinite(candidate) || candidate <= 0) return;
+    return Math.floor(candidate);
+}
 exports.MCPClientManager = __webpack_exports__.MCPClientManager;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MCPClientManager"

package/dist/agent/config/mcpClientManager.d.ts

@@ -1,6 +1,6 @@
 import type { StructuredTool } from "@langchain/core/tools";
-import type { MCPServersConfig } from "@/types/mcp.js";
 import type { Logger } from "@/logger.js";
+import type { MCPServersConfig } from "@/types/mcp.js";
 /**
  * Manages MCP server connections and tool retrieval
  * Handles server lifecycle: initialization, tool loading, and cleanup
@@ -9,7 +9,10 @@ export declare class MCPClientManager {
     private client;
     private logger;
     private serverConfigs;
-    constructor(configs: MCPServersConfig[], logger: Logger);
+    private executionWorkspace;
+    constructor(configs: MCPServersConfig[], logger: Logger, options?: {
+        executionWorkspace?: string | null;
+    });
     /**
      * Merge multiple MCP configurations (global + agent-specific)
      * Agent-specific servers override global ones with same name
@@ -19,6 +22,7 @@ export declare class MCPClientManager {
      * Convert Wingman MCP config to MultiServerMCPClient format
      */
     private buildClientConfig;
+    private applyRuntimeEnv;
     /**
      * Initialize MCP client and connect to servers
      */

package/dist/agent/config/mcpClientManager.js

@@ -1,5 +1,5 @@
-import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { tool as tools_tool } from "@langchain/core/tools";
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -17,26 +17,51 @@ class MCPClientManager {
         return Array.from(serverMap.values());
     }
     buildClientConfig() {
-        const clientConfig = {};
+        const mcpServers = {};
         for (const server of this.serverConfigs)if ("stdio" === server.transport) {
             const stdioServer = server;
             const resolvedEnv = {};
             for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
-            clientConfig[server.name] = {
+            const runtimeEnv = this.applyRuntimeEnv(resolvedEnv);
+            const defaultToolTimeout = getDefaultToolTimeout(stdioServer);
+            mcpServers[server.name] = {
                 transport: "stdio",
                 command: stdioServer.command,
                 args: stdioServer.args || [],
-                env: resolvedEnv
+                env: runtimeEnv,
+                ...void 0 !== defaultToolTimeout ? {
+                    defaultToolTimeout
+                } : {}
             };
         } else if ("sse" === server.transport) {
             const sseServer = server;
-            clientConfig[server.name] = {
+            const defaultToolTimeout = getDefaultToolTimeout(sseServer);
+            mcpServers[server.name] = {
                 transport: "sse",
                 url: sseServer.url,
-                headers: sseServer.headers || {}
+                headers: sseServer.headers || {},
+                ...void 0 !== defaultToolTimeout ? {
+                    defaultToolTimeout
+                } : {}
             };
         }
-        return clientConfig;
+        return {
+            mcpServers,
+            useStandardContentBlocks: false,
+            outputHandling: {
+                image: "artifact",
+                audio: "artifact",
+                resource: "artifact"
+            }
+        };
+    }
+    applyRuntimeEnv(env) {
+        if (!this.executionWorkspace) return env;
+        const next = {
+            ...env
+        };
+        next.WINGMAN_WORKDIR = this.executionWorkspace;
+        return next;
     }
     async initialize() {
         if (0 === this.serverConfigs.length) return void this.logger.debug("No MCP servers configured");
@@ -89,7 +114,8 @@ class MCPClientManager {
             if (sanitized === original) return tool;
             const originalLabel = `Original tool name: ${original}`;
             const description = tool.description ? `${tool.description}\n\n${originalLabel}` : originalLabel;
-            const schema = tool.schema ?? tool.inputSchema;
+            const toolWithSchema = tool;
+            const schema = toolWithSchema.schema ?? toolWithSchema.inputSchema;
             if (!schema) try {
                 tool.name = sanitized;
                 tool.description = description;
@@ -100,7 +126,7 @@ class MCPClientManager {
             return tools_tool(async (input)=>tool.invoke(input), {
                 name: sanitized,
                 description,
-                schema
+                schema: schema
             });
         });
     }
@@ -117,12 +143,14 @@ class MCPClientManager {
     hasServers() {
         return this.serverConfigs.length > 0;
     }
-    constructor(configs, logger){
+    constructor(configs, logger, options){
         _define_property(this, "client", null);
         _define_property(this, "logger", void 0);
         _define_property(this, "serverConfigs", void 0);
+        _define_property(this, "executionWorkspace", void 0);
         this.logger = logger;
         this.serverConfigs = this.mergeConfigs(configs);
+        this.executionWorkspace = options?.executionWorkspace?.trim() || null;
     }
 }
 function resolveEnvValue(value) {
@@ -131,4 +159,10 @@ function resolveEnvValue(value) {
     const envValue = process.env[match[1]];
     return envValue ?? "";
 }
+function getDefaultToolTimeout(server) {
+    const candidate = server.defaultToolTimeout;
+    if ("number" != typeof candidate) return;
+    if (!Number.isFinite(candidate) || candidate <= 0) return;
+    return Math.floor(candidate);
+}
 export { MCPClientManager };

package/dist/agent/config/toolRegistry.cjs

@@ -102,7 +102,9 @@ async function createTools(toolNames, options = {}) {
         else logger.warn(`Skipping unknown tool: ${name}`);
     }
     if (options.mcpConfigs && options.mcpConfigs.length > 0) try {
-        const mcpManager = new external_mcpClientManager_cjs_namespaceObject.MCPClientManager(options.mcpConfigs, logger);
+        const mcpManager = new external_mcpClientManager_cjs_namespaceObject.MCPClientManager(options.mcpConfigs, logger, {
+            executionWorkspace: options.executionWorkspace || options.workspace || null
+        });
         await mcpManager.initialize();
         const mcpTools = await mcpManager.getTools();
         if (mcpTools.length > 0) {

package/dist/agent/config/toolRegistry.js

@@ -71,7 +71,9 @@ async function createTools(toolNames, options = {}) {
         else logger.warn(`Skipping unknown tool: ${name}`);
     }
     if (options.mcpConfigs && options.mcpConfigs.length > 0) try {
-        const mcpManager = new MCPClientManager(options.mcpConfigs, logger);
+        const mcpManager = new MCPClientManager(options.mcpConfigs, logger, {
+            executionWorkspace: options.executionWorkspace || options.workspace || null
+        });
         await mcpManager.initialize();
         const mcpTools = await mcpManager.getTools();
         if (mcpTools.length > 0) {