Skip to main content
Glama

edit_thread

Update an existing thread's title, content, category, privacy settings, or other attributes by specifying only the fields you want to change.

Instructions

Edit an existing thread. Only provided fields are updated.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
thread_idYesGlobal thread ID
titleNoNew title
contentNoNew body (markdown or Ed XML)
typeNo
categoryNo
subcategoryNo
is_privateNo
is_anonymousNo
is_pinnedNo

Implementation Reference

  • The API method that performs the actual network request to update the thread.
    async editThread(
      threadId: number,
      params: EdEditThreadParams
    ): Promise<{ thread: EdThread }> {
      // Fetch current thread to merge fields
      const current = await this.getThread(threadId);
      const merged = { ...current.thread, ...params };
      return this.request<{ thread: EdThread }>("PUT", `threads/${threadId}`, {
        thread: merged,
      });
    }
  • src/index.ts:247-270 (registration)
    The tool registration for 'edit_thread', which handles input parsing, optional content formatting, and calling the API handler.
    server.tool(
      "edit_thread",
      "Edit an existing thread. Only provided fields are updated.",
      {
        thread_id: z.number().describe("Global thread ID"),
        title: z.string().optional().describe("New title"),
        content: z.string().optional().describe("New body (markdown or Ed XML)"),
        type: z.enum(["post", "question", "announcement"]).optional(),
        category: z.string().optional(),
        subcategory: z.string().optional(),
        is_private: z.boolean().optional(),
        is_anonymous: z.boolean().optional(),
        is_pinned: z.boolean().optional(),
      },
      async ({ thread_id, content, ...rest }) => {
        try {
          const params: EdEditThreadParams = { ...rest };
          if (content !== undefined) {
            params.content = ensureEdXml(content);
          }
          const result = await api.editThread(thread_id, params);
          return ok(result);
        } catch (err) {
          return fail(err);
  • Type definition for the parameters used to edit a thread.
    export interface EdEditThreadParams {
      type?: string;
      title?: string;
      category?: string;
      subcategory?: string;
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full behavioral burden. It discloses partial-update behavior but fails to mention mutation safety, authorization requirements, what happens if thread_id is invalid, or return value structure for this 9-parameter operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with zero waste—every word earns its place. Front-loaded with the action. However, given the low schema coverage, extreme brevity becomes a liability rather than a virtue.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Inadequate for a complex mutation tool with 9 parameters and no output schema. Missing auth context, error conditions, and parameter relationships. The partial update note is insufficient compensation for the schema coverage gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 33% (3 of 9 params documented). The description adds no compensatory information for the 6 undocumented parameters (category, subcategory, is_private, is_anonymous, is_pinned, type), leaving critical semantics like 'type' enum usage unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States specific verb ('Edit') and resource ('thread') clearly. The phrase 'existing thread' implicitly distinguishes from sibling tool 'post_thread' (creation), though it doesn't explicitly name alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The sentence 'Only provided fields are updated' provides important guidance about partial update behavior (PATCH semantics), indicating optional parameters. However, it lacks explicit 'when to use vs. when to use post_thread' guidance or prerequisites like thread existence.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/rob-9/edstem-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server