@inkeep/agents-manage-mcp 0.39.5 → 0.40.0

package/src/lib/primitives.ts

@@ -1,11 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d4b98409bef2
  */
 
 class InvariantError extends Error {
   constructor(message: string) {
     super(message);
-    this.name = 'InvariantError';
+    this.name = "InvariantError";
   }
 }
 
@@ -40,21 +41,21 @@ export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
     for (const signalRef of signalRefs) {
       const signal = signalRef.deref();
       if (signal) {
-        signal.removeEventListener('abort', abort);
+        signal.removeEventListener("abort", abort);
       }
     }
   }
 
   for (const signal of signals) {
     signalRefs.push(new WeakRef(signal));
-    signal.addEventListener('abort', abort);
+    signal.addEventListener("abort", abort);
   }
 
   return result;
 }
 
 export function allRequired<V extends Record<string, unknown>>(
-  v: V
+  v: V,
 ):
   | {
       [K in keyof V]: NonNullable<V[K]>;
@@ -82,18 +83,20 @@ export function combineSignals(
     case 1:
       return filtered[0] || null;
     default:
-      if ('any' in AbortSignal && typeof AbortSignal.any === 'function') {
+      if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
         return AbortSignal.any(filtered);
       }
       return abortSignalAny(filtered);
   }
 }
 
-export function compactMap<T>(values: Record<string, T | undefined>): Record<string, T> {
+export function compactMap<T>(
+  values: Record<string, T | undefined>,
+): Record<string, T> {
   const out: Record<string, T> = {};
 
   for (const [k, v] of Object.entries(values)) {
-    if (typeof v !== 'undefined') {
+    if (typeof v !== "undefined") {
       out[k] = v;
     }
   }
@@ -101,7 +104,10 @@ export function compactMap<T>(values: Record<string, T | undefined>): Record<str
   return out;
 }
 
-export function invariant(condition: unknown, message: string): asserts condition {
+export function invariant(
+  condition: unknown,
+  message: string,
+): asserts condition {
   if (!condition) {
     throw new InvariantError(message);
   }

package/src/lib/result.ts

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0d1e69fcd959
  */
 
 /**
@@ -38,7 +39,9 @@ export function unwrap<T>(r: Result<T, unknown>): T {
  * unwrapAsync is a convenience function for resolving a value from a Promise
  * of a result or rejecting if an error occurred.
  */
-export async function unwrapAsync<T>(pr: Promise<Result<T, unknown>>): Promise<T> {
+export async function unwrapAsync<T>(
+  pr: Promise<Result<T, unknown>>,
+): Promise<T> {
   const r = await pr;
   if (!r.ok) {
     throw r.error;

package/src/lib/retries.ts

@@ -1,8 +1,9 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7f7858f8f715
  */
 
-import { isConnectionError, isTimeoutError } from './http.js';
+import { isConnectionError, isTimeoutError } from "./http.js";
 
 export type BackoffStrategy = {
   initialInterval: number;
@@ -19,9 +20,9 @@ const defaultBackoff: BackoffStrategy = {
 };
 
 export type RetryConfig =
-  | { strategy: 'none' }
+  | { strategy: "none" }
   | {
-      strategy: 'backoff';
+      strategy: "backoff";
       backoff?: BackoffStrategy;
       retryConnectionErrors?: boolean;
     };
@@ -41,10 +42,10 @@ export class PermanentError extends Error {
     }
 
     super(msg, options);
-    this.name = 'PermanentError';
+    this.name = "PermanentError";
     // In older runtimes, the cause field would not have been assigned through
     // the super() call.
-    if (typeof this.cause === 'undefined') {
+    if (typeof this.cause === "undefined") {
       this.cause = options?.cause;
     }
 
@@ -63,7 +64,7 @@ export class TemporaryError extends Error {
   constructor(message: string, response: Response) {
     super(message);
     this.response = response;
-    this.name = 'TemporaryError';
+    this.name = "TemporaryError";
 
     Object.setPrototypeOf(this, TemporaryError.prototype);
   }
@@ -74,16 +75,16 @@ export async function retry(
   options: {
     config: RetryConfig;
     statusCodes: string[];
-  }
+  },
 ): Promise<Response> {
   switch (options.config.strategy) {
-    case 'backoff':
+    case "backoff":
       return retryBackoff(
         wrapFetcher(fetchFn, {
           statusCodes: options.statusCodes,
           retryConnectionErrors: !!options.config.retryConnectionErrors,
         }),
-        options.config.backoff ?? defaultBackoff
+        options.config.backoff ?? defaultBackoff,
       );
     default:
       return await fetchFn();
@@ -95,13 +96,16 @@ function wrapFetcher(
   options: {
     statusCodes: string[];
     retryConnectionErrors: boolean;
-  }
+  },
 ): () => Promise<Response> {
   return async () => {
     try {
       const res = await fn();
       if (isRetryableResponse(res, options.statusCodes)) {
-        throw new TemporaryError('Response failed with retryable status code', res);
+        throw new TemporaryError(
+          "Response failed with retryable status code",
+          res,
+        );
       }
 
       return res;
@@ -110,16 +114,19 @@ function wrapFetcher(
         throw err;
       }
 
-      if (options.retryConnectionErrors && (isTimeoutError(err) || isConnectionError(err))) {
+      if (
+        options.retryConnectionErrors &&
+        (isTimeoutError(err) || isConnectionError(err))
+      ) {
         throw err;
       }
 
-      throw new PermanentError('Permanent error', { cause: err });
+      throw new PermanentError("Permanent error", { cause: err });
     }
   };
 }
 
-const codeRangeRE = /^[0-9]xx$/i;
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
 
 function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
   const actual = `${res.status}`;
@@ -131,7 +138,7 @@ function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
 
     const expectFamily = code.charAt(0);
     if (!expectFamily) {
-      throw new Error('Invalid status code range');
+      throw new Error("Invalid status code range");
     }
 
     const actualFamily = actual.charAt(0);
@@ -145,7 +152,7 @@ function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
 
 async function retryBackoff(
   fn: () => Promise<Response>,
-  strategy: BackoffStrategy
+  strategy: BackoffStrategy,
 ): Promise<Response> {
   const { maxElapsedTime, initialInterval, exponent, maxInterval } = strategy;
 
@@ -175,7 +182,8 @@ async function retryBackoff(
       }
 
       if (retryInterval <= 0) {
-        retryInterval = initialInterval * x ** exponent + Math.random() * 1000;
+        retryInterval =
+          initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
       }
 
       const d = Math.min(retryInterval, maxInterval);
@@ -187,7 +195,7 @@ async function retryBackoff(
 }
 
 function retryIntervalFromResponse(res: Response): number {
-  const retryVal = res.headers.get('retry-after') || '';
+  const retryVal = res.headers.get("retry-after") || "";
   if (!retryVal) {
     return 0;
   }

package/src/lib/schemas.ts

@@ -1,34 +1,24 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0247cbe8ccc2
  */
 
-import {
-  type output,
-  type ZodEffects,
-  ZodError,
-  type ZodObject,
-  type ZodRawShape,
-  type ZodTypeAny,
-} from 'zod';
-import { SDKValidationError } from '../models/errors/sdkvalidationerror.js';
-import { ERR, OK, type Result } from '../types/fp.js';
+import * as z from "zod";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 
 export function collectExtraKeys<
-  Shape extends ZodRawShape,
-  Catchall extends ZodTypeAny,
+  Shape extends z.ZodRawShape,
+  Catchall extends z.ZodType,
   K extends string,
+  Optional extends boolean,
 >(
-  obj: ZodObject<Shape, 'strip', Catchall>,
+  obj: z.ZodObject<Shape, z.core.$catchall<Catchall>>,
   extrasKey: K,
-  optional: boolean
-): ZodEffects<
-  typeof obj,
-  output<ZodObject<Shape, 'strict'>> & {
-    [k in K]: Record<string, output<Catchall>>;
-  }
-> {
-  return obj.transform((val) => {
-    const extras: Record<string, output<Catchall>> = {};
+  optional: Optional,
+) {
+  return obj.transform((val: any) => {
+    const extras: Record<string, z.output<Catchall>> = {};
     const { shape } = obj;
     for (const [key] of Object.entries(val)) {
       if (key in shape) {
@@ -36,7 +26,7 @@ export function collectExtraKeys<
       }
 
       const v = val[key];
-      if (typeof v === 'undefined') {
+      if (typeof v === "undefined") {
         continue;
       }
 
@@ -57,11 +47,15 @@ export function collectExtraKeys<
  * intercepts this error and converts it to an SDKValidationError so as to not
  * leak Zod implementation details to user code.
  */
-export function parse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMessage: string): Out {
+export function parse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+): Out {
   try {
     return fn(rawValue);
   } catch (err) {
-    if (err instanceof ZodError) {
+    if (err instanceof z.ZodError) {
       throw new SDKValidationError(errorMessage, err, rawValue);
     }
     throw err;
@@ -76,7 +70,7 @@ export function parse<Inp, Out>(rawValue: Inp, fn: (value: Inp) => Out, errorMes
 export function safeParse<Inp, Out>(
   rawValue: Inp,
   fn: (value: Inp) => Out,
-  errorMessage: string
+  errorMessage: string,
 ): Result<Out, SDKValidationError> {
   try {
     return OK(fn(rawValue));