Hacktoberfest 2026: the issues maintainers tagged for October, open and beginner-friendly. Browse Hacktoberfest issues

WebMCP tool execution progress report

Open
  • Is something wrong?
#196 2 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
5/5
Estimated time
Over a week
Newbie friendliness
28/100
Issue type
Feature
Clarity
Mostly clear
Activity status
Quiet
Tech stack
javascript
Domain
ai, api

Research direction

Start with the linked Chromium change, the extension inspector PR, and the current ToolExecuteCallback and document.modelContext definitions. Compare the proposed event-target API with the alternative ExecuteToolOptions.monitor, especially how concurrent executions receive identifiers. Done means selecting and specifying one API shape, including progress-event fields and execution-ID behavior, then updating the WebMCP specification and examples consistently.

Written by the indexing model from the issue text.

Description

enhancement

Introduction & Objectives

As Language Models and Agentic workflows become deeply integrated into the web platform via WebMCP, some tools registered by web applications may be tasked with long-running operations (e.g., repository indexing, complex multi-file analyses). Currently, the ToolExecuteCallback interface executes asynchronously but behaves as a "black box" until the final promise resolves or rejects. There is no native mechanism for an active tool execution to stream intermediate telemetry, status messages, or sub-task heartbeats back to the calling agent, which leaves both the agent and the user without visibility into the tool's current state.

Better agent to agent integrations

A common agentic pattern is to expose sub-agents to a coordinator as tools. This pattern also enables websites to expose their own agents to browser agents. Similar to other tasks described in this document, invoking a sub-agent can be a long running process. The progress report feature would enable sub-agents to send progress updates: thinking blocks, partial texts, and details on their own tool calls to the browser agent, so it can display their content to the user.

[!NOTE]
While it’s up to the agent to decide how to use the progress reports it receives, the goal is to use the information to show progress of the tool call to the user, and the content of those reports should not be included in the conversation between agents, to avoid context bloat.

Proposed API changes

partial interface ModelContextClient {
    undefined reportProgress(DOMString message);
};

interface ToolProgressEvent : Event {
    constructor(DOMString type, optional ToolProgressEventInit eventInitDict = {});
    readonly attribute DOMString toolName;
    readonly attribute DOMString message;
};

dictionary ToolProgressEventInit : EventInit {
    DOMString toolName = "";
    DOMString message = "";
};

partial interface ModelContext : EventTarget {
    attribute EventHandler ontoolprogress;
};

JavaScript example

// 1. Tool Implementation with Progress Updates
async function* runTasks() {
  yield { type: 'thinking', text: 'Analyzing your workspace...' };
  await new Promise((r) => setTimeout(r, 800));

  yield { type: 'tool_start', name: 'hackathon-analyzer', params: { file: 'reasons.md' } };
  await new Promise((r) => setTimeout(r, 1200));

  yield { type: 'tool_finish', name: 'hackathon-analyzer' };
  await new Promise((r) => setTimeout(r, 500));

  yield { type: 'text', text: 'Analysis complete! Found 3 migration reasons.' };
}

// 2. Registering the Tool with the injected client
document.modelContext.registerTool({
  name: 'workspace-analyzer',
  description: 'Analyzes files in the current workspace directory',
  execute: async (input, client) => {
    for await (const message of runTasks()) {
      // Serialize updates to string data
      client.reportProgress(JSON.stringify(message));
    }
    return { success: true };
  },
});

// 3. Orchestrator observing runtime progress hooks
document.modelContext.ontoolprogress = (event) => {
  const { toolName, message } = event;
  const data = JSON.parse(message);
  
  console.log(`[Progress Update] Tool: ${toolName}`, data);
};

Resources

Open questions

A key challenge remains: determining how an extension can effectively track concurrent tool executions. Tool execution IDs are currently unavailable until executeTool() completes, which complicates parallel monitoring. Shall we introduce a new monitor object in ExecuteToolOptions instead of document.modelContext.ontoolprogress to report progress?

const result = await document.modelContext.executeTool(myTool, {
  monitor(m) {
    m.addEventListener('progress', ({ message }) => {
      // Report progress to the extension sidebar
      chrome.runtime.sendMessage({
        toolExecutionId: m.toolExecutionId,
        toolName: m.toolName,
        message,
      });
    });
  },
});
// Report final result from tool execution.
chrome.runtime.sendMessage({ result });
Dominant language
Bikeshed
Stars
4.7k
Forks
328
Avg merge
2d 15h
Merged PRs (30d)
16

Getting set up

This project ships no dev container, Dockerfile or contributing guide, so setting up is up to you: start from its README, and see our first-contribution guide for the general steps.

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from webmachinelearning/webmcp

All issues in webmachinelearning/webmcp

Similar issues

More AI Infra & Agents issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.