snow-flow 10.0.185 → 10.0.186-dev.682

package/src/mcp/oauth-provider.ts

@@ -143,10 +143,41 @@ export class McpOAuthProvider implements OAuthClientProvider {
 
   async state(): Promise<string> {
     const entry = await McpAuth.get(this.mcpName)
-    if (!entry?.oauthState) {
-      throw new Error(`No OAuth state saved for MCP server: ${this.mcpName}`)
+    if (entry?.oauthState) {
+      return entry.oauthState
+    }
+
+    // Generate a new state if none exists — the SDK calls state() as a
+    // generator, not just a reader, so we need to produce a value even when
+    // startAuth() hasn't pre-saved one (e.g. during automatic auth on first
+    // connect).
+    const newState = Array.from(crypto.getRandomValues(new Uint8Array(32)))
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("")
+    await McpAuth.updateOAuthState(this.mcpName, newState)
+    return newState
+  }
+
+  async invalidateCredentials(type: "all" | "client" | "tokens"): Promise<void> {
+    log.info("invalidating credentials", { mcpName: this.mcpName, type })
+    const entry = await McpAuth.get(this.mcpName)
+    if (!entry) {
+      return
+    }
+
+    switch (type) {
+      case "all":
+        await McpAuth.remove(this.mcpName)
+        break
+      case "client":
+        delete entry.clientInfo
+        await McpAuth.set(this.mcpName, entry)
+        break
+      case "tokens":
+        delete entry.tokens
+        await McpAuth.set(this.mcpName, entry)
+        break
     }
-    return entry.oauthState
   }
 }
 

package/src/project/project.ts

@@ -79,7 +79,7 @@ export namespace Project {
 
         // generate id from root commit
         if (!id) {
-          const roots = await $`git rev-list --max-parents=0 --all`
+          const roots = await $`git rev-list --max-parents=0 HEAD`
             .quiet()
             .nothrow()
             .cwd(sandbox)
@@ -104,6 +104,7 @@ export namespace Project {
 
           id = roots[0]
           if (id) {
+            // Write to .git dir so the cache is shared across worktrees.
             void Bun.file(path.join(git, "opencode"))
               .write(id)
               .catch(() => undefined)
@@ -187,9 +188,6 @@ export namespace Project {
           updated: Date.now(),
         },
       }
-      if (id !== "global") {
-        await migrateFromGlobal(id, worktree)
-      }
     }
 
     // migrate old projects before sandboxes
@@ -209,6 +207,12 @@ export namespace Project {
     if (sandbox !== result.worktree && !result.sandboxes.includes(sandbox)) result.sandboxes.push(sandbox)
     result.sandboxes = result.sandboxes.filter((x) => existsSync(x))
     await Storage.write<Info>(["project", id], result)
+    // Runs after write so the target project record exists.
+    // Runs on every startup because sessions created before git init
+    // accumulate under "global" and need migrating whenever they appear.
+    if (id !== "global") {
+      await migrateFromGlobal(id, worktree)
+    }
     GlobalBus.emit("event", {
       payload: {
         type: Event.Updated.type,

package/src/provider/models.ts

@@ -122,7 +122,7 @@ export namespace ModelsDev {
   }
 }
 
-if (!Flag.OPENCODE_DISABLE_MODELS_FETCH) {
+if (!Flag.OPENCODE_DISABLE_MODELS_FETCH && !process.argv.includes("--get-yargs-completions")) {
   ModelsDev.refresh()
   setInterval(
     async () => {

package/src/provider/provider.ts

@@ -39,6 +39,8 @@ import { createVercel } from "@ai-sdk/vercel"
 import { createGitLab } from "@gitlab/gitlab-ai-provider"
 import { ProviderTransform } from "./transform"
 
+const DEFAULT_CHUNK_TIMEOUT = 300_000
+
 export namespace Provider {
   const log = Log.create({ service: "provider" })
 
@@ -54,6 +56,78 @@ export namespace Provider {
     return isGpt5OrLater(modelID) && !modelID.startsWith("gpt-5-mini")
   }
 
+  function googleVertexVars(options: Record<string, any>) {
+    const project =
+      options["project"] ?? Env.get("GOOGLE_CLOUD_PROJECT") ?? Env.get("GCP_PROJECT") ?? Env.get("GCLOUD_PROJECT")
+    const location =
+      options["location"] ?? Env.get("GOOGLE_CLOUD_LOCATION") ?? Env.get("VERTEX_LOCATION") ?? "us-central1"
+    const endpoint = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`
+
+    return {
+      GOOGLE_VERTEX_PROJECT: project,
+      GOOGLE_VERTEX_LOCATION: location,
+      GOOGLE_VERTEX_ENDPOINT: endpoint,
+    }
+  }
+
+  function loadBaseURL(model: Model, options: Record<string, any>) {
+    const raw = options["baseURL"] ?? model.api.url
+    if (typeof raw !== "string") return raw
+    const vars = model.providerID === "google-vertex" ? googleVertexVars(options) : undefined
+    return raw.replace(/\$\{([^}]+)\}/g, (match, key) => {
+      const val = Env.get(String(key)) ?? vars?.[String(key) as keyof typeof vars]
+      return val ?? match
+    })
+  }
+
+  function wrapSSE(res: Response, ms: number, ctl: AbortController) {
+    if (typeof ms !== "number" || ms <= 0) return res
+    if (!res.body) return res
+    if (!res.headers.get("content-type")?.includes("text/event-stream")) return res
+
+    const reader = res.body.getReader()
+    const body = new ReadableStream<Uint8Array>({
+      async pull(ctrl) {
+        const part = await new Promise<Awaited<ReturnType<typeof reader.read>>>((resolve, reject) => {
+          const id = setTimeout(() => {
+            const err = new Error("SSE read timed out")
+            ctl.abort(err)
+            void reader.cancel(err)
+            reject(err)
+          }, ms)
+
+          reader.read().then(
+            (part) => {
+              clearTimeout(id)
+              resolve(part)
+            },
+            (err) => {
+              clearTimeout(id)
+              reject(err)
+            },
+          )
+        })
+
+        if (part.done) {
+          ctrl.close()
+          return
+        }
+
+        ctrl.enqueue(part.value)
+      },
+      async cancel(reason) {
+        ctl.abort(reason)
+        await reader.cancel(reason)
+      },
+    })
+
+    return new Response(body, {
+      headers: new Headers(res.headers),
+      status: res.status,
+      statusText: res.statusText,
+    })
+  }
+
   const BUNDLED_PROVIDERS: Record<string, (options: any) => SDK> = {
     "@ai-sdk/amazon-bedrock": createAmazonBedrock,
     "@ai-sdk/anthropic": createAnthropic,
@@ -1402,21 +1476,23 @@ export namespace Provider {
       }
 
       const customFetch = options["fetch"]
+      const chunkTimeout = options["chunkTimeout"] || DEFAULT_CHUNK_TIMEOUT
+      delete options["chunkTimeout"]
 
       options["fetch"] = async (input: any, init?: BunFetchRequestInit) => {
         // Preserve custom fetch if it exists, wrap it with timeout logic
         const fetchFn = customFetch ?? fetch
         const opts = init ?? {}
+        const chunkAbortCtl = typeof chunkTimeout === "number" && chunkTimeout > 0 ? new AbortController() : undefined
+        const signals: AbortSignal[] = []
 
-        if (options["timeout"] !== undefined && options["timeout"] !== null) {
-          const signals: AbortSignal[] = []
-          if (opts.signal) signals.push(opts.signal)
-          if (options["timeout"] !== false) signals.push(AbortSignal.timeout(options["timeout"]))
-
-          const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0]
+        if (opts.signal) signals.push(opts.signal)
+        if (chunkAbortCtl) signals.push(chunkAbortCtl.signal)
+        if (options["timeout"] !== undefined && options["timeout"] !== null && options["timeout"] !== false)
+          signals.push(AbortSignal.timeout(options["timeout"]))
 
-          opts.signal = combined
-        }
+        const combined = signals.length === 0 ? null : signals.length === 1 ? signals[0] : AbortSignal.any(signals)
+        if (combined) opts.signal = combined
 
         // Strip openai itemId metadata following what codex does
         // Codex uses #[serde(skip_serializing)] on id fields for all item types:
@@ -1436,11 +1512,14 @@ export namespace Provider {
           }
         }
 
-        return fetchFn(input, {
+        const res = await fetchFn(input, {
           ...opts,
           // @ts-ignore see here: https://github.com/oven-sh/bun/issues/16682
           timeout: false,
         })
+
+        if (!chunkAbortCtl) return res
+        return wrapSSE(res, chunkTimeout, chunkAbortCtl)
       }
 
       // Special case: google-vertex-anthropic uses a subpath import

package/src/provider/transform.ts

@@ -46,7 +46,7 @@ export namespace ProviderTransform {
   ): ModelMessage[] {
     // Anthropic rejects messages with empty content - filter out empty string messages
     // and remove empty text/reasoning parts from array content
-    if (model.api.npm === "@ai-sdk/anthropic") {
+    if (model.api.npm === "@ai-sdk/anthropic" || model.api.npm === "@ai-sdk/amazon-bedrock") {
       msgs = msgs
         .map((msg) => {
           if (typeof msg.content === "string") {
@@ -492,8 +492,13 @@ export namespace ProviderTransform {
             },
           }
         }
+        let levels = ["low", "high"]
+        if (id.includes("3.1")) {
+          levels = ["low", "medium", "high"]
+        }
+
         return Object.fromEntries(
-          ["low", "high"].map((effort) => [
+          levels.map((effort) => [
             effort,
             {
               includeThoughts: true,

package/src/servicenow/servicenow-mcp-unified/tools/agile/snow_agile_capacity_plan.ts

@@ -38,20 +38,33 @@ export const toolDefinition: MCPToolDefinition = {
 }
 
 export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
-  const { team, sprint, velocity_sprints = 3 } = args
+  const PLUGIN_HINT =
+    "The rm_team table does not exist. Activate the 'Agile Development 2.0 - Team component' plugin (com.snc.sdlc.agile.2.0.team) to enable team management."
+
   try {
     const client = await getAuthenticatedClient(context)
 
+    // Verify rm_team table exists
+    try {
+      await client.get("/api/now/table/rm_team", { params: { sysparm_limit: 0 } })
+    } catch (e: any) {
+      const msg = (e.message || "") + (e.response?.data?.error?.message || "")
+      if (msg.indexOf("Invalid table") !== -1 || msg.indexOf("ACL") !== -1) {
+        return createErrorResult(PLUGIN_HINT)
+      }
+      throw e
+    }
+
     // Resolve team
     const teamResp = await client.get("/api/now/table/rm_team", {
       params: {
-        sysparm_query: "name=" + team + "^ORsys_id=" + team,
+        sysparm_query: "name=" + args.team + "^ORsys_id=" + args.team,
         sysparm_limit: 1,
         sysparm_display_value: "true",
       },
     })
     const teams = teamResp.data.result || []
-    if (teams.length === 0) return createErrorResult("Team not found: " + team)
+    if (teams.length === 0) return createErrorResult("Team not found: " + args.team)
     const teamRecord = teams[0]
 
     // Get team members
@@ -66,9 +79,9 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
 
     // Resolve target sprint
     var targetSprint: any = null
-    if (sprint) {
-      var sprintQuery = "sys_id=" + sprint
-      if (sprint.indexOf("SPRNT") === 0) sprintQuery = "number=" + sprint
+    if (args.sprint) {
+      var sprintQuery = "sys_id=" + args.sprint
+      if (args.sprint.indexOf("SPRNT") === 0) sprintQuery = "number=" + args.sprint
       const sprintResp = await client.get("/api/now/table/rm_sprint", {
         params: { sysparm_query: sprintQuery, sysparm_limit: 1, sysparm_display_value: "true" },
       })
@@ -91,7 +104,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
     const closedSprintsResp = await client.get("/api/now/table/rm_sprint", {
       params: {
         sysparm_query: "group=" + teamRecord.sys_id + "^state=3^ORDERBYDESCend_date",
-        sysparm_limit: velocity_sprints,
+        sysparm_limit: args.velocity_sprints || 3,
         sysparm_fields: "sys_id,number,story_points",
       },
     })

package/src/servicenow/servicenow-mcp-unified/tools/agile/snow_agile_retrospective.ts

@@ -132,12 +132,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
     if (teamId) {
       const prevSprintsResp = await client.get("/api/now/table/rm_sprint", {
         params: {
-          sysparm_query:
-            "group=" +
-            teamId +
-            "^state=3^sys_id!=" +
-            sprintId +
-            "^ORDERBYDESCend_date",
+          sysparm_query: "group=" + teamId + "^state=3^sys_id!=" + sprintId + "^ORDERBYDESCend_date",
           sysparm_limit: compare_sprints,
           sysparm_fields: "sys_id,short_description,number,story_points,start_date,end_date",
           sysparm_display_value: "true",
@@ -150,6 +145,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           params: {
             sysparm_query: "sprint=" + prevSprints[j].sys_id,
             sysparm_fields: "story_points,state",
+            sysparm_display_value: "true",
           },
         })
         const prevStories = prevStoriesResp.data.result || []
@@ -159,7 +155,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         for (var k = 0; k < prevStories.length; k++) {
           var prevPts = parseInt(prevStories[k].story_points, 10) || 0
           prevPlanned += prevPts
-          if (prevStories[k].state === "3") prevCompleted += prevPts // state value for Closed Complete
+          if (prevStories[k].state === "Closed Complete") prevCompleted += prevPts
         }
 
         comparison.push({
@@ -237,7 +233,9 @@ function generateInsights(
     var recent = comparison[0]
     var previous = comparison[1]
     if (rate > recent.completion_rate)
-      insights.push("Velocity improving compared to previous sprint (" + recent.completion_rate + "% -> " + rate + "%).")
+      insights.push(
+        "Velocity improving compared to previous sprint (" + recent.completion_rate + "% -> " + rate + "%).",
+      )
     else if (rate < recent.completion_rate)
       insights.push(
         "Velocity declining compared to previous sprint (" + recent.completion_rate + "% -> " + rate + "%).",

package/src/servicenow/servicenow-mcp-unified/tools/agile/snow_agile_sprint_manage.ts

@@ -59,24 +59,36 @@ export const toolDefinition: MCPToolDefinition = {
 }
 
 export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
-  const { action, sys_id, name, start_date, end_date, team, story_points, goal } = args
   try {
     const client = await getAuthenticatedClient(context)
 
-    if (action === "create") {
-      if (!name) return createErrorResult("name is required for create action")
-      const body: Record<string, any> = { short_description: name }
-      if (start_date) body.start_date = start_date
-      if (end_date) body.end_date = end_date
-      if (story_points) body.story_points = story_points
-      if (goal) body.goal = goal
+    if (args.action === "create") {
+      if (!args.name) return createErrorResult("name is required for create action")
+      const body: Record<string, any> = { short_description: args.name }
+      if (args.start_date) body.start_date = args.start_date
+      if (args.end_date) body.end_date = args.end_date
+      if (args.story_points) body.story_points = args.story_points
+      if (args.goal) body.goal = args.goal
 
-      if (team) {
-        const teamResp = await client.get("/api/now/table/rm_team", {
-          params: { sysparm_query: "name=" + team + "^ORsys_id=" + team, sysparm_limit: 1, sysparm_fields: "sys_id" },
-        })
-        const teams = teamResp.data.result || []
-        if (teams.length > 0) body.group = teams[0].sys_id
+      if (args.team) {
+        try {
+          const teamResp = await client.get("/api/now/table/rm_team", {
+            params: {
+              sysparm_query: "name=" + args.team + "^ORsys_id=" + args.team,
+              sysparm_limit: 1,
+              sysparm_fields: "sys_id",
+            },
+          })
+          const teams = teamResp.data.result || []
+          if (teams.length > 0) body.assignment_group = teams[0].sys_id
+        } catch (_e: any) {
+          const msg = _e.message || ""
+          if (msg.indexOf("Invalid table") !== -1) {
+            return createErrorResult(
+              "The rm_team table is not available. Activate the Agile Development 2.0 plugin (com.snc.sdlc.agile.2.0) to enable team management. You can still create sprints without a team by omitting the 'team' parameter.",
+            )
+          }
+        }
       }
 
       const response = await client.post("/api/now/table/rm_sprint", body)
@@ -86,32 +98,38 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
       })
     }
 
-    if (!sys_id) return createErrorResult("sys_id is required for " + action + " action")
+    if (!args.sys_id) return createErrorResult("sys_id is required for " + args.action + " action")
 
-    if (action === "start") {
-      const response = await client.patch("/api/now/table/rm_sprint/" + sys_id, { state: "2" })
+    if (args.action === "start") {
+      const response = await client.patch("/api/now/table/rm_sprint/" + args.sys_id, { state: "2" })
       return createSuccessResult({ action: "started", sprint: response.data.result })
     }
 
-    if (action === "close") {
-      const response = await client.patch("/api/now/table/rm_sprint/" + sys_id, { state: "3" })
+    if (args.action === "close") {
+      const response = await client.patch("/api/now/table/rm_sprint/" + args.sys_id, { state: "3" })
       return createSuccessResult({ action: "closed", sprint: response.data.result })
     }
 
-    if (action === "update") {
+    if (args.action === "update") {
       const updates: Record<string, any> = {}
-      if (name) updates.short_description = name
-      if (start_date) updates.start_date = start_date
-      if (end_date) updates.end_date = end_date
-      if (story_points) updates.story_points = story_points
-      if (goal) updates.goal = goal
-      const response = await client.patch("/api/now/table/rm_sprint/" + sys_id, updates)
+      if (args.name) updates.short_description = args.name
+      if (args.start_date) updates.start_date = args.start_date
+      if (args.end_date) updates.end_date = args.end_date
+      if (args.story_points) updates.story_points = args.story_points
+      if (args.goal) updates.goal = args.goal
+      const response = await client.patch("/api/now/table/rm_sprint/" + args.sys_id, updates)
       return createSuccessResult({ action: "updated", sprint: response.data.result })
     }
 
-    return createErrorResult("Unknown action: " + action)
+    return createErrorResult("Unknown action: " + args.action)
   } catch (error: any) {
-    return createErrorResult(error.message)
+    const msg = error.message || "Operation failed"
+    if (msg.indexOf("Invalid table") !== -1) {
+      return createErrorResult(
+        "The rm_sprint table is not available. Activate the Agile Development 2.0 plugin (com.snc.sdlc.agile.2.0) on your instance.",
+      )
+    }
+    return createErrorResult("Sprint " + args.action + " failed: " + msg)
   }
 }
 

package/src/servicenow/servicenow-mcp-unified/tools/agile/snow_agile_team_manage.ts

@@ -55,43 +55,66 @@ export const toolDefinition: MCPToolDefinition = {
   },
 }
 
+async function resolveUser(client: any, username: string): Promise<string | null> {
+  const resp = await client.get("/api/now/table/sys_user", {
+    params: {
+      sysparm_query: "user_name=" + username + "^ORsys_id=" + username,
+      sysparm_limit: 1,
+      sysparm_fields: "sys_id",
+    },
+  })
+  const users = resp.data.result || []
+  return users.length > 0 ? users[0].sys_id : null
+}
+
+const PLUGIN_HINT =
+  "The rm_team table is not available. Activate the Agile Development 2.0 plugin (com.snc.sdlc.agile.2.0) to enable team management."
+
 export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
-  const { action, sys_id, name, description, velocity, member, role } = args
   try {
     const client = await getAuthenticatedClient(context)
 
-    if (action === "create") {
-      if (!name) return createErrorResult("name is required for create action")
-      const body: Record<string, any> = { name }
-      if (description) body.description = description
-      if (velocity) body.velocity = velocity
+    try {
+      await client.get("/api/now/table/rm_team", { params: { sysparm_limit: 1, sysparm_fields: "sys_id" } })
+    } catch (_e: any) {
+      const msg = _e.message || ""
+      if (msg.indexOf("Invalid table") !== -1 || (_e.response && _e.response.status === 404)) {
+        return createErrorResult(PLUGIN_HINT)
+      }
+      throw _e
+    }
+
+    if (args.action === "create") {
+      if (!args.name) return createErrorResult("name is required for create action")
+      const body: Record<string, any> = { name: args.name }
+      if (args.description) body.description = args.description
+      if (args.velocity) body.velocity = args.velocity
       const response = await client.post("/api/now/table/rm_team", body)
       return createSuccessResult({ action: "created", team: response.data.result })
     }
 
-    if (!sys_id) return createErrorResult("sys_id is required for " + action + " action")
+    if (!args.sys_id) return createErrorResult("sys_id is required for " + args.action + " action")
 
-    if (action === "update") {
+    if (args.action === "update") {
       const body: Record<string, any> = {}
-      if (name) body.name = name
-      if (description) body.description = description
-      if (velocity) body.velocity = velocity
-      const response = await client.patch("/api/now/table/rm_team/" + sys_id, body)
+      if (args.name) body.name = args.name
+      if (args.description) body.description = args.description
+      if (args.velocity) body.velocity = args.velocity
+      const response = await client.patch("/api/now/table/rm_team/" + args.sys_id, body)
       return createSuccessResult({ action: "updated", team: response.data.result })
     }
 
-    if (action === "list_members") {
+    if (args.action === "list_members") {
       const membersResp = await client.get("/api/now/table/rm_team_member", {
         params: {
-          sysparm_query: "team=" + sys_id,
+          sysparm_query: "team=" + args.sys_id,
           sysparm_fields: "sys_id,user,role,allocation",
           sysparm_display_value: "true",
         },
       })
       const members = membersResp.data.result || []
 
-      // Also get the team details
-      const teamResp = await client.get("/api/now/table/rm_team/" + sys_id, {
+      const teamResp = await client.get("/api/now/table/rm_team/" + args.sys_id, {
         params: { sysparm_display_value: "true" },
       })
 
@@ -102,37 +125,24 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
       })
     }
 
-    if (action === "add_member") {
-      if (!member) return createErrorResult("member is required for add_member action")
-
-      // Resolve user
-      var userId = member
-      if (member.indexOf("SYS") !== 0 && member.length !== 32) {
-        const userLookup = await client.get("/api/now/table/sys_user", {
-          params: {
-            sysparm_query: "user_name=" + member + "^ORsys_id=" + member,
-            sysparm_limit: 1,
-            sysparm_fields: "sys_id,user_name,name",
-          },
-        })
-        const users = userLookup.data.result || []
-        if (users.length === 0) return createErrorResult("User not found: " + member)
-        userId = users[0].sys_id
-      }
+    if (args.action === "add_member") {
+      if (!args.member) return createErrorResult("member is required for add_member action")
+
+      const userId = args.member.length === 32 ? args.member : await resolveUser(client, args.member)
+      if (!userId) return createErrorResult("User not found: " + args.member)
 
-      const body: Record<string, any> = { team: sys_id, user: userId }
-      if (role) body.role = role
+      const body: Record<string, any> = { team: args.sys_id, user: userId }
+      if (args.role) body.role = args.role
       const response = await client.post("/api/now/table/rm_team_member", body)
       return createSuccessResult({ action: "member_added", member: response.data.result })
     }
 
-    if (action === "remove_member") {
-      if (!member) return createErrorResult("member is required for remove_member action")
+    if (args.action === "remove_member") {
+      if (!args.member) return createErrorResult("member is required for remove_member action")
 
-      // Find the team_member record
       const memberLookup = await client.get("/api/now/table/rm_team_member", {
         params: {
-          sysparm_query: "team=" + sys_id + "^user=" + member + "^ORuser.user_name=" + member,
+          sysparm_query: "team=" + args.sys_id + "^user=" + args.member + "^ORuser.user_name=" + args.member,
           sysparm_limit: 1,
           sysparm_fields: "sys_id",
         },
@@ -144,9 +154,11 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
       return createSuccessResult({ action: "member_removed", member_sys_id: found[0].sys_id })
     }
 
-    return createErrorResult("Unknown action: " + action)
+    return createErrorResult("Unknown action: " + args.action)
   } catch (error: any) {
-    return createErrorResult(error.message)
+    const msg = error.message || "Operation failed"
+    if (msg.indexOf("Invalid table") !== -1) return createErrorResult(PLUGIN_HINT)
+    return createErrorResult("Team " + args.action + " failed: " + msg)
   }
 }
 

package/src/servicenow/servicenow-mcp-unified/tools/agile/snow_agile_velocity_report.ts

@@ -56,7 +56,14 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
     })
 
     const sprints = sprintsResp.data.result || []
-    if (sprints.length === 0) return createSuccessResult({ message: "No sprints found for team: " + team, velocity: [] })
+    if (sprints.length === 0)
+      return createSuccessResult({
+        message:
+          "No sprints found for team: " +
+          args.team +
+          ". If using Agile 2.0 teams, ensure the 'Agile Development 2.0 - Team component' plugin (com.snc.sdlc.agile.2.0.team) is activated and sprints are linked to the team's group.",
+        velocity: [],
+      })
 
     var velocityData: any[] = []
     var totalCompleted = 0