@promptlayer/mcp-server 1.8.0 → 1.10.0

package/gcp/package.json

@@ -22,5 +22,18 @@
   },
   "engines": {
     "node": ">=20.0.0"
+  },
+  "overrides": {
+    "hono": "^4.12.14",
+    "@hono/node-server": "^1.19.13",
+    "express-rate-limit": "^8.2.2",
+    "express": {
+      "path-to-regexp": "^0.1.13"
+    },
+    "router": {
+      "path-to-regexp": "^8.4.0"
+    },
+    "qs": "^6.14.2",
+    "ajv": "^8.18.0"
   }
 }

package/gcp/src/index.ts

@@ -90,6 +90,14 @@ const TOOL_HANDLERS: Record<string, ToolHandler> = {
   "get-workflow-labels": (c, { workflow_id_or_name }) =>
     c.getWorkflowLabels(workflow_id_or_name as string),
 
+  // Tool Registry
+  "list-tool-registries": (c) => c.listToolRegistries(),
+  "get-tool-registry": (c, { api_key: _, identifier, ...p }) =>
+    c.getToolRegistry(identifier as string, p),
+  "create-tool-registry": (c, a) => c.createToolRegistry(body(a)),
+  "create-tool-version": (c, { api_key: _, identifier, ...b }) =>
+    c.createToolVersion(identifier as string, b),
+
   // Folders
   "create-folder": (c, a) => c.createFolder(body(a)),
   "edit-folder": (c, { api_key: _, folder_id, ...b }) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptlayer/mcp-server",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Model Context Protocol server for PromptLayer",
   "type": "module",
   "main": "build/index.js",
@@ -32,5 +32,13 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "overrides": {
+    "hono": "^4.12.14",
+    "@hono/node-server": "^1.19.13",
+    "express-rate-limit": "^8.2.2",
+    "path-to-regexp": "^8.4.0",
+    "qs": "^6.14.2",
+    "ajv": "^8.18.0"
   }
 }

package/src/client.ts

@@ -99,6 +99,12 @@ export class PromptLayerClient {
   runWorkflow(name: string, body: Body) { return this.post(`/workflows/${this.enc(name)}/run`, body); }
   getWorkflowVersionExecutionResults(params: Body) { return this.get("/workflow-version-execution-results", params); }
 
+  // Tool Registry
+  listToolRegistries() { return this.get("/api/public/v2/tool-registry"); }
+  getToolRegistry(identifier: string, params?: Body) { return this.get(`/api/public/v2/tool-registry/${this.enc(identifier)}`, params); }
+  createToolRegistry(body: Body) { return this.post("/api/public/v2/tool-registry", body); }
+  createToolVersion(identifier: string, body: Body) { return this.post(`/api/public/v2/tool-registry/${this.enc(identifier)}/versions`, body); }
+
   // Folders
   createFolder(body: Body) { return this.post("/api/public/v2/folders", body); }
   editFolder(folderId: number, body: Body) { return this.patch(`/api/public/v2/folders/${folderId}`, body); }

package/src/handlers.ts

@@ -139,6 +139,18 @@ export function registerAllTools(server: any) {
     (c, a) => c.getWorkflowLabels((a as { workflow_id_or_name: string }).workflow_id_or_name),
     (r) => { const labels = (r as { release_labels?: unknown[] }).release_labels; return `${labels?.length ?? 0} label(s) found`; });
 
+  // Tool Registry
+  reg(t["list-tool-registries"], (c) => c.listToolRegistries(),
+    (r) => { const tools = (r as { tool_registries?: unknown[] }).tool_registries; return `${tools?.length ?? 0} tool(s)`; });
+  reg(t["get-tool-registry"],
+    (c, a) => { const { api_key: _, identifier, ...p } = a as { identifier: string; api_key?: string } & Args; return c.getToolRegistry(identifier, p); },
+    (r) => { const t_ = (r as { tool_registry?: { name?: string } }).tool_registry; return `Tool "${t_?.name ?? ""}" retrieved`; });
+  reg(t["create-tool-registry"], (c, a) => c.createToolRegistry(body(a)),
+    (r) => { const t_ = (r as { tool_registry?: { name?: string; id?: number } }).tool_registry; return t_ ? `Tool "${t_.name}" created (ID: ${t_.id})` : "Tool created"; });
+  reg(t["create-tool-version"],
+    (c, a) => { const { api_key: _, identifier, ...b } = a as { identifier: string; api_key?: string } & Args; return c.createToolVersion(identifier, b); },
+    (r) => { const v = (r as { version?: { number?: number } }).version; return v ? `Version ${v.number} created` : "Version created"; });
+
   // Folders
   reg(t["create-folder"], (c, a) => c.createFolder(body(a)), () => "Folder created");
   reg(t["edit-folder"],

package/src/types.ts

@@ -83,7 +83,12 @@ export const PublishPromptTemplateArgsSchema = z.object({
     prompt_name: z.string().describe("Name of the prompt template"),
     tags: z.array(z.string()).optional().describe("Tags to associate"),
     folder_id: z.number().int().optional().describe("Folder ID to publish into"),
-  }).describe("Template metadata: prompt_name (required), tags, folder_id"),
+    is_snippet: z.boolean().optional().describe(
+      "Mark this template as a reusable snippet (referenced via @@@name@@@ in other prompts). " +
+      "Only takes effect when the prompt is first created — publishing a new version of an " +
+      "existing template will not flip this flag."
+    ),
+  }).describe("Template metadata: prompt_name (required), tags, folder_id, is_snippet"),
   prompt_version: z.object({
     prompt_template: z.record(z.unknown()).describe("The template content in chat ({type:'chat', messages:[...]}) or completion format"),
     commit_message: z.string().optional().describe("Commit message (max 72 chars)"),
@@ -218,44 +223,59 @@ export const CreateDatasetVersionFromFileArgsSchema = z.object({
   api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
 });
 
+// ── Structured filter primitives (shared by request search + dataset-from-history) ──
+// NOTE: value/filters use loose types (z.unknown()) because the backend validates
+// operator-field compatibility at runtime. This is tracked as a known exception in
+// scripts/diff-endpoints.ts.
+
+const StructuredFilterSchema = z.object({
+  field: z.enum([
+    "pl_id", "prompt_id", "engine", "provider_type", "input_text", "output_text",
+    "prompt_version_number", "input_tokens", "output_tokens", "cost", "latency_ms",
+    "request_start_time", "request_end_time", "status",
+    "is_json", "is_tool_call", "is_plain_text", "has_trace",
+    "tags", "metadata_keys", "metadata", "tool_names",
+    "output", "output_keys", "input_variables", "input_variable_keys",
+    "turn_count", "tool_call_count",
+  ]).describe("Request log field to filter on"),
+  operator: z.enum([
+    "is", "is_not", "in", "not_in",
+    "contains", "not_contains", "starts_with", "ends_with",
+    "eq", "neq", "gt", "gte", "lt", "lte", "between",
+    "before", "after",
+    "is_true", "is_false", "is_empty", "is_not_empty",
+    "is_null", "is_not_null",
+    "key_equals", "key_not_equals", "key_contains",
+  ]).describe("Filter operator (availability depends on field type)"),
+  value: z.unknown().optional().describe("Filter value (type depends on operator)"),
+  nested_key: z.string().optional().describe("Key name for nested field operators (metadata, output, input_variables)"),
+});
+
+const StructuredFilterGroupSchema: z.ZodType = z.object({
+  logic: z.enum(["AND", "OR"]).optional().describe("Logical operator (default: AND)"),
+  filters: z.array(z.union([StructuredFilterSchema, z.lazy(() => StructuredFilterGroupSchema)])).describe("Filters or nested filter groups"),
+});
+
 // ── Create Dataset Version from Filter Params (POST /api/public/v2/dataset-versions/from-filter-params)
 
 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"),
-  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"),
-  start_time: z.string().optional().describe("Start time filter (ISO 8601)"),
-  end_time: z.string().optional().describe("End time filter (ISO 8601)"),
-  id: z.number().int().optional().describe("Filter by specific request log ID"),
-  limit: z.number().int().optional().describe("Limit number of request logs to pull"),
-  tags_and: z.array(z.string()).optional().describe("Filter by tags (AND logic — all must match)"),
-  tags_or: z.array(z.string()).optional().describe("Filter by tags (OR logic — any can match)"),
-  metadata_and: z.array(z.object({ key: z.string(), value: z.string() })).optional().describe("Metadata filters with AND logic (all must match). Each item: {key, value}"),
-  metadata_or: z.array(z.object({ key: z.string(), value: z.string() })).optional().describe("Metadata filters with OR logic (any can match). Each item: {key, value}"),
-  scores: z.array(z.object({
-    name: z.string().describe("Score name"),
-    operator: z.enum([">", "<", ">=", "<=", "="]).describe("Comparison operator"),
-    value: z.number().int().describe("Score value to compare against"),
-  })).optional().describe("Filter by score criteria. Each item: {name, operator, value}"),
-  prompt_templates_include: 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"),
-    labels: z.array(z.string()).optional().describe("Filter to specific labels"),
-  })).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"),
-    labels: z.array(z.string()).optional().describe("Filter to specific labels"),
-  })).optional().describe("Exclude request logs matching these prompt templates"),
-  starred: z.boolean().optional().describe("Filter by starred status"),
-  status: z.array(z.enum(["SUCCESS", "WARNING", "ERROR"])).optional().describe("Filter by request log status"),
+  dataset_group_id: z.number().int().describe("Dataset group ID to create the new version under"),
+  request_log_ids: z.array(z.number().int().positive()).optional().describe(
+    "Static snapshot mode: pin the dataset to an explicit list of request log IDs (capped at 50,000). " +
+    "≤50 IDs run synchronously; >50 are processed asynchronously. " +
+    "Datasets created this way are not refreshable."
+  ),
+  filter_group: StructuredFilterGroupSchema.optional().describe(
+    "Structured filter mode: same shape as search-request-logs (AND/OR groups of field/operator/value filters). " +
+    "Always processed asynchronously. Persisted on the dataset so refresh_dataset can replay it."
+  ),
+  q: z.string().optional().describe("Free-text search query applied alongside filter_group"),
   sort_by: z.enum([
-    "request_start_time", "input_tokens", "output_tokens", "price",
-    "score", "latency", "prompt_name", "status",
+    "request_start_time", "input_tokens", "output_tokens", "cost",
+    "latency_ms", "status", "turn_count", "tool_call_count",
   ]).optional().describe("Sort field"),
-  sort_order: z.enum(["asc", "desc"]).optional().describe("Sort direction"),
-  order_by_random: z.boolean().optional().describe("Random ordering (requires limit)"),
+  sort_order: z.enum(["asc", "desc"]).optional().describe("Sort direction (defaults to desc when sort_by is set)"),
+  variables_to_parse: z.array(z.string()).optional().describe("Input variable names to extract as dataset columns"),
   api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
 });
 
@@ -496,6 +516,34 @@ export const GetWorkflowLabelsArgsSchema = z.object({
 });
 
 
+// ── Tool Registry ────────────────────────────────────────────────────
+
+export const ListToolRegistriesArgsSchema = z.object({
+  api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
+});
+
+export const GetToolRegistryArgsSchema = z.object({
+  identifier: z.string().describe("Tool ID (numeric) or name"),
+  label: z.string().optional().describe("Resolve version by label name (e.g. 'production')"),
+  version: z.number().int().optional().describe("Resolve by specific version number"),
+  api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
+});
+
+export const CreateToolRegistryArgsSchema = z.object({
+  name: z.string().describe("Tool name (unique per workspace)"),
+  tool_definition: z.record(z.unknown()).describe("Tool definition in OpenAI function-calling format: {type: 'function', function: {name, description, parameters}}"),
+  folder_id: z.number().int().optional().describe("Folder ID to place tool in"),
+  commit_message: z.string().optional().describe("Commit message for the initial version"),
+  api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
+});
+
+export const CreateToolVersionArgsSchema = z.object({
+  identifier: z.string().describe("Tool ID (numeric) or name"),
+  tool_definition: z.record(z.unknown()).describe("Updated tool definition in OpenAI function-calling format"),
+  commit_message: z.string().optional().describe("Commit message describing what changed"),
+  api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
+});
+
 export const CreateFolderArgsSchema = z.object({
   name: z.string().describe("Folder name (unique within parent)"),
   parent_id: z.number().int().optional().describe("Parent folder ID (root if omitted)"),
@@ -570,43 +618,18 @@ export const ResolveFolderIdArgsSchema = z.object({
 
 
 // ── Search Request Logs (POST /api/public/v2/requests/search) ────────────
-// NOTE: The StructuredFilter and StructuredFilterGroup schemas use loose types
-// (z.unknown()) for value/filters because the backend validates operator-field
-// compatibility at runtime. This is tracked as a known exception in scripts/diff-endpoints.ts.
-
-const StructuredFilterSchema = z.object({
-  field: z.enum([
-    "pl_id", "prompt_id", "engine", "provider_type", "input_text", "output_text",
-    "prompt_version_number", "input_tokens", "output_tokens", "cost", "latency_ms",
-    "request_start_time", "request_end_time", "status",
-    "is_json", "is_tool_call", "is_plain_text",
-    "tags", "metadata_keys", "metadata", "tool_names",
-    "output", "output_keys", "input_variables", "input_variable_keys",
-  ]).describe("Request log field to filter on"),
-  operator: z.enum([
-    "is", "is_not", "in", "not_in",
-    "contains", "not_contains", "starts_with", "ends_with",
-    "eq", "neq", "gt", "gte", "lt", "lte", "between",
-    "before", "after",
-    "is_true", "is_false", "is_empty", "is_not_empty",
-    "is_null", "is_not_null",
-    "key_equals", "key_not_equals", "key_contains",
-  ]).describe("Filter operator (availability depends on field type)"),
-  value: z.unknown().optional().describe("Filter value (type depends on operator)"),
-  nested_key: z.string().optional().describe("Key name for nested field operators (metadata, output, input_variables)"),
-});
-
-const StructuredFilterGroupSchema: z.ZodType = z.object({
-  logic: z.enum(["AND", "OR"]).optional().describe("Logical operator (default: AND)"),
-  filters: z.array(z.union([StructuredFilterSchema, z.lazy(() => StructuredFilterGroupSchema)])).describe("Filters or nested filter groups"),
-});
+// (StructuredFilter / StructuredFilterGroup are defined higher up so the
+// dataset-from-filter-params endpoint can reuse them.)
 
 export const SearchRequestLogsArgsSchema = z.object({
   filter_group: StructuredFilterGroupSchema.optional().describe("Filter group with AND/OR logic, supports nesting. Wrap multiple filters in an AND group."),
   q: z.string().optional().describe("Free-text search across prompt input and LLM output"),
   page: z.number().int().optional().describe("Page number (default: 1)"),
   per_page: z.number().int().optional().describe("Items per page (max: 25)"),
-  sort_by: z.enum(["request_start_time", "input_tokens", "output_tokens", "cost", "latency_ms", "status"]).optional().describe("Sort field"),
+  sort_by: z.enum([
+    "request_start_time", "input_tokens", "output_tokens", "cost", "latency_ms", "status",
+    "turn_count", "tool_call_count",
+  ]).optional().describe("Sort field"),
   sort_order: z.enum(["asc", "desc"]).optional().describe("Sort direction (must be provided with sort_by)"),
   include_prompt_name: z.boolean().optional().describe("Include prompt template name in results"),
   api_key: z.string().optional().describe("PromptLayer API key (optional, defaults to PROMPTLAYER_API_KEY env var)"),
@@ -687,11 +710,14 @@ export const TOOL_DEFINITIONS = {
     name: "publish-prompt-template",
     description:
       "Create a new version of a prompt template. " +
-      "Body has two required objects: prompt_template (with prompt_name, tags, folder_id) and " +
+      "Body has two required objects: prompt_template (with prompt_name, tags, folder_id, is_snippet) and " +
       "prompt_version (with prompt_template content in chat/completion format, commit_message, metadata). " +
       "Optionally assign release_labels. " +
       "IMPORTANT: If the prompt uses snippets, preserve @@@snippet_name@@@ markers in the content. " +
-      "Do not inline snippet text — this breaks snippet references.",
+      "Do not inline snippet text — this breaks snippet references. " +
+      "To create a snippet (a reusable fragment referenced by other prompts), set " +
+      "prompt_template.is_snippet=true on the first publish. The flag is only honored on initial " +
+      "creation; later versions cannot flip an existing template into a snippet or vice versa.",
     inputSchema: PublishPromptTemplateArgsSchema,
     annotations: { readOnlyHint: false },
   },
@@ -736,9 +762,9 @@ export const TOOL_DEFINITIONS = {
       "Operators by field type:\n" +
       "  - String fields (engine, provider_type): is, is_not, in, not_in\n" +
       "  - Text fields (input_text, output_text): contains, not_contains, starts_with, ends_with\n" +
-      "  - Numeric fields (cost, latency_ms, input_tokens, output_tokens): eq, neq, gt, gte, lt, lte, between (value=[min,max]), is_null, is_not_null\n" +
+      "  - Numeric fields (cost, latency_ms, input_tokens, output_tokens, turn_count, tool_call_count): eq, neq, gt, gte, lt, lte, between (value=[min,max]), is_null, is_not_null\n" +
       "  - Datetime fields (request_start_time, request_end_time): is, before, after, between (value=[start,end] as ISO 8601)\n" +
-      "  - Boolean fields (is_json, is_tool_call, is_plain_text): is_true, is_false\n" +
+      "  - Boolean fields (is_json, is_tool_call, is_plain_text, has_trace): is_true, is_false\n" +
       "  - Array fields (tags, metadata_keys, tool_names, output_keys, input_variable_keys): contains, not_contains, in, not_in, is_empty, is_not_empty\n" +
       "  - Nested fields (metadata, output, input_variables): key_equals, key_not_equals, key_contains, in, not_in, is_empty, is_not_empty — requires nested_key\n\n" +
       "EXAMPLES:\n" +
@@ -821,7 +847,12 @@ export const TOOL_DEFINITIONS = {
   },
   "create-dataset-version-from-filter-params": {
     name: "create-dataset-version-from-filter-params",
-    description: "Create a dataset version from request log history using filter criteria. Populated asynchronously.",
+    description:
+      "Create a dataset version from request log history. Two modes:\n" +
+      "  1. request_log_ids — pin to an explicit list of IDs (≤50 sync, >50 async). Snapshot, not refreshable.\n" +
+      "  2. filter_group (+ optional q) — structured AND/OR filter, same shape as search-request-logs. " +
+      "Async; persisted on the dataset so refresh_dataset can replay it.\n" +
+      "Use variables_to_parse to extract specific input variables as dataset columns.",
     inputSchema: CreateDatasetVersionFromFilterParamsArgsSchema,
     annotations: { readOnlyHint: false },
   },
@@ -974,6 +1005,32 @@ export const TOOL_DEFINITIONS = {
     annotations: { readOnlyHint: true },
   },
 
+  // ── Tool Registry ───────────────────────────────────────────────────
+  "list-tool-registries": {
+    name: "list-tool-registries",
+    description: "List all tools in the Tool Registry for the workspace. Returns tool names, IDs, and metadata.",
+    inputSchema: ListToolRegistriesArgsSchema,
+    annotations: { readOnlyHint: true },
+  },
+  "get-tool-registry": {
+    name: "get-tool-registry",
+    description: "Get a tool from the Tool Registry by ID or name. Optionally resolve a specific version by label or version number. Returns the tool definition and metadata.",
+    inputSchema: GetToolRegistryArgsSchema,
+    annotations: { readOnlyHint: true },
+  },
+  "create-tool-registry": {
+    name: "create-tool-registry",
+    description: "Create a new tool in the Tool Registry with an initial version. The tool definition should be in OpenAI function-calling format.",
+    inputSchema: CreateToolRegistryArgsSchema,
+    annotations: { readOnlyHint: false },
+  },
+  "create-tool-version": {
+    name: "create-tool-version",
+    description: "Create a new version of an existing tool in the Tool Registry. Each version is immutable — this adds a new version with the updated definition.",
+    inputSchema: CreateToolVersionArgsSchema,
+    annotations: { readOnlyHint: false },
+  },
+
   // ── Folders ─────────────────────────────────────────────────────────
   "create-folder": {
     name: "create-folder",