@compilr-dev/agents 0.3.1 → 0.3.4

package/dist/agent.d.ts

@@ -2,7 +2,7 @@
  * Agent - The main class for running AI agents with tool use
  */
 import type { LLMProvider, Message, ChatOptions, StreamChunk } from './providers/types.js';
-import type { Tool, ToolDefinition, ToolRegistry, ToolExecutionResult } from './tools/types.js';
+import type { Tool, ToolDefinition, ToolRegistry, ToolExecutionResult, ToolExecutionContext } from './tools/types.js';
 import type { ContextStats, VerbosityLevel, SmartCompactionResult } from './context/types.js';
 import type { AgentState, Checkpointer, SessionMetadata } from './state/types.js';
 import type { Anchor, AnchorInput, AnchorQueryOptions, AnchorClearOptions, AnchorManagerOptions } from './anchors/types.js';
@@ -16,6 +16,7 @@ import { ContextManager } from './context/manager.js';
 import { FileAccessTracker } from './context/file-tracker.js';
 import { AnchorManager } from './anchors/manager.js';
 import { GuardrailManager } from './guardrails/manager.js';
+import { type RetryConfig } from './utils/index.js';
 /**
  * Event types emitted during agent execution
  */
@@ -146,6 +147,18 @@ export type AgentEvent = {
     type: 'iteration_limit_extended';
     newMaxIterations: number;
     addedIterations: number;
+} | {
+    type: 'llm_retry';
+    attempt: number;
+    maxAttempts: number;
+    error: string;
+    delayMs: number;
+    provider: string;
+} | {
+    type: 'llm_retry_exhausted';
+    attempts: number;
+    error: string;
+    provider: string;
 };
 /**
  * Event handler function type
@@ -268,6 +281,29 @@ export interface AgentConfig {
      * Event handler for monitoring agent execution
      */
     onEvent?: AgentEventHandler;
+    /**
+     * Configuration for automatic retry on transient LLM errors.
+     * Enabled by default with sensible defaults (10 attempts, exponential backoff).
+     *
+     * Retryable errors include:
+     * - Rate limit (429)
+     * - Server errors (5xx)
+     * - Connection/network errors
+     * - Anthropic overloaded (529)
+     *
+     * @example
+     * ```typescript
+     * const agent = new Agent({
+     *   provider,
+     *   retry: {
+     *     maxAttempts: 5,      // Max 5 retries
+     *     baseDelayMs: 2000,   // Start with 2s delay
+     *     maxDelayMs: 60000,   // Cap at 60s
+     *   }
+     * });
+     * ```
+     */
+    retry?: RetryConfig;
     /**
      * Checkpointer for persisting agent state.
      * If provided, enables checkpoint() and resume() functionality.
@@ -377,6 +413,15 @@ export interface AgentConfig {
      * ```
      */
     permissions?: PermissionManagerOptions;
+    /**
+     * Pre-existing PermissionManager instance.
+     *
+     * Use this to share a PermissionManager between agents (e.g., parent and sub-agents).
+     * When provided, takes precedence over `permissions` options.
+     *
+     * This is primarily used internally for sub-agent permission inheritance.
+     */
+    permissionManager?: PermissionManager;
     /**
      * Pre-loaded project memory to prepend to system prompt.
      *
@@ -544,6 +589,29 @@ export interface RunOptions {
      * ```
      */
     toolFilter?: string[];
+    /**
+     * Callback to provide additional tool execution context.
+     * Called before each tool execution, allowing the caller to inject
+     * abort signals or other context-specific options.
+     *
+     * @example
+     * ```typescript
+     * // Provide abort signal for bash commands (for Ctrl+B backgrounding)
+     * const bashAbortController = new AbortController();
+     * await agent.stream(message, {
+     *   getToolContext: (toolName, toolUseId) => {
+     *     if (toolName === 'bash') {
+     *       return {
+     *         abortSignal: bashAbortController.signal,
+     *         onBackground: (shellId, output) => { ... },
+     *       };
+     *     }
+     *     return {};
+     *   },
+     * });
+     * ```
+     */
+    getToolContext?: (toolName: string, toolUseId: string) => Partial<Omit<ToolExecutionContext, 'toolUseId' | 'onOutput'>>;
 }
 /**
  * Agent run result
@@ -649,6 +717,20 @@ export interface SubAgentConfig {
      * Default: false (uses shared store)
      */
     stateIsolation?: boolean;
+    /**
+     * Inherit parent's permission manager.
+     *
+     * When true (default), the sub-agent uses the parent's PermissionManager,
+     * sharing session grants and permission rules. This ensures:
+     * - Sub-agents follow the same permission rules as parent
+     * - Session grants from parent are available to sub-agents
+     * - User sees permission prompts for sub-agent tool usage
+     *
+     * Set to false to allow sub-agents to bypass permissions (use with caution).
+     *
+     * Default: true
+     */
+    inheritPermissions?: boolean;
 }
 /**
  * Result from a sub-agent execution
@@ -712,6 +794,7 @@ export declare class Agent {
     private readonly autoContextManagement;
     private readonly onEvent?;
     private readonly onIterationLimitReached?;
+    private readonly retryConfig;
     private readonly checkpointer?;
     private readonly _sessionId;
     private readonly autoCheckpoint;
@@ -1136,8 +1219,14 @@ export declare class Agent {
     /**
      * Set the conversation history (for manual compaction/restoration)
      * Also updates the context manager's token count if configured.
+     *
+     * @param messages - The message history to restore
+     * @param options - Optional restore options
+     * @param options.turnCount - The turn count to restore (important for compaction)
      */
-    setHistory(messages: Message[]): Promise<this>;
+    setHistory(messages: Message[], options?: {
+        turnCount?: number;
+    }): Promise<this>;
     /**
      * Get the context manager (if configured)
      */
@@ -1439,6 +1528,10 @@ export declare class Agent {
      * Get all registered tool definitions
      */
     getToolDefinitions(): ToolDefinition[];
+    /**
+     * Check if a tool is marked as silent (no spinner or result output)
+     */
+    isToolSilent(name: string): boolean;
     /**
      * Run the agent with a user message
      */
@@ -1454,6 +1547,18 @@ export declare class Agent {
      * Process stream chunks into text, tool uses, and usage data
      */
     private processChunks;
+    /**
+     * Wrap provider.chat() with automatic retry on transient errors.
+     *
+     * Retries the entire stream on failure with exponential backoff.
+     * Emits llm_retry events before each retry attempt.
+     *
+     * @param messages - Messages to send
+     * @param options - Chat options
+     * @param emit - Event emitter function
+     * @param signal - Optional abort signal
+     */
+    private chatWithRetry;
     /**
      * Generate a summary of messages using the LLM provider.
      * Used for context summarization when approaching limits.

package/dist/agent.js

@@ -11,10 +11,11 @@ import { FileAccessTracker } from './context/file-tracker.js';
 import { createFileTrackingHook } from './context/file-tracking-hook.js';
 import { AnchorManager } from './anchors/manager.js';
 import { GuardrailManager } from './guardrails/manager.js';
-import { MaxIterationsError, ToolLoopError } from './errors.js';
+import { MaxIterationsError, ToolLoopError, ProviderError } from './errors.js';
 import { generateSessionId, createAgentState, deserializeTodos } from './state/agent-state.js';
 import { getDefaultTodoStore, createIsolatedTodoStore } from './tools/builtin/todo.js';
 import { repairToolPairing } from './messages/index.js';
+import { DEFAULT_RETRY_CONFIG, withRetryGenerator } from './utils/index.js';
 /**
  * Agent class - orchestrates LLM interactions with tool use
  *
@@ -44,6 +45,8 @@ export class Agent {
     autoContextManagement;
     onEvent;
     onIterationLimitReached;
+    // Retry configuration
+    retryConfig;
     // State management
     checkpointer;
     _sessionId;
@@ -120,7 +123,12 @@ export class Agent {
             this.guardrailManager = new GuardrailManager(config.guardrails);
         }
         // Permission management
-        if (config.permissions !== undefined) {
+        // Use pre-existing permissionManager if provided (for sub-agent inheritance)
+        // Otherwise create one from options
+        if (config.permissionManager !== undefined) {
+            this.permissionManager = config.permissionManager;
+        }
+        else if (config.permissions !== undefined) {
             this.permissionManager = new PermissionManager(config.permissions);
         }
         // Project memory - store and prepend to system prompt
@@ -183,6 +191,13 @@ export class Agent {
             // Hooks manager without file tracking
             this.hooksManager = new HooksManager({ hooks: config.hooks });
         }
+        // Retry configuration with defaults
+        this.retryConfig = {
+            enabled: config.retry?.enabled ?? DEFAULT_RETRY_CONFIG.enabled,
+            maxAttempts: config.retry?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts,
+            baseDelayMs: config.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
+            maxDelayMs: config.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
+        };
     }
     // ==========================================================================
     // Static Factory Methods
@@ -710,11 +725,28 @@ export class Agent {
     /**
      * Set the conversation history (for manual compaction/restoration)
      * Also updates the context manager's token count if configured.
+     *
+     * @param messages - The message history to restore
+     * @param options - Optional restore options
+     * @param options.turnCount - The turn count to restore (important for compaction)
      */
-    async setHistory(messages) {
-        this.conversationHistory = [...messages];
+    async setHistory(messages, options) {
+        // Repair tool_use/tool_result pairing to fix any corrupted messages
+        // This is especially important after resuming from a saved session
+        const repairedMessages = repairToolPairing(messages);
+        this.conversationHistory = [...repairedMessages];
         if (this.contextManager) {
-            await this.contextManager.updateTokenCount(messages);
+            await this.contextManager.updateTokenCount(repairedMessages);
+            // Restore turn count if provided
+            if (options?.turnCount !== undefined) {
+                this.contextManager.setTurnCount(options.turnCount);
+            }
+            else {
+                // Infer turn count from messages as a fallback
+                // Count user messages as a proxy for turns
+                const inferredTurnCount = repairedMessages.filter((m) => m.role === 'user').length;
+                this.contextManager.setTurnCount(inferredTurnCount);
+            }
         }
         return this;
     }
@@ -926,6 +958,7 @@ export class Agent {
             messages: this.conversationHistory,
             todos: todoStore.getAll(),
             currentIteration: this._currentIteration,
+            turnCount: this.contextManager?.getTurnCount() ?? 0,
             totalTokensUsed: this._totalTokensUsed,
             createdAt: this._createdAt,
         });
@@ -1054,6 +1087,11 @@ export class Agent {
         agent._createdAt = state.createdAt;
         agent._totalTokensUsed = state.totalTokensUsed;
         agent._currentIteration = state.currentIteration;
+        // Restore turn count to context manager if configured
+        // Note: turnCount is guaranteed to exist - deserializer ensures backward compatibility
+        if (agent.contextManager) {
+            agent.contextManager.setTurnCount(state.turnCount);
+        }
         // Restore todos
         if (state.todos.length > 0) {
             const todoStore = getDefaultTodoStore();
@@ -1118,6 +1156,9 @@ export class Agent {
         for (const tool of toolsToRegister) {
             subAgentToolRegistry.register(tool);
         }
+        // Determine if sub-agent should inherit parent's permissions
+        // Default: true (sub-agents follow same permission rules as parent)
+        const inheritPermissions = config.inheritPermissions ?? true;
         // Create the sub-agent
         const subAgent = new Agent({
             provider: this.provider,
@@ -1128,6 +1169,12 @@ export class Agent {
             contextManager: subAgentContextManager,
             autoContextManagement: true,
             onEvent: this.onEvent, // Forward events to parent
+            // Sub-agents should summarize their findings when hitting iteration limit
+            // rather than throwing an error with no response
+            iterationLimitBehavior: 'summarize',
+            // Inherit parent's permission manager if enabled
+            // This shares session grants and permission rules with sub-agents
+            permissionManager: inheritPermissions ? this.permissionManager : undefined,
         });
         // Store the sub-agent
         this.subAgents.set(config.name, { config, agent: subAgent });
@@ -1375,6 +1422,13 @@ export class Agent {
     getToolDefinitions() {
         return this.toolRegistry.getDefinitions();
     }
+    /**
+     * Check if a tool is marked as silent (no spinner or result output)
+     */
+    isToolSilent(name) {
+        const tool = this.toolRegistry.get(name);
+        return tool?.silent === true;
+    }
     /**
      * Run the agent with a user message
      */
@@ -1382,6 +1436,7 @@ export class Agent {
         let maxIterations = options?.maxIterations ?? this.maxIterations;
         const chatOptions = { ...this.chatOptions, ...options?.chatOptions };
         const signal = options?.signal;
+        const getToolContext = options?.getToolContext;
         // Combined event emitter
         const emit = (event) => {
             this.onEvent?.(event);
@@ -1390,22 +1445,34 @@ export class Agent {
         // Build messages: system prompt + history + new user message
         let messages = [];
         // Add system message if present
-        if (this.systemPrompt) {
-            messages.push({
-                role: 'system',
-                content: this.systemPrompt,
-            });
-        }
-        // Inject anchors (critical information that survives context compaction)
+        // NOTE: Anchors are now appended to the system prompt (not a separate message)
+        // to avoid multiple system messages which can confuse Claude's role identity
+        let systemContent = this.systemPrompt;
+        // Inject anchors into the system prompt (not as separate message)
         if (this.anchorManager && this.anchorManager.size > 0) {
             const anchorsContent = this.anchorManager.format();
             if (anchorsContent) {
-                messages.push({
-                    role: 'system',
-                    content: `## Active Anchors (Critical Information)\n\n${anchorsContent}`,
-                });
+                // Insert anchors BEFORE the role ending (if present) so role reinforcement stays at the end
+                const roleEndingMarker = '## YOUR ASSIGNED ROLE:';
+                const roleEndingIndex = systemContent.indexOf(roleEndingMarker);
+                if (roleEndingIndex > 0) {
+                    // Insert anchors before the role ending
+                    const beforeRole = systemContent.substring(0, roleEndingIndex);
+                    const roleEnding = systemContent.substring(roleEndingIndex);
+                    systemContent = `${beforeRole}\n\n---\n\n## Active Anchors (Critical Information)\n\n${anchorsContent}\n\n---\n\n${roleEnding}`;
+                }
+                else {
+                    // No role ending, just append anchors
+                    systemContent = `${systemContent}\n\n---\n\n## Active Anchors (Critical Information)\n\n${anchorsContent}`;
+                }
             }
         }
+        if (systemContent) {
+            messages.push({
+                role: 'system',
+                content: systemContent,
+            });
+        }
         // Add conversation history
         messages.push(...this.conversationHistory);
         // Add new user message
@@ -1514,10 +1581,10 @@ export class Agent {
             const llmStartTime = Date.now();
             const chunks = [];
             try {
-                for await (const chunk of this.provider.chat(messages, {
+                for await (const chunk of this.chatWithRetry(messages, {
                     ...chatOptions,
                     tools: tools.length > 0 ? tools : undefined,
-                })) {
+                }, emit, signal)) {
                     // Check for abort during streaming
                     if (signal?.aborted) {
                         aborted = true;
@@ -1615,6 +1682,7 @@ export class Agent {
                         id: tu.id,
                         name: tu.name,
                         input: tu.input,
+                        signature: tu.signature, // Gemini 3 thought signature (required for multi-turn)
                     })),
                 ],
             };
@@ -1757,6 +1825,8 @@ export class Agent {
                 }
                 const toolStartTime = Date.now();
                 try {
+                    // Get additional context from caller (e.g., for bash backgrounding)
+                    const additionalContext = getToolContext?.(toolUse.name, toolUse.id) ?? {};
                     const toolContext = {
                         toolUseId: toolUse.id,
                         onOutput: (output, stream) => {
@@ -1768,6 +1838,8 @@ export class Agent {
                                 stream,
                             });
                         },
+                        // Merge in additional context (abortSignal, onBackground, etc.)
+                        ...additionalContext,
                     };
                     result = await this.toolRegistry.execute(toolUse.name, toolInput, toolContext);
                 }
@@ -2111,6 +2183,7 @@ export class Agent {
                             id: chunk.toolUse.id,
                             name: chunk.toolUse.name,
                             inputJson: '',
+                            signature: chunk.toolUse.signature, // Capture Gemini 3 thought signature
                         };
                     }
                     break;
@@ -2129,6 +2202,7 @@ export class Agent {
                                 id: currentToolUse.id,
                                 name: currentToolUse.name,
                                 input,
+                                signature: currentToolUse.signature, // Pass through the signature
                             });
                         }
                         catch {
@@ -2146,6 +2220,53 @@ export class Agent {
         }
         return { text, toolUses, usage, model };
     }
+    /**
+     * Wrap provider.chat() with automatic retry on transient errors.
+     *
+     * Retries the entire stream on failure with exponential backoff.
+     * Emits llm_retry events before each retry attempt.
+     *
+     * @param messages - Messages to send
+     * @param options - Chat options
+     * @param emit - Event emitter function
+     * @param signal - Optional abort signal
+     */
+    chatWithRetry(messages, options, emit, signal) {
+        // If retry is disabled, return the raw provider stream
+        if (!this.retryConfig.enabled) {
+            return this.provider.chat(messages, options);
+        }
+        const providerName = this.provider.name;
+        const { maxAttempts, baseDelayMs, maxDelayMs } = this.retryConfig;
+        return withRetryGenerator(() => this.provider.chat(messages, options), {
+            maxAttempts,
+            baseDelayMs,
+            maxDelayMs,
+            isRetryable: (error) => {
+                // Use the ProviderError's built-in retryable check
+                return error instanceof ProviderError && error.isRetryable();
+            },
+            onRetry: (attempt, max, error, delayMs) => {
+                emit({
+                    type: 'llm_retry',
+                    attempt,
+                    maxAttempts: max,
+                    error: error.message,
+                    delayMs,
+                    provider: providerName,
+                });
+            },
+            onExhausted: (attempts, error) => {
+                emit({
+                    type: 'llm_retry_exhausted',
+                    attempts,
+                    error: error.message,
+                    provider: providerName,
+                });
+            },
+            signal,
+        });
+    }
     /**
      * Generate a summary of messages using the LLM provider.
      * Used for context summarization when approaching limits.
@@ -2184,11 +2305,15 @@ Keep the summary under 500 words.
 Conversation to summarize:
 ${messages.map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`).join('\n\n')}`;
         const summaryMessages = [{ role: 'user', content: summaryPrompt }];
+        // Create emit function for retry events (uses main event handler)
+        const emit = (event) => {
+            this.onEvent?.(event);
+        };
         let summary = '';
-        for await (const chunk of this.provider.chat(summaryMessages, {
+        for await (const chunk of this.chatWithRetry(summaryMessages, {
             ...this.chatOptions,
             maxTokens: this.contextManager?.getConfig().summarization.summaryMaxTokens ?? 2000,
-        })) {
+        }, emit)) {
             if (chunk.type === 'text' && chunk.text) {
                 summary += chunk.text;
             }
@@ -2227,11 +2352,15 @@ ${messages
             .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content.slice(0, 500) : '[complex content]'}`)
             .join('\n\n')}`;
         const summaryMessages = [{ role: 'user', content: summaryPrompt }];
+        // Create emit function for retry events (uses main event handler)
+        const emit = (event) => {
+            this.onEvent?.(event);
+        };
         let summary = '';
-        for await (const chunk of this.provider.chat(summaryMessages, {
+        for await (const chunk of this.chatWithRetry(summaryMessages, {
             ...this.chatOptions,
             maxTokens: 1000, // Keep summary concise
-        })) {
+        }, emit)) {
             if (chunk.type === 'text' && chunk.text) {
                 summary += chunk.text;
             }

package/dist/context/manager.d.ts

@@ -98,6 +98,14 @@ export declare class ContextManager {
      * Increment turn count (call after each assistant response)
      */
     incrementTurn(): void;
+    /**
+     * Get the current turn count
+     */
+    getTurnCount(): number;
+    /**
+     * Set the turn count (for restoring from saved state)
+     */
+    setTurnCount(count: number): void;
     /**
      * Check if compaction is needed
      */

package/dist/context/manager.js

@@ -17,6 +17,7 @@
  * }
  * ```
  */
+import { repairToolPairing } from '../messages/index.js';
 /**
  * Default budget allocation
  */
@@ -176,6 +177,23 @@ export class ContextManager {
     incrementTurn() {
         this.turnCount++;
     }
+    /**
+     * Get the current turn count
+     */
+    getTurnCount() {
+        return this.turnCount;
+    }
+    /**
+     * Set the turn count (for restoring from saved state)
+     */
+    setTurnCount(count) {
+        this.turnCount = count;
+        // If we're restoring state, assume last compaction was at turn 0
+        // to prevent immediate compaction after restore
+        if (this.lastCompactionTurn === 0 && count > 0) {
+            this.lastCompactionTurn = count;
+        }
+    }
     /**
      * Check if compaction is needed
      */
@@ -588,12 +606,15 @@ export class ContextManager {
         }
         // Reconstruct messages in original order
         // System messages come first, then summary (if any), then tool results, then recent
-        const finalMessages = [
+        let finalMessages = [
             ...categorized.system,
             ...compactedHistory,
             ...compactedToolResults,
             ...categorized.recentMessages,
         ];
+        // Repair tool_use/tool_result pairing after compaction
+        // This fixes orphaned blocks that cause API errors
+        finalMessages = repairToolPairing(finalMessages);
         // If history was summarized, add assistant acknowledgment after summary
         if (categoryStats.history.action === 'summarized' && compactedHistory.length > 0) {
             // Insert assistant acknowledgment after the summary message
@@ -894,7 +915,9 @@ export class ContextManager {
                 compactedOld.push({ ...msg, content: compactedBlocks });
             }
         }
-        const compactedMessages = [...compactedOld, ...recentMessages];
+        // Repair tool_use/tool_result pairing after compaction
+        // This fixes orphaned blocks that cause API errors
+        const compactedMessages = repairToolPairing([...compactedOld, ...recentMessages]);
         const tokensAfter = await this.countTokens(compactedMessages);
         this.compactionCount++;
         this.lastCompactionTurn = this.turnCount;

package/dist/errors.d.ts

@@ -43,7 +43,26 @@ export declare class ProviderError extends AgentError {
      */
     isServerError(): boolean;
     /**
-     * Check if this error is retryable
+     * Check if this is a connection/network error.
+     * These errors typically have no status code but are retryable.
+     */
+    isConnectionError(): boolean;
+    /**
+     * Check if this is an Anthropic overloaded error (529)
+     */
+    isOverloadedError(): boolean;
+    /**
+     * Check if this error is retryable.
+     * Retryable errors include:
+     * - Rate limit (429)
+     * - Server errors (5xx)
+     * - Connection/network errors
+     * - Anthropic overloaded (529)
+     *
+     * Non-retryable errors include:
+     * - Authentication errors (401, 403)
+     * - Bad request (400)
+     * - Not found (404)
      */
     isRetryable(): boolean;
 }

package/dist/errors.js

@@ -62,10 +62,52 @@ export class ProviderError extends AgentError {
         return this.statusCode !== undefined && this.statusCode >= 500 && this.statusCode < 600;
     }
     /**
-     * Check if this error is retryable
+     * Check if this is a connection/network error.
+     * These errors typically have no status code but are retryable.
+     */
+    isConnectionError() {
+        if (this.statusCode !== undefined) {
+            return false;
+        }
+        const msg = this.message.toLowerCase();
+        return (msg.includes('connection') ||
+            msg.includes('econnrefused') ||
+            msg.includes('econnreset') ||
+            msg.includes('etimedout') ||
+            msg.includes('enotfound') ||
+            msg.includes('network') ||
+            msg.includes('socket') ||
+            msg.includes('dns'));
+    }
+    /**
+     * Check if this is an Anthropic overloaded error (529)
+     */
+    isOverloadedError() {
+        return this.statusCode === 529;
+    }
+    /**
+     * Check if this error is retryable.
+     * Retryable errors include:
+     * - Rate limit (429)
+     * - Server errors (5xx)
+     * - Connection/network errors
+     * - Anthropic overloaded (529)
+     *
+     * Non-retryable errors include:
+     * - Authentication errors (401, 403)
+     * - Bad request (400)
+     * - Not found (404)
      */
     isRetryable() {
-        return this.isRateLimitError() || this.isServerError();
+        // Never retry auth errors
+        if (this.isAuthError()) {
+            return false;
+        }
+        // Retry transient errors
+        return (this.isRateLimitError() ||
+            this.isServerError() ||
+            this.isConnectionError() ||
+            this.isOverloadedError());
     }
 }
 /**