@launchdarkly/mcp-server 0.2.7 → 0.4.0

package/src/lib/files.ts

@@ -38,3 +38,45 @@ export async function readableStreamToArrayBuffer(
 
   return concatenatedChunks.buffer as ArrayBuffer;
 }
+
+/**
+ * Determines the MIME content type based on a file's extension.
+ * Returns null if the extension is not recognized.
+ */
+export function getContentTypeFromFileName(fileName: string): string | null {
+  if (!fileName) return null;
+
+  const ext = fileName.toLowerCase().split(".").pop();
+  if (!ext) return null;
+
+  const mimeTypes: Record<string, string> = {
+    json: "application/json",
+    xml: "application/xml",
+    html: "text/html",
+    htm: "text/html",
+    txt: "text/plain",
+    csv: "text/csv",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    js: "application/javascript",
+    css: "text/css",
+    zip: "application/zip",
+    tar: "application/x-tar",
+    gz: "application/gzip",
+    mp4: "video/mp4",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+  };
+
+  return mimeTypes[ext] || null;
+}

package/src/lib/matchers.ts

@@ -3,11 +3,10 @@
  */
 
 import { APIError } from "../models/errors/apierror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { Result } from "../types/fp.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
-import { safeParse } from "./schemas.js";
 
 export type Encoding =
   | "jsonl"
@@ -176,17 +175,19 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
+  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
-): MatchFunc<T, E | APIError | SDKValidationError> {
+): MatchFunc<T, E | APIError | ResponseValidationError> {
   return async function matchFunc(
     response: Response,
+    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
-    [result: Result<T, E | APIError | SDKValidationError>, raw: unknown]
+    [result: Result<T, E | APIError | ResponseValidationError>, raw: unknown]
   > {
     let raw: unknown;
     let matcher: Matcher<T, E> | undefined;
@@ -205,21 +206,22 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError(
-          "Unexpected API response status or content-type",
+        error: new APIError("Unexpected Status or Content-Type", {
           response,
-          responseBody,
-        ),
-      }, responseBody];
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
         break;
       case "jsonl":
         raw = response.body;
@@ -231,16 +233,19 @@ export function match<T, E>(
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         encoding satisfies never;
@@ -250,11 +255,7 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError(
-          "API error occurred",
-          response,
-          typeof raw === "string" ? raw : "",
-        ),
+        error: new APIError("API error occurred", { request, response, body }),
       }, raw];
     }
 
@@ -266,6 +267,9 @@ export function match<T, E>(
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
       };
     } else if (resultKey) {
       data = {
@@ -284,18 +288,20 @@ export function match<T, E>(
     }
 
     if ("err" in matcher) {
-      const result = safeParse(
+      const result = safeParseResponse(
         data,
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
+        { request, response, body },
       );
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(
+        safeParseResponse(
           data,
           (v: unknown) => matcher.schema.parse(v),
           "Response validation failed",
+          { request, response, body },
         ),
         raw,
       ];
@@ -318,25 +324,22 @@ export function unpackHeaders(headers: Headers): Record<string, string[]> {
   return out;
 }
 
-/**
- * Discards the response body to free up resources.
- *
- * To learn why this is need, see the undici docs:
- * https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function discardResponseBody(res: Response) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
-
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
   try {
-    let done = false;
-    while (!done) {
-      const res = await reader.read();
-      done = res.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
   }
 }

package/src/lib/sdks.ts

@@ -65,6 +65,7 @@ type RequestConfig = {
   headers?: HeadersInit;
   security?: SecurityState | null;
   uaHeader?: string;
+  userAgent?: string | undefined;
   timeoutMs?: number;
 };
 
@@ -96,19 +97,21 @@ export class ClientSDK {
     } else {
       this.#hooks = new SDKHooks();
     }
-    this._options = { ...options, hooks: this.#hooks };
-
     const url = serverURLFromOptions(options);
     if (url) {
       url.pathname = url.pathname.replace(/\/+$/, "") + "/";
     }
+
     const { baseURL, client } = this.#hooks.sdkInit({
       baseURL: url,
       client: options.httpClient || new HTTPClient(),
     });
     this._baseURL = baseURL;
     this.#httpClient = client;
-    this.#logger = options.debugLogger;
+
+    this._options = { ...options, hooks: this.#hooks };
+
+    this.#logger = this._options.debugLogger;
     if (!this.#logger && env().LAUNCHDARKLY_DEBUG) {
       this.#logger = console;
     }
@@ -184,7 +187,10 @@ export class ClientSDK {
     // Only set user agent header in non-browser-like environments since CORS
     // policy disallows setting it in browsers e.g. Chrome throws an error.
     if (!isBrowserLike) {
-      headers.set(conf.uaHeader ?? "user-agent", SDK_METADATA.userAgent);
+      headers.set(
+        conf.uaHeader ?? "user-agent",
+        conf.userAgent ?? SDK_METADATA.userAgent,
+      );
     }
 
     const fetchOptions: Omit<RequestInit, "method" | "body"> = {

package/src/lib/security.ts

@@ -7,8 +7,8 @@ import { env } from "./env.js";
 
 type OAuth2PasswordFlow = {
   username: string;
-  password?: string | undefined;
-  clientID: string;
+  password: string;
+  clientID?: string | undefined;
   clientSecret?: string | undefined;
   tokenURL: string;
 };

package/src/mcp-server/cli/start/command.ts

@@ -37,18 +37,13 @@ export const startCommand = buildCommand({
           return z.string().parse(value);
         },
       },
-      ...(mcpScopes.length
-        ? {
-          scope: {
-            kind: "enum",
-            brief:
-              "Mount tools/resources that match given scope (repeatable flag)",
-            values: mcpScopes,
-            variadic: true,
-            optional: true,
-          },
-        }
-        : {}),
+      scope: {
+        kind: "enum",
+        brief: "Mount tools/resources that match given scope (repeatable flag)",
+        values: mcpScopes,
+        variadic: true,
+        optional: true,
+      },
       "api-key": {
         kind: "parsed",
         brief: "Sets the apiKey auth field for the API",

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

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.2.7",
+    currentVersion: "0.4.0",
   },
 });
 

package/src/mcp-server/server.ts

@@ -18,9 +18,11 @@ import { tool$aiConfigsCreateVariation } from "./tools/aiConfigsCreateVariation.
 import { tool$aiConfigsDelete } from "./tools/aiConfigsDelete.js";
 import { tool$aiConfigsDeleteVariation } from "./tools/aiConfigsDeleteVariation.js";
 import { tool$aiConfigsGet } from "./tools/aiConfigsGet.js";
+import { tool$aiConfigsGetTargeting } from "./tools/aiConfigsGetTargeting.js";
 import { tool$aiConfigsGetVariation } from "./tools/aiConfigsGetVariation.js";
 import { tool$aiConfigsList } from "./tools/aiConfigsList.js";
 import { tool$aiConfigsUpdate } from "./tools/aiConfigsUpdate.js";
+import { tool$aiConfigsUpdateTargeting } from "./tools/aiConfigsUpdateTargeting.js";
 import { tool$aiConfigsUpdateVariation } from "./tools/aiConfigsUpdateVariation.js";
 import { tool$featureFlagsCreate } from "./tools/featureFlagsCreate.js";
 import { tool$featureFlagsDelete } from "./tools/featureFlagsDelete.js";
@@ -38,7 +40,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "LaunchDarkly",
-    version: "0.2.7",
+    version: "0.4.0",
   });
 
   const client = new LaunchDarklyCore({
@@ -73,6 +75,8 @@ export function createMCPServer(deps: {
   tool(tool$featureFlagsGet);
   tool(tool$featureFlagsPatch);
   tool(tool$featureFlagsDelete);
+  tool(tool$aiConfigsGetTargeting);
+  tool(tool$aiConfigsUpdateTargeting);
   tool(tool$aiConfigsList);
   tool(tool$aiConfigsCreate);
   tool(tool$aiConfigsDelete);

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

@@ -13,7 +13,8 @@ const args = {
 export const tool$aiConfigsCreate: ToolDefinition<typeof args> = {
   name: "create-ai-config",
   description:
-    `Creates a new AI Config within a project. Useful for setting up LLM configurations programmatically.`,
+    `Creates a new AI Config within a project. Useful for setting up LLM configurations programmatically.
+`,
   scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -11,22 +11,11 @@ const args = {
 };
 
 export const tool$aiConfigsCreateVariation: ToolDefinition<typeof args> = {
-  name: "ai-configs-create-variation",
-  description: `Create AI Config variation
-
-Create a new variation for a given AI Config.
-
-The <code>model</code> in the request body requires a <code>modelName</code> and <code>parameters</code>, for example:
-
-\`\`\`
-  "model": {
-    "modelName": "claude-3-opus-20240229",
-    "parameters": {
-      "max_tokens": 1024
-    }
-  }
-\`\`\`
+  name: "create-ai-config-variation",
+  description:
+    `Adds a new variation to an AI Config, supporting experimentation or multi-model strategies.
 `,
+  scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsCreateVariation(

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

@@ -11,10 +11,11 @@ const args = {
 };
 
 export const tool$aiConfigsDelete: ToolDefinition<typeof args> = {
-  name: "ai-configs-delete",
-  description: `Delete AI Config
-
-Delete an existing AI Config.`,
+  name: "delete-ai-config",
+  description:
+    `Deletes an AI Config and its associated variations. Intended for cleanup or deprecation workflows.
+`,
+  scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsDelete(

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

@@ -11,10 +11,9 @@ const args = {
 };
 
 export const tool$aiConfigsDeleteVariation: ToolDefinition<typeof args> = {
-  name: "ai-configs-delete-variation",
-  description: `Delete AI Config variation
-
-Delete a specific variation of an AI Config by config key and variation key.`,
+  name: "delete-ai-config-variation",
+  description: `Deletes an AI Config variation.`,
+  scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsDeleteVariation(

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

@@ -11,10 +11,10 @@ const args = {
 };
 
 export const tool$aiConfigsGet: ToolDefinition<typeof args> = {
-  name: "ai-configs-get",
-  description: `Get AI Config
-
-Retrieve a specific AI Config by its key.`,
+  name: "get-ai-config",
+  description:
+    `Retrieves details of a specific AI Config, including variations and model settings.`,
+  scopes: ["read"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsGet(

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

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aiConfigsGetTargeting } from "../../funcs/aiConfigsGetTargeting.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GetAIConfigTargetingRequest$inboundSchema,
+};
+
+export const tool$aiConfigsGetTargeting: ToolDefinition<typeof args> = {
+  name: "get-ai-config-targeting",
+  description:
+    `Retrieves the targeting details of a specific AI Config, including individual targets, rules, and rollouts.`,
+  scopes: ["read"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await aiConfigsGetTargeting(
+      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/aiConfigsGetVariation.ts

@@ -11,10 +11,9 @@ const args = {
 };
 
 export const tool$aiConfigsGetVariation: ToolDefinition<typeof args> = {
-  name: "ai-configs-get-variation",
-  description: `Get AI Config variation
-
-Get an AI Config variation by key. The response includes all variation versions for the given variation key.`,
+  name: "get-ai-config-variation",
+  description: `Retrieves an AI configuration variation.`,
+  scopes: ["read"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsGetVariation(

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

@@ -13,8 +13,9 @@ const args = {
 export const tool$aiConfigsList: ToolDefinition<typeof args> = {
   name: "list-ai-configs",
   description:
-    `Lists all AI Configs in a project, allowing agents to enumerate available configurations for analysis or testing.`,
-  scopes: ["read", "read"],
+    `Retrieves AI configuration settings for a specific project. This endpoint allows agents to access and modify AI-related configurations, ensuring that the AI's behavior aligns with project requirements and user expectations.
+`,
+  scopes: ["read"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsList(

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

@@ -11,21 +11,9 @@ const args = {
 };
 
 export const tool$aiConfigsUpdate: ToolDefinition<typeof args> = {
-  name: "ai-configs-update",
-  description: `Update AI Config
-
-Edit an existing AI Config.
-
-The request body must be a JSON object of the fields to update. The values you include replace the existing values for the fields.
-
-Here's an example:
-  \`\`\`
-    {
-      "description": "Example updated description",
-      "tags": ["new-tag"]
-    }
-  \`\`\`
-`,
+  name: "update-ai-config",
+  description: `Updates metadata or configuration of an existing AI Config.`,
+  scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsUpdate(

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

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aiConfigsUpdateTargeting } from "../../funcs/aiConfigsUpdateTargeting.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.PatchAIConfigTargetingRequest$inboundSchema,
+};
+
+export const tool$aiConfigsUpdateTargeting: ToolDefinition<typeof args> = {
+  name: "update-ai-config-targeting",
+  description: `Updates the targeting of an existing AI Config.`,
+  scopes: ["write"],
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await aiConfigsUpdateTargeting(
+      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/aiConfigsUpdateVariation.ts

@@ -11,25 +11,11 @@ const args = {
 };
 
 export const tool$aiConfigsUpdateVariation: ToolDefinition<typeof args> = {
-  name: "ai-configs-update-variation",
-  description: `Update AI Config variation
-
-Edit an existing variation of an AI Config. This creates a new version of the variation.
-
-The request body must be a JSON object of the fields to update. The values you include replace the existing values for the fields.
-
-Here's an example:
-\`\`\`
-  {
-    "messages": [
-      {
-        "role": "system",
-        "content": "The new message"
-      }
-    ]
-  }
-\`\`\`
+  name: "update-ai-config-variation",
+  description:
+    `Updates a specific variation within an AI Config. Enables fine-tuned control of model behavior.
 `,
+  scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {
     const [result, apiCall] = await aiConfigsUpdateVariation(

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

@@ -13,7 +13,8 @@ const args = {
 export const tool$featureFlagsCreate: ToolDefinition<typeof args> = {
   name: "create-feature-flag",
   description:
-    `Creates a new feature flag within a project. AI agents can use this operation to define feature toggles for controlled rollouts, experimentation, or gated features, automating the flag setup process.`,
+    `Creates a new feature flag within a project. AI agents can use this operation to define feature toggles for controlled rollouts, experimentation, or gated features, automating the flag setup process.
+`,
   scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -13,7 +13,8 @@ const args = {
 export const tool$featureFlagsDelete: ToolDefinition<typeof args> = {
   name: "delete-feature-flag",
   description:
-    `Removes a feature flag from the project. Used by AI agents to clean up deprecated toggles that are no longer in use, improving system hygiene and maintainability.`,
+    `Removes a feature flag from the project. Used by AI agents to clean up deprecated toggles that are no longer in use, improving system hygiene and maintainability.
+`,
   scopes: ["write"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -13,7 +13,8 @@ const args = {
 export const tool$featureFlagsGet: ToolDefinition<typeof args> = {
   name: "get-feature-flag",
   description:
-    `Fetches the full configuration for a specific feature flag, including environments, variations, and targeting rules. Useful for agents auditing or managing specific feature toggles in a detailed, contextual manner.`,
+    `Fetches the full configuration for a specific feature flag, including environments, variations, and targeting rules. Useful for agents auditing or managing specific feature toggles in a detailed, contextual manner.
+`,
   scopes: ["read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -13,7 +13,8 @@ const args = {
 export const tool$featureFlagsList: ToolDefinition<typeof args> = {
   name: "list-feature-flags",
   description:
-    `Retrieves all feature flags within a project, including metadata and targeting rules. Enables AI agents to enumerate existing flags for inspection, configuration analysis, or generating flag usage reports across environments.`,
+    `Retrieves all feature flags within a project, including metadata and targeting rules. Enables AI agents to enumerate existing flags for inspection, configuration analysis, or generating flag usage reports across environments.
+`,
   scopes: ["read"],
   args,
   tool: async (client, args, ctx) => {

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

@@ -13,7 +13,8 @@ const args = {
 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.`,
+    `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) => {