@inkeep/agents-manage-mcp 0.0.0-chat-to-edit-20251119071712

package/src/lib/sdks.ts

@@ -0,0 +1,380 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SDKHooks } from '../hooks/hooks.js';
+import { HookContext } from '../hooks/types.js';
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from '../models/errors/httpclienterrors.js';
+import { stringToBase64 } from './base64.js';
+import { SDK_METADATA, SDKOptions, serverURLFromOptions } from './config.js';
+import { encodeForm } from './encodings.js';
+import { env } from './env.js';
+import {
+  HTTPClient,
+  isAbortError,
+  isConnectionError,
+  isTimeoutError,
+  matchContentType,
+  matchStatusCode,
+} from './http.js';
+import { Logger } from './logger.js';
+import { ERR, OK, Result } from './result.js';
+import { retry, RetryConfig } from './retries.js';
+import { SecurityState } from './security.js';
+
+export type RequestOptions = {
+  /**
+   * Sets a timeout, in milliseconds, on HTTP requests made by an SDK method. If
+   * `fetchOptions.signal` is set then it will take precedence over this option.
+   */
+  timeoutMs?: number;
+  /**
+   * Set or override a retry policy on HTTP calls.
+   */
+  retries?: RetryConfig;
+  /**
+   * Specifies the status codes which should be retried using the given retry policy.
+   */
+  retryCodes?: string[];
+  /**
+   * Overrides the base server URL that will be used by an operation.
+   */
+  serverURL?: string | URL;
+  /**
+   * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
+   *
+   * Sets various request options on the `fetch` call made by an SDK method.
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
+   */
+  fetchOptions?: Omit<RequestInit, 'method' | 'body'>;
+} & Omit<RequestInit, 'method' | 'body'>;
+
+type RequestConfig = {
+  method: string;
+  path: string;
+  baseURL?: string | URL | undefined;
+  query?: string;
+  body?: RequestInit['body'];
+  headers?: HeadersInit;
+  security?: SecurityState | null;
+  uaHeader?: string;
+  userAgent?: string | undefined;
+  timeoutMs?: number;
+};
+
+const gt: unknown = typeof globalThis === 'undefined' ? null : globalThis;
+const webWorkerLike =
+  typeof gt === 'object' &&
+  gt != null &&
+  'importScripts' in gt &&
+  typeof gt['importScripts'] === 'function';
+const isBrowserLike =
+  webWorkerLike ||
+  (typeof navigator !== 'undefined' && 'serviceWorker' in navigator) ||
+  (typeof window === 'object' && typeof window.document !== 'undefined');
+
+export class ClientSDK {
+  readonly #httpClient: HTTPClient;
+  readonly #hooks: SDKHooks;
+  readonly #logger?: Logger | undefined;
+  public readonly _baseURL: URL | null;
+  public readonly _options: SDKOptions & { hooks?: SDKHooks };
+
+  constructor(options: SDKOptions = {}) {
+    const opt = options as unknown;
+    if (typeof opt === 'object' && opt != null && 'hooks' in opt && opt.hooks instanceof SDKHooks) {
+      this.#hooks = opt.hooks;
+    } else {
+      this.#hooks = new SDKHooks();
+    }
+    const defaultHttpClient = new HTTPClient();
+    options.httpClient = options.httpClient || defaultHttpClient;
+    options = this.#hooks.sdkInit(options);
+
+    const url = serverURLFromOptions(options);
+    if (url) {
+      url.pathname = url.pathname.replace(/\/+$/, '') + '/';
+    }
+    this._baseURL = url;
+    this.#httpClient = options.httpClient || defaultHttpClient;
+
+    this._options = { ...options, hooks: this.#hooks };
+
+    this.#logger = this._options.debugLogger;
+    if (!this.#logger && env().INKEEPAGENTS_DEBUG) {
+      this.#logger = console;
+    }
+  }
+
+  public _createRequest(
+    context: HookContext,
+    conf: RequestConfig,
+    options?: RequestOptions
+  ): Result<Request, InvalidRequestError | UnexpectedClientError> {
+    const { method, path, query, headers: opHeaders, security } = conf;
+
+    const base = conf.baseURL ?? this._baseURL;
+    if (!base) {
+      return ERR(new InvalidRequestError('No base URL provided for operation'));
+    }
+    const reqURL = new URL(base);
+    const inputURL = new URL(path, reqURL);
+
+    if (path) {
+      reqURL.pathname += reqURL.pathname.endsWith('/') ? '' : '/';
+      reqURL.pathname += inputURL.pathname.replace(/^\/+/, '');
+    }
+
+    let finalQuery = query || '';
+
+    const secQuery: string[] = [];
+    for (const [k, v] of Object.entries(security?.queryParams || {})) {
+      const q = encodeForm(k, v, { charEncoding: 'percent' });
+      if (typeof q !== 'undefined') {
+        secQuery.push(q);
+      }
+    }
+    if (secQuery.length) {
+      finalQuery += `&${secQuery.join('&')}`;
+    }
+
+    if (finalQuery) {
+      const q = finalQuery.startsWith('&') ? finalQuery.slice(1) : finalQuery;
+      reqURL.search = `?${q}`;
+    }
+
+    const headers = new Headers(opHeaders);
+
+    const username = security?.basic.username;
+    const password = security?.basic.password;
+    if (username != null || password != null) {
+      const encoded = stringToBase64([username || '', password || ''].join(':'));
+      headers.set('Authorization', `Basic ${encoded}`);
+    }
+
+    const securityHeaders = new Headers(security?.headers || {});
+    for (const [k, v] of securityHeaders) {
+      headers.set(k, v);
+    }
+
+    let cookie = headers.get('cookie') || '';
+    for (const [k, v] of Object.entries(security?.cookies || {})) {
+      cookie += `; ${k}=${v}`;
+    }
+    cookie = cookie.startsWith('; ') ? cookie.slice(2) : cookie;
+    headers.set('cookie', cookie);
+
+    const userHeaders = new Headers(options?.headers ?? options?.fetchOptions?.headers);
+    for (const [k, v] of userHeaders) {
+      headers.set(k, v);
+    }
+
+    // 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', conf.userAgent ?? SDK_METADATA.userAgent);
+    }
+
+    const fetchOptions: Omit<RequestInit, 'method' | 'body'> = {
+      ...options?.fetchOptions,
+      ...options,
+    };
+    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
+      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
+      fetchOptions.signal = timeoutSignal;
+    }
+
+    if (conf.body instanceof ReadableStream) {
+      Object.assign(fetchOptions, { duplex: 'half' });
+    }
+
+    let input;
+    try {
+      input = this.#hooks.beforeCreateRequest(context, {
+        url: reqURL,
+        options: {
+          ...fetchOptions,
+          body: conf.body ?? null,
+          headers,
+          method,
+        },
+      });
+    } catch (err: unknown) {
+      return ERR(
+        new UnexpectedClientError('Create request hook failed to execute', {
+          cause: err,
+        })
+      );
+    }
+
+    return OK(new Request(input.url, input.options));
+  }
+
+  public async _do(
+    request: Request,
+    options: {
+      context: HookContext;
+      errorCodes: number | string | (number | string)[];
+      retryConfig: RetryConfig;
+      retryCodes: string[];
+    }
+  ): Promise<
+    Result<
+      Response,
+      RequestAbortedError | RequestTimeoutError | ConnectionError | UnexpectedClientError
+    >
+  > {
+    const { context, errorCodes } = options;
+
+    return retry(
+      async () => {
+        const req = await this.#hooks.beforeRequest(context, request.clone() as Request);
+        await logRequest(this.#logger, req).catch((e) =>
+          this.#logger?.log('Failed to log request:', e)
+        );
+
+        let response = await this.#httpClient.request(req);
+
+        try {
+          if (matchStatusCode(response, errorCodes)) {
+            const result = await this.#hooks.afterError(context, response, null);
+            if (result.error) {
+              throw result.error;
+            }
+            response = result.response || response;
+          } else {
+            response = await this.#hooks.afterSuccess(context, response);
+          }
+        } finally {
+          await logResponse(this.#logger, response, req).catch((e) =>
+            this.#logger?.log('Failed to log response:', e)
+          );
+        }
+
+        return response;
+      },
+      { config: options.retryConfig, statusCodes: options.retryCodes }
+    ).then(
+      (r) => OK(r),
+      (err) => {
+        switch (true) {
+          case isAbortError(err):
+            return ERR(
+              new RequestAbortedError('Request aborted by client', {
+                cause: err,
+              })
+            );
+          case isTimeoutError(err):
+            return ERR(new RequestTimeoutError('Request timed out', { cause: err }));
+          case isConnectionError(err):
+            return ERR(new ConnectionError('Unable to make request', { cause: err }));
+          default:
+            return ERR(
+              new UnexpectedClientError('Unexpected HTTP client error', {
+                cause: err,
+              })
+            );
+        }
+      }
+    );
+  }
+}
+
+const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
+const jsonlLikeContentTypeRE = /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
+async function logRequest(logger: Logger | undefined, req: Request) {
+  if (!logger) {
+    return;
+  }
+
+  const contentType = req.headers.get('content-type');
+  const ct = contentType?.split(';')[0] || '';
+
+  logger.group(`> Request: ${req.method} ${req.url}`);
+
+  logger.group('Headers:');
+  for (const [k, v] of req.headers.entries()) {
+    logger.log(`${k}: ${v}`);
+  }
+  logger.groupEnd();
+
+  logger.group('Body:');
+  switch (true) {
+    case jsonLikeContentTypeRE.test(ct):
+      logger.log(await req.clone().json());
+      break;
+    case ct.startsWith('text/'):
+      logger.log(await req.clone().text());
+      break;
+    case ct === 'multipart/form-data': {
+      const body = await req.clone().formData();
+      for (const [k, v] of body) {
+        const vlabel = v instanceof Blob ? '<Blob>' : v;
+        logger.log(`${k}: ${vlabel}`);
+      }
+      break;
+    }
+    default:
+      logger.log(`<${contentType}>`);
+      break;
+  }
+  logger.groupEnd();
+
+  logger.groupEnd();
+}
+
+async function logResponse(logger: Logger | undefined, res: Response, req: Request) {
+  if (!logger) {
+    return;
+  }
+
+  const contentType = res.headers.get('content-type');
+  const ct = contentType?.split(';')[0] || '';
+
+  logger.group(`< Response: ${req.method} ${req.url}`);
+  logger.log('Status Code:', res.status, res.statusText);
+
+  logger.group('Headers:');
+  for (const [k, v] of res.headers.entries()) {
+    logger.log(`${k}: ${v}`);
+  }
+  logger.groupEnd();
+
+  logger.group('Body:');
+  switch (true) {
+    case matchContentType(res, 'application/json') ||
+      (jsonLikeContentTypeRE.test(ct) && !jsonlLikeContentTypeRE.test(ct)):
+      logger.log(await res.clone().json());
+      break;
+    case matchContentType(res, 'application/jsonl') || jsonlLikeContentTypeRE.test(ct):
+      logger.log(await res.clone().text());
+      break;
+    case matchContentType(res, 'text/event-stream'):
+      logger.log(`<${contentType}>`);
+      break;
+    case matchContentType(res, 'text/*'):
+      logger.log(await res.clone().text());
+      break;
+    case matchContentType(res, 'multipart/form-data'): {
+      const body = await res.clone().formData();
+      for (const [k, v] of body) {
+        const vlabel = v instanceof Blob ? '<Blob>' : v;
+        logger.log(`${k}: ${vlabel}`);
+      }
+      break;
+    }
+    default:
+      logger.log(`<${contentType}>`);
+      break;
+  }
+  logger.groupEnd();
+
+  logger.groupEnd();
+}

package/src/lib/security.ts

@@ -0,0 +1,218 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+type OAuth2PasswordFlow = {
+  username: string;
+  password: string;
+  clientID?: string | undefined;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
+export enum SecurityErrorCode {
+  Incomplete = 'incomplete',
+  UnrecognisedSecurityType = 'unrecognized_security_type',
+}
+
+export class SecurityError extends Error {
+  constructor(
+    public code: SecurityErrorCode,
+    message: string
+  ) {
+    super(message);
+    this.name = 'SecurityError';
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      'Security requirements not met in order to perform the operation'
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`
+    );
+  }
+}
+
+export type SecurityState = {
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
+  oauth2: ({ type: 'password' } & OAuth2PasswordFlow) | { type: 'none' };
+};
+
+type SecurityInputBasic = {
+  type: 'http:basic';
+  value: { username?: string | undefined; password?: string | undefined } | null | undefined;
+};
+
+type SecurityInputBearer = {
+  type: 'http:bearer';
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+  type: 'apiKey:header' | 'apiKey:query' | 'apiKey:cookie';
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOIDC = {
+  type: 'openIdConnect';
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+  type: 'oauth2';
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+  type: 'oauth2:client_credentials';
+  value:
+    | { clientID?: string | undefined; clientSecret?: string | undefined }
+    | null
+    | string
+    | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: 'oauth2:password';
+  value: string | null | undefined;
+  fieldName?: string;
+};
+
+type SecurityInputCustom = {
+  type: 'http:custom';
+  value: any | null | undefined;
+  fieldName?: string;
+};
+
+export type SecurityInput =
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(...options: SecurityInput[][]): SecurityState | null {
+  const state: SecurityState = {
+    basic: {},
+    headers: {},
+    queryParams: {},
+    cookies: {},
+    oauth2: { type: 'none' },
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === 'http:basic') {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === 'http:custom') {
+        return null;
+      } else if (o.type === 'oauth2:password') {
+        return typeof o.value === 'string' && !!o.value;
+      } else if (o.type === 'oauth2:client_credentials') {
+        if (typeof o.value == 'string') {
+          return !!o.value;
+        }
+        return o.value.clientID != null || o.value.clientSecret != null;
+      } else if (typeof o.value === 'string') {
+        return !!o.value;
+      } else {
+        throw new Error(`Unrecognized security type: ${o.type} (value type: ${typeof o.value})`);
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
+    }
+
+    const { type } = spec;
+
+    switch (type) {
+      case 'apiKey:header':
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case 'apiKey:query':
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case 'apiKey:cookie':
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case 'http:basic':
+        applyBasic(state, spec);
+        break;
+      case 'http:custom':
+        break;
+      case 'http:bearer':
+        applyBearer(state, spec);
+        break;
+      case 'oauth2':
+        applyBearer(state, spec);
+        break;
+      case 'oauth2:password':
+        applyBearer(state, spec);
+        break;
+      case 'oauth2:client_credentials':
+        break;
+      case 'openIdConnect':
+        applyBearer(state, spec);
+        break;
+      default:
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
+    }
+  });
+
+  return state;
+}
+
+function applyBasic(state: SecurityState, spec: SecurityInputBasic) {
+  if (spec.value == null) {
+    return;
+  }
+
+  state.basic = spec.value;
+}
+
+function applyBearer(
+  state: SecurityState,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials
+) {
+  if (typeof spec.value !== 'string' || !spec.value) {
+    return;
+  }
+
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== 'bearer ') {
+    value = `Bearer ${value}`;
+  }
+
+  if (spec.fieldName !== undefined) {
+    state.headers[spec.fieldName] = value;
+  }
+}

package/src/lib/url.ts

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: 'percent' | 'none' }
+): (params?: Params) => string {
+  const paramRE = /\{([a-zA-Z0-9_]+?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
+
+      const value = params[placeholder];
+      if (typeof value !== 'string' && typeof value !== 'number') {
+        throw new Error(`Parameter '${placeholder}' must be a string or number`);
+      }
+
+      return options?.charEncoding === 'percent' ? encodeURIComponent(`${value}`) : `${value}`;
+    });
+  };
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { buildCommand } from '@stricli/core';
+import { numberParser } from '@stricli/core';
+import * as z from 'zod';
+import { consoleLoggerLevels } from '../../console-logger.js';
+
+export const startCommand = buildCommand({
+  loader: async () => {
+    const { main } = await import('./impl.js');
+    return main;
+  },
+  parameters: {
+    flags: {
+      transport: {
+        kind: 'enum',
+        brief: 'The transport to use for communicating with the server',
+        default: 'stdio',
+        values: ['stdio', 'sse'],
+      },
+      port: {
+        kind: 'parsed',
+        brief: 'The port to use when the SSE transport is enabled',
+        default: '2718',
+        parse: (val: string) => z.coerce.number().int().gte(0).lt(65536).parse(val),
+      },
+      tool: {
+        kind: 'parsed',
+        brief: 'Specify tools to mount on the server',
+        optional: true,
+        variadic: true,
+        parse: (value) => {
+          return z.string().parse(value);
+        },
+      },
+      'server-url': {
+        kind: 'parsed',
+        brief: 'Overrides the default server URL used by the SDK',
+        optional: true,
+        parse: (value) => new URL(value).toString(),
+      },
+      'server-index': {
+        kind: 'parsed',
+        brief: 'Selects a predefined server used by the SDK',
+        optional: true,
+        parse: numberParser,
+      },
+      'log-level': {
+        kind: 'enum',
+        brief: 'The log level to use for the server',
+        default: 'info',
+        values: consoleLoggerLevels,
+      },
+      env: {
+        kind: 'parsed',
+        brief: 'Environment variables made available to the server',
+        optional: true,
+        variadic: true,
+        parse: (val: string) => {
+          const sepIdx = val.indexOf('=');
+          if (sepIdx === -1) {
+            throw new Error('Invalid environment variable format');
+          }
+
+          const key = val.slice(0, sepIdx);
+          const value = val.slice(sepIdx + 1);
+
+          return [
+            z
+              .string()
+              .nonempty({
+                message: 'Environment variable key must be a non-empty string',
+              })
+              .parse(key),
+            z
+              .string()
+              .nonempty({
+                message: 'Environment variable value must be a non-empty string',
+              })
+              .parse(value),
+          ] satisfies [string, string];
+        },
+      },
+    },
+  },
+  docs: {
+    brief: 'Run the Model Context Protocol server',
+  },
+});