wave-agent-sdk 0.17.8 → 0.17.10

package/src/managers/hookManager.ts

@@ -988,9 +988,9 @@ export class HookManager {
       transcriptPath,
       cwd: this.workdir,
       endSource: source,
-      env:
-        this.container.get<Record<string, string>>("MergedEnv") ||
-        (process.env as Record<string, string>),
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
     };
 
     const results = await this.executeHooks("SessionEnd", context);
@@ -1060,9 +1060,9 @@ export class HookManager {
       transcriptPath,
       cwd: this.workdir,
       compactSummary,
-      env:
-        this.container.get<Record<string, string>>("MergedEnv") ||
-        (process.env as Record<string, string>),
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e) => e[1] !== undefined),
+      ) as Record<string, string>,
     };
 
     const results = await this.executeHooks("PostCompact", context);

package/src/managers/mcpManager.ts

@@ -432,11 +432,9 @@ export class McpManager {
             `MCP server ${name} with type "stdio" requires a 'command'`,
           );
         }
-        const agentEnv =
-          this.container.get<Record<string, string>>("MergedEnv") ||
-          (process.env as Record<string, string>);
+
         const env: Record<string, string> = {
-          ...agentEnv,
+          ...(process.env as Record<string, string>),
           ...(server.config.env || {}),
         };
 

package/src/managers/messageManager.ts

@@ -308,14 +308,6 @@ export class MessageManager {
         return;
       }
 
-      // Filter out meta messages
-      const meaningfulMessages = unsavedMessages.filter((m) => !m.isMeta);
-
-      if (meaningfulMessages.length === 0) {
-        // No meaningful messages to save
-        return;
-      }
-
       // Create session if needed (only when we have messages to save)
       if (this.savedMessageCount === 0) {
         // This is the first time saving messages, so create the session
@@ -325,7 +317,7 @@ export class MessageManager {
       // Use JSONL format for new sessions
       await appendMessages(
         this.sessionId,
-        meaningfulMessages, // Only append meaningful messages
+        unsavedMessages,
         this.workdir,
         this.sessionType,
         this.rootSessionId,

package/src/managers/toolManager.ts

@@ -356,24 +356,12 @@ class ToolManager {
   }): ChatCompletionFunctionTool[] {
     const permissionManager =
       this.container.get<PermissionManager>("PermissionManager");
-    const effectivePermissionMode = this.getPermissionMode();
     const builtInToolsConfig = Array.from(this.toolsRegistry.values())
       .filter((tool) => {
         // If tool is explicitly denied by name in permission rules, filter it out
         if (permissionManager?.isToolDenied(tool.name)) {
           return false;
         }
-        if (effectivePermissionMode === "bypassPermissions") {
-          if (tool.name === "ExitPlanMode") {
-            return false;
-          }
-        }
-        if (tool.name === "ExitPlanMode") {
-          return effectivePermissionMode === "plan";
-        }
-        if (tool.name === "EnterPlanMode") {
-          return effectivePermissionMode !== "plan";
-        }
         return true;
       })
       .map((tool) => {
@@ -408,6 +396,24 @@ class ToolManager {
     return Array.from(this.toolsRegistry.values());
   }
 
+  /**
+   * Check whether a tool is safe to execute in parallel with other tools.
+   * Built-in tools default to safe (parallel); Edit and Write opt out.
+   * MCP tools are conservatively non-safe (can't inspect side effects).
+   */
+  public isConcurrencySafe(name: string): boolean {
+    // MCP tools are conservatively non-safe
+    if (this.mcpManager.isMcpTool(name)) {
+      return false;
+    }
+    const plugin = this.toolsRegistry.get(name);
+    if (plugin) {
+      return plugin.isConcurrencySafe ?? true;
+    }
+    // Unknown tools are conservatively non-safe
+    return false;
+  }
+
   /**
    * Get the current permission mode
    */
@@ -432,6 +438,25 @@ class ToolManager {
     this.container.register("PermissionMode", mode);
   }
 
+  /**
+   * Request a full permission mode transition (planManager + UI callback).
+   * Used by tools like EnterPlanMode in bypass mode where the canUseTool
+   * callback (which normally handles the transition) is not invoked.
+   * In normal mode, the callback already handles the transition.
+   */
+  public requestPermissionModeChange(mode: PermissionMode): void {
+    if (this.container.has("PermissionModeTransition")) {
+      const transition = this.container.get<(mode: PermissionMode) => void>(
+        "PermissionModeTransition",
+      );
+      if (transition) {
+        transition(mode);
+        return;
+      }
+    }
+    this.setPermissionMode(mode);
+  }
+
   /**
    * Get the permission manager
    */

package/src/services/aiService.ts

@@ -12,8 +12,7 @@ import { addOnceAbortListener } from "../utils/abortUtils.js";
 import type { GatewayConfig, ModelConfig } from "../types/index.js";
 import { ConfigurationError, CONFIG_ERRORS } from "../types/index.js";
 import {
-  transformMessagesForClaudeCache,
-  addCacheControlToLastTool,
+  transformMessagesForExplicitCache,
   supportsPromptCaching,
   extendUsageWithCacheMetrics,
   type ClaudeUsage,
@@ -282,15 +281,10 @@ export async function callAgent(
     processedTools = tools;
 
     if (supportsPromptCaching(currentModel)) {
-      openaiMessages = transformMessagesForClaudeCache(
+      openaiMessages = transformMessagesForExplicitCache(
         openaiMessages,
         currentModel,
       );
-
-      // Apply cache control to tools separately
-      if (tools && tools.length > 0) {
-        processedTools = addCacheControlToLastTool(tools);
-      }
     }
 
     // Get model configuration - use injected modelConfig with optional override
@@ -845,6 +839,7 @@ export async function compactMessages(
     fastModel: _fastModel,
     maxTokens: _maxTokens,
     permissionMode: _permissionMode,
+    fastModelConfig: _fastModelConfig,
     ...extraParams
   } = modelConfig;
   void _model;
@@ -852,10 +847,16 @@ export async function compactMessages(
   void _maxTokens;
   void _permissionMode;
 
+  // When a fast model override is provided, use the fast model's hyperparams
+  // (if configured); otherwise fall back to the agent model's extraParams.
+  const activeExtraParams = options.model
+    ? _fastModelConfig || {}
+    : extraParams;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 8192,
-    ...extraParams,
+    ...activeExtraParams,
   });
 
   try {
@@ -961,6 +962,7 @@ export async function processWebContent(
     fastModel: _fastModel,
     maxTokens: _maxTokens,
     permissionMode: _permissionMode,
+    fastModelConfig: _fastModelConfig,
     ...extraParams
   } = modelConfig;
   void _model;
@@ -968,10 +970,16 @@ export async function processWebContent(
   void _maxTokens;
   void _permissionMode;
 
+  // When a fast model override is provided, use the fast model's hyperparams
+  // (if configured); otherwise fall back to the agent model's extraParams.
+  const activeExtraParams = options.model
+    ? _fastModelConfig || {}
+    : extraParams;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 4096,
-    ...extraParams,
+    ...activeExtraParams,
   });
 
   try {
@@ -1177,17 +1185,20 @@ export async function evaluateGoal(
     fastModel: _fastModel,
     maxTokens: _maxTokens,
     permissionMode: _permissionMode,
-    ...extraParams
+    fastModelConfig: _fastModelConfig,
   } = modelConfig;
   void _model;
   void _fastModel;
   void _maxTokens;
   void _permissionMode;
 
+  // evaluateGoal always uses the fast model; use its hyperparams if configured.
+  const activeExtraParams = _fastModelConfig || {};
+
   const openaiModelConfig = getModelConfig(model, {
     temperature: 0,
     max_tokens: 200,
-    ...extraParams,
+    ...activeExtraParams,
   });
 
   // Strip images from messages to reduce token usage (same as compact)

package/src/services/configurationService.ts

@@ -532,6 +532,27 @@ export class ConfigurationService {
       permissionMode: permissionMode ?? this.options.permissionMode,
     };
 
+    // Resolve fast model hyperparams from models[fastModel], stripping
+    // structural fields so only hyperparameters remain. Set on baseConfig
+    // before the modelSpecificConfig spread so it isn't overwritten.
+    const fastModelConfigSource =
+      resolvedFastModel &&
+      this.currentConfiguration?.models?.[resolvedFastModel];
+    if (fastModelConfigSource) {
+      const {
+        model: _fm,
+        fastModel: _ffm,
+        maxTokens: _fmt,
+        permissionMode: _fpm,
+        ...fastHyperparams
+      } = fastModelConfigSource;
+      void _fm;
+      void _ffm;
+      void _fmt;
+      void _fpm;
+      baseConfig.fastModelConfig = fastHyperparams;
+    }
+
     // Merge model-specific settings from configuration
     const modelSpecificConfig =
       resolvedAgentModel &&

package/src/services/jsonlHandler.ts

@@ -229,19 +229,7 @@ export class JsonlHandler {
     // Extract filename from path
     const filename = filePath.split("/").pop() || "";
 
-    // New timestamp-prefixed format
-    const newSubagentMatch = filename.match(
-      /^subagent-(\d{14}-[0-9a-f]{8})\.jsonl$/,
-    );
-    if (newSubagentMatch) {
-      return { sessionId: newSubagentMatch[1], sessionType: "subagent" };
-    }
-    const newMainMatch = filename.match(/^(\d{14}-[0-9a-f]{8})\.jsonl$/);
-    if (newMainMatch) {
-      return { sessionId: newMainMatch[1], sessionType: "main" };
-    }
-
-    // Old UUID format (backward compat)
+    // Check if it's a subagent session
     const subagentMatch = filename.match(
       /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
     );
@@ -252,6 +240,7 @@ export class JsonlHandler {
       };
     }
 
+    // Check if it's a main session
     const mainMatch = filename.match(
       /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
     );
@@ -271,26 +260,18 @@ export class JsonlHandler {
    * @returns True if valid, false otherwise
    */
   isValidSessionFilename(filename: string): boolean {
-    // New timestamp-prefixed format patterns
-    const newFormatPattern = /^(\d{14}-[0-9a-f]{8})\.jsonl$/;
-    const newSubagentPattern = /^subagent-(\d{14}-[0-9a-f]{8})\.jsonl$/;
-    // Old UUID format patterns (backward compat)
+    // UUID validation patterns
     const uuidPattern =
       /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
     const subagentPattern =
       /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
 
-    return (
-      newFormatPattern.test(filename) ||
-      newSubagentPattern.test(filename) ||
-      uuidPattern.test(filename) ||
-      subagentPattern.test(filename)
-    );
+    return uuidPattern.test(filename) || subagentPattern.test(filename);
   }
 
   /**
    * Generate simple filename for sessions
-   * @param sessionId - Session identifier (timestamp-prefixed or legacy UUID format)
+   * @param sessionId - UUID session identifier
    * @param sessionType - Type of session ("main" or "subagent")
    * @returns Generated filename
    */
@@ -298,11 +279,10 @@ export class JsonlHandler {
     sessionId: string,
     sessionType: "main" | "subagent",
   ): string {
-    // Validate sessionId is either new timestamp-prefixed format or legacy UUID
-    const newFormatPattern = /^\d{14}-[0-9a-f]{8}$/;
+    // Validate sessionId is a valid UUID
     const uuidPattern =
       /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-    if (!newFormatPattern.test(sessionId) && !uuidPattern.test(sessionId)) {
+    if (!uuidPattern.test(sessionId)) {
       throw new Error(`Invalid session ID format: ${sessionId}`);
     }
 

package/src/services/session.ts

@@ -63,43 +63,11 @@ export interface SessionIndex {
 }
 
 /**
- * Generate a new session ID with a timestamp prefix for sortability
- * Format: {YYYYMMDDHHmmss}-{8hex} (e.g. 20260527143025-a1b2c3d4)
- * @returns Timestamp-prefixed session ID string
+ * Generate a new session ID using Node.js native crypto.randomUUID()
+ * @returns UUID string for session identification
  */
 export function generateSessionId(): string {
-  const now = new Date();
-  const ts = [
-    now.getFullYear(),
-    String(now.getMonth() + 1).padStart(2, "0"),
-    String(now.getDate()).padStart(2, "0"),
-    String(now.getHours()).padStart(2, "0"),
-    String(now.getMinutes()).padStart(2, "0"),
-    String(now.getSeconds()).padStart(2, "0"),
-  ].join("");
-  const shortId = randomUUID().slice(0, 8);
-  return `${ts}-${shortId}`;
-}
-
-/**
- * Parse the timestamp prefix from a session ID back into a Date
- * Format: {YYYYMMDDHHmmss}-{8hex} (e.g. 20260527143025-a1b2c3d4)
- * @returns Date from the session ID timestamp prefix
- */
-export function parseSessionIdTimestamp(sessionId: string): Date {
-  const match = sessionId.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/);
-  if (!match) {
-    return new Date(); // Fallback to now for legacy UUID-format session IDs
-  }
-  const [, year, month, day, hour, minute, second] = match;
-  return new Date(
-    Number(year),
-    Number(month) - 1,
-    Number(day),
-    Number(hour),
-    Number(minute),
-    Number(second),
-  );
+  return randomUUID();
 }
 
 /**
@@ -293,9 +261,9 @@ export async function appendMessages(
       (await getFirstMessageContent(sessionId, workdir)) || undefined;
   }
 
-  // Derive createdAt from session ID timestamp if not in index
+  // Derive createdAt from session ID if not in index
   if (!createdAt) {
-    createdAt = new Date(parseSessionIdTimestamp(sessionId));
+    createdAt = new Date();
   }
 
   await updateSessionIndex(projectDir.encodedPath, {
@@ -520,17 +488,15 @@ export async function listSessionsFromJsonl(
       try {
         const filePath = join(projectDir.encodedPath, file);
 
-        // Validate main session filename format (new timestamp format or legacy UUID)
-        const newFormatMatch = file.match(/^(\d{14}-[0-9a-f]{8})\.jsonl$/);
+        // Validate main session filename format (UUID.jsonl)
         const uuidMatch = file.match(
           /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
         );
-        const match = newFormatMatch || uuidMatch;
-        if (!match) {
+        if (!uuidMatch) {
           continue; // Skip invalid filenames
         }
 
-        const sessionId = match[1];
+        const sessionId = uuidMatch[1];
 
         // PERFORMANCE OPTIMIZATION: Only read the last message for timestamps and tokens
         const jsonlHandler = new JsonlHandler();
@@ -557,7 +523,7 @@ export async function listSessionsFromJsonl(
           sessionType: "main",
           subagentType: undefined, // No longer stored in metadata
           workdir: projectDir.originalPath,
-          createdAt: new Date(parseSessionIdTimestamp(sessionId)),
+          createdAt: new Date(),
           lastActiveAt,
           latestTotalTokens: lastMessage?.usage
             ? extractLatestTotalTokens([lastMessage])
@@ -720,24 +686,17 @@ export async function cleanupExpiredSessionsFromJsonl(
             );
             const indexContent = await fs.readFile(indexPath, "utf8");
             const index = JSON.parse(indexContent) as SessionIndex;
-            // New timestamp-prefixed format patterns
-            const newMainMatch = file.match(/^(\d{14}-[0-9a-f]{8})\.jsonl$/);
-            const newSubagentMatch = file.match(
-              /^subagent-(\d{14}-[0-9a-f]{8})\.jsonl$/,
-            );
-            // Old UUID format patterns (backward compat)
             const uuidMatch = file.match(
-              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
             );
             const subagentMatch = file.match(
-              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
             );
-            const sessionId =
-              newMainMatch?.[1] ??
-              newSubagentMatch?.[1] ??
-              uuidMatch?.[1] ??
-              subagentMatch?.[1] ??
-              null;
+            const sessionId = uuidMatch
+              ? uuidMatch[1]
+              : subagentMatch
+                ? subagentMatch[1]
+                : null;
 
             if (sessionId && index.sessions[sessionId]) {
               delete index.sessions[sessionId];

package/src/tools/bashTool.ts

@@ -240,7 +240,9 @@ The working directory persists between commands. Try to maintain your current wo
         stdio: "pipe",
         detached: true,
         cwd: context.workdir,
-        env: context.env || { ...process.env },
+        env: {
+          ...process.env,
+        },
       });
 
       let outputBuffer = "";

package/src/tools/editTool.ts

@@ -1,4 +1,5 @@
-import { readFile, writeFile } from "fs/promises";
+import { readFile, writeFile, stat } from "fs/promises";
+import { createHash } from "crypto";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
@@ -21,6 +22,7 @@ function formatCompactParams(
  */
 export const editTool: ToolPlugin = {
   name: EDIT_TOOL_NAME,
+  isConcurrencySafe: false,
   formatCompactParams,
   prompt: () =>
     `Performs exact string replacements in files.
@@ -137,6 +139,22 @@ Usage:
         };
       }
 
+      // Staleness check: file must not have been modified since last Read
+      if (context.readFileState) {
+        const state = context.readFileState.get(resolvedPath);
+        if (state) {
+          const currentStats = await stat(resolvedPath);
+          if (currentStats.mtime.getTime() !== state.mtime) {
+            return {
+              success: false,
+              content: "",
+              error:
+                "File has been unexpectedly modified since last read. Read it again before editing it.",
+            };
+          }
+        }
+      }
+
       // Normalize line endings for matching
       const normalizedContent = originalContent.replace(/\r\n/g, "\n");
       const normalizedOldString = oldString.replace(/\r\n/g, "\n");
@@ -240,6 +258,18 @@ Usage:
         };
       }
 
+      // Update readFileState so subsequent serialized edits see fresh state
+      if (context.readFileState) {
+        const newStats = await stat(resolvedPath);
+        const hash = createHash("sha256").update(newContent).digest("hex");
+        context.readFileState.set(resolvedPath, {
+          mtime: newStats.mtime.getTime(),
+          hash,
+          offset: undefined,
+          limit: undefined,
+        });
+      }
+
       const shortResult = replaceAll
         ? `Replaced ${replacementCount} instances`
         : "Text replaced successfully";

package/src/tools/enterPlanMode.ts

@@ -49,6 +49,15 @@ export const enterPlanModeTool: ToolPlugin = {
     context: ToolContext,
   ): Promise<ToolResult> => {
     try {
+      // Runtime guard: tool is always visible but only works outside plan mode
+      if (context.permissionMode === "plan") {
+        return {
+          success: false,
+          content: "Already in plan mode. Use ExitPlanMode to exit.",
+          error: "Already in plan mode",
+        };
+      }
+
       if (!context.permissionManager) {
         return {
           success: false,
@@ -87,10 +96,12 @@ export const enterPlanModeTool: ToolPlugin = {
         };
       }
 
-      // Ensure permission mode is switched to plan (in bypass mode the
-      // canUseTool callback is not invoked, so the mode change doesn't happen)
-      if (context.toolManager) {
-        context.toolManager.setPermissionMode("plan");
+      // Ensure the full plan mode transition happens (planManager + UI callback).
+      // In bypass mode the canUseTool callback is not invoked, so the transition
+      // never occurs. In normal mode, the callback already handled it
+      // (permissionResult.newPermissionMode will be set).
+      if (!permissionResult.newPermissionMode && context.toolManager) {
+        context.toolManager.requestPermissionModeChange("plan");
       }
 
       return {

package/src/tools/exitPlanMode.ts

@@ -52,6 +52,16 @@ Ensure your plan is complete and unambiguous:
     context: ToolContext,
   ): Promise<ToolResult> => {
     try {
+      // Runtime guard: tool is always visible but only works in plan mode
+      if (context.permissionMode !== "plan") {
+        return {
+          success: false,
+          content:
+            "Not in plan mode. ExitPlanMode can only be used when actively in plan mode.",
+          error: "Not in plan mode",
+        };
+      }
+
       if (!context.permissionManager) {
         return {
           success: false,

package/src/tools/readTool.ts

@@ -244,18 +244,26 @@ Usage:
 
       const stats = await stat(actualFilePath);
 
-      // Deduplication
+      // Deduplication: only dedup if the exact same range was read before
       if (context.readFileState) {
         const state = context.readFileState.get(actualFilePath);
-        if (state && state.mtime === stats.mtime.getTime()) {
-          return {
-            success: true,
-            content: `File ${filePath} has not changed since last read.`,
-            shortResult: "File unchanged",
-            metadata: {
-              type: "file_unchanged",
-            },
-          };
+        // Only dedup entries from a prior Read with explicit offset (not Edit/Write entries)
+        if (
+          state &&
+          state.mtime === stats.mtime.getTime() &&
+          state.offset !== undefined
+        ) {
+          const rangeMatch = state.offset === offset && state.limit === limit;
+          if (rangeMatch) {
+            return {
+              success: true,
+              content: `File ${filePath} has not changed since last read. The content from the earlier Read tool_result in this conversation is still current — refer to that instead of re-reading.`,
+              shortResult: "File unchanged",
+              metadata: {
+                type: "file_unchanged",
+              },
+            };
+          }
         }
       }
 
@@ -287,6 +295,8 @@ Usage:
         context.readFileState.set(actualFilePath, {
           mtime: stats.mtime.getTime(),
           hash,
+          offset, // undefined for full reads
+          limit, // undefined for full reads
         });
       }
 

package/src/tools/types.ts

@@ -31,6 +31,12 @@ export interface ToolPlugin {
     workdir?: string;
     isSubagent?: boolean;
   }) => string;
+  /**
+   * Whether this tool is safe to run in parallel with other tools.
+   * Default (undefined) = true (parallel). Set to false for tools that
+   * perform read-modify-write on shared resources (e.g. Edit, Write).
+   */
+  isConcurrencySafe?: boolean;
 }
 
 export interface ToolResult {
@@ -104,15 +110,21 @@ export interface ToolContext {
     maxTokens: number;
   };
   /** State of files read in the current session for deduplication */
-  readFileState?: Map<string, { mtime: number; hash: string }>;
+  readFileState?: Map<
+    string,
+    {
+      mtime: number;
+      hash: string;
+      offset?: number; // undefined = full read or Edit/Write entry (never dedup)
+      limit?: number;
+    }
+  >;
   /** Hook manager instance for executing hooks */
   hookManager?: import("../managers/hookManager.js").HookManager;
   /** Callback to notify when the current working directory changes */
   onCwdChange?: (newCwd: string) => void;
   /** Original working directory (before any cd changes) for CWD reset */
   originalWorkdir?: string;
-  /** Merged environment variables (process.env + agent env) for child processes */
-  env?: Record<string, string>;
   /** Workflow manager instance for workflow orchestration */
   workflowManager?: import("../managers/workflowManager.js").WorkflowManager;
 }