@slates/provider-handler 1.0.0-rc.4 → 1.0.0-rc.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.41",
   "publishConfig": {
     "access": "public"
   },
@@ -11,7 +11,7 @@
     "package.json"
   ],
   "author": "Tobias Herber",
-  "license": "Apache 2",
+  "license": "FSL 1.1",
   "type": "module",
   "source": "src/index.ts",
   "exports": {
@@ -23,22 +23,24 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.module.js",
   "types": "dist/index.d.ts",
-  "unpkg": "./dist/index.umd.js",
+  "unpkg": "./dist/index.module.js",
   "scripts": {
     "test": "vitest run --passWithNoTests",
-    "lint": "prettier src/**/*.ts --check",
-    "build": "microbundle"
+    "build": "tsup --config ../../tsup.packages.config.ts",
+    "typecheck": "tsc --noEmit",
+    "biome:check": "biome check --write src"
   },
   "dependencies": {
-    "@lowerdeck/error": "^1.0.8",
-    "@slates/proto": "^1.0.0-rc.5",
-    "@slates/provider": "^1.0.0-rc.2",
+    "@lowerdeck/error": "^1.1.0",
+    "@slates/proto": "1.0.0-rc.26",
+    "@slates/provider": "1.0.0-rc.31",
+    "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "microbundle": "^0.15.1",
-    "@slates/tsconfig": "^1.0.0",
+    "@slates/tsconfig": "1.0.0-rc.1",
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/adminSetup.test.ts

@@ -0,0 +1,189 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import { describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+import { createProviderHandler } from './index';
+
+let createManager = async (method: Record<string, any>) => {
+  let slate = {
+    spec: {
+      key: 'test',
+      name: 'Test',
+      auth: {
+        authStack: [
+          {
+            type: 'auth.oauth',
+            key: 'oauth',
+            name: 'OAuth',
+            scopes: [],
+            ...method
+          }
+        ],
+        outputSchema: z.object({ token: z.string() })
+      }
+    },
+    adapters: [],
+    actions: [],
+    triggerGroups: []
+  };
+  let manager = await createProviderHandler(slate as any, []).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: [] }
+  });
+
+  return manager;
+};
+
+let baseParams = {
+  authenticationMethodId: 'oauth',
+  state: 'state-123',
+  redirectUri: 'https://hub.example/callback',
+  input: { tenant: 'acme' },
+  clientId: 'client-id',
+  clientSecret: 'client-secret',
+  scopes: ['read']
+};
+
+let getAdminAuthorizationUrl = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'url',
+    method: 'slates/auth.admin_authorization_url.get',
+    params: baseParams
+  });
+
+let handleAdminCallback = (
+  manager: SlatesProviderProtoHandlerManager,
+  params: { code?: string; callbackParams?: Record<string, string> } = {}
+) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'callback',
+    method: 'slates/auth.admin_callback.handle',
+    params: { ...baseParams, ...params }
+  });
+
+let regularMethod = () => ({
+  getAuthorizationUrl: vi.fn(async () => ({
+    url: 'https://provider.example/authorize',
+    callbackState: { verifier: 'regular' }
+  })),
+  handleCallback: vi.fn(async () => ({ output: { token: 'user-token' } }))
+});
+
+describe('slates/auth.admin_authorization_url.get', () => {
+  it('falls back to the regular authorization URL', async () => {
+    let method = regularMethod();
+    let manager = await createManager({ ...method, adminSetup: {} });
+
+    expect(await getAdminAuthorizationUrl(manager)).toEqual({
+      jsonrpc: '2.0',
+      id: 'url',
+      result: {
+        authorizationUrl: 'https://provider.example/authorize',
+        callbackState: { verifier: 'regular' }
+      }
+    });
+    let { authenticationMethodId: _, ...ctx } = baseParams;
+    expect(method.getAuthorizationUrl).toHaveBeenCalledWith({ ...ctx, config: {} });
+  });
+
+  it('uses the admin authorization URL override', async () => {
+    let method = regularMethod();
+    let adminGetAuthorizationUrl = vi.fn(async () => ({
+      url: 'https://provider.example/adminconsent',
+      input: { tenant: 'acme' }
+    }));
+    let manager = await createManager({
+      ...method,
+      adminSetup: { getAuthorizationUrl: adminGetAuthorizationUrl }
+    });
+
+    expect(await getAdminAuthorizationUrl(manager)).toMatchObject({
+      result: {
+        authorizationUrl: 'https://provider.example/adminconsent',
+        input: { tenant: 'acme' }
+      }
+    });
+    expect(adminGetAuthorizationUrl).toHaveBeenCalledWith(
+      expect.objectContaining({ clientId: 'client-id', state: 'state-123', config: {} })
+    );
+    expect(method.getAuthorizationUrl).not.toHaveBeenCalled();
+  });
+
+  it('rejects methods without admin setup', async () => {
+    let manager = await createManager(regularMethod());
+
+    expect(await getAdminAuthorizationUrl(manager)).toMatchObject({
+      error: { code: 'request.precondition_failed' }
+    });
+  });
+});
+
+describe('slates/auth.admin_callback.handle', () => {
+  it('runs the regular callback and discards its output by default', async () => {
+    let method = regularMethod();
+    let manager = await createManager({ ...method, adminSetup: {} });
+
+    expect(await handleAdminCallback(manager, { code: 'admin-code' })).toEqual({
+      jsonrpc: '2.0',
+      id: 'callback',
+      result: {}
+    });
+    expect(method.handleCallback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        code: 'admin-code',
+        clientId: 'client-id',
+        callbackParams: {},
+        callbackState: {},
+        config: {}
+      })
+    );
+  });
+
+  it('requires a code when falling back to the regular callback', async () => {
+    let method = regularMethod();
+    let manager = await createManager({ ...method, adminSetup: {} });
+
+    expect(await handleAdminCallback(manager)).toMatchObject({
+      error: { code: 'request.bad', message: expect.stringContaining('authorization code') }
+    });
+    expect(method.handleCallback).not.toHaveBeenCalled();
+  });
+
+  it('uses the admin callback override without a code', async () => {
+    let method = regularMethod();
+    let adminHandleCallback = vi.fn(async () => ({ instructions: '1. Trust the app.' }));
+    let manager = await createManager({
+      ...method,
+      adminSetup: { handleCallback: adminHandleCallback }
+    });
+
+    expect(
+      await handleAdminCallback(manager, { callbackParams: { admin_consent: 'True' } })
+    ).toMatchObject({ result: { instructions: '1. Trust the app.' } });
+    expect(adminHandleCallback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        code: undefined,
+        callbackParams: { admin_consent: 'True' },
+        callbackState: {}
+      })
+    );
+    expect(method.handleCallback).not.toHaveBeenCalled();
+  });
+
+  it('rejects methods without admin setup', async () => {
+    let manager = await createManager(regularMethod());
+
+    expect(await handleAdminCallback(manager, { code: 'admin-code' })).toMatchObject({
+      error: { code: 'request.precondition_failed' }
+    });
+  });
+});

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/exposure.test.ts

@@ -0,0 +1,216 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { createProviderHandler } from './index';
+
+let createManager = async () => {
+  let providerGroup = {
+    key: 'provider_group',
+    name: 'Provider Group',
+    description: undefined,
+    metadata: {},
+    source: 'polling',
+    polling: { intervalSeconds: 60 }
+  };
+  let adapterGroup = {
+    key: 'adapter_group',
+    name: 'Adapter Group',
+    description: undefined,
+    metadata: {},
+    source: 'polling',
+    polling: { intervalSeconds: 60 }
+  };
+  let emptyGroup = {
+    key: 'empty_group',
+    name: 'Empty Group',
+    description: undefined,
+    metadata: {},
+    source: 'polling',
+    polling: { intervalSeconds: 60 }
+  };
+  let action = {
+    name: 'Action',
+    description: undefined,
+    instructions: undefined,
+    constraints: undefined,
+    tags: [],
+    metadata: {},
+    scopes: [],
+    authMethods: [],
+    docs: [],
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+    matches: () => true,
+    map: async () => ({ type: 'event', output: {} })
+  };
+  let slate = {
+    spec: { key: 'test', name: 'Test' },
+    adapters: [{ id: 'chat', name: 'Chat', capabilities: [] }],
+    actions: [
+      { ...action, key: 'provider_tool', type: 'tool', isPublic: false },
+      {
+        ...action,
+        key: 'adapter_tool',
+        type: 'tool',
+        adapter: 'chat',
+        isPublic: false
+      },
+      { ...action, key: 'provider_trigger', type: 'trigger', triggerGroup: providerGroup },
+      {
+        ...action,
+        key: 'adapter_trigger',
+        type: 'trigger',
+        adapter: 'chat',
+        triggerGroup: adapterGroup
+      }
+    ],
+    triggerGroups: [providerGroup, adapterGroup, emptyGroup]
+  };
+  let manager = await createProviderHandler(slate as any, []).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: [] }
+  });
+
+  return manager;
+};
+
+let request = async (
+  manager: SlatesProviderProtoHandlerManager,
+  method:
+    | 'slates/actions.list'
+    | 'slates/action.get'
+    | 'slates/adapters.list'
+    | 'slates/adapter.get'
+    | 'slates/trigger_groups.list',
+  params: Record<string, unknown> = {}
+) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: method,
+    method,
+    params
+  } as any);
+
+describe('adapter capability exposure', () => {
+  it('hides adapter surfaces from a legacy hub that only supports triggers', async () => {
+    let manager = await createManager();
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { triggers: true } }
+    });
+
+    expect(await request(manager, 'slates/adapters.list')).toMatchObject({
+      result: { adapters: [] }
+    });
+    expect(
+      await request(manager, 'slates/actions.list', { includeAdapterActions: true })
+    ).toMatchObject({
+      result: { actions: [{ id: 'provider_tool' }, { id: 'provider_trigger' }] }
+    });
+    expect(await request(manager, 'slates/trigger_groups.list')).toMatchObject({
+      result: { triggerGroups: [{ id: 'provider_group' }] }
+    });
+    expect(await request(manager, 'slates/adapter.get', { adapterId: 'chat' })).toHaveProperty(
+      'error'
+    );
+    expect(
+      await request(manager, 'slates/action.get', { actionId: 'adapter_tool' })
+    ).toHaveProperty('error');
+  });
+
+  it('exposes adapters and their actions when the hub enables them', async () => {
+    let manager = await createManager();
+
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { adapters: true, triggers: true } }
+    });
+
+    expect(await request(manager, 'slates/adapters.list')).toMatchObject({
+      result: { adapters: [{ id: 'chat' }] }
+    });
+    expect(
+      await request(manager, 'slates/actions.list', { includeAdapterActions: true })
+    ).toMatchObject({
+      result: {
+        actions: [
+          { id: 'provider_tool' },
+          { id: 'adapter_tool' },
+          { id: 'provider_trigger' },
+          { id: 'adapter_trigger' }
+        ]
+      }
+    });
+    expect(await request(manager, 'slates/trigger_groups.list')).toMatchObject({
+      result: {
+        triggerGroups: [{ id: 'provider_group' }, { id: 'adapter_group' }]
+      }
+    });
+  });
+
+  it('returns empty adapter and trigger group lists for older slates that omit those collections', async () => {
+    let manager = await createProviderHandler(
+      {
+        spec: { key: 'legacy', name: 'Legacy' },
+        actions: [
+          {
+            key: 'provider_tool',
+            type: 'tool',
+            name: 'Action',
+            description: undefined,
+            instructions: undefined,
+            constraints: undefined,
+            tags: [],
+            metadata: {},
+            scopes: [],
+            authMethods: [],
+            docs: [],
+            inputSchema: z.object({}),
+            outputSchema: z.object({}),
+            isPublic: false
+          }
+        ]
+      } as any,
+      []
+    ).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: [] }
+    });
+    await SlatesProviderProtoHandlerManager.handleInput(manager, {
+      jsonrpc: '2.0',
+      method: 'slates/hub.capabilities.set',
+      params: { capabilities: { adapters: true, triggers: true } }
+    });
+
+    expect(await request(manager, 'slates/adapters.list')).toMatchObject({
+      result: { adapters: [] }
+    });
+    expect(await request(manager, 'slates/trigger_groups.list')).toMatchObject({
+      result: { triggerGroups: [] }
+    });
+    expect(
+      await request(manager, 'slates/actions.list', { includeAdapterActions: true })
+    ).toMatchObject({
+      result: { actions: [{ id: 'provider_tool' }] }
+    });
+  });
+});