micode 0.7.0 → 0.7.1

package/src/tools/pty/tools/list.ts

@@ -0,0 +1,55 @@
+// src/tools/pty/tools/list.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import type { PTYManager } from "../manager";
+
+const DESCRIPTION = `Lists all PTY sessions (active and exited).
+
+Use this tool to:
+- See all running and exited PTY sessions
+- Get session IDs for use with other pty_* tools
+- Check the status and output line count of each session
+- Monitor which processes are still running
+
+Returns for each session:
+- \`id\`: Unique identifier for use with other tools
+- \`title\`: Human-readable name
+- \`command\`: The command that was executed
+- \`status\`: Current status (running, exited, killed)
+- \`exitCode\`: Exit code (if exited/killed)
+- \`pid\`: Process ID
+- \`lineCount\`: Number of lines in the output buffer
+- \`createdAt\`: When the session was created
+
+Tips:
+- Use the session ID with pty_read, pty_write, or pty_kill
+- Sessions remain in the list after exit until explicitly cleaned up with pty_kill
+- This allows you to compare output from multiple sessions`;
+
+export function createPtyListTool(manager: PTYManager) {
+  return tool({
+    description: DESCRIPTION,
+    args: {},
+    execute: async () => {
+      const sessions = manager.list();
+
+      if (sessions.length === 0) {
+        return "<pty_list>\nNo active PTY sessions.\n</pty_list>";
+      }
+
+      const lines = ["<pty_list>"];
+      for (const session of sessions) {
+        const exitInfo = session.exitCode !== undefined ? ` (exit: ${session.exitCode})` : "";
+        lines.push(`[${session.id}] ${session.title}`);
+        lines.push(`  Command: ${session.command} ${session.args.join(" ")}`);
+        lines.push(`  Status: ${session.status}${exitInfo}`);
+        lines.push(`  PID: ${session.pid} | Lines: ${session.lineCount} | Workdir: ${session.workdir}`);
+        lines.push(`  Created: ${session.createdAt.toISOString()}`);
+        lines.push("");
+      }
+      lines.push(`Total: ${sessions.length} session(s)`);
+      lines.push("</pty_list>");
+
+      return lines.join("\n");
+    },
+  });
+}

package/src/tools/pty/tools/read.ts

@@ -0,0 +1,152 @@
+// src/tools/pty/tools/read.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import type { PTYManager } from "../manager";
+
+const DESCRIPTION = `Reads output from a PTY session's buffer.
+
+The PTY maintains a rolling buffer of output lines. Use offset and limit to paginate through the output, similar to reading a file.
+
+Usage:
+- \`id\`: The PTY session ID (from pty_spawn or pty_list)
+- \`offset\`: Line number to start reading from (0-based, defaults to 0)
+- \`limit\`: Number of lines to read (defaults to 500)
+- \`pattern\`: Regex pattern to filter lines (optional)
+- \`ignoreCase\`: Case-insensitive pattern matching (default: false)
+
+Returns:
+- Numbered lines of output (similar to cat -n format)
+- Total line count in the buffer
+- Indicator if more lines are available
+
+The buffer stores up to PTY_MAX_BUFFER_LINES (default: 50000) lines. Older lines are discarded when the limit is reached.
+
+Pattern Filtering:
+- When \`pattern\` is set, lines are FILTERED FIRST using the regex, then offset/limit apply to the MATCHES
+- Original line numbers are preserved so you can see where matches occurred in the buffer
+- Supports full regex syntax (e.g., "error", "ERROR|WARN", "failed.*connection", etc.)
+- If the pattern is invalid, an error message is returned explaining the issue
+- If no lines match the pattern, a clear message indicates zero matches
+
+Tips:
+- To see the latest output, use a high offset or omit offset to read from the start
+- To tail recent output, calculate offset as (totalLines - N) where N is how many recent lines you want
+- Lines longer than 2000 characters are truncated
+- Empty output may mean the process hasn't produced output yet
+
+Examples:
+- Read first 100 lines: offset=0, limit=100
+- Read lines 500-600: offset=500, limit=100
+- Read all available: omit both parameters
+- Find errors: pattern="error", ignoreCase=true
+- Find specific log levels: pattern="ERROR|WARN|FATAL"
+- First 10 matches only: pattern="error", limit=10`;
+
+const DEFAULT_LIMIT = 500;
+const MAX_LINE_LENGTH = 2000;
+
+export function createPtyReadTool(manager: PTYManager) {
+  return tool({
+    description: DESCRIPTION,
+    args: {
+      id: tool.schema.string().describe("The PTY session ID (e.g., pty_a1b2c3d4)"),
+      offset: tool.schema.number().optional().describe("Line number to start reading from (0-based, defaults to 0)"),
+      limit: tool.schema.number().optional().describe("Number of lines to read (defaults to 500)"),
+      pattern: tool.schema.string().optional().describe("Regex pattern to filter lines"),
+      ignoreCase: tool.schema.boolean().optional().describe("Case-insensitive pattern matching (default: false)"),
+    },
+    execute: async (args) => {
+      const session = manager.get(args.id);
+      if (!session) {
+        throw new Error(`PTY session '${args.id}' not found. Use pty_list to see active sessions.`);
+      }
+
+      const offset = Math.max(0, args.offset ?? 0);
+      const limit = args.limit ?? DEFAULT_LIMIT;
+
+      if (args.pattern) {
+        let regex: RegExp;
+        try {
+          regex = new RegExp(args.pattern, args.ignoreCase ? "i" : "");
+        } catch (e) {
+          const error = e instanceof Error ? e.message : String(e);
+          throw new Error(`Invalid regex pattern '${args.pattern}': ${error}`);
+        }
+
+        const result = manager.search(args.id, regex, offset, limit);
+        if (!result) {
+          throw new Error(`PTY session '${args.id}' not found.`);
+        }
+
+        if (result.matches.length === 0) {
+          return [
+            `<pty_output id="${args.id}" status="${session.status}" pattern="${args.pattern}">`,
+            `No lines matched the pattern '${args.pattern}'.`,
+            `Total lines in buffer: ${result.totalLines}`,
+            `</pty_output>`,
+          ].join("\n");
+        }
+
+        const formattedLines = result.matches.map((match) => {
+          const lineNum = match.lineNumber.toString().padStart(5, "0");
+          const truncatedLine =
+            match.text.length > MAX_LINE_LENGTH ? `${match.text.slice(0, MAX_LINE_LENGTH)}...` : match.text;
+          return `${lineNum}| ${truncatedLine}`;
+        });
+
+        const output = [
+          `<pty_output id="${args.id}" status="${session.status}" pattern="${args.pattern}">`,
+          ...formattedLines,
+          "",
+        ];
+
+        if (result.hasMore) {
+          output.push(
+            `(${result.matches.length} of ${result.totalMatches} matches shown. Use offset=${offset + result.matches.length} to see more.)`,
+          );
+        } else {
+          output.push(
+            `(${result.totalMatches} match${result.totalMatches === 1 ? "" : "es"} from ${result.totalLines} total lines)`,
+          );
+        }
+        output.push(`</pty_output>`);
+
+        return output.join("\n");
+      }
+
+      const result = manager.read(args.id, offset, limit);
+      if (!result) {
+        throw new Error(`PTY session '${args.id}' not found.`);
+      }
+
+      if (result.lines.length === 0) {
+        return [
+          `<pty_output id="${args.id}" status="${session.status}">`,
+          `(No output available - buffer is empty)`,
+          `Total lines: ${result.totalLines}`,
+          `</pty_output>`,
+        ].join("\n");
+      }
+
+      const formattedLines = result.lines.map((line, index) => {
+        const lineNum = (result.offset + index + 1).toString().padStart(5, "0");
+        const truncatedLine = line.length > MAX_LINE_LENGTH ? `${line.slice(0, MAX_LINE_LENGTH)}...` : line;
+        return `${lineNum}| ${truncatedLine}`;
+      });
+
+      const output = [`<pty_output id="${args.id}" status="${session.status}">`, ...formattedLines];
+
+      if (result.hasMore) {
+        output.push("");
+        output.push(
+          `(Buffer has more lines. Use offset=${result.offset + result.lines.length} to read beyond line ${result.offset + result.lines.length})`,
+        );
+      } else {
+        output.push("");
+        output.push(`(End of buffer - total ${result.totalLines} lines)`);
+      }
+      output.push(`</pty_output>`);
+
+      return output.join("\n");
+    },
+  });
+}

package/src/tools/pty/tools/spawn.ts

@@ -0,0 +1,78 @@
+// src/tools/pty/tools/spawn.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import type { PTYManager } from "../manager";
+
+const DESCRIPTION = `Spawns a new interactive PTY (pseudo-terminal) session that runs in the background.
+
+Unlike the built-in bash tool which runs commands synchronously and waits for completion, PTY sessions persist and allow you to:
+- Run long-running processes (dev servers, watch modes, etc.)
+- Send interactive input (including Ctrl+C, arrow keys, etc.)
+- Read output at any time
+- Manage multiple concurrent terminal sessions
+
+Usage:
+- The \`command\` parameter is required (e.g., "npm", "python", "bash")
+- Use \`args\` to pass arguments to the command (e.g., ["run", "dev"])
+- Use \`workdir\` to set the working directory (defaults to project root)
+- Use \`env\` to set additional environment variables
+- Use \`title\` to give the session a human-readable name
+- Use \`description\` for a clear, concise 5-10 word description (optional)
+
+Returns the session info including:
+- \`id\`: Unique identifier (pty_XXXXXXXX) for use with other pty_* tools
+- \`pid\`: Process ID
+- \`status\`: Current status ("running")
+
+After spawning, use:
+- \`pty_write\` to send input to the PTY
+- \`pty_read\` to read output from the PTY
+- \`pty_list\` to see all active PTY sessions
+- \`pty_kill\` to terminate the PTY
+
+Examples:
+- Start a dev server: command="npm", args=["run", "dev"], title="Dev Server"
+- Start a Python REPL: command="python3", title="Python REPL"
+- Run tests in watch mode: command="npm", args=["test", "--", "--watch"]`;
+
+export function createPtySpawnTool(manager: PTYManager) {
+  return tool({
+    description: DESCRIPTION,
+    args: {
+      command: tool.schema.string().describe("The command/executable to run"),
+      args: tool.schema.array(tool.schema.string()).optional().describe("Arguments to pass to the command"),
+      workdir: tool.schema.string().optional().describe("Working directory for the PTY session"),
+      env: tool.schema
+        .record(tool.schema.string(), tool.schema.string())
+        .optional()
+        .describe("Additional environment variables"),
+      title: tool.schema.string().optional().describe("Human-readable title for the session"),
+      description: tool.schema
+        .string()
+        .optional()
+        .describe("Clear, concise description of what this PTY session is for in 5-10 words"),
+    },
+    execute: async (args, ctx) => {
+      const info = manager.spawn({
+        command: args.command,
+        args: args.args,
+        workdir: args.workdir,
+        env: args.env,
+        title: args.title,
+        parentSessionId: ctx.sessionID,
+      });
+
+      const output = [
+        `<pty_spawned>`,
+        `ID: ${info.id}`,
+        `Title: ${info.title}`,
+        `Command: ${info.command} ${info.args.join(" ")}`,
+        `Workdir: ${info.workdir}`,
+        `PID: ${info.pid}`,
+        `Status: ${info.status}`,
+        `</pty_spawned>`,
+      ].join("\n");
+
+      return output;
+    },
+  });
+}

package/src/tools/pty/tools/write.ts

@@ -0,0 +1,97 @@
+// src/tools/pty/tools/write.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import type { PTYManager } from "../manager";
+
+const DESCRIPTION = `Sends input data to an active PTY session.
+
+Use this tool to:
+- Type commands or text into an interactive terminal
+- Send special key sequences (Ctrl+C, Enter, arrow keys, etc.)
+- Respond to prompts in interactive programs
+
+Usage:
+- \`id\`: The PTY session ID (from pty_spawn or pty_list)
+- \`data\`: The input to send (text, commands, or escape sequences)
+
+Common escape sequences:
+- Enter/newline: "\\n" or "\\r"
+- Ctrl+C (interrupt): "\\x03"
+- Ctrl+D (EOF): "\\x04"
+- Ctrl+Z (suspend): "\\x1a"
+- Tab: "\\t"
+- Arrow Up: "\\x1b[A"
+- Arrow Down: "\\x1b[B"
+- Arrow Right: "\\x1b[C"
+- Arrow Left: "\\x1b[D"
+
+Returns success or error message.
+
+Examples:
+- Send a command: data="ls -la\\n"
+- Interrupt a process: data="\\x03"
+- Answer a prompt: data="yes\\n"`;
+
+/**
+ * Parse escape sequences in a string to their actual byte values.
+ * Handles: \n, \r, \t, \xNN (hex), \uNNNN (unicode), \\
+ */
+function parseEscapeSequences(input: string): string {
+  return input.replace(/\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|[nrt0\\])/g, (match, seq: string) => {
+    if (seq.startsWith("x")) {
+      return String.fromCharCode(parseInt(seq.slice(1), 16));
+    }
+    if (seq.startsWith("u")) {
+      return String.fromCharCode(parseInt(seq.slice(1), 16));
+    }
+    switch (seq) {
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "\t";
+      case "0":
+        return "\0";
+      case "\\":
+        return "\\";
+      default:
+        return match;
+    }
+  });
+}
+
+export function createPtyWriteTool(manager: PTYManager) {
+  return tool({
+    description: DESCRIPTION,
+    args: {
+      id: tool.schema.string().describe("The PTY session ID (e.g., pty_a1b2c3d4)"),
+      data: tool.schema.string().describe("The input data to send to the PTY"),
+    },
+    execute: async (args) => {
+      const session = manager.get(args.id);
+      if (!session) {
+        throw new Error(`PTY session '${args.id}' not found. Use pty_list to see active sessions.`);
+      }
+
+      if (session.status !== "running") {
+        throw new Error(`Cannot write to PTY '${args.id}' - session status is '${session.status}'.`);
+      }
+
+      // Parse escape sequences to actual bytes
+      const parsedData = parseEscapeSequences(args.data);
+
+      const success = manager.write(args.id, parsedData);
+      if (!success) {
+        throw new Error(`Failed to write to PTY '${args.id}'.`);
+      }
+
+      const preview = args.data.length > 50 ? `${args.data.slice(0, 50)}...` : args.data;
+      const displayPreview = preview
+        .replace(/\x03/g, "^C")
+        .replace(/\x04/g, "^D")
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r");
+      return `Sent ${parsedData.length} bytes to ${args.id}: "${displayPreview}"`;
+    },
+  });
+}

package/src/tools/pty/types.ts

@@ -0,0 +1,62 @@
+// src/tools/pty/types.ts
+import type { RingBuffer } from "./buffer";
+
+export type PTYStatus = "running" | "exited" | "killed";
+
+export interface PTYSession {
+  id: string;
+  title: string;
+  command: string;
+  args: string[];
+  workdir: string;
+  env?: Record<string, string>;
+  status: PTYStatus;
+  exitCode?: number;
+  pid: number;
+  createdAt: Date;
+  parentSessionId: string;
+  buffer: RingBuffer;
+  process: import("bun-pty").IPty;
+}
+
+export interface PTYSessionInfo {
+  id: string;
+  title: string;
+  command: string;
+  args: string[];
+  workdir: string;
+  status: PTYStatus;
+  exitCode?: number;
+  pid: number;
+  createdAt: Date;
+  lineCount: number;
+}
+
+export interface SpawnOptions {
+  command: string;
+  args?: string[];
+  workdir?: string;
+  env?: Record<string, string>;
+  title?: string;
+  parentSessionId: string;
+}
+
+export interface ReadResult {
+  lines: string[];
+  totalLines: number;
+  offset: number;
+  hasMore: boolean;
+}
+
+export interface SearchMatch {
+  lineNumber: number;
+  text: string;
+}
+
+export interface SearchResult {
+  matches: SearchMatch[];
+  totalMatches: number;
+  totalLines: number;
+  offset: number;
+  hasMore: boolean;
+}

package/src/utils/model-limits.ts

@@ -0,0 +1,36 @@
+// Shared model context limits (tokens)
+// Used by context-window-monitor and auto-clear-ledger hooks
+
+export const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+  // Claude models
+  "claude-opus": 200_000,
+  "claude-sonnet": 200_000,
+  "claude-haiku": 200_000,
+  "claude-3": 200_000,
+  "claude-4": 200_000,
+  // OpenAI models
+  "gpt-4o": 128_000,
+  "gpt-4-turbo": 128_000,
+  "gpt-4": 128_000,
+  "gpt-5": 200_000,
+  o1: 200_000,
+  o3: 200_000,
+  // Google models
+  gemini: 1_000_000,
+};
+
+export const DEFAULT_CONTEXT_LIMIT = 200_000;
+
+/**
+ * Get the context window limit for a given model ID.
+ * Matches against known patterns and falls back to default.
+ */
+export function getContextLimit(modelID: string): number {
+  const modelLower = modelID.toLowerCase();
+  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (modelLower.includes(pattern)) {
+      return limit;
+    }
+  }
+  return DEFAULT_CONTEXT_LIMIT;
+}

package/dist/agents/artifact-searcher.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const artifactSearcherAgent: AgentConfig;

package/dist/agents/brainstormer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const brainstormerAgent: AgentConfig;

package/dist/agents/codebase-analyzer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const codebaseAnalyzerAgent: AgentConfig;

package/dist/agents/codebase-locator.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const codebaseLocatorAgent: AgentConfig;

package/dist/agents/commander.d.ts

@@ -1,3 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const primaryAgent: AgentConfig;
-export declare const PRIMARY_AGENT_NAME: string;

package/dist/agents/executor.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const executorAgent: AgentConfig;

package/dist/agents/implementer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const implementerAgent: AgentConfig;

package/dist/agents/index.d.ts

@@ -1,15 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-import { brainstormerAgent } from "./brainstormer";
-import { codebaseLocatorAgent } from "./codebase-locator";
-import { codebaseAnalyzerAgent } from "./codebase-analyzer";
-import { patternFinderAgent } from "./pattern-finder";
-import { plannerAgent } from "./planner";
-import { implementerAgent } from "./implementer";
-import { reviewerAgent } from "./reviewer";
-import { executorAgent } from "./executor";
-import { primaryAgent, PRIMARY_AGENT_NAME } from "./commander";
-import { projectInitializerAgent } from "./project-initializer";
-import { ledgerCreatorAgent } from "./ledger-creator";
-import { artifactSearcherAgent } from "./artifact-searcher";
-export declare const agents: Record<string, AgentConfig>;
-export { primaryAgent, PRIMARY_AGENT_NAME, brainstormerAgent, codebaseLocatorAgent, codebaseAnalyzerAgent, patternFinderAgent, plannerAgent, implementerAgent, reviewerAgent, executorAgent, projectInitializerAgent, ledgerCreatorAgent, artifactSearcherAgent, };

package/dist/agents/ledger-creator.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const ledgerCreatorAgent: AgentConfig;

package/dist/agents/pattern-finder.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const patternFinderAgent: AgentConfig;

package/dist/agents/planner.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const plannerAgent: AgentConfig;

package/dist/agents/project-initializer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const projectInitializerAgent: AgentConfig;

package/dist/agents/reviewer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const reviewerAgent: AgentConfig;

package/dist/config-loader.d.ts

@@ -1,20 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export interface AgentOverride {
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-}
-export interface MicodeConfig {
-    agents?: Record<string, AgentOverride>;
-}
-/**
- * Load micode.json from ~/.config/opencode/micode.json
- * Returns null if file doesn't exist or is invalid JSON
- * @param configDir - Optional override for config directory (for testing)
- */
-export declare function loadMicodeConfig(configDir?: string): Promise<MicodeConfig | null>;
-/**
- * Merge user config overrides into plugin agent configs
- * User overrides take precedence for safe properties only
- */
-export declare function mergeAgentConfigs(pluginAgents: Record<string, AgentConfig>, userConfig: MicodeConfig | null): Record<string, AgentConfig>;

package/dist/hooks/artifact-auto-index.d.ts

@@ -1,19 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function parseLedger(content: string, filePath: string, sessionName: string): {
-    id: string;
-    sessionName: string;
-    filePath: string;
-    goal: string;
-    stateNow: string;
-    keyDecisions: string;
-    filesRead: string;
-    filesModified: string;
-};
-export declare function createArtifactAutoIndexHook(_ctx: PluginInput): {
-    "tool.execute.after": (input: {
-        tool: string;
-        args?: Record<string, unknown>;
-    }, _output: {
-        output?: string;
-    }) => Promise<void>;
-};

package/dist/hooks/auto-clear-ledger.d.ts

@@ -1,11 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare const DEFAULT_THRESHOLD = 0.6;
-export declare const CLEAR_COOLDOWN_MS = 60000;
-export declare function createAutoClearLedgerHook(ctx: PluginInput): {
-    event: ({ event }: {
-        event: {
-            type: string;
-            properties?: unknown;
-        };
-    }) => Promise<void>;
-};

package/dist/hooks/auto-compact.d.ts

@@ -1,9 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createAutoCompactHook(ctx: PluginInput): {
-    event: ({ event }: {
-        event: {
-            type: string;
-            properties?: unknown;
-        };
-    }) => Promise<void>;
-};

package/dist/hooks/comment-checker.d.ts

@@ -1,9 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createCommentCheckerHook(_ctx: PluginInput): {
-    "tool.execute.after": (input: {
-        tool: string;
-        args?: Record<string, unknown>;
-    }, output: {
-        output?: string;
-    }) => Promise<void>;
-};

package/dist/hooks/context-injector.d.ts

@@ -1,15 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createContextInjectorHook(ctx: PluginInput): {
-    "chat.params": (_input: {
-        sessionID: string;
-    }, output: {
-        options?: Record<string, unknown>;
-        system?: string;
-    }) => Promise<void>;
-    "tool.execute.after": (input: {
-        tool: string;
-        args?: Record<string, unknown>;
-    }, output: {
-        output?: string;
-    }) => Promise<void>;
-};

package/dist/hooks/context-window-monitor.d.ts

@@ -1,15 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createContextWindowMonitorHook(ctx: PluginInput): {
-    "chat.params": (input: {
-        sessionID: string;
-    }, output: {
-        system?: string;
-        options?: Record<string, unknown>;
-    }) => Promise<void>;
-    event: ({ event }: {
-        event: {
-            type: string;
-            properties?: unknown;
-        };
-    }) => Promise<void>;
-};