@launchdarkly/mcp-server 0.3.1 → 0.4.0

package/src/models/errors/methodnotallowederrorrep.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { LaunchDarklyError } from "./launchdarklyerror.js";
 
 export type MethodNotAllowedErrorRepData = {
   /**
@@ -15,7 +16,7 @@ export type MethodNotAllowedErrorRepData = {
   message: string;
 };
 
-export class MethodNotAllowedErrorRep extends Error {
+export class MethodNotAllowedErrorRep extends LaunchDarklyError {
   /**
    * Specific error code encountered
    */
@@ -24,13 +25,13 @@ export class MethodNotAllowedErrorRep extends Error {
   /** The original data that was passed to this error instance. */
   data$: MethodNotAllowedErrorRepData;
 
-  constructor(err: MethodNotAllowedErrorRepData) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+  constructor(
+    err: MethodNotAllowedErrorRepData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
 
     this.name = "MethodNotAllowedErrorRep";
@@ -45,9 +46,16 @@ export const MethodNotAllowedErrorRep$inboundSchema: z.ZodType<
 > = z.object({
   code: z.string(),
   message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new MethodNotAllowedErrorRep(v);
+    return new MethodNotAllowedErrorRep(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/notfounderrorrep.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { LaunchDarklyError } from "./launchdarklyerror.js";
 
 export type NotFoundErrorRepData = {
   /**
@@ -15,7 +16,7 @@ export type NotFoundErrorRepData = {
   message: string;
 };
 
-export class NotFoundErrorRep extends Error {
+export class NotFoundErrorRep extends LaunchDarklyError {
   /**
    * Specific error code encountered
    */
@@ -24,13 +25,13 @@ export class NotFoundErrorRep extends Error {
   /** The original data that was passed to this error instance. */
   data$: NotFoundErrorRepData;
 
-  constructor(err: NotFoundErrorRepData) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+  constructor(
+    err: NotFoundErrorRepData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
 
     this.name = "NotFoundErrorRep";
@@ -45,9 +46,16 @@ export const NotFoundErrorRep$inboundSchema: z.ZodType<
 > = z.object({
   code: z.string(),
   message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new NotFoundErrorRep(v);
+    return new NotFoundErrorRep(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/ratelimitederrorrep.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { LaunchDarklyError } from "./launchdarklyerror.js";
 
 export type RateLimitedErrorRepData = {
   /**
@@ -15,7 +16,7 @@ export type RateLimitedErrorRepData = {
   message: string;
 };
 
-export class RateLimitedErrorRep extends Error {
+export class RateLimitedErrorRep extends LaunchDarklyError {
   /**
    * Specific error code encountered
    */
@@ -24,13 +25,13 @@ export class RateLimitedErrorRep extends Error {
   /** The original data that was passed to this error instance. */
   data$: RateLimitedErrorRepData;
 
-  constructor(err: RateLimitedErrorRepData) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+  constructor(
+    err: RateLimitedErrorRepData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
 
     this.name = "RateLimitedErrorRep";
@@ -45,9 +46,16 @@ export const RateLimitedErrorRep$inboundSchema: z.ZodType<
 > = z.object({
   code: z.string(),
   message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new RateLimitedErrorRep(v);
+    return new RateLimitedErrorRep(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/responsevalidationerror.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { LaunchDarklyError } from "./launchdarklyerror.js";
+import { formatZodError } from "./sdkvalidationerror.js";
+
+export class ResponseValidationError extends LaunchDarklyError {
+  /**
+   * The raw value that failed validation.
+   */
+  public readonly rawValue: unknown;
+
+  /**
+   * The raw message that failed validation.
+   */
+  public readonly rawMessage: unknown;
+
+  constructor(
+    message: string,
+    extra: {
+      response: Response;
+      request: Request;
+      body: string;
+      cause: unknown;
+      rawValue: unknown;
+      rawMessage: unknown;
+    },
+  ) {
+    super(message, extra);
+    this.name = "ResponseValidationError";
+    this.cause = extra.cause;
+    this.rawValue = extra.rawValue;
+    this.rawMessage = extra.rawMessage;
+  }
+
+  /**
+   * Return a pretty-formatted error message if the underlying validation error
+   * is a ZodError or some other recognized error type, otherwise return the
+   * default error message.
+   */
+  public pretty(): string {
+    if (this.cause instanceof z.ZodError) {
+      return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+    } else {
+      return this.toString();
+    }
+  }
+}

package/src/models/errors/sdkvalidationerror.ts

@@ -15,6 +15,18 @@ export class SDKValidationError extends Error {
    */
   public readonly rawMessage: unknown;
 
+  // Allows for backwards compatibility for `instanceof` checks of `ResponseValidationError`
+  static override [Symbol.hasInstance](
+    instance: unknown,
+  ): instance is SDKValidationError {
+    if (!(instance instanceof Error)) return false;
+    if (!("rawValue" in instance)) return false;
+    if (!("rawMessage" in instance)) return false;
+    if (!("pretty" in instance)) return false;
+    if (typeof instance.pretty !== "function") return false;
+    return true;
+  }
+
   constructor(message: string, cause: unknown, rawValue: unknown) {
     super(`${message}: ${cause}`);
     this.name = "SDKValidationError";

package/src/models/errors/statusconflicterrorrep.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { LaunchDarklyError } from "./launchdarklyerror.js";
 
 export type StatusConflictErrorRepData = {
   /**
@@ -15,7 +16,7 @@ export type StatusConflictErrorRepData = {
   message: string;
 };
 
-export class StatusConflictErrorRep extends Error {
+export class StatusConflictErrorRep extends LaunchDarklyError {
   /**
    * Specific error code encountered
    */
@@ -24,13 +25,13 @@ export class StatusConflictErrorRep extends Error {
   /** The original data that was passed to this error instance. */
   data$: StatusConflictErrorRepData;
 
-  constructor(err: StatusConflictErrorRepData) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+  constructor(
+    err: StatusConflictErrorRepData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
 
     this.name = "StatusConflictErrorRep";
@@ -45,9 +46,16 @@ export const StatusConflictErrorRep$inboundSchema: z.ZodType<
 > = z.object({
   code: z.string(),
   message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new StatusConflictErrorRep(v);
+    return new StatusConflictErrorRep(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/unauthorizederrorrep.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { LaunchDarklyError } from "./launchdarklyerror.js";
 
 export type UnauthorizedErrorRepData = {
   /**
@@ -15,7 +16,7 @@ export type UnauthorizedErrorRepData = {
   message: string;
 };
 
-export class UnauthorizedErrorRep extends Error {
+export class UnauthorizedErrorRep extends LaunchDarklyError {
   /**
    * Specific error code encountered
    */
@@ -24,13 +25,13 @@ export class UnauthorizedErrorRep extends Error {
   /** The original data that was passed to this error instance. */
   data$: UnauthorizedErrorRepData;
 
-  constructor(err: UnauthorizedErrorRepData) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+  constructor(
+    err: UnauthorizedErrorRepData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
 
     this.name = "UnauthorizedErrorRep";
@@ -45,9 +46,16 @@ export const UnauthorizedErrorRep$inboundSchema: z.ZodType<
 > = z.object({
   code: z.string(),
   message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new UnauthorizedErrorRep(v);
+    return new UnauthorizedErrorRep(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/operations/getaiconfigtargeting.ts

@@ -0,0 +1,123 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Version of the endpoint.
+ */
+export const GetAIConfigTargetingLDAPIVersion = {
+  Beta: "beta",
+} as const;
+/**
+ * Version of the endpoint.
+ */
+export type GetAIConfigTargetingLDAPIVersion = ClosedEnum<
+  typeof GetAIConfigTargetingLDAPIVersion
+>;
+
+export type GetAIConfigTargetingRequest = {
+  /**
+   * Version of the endpoint.
+   */
+  ldAPIVersion: GetAIConfigTargetingLDAPIVersion;
+  projectKey: string;
+  configKey: string;
+};
+
+/** @internal */
+export const GetAIConfigTargetingLDAPIVersion$inboundSchema: z.ZodNativeEnum<
+  typeof GetAIConfigTargetingLDAPIVersion
+> = z.nativeEnum(GetAIConfigTargetingLDAPIVersion);
+
+/** @internal */
+export const GetAIConfigTargetingLDAPIVersion$outboundSchema: z.ZodNativeEnum<
+  typeof GetAIConfigTargetingLDAPIVersion
+> = GetAIConfigTargetingLDAPIVersion$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace GetAIConfigTargetingLDAPIVersion$ {
+  /** @deprecated use `GetAIConfigTargetingLDAPIVersion$inboundSchema` instead. */
+  export const inboundSchema = GetAIConfigTargetingLDAPIVersion$inboundSchema;
+  /** @deprecated use `GetAIConfigTargetingLDAPIVersion$outboundSchema` instead. */
+  export const outboundSchema = GetAIConfigTargetingLDAPIVersion$outboundSchema;
+}
+
+/** @internal */
+export const GetAIConfigTargetingRequest$inboundSchema: z.ZodType<
+  GetAIConfigTargetingRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "LD-API-Version": GetAIConfigTargetingLDAPIVersion$inboundSchema,
+  projectKey: z.string(),
+  configKey: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "LD-API-Version": "ldAPIVersion",
+  });
+});
+
+/** @internal */
+export type GetAIConfigTargetingRequest$Outbound = {
+  "LD-API-Version": string;
+  projectKey: string;
+  configKey: string;
+};
+
+/** @internal */
+export const GetAIConfigTargetingRequest$outboundSchema: z.ZodType<
+  GetAIConfigTargetingRequest$Outbound,
+  z.ZodTypeDef,
+  GetAIConfigTargetingRequest
+> = z.object({
+  ldAPIVersion: GetAIConfigTargetingLDAPIVersion$outboundSchema,
+  projectKey: z.string(),
+  configKey: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    ldAPIVersion: "LD-API-Version",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace GetAIConfigTargetingRequest$ {
+  /** @deprecated use `GetAIConfigTargetingRequest$inboundSchema` instead. */
+  export const inboundSchema = GetAIConfigTargetingRequest$inboundSchema;
+  /** @deprecated use `GetAIConfigTargetingRequest$outboundSchema` instead. */
+  export const outboundSchema = GetAIConfigTargetingRequest$outboundSchema;
+  /** @deprecated use `GetAIConfigTargetingRequest$Outbound` instead. */
+  export type Outbound = GetAIConfigTargetingRequest$Outbound;
+}
+
+export function getAIConfigTargetingRequestToJSON(
+  getAIConfigTargetingRequest: GetAIConfigTargetingRequest,
+): string {
+  return JSON.stringify(
+    GetAIConfigTargetingRequest$outboundSchema.parse(
+      getAIConfigTargetingRequest,
+    ),
+  );
+}
+
+export function getAIConfigTargetingRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetAIConfigTargetingRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetAIConfigTargetingRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetAIConfigTargetingRequest' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -7,10 +7,12 @@ export * from "./deleteaiconfigvariation.js";
 export * from "./deletefeatureflag.js";
 export * from "./getaiconfig.js";
 export * from "./getaiconfigs.js";
+export * from "./getaiconfigtargeting.js";
 export * from "./getaiconfigvariation.js";
 export * from "./getfeatureflag.js";
 export * from "./getfeatureflags.js";
 export * from "./patchaiconfig.js";
+export * from "./patchaiconfigtargeting.js";
 export * from "./patchaiconfigvariation.js";
 export * from "./patchfeatureflag.js";
 export * from "./postaiconfig.js";

package/src/models/operations/patchaiconfigtargeting.ts

@@ -0,0 +1,138 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Version of the endpoint.
+ */
+export const PatchAIConfigTargetingLDAPIVersion = {
+  Beta: "beta",
+} as const;
+/**
+ * Version of the endpoint.
+ */
+export type PatchAIConfigTargetingLDAPIVersion = ClosedEnum<
+  typeof PatchAIConfigTargetingLDAPIVersion
+>;
+
+export type PatchAIConfigTargetingRequest = {
+  /**
+   * Version of the endpoint.
+   */
+  ldAPIVersion: PatchAIConfigTargetingLDAPIVersion;
+  projectKey: string;
+  configKey: string;
+  /**
+   * AI Config targeting semantic patch instructions
+   */
+  aiConfigTargetingPatch?: components.AIConfigTargetingPatch | undefined;
+};
+
+/** @internal */
+export const PatchAIConfigTargetingLDAPIVersion$inboundSchema: z.ZodNativeEnum<
+  typeof PatchAIConfigTargetingLDAPIVersion
+> = z.nativeEnum(PatchAIConfigTargetingLDAPIVersion);
+
+/** @internal */
+export const PatchAIConfigTargetingLDAPIVersion$outboundSchema: z.ZodNativeEnum<
+  typeof PatchAIConfigTargetingLDAPIVersion
+> = PatchAIConfigTargetingLDAPIVersion$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace PatchAIConfigTargetingLDAPIVersion$ {
+  /** @deprecated use `PatchAIConfigTargetingLDAPIVersion$inboundSchema` instead. */
+  export const inboundSchema = PatchAIConfigTargetingLDAPIVersion$inboundSchema;
+  /** @deprecated use `PatchAIConfigTargetingLDAPIVersion$outboundSchema` instead. */
+  export const outboundSchema =
+    PatchAIConfigTargetingLDAPIVersion$outboundSchema;
+}
+
+/** @internal */
+export const PatchAIConfigTargetingRequest$inboundSchema: z.ZodType<
+  PatchAIConfigTargetingRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "LD-API-Version": PatchAIConfigTargetingLDAPIVersion$inboundSchema,
+  projectKey: z.string(),
+  configKey: z.string(),
+  AIConfigTargetingPatch: components.AIConfigTargetingPatch$inboundSchema
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "LD-API-Version": "ldAPIVersion",
+    "AIConfigTargetingPatch": "aiConfigTargetingPatch",
+  });
+});
+
+/** @internal */
+export type PatchAIConfigTargetingRequest$Outbound = {
+  "LD-API-Version": string;
+  projectKey: string;
+  configKey: string;
+  AIConfigTargetingPatch?:
+    | components.AIConfigTargetingPatch$Outbound
+    | undefined;
+};
+
+/** @internal */
+export const PatchAIConfigTargetingRequest$outboundSchema: z.ZodType<
+  PatchAIConfigTargetingRequest$Outbound,
+  z.ZodTypeDef,
+  PatchAIConfigTargetingRequest
+> = z.object({
+  ldAPIVersion: PatchAIConfigTargetingLDAPIVersion$outboundSchema,
+  projectKey: z.string(),
+  configKey: z.string(),
+  aiConfigTargetingPatch: components.AIConfigTargetingPatch$outboundSchema
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    ldAPIVersion: "LD-API-Version",
+    aiConfigTargetingPatch: "AIConfigTargetingPatch",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace PatchAIConfigTargetingRequest$ {
+  /** @deprecated use `PatchAIConfigTargetingRequest$inboundSchema` instead. */
+  export const inboundSchema = PatchAIConfigTargetingRequest$inboundSchema;
+  /** @deprecated use `PatchAIConfigTargetingRequest$outboundSchema` instead. */
+  export const outboundSchema = PatchAIConfigTargetingRequest$outboundSchema;
+  /** @deprecated use `PatchAIConfigTargetingRequest$Outbound` instead. */
+  export type Outbound = PatchAIConfigTargetingRequest$Outbound;
+}
+
+export function patchAIConfigTargetingRequestToJSON(
+  patchAIConfigTargetingRequest: PatchAIConfigTargetingRequest,
+): string {
+  return JSON.stringify(
+    PatchAIConfigTargetingRequest$outboundSchema.parse(
+      patchAIConfigTargetingRequest,
+    ),
+  );
+}
+
+export function patchAIConfigTargetingRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<PatchAIConfigTargetingRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PatchAIConfigTargetingRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PatchAIConfigTargetingRequest' from JSON`,
+  );
+}