@lightsage/mcp 0.4.5 → 0.4.6

package/bin/mcp-server.js

@@ -52844,9 +52844,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.4.5",
+    sdkVersion: "0.4.6",
     genVersion: "2.943.0",
-    userAgent: "speakeasy-sdk/mcp-typescript 0.4.5 2.943.0 1.0.0 @lightsage/mcp"
+    userAgent: "speakeasy-sdk/mcp-typescript 0.4.6 2.943.0 1.0.0 @lightsage/mcp"
   };
 });
 
@@ -54265,11 +54265,1233 @@ var init_async = __esm(() => {
   };
 });
 
+// src/funcs/agentPreferenceV2AgentPreferenceCompetitorsList.ts
+function agentPreferenceV2AgentPreferenceCompetitorsList(client$, options) {
+  return new APIPromise($do(client$, options));
+}
+async function $do(client$, options) {
+  const path$ = pathToFunc("/v2/agent-preference/competitors")();
+  const headers$ = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_competitors_list",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceCompetitorsList = __esm(() => {
+  init_primitives();
+  init_security();
+  init_url();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceCompetitorsList.ts
+var tool$agentPreferenceV2AgentPreferenceCompetitorsList;
+var init_agentPreferenceV2AgentPreferenceCompetitorsList2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceCompetitorsList();
+  init_tools();
+  tool$agentPreferenceV2AgentPreferenceCompetitorsList = {
+    name: "agent-preference-v2-agent-preference-competitors-9f0",
+    description: `List Competitors
+
+Returns the tracked competitors your company can be compared against. Use a returned \`id\` as \`competitor_id\` when creating an Agent Preference eval.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    tool: async (client, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceCompetitorsList(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/errors/sdkvalidationerror.ts
+function formatZodError(err) {
+  return prettifyError(err);
+}
+var SDKValidationError;
+var init_sdkvalidationerror = __esm(() => {
+  init_zod();
+  SDKValidationError = class SDKValidationError extends Error {
+    rawValue;
+    rawMessage;
+    constructor(message, cause, rawValue) {
+      super(`${message}: ${cause}`);
+      this.name = "SDKValidationError";
+      this.cause = cause;
+      this.rawValue = rawValue;
+      this.rawMessage = message;
+    }
+    pretty() {
+      if (this.cause instanceof ZodError) {
+        return `${this.rawMessage}
+${formatZodError(this.cause)}`;
+      } else {
+        return this.toString();
+      }
+    }
+  };
+});
+
+// src/types/fp.ts
+function OK3(value) {
+  return { ok: true, value };
+}
+function ERR2(error) {
+  return { ok: false, error };
+}
+
+// src/lib/schemas.ts
+function collectExtraKeys(obj, extrasKey, optional) {
+  return obj.transform((val) => {
+    const extras = {};
+    const { shape } = obj;
+    for (const [key] of Object.entries(val)) {
+      if (key in shape) {
+        continue;
+      }
+      const v = val[key];
+      if (typeof v === "undefined") {
+        continue;
+      }
+      extras[key] = v;
+      delete val[key];
+    }
+    if (optional && Object.keys(extras).length === 0) {
+      return val;
+    }
+    return { ...val, [extrasKey]: extras };
+  });
+}
+function safeParse4(rawValue, fn, errorMessage) {
+  try {
+    return OK3(fn(rawValue));
+  } catch (err) {
+    return ERR2(new SDKValidationError(errorMessage, err, rawValue));
+  }
+}
+var init_schemas4 = __esm(() => {
+  init_sdkvalidationerror();
+});
+
+// src/models/searchgroundingmode.ts
+var SearchGroundingMode$zodSchema;
+var init_searchgroundingmode = __esm(() => {
+  init_zod();
+  SearchGroundingMode$zodSchema = _enum([
+    "disabled",
+    "enabled",
+    "default"
+  ]).describe("Requested web-retrieval behavior for an eval run.");
+});
+
+// src/models/createv2agentpreferenceevalrequest.ts
+var CreateV2AgentPreferenceEvalRequest$zodSchema;
+var init_createv2agentpreferenceevalrequest = __esm(() => {
+  init_zod();
+  init_searchgroundingmode();
+  CreateV2AgentPreferenceEvalRequest$zodSchema = object({
+    agent: array(string2()).optional().describe("Runnable agents from `GET /v2/agents`. An empty array saves the comparison without default agents. CLI clients expose repeatable `--agent`."),
+    competitor_id: string2().describe("Tracked competitor to compare against, from `GET /v2/agent-preference/competitors`."),
+    name: string2().optional().describe("Display name. Defaults to `<your company> vs <competitor>` when omitted."),
+    persona: string2().optional().describe("Optional perspective applied to the whole comparison."),
+    prompts: array(string2()).describe("Buying or build questions the agent answers by choosing between your company and the competitor. CLI clients expose this as repeatable `--prompt`."),
+    runs: int().default(1).describe("Independent attempts for every prompt-agent pair."),
+    search_grounding: SearchGroundingMode$zodSchema.optional().describe("Requested web-retrieval behavior for an eval run."),
+    tags: array(string2()).optional()
+  });
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceEvalsCreate.ts
+function agentPreferenceV2AgentPreferenceEvalsCreate(client$, request, options) {
+  return new APIPromise($do2(client$, request, options));
+}
+async function $do2(client$, request, options) {
+  const parsed$ = safeParse4(request, (value$) => CreateV2AgentPreferenceEvalRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$, { explode: true });
+  const path$ = pathToFunc("/v2/agent-preference/evals")();
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_evals_create",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceEvalsCreate = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_createv2agentpreferenceevalrequest();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceEvalsCreate.ts
+var args, tool$agentPreferenceV2AgentPreferenceEvalsCreate;
+var init_agentPreferenceV2AgentPreferenceEvalsCreate2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceEvalsCreate();
+  init_createv2agentpreferenceevalrequest();
+  init_tools();
+  args = {
+    request: CreateV2AgentPreferenceEvalRequest$zodSchema
+  };
+  tool$agentPreferenceV2AgentPreferenceEvalsCreate = {
+    name: "agent-preference-v2-agent-preference-evals-create",
+    description: `Create Eval
+
+Creates a head-to-head comparison between your company and one tracked competitor. Each prompt asks an agent to choose, and a fixed judge records which company it recommended. Creating the eval does not start a run; pass the returned \`id\` as \`eval_id\` to \`POST /v2/eval-runs\`.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args,
+    tool: async (client, args, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceEvalsCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/validationerror.ts
+var Loc$zodSchema, Context$zodSchema, ValidationError$zodSchema;
+var init_validationerror = __esm(() => {
+  init_zod();
+  Loc$zodSchema = union([
+    string2(),
+    int()
+  ]);
+  Context$zodSchema = object({});
+  ValidationError$zodSchema = object({
+    ctx: lazy(() => Context$zodSchema).optional(),
+    input: any().optional(),
+    loc: array(union([
+      string2(),
+      int()
+    ])),
+    msg: string2(),
+    type: string2()
+  });
+});
+
+// src/models/httpvalidationerror.ts
+var HTTPValidationError$zodSchema;
+var init_httpvalidationerror = __esm(() => {
+  init_zod();
+  init_validationerror();
+  HTTPValidationError$zodSchema = object({
+    detail: array(ValidationError$zodSchema).optional()
+  });
+});
+
+// src/models/v2agentpreferencecompetitor.ts
+var V2AgentPreferenceCompetitor$zodSchema;
+var init_v2agentpreferencecompetitor = __esm(() => {
+  init_zod();
+  V2AgentPreferenceCompetitor$zodSchema = object({
+    domain: string2().nullable().optional(),
+    id: string2().describe("Competitor ID to pass as `competitor_id`."),
+    logo_url: string2().nullable().optional(),
+    name: string2()
+  });
+});
+
+// src/models/v2agentpreferenceeval.ts
+var V2AgentPreferenceEval$zodSchema;
+var init_v2agentpreferenceeval = __esm(() => {
+  init_zod();
+  init_searchgroundingmode();
+  init_v2agentpreferencecompetitor();
+  V2AgentPreferenceEval$zodSchema = object({
+    agent: array(string2()).optional(),
+    competitor: V2AgentPreferenceCompetitor$zodSchema.nullable().optional().describe("The competitor your company is compared against. Null when the competitor is no longer tracked."),
+    created_at: string2().nullable().optional(),
+    id: string2().describe("Eval ID. Pass it as `eval_id` to `POST /v2/eval-runs` to run the comparison."),
+    judges: array(string2()).optional().describe("Criteria applied to each response. The first one decides which company the agent recommended and cannot be changed."),
+    name: string2(),
+    persona: string2().nullable().optional(),
+    prompts: array(string2()).optional(),
+    runs: int().default(1),
+    search_grounding: SearchGroundingMode$zodSchema.optional().describe("Requested web-retrieval behavior for an eval run."),
+    tags: array(string2()).optional(),
+    updated_at: string2().nullable().optional()
+  });
+});
+
+// src/models/v2agentpreferenceevalsdeleteop.ts
+var V2AgentPreferenceEvalsDeleteRequest$zodSchema, V2AgentPreferenceEvalsDeleteResponse$zodSchema;
+var init_v2agentpreferenceevalsdeleteop = __esm(() => {
+  init_zod();
+  init_httpvalidationerror();
+  init_v2agentpreferenceeval();
+  V2AgentPreferenceEvalsDeleteRequest$zodSchema = object({
+    eval_id: string2()
+  });
+  V2AgentPreferenceEvalsDeleteResponse$zodSchema = union([
+    V2AgentPreferenceEval$zodSchema,
+    HTTPValidationError$zodSchema
+  ]);
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceEvalsDelete.ts
+function agentPreferenceV2AgentPreferenceEvalsDelete(client$, request, options) {
+  return new APIPromise($do3(client$, request, options));
+}
+async function $do3(client$, request, options) {
+  const parsed$ = safeParse4(request, (value$) => V2AgentPreferenceEvalsDeleteRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    eval_id: encodeSimple("eval_id", payload$.eval_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v2/agent-preference/evals/{eval_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_evals_delete",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceEvalsDelete = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_v2agentpreferenceevalsdeleteop();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceEvalsDelete.ts
+var args2, tool$agentPreferenceV2AgentPreferenceEvalsDelete;
+var init_agentPreferenceV2AgentPreferenceEvalsDelete2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceEvalsDelete();
+  init_v2agentpreferenceevalsdeleteop();
+  init_tools();
+  args2 = {
+    request: V2AgentPreferenceEvalsDeleteRequest$zodSchema
+  };
+  tool$agentPreferenceV2AgentPreferenceEvalsDelete = {
+    name: "agent-preference-v2-agent-preference-evals-delete",
+    description: `Delete Eval
+
+Permanently deletes an Agent Preference eval and returns its last saved state.`,
+    annotations: {
+      title: "",
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args2,
+    tool: async (client, args, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceEvalsDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceEvalsList.ts
+function agentPreferenceV2AgentPreferenceEvalsList(client$, options) {
+  return new APIPromise($do4(client$, options));
+}
+async function $do4(client$, options) {
+  const path$ = pathToFunc("/v2/agent-preference/evals")();
+  const headers$ = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_evals_list",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceEvalsList = __esm(() => {
+  init_primitives();
+  init_security();
+  init_url();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceEvalsList.ts
+var tool$agentPreferenceV2AgentPreferenceEvalsList;
+var init_agentPreferenceV2AgentPreferenceEvalsList2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceEvalsList();
+  init_tools();
+  tool$agentPreferenceV2AgentPreferenceEvalsList = {
+    name: "agent-preference-v2-agent-preference-evals-list",
+    description: `List Evals
+
+Returns all active Agent Preference evals owned by the organization.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    tool: async (client, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceEvalsList(client, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/v2agentpreferenceevalsretrieveop.ts
+var V2AgentPreferenceEvalsRetrieveRequest$zodSchema, V2AgentPreferenceEvalsRetrieveResponse$zodSchema;
+var init_v2agentpreferenceevalsretrieveop = __esm(() => {
+  init_zod();
+  init_httpvalidationerror();
+  init_v2agentpreferenceeval();
+  V2AgentPreferenceEvalsRetrieveRequest$zodSchema = object({
+    eval_id: string2()
+  });
+  V2AgentPreferenceEvalsRetrieveResponse$zodSchema = union([
+    V2AgentPreferenceEval$zodSchema,
+    HTTPValidationError$zodSchema
+  ]);
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceEvalsRetrieve.ts
+function agentPreferenceV2AgentPreferenceEvalsRetrieve(client$, request, options) {
+  return new APIPromise($do5(client$, request, options));
+}
+async function $do5(client$, request, options) {
+  const parsed$ = safeParse4(request, (value$) => V2AgentPreferenceEvalsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    eval_id: encodeSimple("eval_id", payload$.eval_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v2/agent-preference/evals/{eval_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_evals_retrieve",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceEvalsRetrieve = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_v2agentpreferenceevalsretrieveop();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceEvalsRetrieve.ts
+var args3, tool$agentPreferenceV2AgentPreferenceEvalsRetrieve;
+var init_agentPreferenceV2AgentPreferenceEvalsRetrieve2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceEvalsRetrieve();
+  init_v2agentpreferenceevalsretrieveop();
+  init_tools();
+  args3 = {
+    request: V2AgentPreferenceEvalsRetrieveRequest$zodSchema
+  };
+  tool$agentPreferenceV2AgentPreferenceEvalsRetrieve = {
+    name: "agent-preference-v2-agent-preference-evals-retrieve",
+    description: `Retrieve Eval
+
+Returns one Agent Preference eval.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args3,
+    tool: async (client, args, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceEvalsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/updatev2agentpreferenceevalrequest.ts
+var UpdateV2AgentPreferenceEvalRequest$zodSchema;
+var init_updatev2agentpreferenceevalrequest = __esm(() => {
+  init_zod();
+  init_searchgroundingmode();
+  UpdateV2AgentPreferenceEvalRequest$zodSchema = object({
+    agent: array(string2()).nullable().optional().describe("Runnable agents from `GET /v2/agents`. An empty array saves the comparison without default agents. CLI clients expose repeatable `--agent`."),
+    name: string2().optional(),
+    persona: string2().optional().describe("Set to null to clear the saved persona."),
+    prompts: array(string2()).nullable().optional().describe("Buying or build questions the agent answers by choosing between your company and the competitor. CLI clients expose this as repeatable `--prompt`."),
+    runs: int().optional(),
+    search_grounding: SearchGroundingMode$zodSchema.nullable().optional(),
+    tags: array(string2()).nullable().optional()
+  });
+});
+
+// src/models/v2agentpreferenceevalsupdateop.ts
+var V2AgentPreferenceEvalsUpdateRequest$zodSchema, V2AgentPreferenceEvalsUpdateResponse$zodSchema;
+var init_v2agentpreferenceevalsupdateop = __esm(() => {
+  init_zod();
+  init_httpvalidationerror();
+  init_updatev2agentpreferenceevalrequest();
+  init_v2agentpreferenceeval();
+  V2AgentPreferenceEvalsUpdateRequest$zodSchema = object({
+    body: UpdateV2AgentPreferenceEvalRequest$zodSchema,
+    eval_id: string2()
+  });
+  V2AgentPreferenceEvalsUpdateResponse$zodSchema = union([
+    V2AgentPreferenceEval$zodSchema,
+    HTTPValidationError$zodSchema
+  ]);
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceEvalsUpdate.ts
+function agentPreferenceV2AgentPreferenceEvalsUpdate(client$, request, options) {
+  return new APIPromise($do6(client$, request, options));
+}
+async function $do6(client$, request, options) {
+  const parsed$ = safeParse4(request, (value$) => V2AgentPreferenceEvalsUpdateRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = encodeJSON("body", payload$.body, { explode: true });
+  const pathParams$ = {
+    eval_id: encodeSimple("eval_id", payload$.eval_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v2/agent-preference/evals/{eval_id}")(pathParams$);
+  const headers$ = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_evals_update",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceEvalsUpdate = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_v2agentpreferenceevalsupdateop();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceEvalsUpdate.ts
+var args4, tool$agentPreferenceV2AgentPreferenceEvalsUpdate;
+var init_agentPreferenceV2AgentPreferenceEvalsUpdate2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceEvalsUpdate();
+  init_v2agentpreferenceevalsupdateop();
+  init_tools();
+  args4 = {
+    request: V2AgentPreferenceEvalsUpdateRequest$zodSchema
+  };
+  tool$agentPreferenceV2AgentPreferenceEvalsUpdate = {
+    name: "agent-preference-v2-agent-preference-evals-update",
+    description: `Update Eval
+
+Updates an Agent Preference eval. Omitted fields remain unchanged, an empty \`agent\` or \`tags\` array clears that collection, and \`persona: null\` clears the saved persona. The competitor and the judge that decides the comparison cannot be changed.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    args: args4,
+    tool: async (client, args, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceEvalsUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/v2agentpreferencecompany.ts
+var V2AgentPreferenceCompany$zodSchema;
+var init_v2agentpreferencecompany = __esm(() => {
+  init_zod();
+  V2AgentPreferenceCompany$zodSchema = object({
+    domain: string2().nullable().optional(),
+    name: string2().nullable().optional()
+  });
+});
+
+// src/models/v2agentpreferencematchup.ts
+var V2AgentPreferenceMatchup$zodSchema;
+var init_v2agentpreferencematchup = __esm(() => {
+  init_zod();
+  V2AgentPreferenceMatchup$zodSchema = object({
+    comparisons: int().describe("`wins + losses + ties`."),
+    competitor_domain: string2().nullable().optional(),
+    competitor_id: string2().nullable().optional().describe("Null when the competitor is no longer tracked."),
+    competitor_name: string2(),
+    eval_ids: array(string2()).optional().describe("Agent Preference evals that contributed to this record."),
+    losses: int().describe("Attempts where the agent recommended the competitor."),
+    ties: int().describe("Attempts where the agent recommended both equally or neither."),
+    win_rate: number2().nullable().optional().describe("`wins / comparisons` from 0 to 1. Null when there are no comparisons."),
+    wins: int().describe("Attempts where the agent recommended your company.")
+  });
+});
+
+// src/models/v2agentpreferencerecord.ts
+var V2AgentPreferenceRecord$zodSchema;
+var init_v2agentpreferencerecord = __esm(() => {
+  init_zod();
+  V2AgentPreferenceRecord$zodSchema = object({
+    comparisons: int().describe("`wins + losses + ties`."),
+    losses: int().describe("Attempts where the agent recommended the competitor."),
+    ties: int().describe("Attempts where the agent recommended both equally or neither."),
+    win_rate: number2().nullable().optional().describe("`wins / comparisons` from 0 to 1. Null when there are no comparisons."),
+    wins: int().describe("Attempts where the agent recommended your company.")
+  });
+});
+
+// src/models/v2agentpreferenceheadtoheadresponse.ts
+var V2AgentPreferenceHeadToHeadResponse$zodSchema;
+var init_v2agentpreferenceheadtoheadresponse = __esm(() => {
+  init_zod();
+  init_v2agentpreferencecompany();
+  init_v2agentpreferencematchup();
+  init_v2agentpreferencerecord();
+  V2AgentPreferenceHeadToHeadResponse$zodSchema = object({
+    attempts_considered: int().describe("Recent attempts read to build the records. Attempts without a usable recommendation are read but not counted as comparisons."),
+    company: V2AgentPreferenceCompany$zodSchema,
+    count: int().describe("The number of items in `data`."),
+    data: array(V2AgentPreferenceMatchup$zodSchema).optional().describe("One record per competitor, most comparisons first."),
+    limit: int(),
+    summary: V2AgentPreferenceRecord$zodSchema,
+    truncated: boolean2().describe("True when older attempts exist beyond `limit` and were not counted.")
+  });
+});
+
+// src/models/v2agentpreferenceheadtoheadretrieveop.ts
+var V2AgentPreferenceHeadToHeadRetrieveRequest$zodSchema, V2AgentPreferenceHeadToHeadRetrieveResponse$zodSchema;
+var init_v2agentpreferenceheadtoheadretrieveop = __esm(() => {
+  init_zod();
+  init_httpvalidationerror();
+  init_v2agentpreferenceheadtoheadresponse();
+  V2AgentPreferenceHeadToHeadRetrieveRequest$zodSchema = object({
+    limit: int().default(500).describe("Most recent attempts to include in the records.")
+  });
+  V2AgentPreferenceHeadToHeadRetrieveResponse$zodSchema = union([
+    V2AgentPreferenceHeadToHeadResponse$zodSchema,
+    HTTPValidationError$zodSchema
+  ]);
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceHeadToHeadRetrieve.ts
+function agentPreferenceV2AgentPreferenceHeadToHeadRetrieve(client$, request, options) {
+  return new APIPromise($do7(client$, request, options));
+}
+async function $do7(client$, request, options) {
+  const parsed$ = safeParse4(request, (value$) => V2AgentPreferenceHeadToHeadRetrieveRequest$zodSchema.optional().parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const path$ = pathToFunc("/v2/agent-preference/head-to-head")();
+  const query$ = encodeFormQuery({
+    limit: payload$?.limit
+  });
+  const headers$ = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_head_to_head_retrieve",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    query: query$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceHeadToHeadRetrieve = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_v2agentpreferenceheadtoheadretrieveop();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceHeadToHeadRetrieve.ts
+var args5, tool$agentPreferenceV2AgentPreferenceHeadToHeadRetrieve;
+var init_agentPreferenceV2AgentPreferenceHeadToHeadRetrieve2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceHeadToHeadRetrieve();
+  init_v2agentpreferenceheadtoheadretrieveop();
+  init_tools();
+  args5 = {
+    request: V2AgentPreferenceHeadToHeadRetrieveRequest$zodSchema.optional()
+  };
+  tool$agentPreferenceV2AgentPreferenceHeadToHeadRetrieve = {
+    name: "agent-preference-v2-agent-preference-head-to-273",
+    description: `Retrieve Head To Head
+
+Returns how often agents recommended your company over each tracked competitor: wins, losses, ties, and win rate per competitor plus a combined record. Calculated from the most recent attempts across all Agent Preference evals, up to \`limit\`; \`truncated\` reports whether older attempts were left out.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args5,
+    tool: async (client, args, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceHeadToHeadRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
+// src/models/v2preferenceresult.ts
+var Outcome$zodSchema, V2PreferenceResult$zodSchema;
+var init_v2preferenceresult = __esm(() => {
+  init_zod();
+  Outcome$zodSchema = _enum([
+    "won",
+    "lost",
+    "tie"
+  ]).describe("`won` when the agent recommended your company, `lost` when it recommended the competitor, and `tie` when it recommended both equally or neither.");
+  V2PreferenceResult$zodSchema = object({
+    competitor_domain: string2().nullable().optional(),
+    competitor_name: string2().nullable().optional(),
+    outcome: Outcome$zodSchema.describe("`won` when the agent recommended your company, `lost` when it recommended the competitor, and `tie` when it recommended both equally or neither."),
+    winner_name: string2().nullable().optional().describe("The recommended company. Null on a tie.")
+  }).describe("Which company an agent recommended, from your company's side.");
+});
+
+// src/models/v2agentpreferenceresult.ts
+var V2AgentPreferenceResult$zodSchema;
+var init_v2agentpreferenceresult = __esm(() => {
+  init_zod();
+  init_v2preferenceresult();
+  V2AgentPreferenceResult$zodSchema = object({
+    agent: string2().nullable().optional().describe("Runnable agent combining the harness and model."),
+    created_at: string2().nullable().optional(),
+    eval_id: string2(),
+    id: string2().describe("Result ID for one attempt."),
+    latency_ms: int().nullable().optional(),
+    preference_result: V2PreferenceResult$zodSchema.nullable().optional().describe("Null when the attempt did not produce a usable recommendation, such as an attempt that ended in an error.")
+  });
+});
+
+// src/models/v2agentpreferenceresultsresponse.ts
+var V2AgentPreferenceResultsResponse$zodSchema;
+var init_v2agentpreferenceresultsresponse = __esm(() => {
+  init_zod();
+  init_v2agentpreferenceresult();
+  V2AgentPreferenceResultsResponse$zodSchema = object({
+    count: int().describe("The number of items in `data`."),
+    data: array(V2AgentPreferenceResult$zodSchema).optional(),
+    limit: int(),
+    offset: int(),
+    total: int().describe("All recorded attempts for this eval.")
+  });
+});
+
+// src/models/v2agentpreferenceresultslistop.ts
+var V2AgentPreferenceResultsListRequest$zodSchema, V2AgentPreferenceResultsListResponse$zodSchema;
+var init_v2agentpreferenceresultslistop = __esm(() => {
+  init_zod();
+  init_httpvalidationerror();
+  init_v2agentpreferenceresultsresponse();
+  V2AgentPreferenceResultsListRequest$zodSchema = object({
+    eval_id: string2(),
+    limit: int().default(50),
+    offset: int().default(0)
+  });
+  V2AgentPreferenceResultsListResponse$zodSchema = union([
+    V2AgentPreferenceResultsResponse$zodSchema,
+    HTTPValidationError$zodSchema
+  ]);
+});
+
+// src/funcs/agentPreferenceV2AgentPreferenceResultsList.ts
+function agentPreferenceV2AgentPreferenceResultsList(client$, request, options) {
+  return new APIPromise($do8(client$, request, options));
+}
+async function $do8(client$, request, options) {
+  const parsed$ = safeParse4(request, (value$) => V2AgentPreferenceResultsListRequest$zodSchema.parse(value$), "Input validation failed");
+  if (!parsed$.ok) {
+    return [parsed$, { status: "invalid" }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+  const pathParams$ = {
+    eval_id: encodeSimple("eval_id", payload$.eval_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path$ = pathToFunc("/v2/agent-preference/evals/{eval_id}/results")(pathParams$);
+  const query$ = encodeFormQuery({
+    limit: payload$.limit,
+    offset: payload$.offset
+  });
+  const headers$ = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client$._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? "",
+    operationID: "v2_agent_preference_results_list",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client$._options.security,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || [
+      "429",
+      "500",
+      "502",
+      "503",
+      "504"
+    ]
+  };
+  const requestRes = client$._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path$,
+    headers: headers$,
+    query: query$,
+    body: body$,
+    userAgent: client$._options.userAgent,
+    timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req$ = requestRes.value;
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req$ }];
+  }
+  return [doResult, {
+    status: "complete",
+    request: req$,
+    response: doResult.value
+  }];
+}
+var init_agentPreferenceV2AgentPreferenceResultsList = __esm(() => {
+  init_encodings();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_v2agentpreferenceresultslistop();
+  init_async();
+});
+
+// src/mcp-server/tools/agentPreferenceV2AgentPreferenceResultsList.ts
+var args6, tool$agentPreferenceV2AgentPreferenceResultsList;
+var init_agentPreferenceV2AgentPreferenceResultsList2 = __esm(() => {
+  init_agentPreferenceV2AgentPreferenceResultsList();
+  init_v2agentpreferenceresultslistop();
+  init_tools();
+  args6 = {
+    request: V2AgentPreferenceResultsListRequest$zodSchema
+  };
+  tool$agentPreferenceV2AgentPreferenceResultsList = {
+    name: "agent-preference-v2-agent-preference-results-list",
+    description: `List Results
+
+Returns recorded attempts for an Agent Preference eval, newest first, each with whether your company won, lost, or tied against the competitor.`,
+    annotations: {
+      title: "",
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    args: args6,
+    tool: async (client, args, ctx) => {
+      const [result] = await agentPreferenceV2AgentPreferenceResultsList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(result.value);
+    }
+  };
+});
+
 // src/funcs/agentsV2AgentsList.ts
 function agentsV2AgentsList(client$, options) {
-  return new APIPromise($do(client$, options));
+  return new APIPromise($do9(client$, options));
 }
-async function $do(client$, options) {
+async function $do9(client$, options) {
   const path$ = pathToFunc("/v2/agents")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -54359,9 +55581,9 @@ Returns all runnable harness-and-model combinations as single agent IDs for use
 
 // src/funcs/clIsV2ClisList.ts
 function clIsV2ClisList(client$, options) {
-  return new APIPromise($do2(client$, options));
+  return new APIPromise($do10(client$, options));
 }
-async function $do2(client$, options) {
+async function $do10(client$, options) {
   const path$ = pathToFunc("/v2/clis")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -54451,9 +55673,9 @@ Returns reusable CLIs without exposing setup or installation commands.`,
 
 // src/funcs/environmentsV2EnvironmentsList.ts
 function environmentsV2EnvironmentsList(client$, options) {
-  return new APIPromise($do3(client$, options));
+  return new APIPromise($do11(client$, options));
 }
-async function $do3(client$, options) {
+async function $do11(client$, options) {
   const path$ = pathToFunc("/v2/environments")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -54541,106 +55763,6 @@ Returns reusable environments without exposing secret values.`,
   };
 });
 
-// src/models/errors/sdkvalidationerror.ts
-function formatZodError(err) {
-  return prettifyError(err);
-}
-var SDKValidationError;
-var init_sdkvalidationerror = __esm(() => {
-  init_zod();
-  SDKValidationError = class SDKValidationError extends Error {
-    rawValue;
-    rawMessage;
-    constructor(message, cause, rawValue) {
-      super(`${message}: ${cause}`);
-      this.name = "SDKValidationError";
-      this.cause = cause;
-      this.rawValue = rawValue;
-      this.rawMessage = message;
-    }
-    pretty() {
-      if (this.cause instanceof ZodError) {
-        return `${this.rawMessage}
-${formatZodError(this.cause)}`;
-      } else {
-        return this.toString();
-      }
-    }
-  };
-});
-
-// src/types/fp.ts
-function OK3(value) {
-  return { ok: true, value };
-}
-function ERR2(error) {
-  return { ok: false, error };
-}
-
-// src/lib/schemas.ts
-function collectExtraKeys(obj, extrasKey, optional) {
-  return obj.transform((val) => {
-    const extras = {};
-    const { shape } = obj;
-    for (const [key] of Object.entries(val)) {
-      if (key in shape) {
-        continue;
-      }
-      const v = val[key];
-      if (typeof v === "undefined") {
-        continue;
-      }
-      extras[key] = v;
-      delete val[key];
-    }
-    if (optional && Object.keys(extras).length === 0) {
-      return val;
-    }
-    return { ...val, [extrasKey]: extras };
-  });
-}
-function safeParse4(rawValue, fn, errorMessage) {
-  try {
-    return OK3(fn(rawValue));
-  } catch (err) {
-    return ERR2(new SDKValidationError(errorMessage, err, rawValue));
-  }
-}
-var init_schemas4 = __esm(() => {
-  init_sdkvalidationerror();
-});
-
-// src/models/validationerror.ts
-var Loc$zodSchema, Context$zodSchema, ValidationError$zodSchema;
-var init_validationerror = __esm(() => {
-  init_zod();
-  Loc$zodSchema = union([
-    string2(),
-    int()
-  ]);
-  Context$zodSchema = object({});
-  ValidationError$zodSchema = object({
-    ctx: lazy(() => Context$zodSchema).optional(),
-    input: any().optional(),
-    loc: array(union([
-      string2(),
-      int()
-    ])),
-    msg: string2(),
-    type: string2()
-  });
-});
-
-// src/models/httpvalidationerror.ts
-var HTTPValidationError$zodSchema;
-var init_httpvalidationerror = __esm(() => {
-  init_zod();
-  init_validationerror();
-  HTTPValidationError$zodSchema = object({
-    detail: array(ValidationError$zodSchema).optional()
-  });
-});
-
 // src/models/publicevalrunprogress.ts
 var PublicEvalRunProgress$zodSchema;
 var init_publicevalrunprogress = __esm(() => {
@@ -54717,9 +55839,9 @@ var init_v2evalrunslistop = __esm(() => {
 
 // src/funcs/evalRunsV2EvalRunsList.ts
 function evalRunsV2EvalRunsList(client$, request, options) {
-  return new APIPromise($do4(client$, request, options));
+  return new APIPromise($do12(client$, request, options));
 }
-async function $do4(client$, request, options) {
+async function $do12(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalRunsListRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -54793,12 +55915,12 @@ var init_evalRunsV2EvalRunsList = __esm(() => {
 });
 
 // src/mcp-server/tools/evalRunsV2EvalRunsList.ts
-var args, tool$evalRunsV2EvalRunsList;
+var args7, tool$evalRunsV2EvalRunsList;
 var init_evalRunsV2EvalRunsList2 = __esm(() => {
   init_evalRunsV2EvalRunsList();
   init_v2evalrunslistop();
   init_tools();
-  args = {
+  args7 = {
     request: V2EvalRunsListRequest$zodSchema.optional()
   };
   tool$evalRunsV2EvalRunsList = {
@@ -54813,7 +55935,7 @@ Returns jobs created through \`POST /v2/eval-runs\`, ordered newest first, with
       openWorldHint: false,
       readOnlyHint: true
     },
-    args,
+    args: args7,
     tool: async (client, args, ctx) => {
       const [result] = await evalRunsV2EvalRunsList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -54856,9 +55978,9 @@ var init_v2evalrunscancelop = __esm(() => {
 
 // src/funcs/evalsCancel.ts
 function evalsCancel(client$, request, options) {
-  return new APIPromise($do5(client$, request, options));
+  return new APIPromise($do13(client$, request, options));
 }
-async function $do5(client$, request, options) {
+async function $do13(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalRunsCancelRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -54933,12 +56055,12 @@ var init_evalsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsCancel.ts
-var args2, tool$evalsCancel;
+var args8, tool$evalsCancel;
 var init_evalsCancel2 = __esm(() => {
   init_evalsCancel();
   init_v2evalrunscancelop();
   init_tools();
-  args2 = {
+  args8 = {
     request: V2EvalRunsCancelRequest$zodSchema
   };
   tool$evalsCancel = {
@@ -54953,7 +56075,7 @@ Marks an active eval run as cancelled and prevents queued attempts from starting
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args2,
+    args: args8,
     tool: async (client, args, ctx) => {
       const [result] = await evalsCancel(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -55014,17 +56136,6 @@ var init_publicgraderresult = __esm(() => {
   });
 });
 
-// src/models/searchgroundingmode.ts
-var SearchGroundingMode$zodSchema;
-var init_searchgroundingmode = __esm(() => {
-  init_zod();
-  SearchGroundingMode$zodSchema = _enum([
-    "disabled",
-    "enabled",
-    "default"
-  ]).describe("Requested web-retrieval behavior for an eval run.");
-});
-
 // src/models/v2evalresultsummary.ts
 var V2EvalResultSummary$zodSchema;
 var init_v2evalresultsummary = __esm(() => {
@@ -55032,6 +56143,7 @@ var init_v2evalresultsummary = __esm(() => {
   init_publicevalrunenvironment();
   init_publicgraderresult();
   init_searchgroundingmode();
+  init_v2preferenceresult();
   V2EvalResultSummary$zodSchema = object({
     agent: string2().nullable().optional().describe("Runnable agent combining the harness and model."),
     created_at: string2().nullable().optional(),
@@ -55044,6 +56156,7 @@ var init_v2evalresultsummary = __esm(() => {
     id: string2().describe("Result ID, not an eval job ID."),
     latency_ms: int().nullable().optional(),
     passed: boolean2().nullable().optional(),
+    preference_result: V2PreferenceResult$zodSchema.nullable().optional().describe("Which company the agent recommended. Present only for Agent Preference evals that produced a usable recommendation."),
     prompt: string2().nullable().optional(),
     prompt_index: int().default(0),
     repeat_index: int().default(0),
@@ -55129,9 +56242,9 @@ var init_v2evalrunsretrieveop = __esm(() => {
 
 // src/funcs/evalsGet.ts
 function evalsGet(client$, request, options) {
-  return new APIPromise($do6(client$, request, options));
+  return new APIPromise($do14(client$, request, options));
 }
-async function $do6(client$, request, options) {
+async function $do14(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalRunsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -55206,12 +56319,12 @@ var init_evalsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsGet.ts
-var args3, tool$evalsGet;
+var args9, tool$evalsGet;
 var init_evalsGet2 = __esm(() => {
   init_evalsGet();
   init_v2evalrunsretrieveop();
   init_tools();
-  args3 = {
+  args9 = {
     request: V2EvalRunsRetrieveRequest$zodSchema
   };
   tool$evalsGet = {
@@ -55226,7 +56339,7 @@ Returns the run's current status and progress. Once its attempts finish, the res
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args3,
+    args: args9,
     tool: async (client, args, ctx) => {
       const [result] = await evalsGet(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -55307,9 +56420,9 @@ var init_createv2evalrunrequest = __esm(() => {
 
 // src/funcs/evalsRun.ts
 function evalsRun(client$, request, options) {
-  return new APIPromise($do7(client$, request, options));
+  return new APIPromise($do15(client$, request, options));
 }
-async function $do7(client$, request, options) {
+async function $do15(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateV2EvalRunRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -55379,12 +56492,12 @@ var init_evalsRun = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRun.ts
-var args4, tool$evalsRun;
+var args10, tool$evalsRun;
 var init_evalsRun2 = __esm(() => {
   init_evalsRun();
   init_createv2evalrunrequest();
   init_tools();
-  args4 = {
+  args10 = {
     request: CreateV2EvalRunRequest$zodSchema
   };
   tool$evalsRun = {
@@ -55408,7 +56521,7 @@ A saved or inline environment containing an empty or placeholder credential is r
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args4,
+    args: args10,
     tool: async (client, args, ctx) => {
       const [result] = await evalsRun(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -55484,9 +56597,9 @@ var init_v2evalrunstraceop = __esm(() => {
 
 // src/funcs/evalsTrace.ts
 function evalsTrace(client$, request, options) {
-  return new APIPromise($do8(client$, request, options));
+  return new APIPromise($do16(client$, request, options));
 }
-async function $do8(client$, request, options) {
+async function $do16(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalRunsTraceRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -55566,12 +56679,12 @@ var init_evalsTrace = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsTrace.ts
-var args5, tool$evalsTrace;
+var args11, tool$evalsTrace;
 var init_evalsTrace2 = __esm(() => {
   init_evalsTrace();
   init_v2evalrunstraceop();
   init_tools();
-  args5 = {
+  args11 = {
     request: V2EvalRunsTraceRequest$zodSchema
   };
   tool$evalsTrace = {
@@ -55586,7 +56699,7 @@ Returns a finite page of sanitized execution events for one eval run. Use \`next
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args5,
+    args: args11,
     tool: async (client, args, ctx) => {
       const [result] = await evalsTrace(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -55659,9 +56772,9 @@ var init_v2evalconfigurationscreateop = __esm(() => {
 
 // src/funcs/evalsV2EvalConfigurationsCreate.ts
 function evalsV2EvalConfigurationsCreate(client$, request, options) {
-  return new APIPromise($do9(client$, request, options));
+  return new APIPromise($do17(client$, request, options));
 }
-async function $do9(client$, request, options) {
+async function $do17(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalConfigurationsCreateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -55737,12 +56850,12 @@ var init_evalsV2EvalConfigurationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalConfigurationsCreate.ts
-var args6, tool$evalsV2EvalConfigurationsCreate;
+var args12, tool$evalsV2EvalConfigurationsCreate;
 var init_evalsV2EvalConfigurationsCreate2 = __esm(() => {
   init_evalsV2EvalConfigurationsCreate();
   init_v2evalconfigurationscreateop();
   init_tools();
-  args6 = {
+  args12 = {
     request: V2EvalConfigurationsCreateRequest$zodSchema
   };
   tool$evalsV2EvalConfigurationsCreate = {
@@ -55757,7 +56870,7 @@ Creates a saved runtime configuration that pairs an eval with a repository, envi
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args6,
+    args: args12,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalConfigurationsCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -55789,9 +56902,9 @@ var init_v2evalconfigurationsdeleteop = __esm(() => {
 
 // src/funcs/evalsV2EvalConfigurationsDelete.ts
 function evalsV2EvalConfigurationsDelete(client$, request, options) {
-  return new APIPromise($do10(client$, request, options));
+  return new APIPromise($do18(client$, request, options));
 }
-async function $do10(client$, request, options) {
+async function $do18(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalConfigurationsDeleteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -55867,12 +56980,12 @@ var init_evalsV2EvalConfigurationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalConfigurationsDelete.ts
-var args7, tool$evalsV2EvalConfigurationsDelete;
+var args13, tool$evalsV2EvalConfigurationsDelete;
 var init_evalsV2EvalConfigurationsDelete2 = __esm(() => {
   init_evalsV2EvalConfigurationsDelete();
   init_v2evalconfigurationsdeleteop();
   init_tools();
-  args7 = {
+  args13 = {
     request: V2EvalConfigurationsDeleteRequest$zodSchema
   };
   tool$evalsV2EvalConfigurationsDelete = {
@@ -55887,7 +57000,7 @@ Permanently deletes an eval configuration and returns its last saved state.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args7,
+    args: args13,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalConfigurationsDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -55929,9 +57042,9 @@ var init_v2evalconfigurationslistop = __esm(() => {
 
 // src/funcs/evalsV2EvalConfigurationsList.ts
 function evalsV2EvalConfigurationsList(client$, request, options) {
-  return new APIPromise($do11(client$, request, options));
+  return new APIPromise($do19(client$, request, options));
 }
-async function $do11(client$, request, options) {
+async function $do19(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalConfigurationsListRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56006,12 +57119,12 @@ var init_evalsV2EvalConfigurationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalConfigurationsList.ts
-var args8, tool$evalsV2EvalConfigurationsList;
+var args14, tool$evalsV2EvalConfigurationsList;
 var init_evalsV2EvalConfigurationsList2 = __esm(() => {
   init_evalsV2EvalConfigurationsList();
   init_v2evalconfigurationslistop();
   init_tools();
-  args8 = {
+  args14 = {
     request: V2EvalConfigurationsListRequest$zodSchema
   };
   tool$evalsV2EvalConfigurationsList = {
@@ -56026,7 +57139,7 @@ Returns the saved runtime configurations for an eval, including repository, envi
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args8,
+    args: args14,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalConfigurationsList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -56058,9 +57171,9 @@ var init_v2evalconfigurationsretrieveop = __esm(() => {
 
 // src/funcs/evalsV2EvalConfigurationsRetrieve.ts
 function evalsV2EvalConfigurationsRetrieve(client$, request, options) {
-  return new APIPromise($do12(client$, request, options));
+  return new APIPromise($do20(client$, request, options));
 }
-async function $do12(client$, request, options) {
+async function $do20(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalConfigurationsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56136,12 +57249,12 @@ var init_evalsV2EvalConfigurationsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalConfigurationsRetrieve.ts
-var args9, tool$evalsV2EvalConfigurationsRetrieve;
+var args15, tool$evalsV2EvalConfigurationsRetrieve;
 var init_evalsV2EvalConfigurationsRetrieve2 = __esm(() => {
   init_evalsV2EvalConfigurationsRetrieve();
   init_v2evalconfigurationsretrieveop();
   init_tools();
-  args9 = {
+  args15 = {
     request: V2EvalConfigurationsRetrieveRequest$zodSchema
   };
   tool$evalsV2EvalConfigurationsRetrieve = {
@@ -56156,7 +57269,7 @@ Returns one saved configuration for an eval.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args9,
+    args: args15,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalConfigurationsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -56208,9 +57321,9 @@ var init_v2evalconfigurationsupdateop = __esm(() => {
 
 // src/funcs/evalsV2EvalConfigurationsUpdate.ts
 function evalsV2EvalConfigurationsUpdate(client$, request, options) {
-  return new APIPromise($do13(client$, request, options));
+  return new APIPromise($do21(client$, request, options));
 }
-async function $do13(client$, request, options) {
+async function $do21(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalConfigurationsUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56287,12 +57400,12 @@ var init_evalsV2EvalConfigurationsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalConfigurationsUpdate.ts
-var args10, tool$evalsV2EvalConfigurationsUpdate;
+var args16, tool$evalsV2EvalConfigurationsUpdate;
 var init_evalsV2EvalConfigurationsUpdate2 = __esm(() => {
   init_evalsV2EvalConfigurationsUpdate();
   init_v2evalconfigurationsupdateop();
   init_tools();
-  args10 = {
+  args16 = {
     request: V2EvalConfigurationsUpdateRequest$zodSchema
   };
   tool$evalsV2EvalConfigurationsUpdate = {
@@ -56307,7 +57420,7 @@ Updates an eval configuration; omitted fields remain unchanged.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args10,
+    args: args16,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalConfigurationsUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -56353,9 +57466,9 @@ var init_createevaltemplatebatchrequest = __esm(() => {
 
 // src/funcs/evalsV2EvalsBatchCreate.ts
 function evalsV2EvalsBatchCreate(client$, request, options) {
-  return new APIPromise($do14(client$, request, options));
+  return new APIPromise($do22(client$, request, options));
 }
-async function $do14(client$, request, options) {
+async function $do22(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateEvalTemplateBatchRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56425,12 +57538,12 @@ var init_evalsV2EvalsBatchCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalsBatchCreate.ts
-var args11, tool$evalsV2EvalsBatchCreate;
+var args17, tool$evalsV2EvalsBatchCreate;
 var init_evalsV2EvalsBatchCreate2 = __esm(() => {
   init_evalsV2EvalsBatchCreate();
   init_createevaltemplatebatchrequest();
   init_tools();
-  args11 = {
+  args17 = {
     request: CreateEvalTemplateBatchRequest$zodSchema
   };
   tool$evalsV2EvalsBatchCreate = {
@@ -56445,7 +57558,7 @@ Step 2 of the reusable template workflow. Provide the \`id\` and \`version\` ret
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args11,
+    args: args17,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalsBatchCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -56491,9 +57604,9 @@ var init_createv2evalrequest = __esm(() => {
 
 // src/funcs/evalsV2EvalsCreate.ts
 function evalsV2EvalsCreate(client$, request, options) {
-  return new APIPromise($do15(client$, request, options));
+  return new APIPromise($do23(client$, request, options));
 }
-async function $do15(client$, request, options) {
+async function $do23(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateV2EvalRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56563,12 +57676,12 @@ var init_evalsV2EvalsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalsCreate.ts
-var args12, tool$evalsV2EvalsCreate;
+var args18, tool$evalsV2EvalsCreate;
 var init_evalsV2EvalsCreate2 = __esm(() => {
   init_evalsV2EvalsCreate();
   init_createv2evalrequest();
   init_tools();
-  args12 = {
+  args18 = {
     request: CreateV2EvalRequest$zodSchema
   };
   tool$evalsV2EvalsCreate = {
@@ -56583,7 +57696,7 @@ Creates a reusable simulation definition with one or more task prompts and judge
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args12,
+    args: args18,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalsCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -56674,9 +57787,9 @@ var init_v2evalsdeleteop = __esm(() => {
 
 // src/funcs/evalsV2EvalsDelete.ts
 function evalsV2EvalsDelete(client$, request, options) {
-  return new APIPromise($do16(client$, request, options));
+  return new APIPromise($do24(client$, request, options));
 }
-async function $do16(client$, request, options) {
+async function $do24(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalsDeleteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56751,12 +57864,12 @@ var init_evalsV2EvalsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalsDelete.ts
-var args13, tool$evalsV2EvalsDelete;
+var args19, tool$evalsV2EvalsDelete;
 var init_evalsV2EvalsDelete2 = __esm(() => {
   init_evalsV2EvalsDelete();
   init_v2evalsdeleteop();
   init_tools();
-  args13 = {
+  args19 = {
     request: V2EvalsDeleteRequest$zodSchema
   };
   tool$evalsV2EvalsDelete = {
@@ -56771,7 +57884,7 @@ Permanently deletes an eval and all of its saved configurations.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args13,
+    args: args19,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalsDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -56787,9 +57900,9 @@ Permanently deletes an eval and all of its saved configurations.`,
 
 // src/funcs/evalsV2EvalsList.ts
 function evalsV2EvalsList(client$, options) {
-  return new APIPromise($do17(client$, options));
+  return new APIPromise($do25(client$, options));
 }
-async function $do17(client$, options) {
+async function $do25(client$, options) {
   const path$ = pathToFunc("/v2/evals")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -56894,9 +58007,9 @@ var init_v2evalsretrieveop = __esm(() => {
 
 // src/funcs/evalsV2EvalsRetrieve.ts
 function evalsV2EvalsRetrieve(client$, request, options) {
-  return new APIPromise($do18(client$, request, options));
+  return new APIPromise($do26(client$, request, options));
 }
-async function $do18(client$, request, options) {
+async function $do26(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -56971,12 +58084,12 @@ var init_evalsV2EvalsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalsRetrieve.ts
-var args14, tool$evalsV2EvalsRetrieve;
+var args20, tool$evalsV2EvalsRetrieve;
 var init_evalsV2EvalsRetrieve2 = __esm(() => {
   init_evalsV2EvalsRetrieve();
   init_v2evalsretrieveop();
   init_tools();
-  args14 = {
+  args20 = {
     request: V2EvalsRetrieveRequest$zodSchema
   };
   tool$evalsV2EvalsRetrieve = {
@@ -56991,7 +58104,7 @@ Returns one reusable eval simulation definition.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args14,
+    args: args20,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -57054,9 +58167,9 @@ var init_v2evalsupdateop = __esm(() => {
 
 // src/funcs/evalsV2EvalsUpdate.ts
 function evalsV2EvalsUpdate(client$, request, options) {
-  return new APIPromise($do19(client$, request, options));
+  return new APIPromise($do27(client$, request, options));
 }
-async function $do19(client$, request, options) {
+async function $do27(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalsUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -57132,12 +58245,12 @@ var init_evalsV2EvalsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsV2EvalsUpdate.ts
-var args15, tool$evalsV2EvalsUpdate;
+var args21, tool$evalsV2EvalsUpdate;
 var init_evalsV2EvalsUpdate2 = __esm(() => {
   init_evalsV2EvalsUpdate();
   init_v2evalsupdateop();
   init_tools();
-  args15 = {
+  args21 = {
     request: V2EvalsUpdateRequest$zodSchema
   };
   tool$evalsV2EvalsUpdate = {
@@ -57152,7 +58265,7 @@ Updates a reusable eval simulation definition. Omitted fields remain unchanged.
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args15,
+    args: args21,
     tool: async (client, args, ctx) => {
       const [result] = await evalsV2EvalsUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -57267,9 +58380,9 @@ var init_createevaltemplaterequest = __esm(() => {
 
 // src/funcs/evalTemplatesV2EvalTemplatesCreate.ts
 function evalTemplatesV2EvalTemplatesCreate(client$, request, options) {
-  return new APIPromise($do20(client$, request, options));
+  return new APIPromise($do28(client$, request, options));
 }
-async function $do20(client$, request, options) {
+async function $do28(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateEvalTemplateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -57339,12 +58452,12 @@ var init_evalTemplatesV2EvalTemplatesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalTemplatesV2EvalTemplatesCreate.ts
-var args16, tool$evalTemplatesV2EvalTemplatesCreate;
+var args22, tool$evalTemplatesV2EvalTemplatesCreate;
 var init_evalTemplatesV2EvalTemplatesCreate2 = __esm(() => {
   init_evalTemplatesV2EvalTemplatesCreate();
   init_createevaltemplaterequest();
   init_tools();
-  args16 = {
+  args22 = {
     request: CreateEvalTemplateRequest$zodSchema
   };
   tool$evalTemplatesV2EvalTemplatesCreate = {
@@ -57359,7 +58472,7 @@ Step 1 of the reusable template workflow. Creates an organization-owned Eval tem
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args16,
+    args: args22,
     tool: async (client, args, ctx) => {
       const [result] = await evalTemplatesV2EvalTemplatesCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -57452,9 +58565,9 @@ var init_v2evaltemplatesdeleteop = __esm(() => {
 
 // src/funcs/evalTemplatesV2EvalTemplatesDelete.ts
 function evalTemplatesV2EvalTemplatesDelete(client$, request, options) {
-  return new APIPromise($do21(client$, request, options));
+  return new APIPromise($do29(client$, request, options));
 }
-async function $do21(client$, request, options) {
+async function $do29(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalTemplatesDeleteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -57529,12 +58642,12 @@ var init_evalTemplatesV2EvalTemplatesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/evalTemplatesV2EvalTemplatesDelete.ts
-var args17, tool$evalTemplatesV2EvalTemplatesDelete;
+var args23, tool$evalTemplatesV2EvalTemplatesDelete;
 var init_evalTemplatesV2EvalTemplatesDelete2 = __esm(() => {
   init_evalTemplatesV2EvalTemplatesDelete();
   init_v2evaltemplatesdeleteop();
   init_tools();
-  args17 = {
+  args23 = {
     request: V2EvalTemplatesDeleteRequest$zodSchema
   };
   tool$evalTemplatesV2EvalTemplatesDelete = {
@@ -57549,7 +58662,7 @@ Soft-deletes an Eval template. Evals previously created from it remain independe
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args17,
+    args: args23,
     tool: async (client, args, ctx) => {
       const [result] = await evalTemplatesV2EvalTemplatesDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -57565,9 +58678,9 @@ Soft-deletes an Eval template. Evals previously created from it remain independe
 
 // src/funcs/evalTemplatesV2EvalTemplatesList.ts
 function evalTemplatesV2EvalTemplatesList(client$, options) {
-  return new APIPromise($do22(client$, options));
+  return new APIPromise($do30(client$, options));
 }
-async function $do22(client$, options) {
+async function $do30(client$, options) {
   const path$ = pathToFunc("/v2/eval-templates")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -57676,9 +58789,9 @@ var init_v2evaltemplatesretrieveop = __esm(() => {
 
 // src/funcs/evalTemplatesV2EvalTemplatesRetrieve.ts
 function evalTemplatesV2EvalTemplatesRetrieve(client$, request, options) {
-  return new APIPromise($do23(client$, request, options));
+  return new APIPromise($do31(client$, request, options));
 }
-async function $do23(client$, request, options) {
+async function $do31(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalTemplatesRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -57753,12 +58866,12 @@ var init_evalTemplatesV2EvalTemplatesRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/evalTemplatesV2EvalTemplatesRetrieve.ts
-var args18, tool$evalTemplatesV2EvalTemplatesRetrieve;
+var args24, tool$evalTemplatesV2EvalTemplatesRetrieve;
 var init_evalTemplatesV2EvalTemplatesRetrieve2 = __esm(() => {
   init_evalTemplatesV2EvalTemplatesRetrieve();
   init_v2evaltemplatesretrieveop();
   init_tools();
-  args18 = {
+  args24 = {
     request: V2EvalTemplatesRetrieveRequest$zodSchema
   };
   tool$evalTemplatesV2EvalTemplatesRetrieve = {
@@ -57773,7 +58886,7 @@ Returns one active reusable Eval template.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args18,
+    args: args24,
     tool: async (client, args, ctx) => {
       const [result] = await evalTemplatesV2EvalTemplatesRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -57866,9 +58979,9 @@ var init_v2evaltemplatesupdateop = __esm(() => {
 
 // src/funcs/evalTemplatesV2EvalTemplatesUpdate.ts
 function evalTemplatesV2EvalTemplatesUpdate(client$, request, options) {
-  return new APIPromise($do24(client$, request, options));
+  return new APIPromise($do32(client$, request, options));
 }
-async function $do24(client$, request, options) {
+async function $do32(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2EvalTemplatesUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -57944,12 +59057,12 @@ var init_evalTemplatesV2EvalTemplatesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalTemplatesV2EvalTemplatesUpdate.ts
-var args19, tool$evalTemplatesV2EvalTemplatesUpdate;
+var args25, tool$evalTemplatesV2EvalTemplatesUpdate;
 var init_evalTemplatesV2EvalTemplatesUpdate2 = __esm(() => {
   init_evalTemplatesV2EvalTemplatesUpdate();
   init_v2evaltemplatesupdateop();
   init_tools();
-  args19 = {
+  args25 = {
     request: V2EvalTemplatesUpdateRequest$zodSchema
   };
   tool$evalTemplatesV2EvalTemplatesUpdate = {
@@ -57964,7 +59077,7 @@ Updates an Eval template. Supply \`expected_template_version\` to reject an edit
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args19,
+    args: args25,
     tool: async (client, args, ctx) => {
       const [result] = await evalTemplatesV2EvalTemplatesUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -57980,9 +59093,9 @@ Updates an Eval template. Supply \`expected_template_version\` to reject an edit
 
 // src/funcs/mcpServersV2MCPServersList.ts
 function mcpServersV2MCPServersList(client$, options) {
-  return new APIPromise($do25(client$, options));
+  return new APIPromise($do33(client$, options));
 }
-async function $do25(client$, options) {
+async function $do33(client$, options) {
   const path$ = pathToFunc("/v2/mcp-servers")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -58164,9 +59277,9 @@ var init_v2opportunitieslistop = __esm(() => {
 
 // src/funcs/opportunitiesV2OpportunitiesList.ts
 function opportunitiesV2OpportunitiesList(client$, request, options) {
-  return new APIPromise($do26(client$, request, options));
+  return new APIPromise($do34(client$, request, options));
 }
-async function $do26(client$, request, options) {
+async function $do34(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2OpportunitiesListRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -58244,12 +59357,12 @@ var init_opportunitiesV2OpportunitiesList = __esm(() => {
 });
 
 // src/mcp-server/tools/opportunitiesV2OpportunitiesList.ts
-var args20, tool$opportunitiesV2OpportunitiesList;
+var args26, tool$opportunitiesV2OpportunitiesList;
 var init_opportunitiesV2OpportunitiesList2 = __esm(() => {
   init_opportunitiesV2OpportunitiesList();
   init_v2opportunitieslistop();
   init_tools();
-  args20 = {
+  args26 = {
     request: V2OpportunitiesListRequest$zodSchema.optional()
   };
   tool$opportunitiesV2OpportunitiesList = {
@@ -58264,7 +59377,7 @@ Returns ranked opportunities computed from stored prompt visibility results. Eac
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args20,
+    args: args26,
     tool: async (client, args, ctx) => {
       const [result] = await opportunitiesV2OpportunitiesList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -58336,9 +59449,9 @@ var init_v2opportunitiesretrieveop = __esm(() => {
 
 // src/funcs/opportunitiesV2OpportunitiesRetrieve.ts
 function opportunitiesV2OpportunitiesRetrieve(client$, request, options) {
-  return new APIPromise($do27(client$, request, options));
+  return new APIPromise($do35(client$, request, options));
 }
-async function $do27(client$, request, options) {
+async function $do35(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2OpportunitiesRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -58419,12 +59532,12 @@ var init_opportunitiesV2OpportunitiesRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/opportunitiesV2OpportunitiesRetrieve.ts
-var args21, tool$opportunitiesV2OpportunitiesRetrieve;
+var args27, tool$opportunitiesV2OpportunitiesRetrieve;
 var init_opportunitiesV2OpportunitiesRetrieve2 = __esm(() => {
   init_opportunitiesV2OpportunitiesRetrieve();
   init_v2opportunitiesretrieveop();
   init_tools();
-  args21 = {
+  args27 = {
     request: V2OpportunitiesRetrieveRequest$zodSchema
   };
   tool$opportunitiesV2OpportunitiesRetrieve = {
@@ -58439,7 +59552,7 @@ Returns one computed opportunity and its execution context for the selected date
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args21,
+    args: args27,
     tool: async (client, args, ctx) => {
       const [result] = await opportunitiesV2OpportunitiesRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -58465,9 +59578,9 @@ var init_createv2promptrunrequest = __esm(() => {
 
 // src/funcs/promptsRun.ts
 function promptsRun(client$, request, options) {
-  return new APIPromise($do28(client$, request, options));
+  return new APIPromise($do36(client$, request, options));
 }
-async function $do28(client$, request, options) {
+async function $do36(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateV2PromptRunRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -58537,12 +59650,12 @@ var init_promptsRun = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsRun.ts
-var args22, tool$promptsRun;
+var args28, tool$promptsRun;
 var init_promptsRun2 = __esm(() => {
   init_promptsRun();
   init_createv2promptrunrequest();
   init_tools();
-  args22 = {
+  args28 = {
     request: CreateV2PromptRunRequest$zodSchema
   };
   tool$promptsRun = {
@@ -58562,7 +59675,7 @@ response returns a run ID to poll with
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args22,
+    args: args28,
     tool: async (client, args, ctx) => {
       const [result] = await promptsRun(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -58641,9 +59754,9 @@ var init_v2promptrunstatusretrieveop = __esm(() => {
 
 // src/funcs/promptsRunStatus.ts
 function promptsRunStatus(client$, request, options) {
-  return new APIPromise($do29(client$, request, options));
+  return new APIPromise($do37(client$, request, options));
 }
-async function $do29(client$, request, options) {
+async function $do37(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptRunStatusRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -58718,12 +59831,12 @@ var init_promptsRunStatus = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsRunStatus.ts
-var args23, tool$promptsRunStatus;
+var args29, tool$promptsRunStatus;
 var init_promptsRunStatus2 = __esm(() => {
   init_promptsRunStatus();
   init_v2promptrunstatusretrieveop();
   init_tools();
-  args23 = {
+  args29 = {
     request: V2PromptRunStatusRetrieveRequest$zodSchema
   };
   tool$promptsRunStatus = {
@@ -58741,7 +59854,7 @@ Individual stored results are available from \`GET /v2/prompts/runs\`.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args23,
+    args: args29,
     tool: async (client, args, ctx) => {
       const [result] = await promptsRunStatus(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -58855,9 +59968,9 @@ var init_v2promptrunslistop = __esm(() => {
 
 // src/funcs/promptsV2PromptRunsList.ts
 function promptsV2PromptRunsList(client$, request, options) {
-  return new APIPromise($do30(client$, request, options));
+  return new APIPromise($do38(client$, request, options));
 }
-async function $do30(client$, request, options) {
+async function $do38(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptRunsListRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -58935,12 +60048,12 @@ var init_promptsV2PromptRunsList = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptRunsList.ts
-var args24, tool$promptsV2PromptRunsList;
+var args30, tool$promptsV2PromptRunsList;
 var init_promptsV2PromptRunsList2 = __esm(() => {
   init_promptsV2PromptRunsList();
   init_v2promptrunslistop();
   init_tools();
-  args24 = {
+  args30 = {
     request: V2PromptRunsListRequest$zodSchema.optional()
   };
   tool$promptsV2PromptRunsList = {
@@ -58955,7 +60068,7 @@ Returns stored prompt runs with limit-and-offset pagination, without exposing ra
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args24,
+    args: args30,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptRunsList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59068,9 +60181,9 @@ var init_v2promptrunsretrieveop = __esm(() => {
 
 // src/funcs/promptsV2PromptRunsRetrieve.ts
 function promptsV2PromptRunsRetrieve(client$, request, options) {
-  return new APIPromise($do31(client$, request, options));
+  return new APIPromise($do39(client$, request, options));
 }
-async function $do31(client$, request, options) {
+async function $do39(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptRunsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -59145,12 +60258,12 @@ var init_promptsV2PromptRunsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptRunsRetrieve.ts
-var args25, tool$promptsV2PromptRunsRetrieve;
+var args31, tool$promptsV2PromptRunsRetrieve;
 var init_promptsV2PromptRunsRetrieve2 = __esm(() => {
   init_promptsV2PromptRunsRetrieve();
   init_v2promptrunsretrieveop();
   init_tools();
-  args25 = {
+  args31 = {
     request: V2PromptRunsRetrieveRequest$zodSchema
   };
   tool$promptsV2PromptRunsRetrieve = {
@@ -59165,7 +60278,7 @@ Returns one stored prompt run, including mentions, citations, and any sanitized
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args25,
+    args: args31,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptRunsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59220,9 +60333,9 @@ var init_createv2promptsrequest = __esm(() => {
 
 // src/funcs/promptsV2PromptsCreate.ts
 function promptsV2PromptsCreate(client$, request, options) {
-  return new APIPromise($do32(client$, request, options));
+  return new APIPromise($do40(client$, request, options));
 }
-async function $do32(client$, request, options) {
+async function $do40(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateV2PromptsRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -59292,12 +60405,12 @@ var init_promptsV2PromptsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptsCreate.ts
-var args26, tool$promptsV2PromptsCreate;
+var args32, tool$promptsV2PromptsCreate;
 var init_promptsV2PromptsCreate2 = __esm(() => {
   init_promptsV2PromptsCreate();
   init_createv2promptsrequest();
   init_tools();
-  args26 = {
+  args32 = {
     request: CreateV2PromptsRequest$zodSchema
   };
   tool$promptsV2PromptsCreate = {
@@ -59312,7 +60425,7 @@ Creates prompts in a batch. Each item is validated independently, so the respons
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args26,
+    args: args32,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptsCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59352,9 +60465,9 @@ var init_v2promptsdeleteop = __esm(() => {
 
 // src/funcs/promptsV2PromptsDelete.ts
 function promptsV2PromptsDelete(client$, request, options) {
-  return new APIPromise($do33(client$, request, options));
+  return new APIPromise($do41(client$, request, options));
 }
-async function $do33(client$, request, options) {
+async function $do41(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptsDeleteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -59429,12 +60542,12 @@ var init_promptsV2PromptsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptsDelete.ts
-var args27, tool$promptsV2PromptsDelete;
+var args33, tool$promptsV2PromptsDelete;
 var init_promptsV2PromptsDelete2 = __esm(() => {
   init_promptsV2PromptsDelete();
   init_v2promptsdeleteop();
   init_tools();
-  args27 = {
+  args33 = {
     request: V2PromptsDeleteRequest$zodSchema
   };
   tool$promptsV2PromptsDelete = {
@@ -59449,7 +60562,7 @@ Archives the prompt and excludes it from normal listings while preserving its hi
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args27,
+    args: args33,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptsDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59577,9 +60690,9 @@ var init_v2promptslistop = __esm(() => {
 
 // src/funcs/promptsV2PromptsList.ts
 function promptsV2PromptsList(client$, request, options) {
-  return new APIPromise($do34(client$, request, options));
+  return new APIPromise($do42(client$, request, options));
 }
-async function $do34(client$, request, options) {
+async function $do42(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptsListRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -59654,12 +60767,12 @@ var init_promptsV2PromptsList = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptsList.ts
-var args28, tool$promptsV2PromptsList;
+var args34, tool$promptsV2PromptsList;
 var init_promptsV2PromptsList2 = __esm(() => {
   init_promptsV2PromptsList();
   init_v2promptslistop();
   init_tools();
-  args28 = {
+  args34 = {
     request: V2PromptsListRequest$zodSchema.optional()
   };
   tool$promptsV2PromptsList = {
@@ -59674,7 +60787,7 @@ Returns active and inactive prompts by default. Set \`include_archived\` to incl
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args28,
+    args: args34,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptsList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59705,9 +60818,9 @@ var init_v2promptsretrieveop = __esm(() => {
 
 // src/funcs/promptsV2PromptsRetrieve.ts
 function promptsV2PromptsRetrieve(client$, request, options) {
-  return new APIPromise($do35(client$, request, options));
+  return new APIPromise($do43(client$, request, options));
 }
-async function $do35(client$, request, options) {
+async function $do43(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -59782,12 +60895,12 @@ var init_promptsV2PromptsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptsRetrieve.ts
-var args29, tool$promptsV2PromptsRetrieve;
+var args35, tool$promptsV2PromptsRetrieve;
 var init_promptsV2PromptsRetrieve2 = __esm(() => {
   init_promptsV2PromptsRetrieve();
   init_v2promptsretrieveop();
   init_tools();
-  args29 = {
+  args35 = {
     request: V2PromptsRetrieveRequest$zodSchema
   };
   tool$promptsV2PromptsRetrieve = {
@@ -59802,7 +60915,7 @@ Returns a prompt with its topic, platforms, tags, lifecycle status, and coding-a
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args29,
+    args: args35,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59853,9 +60966,9 @@ var init_v2promptsupdateop = __esm(() => {
 
 // src/funcs/promptsV2PromptsUpdate.ts
 function promptsV2PromptsUpdate(client$, request, options) {
-  return new APIPromise($do36(client$, request, options));
+  return new APIPromise($do44(client$, request, options));
 }
-async function $do36(client$, request, options) {
+async function $do44(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptsUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -59931,12 +61044,12 @@ var init_promptsV2PromptsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptsUpdate.ts
-var args30, tool$promptsV2PromptsUpdate;
+var args36, tool$promptsV2PromptsUpdate;
 var init_promptsV2PromptsUpdate2 = __esm(() => {
   init_promptsV2PromptsUpdate();
   init_v2promptsupdateop();
   init_tools();
-  args30 = {
+  args36 = {
     request: V2PromptsUpdateRequest$zodSchema
   };
   tool$promptsV2PromptsUpdate = {
@@ -59951,7 +61064,7 @@ Updates a prompt's text, topic, platforms, lifecycle status, or coding-agent run
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args30,
+    args: args36,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptsUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -59976,9 +61089,9 @@ var init_createprompttopicrequest = __esm(() => {
 
 // src/funcs/promptsV2PromptTopicsCreate.ts
 function promptsV2PromptTopicsCreate(client$, request, options) {
-  return new APIPromise($do37(client$, request, options));
+  return new APIPromise($do45(client$, request, options));
 }
-async function $do37(client$, request, options) {
+async function $do45(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreatePromptTopicRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60048,12 +61161,12 @@ var init_promptsV2PromptTopicsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptTopicsCreate.ts
-var args31, tool$promptsV2PromptTopicsCreate;
+var args37, tool$promptsV2PromptTopicsCreate;
 var init_promptsV2PromptTopicsCreate2 = __esm(() => {
   init_promptsV2PromptTopicsCreate();
   init_createprompttopicrequest();
   init_tools();
-  args31 = {
+  args37 = {
     request: CreatePromptTopicRequest$zodSchema
   };
   tool$promptsV2PromptTopicsCreate = {
@@ -60068,7 +61181,7 @@ Creates a prompt topic and returns the saved topic.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args31,
+    args: args37,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptTopicsCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -60100,9 +61213,9 @@ var init_v2prompttopicsdeleteop = __esm(() => {
 
 // src/funcs/promptsV2PromptTopicsDelete.ts
 function promptsV2PromptTopicsDelete(client$, request, options) {
-  return new APIPromise($do38(client$, request, options));
+  return new APIPromise($do46(client$, request, options));
 }
-async function $do38(client$, request, options) {
+async function $do46(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptTopicsDeleteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60181,12 +61294,12 @@ var init_promptsV2PromptTopicsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptTopicsDelete.ts
-var args32, tool$promptsV2PromptTopicsDelete;
+var args38, tool$promptsV2PromptTopicsDelete;
 var init_promptsV2PromptTopicsDelete2 = __esm(() => {
   init_promptsV2PromptTopicsDelete();
   init_v2prompttopicsdeleteop();
   init_tools();
-  args32 = {
+  args38 = {
     request: V2PromptTopicsDeleteRequest$zodSchema
   };
   tool$promptsV2PromptTopicsDelete = {
@@ -60201,7 +61314,7 @@ Archives a prompt topic. Set \`archive_prompts\` to archive remaining prompts; o
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args32,
+    args: args38,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptTopicsDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -60217,9 +61330,9 @@ Archives a prompt topic. Set \`archive_prompts\` to archive remaining prompts; o
 
 // src/funcs/promptsV2PromptTopicsList.ts
 function promptsV2PromptTopicsList(client$, options) {
-  return new APIPromise($do39(client$, options));
+  return new APIPromise($do47(client$, options));
 }
-async function $do39(client$, options) {
+async function $do47(client$, options) {
   const path$ = pathToFunc("/v2/prompts/topics")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -60335,9 +61448,9 @@ var init_v2prompttopicsupdateop = __esm(() => {
 
 // src/funcs/promptsV2PromptTopicsUpdate.ts
 function promptsV2PromptTopicsUpdate(client$, request, options) {
-  return new APIPromise($do40(client$, request, options));
+  return new APIPromise($do48(client$, request, options));
 }
-async function $do40(client$, request, options) {
+async function $do48(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2PromptTopicsUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60413,12 +61526,12 @@ var init_promptsV2PromptTopicsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsV2PromptTopicsUpdate.ts
-var args33, tool$promptsV2PromptTopicsUpdate;
+var args39, tool$promptsV2PromptTopicsUpdate;
 var init_promptsV2PromptTopicsUpdate2 = __esm(() => {
   init_promptsV2PromptTopicsUpdate();
   init_v2prompttopicsupdateop();
   init_tools();
-  args33 = {
+  args39 = {
     request: V2PromptTopicsUpdateRequest$zodSchema
   };
   tool$promptsV2PromptTopicsUpdate = {
@@ -60433,7 +61546,7 @@ Renames a prompt topic and returns the updated topic.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args33,
+    args: args39,
     tool: async (client, args, ctx) => {
       const [result] = await promptsV2PromptTopicsUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -60476,9 +61589,9 @@ var init_createv2repositoryrequest = __esm(() => {
 
 // src/funcs/repositoriesV2RepositoriesCreate.ts
 function repositoriesV2RepositoriesCreate(client$, request, options) {
-  return new APIPromise($do41(client$, request, options));
+  return new APIPromise($do49(client$, request, options));
 }
-async function $do41(client$, request, options) {
+async function $do49(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => CreateV2RepositoryRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60548,12 +61661,12 @@ var init_repositoriesV2RepositoriesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/repositoriesV2RepositoriesCreate.ts
-var args34, tool$repositoriesV2RepositoriesCreate;
+var args40, tool$repositoriesV2RepositoriesCreate;
 var init_repositoriesV2RepositoriesCreate2 = __esm(() => {
   init_repositoriesV2RepositoriesCreate();
   init_createv2repositoryrequest();
   init_tools();
-  args34 = {
+  args40 = {
     request: CreateV2RepositoryRequest$zodSchema
   };
   tool$repositoriesV2RepositoriesCreate = {
@@ -60568,7 +61681,7 @@ Adds a reusable Git repository workspace for eval configurations.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args34,
+    args: args40,
     tool: async (client, args, ctx) => {
       const [result] = await repositoriesV2RepositoriesCreate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -60634,9 +61747,9 @@ var init_v2repositoriesdeleteop = __esm(() => {
 
 // src/funcs/repositoriesV2RepositoriesDelete.ts
 function repositoriesV2RepositoriesDelete(client$, request, options) {
-  return new APIPromise($do42(client$, request, options));
+  return new APIPromise($do50(client$, request, options));
 }
-async function $do42(client$, request, options) {
+async function $do50(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2RepositoriesDeleteRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60711,12 +61824,12 @@ var init_repositoriesV2RepositoriesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/repositoriesV2RepositoriesDelete.ts
-var args35, tool$repositoriesV2RepositoriesDelete;
+var args41, tool$repositoriesV2RepositoriesDelete;
 var init_repositoriesV2RepositoriesDelete2 = __esm(() => {
   init_repositoriesV2RepositoriesDelete();
   init_v2repositoriesdeleteop();
   init_tools();
-  args35 = {
+  args41 = {
     request: V2RepositoriesDeleteRequest$zodSchema
   };
   tool$repositoriesV2RepositoriesDelete = {
@@ -60731,7 +61844,7 @@ Permanently deletes a repository workspace and returns its last saved state.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args35,
+    args: args41,
     tool: async (client, args, ctx) => {
       const [result] = await repositoriesV2RepositoriesDelete(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -60747,9 +61860,9 @@ Permanently deletes a repository workspace and returns its last saved state.`,
 
 // src/funcs/repositoriesV2RepositoriesList.ts
 function repositoriesV2RepositoriesList(client$, options) {
-  return new APIPromise($do43(client$, options));
+  return new APIPromise($do51(client$, options));
 }
-async function $do43(client$, options) {
+async function $do51(client$, options) {
   const path$ = pathToFunc("/v2/repositories")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -60854,9 +61967,9 @@ var init_v2repositoriesretrieveop = __esm(() => {
 
 // src/funcs/repositoriesV2RepositoriesRetrieve.ts
 function repositoriesV2RepositoriesRetrieve(client$, request, options) {
-  return new APIPromise($do44(client$, request, options));
+  return new APIPromise($do52(client$, request, options));
 }
-async function $do44(client$, request, options) {
+async function $do52(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2RepositoriesRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -60931,12 +62044,12 @@ var init_repositoriesV2RepositoriesRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/repositoriesV2RepositoriesRetrieve.ts
-var args36, tool$repositoriesV2RepositoriesRetrieve;
+var args42, tool$repositoriesV2RepositoriesRetrieve;
 var init_repositoriesV2RepositoriesRetrieve2 = __esm(() => {
   init_repositoriesV2RepositoriesRetrieve();
   init_v2repositoriesretrieveop();
   init_tools();
-  args36 = {
+  args42 = {
     request: V2RepositoriesRetrieveRequest$zodSchema
   };
   tool$repositoriesV2RepositoriesRetrieve = {
@@ -60951,7 +62064,7 @@ Returns one reusable repository workspace.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args36,
+    args: args42,
     tool: async (client, args, ctx) => {
       const [result] = await repositoriesV2RepositoriesRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -61011,9 +62124,9 @@ var init_v2repositoriesupdateop = __esm(() => {
 
 // src/funcs/repositoriesV2RepositoriesUpdate.ts
 function repositoriesV2RepositoriesUpdate(client$, request, options) {
-  return new APIPromise($do45(client$, request, options));
+  return new APIPromise($do53(client$, request, options));
 }
-async function $do45(client$, request, options) {
+async function $do53(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2RepositoriesUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61089,12 +62202,12 @@ var init_repositoriesV2RepositoriesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/repositoriesV2RepositoriesUpdate.ts
-var args37, tool$repositoriesV2RepositoriesUpdate;
+var args43, tool$repositoriesV2RepositoriesUpdate;
 var init_repositoriesV2RepositoriesUpdate2 = __esm(() => {
   init_repositoriesV2RepositoriesUpdate();
   init_v2repositoriesupdateop();
   init_tools();
-  args37 = {
+  args43 = {
     request: V2RepositoriesUpdateRequest$zodSchema
   };
   tool$repositoriesV2RepositoriesUpdate = {
@@ -61109,7 +62222,7 @@ Updates a repository workspace; omitted fields remain unchanged.`,
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args37,
+    args: args43,
     tool: async (client, args, ctx) => {
       const [result] = await repositoriesV2RepositoriesUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -61125,9 +62238,9 @@ Updates a repository workspace; omitted fields remain unchanged.`,
 
 // src/funcs/siteAuditsV2SiteAuditsList.ts
 function siteAuditsV2SiteAuditsList(client$, options) {
-  return new APIPromise($do46(client$, options));
+  return new APIPromise($do54(client$, options));
 }
-async function $do46(client$, options) {
+async function $do54(client$, options) {
   const path$ = pathToFunc("/v2/site-audits")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -61268,9 +62381,9 @@ var init_v2siteauditsretrieveop = __esm(() => {
 
 // src/funcs/siteAuditsV2SiteAuditsRetrieve.ts
 function siteAuditsV2SiteAuditsRetrieve(client$, request, options) {
-  return new APIPromise($do47(client$, request, options));
+  return new APIPromise($do55(client$, request, options));
 }
-async function $do47(client$, request, options) {
+async function $do55(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2SiteAuditsRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61345,12 +62458,12 @@ var init_siteAuditsV2SiteAuditsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/siteAuditsV2SiteAuditsRetrieve.ts
-var args38, tool$siteAuditsV2SiteAuditsRetrieve;
+var args44, tool$siteAuditsV2SiteAuditsRetrieve;
 var init_siteAuditsV2SiteAuditsRetrieve2 = __esm(() => {
   init_siteAuditsV2SiteAuditsRetrieve();
   init_v2siteauditsretrieveop();
   init_tools();
-  args38 = {
+  args44 = {
     request: V2SiteAuditsRetrieveRequest$zodSchema
   };
   tool$siteAuditsV2SiteAuditsRetrieve = {
@@ -61365,7 +62478,7 @@ Returns one audited page with its score, priority, supporting evidence, and reco
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args38,
+    args: args44,
     tool: async (client, args, ctx) => {
       const [result] = await siteAuditsV2SiteAuditsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -61381,9 +62494,9 @@ Returns one audited page with its score, priority, supporting evidence, and reco
 
 // src/funcs/skillsV2SkillsList.ts
 function skillsV2SkillsList(client$, options) {
-  return new APIPromise($do48(client$, options));
+  return new APIPromise($do56(client$, options));
 }
-async function $do48(client$, options) {
+async function $do56(client$, options) {
   const path$ = pathToFunc("/v2/skills")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -61473,9 +62586,9 @@ Returns reusable skills available to workflows and eval configurations.`,
 
 // src/funcs/statusV2AuthStatusGet.ts
 function statusV2AuthStatusGet(client$, options) {
-  return new APIPromise($do49(client$, options));
+  return new APIPromise($do57(client$, options));
 }
-async function $do49(client$, options) {
+async function $do57(client$, options) {
   const path$ = pathToFunc("/v2/auth/status")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -61565,9 +62678,9 @@ Validates the API key and returns its organization ID, API key ID, scopes, and a
 
 // src/funcs/statusV2StatusGet.ts
 function statusV2StatusGet(client$, options) {
-  return new APIPromise($do50(client$, options));
+  return new APIPromise($do58(client$, options));
 }
-async function $do50(client$, options) {
+async function $do58(client$, options) {
   const path$ = pathToFunc("/v2/status")();
   const headers$ = new Headers(compactMap({
     Accept: "application/json"
@@ -61787,9 +62900,9 @@ var init_v2taskslistop = __esm(() => {
 
 // src/funcs/tasksV2TasksList.ts
 function tasksV2TasksList(client$, request, options) {
-  return new APIPromise($do51(client$, request, options));
+  return new APIPromise($do59(client$, request, options));
 }
-async function $do51(client$, request, options) {
+async function $do59(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2TasksListRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61863,12 +62976,12 @@ var init_tasksV2TasksList = __esm(() => {
 });
 
 // src/mcp-server/tools/tasksV2TasksList.ts
-var args39, tool$tasksV2TasksList;
+var args45, tool$tasksV2TasksList;
 var init_tasksV2TasksList2 = __esm(() => {
   init_tasksV2TasksList();
   init_v2taskslistop();
   init_tools();
-  args39 = {
+  args45 = {
     request: V2TasksListRequest$zodSchema.optional()
   };
   tool$tasksV2TasksList = {
@@ -61883,7 +62996,7 @@ Returns persisted daily tasks with execution instructions. Includes per-status c
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args39,
+    args: args45,
     tool: async (client, args, ctx) => {
       const [result] = await tasksV2TasksList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -61914,9 +63027,9 @@ var init_v2tasksretrieveop = __esm(() => {
 
 // src/funcs/tasksV2TasksRetrieve.ts
 function tasksV2TasksRetrieve(client$, request, options) {
-  return new APIPromise($do52(client$, request, options));
+  return new APIPromise($do60(client$, request, options));
 }
-async function $do52(client$, request, options) {
+async function $do60(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2TasksRetrieveRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -61991,12 +63104,12 @@ var init_tasksV2TasksRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/tasksV2TasksRetrieve.ts
-var args40, tool$tasksV2TasksRetrieve;
+var args46, tool$tasksV2TasksRetrieve;
 var init_tasksV2TasksRetrieve2 = __esm(() => {
   init_tasksV2TasksRetrieve();
   init_v2tasksretrieveop();
   init_tools();
-  args40 = {
+  args46 = {
     request: V2TasksRetrieveRequest$zodSchema
   };
   tool$tasksV2TasksRetrieve = {
@@ -62011,7 +63124,7 @@ Returns one persisted task and its execution prompt.`,
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args40,
+    args: args46,
     tool: async (client, args, ctx) => {
       const [result] = await tasksV2TasksRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -62074,9 +63187,9 @@ var init_v2tasksupdateop = __esm(() => {
 
 // src/funcs/tasksV2TasksUpdate.ts
 function tasksV2TasksUpdate(client$, request, options) {
-  return new APIPromise($do53(client$, request, options));
+  return new APIPromise($do61(client$, request, options));
 }
-async function $do53(client$, request, options) {
+async function $do61(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2TasksUpdateRequest$zodSchema.parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62152,12 +63265,12 @@ var init_tasksV2TasksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/tasksV2TasksUpdate.ts
-var args41, tool$tasksV2TasksUpdate;
+var args47, tool$tasksV2TasksUpdate;
 var init_tasksV2TasksUpdate2 = __esm(() => {
   init_tasksV2TasksUpdate();
   init_v2tasksupdateop();
   init_tools();
-  args41 = {
+  args47 = {
     request: V2TasksUpdateRequest$zodSchema
   };
   tool$tasksV2TasksUpdate = {
@@ -62172,7 +63285,7 @@ Updates a task's status, priority, assignee, or action type. Only sent fields ar
       openWorldHint: false,
       readOnlyHint: false
     },
-    args: args41,
+    args: args47,
     tool: async (client, args, ctx) => {
       const [result] = await tasksV2TasksUpdate(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -62260,9 +63373,9 @@ var init_v2visibilitycitationslistop = __esm(() => {
 
 // src/funcs/visibilityV2VisibilityCitationsList.ts
 function visibilityV2VisibilityCitationsList(client$, request, options) {
-  return new APIPromise($do54(client$, request, options));
+  return new APIPromise($do62(client$, request, options));
 }
-async function $do54(client$, request, options) {
+async function $do62(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2VisibilityCitationsListRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62339,12 +63452,12 @@ var init_visibilityV2VisibilityCitationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/visibilityV2VisibilityCitationsList.ts
-var args42, tool$visibilityV2VisibilityCitationsList;
+var args48, tool$visibilityV2VisibilityCitationsList;
 var init_visibilityV2VisibilityCitationsList2 = __esm(() => {
   init_visibilityV2VisibilityCitationsList();
   init_v2visibilitycitationslistop();
   init_tools();
-  args42 = {
+  args48 = {
     request: V2VisibilityCitationsListRequest$zodSchema.optional()
   };
   tool$visibilityV2VisibilityCitationsList = {
@@ -62359,7 +63472,7 @@ Returns URL-level citation counts ranked from most to least cited. Results can b
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args42,
+    args: args48,
     tool: async (client, args, ctx) => {
       const [result] = await visibilityV2VisibilityCitationsList(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -62424,9 +63537,9 @@ var init_v2visibilitycurrentretrieveop = __esm(() => {
 
 // src/funcs/visibilityV2VisibilityCurrentRetrieve.ts
 function visibilityV2VisibilityCurrentRetrieve(client$, request, options) {
-  return new APIPromise($do55(client$, request, options));
+  return new APIPromise($do63(client$, request, options));
 }
-async function $do55(client$, request, options) {
+async function $do63(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2VisibilityCurrentRetrieveRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62500,12 +63613,12 @@ var init_visibilityV2VisibilityCurrentRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/visibilityV2VisibilityCurrentRetrieve.ts
-var args43, tool$visibilityV2VisibilityCurrentRetrieve;
+var args49, tool$visibilityV2VisibilityCurrentRetrieve;
 var init_visibilityV2VisibilityCurrentRetrieve2 = __esm(() => {
   init_visibilityV2VisibilityCurrentRetrieve();
   init_v2visibilitycurrentretrieveop();
   init_tools();
-  args43 = {
+  args49 = {
     request: V2VisibilityCurrentRetrieveRequest$zodSchema.optional()
   };
   tool$visibilityV2VisibilityCurrentRetrieve = {
@@ -62520,7 +63633,7 @@ Returns visibility score, share of voice, ranks, and date-range metadata for the
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args43,
+    args: args49,
     tool: async (client, args, ctx) => {
       const [result] = await visibilityV2VisibilityCurrentRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -62663,9 +63776,9 @@ var init_v2visibilityoverviewretrieveop = __esm(() => {
 
 // src/funcs/visibilityV2VisibilityOverviewRetrieve.ts
 function visibilityV2VisibilityOverviewRetrieve(client$, request, options) {
-  return new APIPromise($do56(client$, request, options));
+  return new APIPromise($do64(client$, request, options));
 }
-async function $do56(client$, request, options) {
+async function $do64(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2VisibilityOverviewRetrieveRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62739,12 +63852,12 @@ var init_visibilityV2VisibilityOverviewRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/visibilityV2VisibilityOverviewRetrieve.ts
-var args44, tool$visibilityV2VisibilityOverviewRetrieve;
+var args50, tool$visibilityV2VisibilityOverviewRetrieve;
 var init_visibilityV2VisibilityOverviewRetrieve2 = __esm(() => {
   init_visibilityV2VisibilityOverviewRetrieve();
   init_v2visibilityoverviewretrieveop();
   init_tools();
-  args44 = {
+  args50 = {
     request: V2VisibilityOverviewRetrieveRequest$zodSchema.optional()
   };
   tool$visibilityV2VisibilityOverviewRetrieve = {
@@ -62759,7 +63872,7 @@ Returns aggregate snapshot, daily trends, per-platform breakdowns, and competito
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args44,
+    args: args50,
     tool: async (client, args, ctx) => {
       const [result] = await visibilityV2VisibilityOverviewRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -62873,9 +63986,9 @@ var init_v2visibilitypromptsretrieveop = __esm(() => {
 
 // src/funcs/visibilityV2VisibilityPromptsRetrieve.ts
 function visibilityV2VisibilityPromptsRetrieve(client$, request, options) {
-  return new APIPromise($do57(client$, request, options));
+  return new APIPromise($do65(client$, request, options));
 }
-async function $do57(client$, request, options) {
+async function $do65(client$, request, options) {
   const parsed$ = safeParse4(request, (value$) => V2VisibilityPromptsRetrieveRequest$zodSchema.optional().parse(value$), "Input validation failed");
   if (!parsed$.ok) {
     return [parsed$, { status: "invalid" }];
@@ -62949,12 +64062,12 @@ var init_visibilityV2VisibilityPromptsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/visibilityV2VisibilityPromptsRetrieve.ts
-var args45, tool$visibilityV2VisibilityPromptsRetrieve;
+var args51, tool$visibilityV2VisibilityPromptsRetrieve;
 var init_visibilityV2VisibilityPromptsRetrieve2 = __esm(() => {
   init_visibilityV2VisibilityPromptsRetrieve();
   init_v2visibilitypromptsretrieveop();
   init_tools();
-  args45 = {
+  args51 = {
     request: V2VisibilityPromptsRetrieveRequest$zodSchema.optional()
   };
   tool$visibilityV2VisibilityPromptsRetrieve = {
@@ -62969,7 +64082,7 @@ Returns per-topic and per-prompt visibility metrics including score, rank, share
       openWorldHint: false,
       readOnlyHint: true
     },
-    args: args45,
+    args: args51,
     tool: async (client, args, ctx) => {
       const [result] = await visibilityV2VisibilityPromptsRetrieve(client, args.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
@@ -62993,7 +64106,7 @@ function createMCPServer(deps) {
       sizes: ["any"]
     }],
     name: "LightsageMcp",
-    version: "0.4.5"
+    version: "0.4.6"
   });
   const getClient = deps.getSDK || (() => new LightsageMcpCore({
     security: deps.security,
@@ -63059,6 +64172,14 @@ function createMCPServer(deps) {
   tool(tool$evalTemplatesV2EvalTemplatesUpdate);
   tool(tool$evalTemplatesV2EvalTemplatesDelete);
   tool(tool$evalRunsV2EvalRunsList);
+  tool(tool$agentPreferenceV2AgentPreferenceCompetitorsList);
+  tool(tool$agentPreferenceV2AgentPreferenceHeadToHeadRetrieve);
+  tool(tool$agentPreferenceV2AgentPreferenceEvalsList);
+  tool(tool$agentPreferenceV2AgentPreferenceEvalsCreate);
+  tool(tool$agentPreferenceV2AgentPreferenceEvalsRetrieve);
+  tool(tool$agentPreferenceV2AgentPreferenceEvalsUpdate);
+  tool(tool$agentPreferenceV2AgentPreferenceEvalsDelete);
+  tool(tool$agentPreferenceV2AgentPreferenceResultsList);
   tool(tool$agentsV2AgentsList);
   tool(tool$repositoriesV2RepositoriesList);
   tool(tool$repositoriesV2RepositoriesCreate);
@@ -63079,6 +64200,14 @@ var init_server2 = __esm(() => {
   init_core3();
   init_resources();
   init_tools();
+  init_agentPreferenceV2AgentPreferenceCompetitorsList2();
+  init_agentPreferenceV2AgentPreferenceEvalsCreate2();
+  init_agentPreferenceV2AgentPreferenceEvalsDelete2();
+  init_agentPreferenceV2AgentPreferenceEvalsList2();
+  init_agentPreferenceV2AgentPreferenceEvalsRetrieve2();
+  init_agentPreferenceV2AgentPreferenceEvalsUpdate2();
+  init_agentPreferenceV2AgentPreferenceHeadToHeadRetrieve2();
+  init_agentPreferenceV2AgentPreferenceResultsList2();
   init_agentsV2AgentsList2();
   init_clIsV2ClisList2();
   init_environmentsV2EnvironmentsList2();
@@ -63399,6 +64528,46 @@ Soft-deletes an Eval template. Evals previously created from it remain independe
       name: "eval-runs-v2-eval-runs-list",
       description: "List Runs\n\nReturns jobs created through `POST /v2/eval-runs`, ordered newest first, with lifecycle state and progress."
     },
+    {
+      name: "agent-preference-v2-agent-preference-competitors-9f0",
+      description: "List Competitors\n\nReturns the tracked competitors your company can be compared against. Use a returned `id` as `competitor_id` when creating an Agent Preference eval."
+    },
+    {
+      name: "agent-preference-v2-agent-preference-head-to-273",
+      description: "Retrieve Head To Head\n\nReturns how often agents recommended your company over each tracked competitor: wins, losses, ties, and win rate per competitor plus a combined record. Calculated from the most recent attempts across all Agent Preference evals, up to `limit`; `truncated` reports whether older attempts were left out."
+    },
+    {
+      name: "agent-preference-v2-agent-preference-evals-list",
+      description: `List Evals
+
+Returns all active Agent Preference evals owned by the organization.`
+    },
+    {
+      name: "agent-preference-v2-agent-preference-evals-create",
+      description: "Create Eval\n\nCreates a head-to-head comparison between your company and one tracked competitor. Each prompt asks an agent to choose, and a fixed judge records which company it recommended. Creating the eval does not start a run; pass the returned `id` as `eval_id` to `POST /v2/eval-runs`."
+    },
+    {
+      name: "agent-preference-v2-agent-preference-evals-retrieve",
+      description: `Retrieve Eval
+
+Returns one Agent Preference eval.`
+    },
+    {
+      name: "agent-preference-v2-agent-preference-evals-update",
+      description: "Update Eval\n\nUpdates an Agent Preference eval. Omitted fields remain unchanged, an empty `agent` or `tags` array clears that collection, and `persona: null` clears the saved persona. The competitor and the judge that decides the comparison cannot be changed."
+    },
+    {
+      name: "agent-preference-v2-agent-preference-evals-delete",
+      description: `Delete Eval
+
+Permanently deletes an Agent Preference eval and returns its last saved state.`
+    },
+    {
+      name: "agent-preference-v2-agent-preference-results-list",
+      description: `List Results
+
+Returns recorded attempts for an Agent Preference eval, newest first, each with whether your company won, lost, or tied against the competitor.`
+    },
     {
       name: "agents-v2-agents-list",
       description: `List Agents
@@ -64363,7 +65532,7 @@ http_headers = { "lightsage-api-key-auth" = "YOUR_LIGHTSAGE_API_KEY_AUTH" }`;
         <h1>Instructions</h1>
         <p>One-click installation for Claude Desktop users</p>
         <div class="instruction-item">
-          <a href="https://github.com/lightsagehq/mcp/releases/download/v0.4.5/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
+          <a href="https://github.com/lightsagehq/mcp/releases/download/v0.4.6/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
             \uD83D\uDCE5 Download MCP Bundle
           </a>
         </div>
@@ -67241,7 +68410,7 @@ var routes = buildRouteMap({
 var app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.4.5"
+    currentVersion: "0.4.6"
   }
 });
 run(app, process3.argv.slice(2), buildContext(process3));
@@ -67249,5 +68418,5 @@ export {
   app
 };
 
-//# debugId=243CF3FE60B2C5ED64756E2164756E21
+//# debugId=59EB2957DA1B9F9B64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map