@slates/provider 1.0.0-rc.1

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@slates/provider",
+  "version": "1.0.0-rc.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Tobias Herber",
+  "license": "Apache 2",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.module.js",
+    "default": "./dist/index.module.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.module.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "./dist/index.umd.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "lint": "prettier src/**/*.ts --check",
+    "build": "microbundle"
+  },
+  "dependencies": {
+    "@toon-format/toon": "^2.1.0",
+    "axios": "^1.13.2",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "microbundle": "^0.15.1",
+    "@slates/tsconfig": "^1.0.0",
+    "typescript": "5.8.2",
+    "vitest": "^3.1.2"
+  }
+}

package/src/action/action.ts

@@ -0,0 +1,191 @@
+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 abstract class SlateAction<
+  Type extends SlateActionType,
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {},
+  OutputType extends {}
+> {
+  constructor(
+    public 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
+  ) {}
+
+  get configSchema() {
+    return this._spec.configSchema;
+  }
+
+  get inputSchema() {
+    return this._inputSchema;
+  }
+
+  get outputSchema() {
+    return this._outputSchema;
+  }
+
+  get parameters() {
+    return this._params;
+  }
+
+  get key() {
+    return this._params.key;
+  }
+
+  get name() {
+    return this._params.name;
+  }
+
+  get description() {
+    return this._params.description;
+  }
+
+  get tags() {
+    return this._params.tags;
+  }
+
+  get instructions() {
+    return this._params.instructions;
+  }
+
+  get constraints() {
+    return this._params.constraints;
+  }
+
+  get metadata() {
+    return this._params.metadata;
+  }
+}

package/src/action/builder.ts

@@ -0,0 +1,150 @@
+import z from 'zod';
+import { SlateDeclarationError } from '../error';
+import { SlateSpecification } from '../specification/specification';
+import {
+  SlateAction,
+  SlateActionCreateParameters,
+  SlateActionParameters,
+  SlateActionParametersTool,
+  SlateActionParametersTrigger,
+  SlateActionType,
+  SlatePollingOptions,
+  SlateToolInvocationHandler,
+  SlateTriggerMappingHandler,
+  SlateTriggerPollingHandler,
+  SlateTriggerWebhookAutoRegistrationHandler,
+  SlateTriggerWebhookAutoUnregistrationHandler,
+  SlateTriggerWebhookRequestHandler
+} from './action';
+
+export class SlateActionBuilder<
+  Type extends SlateActionType,
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {},
+  OutputType extends {},
+  Result extends SlateAction<Type, ConfigType, AuthType, any, any>
+> {
+  #configSchema: z.ZodType<ConfigType>;
+  #authSchema: z.ZodType<AuthType>;
+  #inputSchema: z.ZodType<InputType> | null = null;
+  #outputSchema: z.ZodType<OutputType> | null = null;
+
+  #toolParams: SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | null =
+    null;
+  #triggerParams: SlateActionParametersTrigger<
+    ConfigType,
+    AuthType,
+    InputType,
+    OutputType
+  > | null = null;
+
+  constructor(
+    private readonly type: Type,
+    private readonly spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly params: SlateActionParameters,
+    private readonly factory: (
+      params: SlateActionCreateParameters<any, any, any, any>
+    ) => Result
+  ) {
+    this.#configSchema = spec.configSchema;
+    this.#authSchema = spec.authSchema;
+  }
+
+  input<NewInputType extends {}>(
+    schema: z.ZodType<NewInputType>
+  ): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType, Result> {
+    this.#inputSchema = schema as any;
+    return this as any;
+  }
+
+  output<NewOutputType extends {}>(
+    schema: z.ZodType<NewOutputType>
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType, Result> {
+    this.#outputSchema = schema as any;
+    return this as any;
+  }
+
+  handleInvocation(
+    handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result> {
+    if (this.type !== 'tool') {
+      throw new SlateDeclarationError('handleInvocation can only be set for tool actions');
+    }
+
+    this.#toolParams = {
+      type: 'tool',
+      handleInvocation: handler
+    };
+
+    return this;
+  }
+
+  webhook(props: {
+    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    handleRequest: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+    autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
+    autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+  }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result> {
+    if (this.type !== 'trigger') {
+      throw new SlateDeclarationError('handleEvent can only be set for trigger actions');
+    }
+
+    this.#triggerParams = {
+      type: 'trigger',
+      source: 'webhook',
+      handleEvent: props.handleEvent,
+      handleRequest: props.handleRequest,
+      autoRegisterWebhook: props.autoRegisterWebhook,
+      autoUnregisterWebhook: props.autoUnregisterWebhook
+    };
+
+    return this;
+  }
+
+  polling(props: {
+    options?: SlatePollingOptions;
+    pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
+    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+  }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result> {
+    if (this.type !== 'trigger') {
+      throw new SlateDeclarationError('handleEvent can only be set for trigger actions');
+    }
+
+    this.#triggerParams = {
+      type: 'trigger',
+      source: 'polling',
+      polling: props.options,
+      pollEvents: props.pollEvents,
+      handleEvent: props.handleEvent
+    };
+
+    return this;
+  }
+
+  build() {
+    if (!this.#inputSchema) {
+      throw new SlateDeclarationError('Input schema is not defined');
+    }
+    if (!this.#outputSchema) {
+      throw new SlateDeclarationError('Output schema is not defined');
+    }
+    if (this.type === 'tool' && !this.#toolParams) {
+      throw new SlateDeclarationError('Tool invocation handler is not defined');
+    }
+    if (this.type === 'trigger' && !this.#triggerParams) {
+      throw new SlateDeclarationError('Trigger event handlers are not defined');
+    }
+
+    return this.factory({
+      ...this.params,
+      configSchema: this.#configSchema,
+      authSchema: this.#authSchema,
+      inputSchema: this.#inputSchema,
+      outputSchema: this.#outputSchema,
+
+      ...this.#toolParams!,
+      ...this.#triggerParams!
+    }) as Result;
+  }
+}

package/src/action/index.ts

@@ -0,0 +1,5 @@
+export * from './action';
+export * from './tool';
+export * from './trigger';
+
+export type * from './builder';

package/src/action/tool.ts

@@ -0,0 +1,52 @@
+import z from 'zod';
+import { SlateSpecification } from '../specification/specification';
+import { SlateAction, SlateActionParameters, SlateToolInvocationHandler } from './action';
+import { SlateActionBuilder } from './builder';
+
+export interface SlateToolParameters<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {},
+  OutputType extends {}
+> extends SlateActionParameters {
+  handleInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
+}
+
+export class SlateTool<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {},
+  OutputType extends {}
+> extends SlateAction<'tool', ConfigType, AuthType, InputType, OutputType> {
+  #handleInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
+
+  private constructor(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    inputSchema: z.ZodType<InputType>,
+    outputSchema: z.ZodType<OutputType>,
+    params: SlateToolParameters<ConfigType, AuthType, InputType, OutputType>
+  ) {
+    super('tool', spec, inputSchema, outputSchema, params);
+
+    this.#handleInvocation = params.handleInvocation;
+  }
+
+  static create<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateActionParameters
+  ) {
+    return new SlateActionBuilder('tool', spec, params, params => {
+      if (params.type != 'tool') throw new Error('Invalid action type for tool');
+      return new SlateTool(spec, params.inputSchema, params.outputSchema, params);
+    });
+  }
+
+  get handleInvocation() {
+    return this.#handleInvocation;
+  }
+}
+
+export let tool = <ConfigType extends {}, AuthType extends {}>(
+  spec: SlateSpecification<ConfigType, AuthType>,
+  params: SlateActionParameters
+) => SlateTool.create(spec, params);

package/src/action/trigger.ts

@@ -0,0 +1,112 @@
+import z from 'zod';
+import { SlateSpecification } from '../specification/specification';
+import {
+  SlateAction,
+  SlateActionParameters,
+  SlatePollingOptions,
+  SlateTriggerMappingHandler,
+  SlateTriggerPollingHandler,
+  SlateTriggerWebhookAutoRegistrationHandler,
+  SlateTriggerWebhookAutoUnregistrationHandler,
+  SlateTriggerWebhookRequestHandler
+} from './action';
+import { SlateActionBuilder } from './builder';
+
+export const SlateDefaultPollingIntervalSeconds = 60 * 10;
+
+export interface SlateTriggerParameters<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {},
+  OutputType extends {
+    type: string;
+  }
+> extends SlateActionParameters {
+  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 class SlateTrigger<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {},
+  OutputType extends {
+    type: string;
+  }
+> extends SlateAction<'trigger', ConfigType, AuthType, InputType, OutputType> {
+  #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>;
+
+  private constructor(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    inputSchema: z.ZodType<InputType>,
+    outputSchema: z.ZodType<OutputType>,
+    params: SlateTriggerParameters<ConfigType, AuthType, InputType, OutputType>
+  ) {
+    super('trigger', spec, inputSchema, outputSchema, params);
+
+    this.#source = params.source;
+    this.#polling = params.polling || {
+      intervalInSeconds: SlateDefaultPollingIntervalSeconds
+    };
+    this.#handleEvent = params.handleEvent;
+    this.#handleRequest = params.handleRequest;
+    this.#pollEvents = params.pollEvents;
+    this.#autoRegisterWebhook = params.autoRegisterWebhook;
+    this.#autoUnregisterWebhook = params.autoUnregisterWebhook;
+  }
+
+  static create<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateActionParameters
+  ) {
+    return new SlateActionBuilder('trigger', spec, params, params => {
+      if (params.type != 'trigger') throw new Error('Invalid action type for trigger');
+      return new SlateTrigger(spec, params.inputSchema, params.outputSchema, params);
+    });
+  }
+
+  get polling() {
+    return this.#polling;
+  }
+
+  get source() {
+    return this.#source;
+  }
+
+  get handleEvent() {
+    return this.#handleEvent;
+  }
+
+  get handleRequest() {
+    return this.#handleRequest;
+  }
+
+  get pollEvents() {
+    return this.#pollEvents;
+  }
+
+  get autoRegisterWebhook() {
+    return this.#autoRegisterWebhook;
+  }
+
+  get autoUnregisterWebhook() {
+    return this.#autoUnregisterWebhook;
+  }
+}
+
+export let trigger = <ConfigType extends {}, AuthType extends {}>(
+  spec: SlateSpecification<ConfigType, AuthType>,
+  params: SlateActionParameters
+) => SlateTrigger.create(spec, params);

package/src/auth/auth.ts

@@ -0,0 +1,82 @@
+import z from 'zod';
+import { SlateAuthType } from './types';
+
+export class SlateAuth<OutputType extends {} = {}> {
+  #outputSchema: z.ZodType<OutputType> | null = null;
+  #authStack: SlateAuthType<any, OutputType>[] = [];
+
+  private constructor() {}
+
+  static create<OutputType extends {}>() {
+    return new SlateAuth<OutputType>();
+  }
+
+  output<NewOutputType extends {}>(
+    schema: z.ZodType<NewOutputType>
+  ): SlateAuth<NewOutputType> {
+    this.#outputSchema = schema as any;
+    return this as any as SlateAuth<NewOutputType>;
+  }
+
+  private addAuth<InputType extends {}>(
+    auth: SlateAuthType<InputType, OutputType>
+  ): SlateAuth<OutputType> {
+    let existingKeys = this.#authStack.map(a => a.key);
+    if (existingKeys.includes(auth.key)) {
+      throw new Error(`Auth with key "${auth.key}" already exists in the auth stack`);
+    }
+
+    this.#authStack.push(auth);
+    return this;
+  }
+
+  addOauth<InputType extends {}>(
+    auth: SlateAuthType<InputType, OutputType> & { type: 'auth.oauth' }
+  ): SlateAuth<OutputType> {
+    this.addAuth(auth as any);
+    return this;
+  }
+
+  addTokenAuth<InputType extends {}>(
+    auth: SlateAuthType<InputType, OutputType> & { type: 'auth.token' }
+  ): SlateAuth<OutputType> {
+    this.addAuth(auth as any);
+    return this;
+  }
+
+  addServiceAccountAuth<InputType extends {}>(
+    auth: SlateAuthType<InputType, OutputType> & { type: 'auth.service_account' }
+  ): SlateAuth<OutputType> {
+    this.addAuth(auth as any);
+    return this;
+  }
+
+  addCustomAuth<InputType extends {}>(
+    auth: SlateAuthType<InputType, OutputType> & { type: 'auth.custom' }
+  ): SlateAuth<OutputType> {
+    this.addAuth(auth as any);
+    return this;
+  }
+
+  addNone(): SlateAuth<OutputType> {
+    this.addAuth({
+      type: 'auth.none',
+      name: 'No Authentication',
+      key: 'none'
+    });
+    return this;
+  }
+
+  get authStack() {
+    return this.#authStack.filter(a => a.type != 'auth.none');
+  }
+
+  get outputSchema() {
+    if (!this.#outputSchema) {
+      throw new Error('Output schema is not defined for this auth');
+    }
+    return this.#outputSchema;
+  }
+}
+
+export let auth = <OutputType extends {} = {}>() => SlateAuth.create<OutputType>();

package/src/auth/index.ts

@@ -0,0 +1,2 @@
+export * from './auth';
+export * from './types';

package/src/auth/types.ts

@@ -0,0 +1,150 @@
+import z from 'zod';
+
+export type SlateAuthWithOauth<
+  InputType extends {},
+  OutputType extends {
+    token: string;
+    refreshToken?: string;
+    expiresAt?: number | string | Date;
+  }
+> = {
+  type: 'auth.oauth';
+
+  name: string;
+  key: string;
+
+  scopes: {
+    title: string;
+    description?: string;
+    scope: string;
+  }[];
+
+  inputSchema?: z.ZodType<InputType>;
+
+  onInputChanged?: (params: {
+    previousInput: InputType | null;
+    newInput: InputType;
+  }) => Promise<{ input?: InputType } | void>;
+
+  getDefaultInput?: () => Promise<InputType>;
+
+  getAuthorizationUrl: (ctx: {
+    redirectUri: string;
+    state: string;
+    input: InputType;
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+  }) => Promise<{
+    url: string;
+    input?: InputType;
+  }>;
+
+  handleCallback: (ctx: {
+    code: string;
+    state: string;
+    redirectUri: string;
+    input: InputType;
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+  }) => Promise<{
+    output: OutputType;
+    input?: InputType;
+  }>;
+
+  handleTokenRefresh?: (ctx: {
+    output: OutputType;
+    input: InputType;
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+  }) => Promise<{
+    output: OutputType;
+    input?: InputType;
+  }>;
+
+  getProfile?: (ctx: { output: OutputType; input: InputType; scopes: string[] }) => Promise<{
+    profile: Record<string, any>;
+  }>;
+};
+
+export type SlateAuthWithToken<InputType extends {}, OutputType extends { token?: string }> = {
+  type: 'auth.token';
+
+  name: string;
+  key: string;
+
+  inputSchema?: z.ZodType<InputType>;
+
+  getOutput: (ctx: { input: InputType }) => Promise<{ output: OutputType }>;
+
+  onInputChanged?: (params: {
+    previousInput: InputType;
+    newInput: InputType;
+  }) => Promise<{ input?: InputType } | void>;
+
+  getDefaultInput?: () => Promise<InputType>;
+
+  getProfile?: (ctx: { output: OutputType; input: InputType }) => Promise<{
+    profile: Record<string, any>;
+  }>;
+};
+
+export type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> = {
+  type: 'auth.service_account';
+
+  name: string;
+  key: string;
+
+  inputSchema?: z.ZodType<InputType>;
+
+  getOutput: (ctx: { input: InputType }) => Promise<{ output: OutputType }>;
+
+  onInputChanged?: (params: {
+    previousInput: InputType;
+    newInput: InputType;
+  }) => Promise<{ input?: InputType } | void>;
+
+  getDefaultInput?: () => Promise<InputType>;
+
+  getProfile?: (ctx: { output: OutputType; input: InputType }) => Promise<{
+    profile: Record<string, any>;
+  }>;
+};
+
+export type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
+  type: 'auth.custom';
+
+  name: string;
+  key: string;
+
+  inputSchema?: z.ZodType<InputType>;
+
+  getOutput: (ctx: { input: InputType }) => Promise<{ output: OutputType }>;
+
+  onInputChanged?: (params: {
+    previousInput: InputType;
+    newInput: InputType;
+  }) => Promise<{ input?: InputType } | void>;
+
+  getDefaultInput?: () => Promise<InputType>;
+
+  getProfile?: (ctx: { output: OutputType; input: InputType }) => Promise<{
+    profile: Record<string, any>;
+  }>;
+};
+
+export type SlateAuthWithNone<InputType extends {}, OutputType extends {}> = {
+  type: 'auth.none';
+
+  name: string;
+  key: string;
+};
+
+export type SlateAuthType<InputType extends {}, OutputType extends {}> =
+  | SlateAuthWithOauth<InputType, OutputType & { token: string }>
+  | SlateAuthWithToken<InputType, OutputType & { token?: string }>
+  | SlateAuthWithServiceAccount<InputType, OutputType>
+  | SlateAuthWithCustomData<InputType, OutputType>
+  | SlateAuthWithNone<InputType, OutputType>;

package/src/axios/index.ts

@@ -0,0 +1,28 @@
+import baseAxios, { CreateAxiosDefaults } from 'axios';
+import { getCurrentContext } from '../context/hook';
+
+export let createAxios = (config?: CreateAxiosDefaults) => {
+  let instance = baseAxios.create({
+    ...config,
+    headers: {
+      ...config?.headers
+    }
+  });
+
+  instance.interceptors.request.use(
+    request => {
+      // Has to be called in the context of an action execution
+      let ctx = getCurrentContext();
+      let spec = ctx.specification;
+
+      request.headers.set('User-Agent', `slates.dev@1.0.0/${spec.key}`);
+
+      return request;
+    },
+    error => Promise.reject(error)
+  );
+
+  return instance;
+};
+
+export let axios = createAxios();

package/src/config/config.ts

@@ -0,0 +1,56 @@
+import z from 'zod';
+
+export class SlateConfig<ConfigType extends {}> {
+  #configSchema: z.ZodType<ConfigType>;
+  #configChanged:
+    | ((params: {
+        previousConfig: ConfigType | null;
+        newConfig: ConfigType;
+      }) => { config: ConfigType | undefined } | void)
+    | null = null;
+  #getDefaultConfig: (() => ConfigType) | null = null;
+
+  private constructor(schema: z.ZodType<ConfigType>) {
+    this.#configSchema = schema;
+  }
+
+  static create<ConfigType extends {}>(schema: z.ZodType<ConfigType>) {
+    return new SlateConfig<ConfigType>(schema);
+  }
+
+  config<NewConfigType extends {}>(
+    schema: z.ZodType<NewConfigType>
+  ): SlateConfig<NewConfigType> {
+    this.#configSchema = schema as any;
+    return this as any as SlateConfig<NewConfigType>;
+  }
+
+  onConfigChanged(
+    handler: (params: {
+      previousConfig: ConfigType | null;
+      newConfig: ConfigType;
+    }) => { config: ConfigType | undefined } | void
+  ): SlateConfig<ConfigType> {
+    this.#configChanged = handler;
+    return this;
+  }
+
+  getDefaultConfig(getter: () => ConfigType): SlateConfig<ConfigType> {
+    this.#getDefaultConfig = getter;
+    return this;
+  }
+
+  get configSchema() {
+    return this.#configSchema;
+  }
+
+  get handlers() {
+    return {
+      configChanged: this.#configChanged,
+      getDefaultConfig: this.#getDefaultConfig
+    };
+  }
+}
+
+export let config = <ConfigType extends {}>(schema: z.ZodType<ConfigType>) =>
+  SlateConfig.create<ConfigType>(schema);

package/src/config/index.ts

@@ -0,0 +1 @@
+export * from './config';

package/src/context/context.ts

@@ -0,0 +1,68 @@
+import { SlateLogger, SlateLogMessageInput } from '../logger';
+import { SlateSpecification } from '../specification/specification';
+
+export class SlateContext<ConfigType extends {}, AuthType extends {}, InputType extends {}> {
+  #config: ConfigType;
+  #input: InputType;
+  #auth: AuthType;
+
+  constructor(
+    config: ConfigType,
+    input: InputType,
+    auth: AuthType,
+    private readonly spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly logger: SlateLogger
+  ) {
+    this.#config = config;
+    this.#input = input;
+    this.#auth = auth;
+  }
+
+  get specification() {
+    return this.spec;
+  }
+
+  get config() {
+    return Object.freeze(this.#config);
+  }
+
+  get input() {
+    return Object.freeze(this.#input);
+  }
+
+  get event() {
+    return Object.freeze(this.#input);
+  }
+
+  get state() {
+    return Object.freeze((this.#input as any).state) as 'state' extends keyof InputType
+      ? InputType['state']
+      : never;
+  }
+
+  get request() {
+    return Object.freeze((this.#input as any).request) as 'request' extends keyof InputType
+      ? InputType['request']
+      : never;
+  }
+
+  get auth() {
+    return Object.freeze(this.#auth);
+  }
+
+  info(message: SlateLogMessageInput) {
+    this.logger.info(message);
+  }
+
+  warn(message: SlateLogMessageInput) {
+    this.logger.warn(message);
+  }
+
+  error(message: SlateLogMessageInput) {
+    this.logger.error(message);
+  }
+
+  progress(message: SlateLogMessageInput) {
+    this.logger.progress(message);
+  }
+}

package/src/context/hook.ts

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { SlateContext } from './context';
+
+let asyncLocalStorage = new AsyncLocalStorage<SlateContext<any, any, any>>();
+
+export let runWithContext = <ConfigType extends {}, AuthType extends {}, InputType extends {}>(
+  context: SlateContext<ConfigType, AuthType, InputType>,
+  fn: () => Promise<void>
+) => {
+  return asyncLocalStorage.run(context, fn);
+};
+
+export let getCurrentContext = <
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {}
+>(): SlateContext<ConfigType, AuthType, InputType> => {
+  let context = asyncLocalStorage.getStore();
+  if (!context) {
+    throw new Error('No Slate context is available');
+  }
+  return context as SlateContext<ConfigType, AuthType, InputType>;
+};

package/src/context/index.ts

@@ -0,0 +1 @@
+export * from './context';

package/src/error/base.ts

@@ -0,0 +1,10 @@
+export class SlateError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SlateError';
+  }
+
+  static is(error: unknown): error is SlateError {
+    return error instanceof SlateError;
+  }
+}

package/src/error/declaration.ts

@@ -0,0 +1,12 @@
+import { SlateError } from './base';
+
+export class SlateDeclarationError extends SlateError {
+  constructor(message: string) {
+    super(`[Declaration Error]: ${message}`);
+    this.name = 'SlateError.DeclarationError';
+  }
+
+  static is(error: unknown): error is SlateDeclarationError {
+    return error instanceof SlateDeclarationError;
+  }
+}

package/src/error/index.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './declaration';

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './action';
+export * from './auth';
+export * from './axios';
+export * from './config';
+export * from './context';
+export * from './error';
+export * from './logger';
+export * from './specification';

package/src/logger/index.ts

@@ -0,0 +1 @@
+export * from './logger';

package/src/logger/logger.ts

@@ -0,0 +1,85 @@
+import { encode } from '@toon-format/toon';
+
+export type SlateLogType = 'info' | 'warn' | 'error' | 'progress';
+
+export type SlateLogMessageInput =
+  | string
+  | Error
+  | boolean
+  | number
+  | null
+  | undefined
+  | object
+  | SlateLogMessageInput[];
+
+let formatMessage = (message: SlateLogMessageInput): string => {
+  if (typeof message === 'object') {
+    if (message === null) return 'null';
+    if (message instanceof Error) {
+      return `[ERROR]: ${message.name}: ${message.message}\n${message.stack}`;
+    }
+    return encode(message);
+  }
+
+  return String(message);
+};
+
+export interface SlateLogEntry {
+  type: SlateLogType;
+  message: string;
+  timestamp: Date;
+}
+
+export type SlateLogListener = (entries: SlateLogEntry[]) => void;
+
+export class SlateLogger {
+  #logs: SlateLogEntry[] = [];
+  #listeners: SlateLogListener[] = [];
+  #timer: NodeJS.Timeout | null = null;
+
+  constructor(listeners: SlateLogListener[] = []) {
+    this.#listeners.push(...listeners);
+  }
+
+  private flush() {
+    if (this.#timer) clearTimeout(this.#timer);
+    if (this.#logs.length === 0) return;
+
+    for (let listener of this.#listeners) {
+      listener(this.#logs);
+    }
+  }
+
+  private scheduleFlush() {
+    if (this.#timer) return;
+    this.#timer = setTimeout(() => {
+      this.flush();
+      this.#timer = null;
+    }, 10);
+  }
+
+  log(type: SlateLogType, message: SlateLogMessageInput) {
+    this.#logs.push({
+      type,
+      timestamp: new Date(),
+      message: formatMessage(message)
+    });
+    this.scheduleFlush();
+  }
+
+  info(...message: SlateLogMessageInput[]) {
+    this.log('info', message.flat());
+  }
+
+  warn(...message: SlateLogMessageInput[]) {
+    this.log('warn', message.flat());
+  }
+
+  error(...message: SlateLogMessageInput[]) {
+    this.log('error', message.flat());
+  }
+
+  progress(...message: SlateLogMessageInput[]) {
+    this.log('progress', message.flat());
+  }
+}

package/src/specification/index.ts

@@ -0,0 +1,2 @@
+export * from './slate';
+export * from './specification';

package/src/specification/slate.ts

@@ -0,0 +1,28 @@
+import { SlateTool, SlateTrigger } from '../action';
+import { SlateSpecification } from './specification';
+
+export class Slate<ConfigType extends {}, AuthType extends {}> {
+  private constructor(
+    private readonly _spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly _actions: (
+      | SlateTrigger<ConfigType, AuthType, any, any>
+      | SlateTool<ConfigType, AuthType, any, any>
+    )[]
+  ) {}
+
+  static create<ConfigType extends {}, AuthType extends {}>(params: {
+    spec: SlateSpecification<ConfigType, AuthType>;
+    triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
+    tools: SlateTool<ConfigType, AuthType, any, any>[];
+  }) {
+    return new Slate(params.spec, [...params.triggers, ...params.tools]);
+  }
+
+  get spec() {
+    return this._spec;
+  }
+
+  get actions() {
+    return this._actions;
+  }
+}

package/src/specification/specification.ts

@@ -0,0 +1,70 @@
+import z from 'zod';
+import { SlateAuth } from '../auth';
+import { SlateConfig } from '../config';
+
+export interface SlateSpecificationParameters {
+  key: string;
+  name: string;
+  description?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface SlateSpecificationCreateParameters<
+  ConfigType extends {},
+  AuthType extends {}
+> extends SlateSpecificationParameters {
+  config: SlateConfig<ConfigType>;
+  auth: SlateAuth<AuthType>;
+}
+
+export class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
+  private constructor(
+    private readonly _config: SlateConfig<ConfigType>,
+    private readonly _auth: SlateAuth<AuthType>,
+    private readonly _params: SlateSpecificationParameters
+  ) {}
+
+  static create<ConfigType extends {}, AuthType extends {}>(
+    params: SlateSpecificationCreateParameters<ConfigType, AuthType>
+  ): SlateSpecification<ConfigType, AuthType> {
+    return new SlateSpecification(params.config, params.auth, params);
+  }
+
+  get configSchema() {
+    return this._config.configSchema;
+  }
+
+  get authSchema() {
+    return (
+      'outputSchema' in this._auth ? this._auth.outputSchema : z.object({})
+    ) as z.ZodType<AuthType>;
+  }
+
+  get config() {
+    return this._config;
+  }
+
+  get auth() {
+    return this._auth;
+  }
+
+  get parameters() {
+    return this._params;
+  }
+
+  get key() {
+    return this._params.key;
+  }
+
+  get name() {
+    return this._params.name;
+  }
+
+  get description() {
+    return this._params.description;
+  }
+}
+
+export let spec = <ConfigType extends {}, AuthType extends {}>(
+  params: SlateSpecificationCreateParameters<ConfigType, AuthType>
+): SlateSpecification<ConfigType, AuthType> => SlateSpecification.create(params);

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@slates/tsconfig/base.json",
+  "exclude": ["dist"],
+  "compilerOptions": {
+    "outDir": "dist"
+  }
+}