@langwatch/mcp-server 2.0.0 → 2.2.0

package/src/tools/get-experiment-results.ts

@@ -1,5 +1,5 @@
-import { LangWatchApiError, makeRequest } from "../langwatch-api.js";
-import { deriveRunStatus, isTerminalStatus } from "./experiment-run-status.js";
+import { LangWatchApiError, makeRequest } from "../langwatch-api.ts";
+import { deriveRunStatus, isTerminalStatus } from "./experiment-run-status.ts";
 
 interface DatasetEntry {
   index: number;
@@ -39,12 +39,17 @@ interface EvaluationRunResults {
     finishedAt?: number | null;
     stoppedAt?: number | null;
   };
+  /** What is stored against what the run reported; absent on servers that predate it. */
+  completeness?: {
+    complete: boolean;
+    dataset: { received: number; expected: number | null };
+    evaluations: { received: number; expected: number | null };
+  };
 }
 
 const DEFAULT_ROW_CAP = 50;
 
-const rowKey = (index: number, targetId?: string | null): string =>
-  `${index}:${targetId ?? ""}`;
+const rowKey = (index: number, targetId?: string | null): string => `${index}:${targetId ?? ""}`;
 
 const summarizeEntry = (entry: Record<string, unknown>): string => {
   const candidates = ["input", "question", "query", "prompt", "user"];
@@ -68,128 +73,72 @@ const isFailedRow = ({
   evaluations: EvaluationItem[];
 }): boolean => Boolean(entry.error) || evaluations.some(isFailedEvaluation);
 
-export async function handleExperimentResults(params: {
+function hasNumericStatus(error: unknown): error is { status: number } {
+  if (typeof error !== "object" || error === null) return false;
+  return "status" in error && typeof error.status === "number";
+}
+
+type RunStatus = ReturnType<typeof deriveRunStatus>;
+type ResultRow = { entry: DatasetEntry; evaluations: EvaluationItem[] };
+type EvaluatorStats = {
+  sum: number;
+  count: number;
+  passed: number;
+  failed: number;
+  errored: number;
+};
+
+function isNotFoundError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  let status: number | undefined;
+  if (error instanceof LangWatchApiError) status = error.status;
+  else if (hasNumericStatus(error)) status = error.status;
+  return status === 404 || (status === undefined && /404|not found/i.test(message));
+}
+
+async function fetchRunResults(params: {
   runId: string;
   experimentSlug?: string;
-  filter?: "all" | "failed";
-  evaluator?: string;
-  limit?: number;
-}): Promise<string> {
-  const filter = params.filter ?? "all";
-  const evaluatorFilter = params.evaluator?.trim();
-  const limit =
-    typeof params.limit === "number" && params.limit > 0
-      ? Math.min(params.limit, DEFAULT_ROW_CAP)
-      : DEFAULT_ROW_CAP;
-
+}): Promise<EvaluationRunResults | null> {
   const search = new URLSearchParams();
   if (params.experimentSlug) search.set("experimentSlug", params.experimentSlug);
   const qs = search.toString() ? `?${search.toString()}` : "";
+  return (await makeRequest(
+    "GET",
+    `/api/v1/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`,
+  )) as EvaluationRunResults;
+}
 
-  let results: EvaluationRunResults | null;
-  try {
-    results = (await makeRequest(
-      "GET",
-      `/api/experiments/runs/${encodeURIComponent(params.runId)}/results${qs}`,
-    )) as EvaluationRunResults;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const status =
-      error instanceof LangWatchApiError
-        ? error.status
-        : error && typeof error === "object" &&
-            "status" in error &&
-            typeof (error as { status?: unknown }).status === "number"
-          ? (error as { status: number }).status
-          : undefined;
-    if (
-      status === 404 ||
-      (status === undefined && /404|not found/i.test(message))
-    ) {
-      return [
-        `# Evaluation Results: ${params.runId}`,
-        "",
-        "**Status**: not found",
-        "",
-        `Could not load results for run \`${params.runId}\`. The run id may be incorrect, or its run state may have expired (Redis keeps it for 24h).`,
-        "",
-        "> Pass `experimentSlug` to load results for runs older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` for the run ids.",
-      ].join("\n");
-    }
-    throw error;
-  }
-
-  if (!results) {
-    return [
-      `# Evaluation Results: ${params.runId}`,
-      "",
-      "**Status**: not found",
-      "",
-      `Could not load results for run \`${params.runId}\`.`,
-      "",
-      "> Pass `experimentSlug` if the run is older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` to confirm the run id.",
-    ].join("\n");
-  }
-
-  // Partial results are served even while the run is still in progress.
-  // Rows land in ClickHouse incrementally, so a "running" or "interrupted"
-  // run can still expose every row recorded so far. A run only fails to set
-  // finished_at/stopped_at when the SDK process dies before flushing, but the
-  // rows it did log are still useful, so we never gate on a terminal status.
-  const runStatus = deriveRunStatus(results.timestamps);
-  const partial = !isTerminalStatus(runStatus);
-
-  // Group evaluations by target-scoped row key, applying evaluator filter.
-  const evaluationsByRow = new Map<string, EvaluationItem[]>();
-  for (const evaluation of results.evaluations) {
+/** Evaluations grouped by target-scoped row key, keeping only the filtered evaluator. */
+function groupEvaluationsByRow({
+  evaluations,
+  evaluatorFilter,
+}: {
+  evaluations: EvaluationItem[];
+  evaluatorFilter: string | undefined;
+}): Map<string, EvaluationItem[]> {
+  const byRow = new Map<string, EvaluationItem[]>();
+  for (const evaluation of evaluations) {
     if (evaluatorFilter && evaluation.evaluator !== evaluatorFilter) continue;
     const key = rowKey(evaluation.index, evaluation.targetId);
-    const list = evaluationsByRow.get(key) ?? [];
+    const list = byRow.get(key) ?? [];
     list.push(evaluation);
-    evaluationsByRow.set(key, list);
-  }
-
-  const evaluatorNames = Array.from(
-    new Set(
-      (evaluatorFilter
-        ? results.evaluations.filter((e) => e.evaluator === evaluatorFilter)
-        : results.evaluations
-      ).map((e) => e.evaluator),
-    ),
-  );
-
-  let rows = results.dataset.map((entry) => ({
-    entry,
-    evaluations: evaluationsByRow.get(rowKey(entry.index, entry.targetId)) ?? [],
-  }));
-
-  if (filter === "failed") {
-    rows = rows.filter((r) =>
-      isFailedRow({ entry: r.entry, evaluations: r.evaluations }),
-    );
+    byRow.set(key, list);
   }
+  return byRow;
+}
 
-  const totalMatching = rows.length;
-  const rowsForSummary = rows;
-  const truncated = rows.length > limit;
-  rows = rows.slice(0, limit);
-
-  // Per-evaluator stats across the filtered rows (before truncation),
-  // so the summary matches the displayed subset when filter="failed".
-  const evaluatorAverages = new Map<
-    string,
-    { sum: number; count: number; passed: number; failed: number; errored: number }
-  >();
-  for (const r of rowsForSummary) {
+function tallyEvaluatorStats(rows: ResultRow[]): Map<string, EvaluatorStats> {
+  const averages = new Map<string, EvaluatorStats>();
+  for (const r of rows) {
     for (const e of r.evaluations) {
-      const stats =
-        evaluatorAverages.get(e.evaluator) ?? {
-          sum: 0,
-          count: 0,
-          passed: 0,
-          failed: 0,
-          errored: 0,
-        };
+      const stats = averages.get(e.evaluator) ?? {
+        sum: 0,
+        count: 0,
+        passed: 0,
+        failed: 0,
+        errored: 0,
+      };
       if (typeof e.score === "number") {
         stats.sum += e.score;
         stats.count += 1;
@@ -197,29 +146,36 @@ export async function handleExperimentResults(params: {
       if (e.status === "error") stats.errored += 1;
       else if (e.passed === true) stats.passed += 1;
       else if (e.passed === false) stats.failed += 1;
-      evaluatorAverages.set(e.evaluator, stats);
+      averages.set(e.evaluator, stats);
     }
   }
+  return averages;
+}
 
+function headerLines({
+  results,
+  runStatus,
+  filter,
+  evaluatorFilter,
+}: {
+  results: EvaluationRunResults;
+  runStatus: RunStatus;
+  filter: "all" | "failed";
+  evaluatorFilter: string | undefined;
+}): string[] {
   const lines: string[] = [];
   lines.push(`# Evaluation Results: ${results.runId}`);
   lines.push("");
   lines.push(`**Experiment**: ${results.experimentId}`);
   lines.push(`**Status**: ${runStatus}`);
   if (typeof results.total === "number" && results.total > 0) {
-    lines.push(
-      `**Progress**: ${results.progress ?? results.dataset.length}/${results.total} rows`,
-    );
+    lines.push(`**Progress**: ${results.progress ?? results.dataset.length}/${results.total} rows`);
   }
   lines.push(`**Total rows**: ${results.dataset.length}`);
   lines.push(`**Total evaluations**: ${results.evaluations.length}`);
-  if (filter === "failed") {
-    lines.push(`**Filter**: failed only`);
-  }
-  if (evaluatorFilter) {
-    lines.push(`**Evaluator filter**: ${evaluatorFilter}`);
-  }
-  if (partial) {
+  if (filter === "failed") lines.push(`**Filter**: failed only`);
+  if (evaluatorFilter) lines.push(`**Evaluator filter**: ${evaluatorFilter}`);
+  if (!isTerminalStatus(runStatus)) {
     lines.push("");
     lines.push(
       runStatus === "interrupted"
@@ -227,80 +183,157 @@ export async function handleExperimentResults(params: {
         : "> These are partial results. The run is still in progress, so more rows may appear on a later call.",
     );
   }
+  const stored = results.completeness;
+  if (isTerminalStatus(runStatus) && stored && !stored.complete) {
+    lines.push("");
+    lines.push(
+      `> These are partial results. The run has ended, but the platform is still storing it: ${storedCount(stored.dataset)} rows and ${storedCount(stored.evaluations)} evaluations so far. Call again shortly for the whole run.`,
+    );
+  }
   lines.push("");
+  return lines;
+}
 
-  if (evaluatorAverages.size > 0) {
-    lines.push("## Evaluator Summary");
-    lines.push("");
-    lines.push("| Evaluator | Avg Score | Passed | Failed | Errored |");
-    lines.push("| --- | --- | --- | --- | --- |");
-    for (const [name, stats] of evaluatorAverages) {
-      const avg =
-        stats.count > 0 ? (stats.sum / stats.count).toFixed(3) : "—";
-      lines.push(
-        `| ${name} | ${avg} | ${stats.passed} | ${stats.failed} | ${stats.errored} |`,
-      );
-    }
-    lines.push("");
+function evaluatorSummaryLines(averages: Map<string, EvaluatorStats>): string[] {
+  if (averages.size === 0) return [];
+  const lines = [
+    "## Evaluator Summary",
+    "",
+    "| Evaluator | Avg Score | Passed | Failed | Errored |",
+    "| --- | --- | --- | --- | --- |",
+  ];
+  for (const [name, stats] of averages) {
+    const avg = stats.count > 0 ? (stats.sum / stats.count).toFixed(3) : "—";
+    lines.push(`| ${name} | ${avg} | ${stats.passed} | ${stats.failed} | ${stats.errored} |`);
   }
+  lines.push("");
+  return lines;
+}
 
-  if (rows.length === 0) {
-    if (filter === "failed") {
-      lines.push("_No rows matched the filter._");
-    } else if (runStatus === "running") {
-      lines.push(
-        "_No rows recorded yet. The run is still in progress; call again shortly._",
-      );
-    } else if (runStatus === "interrupted") {
-      lines.push("_No rows were recorded before the run was interrupted._");
-    } else {
-      lines.push("_No rows recorded for this run._");
-    }
-    return lines.join("\n");
+const storedCount = ({ received, expected }: { received: number; expected: number | null }) =>
+  expected === null ? `${received}` : `${received} of ${expected}`;
+
+function noRowsLine({ filter, runStatus }: { filter: "all" | "failed"; runStatus: RunStatus }) {
+  if (filter === "failed") return "_No rows matched the filter._";
+  if (runStatus === "running")
+    return "_No rows recorded yet. The run is still in progress; call again shortly._";
+  if (runStatus === "interrupted") return "_No rows were recorded before the run was interrupted._";
+  return "_No rows recorded for this run._";
+}
+
+function evaluationLines(e: EvaluationItem): string[] {
+  const parts: string[] = [`**${e.evaluator}**`];
+  if (e.status === "error") parts.push("status=error");
+  else if (typeof e.score === "number") parts.push(`score=${e.score.toFixed(3)}`);
+  if (typeof e.passed === "boolean") parts.push(`passed=${e.passed ? "yes" : "no"}`);
+  if (e.label) parts.push(`label=${e.label}`);
+  const lines = [`- ${parts.join(" · ")}`];
+  if (e.details) lines.push(`  - details: ${e.details}`);
+  return lines;
+}
+
+function rowLines({
+  row: { entry, evaluations },
+  anyEvaluators,
+}: {
+  row: ResultRow;
+  anyEvaluators: boolean;
+}): string[] {
+  const summary = summarizeEntry(entry.entry);
+  const lines = [`### Row #${entry.index}${summary ? ` — ${summary}` : ""}`];
+  if (entry.error) lines.push(`- **Error**: ${entry.error}`);
+  if (entry.traceId) lines.push(`- **Trace ID**: \`${entry.traceId}\``);
+  if (evaluations.length === 0) {
+    lines.push(
+      anyEvaluators ? "- _No evaluations recorded for this row_" : "- _No evaluations recorded_",
+    );
+  }
+  for (const e of evaluations) lines.push(...evaluationLines(e));
+  lines.push("");
+  return lines;
+}
+
+function notFoundReport({ runId, expired }: { runId: string; expired: boolean }): string {
+  const lines = [`# Evaluation Results: ${runId}`, "", "**Status**: not found", ""];
+  if (expired) {
+    lines.push(
+      `Could not load results for run \`${runId}\`. The run id may be incorrect, or its run state may have expired (Redis keeps it for 24h).`,
+      "",
+      "> Pass `experimentSlug` to load results for runs older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` for the run ids.",
+    );
+  } else {
+    lines.push(
+      `Could not load results for run \`${runId}\`.`,
+      "",
+      "> Pass `experimentSlug` if the run is older than 24h. Discover the slug with `platform_experiment_list`, then `platform_experiment_list_runs` to confirm the run id.",
+    );
   }
+  return lines.join("\n");
+}
 
-  lines.push(
-    `## Rows (${rows.length}${truncated ? ` of ${totalMatching}` : ""})`,
+export async function handleExperimentResults(params: {
+  runId: string;
+  experimentSlug?: string;
+  filter?: "all" | "failed";
+  evaluator?: string;
+  limit?: number;
+}): Promise<string> {
+  const filter = params.filter ?? "all";
+  const evaluatorFilter = params.evaluator?.trim();
+  const limit =
+    typeof params.limit === "number" && params.limit > 0
+      ? Math.min(params.limit, DEFAULT_ROW_CAP)
+      : DEFAULT_ROW_CAP;
+
+  let results: EvaluationRunResults | null;
+  try {
+    results = await fetchRunResults(params);
+  } catch (error) {
+    if (isNotFoundError(error)) return notFoundReport({ runId: params.runId, expired: true });
+    throw error;
+  }
+  if (!results) return notFoundReport({ runId: params.runId, expired: false });
+
+  // Partial results are served while the run is in progress: rows land
+  // incrementally, and a run whose SDK died before flushing still has useful
+  // rows, so we never gate on a terminal status.
+  const runStatus = deriveRunStatus(results.timestamps);
+  const evaluationsByRow = groupEvaluationsByRow({
+    evaluations: results.evaluations,
+    evaluatorFilter,
+  });
+  const evaluatorNames = new Set(
+    (evaluatorFilter
+      ? results.evaluations.filter((e) => e.evaluator === evaluatorFilter)
+      : results.evaluations
+    ).map((e) => e.evaluator),
   );
-  lines.push("");
 
-  for (const { entry, evaluations } of rows) {
-    const summary = summarizeEntry(entry.entry);
-    lines.push(`### Row #${entry.index}${summary ? ` — ${summary}` : ""}`);
-    if (entry.error) {
-      lines.push(`- **Error**: ${entry.error}`);
-    }
-    if (entry.traceId) {
-      lines.push(`- **Trace ID**: \`${entry.traceId}\``);
-    }
-    if (evaluations.length === 0) {
-      lines.push(
-        evaluatorNames.length === 0
-          ? "- _No evaluations recorded_"
-          : "- _No evaluations recorded for this row_",
-      );
-    }
-    for (const e of evaluations) {
-      const parts: string[] = [`**${e.evaluator}**`];
-      if (e.status === "error") parts.push("status=error");
-      else if (typeof e.score === "number") parts.push(`score=${e.score.toFixed(3)}`);
-      if (typeof e.passed === "boolean") {
-        parts.push(`passed=${e.passed ? "yes" : "no"}`);
-      }
-      if (e.label) parts.push(`label=${e.label}`);
-      lines.push(`- ${parts.join(" · ")}`);
-      if (e.details) {
-        lines.push(`  - details: ${e.details}`);
-      }
-    }
-    lines.push("");
+  const allRows: ResultRow[] = results.dataset.map((entry) => ({
+    entry,
+    evaluations: evaluationsByRow.get(rowKey(entry.index, entry.targetId)) ?? [],
+  }));
+  // The summary covers the filtered rows before truncation.
+  const matching = filter === "failed" ? allRows.filter((r) => isFailedRow(r)) : allRows;
+  const truncated = matching.length > limit;
+  const rows = matching.slice(0, limit);
+
+  const lines = [
+    ...headerLines({ results, runStatus, filter, evaluatorFilter }),
+    ...evaluatorSummaryLines(tallyEvaluatorStats(matching)),
+  ];
+  if (rows.length === 0) {
+    lines.push(noRowsLine({ filter, runStatus }));
+    return lines.join("\n");
   }
 
+  lines.push(`## Rows (${rows.length}${truncated ? ` of ${matching.length}` : ""})`);
+  lines.push("");
+  for (const row of rows) lines.push(...rowLines({ row, anyEvaluators: evaluatorNames.size > 0 }));
   if (truncated) {
     lines.push(
-      `> Output truncated to ${limit} rows of ${totalMatching} matching to protect the agent's context window. Pass \`limit\` to expand or filter further.`,
+      `> Output truncated to ${limit} rows of ${matching.length} matching to protect the agent's context window. Pass \`limit\` to expand or filter further.`,
     );
   }
-
   return lines.join("\n");
 }

package/src/tools/get-project.ts

@@ -1,8 +1,6 @@
-import { getProject as apiGetProject } from "../langwatch-api-projects.js";
+import { getProject as apiGetProject } from "../langwatch-api-projects.ts";
 
-export async function handleGetProject(params: {
-  id: string;
-}): Promise<string> {
+export async function handleGetProject(params: { id: string }): Promise<string> {
   const project = await apiGetProject(params.id);
 
   const lines: string[] = [];

package/src/tools/get-prompt.ts

@@ -1,54 +1,117 @@
-import { getPrompt as apiGetPrompt } from "../langwatch-api.js";
+import { getPrompt as apiGetPrompt, type PromptDetailResponse } from "../langwatch-api.ts";
+
+interface DeploymentTag {
+  name: string;
+  versionId?: string;
+}
 
 /**
- * Handles the platform_get_prompt MCP tool invocation.
- *
- * Retrieves a specific prompt by ID or handle and formats it as
- * AI-readable markdown, including messages, model config, and version history.
+ * Normalizes one tag entry from the API. The API returns tag objects
+ * ({ name, versionId }); plain strings are tolerated so a shape drift can
+ * never crash the tool.
  */
+function normalizeTag(tag: unknown): DeploymentTag | undefined {
+  if (typeof tag === "string") return { name: tag };
+  if (tag && typeof tag === "object" && "name" in tag) {
+    const candidate = tag as { name: unknown; versionId?: unknown };
+    if (typeof candidate.name === "string") {
+      return {
+        name: candidate.name,
+        versionId: typeof candidate.versionId === "string" ? candidate.versionId : undefined,
+      };
+    }
+  }
+  return undefined;
+}
+
+function fieldEntry(field: unknown): string {
+  if (field && typeof field === "object" && "identifier" in field) {
+    const typed = field as { identifier: unknown; type?: unknown };
+    return `- **${String(typed.identifier)}**: ${typeof typed.type === "string" ? typed.type : "unknown"}`;
+  }
+  return `- ${JSON.stringify(field)}`;
+}
+
+// Renders a field list of any shape the API may return: an array of
+// { identifier, type } entries (inputs/outputs), an object map of
+// name -> value (parameters), or absent/empty (no heading at all).
+function fieldListLines({ heading, fields }: { heading: string; fields: unknown }): string[] {
+  const entries: string[] = [];
+  if (Array.isArray(fields)) {
+    entries.push(...fields.map(fieldEntry));
+  } else if (fields && typeof fields === "object") {
+    for (const [key, value] of Object.entries(fields)) {
+      entries.push(`- **${key}**: ${JSON.stringify(value)}`);
+    }
+  }
+  if (entries.length === 0) return [];
+  return [`\n**${heading}**`, ...entries];
+}
+
+function messageLines(prompt: PromptDetailResponse): string[] {
+  const messages = prompt.messages;
+  if (Array.isArray(messages) && messages.length > 0) {
+    return ["\n## Messages", ...messages.flatMap((msg) => [`\n### ${msg.role}`, msg.content])];
+  }
+  if (typeof prompt.prompt === "string" && prompt.prompt.length > 0) {
+    return ["\n## Messages", "\n### system", prompt.prompt];
+  }
+  return [];
+}
+
+// Deployments: every non-"latest" tag on the prompt, each shown with the
+// version it currently points to. Always rendered, even when empty, so an
+// empty section is never mistaken for "not checked" — and a tag pointing
+// at another version is listed truthfully instead of implied undeployed.
+function deploymentLines(prompt: PromptDetailResponse): string[] {
+  const lines = ["\n## Deployments"];
+  const tags = Array.isArray(prompt.tags) ? prompt.tags : [];
+  for (const rawTag of tags) {
+    const tag = normalizeTag(rawTag);
+    if (!tag || tag.name === "latest") continue;
+    const target = tag.versionId ?? "unknown version";
+    const marker = tag.versionId && tag.versionId === prompt.versionId ? " (this version)" : "";
+    lines.push(`- ${tag.name} → ${target}${marker}`);
+  }
+  return lines;
+}
+
+// Retrieves a prompt by ID/handle; returns a markdown digest by default or
+// raw JSON if format: "json" is specified.
 export async function handleGetPrompt(params: {
   idOrHandle: string;
   version?: number;
   tag?: string;
+  format?: "digest" | "json";
 }): Promise<string> {
-  const prompt = await apiGetPrompt(params.idOrHandle, { version: params.version, tag: params.tag });
+  const prompt = await apiGetPrompt(params.idOrHandle, {
+    version: params.version,
+    tag: params.tag,
+  });
+
+  if (params.format === "json") {
+    return JSON.stringify(prompt, null, 2);
+  }
 
   const lines: string[] = [];
-  lines.push(
-    `# Prompt: ${prompt.name || prompt.handle || prompt.id}\n`
-  );
+  lines.push(`# Prompt: ${prompt.name || prompt.handle || prompt.id}\n`);
 
   if (prompt.handle) lines.push(`**Handle**: ${prompt.handle}`);
   if (prompt.id) lines.push(`**ID**: ${prompt.id}`);
-  if (prompt.latestVersionNumber != null)
-    lines.push(`**Latest Version**: v${prompt.latestVersionNumber}`);
-
-  // Show model config
-  const version = prompt.versions?.[0] ?? prompt;
-  if (version.model) lines.push(`**Model**: ${version.model}`);
+  if (prompt.version != null) lines.push(`**Version**: v${prompt.version}`);
+  if (prompt.versionId) lines.push(`**Version ID**: ${prompt.versionId}`);
+  if (prompt.commitMessage) lines.push(`**Commit**: ${prompt.commitMessage}`);
+  if (prompt.model) lines.push(`**Model**: ${prompt.model}`);
+  if (prompt.temperature != null) lines.push(`**Temperature**: ${prompt.temperature}`);
+  if (prompt.maxTokens != null) lines.push(`**Max Tokens**: ${prompt.maxTokens}`);
+  if (prompt.responseFormat)
+    lines.push(`**Response Format**: ${JSON.stringify(prompt.responseFormat)}`);
 
-  // Show messages
-  const messages = version.messages || prompt.prompt || [];
-  if (Array.isArray(messages) && messages.length > 0) {
-    lines.push("\n## Messages");
-    for (const msg of messages) {
-      lines.push(`\n### ${msg.role}`);
-      lines.push(msg.content);
-    }
-  }
-
-  // Show version history
-  if (prompt.versions && prompt.versions.length > 0) {
-    lines.push("\n## Version History");
-    for (const v of prompt.versions.slice(0, 10)) {
-      const versionNum = v.version ?? "?";
-      const commitMsg = v.commitMessage || "No message";
-      lines.push(`- **v${versionNum}**: ${commitMsg}`);
-    }
-    if (prompt.versions.length > 10) {
-      lines.push(`... and ${prompt.versions.length - 10} more versions`);
-    }
-  }
+  lines.push(...fieldListLines({ heading: "Parameters", fields: prompt.parameters }));
+  lines.push(...fieldListLines({ heading: "Inputs", fields: prompt.inputs }));
+  lines.push(...fieldListLines({ heading: "Outputs", fields: prompt.outputs }));
+  lines.push(...messageLines(prompt));
+  lines.push(...deploymentLines(prompt));
 
   return lines.join("\n");
 }