@slates/provider-handler 1.0.0-rc.22 → 1.0.0-rc.26

package/dist/index.cjs

@@ -37,6 +37,22 @@ var import_error4 = require("@lowerdeck/error");
 var import_proto = require("@slates/proto");
 var import_provider2 = require("@slates/provider");
 
+// src/pQueue.ts
+var import_p_queue = __toESM(require("p-queue"), 1);
+var resolveDefaultExport = (value) => {
+  let current = value;
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === "function") return current;
+    if (current && typeof current === "object" && "default" in current) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  throw new TypeError("Module export is not a constructor");
+};
+var PQueue = resolveDefaultExport(import_p_queue.default);
+
 // src/spec.ts
 var import_error2 = require("@lowerdeck/error");
 var import_provider = require("@slates/provider");
@@ -94,8 +110,7 @@ var mapAuthMethod = (slate, m) => ({
   scopes: "scopes" in m ? m.scopes.map((s) => ({
     id: s.scope,
     title: s.title,
-    description: s.description,
-    defaultChecked: s.defaultChecked
+    description: s.description
   })) : void 0,
   inputSchema: toJsonSchema(m.inputSchema ?? import_zod.default.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
@@ -253,6 +268,36 @@ var serializeWebhookHttpResponse = async (response) => {
 };
 
 // src/index.ts
+var DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 1e8;
+var routeAttachmentsThroughDirectUpload = async (attachments, live) => {
+  if (!attachments || attachments.length === 0 || !live) return attachments;
+  let contentEntries = attachments.map((attachment, index) => ({ attachment, index })).filter((entry) => entry.attachment.content.type === "content");
+  if (contentEntries.length === 0) return attachments;
+  let queue = new PQueue({ concurrency: 10 });
+  let replacements = /* @__PURE__ */ new Map();
+  await Promise.all(
+    contentEntries.map(
+      (entry) => queue.add(async () => {
+        try {
+          let body = entry.attachment.content.type === "content" ? entry.attachment.content.encoding === "base64" ? Buffer.from(entry.attachment.content.content, "base64") : Buffer.from(entry.attachment.content.content, "utf-8") : Buffer.alloc(0);
+          replacements.set(
+            entry.index,
+            await (0, import_provider2.uploadAttachmentDirect)({
+              live,
+              mimeType: entry.attachment.mimeType,
+              body
+            })
+          );
+        } catch {
+          replacements.set(entry.index, null);
+        }
+      })
+    )
+  );
+  return attachments.map(
+    (attachment, index) => replacements.has(index) ? replacements.get(index) : attachment
+  ).filter((a) => a != null);
+};
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getObjectKeyCount = (value) => isRecord(value) ? Object.keys(value).length : void 0;
 var DOWNLOAD_ATTACHMENT_URL_KEYS = /* @__PURE__ */ new Set([
@@ -316,6 +361,19 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   let auth = new State(null);
   let config = new State(null);
   let session = new State(null);
+  let hubCapabilities = new State(null);
+  let liveInvocation = new State(
+    null
+  );
+  let getLiveInvocation = () => {
+    let directUpload = hubCapabilities.get()?.attachments?.directUpload;
+    let live = liveInvocation.get();
+    if (!directUpload?.enabled || !live) return null;
+    return {
+      ...live,
+      maxAttachmentSizeBytes: directUpload.maxAttachmentSizeBytes ?? DEFAULT_MAX_ATTACHMENT_SIZE_BYTES
+    };
+  };
   let logger = new import_provider2.SlateLogger(listeners);
   let providerTrace = {
     providerId: slate.spec.key,
@@ -442,6 +500,15 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       state: params.state
     });
   });
+  manager.onNotification("slates/hub.capabilities.set", async ({ params }) => {
+    hubCapabilities.set(params.capabilities);
+  });
+  manager.onNotification("slates/hub.live_invocation.set", async ({ params }) => {
+    liveInvocation.set({
+      token: params.token,
+      baseUrl: params.baseUrl
+    });
+  });
   manager.onRequest("slates/config.changed", async ({ params }) => {
     getContextBasic();
     let newConfig = validate(
@@ -906,19 +973,39 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         },
         () => (0, import_provider2.runWithContext)(context, () => action.handleInvocation(context))
       );
+      let contextAttachments = await context._finalizeAttachments();
+      let merged = mergeAttachments(
+        [...res.attachments ?? [], ...contextAttachments],
+        res.output
+      );
+      let redacted = (0, import_provider2.redactUrlAttachmentSecrets)(
+        merged,
+        context._getAuthConfigForRedaction()
+      );
+      let finalAttachments = await routeAttachmentsThroughDirectUpload(
+        redacted,
+        getLiveInvocation()
+      );
       return withRequestTraces(context, {
         output: res.output,
         message: res.message,
-        attachments: mergeAttachments(res.attachments, res.output)
+        attachments: finalAttachments
       });
     };
     if (action.isPublic) {
       getContextBasic();
-      return invoke(new import_provider2.SlatePublicContext(input, slate.spec, logger));
+      return invoke(new import_provider2.SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
     }
     let ctx = getContextFull();
     return invoke(
-      new import_provider2.SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger)
+      new import_provider2.SlateContext(
+        ctx.config,
+        input,
+        ctx.auth?.output,
+        slate.spec,
+        logger,
+        getLiveInvocation()
+      )
     );
   });
   manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {

package/dist/index.module.js

@@ -5,12 +5,30 @@ import {
   SLATES_PROTOCOL_VERSION
 } from "@slates/proto";
 import {
+  redactUrlAttachmentSecrets,
   runWithContext,
   SlateContext,
   SlateLogger,
-  SlatePublicContext
+  SlatePublicContext,
+  uploadAttachmentDirect
 } from "@slates/provider";
 
+// src/pQueue.ts
+import PQueueImport from "p-queue";
+var resolveDefaultExport = (value) => {
+  let current = value;
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === "function") return current;
+    if (current && typeof current === "object" && "default" in current) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  throw new TypeError("Module export is not a constructor");
+};
+var PQueue = resolveDefaultExport(PQueueImport);
+
 // src/spec.ts
 import { badRequestError, notFoundError, ServiceError as ServiceError2 } from "@lowerdeck/error";
 import {
@@ -70,8 +88,7 @@ var mapAuthMethod = (slate, m) => ({
   scopes: "scopes" in m ? m.scopes.map((s) => ({
     id: s.scope,
     title: s.title,
-    description: s.description,
-    defaultChecked: s.defaultChecked
+    description: s.description
   })) : void 0,
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
@@ -229,6 +246,36 @@ var serializeWebhookHttpResponse = async (response) => {
 };
 
 // src/index.ts
+var DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 1e8;
+var routeAttachmentsThroughDirectUpload = async (attachments, live) => {
+  if (!attachments || attachments.length === 0 || !live) return attachments;
+  let contentEntries = attachments.map((attachment, index) => ({ attachment, index })).filter((entry) => entry.attachment.content.type === "content");
+  if (contentEntries.length === 0) return attachments;
+  let queue = new PQueue({ concurrency: 10 });
+  let replacements = /* @__PURE__ */ new Map();
+  await Promise.all(
+    contentEntries.map(
+      (entry) => queue.add(async () => {
+        try {
+          let body = entry.attachment.content.type === "content" ? entry.attachment.content.encoding === "base64" ? Buffer.from(entry.attachment.content.content, "base64") : Buffer.from(entry.attachment.content.content, "utf-8") : Buffer.alloc(0);
+          replacements.set(
+            entry.index,
+            await uploadAttachmentDirect({
+              live,
+              mimeType: entry.attachment.mimeType,
+              body
+            })
+          );
+        } catch {
+          replacements.set(entry.index, null);
+        }
+      })
+    )
+  );
+  return attachments.map(
+    (attachment, index) => replacements.has(index) ? replacements.get(index) : attachment
+  ).filter((a) => a != null);
+};
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getObjectKeyCount = (value) => isRecord(value) ? Object.keys(value).length : void 0;
 var DOWNLOAD_ATTACHMENT_URL_KEYS = /* @__PURE__ */ new Set([
@@ -292,6 +339,19 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   let auth = new State(null);
   let config = new State(null);
   let session = new State(null);
+  let hubCapabilities = new State(null);
+  let liveInvocation = new State(
+    null
+  );
+  let getLiveInvocation = () => {
+    let directUpload = hubCapabilities.get()?.attachments?.directUpload;
+    let live = liveInvocation.get();
+    if (!directUpload?.enabled || !live) return null;
+    return {
+      ...live,
+      maxAttachmentSizeBytes: directUpload.maxAttachmentSizeBytes ?? DEFAULT_MAX_ATTACHMENT_SIZE_BYTES
+    };
+  };
   let logger = new SlateLogger(listeners);
   let providerTrace = {
     providerId: slate.spec.key,
@@ -418,6 +478,15 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       state: params.state
     });
   });
+  manager.onNotification("slates/hub.capabilities.set", async ({ params }) => {
+    hubCapabilities.set(params.capabilities);
+  });
+  manager.onNotification("slates/hub.live_invocation.set", async ({ params }) => {
+    liveInvocation.set({
+      token: params.token,
+      baseUrl: params.baseUrl
+    });
+  });
   manager.onRequest("slates/config.changed", async ({ params }) => {
     getContextBasic();
     let newConfig = validate(
@@ -882,19 +951,39 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         },
         () => runWithContext(context, () => action.handleInvocation(context))
       );
+      let contextAttachments = await context._finalizeAttachments();
+      let merged = mergeAttachments(
+        [...res.attachments ?? [], ...contextAttachments],
+        res.output
+      );
+      let redacted = redactUrlAttachmentSecrets(
+        merged,
+        context._getAuthConfigForRedaction()
+      );
+      let finalAttachments = await routeAttachmentsThroughDirectUpload(
+        redacted,
+        getLiveInvocation()
+      );
       return withRequestTraces(context, {
         output: res.output,
         message: res.message,
-        attachments: mergeAttachments(res.attachments, res.output)
+        attachments: finalAttachments
       });
     };
     if (action.isPublic) {
       getContextBasic();
-      return invoke(new SlatePublicContext(input, slate.spec, logger));
+      return invoke(new SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
     }
     let ctx = getContextFull();
     return invoke(
-      new SlateContext(ctx.config, input, ctx.auth?.output, slate.spec, logger)
+      new SlateContext(
+        ctx.config,
+        input,
+        ctx.auth?.output,
+        slate.spec,
+        logger,
+        getLiveInvocation()
+      )
     );
   });
   manager.onRequest("slates/action.trigger.map_event", async ({ params }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.22",
+  "version": "1.0.0-rc.26",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,9 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.15",
-    "@slates/provider": "1.0.0-rc.18",
+    "@slates/proto": "1.0.0-rc.16",
+    "@slates/provider": "1.0.0-rc.20",
+    "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },
   "devDependencies": {

package/src/attachments.test.ts

@@ -0,0 +1,171 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import {
+  Slate,
+  SlateAuth,
+  SlateConfig,
+  SlatePublicTool,
+  SlateSpecification
+} from '@slates/provider';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+import { createProviderHandler } from './index';
+
+let createManager = async () => {
+  let spec = SlateSpecification.create({
+    key: 'attachments-test',
+    name: 'Attachments Test',
+    config: SlateConfig.create(z.object({})),
+    auth: SlateAuth.create().output(z.object({}))
+  });
+  let tool = SlatePublicTool.create(spec, {
+    key: 'attach',
+    name: 'Attach'
+  })
+    .input(z.object({}))
+    .output(z.object({}))
+    .handleInvocation(async ctx => {
+      await ctx.addAttachment({
+        type: 'content',
+        content: new Response('hello', {
+          headers: { 'content-type': 'text/plain' }
+        }),
+        filename: 'hello.txt'
+      });
+
+      return { output: {}, message: 'ok' };
+    })
+    .build();
+  let slate = Slate.create({ spec, triggers: [], tools: [tool] });
+  let manager = await createProviderHandler(slate, []).run();
+
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hello',
+    params: { protocol: SLATES_PROTOCOL_VERSION }
+  });
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/participant.set',
+    params: {
+      participants: [
+        { type: 'consumer', id: 'consumer', name: 'Consumer' },
+        { type: 'hub', id: 'hub', name: 'Hub' }
+      ]
+    }
+  });
+
+  return manager;
+};
+
+let invoke = async (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'request',
+    method: 'slates/action.tool.invoke',
+    params: { actionId: 'attach', input: {} }
+  });
+
+let expectInlineAttachment = (response: Awaited<ReturnType<typeof invoke>>) => {
+  expect(response).toMatchObject({
+    result: {
+      attachments: [
+        {
+          mimeType: 'text/plain',
+          content: {
+            type: 'content',
+            encoding: 'base64',
+            content: Buffer.from('hello').toString('base64')
+          }
+        }
+      ]
+    }
+  });
+};
+
+describe('addAttachment fallback', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns a standard inline attachment when capabilities and a live token are absent', async () => {
+    let fetchSpy = vi.spyOn(globalThis, 'fetch');
+    let response = await invoke(await createManager());
+
+    expectInlineAttachment(response);
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it('returns a standard inline attachment when direct upload is enabled without a live token', async () => {
+    let manager = await createManager();
+    let fetchSpy = vi.spyOn(globalThis, 'fetch');
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { attachments: { directUpload: { enabled: true } } } }
+    });
+
+    expectInlineAttachment(await invoke(manager));
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it('returns a standard inline attachment when a live token exists without the capability', async () => {
+    let manager = await createManager();
+    let fetchSpy = vi.spyOn(globalThis, 'fetch');
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.live_invocation.set',
+      params: { token: 'token', baseUrl: 'https://hub.example' }
+    });
+
+    expectInlineAttachment(await invoke(manager));
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it('uses direct upload only when both the capability and live token exist', async () => {
+    let manager = await createManager();
+    let fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            attachments: [
+              {
+                referenceId: 'attachment-reference',
+                uploadUrl: 'https://uploads.example/attachment'
+              }
+            ]
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } }
+        )
+      )
+      .mockResolvedValueOnce(new Response(null, { status: 200 }));
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { attachments: { directUpload: { enabled: true } } } }
+    });
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.live_invocation.set',
+      params: { token: 'token', baseUrl: 'https://hub.example' }
+    });
+
+    expect(await invoke(manager)).toMatchObject({
+      result: {
+        attachments: [
+          {
+            mimeType: 'text/plain',
+            content: {
+              type: 'upload_reference',
+              referenceId: 'attachment-reference'
+            }
+          }
+        ]
+      }
+    });
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+  });
+});

package/src/index.ts

@@ -5,14 +5,18 @@ import {
   type SlatesParticipant
 } from '@slates/proto';
 import {
+  redactUrlAttachmentSecrets,
   runWithContext,
   type Slate,
   type SlateAttachment,
   SlateContext,
+  type SlateLiveInvocationInfo,
   SlateLogger,
   type SlateLogListener,
-  SlatePublicContext
+  SlatePublicContext,
+  uploadAttachmentDirect
 } from '@slates/provider';
+import { PQueue } from './pQueue';
 import {
   getAction,
   getActionWithType,
@@ -26,6 +30,57 @@ import { State } from './state';
 import { toJsonSchema, validate } from './validation';
 import { serializeWebhookHttpResponse } from './webhook';
 
+let DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 100_000_000;
+
+let routeAttachmentsThroughDirectUpload = async (
+  attachments: SlateAttachment[] | undefined,
+  live: SlateLiveInvocationInfo | null
+): Promise<SlateAttachment[] | undefined> => {
+  if (!attachments || attachments.length === 0 || !live) return attachments;
+
+  let contentEntries = attachments
+    .map((attachment, index) => ({ attachment, index }))
+    .filter(entry => entry.attachment.content.type === 'content');
+  if (contentEntries.length === 0) return attachments;
+
+  let queue = new PQueue({ concurrency: 10 });
+  let replacements = new Map<number, SlateAttachment | null>();
+
+  await Promise.all(
+    contentEntries.map(entry =>
+      queue.add(async () => {
+        try {
+          let body =
+            entry.attachment.content.type === 'content'
+              ? entry.attachment.content.encoding === 'base64'
+                ? Buffer.from(entry.attachment.content.content, 'base64')
+                : Buffer.from(entry.attachment.content.content, 'utf-8')
+              : Buffer.alloc(0);
+
+          replacements.set(
+            entry.index,
+            await uploadAttachmentDirect({
+              live,
+              mimeType: entry.attachment.mimeType,
+              body
+            })
+          );
+        } catch {
+          // Upload failed or was interrupted -- we simply don't have this attachment, not a
+          // failed tool call.
+          replacements.set(entry.index, null);
+        }
+      })
+    )
+  );
+
+  return attachments
+    .map((attachment, index) =>
+      replacements.has(index) ? replacements.get(index) : attachment
+    )
+    .filter((a): a is SlateAttachment => a != null);
+};
+
 let isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
@@ -128,6 +183,26 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     let config = new State<{ value: ConfigType } | null>(null);
     let session = new State<{ id: string; state: any } | null>(null);
 
+    let hubCapabilities = new State<{
+      attachments?: { directUpload?: { enabled: boolean; maxAttachmentSizeBytes?: number } };
+    } | null>(null);
+    let liveInvocation = new State<Pick<SlateLiveInvocationInfo, 'token' | 'baseUrl'> | null>(
+      null
+    );
+
+    let getLiveInvocation = (): SlateLiveInvocationInfo | null => {
+      let directUpload = hubCapabilities.get()?.attachments?.directUpload;
+      let live = liveInvocation.get();
+
+      if (!directUpload?.enabled || !live) return null;
+
+      return {
+        ...live,
+        maxAttachmentSizeBytes:
+          directUpload.maxAttachmentSizeBytes ?? DEFAULT_MAX_ATTACHMENT_SIZE_BYTES
+      };
+    };
+
     let logger = new SlateLogger(listeners);
     let providerTrace = {
       providerId: slate.spec.key,
@@ -301,6 +376,17 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       });
     });
 
+    manager.onNotification('slates/hub.capabilities.set', async ({ params }) => {
+      hubCapabilities.set(params.capabilities);
+    });
+
+    manager.onNotification('slates/hub.live_invocation.set', async ({ params }) => {
+      liveInvocation.set({
+        token: params.token,
+        baseUrl: params.baseUrl
+      });
+    });
+
     manager.onRequest('slates/config.changed', async ({ params }) => {
       getContextBasic();
 
@@ -828,21 +914,43 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           () => runWithContext(context, () => action.handleInvocation(context as any))
         );
 
+        let contextAttachments = await context._finalizeAttachments();
+        let merged = mergeAttachments(
+          [...(res.attachments ?? []), ...contextAttachments],
+          res.output
+        );
+
+        let redacted = redactUrlAttachmentSecrets(
+          merged,
+          context._getAuthConfigForRedaction()
+        );
+        let finalAttachments = await routeAttachmentsThroughDirectUpload(
+          redacted,
+          getLiveInvocation()
+        );
+
         return withRequestTraces(context, {
           output: res.output,
           message: res.message,
-          attachments: mergeAttachments(res.attachments, res.output)
+          attachments: finalAttachments
         });
       };
 
       if (action.isPublic) {
         getContextBasic();
-        return invoke(new SlatePublicContext(input, slate.spec, logger));
+        return invoke(new SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
       }
 
       let ctx = getContextFull();
       return invoke(
-        new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger)
+        new SlateContext(
+          ctx.config,
+          input,
+          ctx.auth?.output!,
+          slate.spec,
+          logger,
+          getLiveInvocation()
+        )
       );
     });
 

package/src/pQueue.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { resolveDefaultExport } from './pQueue';
+
+class Example {
+  value: number;
+  constructor(value: number) {
+    this.value = value;
+  }
+}
+
+describe('resolveDefaultExport', () => {
+  it('unwraps nested CJS default exports from bundlers', () => {
+    expect(resolveDefaultExport<typeof Example>({ default: { default: Example } })).toBe(
+      Example
+    );
+    expect(new (resolveDefaultExport<typeof Example>({ default: Example }))(3).value).toBe(3);
+  });
+});

package/src/pQueue.ts

@@ -0,0 +1,18 @@
+import PQueueImport from 'p-queue';
+
+export let resolveDefaultExport = <T>(value: unknown): T => {
+  let current = value;
+
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === 'function') return current as T;
+    if (current && typeof current === 'object' && 'default' in current) {
+      current = (current as { default: unknown }).default;
+      continue;
+    }
+    break;
+  }
+
+  throw new TypeError('Module export is not a constructor');
+};
+
+export let PQueue = resolveDefaultExport<typeof PQueueImport>(PQueueImport);

package/src/spec.ts

@@ -41,8 +41,7 @@ export let mapAuthMethod = <ConfigType extends {}, AuthType extends {}>(
       ? m.scopes.map(s => ({
           id: s.scope,
           title: s.title,
-          description: s.description,
-          defaultChecked: s.defaultChecked
+          description: s.description
         }))
       : undefined,