mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-20 18:26:40 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work. > - MCP Apps (#21119) show interactive widgets from MCP servers, such as Circleback meeting cards, with the agent's reply in the task chat. > - The first version deferred three parts of the MCP Apps spec. A widget could not propose a chat message (`ui/message`). It could not give the agent context (`ui/update-model-context`). It could not go full screen. > - Paperclip also ignored the `icons` that MCP servers declare on tools (SEP-973). > - The security review of #21119 showed what these features need from day one: explicit consent, untrusted-data labels and strict icon sanitizing. > - This pull request adds the three host features and provider tool icons, with those protections built in. > - The benefit is that widgets can now work with the person and the agent, not only display data. ## Linked Issues or Issue Description Refs #21119 **Subsystem affected** MCP Apps host (task chat widgets), tool catalog, run wake prompt. **Problem or motivation** The MCP Apps host refused `ui/message` (-32601), dropped `ui/update-model-context` and kept every view inline. MCP tool `icons` were not parsed or shown. So widgets could not ask the agent a follow-up, the agent could not see what the person selected in a widget, large widgets were cramped, and tool rows used only generic icons. **Proposed solution** Add consent-gated view messages, per-view app context delivered to the task's next run as untrusted data, a full-screen dialog, and sanitized provider icons. Details are under "What Changed". **Alternatives considered** - Send view messages with a new server route that creates the comment itself. Rejected: comment creation has many rules (agent chat ownership, paused conversations, queued delivery, wakeups, receipts). The widget's Send button uses the same send path as the composer. A small route then records which view the comment came from. - Keep the iframe in place for full screen with CSS. Rejected: chat containers can create containing blocks that break `position: fixed`. A moved iframe always reloads, so the dialog hosts a new frame instead. **Roadmap alignment** Continues the MCP feature work after #21119, #21140 and #21219. It does not touch the MCP Tasks work (gateway `tools/call` polling and elicitation). ## What Changed - **`ui/message`.** The host shows "<App> wants to send: …" with **Send** and **Dismiss** under the widget (and inside the full-screen dialog). Nothing is sent before the click. Send posts the text as the viewer's own comment through the chat's normal send path (`handleThreadAdd`). `POST /api/issues/:issueId/mcp-app-views/:viewId/messages` then logs `issue.mcp_app_message_sent`. It accepts only the caller's own comment on the same task, matched by `clientRequestId`, from the last 10 minutes. One proposal per view can wait at a time. The view gets `{}` after the send, or -32000 "Message sending denied" after Dismiss. Only `user` text up to 8,000 characters is accepted. - **`ui/update-model-context`.** `PUT /api/issues/:issueId/mcp-app-views/:viewId/model-context` stores the latest context per view in `tool_mcp_app_views.model_context` (text blocks and `structuredContent`, 16 KB at most). Updates are applied in order and deduped in the browser and on the server. A change logs `issue.mcp_app_context_updated`, and an empty update clears the context. The task's next run gets the three most recently updated contexts as an `## App context (untrusted)` wake-prompt section. The section quotes the data as JSON and says it is third-party data, not instructions. The read runs in parallel with the other run preparation and never fails the run. CLI adapters and the native runner render it through the same `renderPaperclipWakePrompt`. - **Who may do this.** Messages and context need a signed-in person with `issue:comment` on the task. Agents and API keys get 403. Other tasks and companies get 404. `message` and `updateModelContext` are advertised in `hostCapabilities` only where the viewer can send messages. - **Full screen.** The host advertises `availableDisplayModes: ["inline","fullscreen"]` and handles `ui/request-display-mode`. It honors the view's declared modes and answers with the resulting mode. It sends `host-context-changed` with `displayMode` and the container (fixed `height`/`width` in full screen), and again when that container resizes. A new **Open full screen** control sits next to "Widget from …". Full screen is a Paperclip dialog that closes with Exit, Escape or the view's own request. - **Provider tool icons.** `icons` on MCP tool descriptors are sanitized into the new `tool_catalog_entries.icons` column, outside the version hash, so a new icon never quarantines a reviewed tool. Only `https:` URLs and `data:image/*` URIs are kept, and SVG only as `data:`. A `data:` icon is at most 32 KB, a URL at most 2,048 characters, with at most 4 icons per tool. `GET /api/companies/:companyId/tool-icons` lists them keyed by gateway tool name, in one cached request per chat. Task chat tool rows and the app's actions list show them through `ProviderToolIcon`. It renders `<img referrerPolicy="no-referrer">` at a fixed size and never inlines markup. It checks the source again before rendering and falls back to the taxonomy icon. - **Schema.** Migration `0477` adds `tool_catalog_entries.icons`, `tool_mcp_app_views.model_context` and `model_context_updated_at`, all nullable. - **Docs and stories.** `doc/connections/MCP-APPS.md` documents the new behavior, and the finished items are removed from "Limits and follow-ups". `Tasks/MCP App views` has new stories: "View asks to send a message", "Full screen" and "Tool rows with provider icons". The fixture view now uses `ui/message`, `ui/request-display-mode` and `ui/update-model-context`. ## Verification - `pnpm exec vitest run server/src/__tests__/mcp-apps.test.ts server/src/__tests__/tool-catalog-publication.test.ts server/src/__tests__/openapi-routes.test.ts packages/shared/src/mcp-icons.test.ts packages/shared/src/mcp-apps.test.ts`: pass (embedded Postgres). These tests cover: - Context: stored, deduped, logged once, 413 when too large, cleared, scoped to the task and company, refused for agents (403), and rendered into the wake prompt as untrusted data. - Messages: attributed only to the viewer's own recent comment on the same task. A teammate's comment, an unknown request id or an old comment gets 404. An agent gets 403. - Icons: stored sanitized, and the version hash and status do not change. Another company sees nothing. - `cd ui && pnpm exec vitest run src/components/mcp-app/ src/components/ProviderToolIcon.test.tsx src/pages/apps/app-detail/`: 69 pass. These tests cover: - The host protocol for each new method: capabilities, consent wait, one proposal at a time, invalid input, ordered and deduped context, the size limit, and the display-mode rules. - The consent card (nothing sent without Send). - The full-screen dialog (one frame at a time). - Icon rendering (no-referrer `img`, no inline SVG, fallback). - `cd ui && pnpm typecheck` (including Storybook) and `tsc --noEmit` for the server: clean. - Red/green: the new route and host tests fail on `master`, where the routes do not exist and the host answers -32601 or drops updates. The icon descriptor test failed when the publication write was removed. - Not run locally: the full suite, and `packages/adapter-utils/src/server-utils.test.ts › runChildProcess › does not crash when the child closes stdin before a delayed write`. That test times out on this Mac with or without this change, so it is a local platform issue. CI covers both. ## Risks - Migration risk is low: three nullable columns, no backfill. - Every run on a task now does one extra indexed read, in parallel with the other preparation. Errors are logged and the run continues without app context. - If the attribution request fails after the comment is sent, the comment stays without the `mcp_app_message_sent` activity row. This is documented. - Switching between inline and full screen restarts the view, so state inside the widget resets. This is documented as a limit. - Icon names shortened with a hash by the gateway (very long names) do not match, and those rows keep the taxonomy icon. > For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and discuss it in `#dev` before opening the PR. Feature PRs that overlap with planned core work may need to be redirected — check the roadmap first. See `CONTRIBUTING.md`. ## Model Used - Claude Opus 5.5 (`claude-opus-5-5`) in Claude Code, with tool use and code execution. One subagent (the same model) built the provider-icon part. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [ ] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
293 lines
15 KiB
TypeScript
293 lines
15 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import type { Db } from "@paperclipai/db";
|
|
import { logger } from "../../middleware/logger.js";
|
|
import { admitToolInputSchema, canonicalToolInputSchema, TOOL_INPUT_SCHEMA_MAX_BYTES } from "../../vendor/paperclip-runner/index.js";
|
|
import { deduplicateToolDescriptors, ToolGatewayHttpError, type ToolGatewayDescriptor, type ToolGatewayService } from "../tool-gateway.js";
|
|
|
|
type WorkMode = "standard" | "planning" | "ask" | "skill_test";
|
|
type ToolDefinition = Record<string, unknown>;
|
|
|
|
const SEARCH_TOOL = "paperclip_search_assigned_tools";
|
|
const CALL_TOOL = "paperclip_call_assigned_tool";
|
|
// A single valid runner schema can be 512 KiB. Leave room for its description
|
|
// while keeping the complete result below the 768 KiB provider-result bound.
|
|
const SEARCH_PAGE_BYTES = 640 * 1024;
|
|
const SCHEMA_CHUNK_CHARACTERS = 64 * 1024;
|
|
const ON_DEMAND_TOOLS: ToolDefinition[] = [
|
|
{
|
|
name: SEARCH_TOOL,
|
|
description: "Search your assigned app tools by name or description and read their input schemas. Pass {\"query\":\"search terms\"}, or an empty query to browse. Use limit from 1 to 20 (default 5). Omit unused optional fields instead of sending null. To fetch the next page, pass the returned nextOffset as offset. A large definition returns inputSchemaRef: set schemaTool to that name with an empty query, then pass the returned nextSchemaOffset as schemaOffset until null. Concatenate schemaJson chunks and parse JSON. Use paperclip_call_assigned_tool with a returned name and arguments matching its inputSchema.",
|
|
inputSchema: {
|
|
type: "object", additionalProperties: false,
|
|
properties: {
|
|
query: { type: "string", maxLength: 200 },
|
|
offset: { type: "integer", minimum: 0 },
|
|
limit: { type: "integer", minimum: 1, maximum: 20, default: 5, description: "Maximum results per page (1 to 20; default 5)." },
|
|
schemaTool: { type: "string", description: "Exact inputSchemaRef from a search result. Omit or leave blank for a normal tool search." },
|
|
schemaOffset: { type: "integer", minimum: 0, description: "Schema chunk offset. A positive offset requires an exact inputSchemaRef in schemaTool." },
|
|
},
|
|
required: ["query"],
|
|
},
|
|
},
|
|
{
|
|
name: CALL_TOOL,
|
|
description: "Call an assigned app tool discovered with paperclip_search_assigned_tools. Use its exact returned name and arguments matching its inputSchema. The same permissions, approvals, and audit rules apply as for direct app tools.",
|
|
inputSchema: {
|
|
type: "object", additionalProperties: false,
|
|
properties: { name: { type: "string" }, arguments: { type: "object", additionalProperties: true } },
|
|
required: ["name", "arguments"],
|
|
},
|
|
},
|
|
];
|
|
|
|
function object(value: unknown): Record<string, unknown> {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
|
throw new Error("assigned_mcp_tool_invalid_arguments");
|
|
}
|
|
return value as Record<string, unknown>;
|
|
}
|
|
|
|
function definition(name: string, tool: ToolGatewayDescriptor, inputSchema: Record<string, unknown>): ToolDefinition {
|
|
return { name, description: `${tool.displayName}: ${tool.description}`, inputSchema: structuredClone(inputSchema) };
|
|
}
|
|
|
|
// Execution must use the app's configured gateway, including deployment
|
|
// restrictions, OAuth refresh, and approval delivery. Never fall back to an
|
|
// isolated gateway whose defaults differ from the running instance.
|
|
const assignedMcpGateways = new WeakMap<Db, ToolGatewayService>();
|
|
|
|
export function registerAssignedMcpGateway(db: Db, gateway: ToolGatewayService): void {
|
|
assignedMcpGateways.set(db, gateway);
|
|
}
|
|
|
|
export function getAssignedMcpGateway(db: Db): ToolGatewayService {
|
|
const gateway = assignedMcpGateways.get(db);
|
|
if (!gateway) throw new Error("assigned_mcp_gateway_unavailable");
|
|
return gateway;
|
|
}
|
|
|
|
/** No configured gateway means no authorized connection tools or instructions. */
|
|
export async function resolveAssignedConnectionInstructionsForRun(db: Db, binding: { companyId: string; agentId: string; runId: string }) {
|
|
const gateway = assignedMcpGateways.get(db);
|
|
return gateway ? gateway.resolveConnectionInstructionsForRun(binding) : null;
|
|
}
|
|
|
|
/** MCP Skills: approved skills of the agent's usable connections; none without a configured gateway. */
|
|
export async function resolveMcpConnectionSkillsForRun(db: Db, binding: { companyId: string; agentId: string; runId: string }) {
|
|
const gateway = assignedMcpGateways.get(db);
|
|
return gateway ? gateway.resolveConnectionSkillsForRun(binding) : null;
|
|
}
|
|
|
|
/** The name native runners give a gateway tool; transcripts show this name. */
|
|
export function assignedToolName(name: string): string {
|
|
const sanitize = (value: string) => value.replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
|
|
const separator = name.lastIndexOf(":");
|
|
const readable = separator >= 0
|
|
? `${sanitize(name.slice(0, separator)).slice(0, 20) || "tool"}_${sanitize(name.slice(separator + 1)).slice(-26) || "action"}`
|
|
: sanitize(name).slice(0, 47) || "tool";
|
|
const digest = createHash("sha256").update(name).digest("hex").slice(0, 12);
|
|
return `app_${readable}_${digest}`;
|
|
}
|
|
|
|
export const ASSIGNED_SCHEMA_LISTING_BUDGET_BYTES = 768 * 1024;
|
|
export const ASSIGNED_SCHEMA_ADMISSION_CACHE_ENTRIES = 1024;
|
|
|
|
type AssignedSchemaOutcome = { ok: true } | { ok: false; reason: string };
|
|
type AssignedSchemaAdmission = { ok: true; schema: Record<string, unknown> } | { ok: false; reason: string };
|
|
const assignedSchemaOutcomes = new Map<string, AssignedSchemaOutcome>();
|
|
|
|
export function assignedSchemaAdmissionCacheSize(): number {
|
|
return assignedSchemaOutcomes.size;
|
|
}
|
|
|
|
async function admitAssignedToolSchema(serialized: string, schema: Record<string, unknown>): Promise<AssignedSchemaAdmission> {
|
|
const key = createHash("sha256").update(serialized).digest("hex");
|
|
let outcome = assignedSchemaOutcomes.get(key);
|
|
if (!outcome) {
|
|
await new Promise<void>(resolve => setImmediate(resolve));
|
|
outcome = assignedSchemaOutcomes.get(key);
|
|
}
|
|
if (!outcome) {
|
|
const admission = admitToolInputSchema(schema);
|
|
outcome = admission.ok ? { ok: true } : { ok: false, reason: admission.reason };
|
|
}
|
|
assignedSchemaOutcomes.delete(key);
|
|
assignedSchemaOutcomes.set(key, outcome);
|
|
while (assignedSchemaOutcomes.size > ASSIGNED_SCHEMA_ADMISSION_CACHE_ENTRIES) {
|
|
assignedSchemaOutcomes.delete(assignedSchemaOutcomes.keys().next().value!);
|
|
}
|
|
return outcome.ok ? { ok: true, schema: canonicalToolInputSchema(schema)!.schema } : outcome;
|
|
}
|
|
|
|
/** Server-owned MCP bindings projected into the runner's existing tool channel. */
|
|
export async function createAssignedMcpTools(input: {
|
|
gateway: ToolGatewayService;
|
|
gatewayPublicId: string;
|
|
bearerToken: string;
|
|
workMode?: WorkMode;
|
|
/** Bound provider grammar complexity independently of protocol byte capacity. */
|
|
delivery?: "on_demand";
|
|
}) {
|
|
const listed = await input.gateway.listToolsForNamedGateway({
|
|
gatewayPublicId: input.gatewayPublicId,
|
|
bearerToken: input.bearerToken,
|
|
});
|
|
const tools = new Map<string, ToolGatewayDescriptor>();
|
|
const schemas = new Map<string, Record<string, unknown>>();
|
|
const unavailable: Array<{ tool: string; reason: string }> = [];
|
|
const unchecked: string[] = [];
|
|
let listingSchemaBytes = 0;
|
|
for (const descriptor of deduplicateToolDescriptors(listed)) {
|
|
const name = assignedToolName(descriptor.name);
|
|
const previous = tools.get(name);
|
|
if (previous) {
|
|
throw new ToolGatewayHttpError(409,
|
|
`Assigned MCP tool name collision for ${JSON.stringify([previous.name, descriptor.name])}.`,
|
|
"assigned_mcp_tool_name_collision");
|
|
}
|
|
const raw = (descriptor.parametersSchema ?? { type: "object", properties: {} }) as Record<string, unknown>;
|
|
const serialized = JSON.stringify(raw);
|
|
const bytes = Buffer.byteLength(serialized, "utf8");
|
|
const compilable = bytes <= TOOL_INPUT_SCHEMA_MAX_BYTES
|
|
&& (listingSchemaBytes += bytes) <= ASSIGNED_SCHEMA_LISTING_BUDGET_BYTES;
|
|
if (!compilable) {
|
|
tools.set(name, descriptor);
|
|
schemas.set(name, structuredClone(raw));
|
|
unchecked.push(descriptor.name);
|
|
continue;
|
|
}
|
|
const admission = await admitAssignedToolSchema(serialized, raw);
|
|
if (!admission.ok) {
|
|
unavailable.push({ tool: descriptor.name, reason: admission.reason });
|
|
continue;
|
|
}
|
|
tools.set(name, descriptor);
|
|
schemas.set(name, admission.schema);
|
|
}
|
|
if (unavailable.length > 0) {
|
|
logger.warn({ gatewayPublicId: input.gatewayPublicId, unavailable },
|
|
"assigned MCP tools whose input schema the Runner cannot validate are not offered");
|
|
}
|
|
if (unchecked.length > 0) {
|
|
logger.warn({ gatewayPublicId: input.gatewayPublicId, unchecked },
|
|
"assigned MCP tools whose input schema is over the compile budget are offered only through assigned-tool search");
|
|
}
|
|
const permits = (tool: ToolGatewayDescriptor, mode: WorkMode = input.workMode ?? "standard") => mode === "standard" || tool.risk === "read";
|
|
// OpenCode's HTTP bridge returns at most 64K JSON characters. Leave room
|
|
// for the envelope and for JSON escaping when returning a schema chunk.
|
|
// Other harnesses retain the larger PRP page and chunk budgets.
|
|
const searchPageBytes = input.delivery === "on_demand" ? 32 * 1024 : SEARCH_PAGE_BYTES;
|
|
const schemaChunkCharacters = input.delivery === "on_demand" ? 16 * 1024 : SCHEMA_CHUNK_CHARACTERS;
|
|
|
|
async function search(argumentsValue: unknown, currentWorkMode?: WorkMode) {
|
|
const args = object(argumentsValue);
|
|
const offset = args.offset ?? 0;
|
|
const limit = args.limit ?? 5;
|
|
const schemaOffset = args.schemaOffset ?? 0;
|
|
const hasSchemaTool = typeof args.schemaTool === "string" && args.schemaTool.trim().length > 0;
|
|
if (typeof args.query !== "string" || args.query.length > 200 ||
|
|
typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0 ||
|
|
typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 1 || limit > 20 ||
|
|
(args.schemaTool !== undefined && typeof args.schemaTool !== "string") ||
|
|
typeof schemaOffset !== "number" || !Number.isSafeInteger(schemaOffset) || schemaOffset < 0) {
|
|
throw new Error("assigned_mcp_tool_invalid_arguments");
|
|
}
|
|
if (schemaOffset > 0 && !hasSchemaTool) {
|
|
throw new Error("assigned_mcp_tool_invalid_arguments: A positive schemaOffset requires an exact inputSchemaRef in schemaTool. Omit schemaTool and schemaOffset to search assigned tools.");
|
|
}
|
|
// Intersect fresh grants with this session's pinned catalog. Revocations
|
|
// take effect immediately; newly assigned tools require a new session.
|
|
const current = new Map(deduplicateToolDescriptors(await input.gateway.listToolsForNamedGateway({
|
|
gatewayPublicId: input.gatewayPublicId, bearerToken: input.bearerToken,
|
|
})).map(tool => [tool.name, tool]));
|
|
const terms = args.query.toLowerCase().trim().split(/\s+/).filter(Boolean);
|
|
const authorized = [...tools].filter(([, tool]) => {
|
|
const fresh = current.get(tool.name);
|
|
return fresh && permits(tool) && permits(tool, currentWorkMode) &&
|
|
permits(fresh) && permits(fresh, currentWorkMode);
|
|
});
|
|
if (hasSchemaTool) {
|
|
const selected = authorized.find(([name]) => name === args.schemaTool);
|
|
if (!selected) throw new Error("assigned_mcp_tool_unknown: schemaTool must match an authorized inputSchemaRef. Omit schemaTool to search assigned tools, then use an exact inputSchemaRef from the results.");
|
|
const schema = JSON.stringify(schemas.get(selected[0]));
|
|
const end = schemaOffset + schemaChunkCharacters;
|
|
return {
|
|
name: selected[0], schemaJson: schema.slice(schemaOffset, end),
|
|
nextSchemaOffset: end < schema.length ? end : null,
|
|
};
|
|
}
|
|
// Keep offsets anchored to the pinned catalog while fresh grants only
|
|
// decide which entries are returned from that stable sequence.
|
|
const authorizedNames = new Set(authorized.map(([name]) => name));
|
|
const matches = [...tools].filter(([, tool]) => permits(tool)).filter(([name, tool]) =>
|
|
terms.every(term => `${name} ${tool.displayName} ${tool.description}`.toLowerCase().includes(term)))
|
|
.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
|
|
const page: ToolDefinition[] = [];
|
|
let nextOffset = offset;
|
|
while (nextOffset < matches.length && page.length < limit) {
|
|
const [name, tool] = matches[nextOffset]!;
|
|
if (!authorizedNames.has(name)) {
|
|
nextOffset += 1;
|
|
continue;
|
|
}
|
|
let next = definition(name, tool, schemas.get(name)!);
|
|
if (Buffer.byteLength(JSON.stringify([next]), "utf8") > searchPageBytes) {
|
|
// One large schema must not block browsing the tools after it. Expose
|
|
// a reference whose schema can be fetched in bounded, reauthorized
|
|
// chunks, without weakening the gateway's argument validation.
|
|
next = { name, description: String(next.description).slice(0, 2000), inputSchemaRef: name };
|
|
}
|
|
if (Buffer.byteLength(JSON.stringify([...page, next]), "utf8") > searchPageBytes) {
|
|
break;
|
|
}
|
|
page.push(next);
|
|
nextOffset += 1;
|
|
}
|
|
return { tools: page, nextOffset: nextOffset < matches.length ? nextOffset : null };
|
|
}
|
|
|
|
return {
|
|
definitions(fits?: (definitions: ToolDefinition[]) => boolean): ToolDefinition[] {
|
|
const direct = [...tools].filter(([, tool]) => permits(tool)).map(([name, tool]) => definition(name, tool, schemas.get(name)!));
|
|
if (input.delivery !== "on_demand" && unchecked.length === 0 && (!fits || fits(direct))) return direct;
|
|
const compact = structuredClone(ON_DEMAND_TOOLS);
|
|
if (fits && !fits(compact)) throw new Error("assigned_mcp_tool_catalog_capacity_exceeded");
|
|
return compact;
|
|
},
|
|
has(name: string): boolean {
|
|
return tools.has(name) || name === SEARCH_TOOL || name === CALL_TOOL;
|
|
},
|
|
async execute(call: { tool: string; arguments: unknown }, currentWorkMode?: WorkMode): Promise<unknown> {
|
|
if (call.tool === SEARCH_TOOL) return search(call.arguments, currentWorkMode);
|
|
let name = call.tool;
|
|
let parameters = call.arguments;
|
|
if (name === CALL_TOOL) {
|
|
const args = object(parameters);
|
|
if (typeof args.name !== "string") throw new Error("assigned_mcp_tool_invalid_arguments");
|
|
name = args.name;
|
|
parameters = object(args.arguments);
|
|
}
|
|
const descriptor = tools.get(name);
|
|
if (!descriptor) throw new Error("assigned_mcp_tool_unknown");
|
|
if (!permits(descriptor) || !permits(descriptor, currentWorkMode)) throw new Error("paperclip_runner_tool_mode_denied");
|
|
// Reauthorize through the existing gateway on every call. Discovery is
|
|
// not a grant: revocation, policy, approval, and audit remain server-owned.
|
|
const result = await input.gateway.executeTool({
|
|
gatewayPublicId: input.gatewayPublicId,
|
|
sessionToken: input.bearerToken,
|
|
tool: descriptor.name,
|
|
parameters,
|
|
});
|
|
if (result.status !== "completed" && result.status !== "replayed") {
|
|
throw new Error("assigned_mcp_tool_execution_incomplete");
|
|
}
|
|
// The gateway normally throws provider errors. Keep a malformed or older
|
|
// provider response from being reported as successful through PRP.
|
|
if (result.result && typeof result.result === "object" && "isError" in result.result && result.result.isError === true) {
|
|
throw new ToolGatewayHttpError(502, "The assigned tool returned an error.", "tool_error");
|
|
}
|
|
return result.result;
|
|
},
|
|
};
|
|
}
|