@launchdarkly/mcp-server 0.2.2

package/src/mcp-server/tools/featureFlagsPatch.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { featureFlagsPatch } from "../../funcs/featureFlagsPatch.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.PatchFeatureFlagRequest$inboundSchema,
+};
+
+export const tool$featureFlagsPatch: ToolDefinition<typeof args> = {
+  name: "update-feature-flag",
+  description:
+    `Updates the configuration of an existing feature flag. Enables agents to change targeting rules, modify variations, or adapt rollout strategies dynamically in response to user behavior or experiment results.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await featureFlagsPatch(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools.ts

@@ -0,0 +1,129 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { objectOutputType, ZodRawShape, ZodTypeAny } from "zod";
+import { LaunchDarklyCore } from "../core.js";
+import { ConsoleLogger } from "./console-logger.js";
+import { MCPScope } from "./scopes.js";
+import { isAsyncIterable, isBinaryData, valueToBase64 } from "./shared.js";
+
+export type ToolDefinition<Args extends undefined | ZodRawShape = undefined> =
+  Args extends ZodRawShape ? {
+      name: string;
+      description: string;
+      scopes?: MCPScope[];
+      args: Args;
+      tool: (
+        client: LaunchDarklyCore,
+        args: objectOutputType<Args, ZodTypeAny>,
+        extra: RequestHandlerExtra,
+      ) => CallToolResult | Promise<CallToolResult>;
+    }
+    : {
+      name: string;
+      description: string;
+      scopes?: MCPScope[];
+      args?: undefined;
+      tool: (
+        client: LaunchDarklyCore,
+        extra: RequestHandlerExtra,
+      ) => CallToolResult | Promise<CallToolResult>;
+    };
+
+// Optional function to assist with formatting tool results
+export async function formatResult(
+  value: unknown,
+  init: { response?: Response | undefined },
+): Promise<CallToolResult> {
+  if (typeof value === "undefined") {
+    return { content: [] };
+  }
+
+  const { response } = init;
+  const contentType = response?.headers.get("content-type") ?? "";
+  let content: CallToolResult["content"] = [];
+
+  if (contentType.search(/\bjson\b/g)) {
+    content = [{ type: "text", text: JSON.stringify(value) }];
+  } else if (
+    contentType.startsWith("text/event-stream")
+    && isAsyncIterable(value)
+  ) {
+    content = await consumeSSE(value);
+  } else if (contentType.startsWith("text/") && typeof value === "string") {
+    content = [{ type: "text", text: value }];
+  } else if (isBinaryData(value) && contentType.startsWith("image/")) {
+    const data = await valueToBase64(value);
+    content = data == null
+      ? []
+      : [{ type: "image", data, mimeType: contentType }];
+  } else {
+    return {
+      content: [{
+        type: "text",
+        text: `Unsupported content type: "${contentType}"`,
+      }],
+      isError: true,
+    };
+  }
+
+  return { content };
+}
+
+async function consumeSSE(
+  value: AsyncIterable<unknown>,
+): Promise<CallToolResult["content"]> {
+  const content: CallToolResult["content"] = [];
+
+  for await (const chunk of value) {
+    if (typeof chunk === "string") {
+      content.push({ type: "text", text: chunk });
+    } else {
+      content.push({ type: "text", text: JSON.stringify(chunk) });
+    }
+  }
+
+  return content;
+}
+
+export function createRegisterTool(
+  logger: ConsoleLogger,
+  server: McpServer,
+  sdk: LaunchDarklyCore,
+  allowedScopes: Set<MCPScope>,
+  allowedTools?: Set<string>,
+): <A extends ZodRawShape | undefined>(tool: ToolDefinition<A>) => void {
+  return <A extends ZodRawShape | undefined>(tool: ToolDefinition<A>): void => {
+    if (allowedTools && !allowedTools.has(tool.name)) {
+      return;
+    }
+
+    const scopes = tool.scopes ?? [];
+    if (allowedScopes.size > 0 && scopes.length === 0) {
+      return;
+    }
+
+    if (
+      allowedScopes.size > 0
+      && !scopes.every((s: MCPScope) => allowedScopes.has(s))
+    ) {
+      return;
+    }
+
+    if (tool.args) {
+      server.tool(tool.name, tool.description, tool.args, async (args, ctx) => {
+        return tool.tool(sdk, args, ctx);
+      });
+    } else {
+      server.tool(tool.name, tool.description, async (ctx) => {
+        return tool.tool(sdk, ctx);
+      });
+    }
+
+    logger.debug("Registered tool", { name: tool.name });
+  };
+}

package/src/models/components/access.ts

@@ -0,0 +1,75 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AccessAllowedRep,
+  AccessAllowedRep$inboundSchema,
+  AccessAllowedRep$Outbound,
+  AccessAllowedRep$outboundSchema,
+} from "./accessallowedrep.js";
+import {
+  AccessDenied,
+  AccessDenied$inboundSchema,
+  AccessDenied$Outbound,
+  AccessDenied$outboundSchema,
+} from "./accessdenied.js";
+
+export type Access = {
+  denied: Array<AccessDenied>;
+  allowed: Array<AccessAllowedRep>;
+};
+
+/** @internal */
+export const Access$inboundSchema: z.ZodType<Access, z.ZodTypeDef, unknown> = z
+  .object({
+    denied: z.array(AccessDenied$inboundSchema),
+    allowed: z.array(AccessAllowedRep$inboundSchema),
+  });
+
+/** @internal */
+export type Access$Outbound = {
+  denied: Array<AccessDenied$Outbound>;
+  allowed: Array<AccessAllowedRep$Outbound>;
+};
+
+/** @internal */
+export const Access$outboundSchema: z.ZodType<
+  Access$Outbound,
+  z.ZodTypeDef,
+  Access
+> = z.object({
+  denied: z.array(AccessDenied$outboundSchema),
+  allowed: z.array(AccessAllowedRep$outboundSchema),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Access$ {
+  /** @deprecated use `Access$inboundSchema` instead. */
+  export const inboundSchema = Access$inboundSchema;
+  /** @deprecated use `Access$outboundSchema` instead. */
+  export const outboundSchema = Access$outboundSchema;
+  /** @deprecated use `Access$Outbound` instead. */
+  export type Outbound = Access$Outbound;
+}
+
+export function accessToJSON(access: Access): string {
+  return JSON.stringify(Access$outboundSchema.parse(access));
+}
+
+export function accessFromJSON(
+  jsonString: string,
+): SafeParseResult<Access, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Access$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Access' from JSON`,
+  );
+}

package/src/models/components/accessallowedreason.ts

@@ -0,0 +1,146 @@
+/*
+ * 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";
+
+/**
+ * Whether this statement should allow or deny actions on the resources.
+ */
+export const AccessAllowedReasonEffect = {
+  Allow: "allow",
+  Deny: "deny",
+} as const;
+/**
+ * Whether this statement should allow or deny actions on the resources.
+ */
+export type AccessAllowedReasonEffect = ClosedEnum<
+  typeof AccessAllowedReasonEffect
+>;
+
+export type AccessAllowedReason = {
+  /**
+   * Resource specifier strings
+   */
+  resources?: Array<string> | undefined;
+  /**
+   * Targeted resources are the resources NOT in this list. The <code>resources</code> and <code>notActions</code> fields must be empty to use this field.
+   */
+  notResources?: Array<string> | undefined;
+  /**
+   * Actions to perform on a resource
+   */
+  actions?: Array<string> | undefined;
+  /**
+   * Targeted actions are the actions NOT in this list. The <code>actions</code> and <code>notResources</code> fields must be empty to use this field.
+   */
+  notActions?: Array<string> | undefined;
+  /**
+   * Whether this statement should allow or deny actions on the resources.
+   */
+  effect: AccessAllowedReasonEffect;
+  roleName?: string | undefined;
+};
+
+/** @internal */
+export const AccessAllowedReasonEffect$inboundSchema: z.ZodNativeEnum<
+  typeof AccessAllowedReasonEffect
+> = z.nativeEnum(AccessAllowedReasonEffect);
+
+/** @internal */
+export const AccessAllowedReasonEffect$outboundSchema: z.ZodNativeEnum<
+  typeof AccessAllowedReasonEffect
+> = AccessAllowedReasonEffect$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccessAllowedReasonEffect$ {
+  /** @deprecated use `AccessAllowedReasonEffect$inboundSchema` instead. */
+  export const inboundSchema = AccessAllowedReasonEffect$inboundSchema;
+  /** @deprecated use `AccessAllowedReasonEffect$outboundSchema` instead. */
+  export const outboundSchema = AccessAllowedReasonEffect$outboundSchema;
+}
+
+/** @internal */
+export const AccessAllowedReason$inboundSchema: z.ZodType<
+  AccessAllowedReason,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  resources: z.array(z.string()).optional(),
+  notResources: z.array(z.string()).optional(),
+  actions: z.array(z.string()).optional(),
+  notActions: z.array(z.string()).optional(),
+  effect: AccessAllowedReasonEffect$inboundSchema,
+  role_name: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "role_name": "roleName",
+  });
+});
+
+/** @internal */
+export type AccessAllowedReason$Outbound = {
+  resources?: Array<string> | undefined;
+  notResources?: Array<string> | undefined;
+  actions?: Array<string> | undefined;
+  notActions?: Array<string> | undefined;
+  effect: string;
+  role_name?: string | undefined;
+};
+
+/** @internal */
+export const AccessAllowedReason$outboundSchema: z.ZodType<
+  AccessAllowedReason$Outbound,
+  z.ZodTypeDef,
+  AccessAllowedReason
+> = z.object({
+  resources: z.array(z.string()).optional(),
+  notResources: z.array(z.string()).optional(),
+  actions: z.array(z.string()).optional(),
+  notActions: z.array(z.string()).optional(),
+  effect: AccessAllowedReasonEffect$outboundSchema,
+  roleName: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    roleName: "role_name",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccessAllowedReason$ {
+  /** @deprecated use `AccessAllowedReason$inboundSchema` instead. */
+  export const inboundSchema = AccessAllowedReason$inboundSchema;
+  /** @deprecated use `AccessAllowedReason$outboundSchema` instead. */
+  export const outboundSchema = AccessAllowedReason$outboundSchema;
+  /** @deprecated use `AccessAllowedReason$Outbound` instead. */
+  export type Outbound = AccessAllowedReason$Outbound;
+}
+
+export function accessAllowedReasonToJSON(
+  accessAllowedReason: AccessAllowedReason,
+): string {
+  return JSON.stringify(
+    AccessAllowedReason$outboundSchema.parse(accessAllowedReason),
+  );
+}
+
+export function accessAllowedReasonFromJSON(
+  jsonString: string,
+): SafeParseResult<AccessAllowedReason, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccessAllowedReason$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccessAllowedReason' from JSON`,
+  );
+}

package/src/models/components/accessallowedrep.ts

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AccessAllowedReason,
+  AccessAllowedReason$inboundSchema,
+  AccessAllowedReason$Outbound,
+  AccessAllowedReason$outboundSchema,
+} from "./accessallowedreason.js";
+
+export type AccessAllowedRep = {
+  action: string;
+  reason: AccessAllowedReason;
+};
+
+/** @internal */
+export const AccessAllowedRep$inboundSchema: z.ZodType<
+  AccessAllowedRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  action: z.string(),
+  reason: AccessAllowedReason$inboundSchema,
+});
+
+/** @internal */
+export type AccessAllowedRep$Outbound = {
+  action: string;
+  reason: AccessAllowedReason$Outbound;
+};
+
+/** @internal */
+export const AccessAllowedRep$outboundSchema: z.ZodType<
+  AccessAllowedRep$Outbound,
+  z.ZodTypeDef,
+  AccessAllowedRep
+> = z.object({
+  action: z.string(),
+  reason: AccessAllowedReason$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccessAllowedRep$ {
+  /** @deprecated use `AccessAllowedRep$inboundSchema` instead. */
+  export const inboundSchema = AccessAllowedRep$inboundSchema;
+  /** @deprecated use `AccessAllowedRep$outboundSchema` instead. */
+  export const outboundSchema = AccessAllowedRep$outboundSchema;
+  /** @deprecated use `AccessAllowedRep$Outbound` instead. */
+  export type Outbound = AccessAllowedRep$Outbound;
+}
+
+export function accessAllowedRepToJSON(
+  accessAllowedRep: AccessAllowedRep,
+): string {
+  return JSON.stringify(
+    AccessAllowedRep$outboundSchema.parse(accessAllowedRep),
+  );
+}
+
+export function accessAllowedRepFromJSON(
+  jsonString: string,
+): SafeParseResult<AccessAllowedRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccessAllowedRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccessAllowedRep' from JSON`,
+  );
+}

package/src/models/components/accessdenied.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AccessDeniedReason,
+  AccessDeniedReason$inboundSchema,
+  AccessDeniedReason$Outbound,
+  AccessDeniedReason$outboundSchema,
+} from "./accessdeniedreason.js";
+
+export type AccessDenied = {
+  action: string;
+  reason: AccessDeniedReason;
+};
+
+/** @internal */
+export const AccessDenied$inboundSchema: z.ZodType<
+  AccessDenied,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  action: z.string(),
+  reason: AccessDeniedReason$inboundSchema,
+});
+
+/** @internal */
+export type AccessDenied$Outbound = {
+  action: string;
+  reason: AccessDeniedReason$Outbound;
+};
+
+/** @internal */
+export const AccessDenied$outboundSchema: z.ZodType<
+  AccessDenied$Outbound,
+  z.ZodTypeDef,
+  AccessDenied
+> = z.object({
+  action: z.string(),
+  reason: AccessDeniedReason$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccessDenied$ {
+  /** @deprecated use `AccessDenied$inboundSchema` instead. */
+  export const inboundSchema = AccessDenied$inboundSchema;
+  /** @deprecated use `AccessDenied$outboundSchema` instead. */
+  export const outboundSchema = AccessDenied$outboundSchema;
+  /** @deprecated use `AccessDenied$Outbound` instead. */
+  export type Outbound = AccessDenied$Outbound;
+}
+
+export function accessDeniedToJSON(accessDenied: AccessDenied): string {
+  return JSON.stringify(AccessDenied$outboundSchema.parse(accessDenied));
+}
+
+export function accessDeniedFromJSON(
+  jsonString: string,
+): SafeParseResult<AccessDenied, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccessDenied$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccessDenied' from JSON`,
+  );
+}

package/src/models/components/accessdeniedreason.ts

@@ -0,0 +1,146 @@
+/*
+ * 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";
+
+/**
+ * Whether this statement should allow or deny actions on the resources.
+ */
+export const AccessDeniedReasonEffect = {
+  Allow: "allow",
+  Deny: "deny",
+} as const;
+/**
+ * Whether this statement should allow or deny actions on the resources.
+ */
+export type AccessDeniedReasonEffect = ClosedEnum<
+  typeof AccessDeniedReasonEffect
+>;
+
+export type AccessDeniedReason = {
+  /**
+   * Resource specifier strings
+   */
+  resources?: Array<string> | undefined;
+  /**
+   * Targeted resources are the resources NOT in this list. The <code>resources</code> and <code>notActions</code> fields must be empty to use this field.
+   */
+  notResources?: Array<string> | undefined;
+  /**
+   * Actions to perform on a resource
+   */
+  actions?: Array<string> | undefined;
+  /**
+   * Targeted actions are the actions NOT in this list. The <code>actions</code> and <code>notResources</code> fields must be empty to use this field.
+   */
+  notActions?: Array<string> | undefined;
+  /**
+   * Whether this statement should allow or deny actions on the resources.
+   */
+  effect: AccessDeniedReasonEffect;
+  roleName?: string | undefined;
+};
+
+/** @internal */
+export const AccessDeniedReasonEffect$inboundSchema: z.ZodNativeEnum<
+  typeof AccessDeniedReasonEffect
+> = z.nativeEnum(AccessDeniedReasonEffect);
+
+/** @internal */
+export const AccessDeniedReasonEffect$outboundSchema: z.ZodNativeEnum<
+  typeof AccessDeniedReasonEffect
+> = AccessDeniedReasonEffect$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccessDeniedReasonEffect$ {
+  /** @deprecated use `AccessDeniedReasonEffect$inboundSchema` instead. */
+  export const inboundSchema = AccessDeniedReasonEffect$inboundSchema;
+  /** @deprecated use `AccessDeniedReasonEffect$outboundSchema` instead. */
+  export const outboundSchema = AccessDeniedReasonEffect$outboundSchema;
+}
+
+/** @internal */
+export const AccessDeniedReason$inboundSchema: z.ZodType<
+  AccessDeniedReason,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  resources: z.array(z.string()).optional(),
+  notResources: z.array(z.string()).optional(),
+  actions: z.array(z.string()).optional(),
+  notActions: z.array(z.string()).optional(),
+  effect: AccessDeniedReasonEffect$inboundSchema,
+  role_name: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "role_name": "roleName",
+  });
+});
+
+/** @internal */
+export type AccessDeniedReason$Outbound = {
+  resources?: Array<string> | undefined;
+  notResources?: Array<string> | undefined;
+  actions?: Array<string> | undefined;
+  notActions?: Array<string> | undefined;
+  effect: string;
+  role_name?: string | undefined;
+};
+
+/** @internal */
+export const AccessDeniedReason$outboundSchema: z.ZodType<
+  AccessDeniedReason$Outbound,
+  z.ZodTypeDef,
+  AccessDeniedReason
+> = z.object({
+  resources: z.array(z.string()).optional(),
+  notResources: z.array(z.string()).optional(),
+  actions: z.array(z.string()).optional(),
+  notActions: z.array(z.string()).optional(),
+  effect: AccessDeniedReasonEffect$outboundSchema,
+  roleName: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    roleName: "role_name",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccessDeniedReason$ {
+  /** @deprecated use `AccessDeniedReason$inboundSchema` instead. */
+  export const inboundSchema = AccessDeniedReason$inboundSchema;
+  /** @deprecated use `AccessDeniedReason$outboundSchema` instead. */
+  export const outboundSchema = AccessDeniedReason$outboundSchema;
+  /** @deprecated use `AccessDeniedReason$Outbound` instead. */
+  export type Outbound = AccessDeniedReason$Outbound;
+}
+
+export function accessDeniedReasonToJSON(
+  accessDeniedReason: AccessDeniedReason,
+): string {
+  return JSON.stringify(
+    AccessDeniedReason$outboundSchema.parse(accessDeniedReason),
+  );
+}
+
+export function accessDeniedReasonFromJSON(
+  jsonString: string,
+): SafeParseResult<AccessDeniedReason, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccessDeniedReason$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccessDeniedReason' from JSON`,
+  );
+}