@promptlayer/mcp-server 1.2.0 → 1.3.0

package/src/types.ts

@@ -228,9 +228,6 @@ export const CreateDatasetVersionFromFileArgsSchema = z.object({
 export const CreateDatasetVersionFromFilterParamsArgsSchema = z.object({
   dataset_group_id: z.number().int().describe("Dataset group ID"),
   variables_to_parse: z.array(z.string()).optional().describe("Variables to extract from request logs"),
-  prompt_id: z.number().int().optional().describe("Filter by prompt template ID"),
-  prompt_version_id: z.number().int().optional().describe("Filter by prompt version ID"),
-  prompt_label_id: z.number().int().optional().describe("Filter by prompt label ID"),
   workspace_id: z.number().int().optional().describe("Workspace ID"),
   tags: z.array(z.string()).optional().describe("Filter by tags (simple tag filter)"),
   metadata: z.record(z.string()).optional().describe("Simple metadata key-value filter"),
@@ -251,7 +248,7 @@ export const CreateDatasetVersionFromFilterParamsArgsSchema = z.object({
     name: z.string().describe("Prompt template name"),
     version_numbers: z.array(z.number().int()).optional().describe("Filter to specific version numbers"),
     labels: z.array(z.string()).optional().describe("Filter to specific labels"),
-  })).optional().describe("Include request logs matching these prompt templates"),
+  })).optional().describe("Include request logs matching these prompt templates. This is the primary way to filter by prompt — use the prompt name (not ID)."),
   prompt_templates_exclude: z.array(z.object({
     name: z.string().describe("Prompt template name"),
     version_numbers: z.array(z.number().int()).optional().describe("Filter to specific version numbers"),
@@ -423,6 +420,15 @@ export const GetWorkflowVersionExecutionResultsArgsSchema = z.object({
 // ── Get Agent (GET /workflows/{workflow_id_or_name}) ─────────────────────
 
 export const GetWorkflowArgsSchema = z.object({
+  workflow_id_or_name: z.string().describe("Agent ID or name"),
+  version: z.number().int().optional().describe("Specific version number (mutually exclusive with label)"),
+  label: z.string().optional().describe("Release label name, e.g. 'prod' (mutually exclusive with version)"),
+  api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
+});
+
+// ── Get Agent Labels (GET /workflows/{workflow_id_or_name}/labels) ────────
+
+export const GetWorkflowLabelsArgsSchema = z.object({
   workflow_id_or_name: z.string().describe("Agent ID or name"),
   api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
 });
@@ -807,10 +813,16 @@ export const TOOL_DEFINITIONS = {
   },
   "get-workflow": {
     name: "get-workflow",
-    description: "Get a single agent (called 'workflow' in the API) by ID or name. Returns the agent details and configuration.",
+    description: "Get a single agent (called 'workflow' in the API) by ID or name. Returns the agent details including full node configuration, edges, and version info. Optionally filter by version number or release label.",
     inputSchema: GetWorkflowArgsSchema,
     annotations: { readOnlyHint: true },
   },
+  "get-workflow-labels": {
+    name: "get-workflow-labels",
+    description: "List all release labels for an agent (workflow). Returns each label with its name, ID, and the version it points to.",
+    inputSchema: GetWorkflowLabelsArgsSchema,
+    annotations: { readOnlyHint: true },
+  },
 
   // ── Folders ─────────────────────────────────────────────────────────
   "create-folder": {

package/scripts/diff-endpoints.ts

@@ -1,277 +0,0 @@
-/**
- * Compares openapi-endpoints.json (source of truth) against mcp-tools.json
- * (what our MCP implements) and reports discrepancies.
- *
- * Usage: npx tsx scripts/diff-endpoints.ts
- *
- * Exit code 0 = in sync (or all issues are known exceptions), 1 = new issues found.
- */
-
-import { readFileSync } from "fs";
-
-const OPENAPI_PATH = new URL("./openapi-endpoints.json", import.meta.url).pathname;
-const MCP_PATH = new URL("./mcp-tools.json", import.meta.url).pathname;
-
-// ─── Known exceptions ────────────────────────────────────────────────────────
-// Each string is matched exactly against an issue line. When ALL remaining
-// issues are in this list, the script exits 0 (pass). Add a comment for each
-// explaining WHY it's expected so a future reader/agent understands.
-const KNOWN_EXCEPTIONS: string[] = [
-  // update-report-score-card is documented in the PromptLayer reference text
-  // (https://docs.promptlayer.com/reference/update-report-score-card) but the
-  // endpoint is not present in the OpenAPI spec (openapi.json). We implement
-  // it because users need it; it will resolve when PromptLayer adds it to the spec.
-  "EXTRA IN MCP (not in OpenAPI): PATCH /reports/{report_id}/score-card (tool: update-report-score-card)",
-
-  // These endpoints exist in the OpenAPI spec but were intentionally removed from the MCP server.
-  // track-prompt, track-score, track-metadata, and track-group are redundant with log-request
-  // which accepts all tracking fields inline. add-report-column is removed as well.
-  "MISSING IN MCP: POST /rest/track-prompt (Track Prompt)",
-  "MISSING IN MCP: POST /rest/track-score (Track Score)",
-  "MISSING IN MCP: POST /rest/track-metadata (Track Metadata)",
-  "MISSING IN MCP: POST /rest/track-group (Track Group)",
-  "MISSING IN MCP: POST /report-columns (Add Column to Evaluation Pipeline)",
-
-  // get-workflow exists in the backend (public_api/workflows/get_workflows_id_or_name.py)
-  // but is not in the OpenAPI spec.
-  "EXTRA IN MCP (not in OpenAPI): GET /workflows/{workflow_id_or_name} (tool: get-workflow)",
-
-  // Folder management endpoints exist in the backend (public_api/) but are not yet in the OpenAPI spec.
-  // edit-folder was added in PR #244.
-  "EXTRA IN MCP (not in OpenAPI): PATCH /api/public/v2/folders/{folder_id} (tool: edit-folder)",
-  "EXTRA IN MCP (not in OpenAPI): GET /api/public/v2/folders/entities (tool: get-folder-entities)",
-  "EXTRA IN MCP (not in OpenAPI): POST /api/public/v2/folders/entities (tool: move-folder-entities)",
-  "EXTRA IN MCP (not in OpenAPI): DELETE /api/public/v2/folders/entities (tool: delete-folder-entities)",
-  "EXTRA IN MCP (not in OpenAPI): GET /api/public/v2/folders/resolve-id (tool: resolve-folder-id)",
-
-  // callback_url is documented in the run-workflow reference text
-  // (https://docs.promptlayer.com/reference/run-workflow) under Request Body
-  // but is not yet in the OpenAPI spec. We include it for async webhook support.
-  'EXTRA FIELD: POST /workflows/{workflow_name}/run > "callback_url" not in OpenAPI [tool: run-workflow]',
-
-  // The OpenAPI spec defines input/output as oneOf (ChatPrompt | CompletionPrompt).
-  // We type them as plain object (z.record) because the MCP tool passes them through
-  // as-is to the API — the server validates the discriminated union, not us.
-  'TYPE MISMATCH: POST /log-request > "input": MCP=object, OpenAPI=oneOf [tool: log-request]',
-  'TYPE MISMATCH: POST /log-request > "output": MCP=object, OpenAPI=oneOf [tool: log-request]',
-
-  // workspace_id is accepted by the backend but not yet in the OpenAPI spec for these endpoints.
-  'EXTRA FIELD: GET /prompt-templates > "workspace_id" not in OpenAPI [tool: list-prompt-templates]',
-  'EXTRA FIELD: POST /api/public/v2/folders > "workspace_id" not in OpenAPI [tool: create-folder]',
-
-  // snippet_overrides is accepted by the backend publish endpoint but not in OpenAPI spec.
-  'EXTRA FIELD: POST /rest/prompt-templates > "snippet_overrides" not in OpenAPI [tool: publish-prompt-template]',
-
-  // Backend accepts prompt_version_id as alternative to prompt_version_number for label ops,
-  // and we make prompt_version_number optional to support both. Not yet in OpenAPI spec.
-  'EXTRA FIELD: POST /prompts/{prompt_id}/label > "prompt_version_id" not in OpenAPI [tool: create-prompt-label]',
-  'EXTRA FIELD: PATCH /prompt-labels/{prompt_label_id} > "prompt_version_id" not in OpenAPI [tool: move-prompt-label]',
-  'REQUIRED MISMATCH: POST /prompts/{prompt_id}/label > "prompt_version_number": MCP=false, OpenAPI=true [tool: create-prompt-label]',
-  'REQUIRED MISMATCH: PATCH /prompt-labels/{prompt_label_id} > "prompt_version_number": MCP=false, OpenAPI=true [tool: move-prompt-label]',
-
-  // score_name is accepted by the backend log-request endpoint but not in OpenAPI spec.
-  'EXTRA FIELD: POST /log-request > "score_name" not in OpenAPI [tool: log-request]',
-
-  // folder_id is accepted by the backend create-dataset-group endpoint but not in OpenAPI spec.
-  'EXTRA FIELD: POST /api/public/v2/dataset-groups > "folder_id" not in OpenAPI [tool: create-dataset-group]',
-
-  // Backend auto-generates name if omitted for dataset groups; OpenAPI marks it required.
-  'REQUIRED MISMATCH: POST /api/public/v2/dataset-groups > "name": MCP=false, OpenAPI=true [tool: create-dataset-group]',
-
-  // workflow_node_id and workflow_node_name are accepted by the backend execution results
-  // endpoint but not in OpenAPI spec.
-  'EXTRA FIELD: GET /workflow-version-execution-results > "workflow_node_id" not in OpenAPI [tool: get-workflow-version-execution-results]',
-  'EXTRA FIELD: GET /workflow-version-execution-results > "workflow_node_name" not in OpenAPI [tool: get-workflow-version-execution-results]',
-
-  // The create-dataset-version-from-filter-params endpoint passes through to the backend's
-  // RequestLogFilterParams model which has many more filter fields than the OpenAPI spec lists.
-  // We include the full set from the backend for completeness. The OpenAPI spec only documents
-  // a simplified subset (dataset_group_id, variables_to_parse, start_time, end_time, plus the
-  // fields we added: prompt_id, prompt_version_id, prompt_label_id, workspace_id, tags, metadata).
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "id" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "limit" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "tags_and" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "tags_or" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "metadata_and" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "metadata_or" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "prompt_templates_include" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "prompt_templates_exclude" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "starred" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "status" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "sort_by" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "sort_order" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-  'EXTRA FIELD: POST /api/public/v2/dataset-versions/from-filter-params > "order_by_random" not in OpenAPI [tool: create-dataset-version-from-filter-params]',
-
-  // The OpenAPI spec defines scores as object but backend uses a list of {name, operator, value}.
-  // Our array type matches what the backend actually accepts.
-  'TYPE MISMATCH: POST /api/public/v2/dataset-versions/from-filter-params > "scores": MCP=array, OpenAPI=object [tool: create-dataset-version-from-filter-params]',
-
-  // patch-prompt-template-version exists in the backend and OpenAPI but is not yet implemented
-  // in MCP. Low priority — publish-prompt-template covers most use cases.
-  "MISSING IN MCP: PATCH /rest/prompt-templates/{identifier} (Patch Prompt Template Version)",
-
-  // OTLP trace ingestion endpoint exists in OpenAPI but is not implemented in MCP.
-  // This is a specialized protocol endpoint, not a typical REST API tool.
-  "MISSING IN MCP: POST /v1/traces (Ingest Traces (OTLP))",
-
-  // Semantic search and tags parameters for folder entities are documented in the reference docs
-  // (https://docs.promptlayer.com/reference/list-folder-entities) but not yet in the OpenAPI spec.
-  'EXTRA FIELD: GET /api/public/v2/folders/entities > "semantic_search" not in OpenAPI [tool: get-folder-entities]',
-  'EXTRA FIELD: GET /api/public/v2/folders/entities > "semantic_search_top_k" not in OpenAPI [tool: get-folder-entities]',
-  'EXTRA FIELD: GET /api/public/v2/folders/entities > "semantic_search_threshold" not in OpenAPI [tool: get-folder-entities]',
-  'EXTRA FIELD: GET /api/public/v2/folders/entities > "tags" not in OpenAPI [tool: get-folder-entities]',
-
-  // The OpenAPI spec represents tags as anyOf(string, array) but our Zod union serializes
-  // as "union" vs "union(string,array)". Functionally equivalent.
-  'TYPE MISMATCH: GET /prompt-templates > "tags": MCP=union, OpenAPI=union(string,array) [tool: list-prompt-templates]',
-
-  // filter_type OpenAPI uses oneOf vs our Zod union. Functionally equivalent.
-  'TYPE MISMATCH: GET /api/public/v2/folders/entities > "filter_type": MCP=union, OpenAPI=oneOf [tool: get-folder-entities]',
-
-  // workspace_id is optional in MCP because the API key implicitly provides it.
-  // OpenAPI marks it required but the backend falls back to the API key's workspace.
-  'REQUIRED MISMATCH: GET /api/public/v2/folders/entities > "workspace_id": MCP=false, OpenAPI=true [tool: get-folder-entities]',
-  'REQUIRED MISMATCH: GET /api/public/v2/folders/resolve-id > "workspace_id": MCP=false, OpenAPI=true [tool: resolve-folder-id]',
-];
-// ─────────────────────────────────────────────────────────────────────────────
-
-type OpenAPIEndpoint = {
-  method: string;
-  path: string;
-  summary: string;
-  operationId: string;
-  pathParams: { name: string; type: string; required: boolean }[];
-  queryParams: { name: string; type: string; required: boolean; enum?: string[] }[];
-  bodyFields: { name: string; type: string; required: boolean; enum?: string[] }[];
-};
-
-type MCPTool = {
-  toolName: string;
-  method: string;
-  path: string;
-  description: string;
-  fields: { name: string; type: string; required: boolean; enum?: string[] }[];
-};
-
-function endpointKey(method: string, path: string): string {
-  return `${method} ${path}`;
-}
-
-function main() {
-  const openapi: OpenAPIEndpoint[] = JSON.parse(readFileSync(OPENAPI_PATH, "utf-8"));
-  const mcp: MCPTool[] = JSON.parse(readFileSync(MCP_PATH, "utf-8"));
-
-  const allIssues: string[] = [];
-
-  const openapiMap = new Map<string, OpenAPIEndpoint>();
-  for (const ep of openapi) openapiMap.set(endpointKey(ep.method, ep.path), ep);
-
-  const mcpMap = new Map<string, MCPTool>();
-  for (const tool of mcp) mcpMap.set(endpointKey(tool.method, tool.path), tool);
-
-  // 1. Endpoints in OpenAPI but missing from MCP
-  for (const [key, ep] of openapiMap) {
-    if (!mcpMap.has(key)) {
-      allIssues.push(`MISSING IN MCP: ${key} (${ep.summary})`);
-    }
-  }
-
-  // 2. Endpoints in MCP but not in OpenAPI
-  for (const [key, tool] of mcpMap) {
-    if (!openapiMap.has(key)) {
-      allIssues.push(`EXTRA IN MCP (not in OpenAPI): ${key} (tool: ${tool.toolName})`);
-    }
-  }
-
-  // 3. Field-level comparison for matching endpoints
-  for (const [key, tool] of mcpMap) {
-    const ep = openapiMap.get(key);
-    if (!ep) continue;
-
-    const openapiFields = new Map<string, { type: string; required: boolean; enum?: string[] }>();
-    for (const p of ep.pathParams) openapiFields.set(p.name, p);
-    for (const p of ep.queryParams) openapiFields.set(p.name, { type: p.type, required: p.required, ...(p.enum ? { enum: p.enum } : {}) });
-    for (const f of ep.bodyFields) openapiFields.set(f.name, { type: f.type, required: f.required, ...(f.enum ? { enum: f.enum } : {}) });
-
-    const mcpFields = new Map<string, { type: string; required: boolean; enum?: string[] }>();
-    for (const f of tool.fields) mcpFields.set(f.name, f);
-
-    for (const [name, spec] of openapiFields) {
-      if (!mcpFields.has(name)) {
-        allIssues.push(`MISSING FIELD: ${key} > "${name}" (${spec.type}, ${spec.required ? "required" : "optional"}) [tool: ${tool.toolName}]`);
-      }
-    }
-
-    for (const [name] of mcpFields) {
-      if (!openapiFields.has(name)) {
-        allIssues.push(`EXTRA FIELD: ${key} > "${name}" not in OpenAPI [tool: ${tool.toolName}]`);
-      }
-    }
-
-    for (const [name, mcpField] of mcpFields) {
-      const oaField = openapiFields.get(name);
-      if (!oaField) continue;
-
-      if (mcpField.required !== oaField.required) {
-        allIssues.push(`REQUIRED MISMATCH: ${key} > "${name}": MCP=${mcpField.required}, OpenAPI=${oaField.required} [tool: ${tool.toolName}]`);
-      }
-
-      const mcpType = mcpField.type.replace("number", "integer");
-      const oaType = oaField.type.replace("number", "integer");
-      if (mcpType !== oaType && oaType !== "unknown") {
-        allIssues.push(`TYPE MISMATCH: ${key} > "${name}": MCP=${mcpField.type}, OpenAPI=${oaField.type} [tool: ${tool.toolName}]`);
-      }
-    }
-  }
-
-  // Partition into known vs new
-  const knownSet = new Set(KNOWN_EXCEPTIONS);
-  const knownIssues = allIssues.filter((i) => knownSet.has(i));
-  const newIssues = allIssues.filter((i) => !knownSet.has(i));
-
-  // Report
-  if (allIssues.length === 0) {
-    console.log("PASS: All MCP tools are in sync with the OpenAPI spec. No issues.");
-    process.exit(0);
-  }
-
-  if (knownIssues.length > 0) {
-    console.log(`Known exceptions (${knownIssues.length}):`);
-    knownIssues.forEach((i) => console.log(`  [OK] ${i}`));
-    console.log();
-  }
-
-  if (newIssues.length === 0) {
-    console.log(`PASS: ${knownIssues.length} known exception(s), 0 new issues.`);
-    process.exit(0);
-  }
-
-  console.log(`FAIL: ${newIssues.length} new issue(s) found:\n`);
-
-  const buckets: Record<string, string[]> = {
-    "Missing Endpoints": [],
-    "Extra Endpoints": [],
-    "Missing Fields": [],
-    "Extra Fields": [],
-    "Type/Required Mismatches": [],
-  };
-
-  for (const i of newIssues) {
-    if (i.startsWith("MISSING IN MCP")) buckets["Missing Endpoints"].push(i);
-    else if (i.startsWith("EXTRA IN MCP")) buckets["Extra Endpoints"].push(i);
-    else if (i.startsWith("MISSING FIELD")) buckets["Missing Fields"].push(i);
-    else if (i.startsWith("EXTRA FIELD")) buckets["Extra Fields"].push(i);
-    else buckets["Type/Required Mismatches"].push(i);
-  }
-
-  for (const [label, items] of Object.entries(buckets)) {
-    if (items.length === 0) continue;
-    console.log(`--- ${label} ---`);
-    items.forEach((i) => console.log(`  ${i}`));
-    console.log();
-  }
-
-  process.exit(1);
-}
-
-main();

package/scripts/extract-mcp-tools.ts

@@ -1,122 +0,0 @@
-/**
- * Extracts the MCP tool definitions from our types.ts and outputs a canonical
- * JSON file matching the shape of openapi-endpoints.json for comparison.
- *
- * Usage: npx tsx scripts/extract-mcp-tools.ts
- */
-
-import { TOOL_DEFINITIONS } from "../src/types.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-const OUTPUT_PATH = new URL("./mcp-tools.json", import.meta.url).pathname;
-
-// Map from MCP tool name to the REST endpoint it wraps.
-// This is the manual mapping — it's the one thing we maintain by hand.
-// The diff script checks everything else automatically.
-// Fields renamed in MCP vs OpenAPI (MCP name → OpenAPI name)
-const FIELD_ALIASES: Record<string, Record<string, string>> = {
-  "get-prompt-template": { "prompt_name": "identifier" },
-};
-
-const TOOL_TO_ENDPOINT: Record<string, { method: string; path: string }> = {
-  "get-prompt-template":        { method: "POST",   path: "/prompt-templates/{identifier}" },
-  "get-prompt-template-raw":    { method: "GET",    path: "/prompt-templates/{identifier}" },
-  "list-prompt-templates":      { method: "GET",    path: "/prompt-templates" },
-  "publish-prompt-template":    { method: "POST",   path: "/rest/prompt-templates" },
-  "list-prompt-template-labels":{ method: "GET",    path: "/prompt-templates/{identifier}/labels" },
-  "create-prompt-label":        { method: "POST",   path: "/prompts/{prompt_id}/label" },
-  "move-prompt-label":          { method: "PATCH",  path: "/prompt-labels/{prompt_label_id}" },
-  "delete-prompt-label":        { method: "DELETE", path: "/prompt-labels/{prompt_label_id}" },
-  "get-snippet-usage":          { method: "GET",    path: "/prompt-templates/{identifier}/snippet-usage" },
-  "search-request-logs":        { method: "POST",   path: "/api/public/v2/requests/search" },
-  "get-request":                { method: "GET",    path: "/api/public/v2/requests/{request_id}" },
-  "log-request":                { method: "POST",   path: "/log-request" },
-  "create-spans-bulk":          { method: "POST",   path: "/spans-bulk" },
-  "list-datasets":              { method: "GET",    path: "/api/public/v2/datasets" },
-  "get-dataset-rows":           { method: "GET",    path: "/api/public/v2/datasets/{dataset_id}/rows" },
-  "create-dataset-group":       { method: "POST",   path: "/api/public/v2/dataset-groups" },
-  "create-dataset-version-from-file": { method: "POST", path: "/api/public/v2/dataset-versions/from-file" },
-  "create-dataset-version-from-filter-params": { method: "POST", path: "/api/public/v2/dataset-versions/from-filter-params" },
-  "list-evaluations":           { method: "GET",    path: "/api/public/v2/evaluations" },
-  "get-evaluation-rows":        { method: "GET",    path: "/api/public/v2/evaluations/{evaluation_id}/rows" },
-  "create-report":              { method: "POST",   path: "/reports" },
-  "run-report":                 { method: "POST",   path: "/reports/{report_id}/run" },
-  "get-report":                 { method: "GET",    path: "/reports/{report_id}" },
-  "get-report-score":           { method: "GET",    path: "/reports/{report_id}/score" },
-  "update-report-score-card":   { method: "PATCH",  path: "/reports/{report_id}/score-card" },
-  "delete-reports-by-name":     { method: "DELETE", path: "/reports/name/{report_name}" },
-  "list-workflows":             { method: "GET",    path: "/workflows" },
-  "create-workflow":            { method: "POST",   path: "/rest/workflows" },
-  "patch-workflow":             { method: "PATCH",  path: "/rest/workflows/{workflow_id_or_name}" },
-  "run-workflow":               { method: "POST",   path: "/workflows/{workflow_name}/run" },
-  "get-workflow-version-execution-results": { method: "GET", path: "/workflow-version-execution-results" },
-  "get-workflow":               { method: "GET",    path: "/workflows/{workflow_id_or_name}" },
-  "create-folder":              { method: "POST",   path: "/api/public/v2/folders" },
-  "edit-folder":                { method: "PATCH",  path: "/api/public/v2/folders/{folder_id}" },
-  "get-folder-entities":        { method: "GET",    path: "/api/public/v2/folders/entities" },
-  "move-folder-entities":       { method: "POST",   path: "/api/public/v2/folders/entities" },
-  "delete-folder-entities":     { method: "DELETE", path: "/api/public/v2/folders/entities" },
-  "resolve-folder-id":          { method: "GET",    path: "/api/public/v2/folders/resolve-id" },
-};
-
-type ToolEntry = {
-  toolName: string;
-  method: string;
-  path: string;
-  description: string;
-  fields: { name: string; type: string; required: boolean; enum?: string[] }[];
-};
-
-function normalizeType(schema: Record<string, unknown>): string {
-  const t = schema.type;
-  if (typeof t === "string") return t;
-  if (Array.isArray(t)) {
-    const nonNull = t.filter((x: unknown) => x !== "null");
-    return nonNull.length === 1 ? String(nonNull[0]) : `union(${nonNull.join(",")})`;
-  }
-  if (schema.anyOf) return "union";
-  if (schema.oneOf) return "oneOf";
-  return "unknown";
-}
-
-async function main() {
-  const tools: ToolEntry[] = [];
-
-  for (const [name, def] of Object.entries(TOOL_DEFINITIONS)) {
-    const mapping = TOOL_TO_ENDPOINT[name];
-    if (!mapping) {
-      console.error(`WARNING: No endpoint mapping for tool "${name}"`);
-      continue;
-    }
-
-    const jsonSchema = zodToJsonSchema(def.inputSchema, { target: "openApi3" }) as Record<string, unknown>;
-    const properties = (jsonSchema.properties || {}) as Record<string, Record<string, unknown>>;
-    const required = new Set((jsonSchema.required || []) as string[]);
-
-    const aliases = FIELD_ALIASES[name] || {};
-    const fields: ToolEntry["fields"] = [];
-    for (const [fieldName, fieldSchema] of Object.entries(properties)) {
-      if (fieldName === "api_key") continue; // skip MCP-only field
-      fields.push({
-        name: aliases[fieldName] || fieldName,
-        type: normalizeType(fieldSchema),
-        required: required.has(fieldName),
-        ...(fieldSchema.enum ? { enum: fieldSchema.enum as string[] } : {}),
-      });
-    }
-
-    tools.push({
-      toolName: name,
-      method: mapping.method,
-      path: mapping.path,
-      description: def.description,
-      fields,
-    });
-  }
-
-  const fs = await import("fs");
-  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(tools, null, 2) + "\n");
-  console.error(`Wrote ${tools.length} tools to ${OUTPUT_PATH}`);
-}
-
-main().catch((e) => { console.error(e); process.exit(1); });

package/scripts/fetch-openapi-endpoints.ts

@@ -1,150 +0,0 @@
-/**
- * Fetches the PromptLayer OpenAPI spec from GitHub and extracts a canonical
- * list of endpoints with their parameters. Writes to scripts/openapi-endpoints.json.
- *
- * Usage: npx tsx scripts/fetch-openapi-endpoints.ts
- */
-
-const OPENAPI_URL = "https://raw.githubusercontent.com/magnivorg/prompt-layer-docs/master/openapi.json";
-const OUTPUT_PATH = new URL("./openapi-endpoints.json", import.meta.url).pathname;
-
-type OpenAPIParam = {
-  name: string;
-  in: string;
-  required?: boolean;
-  schema?: { type?: string; enum?: string[]; default?: unknown; [k: string]: unknown };
-  [k: string]: unknown;
-};
-
-type OpenAPISchema = {
-  type?: string;
-  properties?: Record<string, { type?: string | unknown[]; enum?: string[]; [k: string]: unknown }>;
-  required?: string[];
-  $ref?: string;
-  [k: string]: unknown;
-};
-
-type CanonicalEndpoint = {
-  method: string;
-  path: string;
-  summary: string;
-  operationId: string;
-  pathParams: { name: string; type: string; required: boolean }[];
-  queryParams: { name: string; type: string; required: boolean; enum?: string[]; default?: unknown }[];
-  bodyFields: { name: string; type: string; required: boolean; enum?: string[] }[];
-};
-
-function resolveRef(ref: string, spec: Record<string, unknown>): Record<string, unknown> {
-  const parts = ref.replace("#/", "").split("/");
-  let obj: unknown = spec;
-  for (const p of parts) obj = (obj as Record<string, unknown>)[p];
-  return obj as Record<string, unknown>;
-}
-
-function resolveSchema(schema: OpenAPISchema, spec: Record<string, unknown>): OpenAPISchema {
-  if (schema.$ref) return resolveRef(schema.$ref, spec) as OpenAPISchema;
-  return schema;
-}
-
-function normalizeType(schema: { type?: string | unknown[]; anyOf?: unknown[]; oneOf?: unknown[]; [k: string]: unknown }): string {
-  if (typeof schema.type === "string") return schema.type;
-  if (Array.isArray(schema.type)) {
-    const nonNull = schema.type.filter((t) => t !== "null");
-    return nonNull.length === 1 ? String(nonNull[0]) : String(schema.type);
-  }
-  if (schema.anyOf) {
-    const types = (schema.anyOf as Array<{ type?: string }>).map((s) => s.type).filter((t) => t && t !== "null");
-    return types.length === 1 ? types[0]! : `union(${types.join(",")})`;
-  }
-  if (schema.oneOf) return "oneOf";
-  return "unknown";
-}
-
-async function main() {
-  console.error(`Fetching OpenAPI spec from ${OPENAPI_URL}...`);
-  const resp = await fetch(OPENAPI_URL);
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
-  const spec = (await resp.json()) as Record<string, unknown>;
-  const paths = spec.paths as Record<string, Record<string, Record<string, unknown>>>;
-
-  const endpoints: CanonicalEndpoint[] = [];
-
-  for (const [path, methods] of Object.entries(paths).sort(([a], [b]) => a.localeCompare(b))) {
-    for (const method of ["get", "post", "put", "patch", "delete"]) {
-      const op = methods[method];
-      if (!op) continue;
-
-      const endpoint: CanonicalEndpoint = {
-        method: method.toUpperCase(),
-        path,
-        summary: (op.summary as string) || "",
-        operationId: (op.operationId as string) || "",
-        pathParams: [],
-        queryParams: [],
-        bodyFields: [],
-      };
-
-      // Parameters (path + query)
-      const params = (op.parameters || []) as OpenAPIParam[];
-      for (const p of params) {
-        const resolved = p.$ref ? (resolveRef(p.$ref as string, spec) as OpenAPIParam) : p;
-        if (resolved.in === "header") continue; // skip X-API-KEY
-        const schema = resolved.schema || {};
-        const entry = {
-          name: resolved.name,
-          type: normalizeType(schema),
-          required: resolved.required ?? false,
-          ...(schema.enum ? { enum: schema.enum } : {}),
-          ...(schema.default !== undefined ? { default: schema.default } : {}),
-        };
-        if (resolved.in === "path") endpoint.pathParams.push(entry);
-        else if (resolved.in === "query") endpoint.queryParams.push(entry);
-      }
-
-      // Request body
-      const reqBody = op.requestBody as { content?: Record<string, { schema?: OpenAPISchema }> } | undefined;
-      if (reqBody?.content) {
-        for (const ct of Object.values(reqBody.content)) {
-          let schema = ct.schema;
-          if (!schema) continue;
-          schema = resolveSchema(schema, spec);
-
-          // Handle anyOf/oneOf wrappers (e.g. anyOf: [$ref, null])
-          if (!schema.properties && (schema.anyOf || schema.oneOf)) {
-            const variants = (schema.anyOf || schema.oneOf) as OpenAPISchema[];
-            const nonNull = variants.filter((v) => v.type !== "null");
-            if (nonNull.length === 1) {
-              schema = resolveSchema(nonNull[0], spec);
-            }
-          }
-
-          if (schema.type === "object" && schema.properties) {
-            const required = new Set(schema.required || []);
-            for (const [name, propSchema] of Object.entries(schema.properties)) {
-              const resolved = propSchema.$ref
-                ? (resolveRef(propSchema.$ref as string, spec) as typeof propSchema)
-                : propSchema;
-              endpoint.bodyFields.push({
-                name,
-                type: normalizeType(resolved),
-                required: required.has(name),
-                ...(resolved.enum ? { enum: resolved.enum as string[] } : {}),
-              });
-            }
-          }
-        }
-      }
-
-      endpoints.push(endpoint);
-    }
-  }
-
-  const { writeFileSync } = await import("fs");
-  writeFileSync(OUTPUT_PATH, JSON.stringify(endpoints, null, 2) + "\n");
-  console.error(`Wrote ${endpoints.length} endpoints to ${OUTPUT_PATH}`);
-}
-
-main().catch((e) => {
-  console.error(e);
-  process.exit(1);
-});