@slates/provider 1.0.0-rc.2 → 1.0.0-rc.20

package/src/logger/logger.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { type SlateLogEntry, SlateLogger } from './logger';
+
+let flushLogs = async () => {
+  await new Promise(resolve => setTimeout(resolve, 20));
+};
+
+describe('SlateLogger', () => {
+  it('keeps a readable message and structured data for object logs', async () => {
+    let entries: SlateLogEntry[] = [];
+    let logger = new SlateLogger([
+      batch => {
+        entries.push(...batch);
+      }
+    ]);
+
+    logger.info({
+      message: 'Invoking tool action',
+      providerId: 'demo-slate',
+      actionId: 'echo',
+      phase: 'start'
+    });
+
+    await flushLogs();
+
+    expect(entries[0]).toMatchObject({
+      type: 'info',
+      message: 'Invoking tool action',
+      data: {
+        providerId: 'demo-slate',
+        actionId: 'echo',
+        phase: 'start'
+      }
+    });
+  });
+
+  it('captures error details as structured metadata', async () => {
+    let entries: SlateLogEntry[] = [];
+    let logger = new SlateLogger([
+      batch => {
+        entries.push(...batch);
+      }
+    ]);
+
+    logger.error(new Error('boom'));
+
+    await flushLogs();
+
+    expect(entries[0]?.message).toBe('Error: boom');
+    expect(entries[0]?.data).toMatchObject({
+      error: {
+        name: 'Error',
+        message: 'boom'
+      }
+    });
+  });
+});

package/src/logger/logger.ts

@@ -1,6 +1,7 @@
 import { encode } from '@toon-format/toon';
 
 export type SlateLogType = 'info' | 'warn' | 'error' | 'progress';
+export type SlateLogFields = Record<string, unknown>;
 
 export type SlateLogMessageInput =
   | string
@@ -12,22 +13,79 @@ export type SlateLogMessageInput =
   | object
   | SlateLogMessageInput[];
 
-let formatMessage = (message: SlateLogMessageInput): string => {
+let isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+let normalizeMessage = (
+  message: SlateLogMessageInput
+): {
+  message: string;
+  data?: SlateLogFields;
+} => {
+  if (Array.isArray(message)) {
+    let parts = message.map(part => normalizeMessage(part));
+    let combinedMessage = parts
+      .map(part => part.message)
+      .filter(Boolean)
+      .join(' ')
+      .trim();
+
+    let dataParts = parts
+      .map(part => {
+        if (part.data) {
+          return {
+            message: part.message,
+            ...part.data
+          };
+        }
+
+        return part.message;
+      })
+      .filter(Boolean);
+
+    return {
+      message: combinedMessage || 'Log entry',
+      data: dataParts.length > 0 ? { parts: dataParts } : undefined
+    };
+  }
+
   if (typeof message === 'object') {
-    if (message === null) return 'null';
+    if (message === null) return { message: 'null' };
     if (message instanceof Error) {
-      return `[ERROR]: ${message.name}: ${message.message}\n${message.stack}`;
+      return {
+        message: `${message.name}: ${message.message}`,
+        data: {
+          error: {
+            name: message.name,
+            message: message.message,
+            stack: message.stack
+          }
+        }
+      };
     }
-    return encode(message);
+
+    if (isRecord(message) && typeof message.message === 'string') {
+      let { message: text, ...data } = message;
+      return {
+        message: text || 'Log entry',
+        data: Object.keys(data).length > 0 ? data : undefined
+      };
+    }
+
+    return {
+      message: encode(message),
+      data: isRecord(message) ? message : undefined
+    };
   }
 
-  return String(message);
+  return { message: String(message) };
 };
 
 export interface SlateLogEntry {
   type: SlateLogType;
   message: string;
   timestamp: Date;
+  data?: SlateLogFields;
 }
 
 export type SlateLogListener = (entries: SlateLogEntry[]) => void;
@@ -44,9 +102,10 @@ export class SlateLogger {
   private flush() {
     if (this.#timer) clearTimeout(this.#timer);
     if (this.#logs.length === 0) return;
+    let logs = this.#logs.splice(0);
 
     for (let listener of this.#listeners) {
-      listener(this.#logs);
+      listener(logs);
     }
   }
 
@@ -59,27 +118,29 @@ export class SlateLogger {
   }
 
   log(type: SlateLogType, message: SlateLogMessageInput) {
+    let normalized = normalizeMessage(message);
     this.#logs.push({
       type,
       timestamp: new Date(),
-      message: formatMessage(message)
+      message: normalized.message,
+      data: normalized.data
     });
     this.scheduleFlush();
   }
 
   info(...message: SlateLogMessageInput[]) {
-    this.log('info', message.flat());
+    this.log('info', message.length === 1 ? message[0]! : message.flat());
   }
 
   warn(...message: SlateLogMessageInput[]) {
-    this.log('warn', message.flat());
+    this.log('warn', message.length === 1 ? message[0]! : message.flat());
   }
 
   error(...message: SlateLogMessageInput[]) {
-    this.log('error', message.flat());
+    this.log('error', message.length === 1 ? message[0]! : message.flat());
   }
 
   progress(...message: SlateLogMessageInput[]) {
-    this.log('progress', message.flat());
+    this.log('progress', message.length === 1 ? message[0]! : message.flat());
   }
 }

package/src/module/resolveDefaultExport.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { resolveDefaultExport } from './resolveDefaultExport';
+
+class Example {
+  value: number;
+  constructor(value: number) {
+    this.value = value;
+  }
+}
+
+describe('resolveDefaultExport', () => {
+  it('returns a constructor export as-is', () => {
+    expect(resolveDefaultExport<typeof Example>(Example)).toBe(Example);
+    expect(new (resolveDefaultExport<typeof Example>(Example))(1).value).toBe(1);
+  });
+
+  it('unwraps CJS default-export objects produced by bundlers', () => {
+    expect(resolveDefaultExport<typeof Example>({ default: Example })).toBe(Example);
+  });
+
+  it('unwraps nested default exports from double-bundling', () => {
+    expect(
+      resolveDefaultExport<typeof Example>({ default: { default: Example } })
+    ).toBe(Example);
+  });
+
+  it('throws when the export is not a constructor', () => {
+    expect(() => resolveDefaultExport({})).toThrow(TypeError);
+    expect(() => resolveDefaultExport({ default: { foo: 1 } })).toThrow(TypeError);
+    expect(() => resolveDefaultExport(undefined)).toThrow(TypeError);
+  });
+});

package/src/module/resolveDefaultExport.ts

@@ -0,0 +1,14 @@
+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');
+};

package/src/object/index.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { pickDefined, setIfDefined } from './index';
+
+describe('object helpers', () => {
+  it('omits only undefined values', () => {
+    expect(
+      pickDefined({
+        keepNull: null,
+        keepFalse: false,
+        keepZero: 0,
+        keepEmpty: '',
+        dropUndefined: undefined
+      })
+    ).toEqual({
+      keepNull: null,
+      keepFalse: false,
+      keepZero: 0,
+      keepEmpty: ''
+    });
+  });
+
+  it('sets only defined values on an existing target', () => {
+    let target: Record<string, unknown> = {};
+
+    setIfDefined(target, 'nullValue', null);
+    setIfDefined(target, 'falseValue', false);
+    setIfDefined(target, 'zeroValue', 0);
+    setIfDefined(target, 'emptyValue', '');
+    setIfDefined(target, 'undefinedValue', undefined);
+
+    expect(target).toEqual({
+      nullValue: null,
+      falseValue: false,
+      zeroValue: 0,
+      emptyValue: ''
+    });
+  });
+});

package/src/object/index.ts

@@ -0,0 +1,12 @@
+export let pickDefined = <T extends object>(value: T) =>
+  Object.fromEntries(
+    Object.entries(value).filter(([, child]) => child !== undefined)
+  ) as Partial<T> & Record<string, unknown>;
+
+export let setIfDefined = (target: Record<string, unknown>, key: string, value: unknown) => {
+  if (value !== undefined) {
+    target[key] = value;
+  }
+
+  return target;
+};

package/src/specification/slate.ts

@@ -1,5 +1,7 @@
-import { SlateTool, SlateTrigger } from '../action';
-import { SlateSpecification } from './specification';
+import type { SlateTool, SlateTrigger } from '../action';
+import type { SlateAdapter } from '../adapter';
+import { SlateDeclarationError } from '../error';
+import type { SlateSpecification } from './specification';
 
 export class Slate<ConfigType extends {}, AuthType extends {}> {
   private constructor(
@@ -7,15 +9,45 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     private readonly _actions: (
       | SlateTrigger<ConfigType, AuthType, any, any>
       | SlateTool<ConfigType, AuthType, any, any>
-    )[]
+    )[],
+    private readonly _adapters: SlateAdapter<ConfigType, AuthType>[]
   ) {}
 
   static create<ConfigType extends {}, AuthType extends {}>(params: {
     spec: SlateSpecification<ConfigType, AuthType>;
     triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
     tools: SlateTool<ConfigType, AuthType, any, any>[];
+    adapters?: SlateAdapter<ConfigType, AuthType>[];
   }) {
-    return new Slate(params.spec, [...params.triggers, ...params.tools]);
+    let adapters = params.adapters ?? [];
+    let actions = [...params.triggers, ...params.tools];
+    let seenAdapterIds = new Set<string>();
+    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() {
@@ -25,4 +57,8 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
   get actions() {
     return this._actions;
   }
+
+  get adapters() {
+    return this._adapters;
+  }
 }

package/src/specification/specification.ts

@@ -1,18 +1,18 @@
 import z from 'zod';
-import { SlateAuth } from '../auth';
-import { SlateConfig } from '../config';
+import type { SlateAuth } from '../auth';
+import type { SlateConfig } from '../config';
+import type { SlateProviderDocsReference } from '../docs';
 
 export interface SlateSpecificationParameters {
   key: string;
   name: string;
   description?: string;
+  docs?: SlateProviderDocsReference[];
   metadata?: Record<string, any>;
 }
 
-export interface SlateSpecificationCreateParameters<
-  ConfigType extends {},
-  AuthType extends {}
-> extends SlateSpecificationParameters {
+export interface SlateSpecificationCreateParameters<ConfigType extends {}, AuthType extends {}>
+  extends SlateSpecificationParameters {
   config: SlateConfig<ConfigType>;
   auth: SlateAuth<AuthType>;
 }
@@ -63,6 +63,10 @@ export class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
   get description() {
     return this._params.description;
   }
+
+  get docs() {
+    return this._params.docs;
+  }
 }
 
 export let spec = <ConfigType extends {}, AuthType extends {}>(

package/src/webhook/graph.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { getGraphWebhookValidationResponse, graphWebhookHttp } from './graph';
+
+describe('Microsoft Graph webhook validation', () => {
+  it('makes only validation requests synchronous', () => {
+    expect(graphWebhookHttp).toEqual({
+      methods: ['POST'],
+      sync: {
+        mode: 'match',
+        match: [{ hasQueryParam: 'validationToken' }]
+      }
+    });
+  });
+
+  it('echoes the URL-decoded validation token as plain text', () => {
+    let response = getGraphWebhookValidationResponse(
+      new Request(
+        'https://example.com/webhook?validationToken=Validation%3a+Testing+client+application+reachability',
+        { method: 'POST' }
+      )
+    );
+
+    expect(response).toEqual({
+      status: 200,
+      headers: { 'content-type': 'text/plain' },
+      body: 'Validation: Testing client application reachability'
+    });
+  });
+
+  it('ignores ordinary change notifications', () => {
+    expect(
+      getGraphWebhookValidationResponse(
+        new Request('https://example.com/webhook', { method: 'POST' })
+      )
+    ).toBeNull();
+  });
+});

package/src/webhook/graph.ts

@@ -0,0 +1,22 @@
+import type { SlateWebhookHttpOptions, SlateWebhookHttpResponseInit } from '../action';
+
+export const graphWebhookHttp = {
+  methods: ['POST'],
+  sync: {
+    mode: 'match',
+    match: [{ hasQueryParam: 'validationToken' }]
+  }
+} satisfies SlateWebhookHttpOptions;
+
+export let getGraphWebhookValidationResponse = (
+  request: Request
+): SlateWebhookHttpResponseInit | null => {
+  let validationToken = new URL(request.url).searchParams.get('validationToken');
+  if (validationToken === null) return null;
+
+  return {
+    status: 200,
+    headers: { 'content-type': 'text/plain' },
+    body: validationToken
+  };
+};

package/src/webhook/index.ts

@@ -0,0 +1,2 @@
+export * from './graph';
+export * from './meta';

package/src/webhook/meta.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { getMetaWebhookVerificationResponse, metaWebhookHttp } from './meta';
+
+let verificationRequest = (verifyToken = 'verify-token', challenge = 'challenge-value') =>
+  new Request(
+    `https://example.com/webhook?hub.mode=subscribe&hub.verify_token=${verifyToken}&hub.challenge=${challenge}`
+  );
+
+describe('Meta webhook verification', () => {
+  it('makes only verification GET requests synchronous', () => {
+    expect(metaWebhookHttp).toEqual({
+      methods: ['GET', 'POST'],
+      sync: {
+        mode: 'match',
+        match: [{ method: 'GET', hasQueryParam: 'hub.mode' }]
+      }
+    });
+  });
+
+  it('returns the challenge for a matching configured token', () => {
+    expect(getMetaWebhookVerificationResponse(verificationRequest(), 'verify-token')).toEqual({
+      status: 200,
+      headers: { 'content-type': 'text/plain' },
+      body: 'challenge-value'
+    });
+  });
+
+  it('rejects a mismatched configured token', () => {
+    expect(
+      getMetaWebhookVerificationResponse(verificationRequest('wrong-token'), 'verify-token')
+    ).toMatchObject({ status: 403 });
+    expect(
+      getMetaWebhookVerificationResponse(verificationRequest('wrong-token'), '')
+    ).toMatchObject({ status: 403 });
+  });
+
+  it('preserves legacy verification when no token is configured', () => {
+    expect(
+      getMetaWebhookVerificationResponse(verificationRequest('legacy-token'), undefined)
+    ).toMatchObject({ status: 200, body: 'challenge-value' });
+  });
+
+  it('rejects malformed verification and ignores POST events', () => {
+    let malformed = new Request('https://example.com/webhook?hub.mode=subscribe');
+    let post = new Request('https://example.com/webhook', { method: 'POST' });
+
+    expect(getMetaWebhookVerificationResponse(malformed, undefined)).toMatchObject({
+      status: 400
+    });
+    expect(getMetaWebhookVerificationResponse(post, undefined)).toBeNull();
+  });
+});

package/src/webhook/meta.ts

@@ -0,0 +1,43 @@
+import type { SlateWebhookHttpOptions, SlateWebhookHttpResponseInit } from '../action';
+
+export const metaWebhookHttp = {
+  methods: ['GET', 'POST'],
+  sync: {
+    mode: 'match',
+    match: [{ method: 'GET', hasQueryParam: 'hub.mode' }]
+  }
+} satisfies SlateWebhookHttpOptions;
+
+export let getMetaWebhookVerificationResponse = (
+  request: Request,
+  expectedVerifyToken: string | undefined
+): SlateWebhookHttpResponseInit | null => {
+  if (request.method !== 'GET') return null;
+
+  let url = new URL(request.url);
+  let mode = url.searchParams.get('hub.mode');
+  let verifyToken = url.searchParams.get('hub.verify_token');
+  let challenge = url.searchParams.get('hub.challenge');
+
+  if (mode !== 'subscribe' || challenge === null) {
+    return {
+      status: 400,
+      headers: { 'content-type': 'text/plain' },
+      body: 'invalid webhook verification request'
+    };
+  }
+
+  if (expectedVerifyToken !== undefined && verifyToken !== expectedVerifyToken) {
+    return {
+      status: 403,
+      headers: { 'content-type': 'text/plain' },
+      body: 'invalid verify token'
+    };
+  }
+
+  return {
+    status: 200,
+    headers: { 'content-type': 'text/plain' },
+    body: challenge
+  };
+};

package/dist/action/action.d.ts

@@ -1,98 +0,0 @@
-import { z } from 'zod';
-import { SlateContext } from '../context';
-import { SlateSpecification } from '../specification/specification';
-export type SlateActionType = 'tool' | 'trigger';
-export interface SlateActionParameters {
-    key: string;
-    name: string;
-    description?: string;
-    instructions?: string[];
-    constraints?: string[];
-    tags?: {
-        destructive?: boolean;
-        readOnly?: boolean;
-        [key: string]: boolean | undefined;
-    };
-    metadata?: Record<string, any>;
-}
-export type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
-    output: OutputType;
-    message: string;
-}>;
-export type SlateTriggerMappingHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
-    type: string;
-    id: string;
-    output: OutputType;
-}>;
-export type SlateTriggerPollingHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    state: any | null;
-}>) => Promise<{
-    inputs: InputType[];
-    updatedState?: any;
-}>;
-export type SlateTriggerWebhookRequestHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    request: Request;
-    state: any | null;
-}>) => Promise<{
-    inputs: InputType[];
-    updatedState?: any;
-}>;
-export type SlateTriggerWebhookAutoRegistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    webhookBaseUrl: string;
-}>) => Promise<{
-    registrationDetails: any;
-    state?: any;
-}>;
-export type SlateTriggerWebhookAutoUnregistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    webhookBaseUrl: string;
-    registrationDetails: any;
-    state: any | null;
-}>) => Promise<unknown>;
-export interface SlateActionParametersTool<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    type: 'tool';
-    handleInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
-}
-export interface SlatePollingOptions {
-    intervalInSeconds?: number;
-}
-export interface SlateActionParametersTrigger<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    type: 'trigger';
-    source: 'polling' | 'webhook';
-    polling?: SlatePollingOptions;
-    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-    handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-    pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-    autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-    autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
-}
-export type SlateActionParametersAny<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | SlateActionParametersTrigger<ConfigType, AuthType, InputType, OutputType>;
-export type SlateActionCreateParameters<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersAny<ConfigType, AuthType, InputType, OutputType> & SlateActionParameters & {
-    configSchema: z.ZodType<ConfigType>;
-    authSchema: z.ZodType<AuthType>;
-    inputSchema: z.ZodType<InputType>;
-    outputSchema: z.ZodType<OutputType>;
-};
-export declare abstract class SlateAction<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    readonly type: Type;
-    protected readonly _spec: SlateSpecification<ConfigType, AuthType>;
-    protected readonly _inputSchema: z.ZodType<InputType>;
-    protected readonly _outputSchema: z.ZodType<OutputType>;
-    protected readonly _params: SlateActionParameters;
-    constructor(type: Type, _spec: SlateSpecification<ConfigType, AuthType>, _inputSchema: z.ZodType<InputType>, _outputSchema: z.ZodType<OutputType>, _params: SlateActionParameters);
-    get configSchema(): z.ZodType<ConfigType, unknown, z.core.$ZodTypeInternals<ConfigType, unknown>>;
-    get inputSchema(): z.ZodType<InputType, unknown, z.core.$ZodTypeInternals<InputType, unknown>>;
-    get outputSchema(): z.ZodType<OutputType, unknown, z.core.$ZodTypeInternals<OutputType, unknown>>;
-    get parameters(): SlateActionParameters;
-    get key(): string;
-    get name(): string;
-    get description(): string | undefined;
-    get tags(): {
-        [key: string]: boolean | undefined;
-        destructive?: boolean;
-        readOnly?: boolean;
-    } | undefined;
-    get instructions(): string[] | undefined;
-    get constraints(): string[] | undefined;
-    get metadata(): Record<string, any> | undefined;
-}
-//# sourceMappingURL=action.d.ts.map

package/dist/action/action.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/action/action.ts"],"names":[],"mappings":"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"}