@slates/provider 1.0.0-rc.17 → 1.0.0-rc.18

package/dist/index.module.js

@@ -54,6 +54,12 @@ var SlateAction = class {
   get docs() {
     return this._params.docs;
   }
+  get adapter() {
+    return this._params.adapter ?? null;
+  }
+  get isPublic() {
+    return this._params.isPublic === true;
+  }
 };
 
 // src/error/api.ts
@@ -798,11 +804,12 @@ var isScopes = (value) => typeof value === "object" && value !== null && "AND" i
 
 // src/action/builder.ts
 var SlateActionBuilder = class {
-  constructor(type, spec2, params, factory) {
+  constructor(type, spec2, params, factory, isPublicTool = false) {
     this.type = type;
     this.spec = spec2;
     this.params = params;
     this.factory = factory;
+    this.isPublicTool = isPublicTool;
     this.#configSchema = spec2.configSchema;
     this.#authSchema = spec2.authSchema;
   }
@@ -810,6 +817,7 @@ var SlateActionBuilder = class {
   spec;
   params;
   factory;
+  isPublicTool;
   #configSchema;
   #authSchema;
   #inputSchema = null;
@@ -818,20 +826,34 @@ var SlateActionBuilder = class {
   #authMethods;
   #toolParams = null;
   #triggerParams = null;
+  #interfaceLocked = false;
   input(schema) {
+    if (this.#interfaceLocked) {
+      throw new SlateDeclarationError("Adapter contract input schema cannot be changed");
+    }
     this.#inputSchema = schema;
     return this;
   }
   output(schema) {
+    if (this.#interfaceLocked) {
+      throw new SlateDeclarationError("Adapter contract output schema cannot be changed");
+    }
     this.#outputSchema = schema;
     return this;
   }
+  lockInterface() {
+    this.#interfaceLocked = true;
+    return this;
+  }
   scopes(scopes) {
     validateScopes(scopes);
     this.#scopes = scopes;
     return this;
   }
   authMethods(authMethods) {
+    if (this.isPublicTool) {
+      throw new SlateDeclarationError("Public tools cannot require authentication methods");
+    }
     this.#authMethods = this.validateAuthMethods(authMethods);
     return this;
   }
@@ -887,6 +909,9 @@ var SlateActionBuilder = class {
       validateScopes(scopes);
     }
     let authMethods = this.validateAuthMethods(this.#authMethods ?? this.params.authMethods);
+    if (this.isPublicTool && authMethods) {
+      throw new SlateDeclarationError("Public tools cannot require authentication methods");
+    }
     if (!this.#inputSchema) {
       throw new SlateDeclarationError("Input schema is not defined");
     }
@@ -903,6 +928,7 @@ var SlateActionBuilder = class {
       ...this.params,
       scopes,
       authMethods,
+      isPublic: this.isPublicTool === true,
       configSchema: this.#configSchema,
       authSchema: this.#authSchema,
       inputSchema: this.#inputSchema,
@@ -922,16 +948,40 @@ var SlateTool = class _SlateTool extends SlateAction {
   }
   static create(spec2, params) {
     return new SlateActionBuilder("tool", spec2, params, (params2) => {
-      if (params2.type !== "tool") throw new Error("Invalid action type for tool");
-      return new _SlateTool(spec2, params2.inputSchema, params2.outputSchema, params2);
+      return _SlateTool.fromCreateParameters(spec2, params2);
     });
   }
+  static fromCreateParameters(spec2, params) {
+    if (params.type !== "tool") throw new Error("Invalid action type for tool");
+    return new _SlateTool(spec2, params.inputSchema, params.outputSchema, params);
+  }
   get handleInvocation() {
     return this.#handleInvocation;
   }
 };
 var tool = (spec2, params) => SlateTool.create(spec2, params);
 
+// src/action/publicTool.ts
+var SlatePublicTool = class {
+  constructor() {
+  }
+  static create(spec2, params) {
+    return new SlateActionBuilder(
+      "tool",
+      spec2,
+      params,
+      (params2) => {
+        return SlateTool.fromCreateParameters(spec2, {
+          ...params2,
+          isPublic: true
+        });
+      },
+      true
+    );
+  }
+};
+var publicTool = (spec2, params) => SlatePublicTool.create(spec2, params);
+
 // src/action/trigger.ts
 var SlateDefaultPollingIntervalSeconds = 60 * 10;
 var SlateTrigger = class _SlateTrigger extends SlateAction {
@@ -1014,6 +1064,135 @@ var createTextAttachment = (content, mimeType) => ({
   }
 });
 
+// src/adapter/adapter.ts
+var SlateAdapter = class {
+  constructor(_spec, _tools, _triggers) {
+    this._spec = _spec;
+    this._tools = _tools;
+    this._triggers = _triggers;
+  }
+  _spec;
+  _tools;
+  _triggers;
+  get spec() {
+    return this._spec;
+  }
+  get id() {
+    return this._spec.id;
+  }
+  get name() {
+    return this._spec.name;
+  }
+  get capabilities() {
+    return this._spec.capabilities;
+  }
+  get tools() {
+    return this._tools;
+  }
+  get triggers() {
+    return this._triggers;
+  }
+  get actions() {
+    return [...this._triggers, ...this._tools];
+  }
+};
+
+// src/adapter/spec.ts
+var SlateAdapterSpec = class _SlateAdapterSpec {
+  constructor(_params) {
+    this._params = _params;
+  }
+  _params;
+  static create(params) {
+    let id = params.id?.trim();
+    let name = params.name?.trim();
+    if (!id) {
+      throw new SlateDeclarationError("Adapter id must be a non-empty string");
+    }
+    if (!name) {
+      throw new SlateDeclarationError("Adapter name must be a non-empty string");
+    }
+    return new _SlateAdapterSpec({
+      id,
+      name,
+      capabilities: validateCapabilities(params.capabilities ?? [])
+    });
+  }
+  get id() {
+    return this._params.id;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get capabilities() {
+    return this._params.capabilities;
+  }
+  get parameters() {
+    return this._params;
+  }
+  tool(spec2, params) {
+    return SlateTool.create(spec2, this.linkAction(params));
+  }
+  publicTool(spec2, params) {
+    return SlatePublicTool.create(spec2, this.linkAction(params));
+  }
+  trigger(spec2, params) {
+    return SlateTrigger.create(spec2, this.linkAction(params));
+  }
+  register(params) {
+    let actions = [...params.tools, ...params.triggers];
+    let seenKeys = /* @__PURE__ */ new Set();
+    for (let action of actions) {
+      if (action.adapter && action.adapter !== this.id) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" is linked to adapter "${action.adapter}", not "${this.id}"`
+        );
+      }
+      if (!action.adapter) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" must be created with this adapter's tool(), publicTool(), or trigger() helpers`
+        );
+      }
+      if (seenKeys.has(action.key)) {
+        throw new SlateDeclarationError(
+          `Adapter "${this.id}" already has an action with key "${action.key}"`
+        );
+      }
+      seenKeys.add(action.key);
+    }
+    return new SlateAdapter(this, params.tools, params.triggers);
+  }
+  linkAction(params) {
+    if (params.adapter != null && params.adapter !== this.id) {
+      throw new SlateDeclarationError(
+        `Action "${params.key}" cannot be linked to adapter "${this.id}" because it is already linked to "${params.adapter}"`
+      );
+    }
+    return {
+      ...params,
+      adapter: this.id
+    };
+  }
+};
+var adapterSpec = (params) => SlateAdapterSpec.create(params);
+var validateCapabilities = (capabilities) => {
+  let seenIds = /* @__PURE__ */ new Set();
+  return capabilities.map((capability) => {
+    let id = capability.id?.trim();
+    if (!id) {
+      throw new SlateDeclarationError("Adapter capability ids must be non-empty strings");
+    }
+    if (seenIds.has(id)) {
+      throw new SlateDeclarationError(`Adapter capability "${id}" is defined more than once`);
+    }
+    seenIds.add(id);
+    return {
+      id,
+      value: capability.value
+    };
+  });
+};
+
 // src/auth/auth.ts
 var SlateAuth = class _SlateAuth {
   #outputSchema = null;
@@ -1813,26 +1992,19 @@ var SlateConfig = class _SlateConfig {
 var config = (schema) => SlateConfig.create(schema);
 
 // src/context/context.ts
-var SlateContext = class {
-  constructor(config2, input, auth2, spec2, logger) {
+var SlatePublicContext = class {
+  constructor(input, spec2, logger) {
     this.spec = spec2;
     this.logger = logger;
-    this.#config = config2;
     this.#input = input;
-    this.#auth = auth2;
   }
   spec;
   logger;
-  #config;
   #input;
-  #auth;
   #httpTraces = [];
   get specification() {
     return this.spec;
   }
-  get config() {
-    return Object.freeze(this.#config);
-  }
   get input() {
     return Object.freeze(this.#input);
   }
@@ -1850,9 +2022,6 @@ var SlateContext = class {
       this.#input.registrationDetails
     );
   }
-  get auth() {
-    return Object.freeze(this.#auth);
-  }
   recordHttpTrace(trace) {
     this.#httpTraces.push(trace);
   }
@@ -1887,6 +2056,21 @@ var SlateContext = class {
     this.logger.progress(message);
   }
 };
+var SlateContext = class extends SlatePublicContext {
+  #config;
+  #auth;
+  constructor(config2, input, auth2, spec2, logger) {
+    super(input, spec2, logger);
+    this.#config = config2;
+    this.#auth = auth2;
+  }
+  get config() {
+    return Object.freeze(this.#config);
+  }
+  get auth() {
+    return Object.freeze(this.#auth);
+  }
+};
 
 // src/crypto/hmac.ts
 import { createHmac, timingSafeEqual } from "crypto";
@@ -2035,14 +2219,40 @@ var setIfDefined = (target, key, value) => {
 
 // src/specification/slate.ts
 var Slate = class _Slate {
-  constructor(_spec, _actions) {
+  constructor(_spec, _actions, _adapters) {
     this._spec = _spec;
     this._actions = _actions;
+    this._adapters = _adapters;
   }
   _spec;
   _actions;
+  _adapters;
   static create(params) {
-    return new _Slate(params.spec, [...params.triggers, ...params.tools]);
+    let adapters = params.adapters ?? [];
+    let actions = [...params.triggers, ...params.tools];
+    let seenAdapterIds = /* @__PURE__ */ new Set();
+    let seenActionKeys = new Map(actions.map((action) => [action.key, action]));
+    for (let adapter of adapters) {
+      if (seenAdapterIds.has(adapter.id)) {
+        throw new SlateDeclarationError(
+          `Adapter "${adapter.id}" is registered more than once`
+        );
+      }
+      seenAdapterIds.add(adapter.id);
+      for (let action of adapter.actions) {
+        let existing = seenActionKeys.get(action.key);
+        if (existing && existing !== action) {
+          throw new SlateDeclarationError(
+            `Adapter "${adapter.id}" action "${action.key}" conflicts with another action`
+          );
+        }
+        if (!existing) {
+          actions.push(action);
+          seenActionKeys.set(action.key, action);
+        }
+      }
+    }
+    return new _Slate(params.spec, actions, adapters);
   }
   get spec() {
     return this._spec;
@@ -2050,6 +2260,9 @@ var Slate = class _Slate {
   get actions() {
     return this._actions;
   }
+  get adapters() {
+    return this._adapters;
+  }
 };
 
 // src/specification/specification.ts
@@ -2151,6 +2364,9 @@ var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
 export {
   Slate,
   SlateAction,
+  SlateActionBuilder,
+  SlateAdapter,
+  SlateAdapterSpec,
   SlateAuth,
   SlateConfig,
   SlateContext,
@@ -2158,9 +2374,12 @@ export {
   SlateDefaultPollingIntervalSeconds,
   SlateError,
   SlateLogger,
+  SlatePublicContext,
+  SlatePublicTool,
   SlateSpecification,
   SlateTool,
   SlateTrigger,
+  adapterSpec,
   allOf,
   anyOf,
   auth,
@@ -2197,6 +2416,7 @@ export {
   metaWebhookHttp,
   normalizeOAuthTokenResponse,
   pickDefined,
+  publicTool,
   requestAxios,
   requestAxiosData,
   runWithContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.17",
+  "version": "1.0.0-rc.18",
   "publishConfig": {
     "access": "public"
   },
@@ -42,4 +42,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/action/action.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { SlateContext } from '../context';
+import type { SlateContext, SlatePublicContext } from '../context';
 import type { SlateActionDocsReference } from '../docs';
 import type { SlateSpecification } from '../specification/specification';
 import type { SlateAttachment } from './attachment';
@@ -29,6 +29,8 @@ export interface SlateActionParameters {
   scopes?: SlateActionScopes;
   authMethods?: string[];
   docs?: SlateActionDocsReference[];
+  adapter?: string | null;
+  isPublic?: boolean;
 }
 
 export type SlateToolInvocationHandler<
@@ -42,6 +44,14 @@ export type SlateToolInvocationHandler<
   attachments?: SlateAttachment[];
 }>;
 
+export type SlatePublicToolInvocationHandler<InputType extends {}, OutputType extends {}> = (
+  context: SlatePublicContext<InputType>
+) => Promise<{
+  output: OutputType;
+  message: string;
+  attachments?: SlateAttachment[];
+}>;
+
 export type SlateTriggerMappingHandler<
   ConfigType extends {},
   AuthType extends {},
@@ -258,4 +268,12 @@ export abstract class SlateAction<
   get docs() {
     return this._params.docs;
   }
+
+  get adapter() {
+    return this._params.adapter ?? null;
+  }
+
+  get isPublic() {
+    return this._params.isPublic === true;
+  }
 }

package/src/action/builder.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { SlateAuth } from '../auth';
+import { SlateConfig } from '../config';
+import { SlatePublicContext } from '../context';
+import { SlateSpecification } from '../specification/specification';
+import { SlatePublicTool } from './publicTool';
+import { SlateTool } from './tool';
+
+let createTestSpec = () => {
+  let config = SlateConfig.create(
+    z.object({
+      prefix: z.string()
+    })
+  );
+  let auth = SlateAuth.create<{ token: string }>().output(
+    z.object({
+      token: z.string()
+    })
+  );
+
+  return SlateSpecification.create({
+    key: 'demo',
+    name: 'Demo',
+    config,
+    auth
+  });
+};
+
+describe('SlateActionBuilder.lockInterface', () => {
+  it('prevents changing input and output schemas after the interface is locked', () => {
+    let spec = createTestSpec();
+    let builder = SlateTool.create(spec, {
+      key: 'send',
+      name: 'Send'
+    })
+      .input(z.object({ to: z.string() }))
+      .output(z.object({ id: z.string() }))
+      .lockInterface();
+
+    expect(() => builder.input(z.object({}))).toThrow(
+      'Adapter contract input schema cannot be changed'
+    );
+    expect(() => builder.output(z.object({}))).toThrow(
+      'Adapter contract output schema cannot be changed'
+    );
+  });
+});
+
+describe('SlatePublicTool', () => {
+  it('builds a public tool that omits config and auth from the handler context', async () => {
+    let spec = createTestSpec();
+    let tool = SlatePublicTool.create(spec, {
+      key: 'setup',
+      name: 'Setup'
+    })
+      .input(
+        z.object({
+          name: z.string()
+        })
+      )
+      .output(
+        z.object({
+          greeting: z.string()
+        })
+      )
+      .handleInvocation(async ctx => {
+        expect(ctx).not.toHaveProperty('config');
+        expect(ctx).not.toHaveProperty('auth');
+
+        return {
+          output: { greeting: `Hello ${ctx.input.name}` },
+          message: 'ok'
+        };
+      })
+      .build();
+
+    expect(tool.isPublic).toBe(true);
+    expect(tool.key).toBe('setup');
+
+    let result = await tool.handleInvocation(
+      new SlatePublicContext({ name: 'Ada' }, spec, {
+        debug: () => {},
+        error: () => {},
+        info: () => {},
+        progress: () => {},
+        warn: () => {}
+      } as any) as any
+    );
+
+    expect(result.output).toEqual({ greeting: 'Hello Ada' });
+  });
+
+  it('keeps regular tools private by default', () => {
+    let spec = createTestSpec();
+    let tool = SlateTool.create(spec, {
+      key: 'send',
+      name: 'Send'
+    })
+      .input(z.object({}))
+      .output(z.object({}))
+      .handleInvocation(async () => ({
+        output: {},
+        message: 'ok'
+      }))
+      .build();
+
+    expect(tool.isPublic).toBe(false);
+  });
+
+  it('rejects authentication methods on public tools', () => {
+    let spec = createTestSpec();
+
+    expect(() =>
+      SlatePublicTool.create(spec, {
+        key: 'setup',
+        name: 'Setup'
+      }).authMethods(['token_auth'])
+    ).toThrow('Public tools cannot require authentication methods');
+
+    expect(() =>
+      SlatePublicTool.create(spec, {
+        key: 'setup',
+        name: 'Setup',
+        authMethods: ['token_auth']
+      })
+        .input(z.object({}))
+        .output(z.object({}))
+        .handleInvocation(async () => ({
+          output: {},
+          message: 'ok'
+        }))
+        .build()
+    ).toThrow('Public tools cannot require authentication methods');
+  });
+});