@slates/provider-handler 1.0.0-rc.3 → 1.0.0-rc.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.32",
   "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,23 @@
   "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",
-    "@slates/provider-handler": "^1.0.0-rc.2",
+    "@lowerdeck/error": "^1.1.0",
+    "@slates/proto": "1.0.0-rc.19",
+    "@slates/provider": "1.0.0-rc.23",
+    "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/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);
+  });
+});