@fern-api/fdr-sdk 1.2.114-2dfb9e1373 → 1.2.114-5ab18f50f0

package/dist/js/client/FdrClient.mjs

@@ -5325,103 +5325,253 @@ function createGitClient(options) {
   return createORPCClient16(link);
 }
 
-// src/orpc-client/pdf-export/client.ts
+// src/orpc-client/mcp-hosting/client.ts
 import { createORPCClient as createORPCClient17 } from "@orpc/client";
 import { OpenAPILink as OpenAPILink17 } from "@orpc/openapi-client/fetch";
 
-// src/orpc-client/pdf-export/contract.ts
+// src/orpc-client/mcp-hosting/contract.ts
 import { oc as oc15 } from "@orpc/contract";
 import * as z25 from "zod";
-var PdfExportScopeSchema = z25.object({
-  pageSlugs: z25.array(z25.string())
-});
-var PdfExportOptionsV1Schema = z25.object({
-  coverTitle: z25.string().nullish(),
-  coverSubtitle: z25.string().nullish(),
-  hideCoverFooter: z25.boolean().nullish(),
-  headerLeftTemplate: z25.string().nullish(),
-  headerRightTemplate: z25.string().nullish(),
-  footerLeftTemplate: z25.string().nullish(),
-  footerRightTemplate: z25.string().nullish(),
-  scope: PdfExportScopeSchema.nullish(),
-  hideCover: z25.boolean().nullish(),
-  hideToc: z25.boolean().nullish()
-});
-var PdfExportOptionsSchema = z25.discriminatedUnion("version", [
-  z25.object({ version: z25.literal("v1") }).merge(PdfExportOptionsV1Schema)
+var McpPathSegmentSchema = z25.string().min(1).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var McpDeploymentStatusSchema = z25.enum(["PUBLISHING", "SUCCEEDED", "FAILED"]);
+var McpAuthSchemeSchema = z25.discriminatedUnion("type", [
+  z25.object({ type: z25.literal("bearer") }),
+  z25.object({
+    type: z25.literal("apiKey"),
+    paramName: z25.string().min(1),
+    in: z25.enum(["header", "query", "cookie"])
+  }),
+  z25.object({ type: z25.literal("basic") })
 ]);
-var PdfExportTaskStatusSchema = z25.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED"]);
-var PdfExportTaskSchema = z25.object({
-  id: z25.string(),
-  orgId: z25.string(),
-  docsUrl: z25.string(),
-  productId: z25.string().nullish(),
-  versionId: z25.string().nullish(),
-  requesterName: z25.string().nullish(),
-  notifyEmails: z25.array(z25.string()).nullish(),
-  status: PdfExportTaskStatusSchema,
-  options: PdfExportOptionsSchema.nullish(),
-  createdAt: z25.string(),
-  startedAt: z25.string().nullish(),
-  completedAt: z25.string().nullish(),
-  fileName: z25.string().nullish(),
-  sizeBytes: z25.number().nullish(),
-  errorMessage: z25.string().nullish()
+var McpMetadataSchema = z25.object({
+  name: z25.string().min(1),
+  toolsets: z25.record(z25.string(), z25.array(z25.string())),
+  toolsetMetadata: z25.array(
+    z25.object({
+      name: z25.string(),
+      title: z25.string(),
+      description: z25.string(),
+      toolCount: z25.number().int().nonnegative()
+    }).strict()
+  ),
+  auth: z25.object({
+    schemes: z25.array(McpAuthSchemeSchema),
+    required: z25.boolean()
+  }).strict(),
+  skippedTools: z25.array(z25.object({ name: z25.string(), reason: z25.string() }).strict()),
+  environmentVariables: z25.array(
+    z25.object({
+      name: z25.string(),
+      description: z25.string(),
+      required: z25.boolean()
+    }).strict()
+  ),
+  baseUrl: z25.string().url(),
+  followRedirects: z25.boolean(),
+  maxRedirects: z25.number().int().nonnegative(),
+  allowedRedirectHosts: z25.array(z25.string())
+}).passthrough();
+var McpModuleSchema = z25.object({
+  name: z25.string().regex(/^[A-Za-z0-9._/-]+$/),
+  hash: z25.string().regex(/^[0-9a-f]{64}$/),
+  contentType: z25.string().min(1)
+}).strict();
+var McpGitInputSchema = z25.object({
+  repoUrl: z25.string(),
+  branch: z25.string(),
+  commitSha: z25.string().optional()
+}).strict();
+var DeployMcpServerInputSchema = z25.object({
+  orgId: McpPathSegmentSchema,
+  slug: McpPathSegmentSchema,
+  mainModule: z25.string().min(1),
+  compatibilityDate: z25.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  compatibilityFlags: z25.array(z25.string()),
+  // Bounded so a single deploy request cannot fan out unbounded parallel
+  // CAS lookups and S3 reads. Generated MCP workers are 1-2 modules;
+  // 20 leaves room for wasm/sourcemap/chunk splitting.
+  modules: z25.array(McpModuleSchema).min(1).max(20),
+  metadata: McpMetadataSchema,
+  // Everything else in this schema is bounded; keep the opaque config
+  // blob bounded too so it cannot balloon the JSONB row.
+  config: z25.unknown().optional().refine((value) => value === void 0 || (JSON.stringify(value)?.length ?? 0) <= 65536, {
+    message: "config must be at most 64KB serialized"
+  }),
+  generatorName: z25.string().min(1),
+  generatorVersion: z25.string().min(1),
+  cliVersion: z25.string().optional(),
+  git: McpGitInputSchema.optional()
+}).strict().superRefine((input, ctx) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const module of input.modules) {
+    if (names.has(module.name)) {
+      ctx.addIssue({
+        code: z25.ZodIssueCode.custom,
+        path: ["modules"],
+        message: `duplicate module name: ${module.name}`
+      });
+    }
+    names.add(module.name);
+  }
+  if (!names.has(input.mainModule)) {
+    ctx.addIssue({
+      code: z25.ZodIssueCode.custom,
+      path: ["mainModule"],
+      message: `mainModule ${input.mainModule} is not among the submitted modules`
+    });
+  }
 });
-var ListPdfExportTasksResponseSchema = z25.object({
-  tasks: z25.array(PdfExportTaskSchema)
+var GetMcpServerInputSchema = z25.object({
+  orgId: McpPathSegmentSchema,
+  slug: McpPathSegmentSchema
 });
-var PdfExportDownloadResponseSchema = z25.object({
-  downloadUrl: z25.string(),
-  fileName: z25.string(),
-  sizeBytes: z25.number()
+var ListMcpServersInputSchema = z25.object({
+  orgId: z25.string()
 });
-var CreatePdfExportTaskInputSchema = z25.object({
+var ListMcpDeploymentsInputSchema = GetMcpServerInputSchema;
+var DeleteMcpServerInputSchema = GetMcpServerInputSchema;
+var McpDeploymentSummarySchema = z25.object({
+  id: z25.string(),
+  status: McpDeploymentStatusSchema,
+  /** True when this deployment is the one the server currently serves. */
+  isActive: z25.boolean(),
+  generatorVersion: z25.string(),
+  createdAt: z25.string(),
+  createdBy: z25.string().nullish(),
+  error: z25.object({ name: z25.string(), message: z25.string() }).nullish()
+});
+var McpServerSchema = z25.object({
+  id: z25.string(),
   orgId: z25.string(),
-  docsUrl: z25.string(),
-  productId: z25.string().nullish(),
-  versionId: z25.string().nullish(),
-  requesterName: z25.string().nullish(),
+  slug: z25.string(),
+  /** The server is serving iff this is set; it names the serving deployment. */
+  activeDeploymentId: z25.string().nullish(),
+  /** Most recent publication attempt — how the last deploy went. */
+  latestDeployment: McpDeploymentSummarySchema.nullish(),
+  url: z25.string().url(),
+  createdAt: z25.string(),
+  updatedAt: z25.string()
+});
+var ListMcpServersResponseSchema = z25.object({ servers: z25.array(McpServerSchema) });
+var ListMcpDeploymentsResponseSchema = z25.object({ deployments: z25.array(McpDeploymentSummarySchema) });
+var mcpHostingContract = {
+  deploy: oc15.route({ method: "POST", path: "/deploy" }).input(DeployMcpServerInputSchema).output(McpServerSchema),
+  getServer: oc15.route({ method: "GET", path: "/servers/{slug}" }).input(GetMcpServerInputSchema).output(McpServerSchema),
+  listServers: oc15.route({ method: "GET", path: "/servers" }).input(ListMcpServersInputSchema).output(ListMcpServersResponseSchema),
+  listDeployments: oc15.route({ method: "GET", path: "/servers/{slug}/deployments" }).input(ListMcpDeploymentsInputSchema).output(ListMcpDeploymentsResponseSchema),
+  deleteServer: oc15.route({ method: "DELETE", path: "/servers/{slug}" }).input(DeleteMcpServerInputSchema)
+};
+
+// src/orpc-client/mcp-hosting/client.ts
+function createMcpHostingClient(options) {
+  const link = new OpenAPILink17(mcpHostingContract, {
+    url: `${options.baseUrl}/mcp-hosting`,
+    headers: () => ({
+      Authorization: `Bearer ${options.token}`,
+      ...options.headers
+    }),
+    ...options.fetch != null ? { fetch: options.fetch } : {}
+  });
+  return createORPCClient17(link);
+}
+
+// src/orpc-client/pdf-export/client.ts
+import { createORPCClient as createORPCClient18 } from "@orpc/client";
+import { OpenAPILink as OpenAPILink18 } from "@orpc/openapi-client/fetch";
+
+// src/orpc-client/pdf-export/contract.ts
+import { oc as oc16 } from "@orpc/contract";
+import * as z26 from "zod";
+var PdfExportScopeSchema = z26.object({
+  pageSlugs: z26.array(z26.string())
+});
+var PdfExportOptionsV1Schema = z26.object({
+  coverTitle: z26.string().nullish(),
+  coverSubtitle: z26.string().nullish(),
+  hideCoverFooter: z26.boolean().nullish(),
+  headerLeftTemplate: z26.string().nullish(),
+  headerRightTemplate: z26.string().nullish(),
+  footerLeftTemplate: z26.string().nullish(),
+  footerRightTemplate: z26.string().nullish(),
+  scope: PdfExportScopeSchema.nullish(),
+  hideCover: z26.boolean().nullish(),
+  hideToc: z26.boolean().nullish()
+});
+var PdfExportOptionsSchema = z26.discriminatedUnion("version", [
+  z26.object({ version: z26.literal("v1") }).merge(PdfExportOptionsV1Schema)
+]);
+var PdfExportTaskStatusSchema = z26.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED"]);
+var PdfExportTaskSchema = z26.object({
+  id: z26.string(),
+  orgId: z26.string(),
+  docsUrl: z26.string(),
+  productId: z26.string().nullish(),
+  versionId: z26.string().nullish(),
+  requesterName: z26.string().nullish(),
+  notifyEmails: z26.array(z26.string()).nullish(),
+  status: PdfExportTaskStatusSchema,
+  options: PdfExportOptionsSchema.nullish(),
+  createdAt: z26.string(),
+  startedAt: z26.string().nullish(),
+  completedAt: z26.string().nullish(),
+  fileName: z26.string().nullish(),
+  sizeBytes: z26.number().nullish(),
+  errorMessage: z26.string().nullish()
+});
+var ListPdfExportTasksResponseSchema = z26.object({
+  tasks: z26.array(PdfExportTaskSchema)
+});
+var PdfExportDownloadResponseSchema = z26.object({
+  downloadUrl: z26.string(),
+  fileName: z26.string(),
+  sizeBytes: z26.number()
+});
+var CreatePdfExportTaskInputSchema = z26.object({
+  orgId: z26.string(),
+  docsUrl: z26.string(),
+  productId: z26.string().nullish(),
+  versionId: z26.string().nullish(),
+  requesterName: z26.string().nullish(),
   options: PdfExportOptionsSchema.nullish()
 });
-var ListPdfExportTasksInputSchema = z25.object({
-  orgId: z25.string(),
-  docsUrl: z25.string(),
-  limit: z25.coerce.number().nullish()
+var ListPdfExportTasksInputSchema = z26.object({
+  orgId: z26.string(),
+  docsUrl: z26.string(),
+  limit: z26.coerce.number().nullish()
 });
-var GetPdfExportTaskInputSchema = z25.object({
-  taskId: z25.string()
+var GetPdfExportTaskInputSchema = z26.object({
+  taskId: z26.string()
 });
-var UpdatePdfExportTaskInputSchema = z25.object({
-  taskId: z25.string(),
+var UpdatePdfExportTaskInputSchema = z26.object({
+  taskId: z26.string(),
   status: PdfExportTaskStatusSchema,
-  startedAt: z25.string().nullish(),
-  completedAt: z25.string().nullish(),
-  s3Key: z25.string().nullish(),
-  fileName: z25.string().nullish(),
-  sizeBytes: z25.number().nullish(),
-  errorMessage: z25.string().nullish()
+  startedAt: z26.string().nullish(),
+  completedAt: z26.string().nullish(),
+  s3Key: z26.string().nullish(),
+  fileName: z26.string().nullish(),
+  sizeBytes: z26.number().nullish(),
+  errorMessage: z26.string().nullish()
 });
-var GetPdfExportDownloadUrlInputSchema = z25.object({
-  taskId: z25.string()
+var GetPdfExportDownloadUrlInputSchema = z26.object({
+  taskId: z26.string()
 });
-var CleanupPdfExportsResponseSchema = z25.object({
-  expiredTasksDeleted: z25.number(),
-  s3ObjectsDeleted: z25.number(),
-  timedOutTasksFailed: z25.number()
+var CleanupPdfExportsResponseSchema = z26.object({
+  expiredTasksDeleted: z26.number(),
+  s3ObjectsDeleted: z26.number(),
+  timedOutTasksFailed: z26.number()
 });
 var pdfExportContract = {
-  createTask: oc15.route({ method: "POST", path: "/task" }).input(CreatePdfExportTaskInputSchema).output(PdfExportTaskSchema),
-  listTasks: oc15.route({ method: "GET", path: "/tasks" }).input(ListPdfExportTasksInputSchema).output(ListPdfExportTasksResponseSchema),
-  getTask: oc15.route({ method: "GET", path: "/task/{taskId}" }).input(GetPdfExportTaskInputSchema).output(PdfExportTaskSchema),
-  updateTask: oc15.route({ method: "POST", path: "/task/{taskId}" }).input(UpdatePdfExportTaskInputSchema).output(PdfExportTaskSchema),
-  getDownloadUrl: oc15.route({ method: "GET", path: "/task/{taskId}/download-url" }).input(GetPdfExportDownloadUrlInputSchema).output(PdfExportDownloadResponseSchema),
-  cleanup: oc15.route({ method: "POST", path: "/cleanup" }).output(CleanupPdfExportsResponseSchema)
+  createTask: oc16.route({ method: "POST", path: "/task" }).input(CreatePdfExportTaskInputSchema).output(PdfExportTaskSchema),
+  listTasks: oc16.route({ method: "GET", path: "/tasks" }).input(ListPdfExportTasksInputSchema).output(ListPdfExportTasksResponseSchema),
+  getTask: oc16.route({ method: "GET", path: "/task/{taskId}" }).input(GetPdfExportTaskInputSchema).output(PdfExportTaskSchema),
+  updateTask: oc16.route({ method: "POST", path: "/task/{taskId}" }).input(UpdatePdfExportTaskInputSchema).output(PdfExportTaskSchema),
+  getDownloadUrl: oc16.route({ method: "GET", path: "/task/{taskId}/download-url" }).input(GetPdfExportDownloadUrlInputSchema).output(PdfExportDownloadResponseSchema),
+  cleanup: oc16.route({ method: "POST", path: "/cleanup" }).output(CleanupPdfExportsResponseSchema)
 };
 
 // src/orpc-client/pdf-export/client.ts
 function createPdfExportClient(options) {
-  const link = new OpenAPILink17(pdfExportContract, {
+  const link = new OpenAPILink18(pdfExportContract, {
     url: `${options.baseUrl}/pdf-export`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5429,17 +5579,17 @@ function createPdfExportClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient17(link);
+  return createORPCClient18(link);
 }
 
 // src/orpc-client/sdks/client.ts
-import { createORPCClient as createORPCClient18 } from "@orpc/client";
-import { OpenAPILink as OpenAPILink18 } from "@orpc/openapi-client/fetch";
+import { createORPCClient as createORPCClient19 } from "@orpc/client";
+import { OpenAPILink as OpenAPILink19 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/sdks/contract.ts
-import { oc as oc16 } from "@orpc/contract";
-import * as z26 from "zod";
-var LanguageEnumSchema = z26.enum([
+import { oc as oc17 } from "@orpc/contract";
+import * as z27 from "zod";
+var LanguageEnumSchema = z27.enum([
   "Go",
   "TypeScript",
   "Java",
@@ -5450,23 +5600,23 @@ var LanguageEnumSchema = z26.enum([
   "Swift",
   "Rust"
 ]);
-var VersionBumpEnumSchema = z26.enum(["MAJOR", "MINOR", "PATCH"]);
-var ComputeSemanticVersionInputSchema = z26.object({
-  package: z26.string(),
+var VersionBumpEnumSchema = z27.enum(["MAJOR", "MINOR", "PATCH"]);
+var ComputeSemanticVersionInputSchema = z27.object({
+  package: z27.string(),
   language: LanguageEnumSchema,
-  githubRepository: z26.string().nullish()
+  githubRepository: z27.string().nullish()
 });
-var ComputeSemanticVersionOutputSchema = z26.object({
-  version: z26.string(),
+var ComputeSemanticVersionOutputSchema = z27.object({
+  version: z27.string(),
   bump: VersionBumpEnumSchema
 });
 var sdksContract = {
-  computeSemanticVersion: oc16.route({ method: "POST", path: "/semantic-version/compute" }).input(ComputeSemanticVersionInputSchema).output(ComputeSemanticVersionOutputSchema)
+  computeSemanticVersion: oc17.route({ method: "POST", path: "/semantic-version/compute" }).input(ComputeSemanticVersionInputSchema).output(ComputeSemanticVersionOutputSchema)
 };
 
 // src/orpc-client/sdks/client.ts
 function createSdksClient(options) {
-  const link = new OpenAPILink18(sdksContract, {
+  const link = new OpenAPILink19(sdksContract, {
     url: `${options.baseUrl}/sdks`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5474,50 +5624,50 @@ function createSdksClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient18(link);
+  return createORPCClient19(link);
 }
 
 // src/orpc-client/slugs/client.ts
-import { createORPCClient as createORPCClient19 } from "@orpc/client";
-import { OpenAPILink as OpenAPILink19 } from "@orpc/openapi-client/fetch";
+import { createORPCClient as createORPCClient20 } from "@orpc/client";
+import { OpenAPILink as OpenAPILink20 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/slugs/contract.ts
-import { oc as oc17 } from "@orpc/contract";
-import * as z27 from "zod";
-var SlugsInputSchema = z27.object({
-  domain: z27.string(),
-  basepath: z27.string().optional().default("")
-});
-var SlugEntrySchema = z27.object({
-  orgId: z27.string(),
-  domain: z27.string(),
-  basepath: z27.string(),
-  slug: z27.string(),
-  lastUpdated: z27.string()
-});
-var MarkdownEntrySchema = z27.object({
-  orgId: z27.string(),
-  domain: z27.string(),
-  basepath: z27.string(),
-  pageId: z27.string(),
-  slug: z27.string(),
-  hash: z27.string(),
-  lastUpdated: z27.string()
-});
-var GetSlugEntriesResponseSchema = z27.object({
-  entries: z27.array(SlugEntrySchema)
-});
-var GetMarkdownEntriesResponseSchema = z27.object({
-  entries: z27.array(MarkdownEntrySchema)
+import { oc as oc18 } from "@orpc/contract";
+import * as z28 from "zod";
+var SlugsInputSchema = z28.object({
+  domain: z28.string(),
+  basepath: z28.string().optional().default("")
+});
+var SlugEntrySchema = z28.object({
+  orgId: z28.string(),
+  domain: z28.string(),
+  basepath: z28.string(),
+  slug: z28.string(),
+  lastUpdated: z28.string()
+});
+var MarkdownEntrySchema = z28.object({
+  orgId: z28.string(),
+  domain: z28.string(),
+  basepath: z28.string(),
+  pageId: z28.string(),
+  slug: z28.string(),
+  hash: z28.string(),
+  lastUpdated: z28.string()
+});
+var GetSlugEntriesResponseSchema = z28.object({
+  entries: z28.array(SlugEntrySchema)
+});
+var GetMarkdownEntriesResponseSchema = z28.object({
+  entries: z28.array(MarkdownEntrySchema)
 });
 var slugsContract = {
-  getSlugEntries: oc17.route({ method: "POST", path: "/slugs" }).input(SlugsInputSchema).output(GetSlugEntriesResponseSchema),
-  getMarkdownEntries: oc17.route({ method: "POST", path: "/markdowns" }).input(SlugsInputSchema).output(GetMarkdownEntriesResponseSchema)
+  getSlugEntries: oc18.route({ method: "POST", path: "/slugs" }).input(SlugsInputSchema).output(GetSlugEntriesResponseSchema),
+  getMarkdownEntries: oc18.route({ method: "POST", path: "/markdowns" }).input(SlugsInputSchema).output(GetMarkdownEntriesResponseSchema)
 };
 
 // src/orpc-client/slugs/client.ts
 function createSlugsClient(options) {
-  const link = new OpenAPILink19(slugsContract, {
+  const link = new OpenAPILink20(slugsContract, {
     url: `${options.baseUrl.replace(/\/+$/, "")}/slugs`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5525,118 +5675,118 @@ function createSlugsClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient19(link);
+  return createORPCClient20(link);
 }
 
 // src/orpc-client/snippets/client.ts
-import { createORPCClient as createORPCClient20 } from "@orpc/client";
-import { OpenAPILink as OpenAPILink20 } from "@orpc/openapi-client/fetch";
+import { createORPCClient as createORPCClient21 } from "@orpc/client";
+import { OpenAPILink as OpenAPILink21 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/snippets/contract.ts
-import { oc as oc18 } from "@orpc/contract";
-import * as z28 from "zod";
-var TypeScriptSdkSchema = z28.object({ package: z28.string(), version: z28.string() });
-var PythonSdkSchema = z28.object({ package: z28.string(), version: z28.string() });
-var GoSdkSchema = z28.object({ githubRepo: z28.string(), version: z28.string() });
-var RubySdkSchema = z28.object({ gem: z28.string(), version: z28.string() });
-var JavaSdkSchema = z28.object({ group: z28.string(), artifact: z28.string(), version: z28.string() });
-var CsharpSdkSchema = z28.object({ package: z28.string(), version: z28.string() });
-var BaseSnippetCreateSchema = z28.object({
+import { oc as oc19 } from "@orpc/contract";
+import * as z29 from "zod";
+var TypeScriptSdkSchema = z29.object({ package: z29.string(), version: z29.string() });
+var PythonSdkSchema = z29.object({ package: z29.string(), version: z29.string() });
+var GoSdkSchema = z29.object({ githubRepo: z29.string(), version: z29.string() });
+var RubySdkSchema = z29.object({ gem: z29.string(), version: z29.string() });
+var JavaSdkSchema = z29.object({ group: z29.string(), artifact: z29.string(), version: z29.string() });
+var CsharpSdkSchema = z29.object({ package: z29.string(), version: z29.string() });
+var BaseSnippetCreateSchema = z29.object({
   endpoint: EndpointIdentifierSchema,
-  exampleIdentifier: z28.string().nullish()
+  exampleIdentifier: z29.string().nullish()
 });
-var SdkSnippetsCreateSchema = z28.discriminatedUnion("type", [
-  z28.object({
-    type: z28.literal("typescript"),
+var SdkSnippetsCreateSchema = z29.discriminatedUnion("type", [
+  z29.object({
+    type: z29.literal("typescript"),
     sdk: TypeScriptSdkSchema,
-    snippets: z28.array(BaseSnippetCreateSchema.extend({ snippet: z28.object({ client: z28.string() }) }))
+    snippets: z29.array(BaseSnippetCreateSchema.extend({ snippet: z29.object({ client: z29.string() }) }))
   }),
-  z28.object({
-    type: z28.literal("python"),
+  z29.object({
+    type: z29.literal("python"),
     sdk: PythonSdkSchema,
-    snippets: z28.array(
+    snippets: z29.array(
       BaseSnippetCreateSchema.extend({
-        snippet: z28.object({ async_client: z28.string(), sync_client: z28.string() })
+        snippet: z29.object({ async_client: z29.string(), sync_client: z29.string() })
       })
     )
   }),
-  z28.object({
-    type: z28.literal("go"),
+  z29.object({
+    type: z29.literal("go"),
     sdk: GoSdkSchema,
-    snippets: z28.array(BaseSnippetCreateSchema.extend({ snippet: z28.object({ client: z28.string() }) }))
+    snippets: z29.array(BaseSnippetCreateSchema.extend({ snippet: z29.object({ client: z29.string() }) }))
   }),
-  z28.object({
-    type: z28.literal("java"),
+  z29.object({
+    type: z29.literal("java"),
     sdk: JavaSdkSchema,
-    snippets: z28.array(
+    snippets: z29.array(
       BaseSnippetCreateSchema.extend({
-        snippet: z28.object({ async_client: z28.string(), sync_client: z28.string() })
+        snippet: z29.object({ async_client: z29.string(), sync_client: z29.string() })
       })
     )
   }),
-  z28.object({
-    type: z28.literal("ruby"),
+  z29.object({
+    type: z29.literal("ruby"),
     sdk: RubySdkSchema,
-    snippets: z28.array(BaseSnippetCreateSchema.extend({ snippet: z28.object({ client: z28.string() }) }))
+    snippets: z29.array(BaseSnippetCreateSchema.extend({ snippet: z29.object({ client: z29.string() }) }))
   }),
-  z28.object({
-    type: z28.literal("csharp"),
+  z29.object({
+    type: z29.literal("csharp"),
     sdk: CsharpSdkSchema,
-    snippets: z28.array(BaseSnippetCreateSchema.extend({ snippet: z28.object({ client: z28.string() }) }))
+    snippets: z29.array(BaseSnippetCreateSchema.extend({ snippet: z29.object({ client: z29.string() }) }))
   })
 ]);
 var snippetsFactoryContract = {
-  createSnippetsForSdk: oc18.route({ method: "POST", path: "/create" }).input(
-    z28.object({
-      orgId: z28.string(),
-      apiId: z28.string(),
+  createSnippetsForSdk: oc19.route({ method: "POST", path: "/create" }).input(
+    z29.object({
+      orgId: z29.string(),
+      apiId: z29.string(),
       snippets: SdkSnippetsCreateSchema
     })
   )
 };
-var ParameterPayloadSchema = z28.object({
-  name: z28.string(),
-  value: z28.unknown()
+var ParameterPayloadSchema = z29.object({
+  name: z29.string(),
+  value: z29.unknown()
 });
-var AuthPayloadSchema = z28.discriminatedUnion("type", [
-  z28.object({ type: z28.literal("bearer"), token: z28.string() }),
-  z28.object({ type: z28.literal("basic"), username: z28.string(), password: z28.string() })
+var AuthPayloadSchema = z29.discriminatedUnion("type", [
+  z29.object({ type: z29.literal("bearer"), token: z29.string() }),
+  z29.object({ type: z29.literal("basic"), username: z29.string(), password: z29.string() })
 ]);
-var CustomSnippetPayloadSchema = z28.object({
-  headers: z28.array(ParameterPayloadSchema).nullish(),
-  pathParameters: z28.array(ParameterPayloadSchema).nullish(),
-  queryParameters: z28.array(ParameterPayloadSchema).nullish(),
-  requestBody: z28.unknown().nullish(),
+var CustomSnippetPayloadSchema = z29.object({
+  headers: z29.array(ParameterPayloadSchema).nullish(),
+  pathParameters: z29.array(ParameterPayloadSchema).nullish(),
+  queryParameters: z29.array(ParameterPayloadSchema).nullish(),
+  requestBody: z29.unknown().nullish(),
   auth: AuthPayloadSchema.nullish()
 });
 var snippetsContract = {
-  get: oc18.route({ method: "POST", path: "/" }).input(
-    z28.object({
-      orgId: z28.string().nullish(),
-      apiId: z28.string().nullish(),
-      sdks: z28.array(SdkRequestSchema).nullish(),
+  get: oc19.route({ method: "POST", path: "/" }).input(
+    z29.object({
+      orgId: z29.string().nullish(),
+      apiId: z29.string().nullish(),
+      sdks: z29.array(SdkRequestSchema).nullish(),
       endpoint: EndpointIdentifierSchema,
-      exampleIdentifier: z28.string().nullish(),
+      exampleIdentifier: z29.string().nullish(),
       payload: CustomSnippetPayloadSchema.nullish()
     })
-  ).output(z28.array(z28.unknown())),
-  load: oc18.route({ method: "POST", path: "/load" }).input(
-    z28.object({
-      orgId: z28.string().nullish(),
-      apiId: z28.string().nullish(),
-      sdks: z28.array(SdkRequestSchema).nullish()
+  ).output(z29.array(z29.unknown())),
+  load: oc19.route({ method: "POST", path: "/load" }).input(
+    z29.object({
+      orgId: z29.string().nullish(),
+      apiId: z29.string().nullish(),
+      sdks: z29.array(SdkRequestSchema).nullish()
     })
   ).output(
-    z28.object({
-      next: z28.number().nullish(),
-      snippets: z28.record(z28.string(), z28.unknown())
+    z29.object({
+      next: z29.number().nullish(),
+      snippets: z29.record(z29.string(), z29.unknown())
     })
   )
 };
 
 // src/orpc-client/snippets/client.ts
 function createSnippetsFactoryClient(options) {
-  const link = new OpenAPILink20(snippetsFactoryContract, {
+  const link = new OpenAPILink21(snippetsFactoryContract, {
     url: `${options.baseUrl}/snippets`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5644,10 +5794,10 @@ function createSnippetsFactoryClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient20(link);
+  return createORPCClient21(link);
 }
 function createSnippetsClient(options) {
-  const link = new OpenAPILink20(snippetsContract, {
+  const link = new OpenAPILink21(snippetsContract, {
     url: `${options.baseUrl}/snippets`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5655,63 +5805,63 @@ function createSnippetsClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient20(link);
+  return createORPCClient21(link);
 }
 
 // src/orpc-client/templates/client.ts
-import { createORPCClient as createORPCClient21 } from "@orpc/client";
-import { OpenAPILink as OpenAPILink21 } from "@orpc/openapi-client/fetch";
+import { createORPCClient as createORPCClient22 } from "@orpc/client";
+import { OpenAPILink as OpenAPILink22 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/templates/contract.ts
-import { oc as oc19 } from "@orpc/contract";
-import * as z29 from "zod";
-var SnippetRegistryEntrySchema = z29.object({
+import { oc as oc20 } from "@orpc/contract";
+import * as z30 from "zod";
+var SnippetRegistryEntrySchema = z30.object({
   sdk: SdkSchema,
-  endpointId: z29.object({
-    path: z29.string(),
+  endpointId: z30.object({
+    path: z30.string(),
     method: HttpMethodSchema,
-    identifierOverride: z29.string().nullish()
+    identifierOverride: z30.string().nullish()
   }),
-  snippetTemplate: z29.object({
-    type: z29.literal("v1"),
-    functionInvocation: z29.unknown(),
-    clientInstantiation: z29.string()
+  snippetTemplate: z30.object({
+    type: z30.literal("v1"),
+    functionInvocation: z30.unknown(),
+    clientInstantiation: z30.string()
   }),
-  additionalTemplates: z29.record(z29.string(), z29.unknown()).nullish()
+  additionalTemplates: z30.record(z30.string(), z30.unknown()).nullish()
 });
-var RegisterInputSchema = z29.object({
-  orgId: z29.string(),
-  apiId: z29.string(),
-  apiDefinitionId: z29.string(),
+var RegisterInputSchema = z30.object({
+  orgId: z30.string(),
+  apiId: z30.string(),
+  apiDefinitionId: z30.string(),
   snippet: SnippetRegistryEntrySchema
 });
-var RegisterBatchInputSchema = z29.object({
-  orgId: z29.string(),
-  apiId: z29.string(),
-  apiDefinitionId: z29.string(),
-  snippets: z29.array(SnippetRegistryEntrySchema)
+var RegisterBatchInputSchema = z30.object({
+  orgId: z30.string(),
+  apiId: z30.string(),
+  apiDefinitionId: z30.string(),
+  snippets: z30.array(SnippetRegistryEntrySchema)
 });
-var GetInputSchema = z29.object({
-  orgId: z29.string(),
-  apiId: z29.string(),
+var GetInputSchema = z30.object({
+  orgId: z30.string(),
+  apiId: z30.string(),
   sdk: SdkSchema,
-  endpointId: z29.object({
-    path: z29.string(),
+  endpointId: z30.object({
+    path: z30.string(),
     method: HttpMethodSchema,
-    identifierOverride: z29.string().nullish()
+    identifierOverride: z30.string().nullish()
   })
 });
-var EndpointSnippetTemplateSchema = z29.record(z29.string(), z29.unknown());
+var EndpointSnippetTemplateSchema = z30.record(z30.string(), z30.unknown());
 var templatesContract = {
-  register: oc19.route({ method: "POST", path: "/register" }).input(RegisterInputSchema),
-  registerBatch: oc19.route({ method: "POST", path: "/register/batch" }).input(RegisterBatchInputSchema),
-  get: oc19.route({ method: "POST", path: "/get" }).input(GetInputSchema).output(EndpointSnippetTemplateSchema)
+  register: oc20.route({ method: "POST", path: "/register" }).input(RegisterInputSchema),
+  registerBatch: oc20.route({ method: "POST", path: "/register/batch" }).input(RegisterBatchInputSchema),
+  get: oc20.route({ method: "POST", path: "/get" }).input(GetInputSchema).output(EndpointSnippetTemplateSchema)
 };
 
 // src/orpc-client/templates/client.ts
 function createTemplatesClient(options) {
   const baseUrl = options.baseUrl.replace(/\/+$/, "");
-  const link = new OpenAPILink21(templatesContract, {
+  const link = new OpenAPILink22(templatesContract, {
     url: `${baseUrl}/snippet-template`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5719,36 +5869,36 @@ function createTemplatesClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient21(link);
+  return createORPCClient22(link);
 }
 
 // src/orpc-client/tokens/client.ts
-import { createORPCClient as createORPCClient22 } from "@orpc/client";
-import { OpenAPILink as OpenAPILink22 } from "@orpc/openapi-client/fetch";
+import { createORPCClient as createORPCClient23 } from "@orpc/client";
+import { OpenAPILink as OpenAPILink23 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/tokens/contract.ts
-import { oc as oc20 } from "@orpc/contract";
-import * as z30 from "zod";
-var GenerateTokenInputSchema = z30.object({
-  orgId: z30.string(),
-  scope: z30.string()
+import { oc as oc21 } from "@orpc/contract";
+import * as z31 from "zod";
+var GenerateTokenInputSchema = z31.object({
+  orgId: z31.string(),
+  scope: z31.string()
 });
-var RevokeTokenInputSchema = z30.object({
-  orgId: z30.string(),
-  tokenId: z30.string()
+var RevokeTokenInputSchema = z31.object({
+  orgId: z31.string(),
+  tokenId: z31.string()
 });
-var GenerateTokenOutputSchema = z30.object({
-  token: z30.string(),
-  id: z30.string()
+var GenerateTokenOutputSchema = z31.object({
+  token: z31.string(),
+  id: z31.string()
 });
 var tokensContract = {
-  generate: oc20.route({ method: "POST", path: "/generate" }).input(GenerateTokenInputSchema).output(GenerateTokenOutputSchema),
-  revoke: oc20.route({ method: "POST", path: "/revoke" }).input(RevokeTokenInputSchema)
+  generate: oc21.route({ method: "POST", path: "/generate" }).input(GenerateTokenInputSchema).output(GenerateTokenOutputSchema),
+  revoke: oc21.route({ method: "POST", path: "/revoke" }).input(RevokeTokenInputSchema)
 };
 
 // src/orpc-client/tokens/client.ts
 function createTokensClient(options) {
-  const link = new OpenAPILink22(tokensContract, {
+  const link = new OpenAPILink23(tokensContract, {
     url: `${options.baseUrl}/tokens`,
     headers: () => ({
       Authorization: `Bearer ${options.token}`,
@@ -5756,7 +5906,7 @@ function createTokensClient(options) {
     }),
     ...options.fetch != null ? { fetch: options.fetch } : {}
   });
-  return createORPCClient22(link);
+  return createORPCClient23(link);
 }
 
 // src/orpc-client/client.ts
@@ -5780,6 +5930,7 @@ function createFdrORPCClient(options) {
       versions: createGeneratorVersionsClient(normalizedOptions)
     },
     git: createGitClient(normalizedOptions),
+    mcpHosting: createMcpHostingClient(normalizedOptions),
     slugs: createSlugsClient(normalizedOptions),
     pdfExport: createPdfExportClient(normalizedOptions),
     sdks: createSdksClient(normalizedOptions),