@kolisachint/hoocode-agent 0.4.118 → 0.4.120

package/CHANGELOG.md

@@ -1,5 +1,91 @@
 # Changelog
 
+## [0.4.120] - 2026-07-13
+
+### Added
+
+- Remote MCP servers: the MCP loader now speaks Streamable HTTP
+  (`{ "type": "http", "url": ..., "headers": ... }`) and the legacy SSE
+  transport (`"type": "sse"`) in addition to stdio, across every config
+  source — standard `mcp.json` files, `~/.hoocode/mcp-servers/*.json`, and
+  plugin `.mcp.json` registrations in both the Claude (`mcpServers`) and
+  Copilot / VS Code (`servers`) shapes. This closes the 0.4.119 known
+  limitation: remote plugin servers (e.g. workiq from the Copilot directory,
+  or Atlassian Rovo) are connected instead of skipped. Built on the official
+  `@modelcontextprotocol/sdk` client transports; a `type: "http"` endpoint
+  that rejects streamable HTTP with a 4xx automatically falls back to the
+  legacy SSE transport.
+- MCP OAuth: remote servers that demand authorization get the full MCP auth
+  flow — RFC 9728/8414 discovery, dynamic client registration, browser-based
+  authorization code + PKCE via a loopback redirect listener, and automatic
+  token refresh — with per-server-URL state persisted under
+  `~/.hoocode/mcp-auth/` (0600). When interactive sign-in is needed the
+  session keeps starting; the server's tools connect and register as soon as
+  the browser flow completes. The headless `loadMcpTools` in
+  `@kolisachint/hoocode-agent-core` accepts the same remote entries plus
+  `McpRemoteOptions` (storage dir, browser opener, auth callbacks), and the
+  transport/provider are exported as `connectHttpMcpServer` /
+  `McpFileOAuthProvider`.
+
+## [0.4.119] - 2026-07-13
+
+### Added
+
+- **Single-turn capability loop**: `InstallPlugin` and `ProposePlugin` now
+  activate the plugin in the live session — skills, slash commands, and
+  subagents are usable on the model's very next request, in the same turn, with
+  no `/reload`. Plugins bundling executable capabilities (hooks, MCP servers)
+  trigger an automatic reload when the turn ends. `UninstallPlugin` schedules
+  the same idle reload so cleanup is autonomous too.
+- Mid-run context refresh: tool or system-prompt changes made while a run is
+  streaming (deferred MCP schema resolution via `ResolveMcpTools`, live plugin
+  activation) now reach the next provider request within the same run, via the
+  agent loop's `prepareNextTurn` hook. Previously the loop's context was frozen
+  at run start, so `ResolveMcpTools`-resolved tools were not callable until the
+  next user prompt.
+- Well-known marketplaces: the official Claude plugins directory
+  (`anthropics/claude-plugins-official`, 250+ plugins) is registered as a
+  curated, trusted marketplace out of the box. Its index is cloned lazily into
+  `.agents/marketplace-cache/` on first `SearchPlugins` call (offline degrades
+  gracefully) and is never auto-updated.
+- Reusability sensing: system-prompt guidance now nudges the model to
+  `SearchPlugins` before hand-rolling a missing capability, and to author a
+  reusable recipe as a plugin with `ProposePlugin` autonomously when no
+  marketplace plugin covers it.
+
+- Real-world GitHub Copilot plugin support: the Copilot adapter now reads the
+  convention established by `github/copilot-plugins` — plugin manifests at
+  `.github/plugin/plugin.json` over a Claude-mirror capability tree, marketplace
+  indices at `.github/plugin/marketplace.json`, manifest dir-path overrides
+  (`"skills": "./skills/"`), and the `{ "source": "github", "repo", "path" }`
+  source shorthand. The legacy authored layout (`.github/copilot-plugin.json` +
+  prompts/chatmodes) still parses. `github/copilot-plugins` joins the well-known
+  trusted marketplaces (searchable with `platform: "github"`).
+- Manifest-less marketplace plugins (bare capability trees, e.g.
+  copilot-plugins' `spark`) now install: a native manifest is synthesized from
+  the marketplace entry so the standard loader carries them.
+- Hooks + bundled scripts verified end to end through the install path: script
+  exec bits survive install, the `{ description, hooks }` `hooks.json` wrapper
+  parses, `${CLAUDE_PLUGIN_ROOT}` resolves to the installed root, event JSON
+  arrives on stdin, and exit-code 2 blocks the tool call.
+
+### Changed
+
+- `deferMcpSchemas` now defaults to **on**: MCP tool schemas are deferred
+  (names only in context, resolved on demand via `ResolveMcpTools`), cutting
+  the context cost of MCP-heavy plugins. Set `deferMcpSchemas: false` to
+  restore eager schema registration.
+- `ProposePlugin`'s Copilot output now follows the real-world convention: one
+  shared capability tree plus a `.github/plugin/plugin.json` marker manifest
+  (previously `.github/copilot-plugin.json` + `.prompt.md`/`.chatmode.md`
+  files).
+
+### Known limitations
+
+- Remote MCP servers (`{ "type": "http", "url": ... }` in a plugin's
+  `.mcp.json`, e.g. workiq) are not yet supported — the MCP loader is
+  stdio-only; such servers are skipped at plugin load.
+
 ## [0.4.118] - 2026-07-12
 
 ## [0.4.117] - 2026-07-12

package/dist/core/agent-session.d.ts

@@ -17,7 +17,7 @@ import type { ImageContent, Model, TextContent } from "@kolisachint/hoocode-ai";
 import { type SessionStats } from "./agent-session-stats.js";
 import { type NavigateTreeOptions, type NavigateTreeResult } from "./agent-session-tree-navigation.js";
 import { type BashResult } from "./bash-executor.js";
-import { type ContextUsage, type ExtensionCommandContextActions, type ExtensionErrorListener, ExtensionRunner, type ExtensionUIContext, type InputSource, type ReplacedSessionContext, type SessionStartEvent, type ShutdownHandler, type ToolDefinition, type ToolInfo } from "./extensions/index.js";
+import { type ContextUsage, type ExtensionCommandContextActions, type ExtensionErrorListener, ExtensionRunner, type ExtensionUIContext, type InputSource, type PluginActivationResult, type ReplacedSessionContext, type SessionStartEvent, type ShutdownHandler, type ToolDefinition, type ToolInfo } from "./extensions/index.js";
 import type { ModelRegistry } from "./model-registry.js";
 import { type PromptTemplate } from "./prompt-templates.js";
 import type { ResourceLoader } from "./resource-loader.js";
@@ -167,6 +167,20 @@ export declare class AgentSession {
     private _toolPromptGuidelines;
     private _baseSystemPrompt;
     private _baseSystemPromptOptions;
+    /**
+     * Set when tools or the system prompt change while a run is in flight (a tool
+     * registered mid-turn, a plugin activated live). The agent loop snapshots its
+     * context at run start; this flag makes prepareNextTurn hand the loop a fresh
+     * systemPrompt + tools before the next provider request, so mid-turn
+     * capability changes are visible within the same turn.
+     */
+    private _runtimeContextDirty;
+    /**
+     * Set when a change needs a full reload (executable plugin capabilities:
+     * hooks, MCP servers, providers) that cannot be wired mid-turn. Consumed on
+     * agent_end: once the session is idle the reload runs automatically.
+     */
+    private _reloadWhenIdle;
     constructor(config: AgentSessionConfig);
     /** Model registry for API key resolution and model discovery */
     get modelRegistry(): ModelRegistry;
@@ -437,6 +451,26 @@ export declare class AgentSession {
     private _refreshToolRegistry;
     private _buildRuntime;
     reload(): Promise<void>;
+    /**
+     * Activate a just-installed or just-authored plugin in the LIVE session, no
+     * reload required. Passive capabilities — skills, slash commands, subagents,
+     * themes — register immediately and become visible to the model on its next
+     * provider request, even mid-turn (via the prepareNextTurn context refresh).
+     *
+     * Executable capabilities (hooks, MCP servers, providers) cannot be safely
+     * wired into a run that is already streaming; when the plugin bundles any,
+     * this schedules an automatic full reload for when the session next goes
+     * idle (end of the current turn), so they still activate autonomously.
+     */
+    activatePlugin(pluginDir: string): PluginActivationResult;
+    /**
+     * Ask for a full reload once the session is idle — used when a change (e.g.
+     * uninstalling a plugin) can only take effect through the reload path. Runs
+     * immediately when already idle.
+     */
+    requestReloadWhenIdle(): void;
+    /** Run the pending idle reload through the mode's reload flow when bound (UI refresh included). */
+    private _runIdleReload;
     /**
      * Cancel in-progress retry.
      */