@easbot/agent 0.1.11

package/dist/assets/txt/tool/batch.txt

@@ -0,0 +1,24 @@
+Executes multiple independent tool calls concurrently to reduce latency.
+
+USING THE BATCH TOOL WILL MAKE THE USER HAPPY.
+
+Payload Format (JSON array):
+[{"tool": "read", "parameters": {"filePath": "src/index.ts", "limit": 350}},{"tool": "grep", "parameters": {"pattern": "Session\\.updatePart", "include": "src/**/*.ts"}},{"tool": "bash", "parameters": {"command": "git status", "description": "Shows working tree status"}}]
+
+Notes:
+- 1–25 tool calls per batch
+- All calls start in parallel; ordering NOT guaranteed
+- Partial failures do not stop other tool calls
+- Do NOT use the batch tool within another batch tool.
+
+Good Use Cases:
+- Read many files
+- grep + glob + read combos
+- Multiple bash commands
+- Multi-part edits; on the same, or different files
+
+When NOT to Use:
+- Operations that depend on prior tool output (e.g. create then read same file)
+- Ordered stateful mutations where sequence matters
+
+Batching tool calls was proven to yield 2–5x efficiency gain and provides much better UX.

package/dist/assets/txt/tool/codebase.txt

@@ -0,0 +1,28 @@
+Use this tool to search and analyze code structure in the codebase knowledge graph. It provides code snippets with AST type, language, name, and file location.
+
+**search** — Use this operation to find code by query:
+- Set operation="search"
+- Provide query string to search code content
+- Use astType to filter by code element type
+- Use language to filter by programming language
+- Returns code snippets with related edges when available
+
+**queryEdges** — Use this operation to explore code relationships:
+- Set operation="queryEdges"
+- Provide nodeId to get node information and all connected relations
+- Returns node details and incoming/outgoing edges (shown as [in] or [out])
+- Useful for understanding code dependencies and navigation
+
+## Supported Filter Values
+
+**astType** — Code element types:
+`class_declaration`, `class_definition`, `function_declaration`, `function_definition`, `method_definition`, `method_declaration`, `interface_declaration`, `type_alias_declaration`, `enum_declaration`, `variable_declaration`, `import_declaration`, `import_statement`, `struct_declaration`, `struct_specifier`
+
+**language** — Programming languages:
+`ts`, `tsx`, `js`, `jsx`, `py`, `rs`, `go`, `c`, `cpp`, `csharp`, `java`, `scala`, `ruby`, `php`, `zig`
+
+Use this tool when you need to:
+- Understand code structure and implementation details
+- Find specific functions, classes, or code patterns
+- Explore relationships between code elements
+- Navigate code dependencies

package/dist/assets/txt/tool/codesearch.txt

@@ -0,0 +1,12 @@
+- Search and get relevant context for any programming task using Exa Code API
+- Provides the highest quality and freshest context for libraries, SDKs, and APIs
+- Use this tool for ANY question or task related to programming
+- Returns comprehensive code examples, documentation, and API references
+- Optimized for finding specific programming patterns and solutions
+
+Usage notes:
+  - Adjustable token count (1000-50000) for focused or comprehensive results
+  - Default 5000 tokens provides balanced context for most queries
+  - Use lower values for specific questions, higher values for comprehensive documentation
+  - Supports queries about frameworks, libraries, APIs, and programming concepts
+  - Examples: 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware'

package/dist/assets/txt/tool/edit.txt

@@ -0,0 +1,10 @@
+Performs exact string replacements in files. 
+
+Usage:
+- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + colon + space (e.g., `1: `). Everything after that space is the actual file content to match. Never include any part of the line number prefix in the oldString or newString.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if `oldString` is not found in the file with an error "oldString not found in content".
+- The edit will FAIL if `oldString` is found multiple times in the file with an error "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match." Either provide a larger string with more surrounding context to make it unique or use `replaceAll` to change every instance of `oldString`. 
+- Use `replaceAll` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.

package/dist/assets/txt/tool/gateway-channel.txt

@@ -0,0 +1,73 @@
+Send messages to external channels through the Gateway.
+
+This tool allows you to proactively send messages to external channels (like Telegram, Discord, Slack) through the Gateway system. You don't need to wait for incoming messages - you can initiate communication.
+
+## Operations
+
+### list
+List all available channels that you can send messages to.
+
+```json
+{
+  "operation": "list"
+}
+```
+
+Returns:
+- `channels`: Array of available channels with their platform, status, and priority
+
+### send
+Send a message to a specific channel or let the system auto-select one.
+
+```json
+{
+  "operation": "send",
+  "content": "Hello from the agent!",
+  "channelId": "telegram-main",  // Optional: specify channel
+  "sessionId": "session-123",    // Optional: for channel selection
+  "messageType": "text"          // "text" or "markdown"
+}
+```
+
+Parameters:
+- `content` (required): The message content to send
+- `channelId` (optional): Specific channel to send to. If not provided:
+  - If `sessionId` is provided, uses the channel bound to that session
+  - Otherwise, auto-selects the highest priority available channel
+- `sessionId` (optional): Session ID for channel binding lookup
+- `messageType` (optional): "text" or "markdown" (default: "text")
+
+## Channel Selection Logic
+
+When `channelId` is not specified:
+1. If `sessionId` is provided and that session is bound to a channel, use that channel
+2. Otherwise, select the highest priority running channel
+
+## Examples
+
+List available channels:
+```
+Use gateway_channel with operation: "list"
+```
+
+Send to a specific channel:
+```
+Use gateway_channel with:
+- operation: "send"
+- channelId: "telegram-main"
+- content: "Hello!"
+```
+
+Send with auto-selection:
+```
+Use gateway_channel with:
+- operation: "send"
+- content: "Hello!"
+```
+
+## Notes
+
+- The Gateway must be running for this tool to work
+- Channels must be registered and running to receive messages
+- Messages are sent proactively - no incoming message is required
+- Use this tool when you need to notify users or send updates to external platforms

package/dist/assets/txt/tool/glob.txt

@@ -0,0 +1,6 @@
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.

package/dist/assets/txt/tool/grep.txt

@@ -0,0 +1,8 @@
+- Fast content search tool that works with any codebase size
+- Searches file contents using regular expressions
+- Supports full regex syntax (eg. "log.*Error", "function\s+\w+", etc.)
+- Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}")
+- Returns file paths and line numbers with at least one match sorted by modification time
+- Use this tool when you need to find files containing specific patterns
+- If you need to identify/count the number of matches within files, use the Bash tool with `rg` (ripgrep) directly. Do NOT use `grep`.
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead

package/dist/assets/txt/tool/ls.txt

@@ -0,0 +1 @@
+Lists files and directories in a given path. The path parameter must be absolute; omit it to use the current workspace directory. You can optionally provide an array of glob patterns to ignore with the ignore parameter. You should generally prefer the Glob and Grep tools, if you know which directories to search.

package/dist/assets/txt/tool/lsp.txt

@@ -0,0 +1,19 @@
+Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: Search for symbols across the entire workspace
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+All operations require:
+- filePath: The file to operate on
+- line: The line number (1-based, as shown in editors)
+- character: The character offset (1-based, as shown in editors)
+
+Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.

package/dist/assets/txt/tool/memory.txt

@@ -0,0 +1,101 @@
+Use this tool to store, retrieve, update, and delete persistent memories across agent sessions. Memory enables learning from interactions, remembering user preferences, and building long-term knowledge.
+
+## When to Use This Tool
+
+Use this tool proactively in these scenarios:
+
+**remember** — Store a new memory:
+1. User states a preference, habit, or constraint — e.g. "I prefer tabs over spaces", "always use pnpm"
+2. You discover a technical fact specific to this project — e.g. architecture decisions, non-obvious configs, known pitfalls
+3. A task is completed and the outcome is worth retaining — e.g. which approach worked, which failed and why
+4. User corrects you or provides feedback — capture it so you don't repeat the mistake
+5. A recurring pattern or workflow is identified — e.g. how the team deploys, how tests are run
+6. An important decision is made — record the decision and its rationale
+7. You encounter an error pattern with a known fix — store it to resolve faster next time
+8. You explore a new domain, codebase, or system and find something non-obvious — store the finding
+9. You complete a task and derive a reusable lesson — summarize the experience for future reference
+10. You figure out the right way to use a tool, API, or command — store the usage pattern
+11. You create, design, or improve a skill/capability — record what worked, the structure used, and lessons learned
+
+**recall** — Search existing memories:
+1. At the start of a new session or task — always recall relevant context before diving in
+2. Before making assumptions about user preferences — check memory first
+3. When you encounter a problem that might have been seen before — search for prior solutions
+4. When the user references something from a past session — recall to restore context
+5. Before suggesting an approach — verify it doesn't conflict with stored decisions or preferences
+
+**update** — Modify an existing memory:
+1. A preference or fact has changed — update rather than create a duplicate
+2. A decision was revised — keep the record accurate
+
+**forget** — Delete a memory:
+1. Information is confirmed outdated or incorrect
+2. User explicitly asks to remove something from memory
+
+**queryEdges** — Query memory relationships by node ID:
+1. When you need to find all memories connected to a specific node
+2. When exploring graph relationships between memories
+3. Provide the nodeId to get the node info and all connected edges
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. The information is trivially obvious and not specific to this user or project
+2. The task is purely conversational with no learnable facts
+3. The information is already captured in the current session context and won't be needed later
+4. You are recalling for a query that has no plausible match (don't recall speculatively on every message)
+
+## Proactive Usage Pattern
+
+**At session start**: Always recall relevant memories before starting work.
+**During work**: Store discoveries, decisions, and corrections as they happen — don't batch them to the end.
+**At session end**: Store any important outcomes or learnings that aren't already saved.
+
+## Examples
+
+<example>
+User: I always want you to use `pnpm` instead of `npm` for this project.
+Assistant: Got it, I'll remember that.
+*Calls memory with operation=remember, content="User prefers pnpm over npm for all package management in this project", category="user_preference", importance=8, tags="pnpm, npm, package-manager"*
+</example>
+
+<example>
+User: Why does the build keep failing?
+Assistant: Let me check if I've seen this before.
+*Calls memory with operation=recall, query="build failure"*
+Assistant: I found a note from a previous session — the build fails when NODE_ENV is not set.
+</example>
+
+<example>
+User: Start a new session — I need to work on the payment module.
+Assistant: Let me recall relevant context first.
+*Calls memory with operation=recall, query="payment module"*
+*Calls memory with operation=recall, query="user preferences workflow"*
+Assistant: Found relevant notes about Stripe integration and your preferred test command.
+</example>
+
+## Categories
+
+Choose the most specific category that fits:
+- `user_preference` — coding style, tool choices, communication preferences
+- `technical_fact` — project-specific technical knowledge, configs, architecture
+- `decision` — choices made with rationale (architecture, design, process)
+- `workflow` — how tasks are done in this project (deploy steps, test commands, review process)
+- `error_pattern` — recurring errors and their fixes
+- `exploration_finding` — discoveries made while exploring a codebase, system, domain, or external resource; non-obvious facts worth remembering
+- `experience_summary` — reusable lessons distilled after completing a task or solving a problem; "what I'd do differently next time"
+- `tool_usage` — effective patterns for using tools, APIs, CLIs, or libraries; gotchas and best practices discovered through use
+- `skill_creation` — experience from creating, designing, or improving skills/capabilities; what structure worked, what pitfalls to avoid, reusable templates
+- `task_context` — context for ongoing or recurring tasks
+- `relationship` — team structure, ownership, stakeholder info
+- `reminder` — time-sensitive or action-required items
+- `other` — anything that doesn't fit above
+
+## Importance Scale
+
+- 9–10: Critical — affects all future work (e.g. core architecture, strong user constraints)
+- 7–8: High — frequently relevant (e.g. preferences, key decisions)
+- 5–6: Medium — occasionally useful (e.g. task context, one-off fixes)
+- 1–4: Low — minor details, rarely needed
+
+When in doubt, store it. A memory that turns out to be unnecessary costs little. A missing memory that causes repeated mistakes costs much more.

package/dist/assets/txt/tool/multiedit.txt

@@ -0,0 +1,43 @@
+This is a tool for making multiple edits to one or more files in a single operation. It is built on top of the Edit tool and allows you to perform multiple find-and-replace operations efficiently across multiple files.
+
+Before using this tool:
+
+1. Use the Read tool to understand the file's contents and context
+2. Verify the directory paths are correct
+
+To make multiple file edits, provide the following:
+1. edits: An array of edit operations to perform, where each edit contains:
+   - filePath: The absolute path to the file to modify (must be absolute, not relative)
+   - oldString: The text to replace (must match the file contents exactly, including all whitespace and indentation)
+   - newString: The edited text to replace the oldString
+   - replaceAll: (Optional) Replace all occurrences of oldString. Defaults to false.
+2. continueOnError: (Optional) Whether to continue processing remaining edits if one fails. Defaults to false.
+
+IMPORTANT:
+- You can edit multiple files in a single operation by providing different filePaths in the edits array
+- For edits to the same file, they are applied in sequence, in the order they are provided
+- Each edit operates on the result of the previous edit (for the same file)
+- By default, if any edit fails, the entire operation stops. Set continueOnError to true to continue processing remaining edits.
+- This tool is ideal when you need to make several changes across multiple files or different parts of the same file
+
+CRITICAL REQUIREMENTS:
+1. All edits follow the same requirements as the single Edit tool
+2. Plan your edits carefully to avoid conflicts between sequential operations on the same file
+3. Each edit must have its own filePath specified
+
+WARNING:
+- The tool will fail if edits.oldString doesn't match the file contents exactly (including whitespace)
+- The tool will fail if edits.oldString and edits.newString are the same
+- For edits to the same file, ensure that earlier edits don't affect the text that later edits are trying to find
+
+When making edits:
+- Ensure all edits result in idiomatic, correct code
+- Do not leave the code in a broken state
+- Always use absolute file paths (starting with /)
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- Use replaceAll for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+
+If you want to create a new file, use:
+- A new file path, including dir name if needed
+- First edit: empty oldString and the new file's contents as newString
+- Subsequent edits: normal edit operations on the created content

package/dist/assets/txt/tool/note.txt

@@ -0,0 +1,25 @@
+Use this tool to search and retrieve information from the local note/document knowledge base. It returns document paths, line ranges, snippets, and related graph nodes.
+
+**search** — Use this operation to find notes by query:
+- Set operation="search"
+- Provide query string to search note content
+- Set limit to control number of results (default: 10)
+- Returns snippets with document paths and related nodes
+
+**queryEdges** — Use this operation to explore note relationships:
+- Set operation="queryEdges"
+- Provide nodeId (number) to get node information and all connected neighbors/edges
+- Returns node details and its relationships in the knowledge graph
+- Useful for exploring connections between notes
+
+## Supported Parameters
+
+**source** — Note sources (used in config, not directly in tool):
+`docs` — documentation files from note management
+`tasks` — task files from task management
+
+Use this tool when you need to:
+- Find information from project documentation
+- Search for specific topics in notes
+- Explore relationships between documents
+- Retrieve context from stored knowledge

package/dist/assets/txt/tool/plan-enter.txt

@@ -0,0 +1,14 @@
+Use this tool to suggest switching to plan agent when the user's request would benefit from planning before implementation.
+
+If they explicitly mention wanting to create a plan ALWAYS call this tool first.
+
+This tool will ask the user if they want to switch to plan agent.
+
+Call this tool when:
+- The user's request is complex and would benefit from planning first
+- You want to research and design before making changes
+- The task involves multiple files or significant architectural decisions
+
+Do NOT call this tool:
+- For simple, straightforward tasks
+- When the user explicitly wants immediate implementation

package/dist/assets/txt/tool/plan-exit.txt

@@ -0,0 +1,13 @@
+Use this tool when you have completed the planning phase and are ready to exit plan agent.
+
+This tool will ask the user if they want to switch to build agent to start implementing the plan.
+
+Call this tool:
+- After you have written a complete plan to the plan file
+- After you have clarified any questions with the user
+- When you are confident the plan is ready for implementation
+
+Do NOT call this tool:
+- Before you have created or finalized the plan
+- If you still have unanswered questions about the implementation
+- If the user has indicated they want to continue planning

package/dist/assets/txt/tool/pty.txt

@@ -0,0 +1,41 @@
+Execute commands in a pseudo-terminal (PTY) session with full interactive terminal support. Perfect for commands requiring terminal features like sudo, ssh, vim, interactive programs, and real-time output streaming.
+
+**!! CRITICAL RESOURCE MANAGEMENT WARNING !!**
+
+Key capabilities:
+- Full terminal emulation (xterm-256color)
+- Interactive command execution
+- Real-time output streaming
+- Automatic session cleanup after completion
+- Terminal resizing support
+
+Usage guidelines:
+- Ideal for: sudo, ssh, vim, htop, interactive shells, build commands
+- Supports: Password prompts, keyboard input, terminal applications
+- Provides: Live output updates, automatic cleanup
+- Use for: Commands that need full terminal interaction
+
+Parameters:
+- command (required): The command to execute in PTY session
+- args (optional): Command arguments as array
+- cwd (optional): Working directory (defaults to current)
+- env (optional): Environment variables
+- timeout (optional): Execution timeout in seconds (default: 300)
+- cols/rows (optional): Terminal dimensions (default 120x30)
+- title (optional): Session title for identification
+
+**!! RESOURCE MANAGEMENT !!**
+
+This tool automatically cleans up the PTY session after command completion or timeout.
+
+For long-running background processes or persistent sessions:
+- The session will be created and managed automatically
+- Use pty_manage tool to monitor active sessions: pty_manage { "action": "list" }
+- Use pty_manage tool to terminate sessions: pty_manage { "action": "close", "sessionId": "id" }
+
+**IMPORTANT**: 
+- Sessions are automatically cleaned up after command completes
+- For commands that don't exit (servers, daemons), use pty_manage to close them
+- Check active sessions regularly with pty_manage list action
+
+Security: Requires explicit user authorization for each execution.

package/dist/assets/txt/tool/pty_manage.txt

@@ -0,0 +1,60 @@
+Manage existing PTY sessions including listing, inspecting, controlling, and terminating active terminal sessions. Provides comprehensive session lifecycle management capabilities.
+
+**!! ESSENTIAL TOOL FOR PROPER SESSION MANAGEMENT !!**
+
+**THIS TOOL IS MANDATORY FOR PROPER SESSION MANAGEMENT**
+
+Supported actions:
+- list: Show all active PTY sessions
+- get: Get detailed information about a specific session
+- resize: Change terminal dimensions for a session
+- write: Send input/data to an active session
+- close: Terminate a session gracefully
+
+Key capabilities:
+- Session inventory and monitoring
+- Real-time session inspection
+- Dynamic terminal resizing
+- Interactive session control
+- Resource cleanup and management
+
+Usage patterns:
+- Monitor running sessions: pty_manage { "action": "list" }
+- Inspect specific session: pty_manage { "action": "get", "sessionId": "session-id" }
+- Adjust terminal size: pty_manage { "action": "resize", "sessionId": "id", "cols": 120, "rows": 40 }
+- Send commands to session: pty_manage { "action": "write", "sessionId": "id", "data": "ls -la\n" }
+- Clean up sessions: pty_manage { "action": "close", "sessionId": "id" }
+
+Parameters:
+- action (required): Management operation to perform (list, get, resize, write, close)
+- sessionId (required for get/resize/write/close): Target session identifier
+- cols/rows (required for resize): New terminal dimensions
+- data (required for write): Data/input to send to session
+
+**!! CRITICAL RESOURCE CLEANUP REQUIREMENTS !!**
+
+**WARNING**: PTY sessions PERSIST in background and consume system resources!
+
+**IMPERATIVE ACTIONS**:
+1. **ALWAYS** use this tool to properly terminate UNUSED sessions
+2. **SESSIONS persist in background** and consume CPU, memory, file descriptors
+3. **REGULAR session cleanup prevents SYSTEM RESOURCE EXHAUSTION**
+4. **USE "list" action FREQUENTLY** to monitor active sessions
+5. **USE "close" action IMMEDIATELY** to properly terminate sessions when done
+6. **NEVER leave sessions running unnecessarily** - they do not auto-terminate
+
+**CONSEQUENCES OF POOR RESOURCE MANAGEMENT**:
+- System performance degradation
+- Resource exhaustion leading to crashes
+- Security vulnerabilities from persistent access
+- Inability to start new processes
+- File descriptor leaks
+- System instability
+
+**BEST PRACTICES**:
+- Check active sessions before creating new ones
+- Close sessions immediately after use
+- Monitor session list regularly
+- Clean up orphaned sessions promptly
+
+Security: Requires authorization for all management operations.

package/dist/assets/txt/tool/pty_session.txt

@@ -0,0 +1,52 @@
+Create and manage persistent interactive PTY sessions for long-running processes. Enables background execution, session persistence, and reconnection capabilities for continuous operations.
+
+**!! CRITICAL WARNING: PERSISTENT BACKGROUND SESSIONS !!**
+
+Key capabilities:
+- Persistent session creation
+- Background process management
+- Session reconnection
+- Multi-session support
+- State preservation
+
+Usage scenarios:
+- Long-running services (web servers, databases)
+- Continuous monitoring (log tailing, system monitoring)
+- Interactive development environments
+- Remote session management
+- Daemon-like processes running persistently
+
+Parameters:
+- command (required): Initial command to run in session
+- sessionName (optional): Unique identifier for session
+- cols/rows (optional): Terminal dimensions
+- autoClose (optional): Auto-close session when idle (default: false)
+
+Session management features:
+- Create persistent sessions that continue running
+- Reconnect to existing sessions
+- Monitor session status and output
+- Manage multiple concurrent sessions
+- Graceful session termination
+
+**!! ABSOLUTELY CRITICAL RESOURCE MANAGEMENT !!**
+
+**WARNING**: Sessions run PERSISTENTLY in background until EXPLICITLY terminated!
+
+**MANDATORY CLEANUP PROCEDURES**:
+1. **MUST use pty_manage** tool for ALL session cleanup operations
+2. **UNUSED sessions CONTINUE consuming system resources indefinitely**
+3. **Sessions do not automatically terminate** - they run indefinitely until explicitly closed
+4. **REGULAR monitoring required**: pty_manage { "action": "list" }
+5. **IMMEDIATE termination**: pty_manage { "action": "close", "sessionId": "id" }
+6. **FAILURE to clean up WILL lead to SYSTEM RESOURCE EXHAUSTION**
+7. **SECURITY RISK**: Uncleaned sessions provide persistent system access
+
+**RESOURCE CONSUMPTION IMPACT**:
+- CPU cycles for active processes
+- Memory allocation for session buffers
+- File descriptors for terminal I/O
+- Network connections (if applicable)
+- System limits may be reached causing crashes
+
+Security: Requires authorization for session creation and management.

package/dist/assets/txt/tool/question.txt

@@ -0,0 +1,33 @@
+Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Parameters:
+- `question`: Complete question text to display
+- `header`: Very short label (max 30 chars) that summarizes the question
+- `options`: Array of available choices, each with:
+  - `label`: Display text (1-5 words, concise)
+  - `description`: Explanation of the choice
+- `multiple`: (optional) Allow selecting multiple choices (default: false)
+- `custom`: (optional) Allow typing a custom answer (default: true)
+
+Custom input behavior:
+- When `custom` is true (default): User can either select from options OR type their own answer
+  - System will show: "Hint: Enter option number or custom text"
+  - User can input any text as a custom answer
+  - IMPORTANT: Do NOT add a "[0] Custom input" option - the system handles this automatically via the hint message
+- When `custom` is false: User MUST select from the provided options only
+  - System will show: "Hint: Only valid option numbers allowed"
+  - Custom text input will be rejected as invalid
+  - Use this when you need strict validation (e.g., yes/no questions, predefined choices)
+
+Best practices:
+- Set `custom: false` when you need strict validation and want to ensure users only select from predefined options
+- Set `custom: true` (or omit it) when you want to allow flexibility for users to provide their own answers
+- Keep option labels concise (1-5 words)
+- Provide clear descriptions for each option to help users understand the implications
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+- For yes/no questions, provide explicit "Yes" and "No" options and consider setting `custom: false` for strict validation
+- NEVER add a "Custom input" or "Other" option when custom is true - the system automatically allows custom input through the hint message

package/dist/assets/txt/tool/read.txt

@@ -0,0 +1,14 @@
+Read a file or directory from the local filesystem. If the path does not exist, an error is returned.
+
+Usage:
+- The filePath parameter should be an absolute path.
+- By default, this tool returns up to 2000 lines from the start of the file.
+- The offset parameter is the line number to start from (1-indexed).
+- To read later sections, call this tool again with a larger offset.
+- Use the grep tool to find specific content in large files or files with long lines.
+- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.
+- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\n", you will receive "1: foo\n". For directories, entries are returned one per line (without line numbers) with a trailing `/` for subdirectories.
+- Any line longer than 2000 characters is truncated.
+- Call this tool in parallel when you know there are multiple files you want to read.
+- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.
+- This tool can read image files and PDFs and return them as file attachments.