open-index/open-npm huggingface dataset:
npm package: @openacp/discord-adapter
Description: Discord adapter plugin for OpenACP — forum threads, slash commands, streaming messages
Latest version: 2026.331.2

# @openacp/discord-adapter

Discord adapter plugin for [OpenACP](https://github.com/Open-ACP/OpenACP). Creates forum threads for each AI session, supports slash commands, streaming messages, and permission requests.

## Installation

```bash
openacp plugin add @openacp/discord-adapter
```

## Development

```bash
git clone https://github.com/Open-ACP/discord-adapter.git
cd discord-adapter
pnpm install
pnpm build
pnpm test

# Hot-reload development
openacp dev .
```

## Configuration

After installing the plugin, run `openacp plugin configure @openacp/discord-adapter` to set up:

- Discord bot token
- Guild ID
- Forum channel ID
npm package: @openacp/slack-adapter
Description: Slack messaging platform adapter plugin for OpenACP
Latest version: 2026.411.1

# @openacp/slack-adapter

Slack messaging platform adapter plugin for [OpenACP](https://github.com/Open-ACP/OpenACP).

## Installation

```bash
openacp plugin install @openacp/slack-adapter
```

## Configuration

Add to your `~/.openacp/config.json`:

```json
{
  "channels": {
    "slack": {
      "enabled": true,
      "adapter": "@openacp/slack-adapter",
      "botToken": "xoxb-...",
      "appToken": "xapp-...",
      "signingSecret": "...",
      "channelPrefix": "openacp",
      "notificationChannelId": "C...",
      "allowedUserIds": [],
      "autoCreateSession": true,
      "outputMode": "medium"
    }
  }
}
```

| Field | Description |
|-------|-------------|
| `botToken` | Bot User OAuth Token (`xoxb-…`) |
| `appToken` | App-Level Token (`xapp-…`) for Socket Mode |
| `signingSecret` | Signing Secret from Basic Information |
| `channelPrefix` | Prefix for session channel names. Default: `openacp` |
| `notificationChannelId` | Optional. Channel ID for system notifications |
| `allowedUserIds` | Optional. Restrict access to specific Slack user IDs |
| `autoCreateSession` | Create a startup session on boot. Default: `true` |
| `outputMode` | Default verbosity: `"low"`, `"medium"`, or `"high"`. Default: `"medium"` |

### Output Mode

The adapter renders agent activity in real time using Slack threads:

- **Low** 🔇 — minimal indicator only (`🔧 Processing...` → `✅ Done`)
- **Medium** 📊 — tool names + running count in the main message; tool cards in thread
- **High** 🔍 — full detail: tool input/output, diffs, viewer links, thinking in thread

Change the mode on the fly with `/outputmode low|medium|high`, or open an interactive modal with `/outputmode`. Requires the slash command to be registered in the Slack app settings — see the [setup guide](https://docs.openacp.dev/platform-setup/slack).

## Development

```bash
npm install
npm run build
npm test

# Install locally for testing
openacp plugin install /path/to/slack-plugin
```

## License

MIT
npm package: @openaction/svelte-pi
Description: A Svelte library for ergonomically and concisely creating Property Inspectors for the OpenAction API
Author: nekename
Latest version: 1.0.1

# @openaction/svelte-pi

A Svelte library for ergonomically and concisely creating Property Inspectors for the [OpenAction API](https://openaction.amankhanna.me) (backwards-compatible with the Stream Deck SDK)

```svelte
<script lang="ts">
	import {
		actionSettings,
		globalSettings,
		eventTarget,
		sendToPlugin,
		openUrl,
	} from "@openaction/svelte-pi";

	actionSettings.subscribe((value) =>
		console.log("Action settings updated:", value),
	);
	globalSettings.subscribe((value) =>
		console.log("Global settings updated:", value),
	);

	eventTarget.addEventListener("sendToPropertyInspector", (event: any) => {
		console.log("sendToPropertyInspector event received:", event.detail);
	});

	sendToPlugin({ a: 1 });
	openUrl("https://example.com");
</script>

<p>{JSON.stringify($actionSettings)}</p>
<p>{JSON.stringify($globalSettings)}</p>

<button onclick={() => $actionSettings.value = Math.random()}>Click me</button>
```

For the OpenAction server to be able to pass connection details to your property inspector, you must include the following snippet in the `<head>` of your `app.html`:

```html
<script>
	window.connectOpenActionSocketData = new Promise((resolve) => {
		window.connectOpenActionSocket = (...args) => resolve(args);
		window.connectElgatoStreamDeckSocket = window.connectOpenActionSocket;
	});
</script>
```

See [OpenActionPlugins/discord](https://github.com/OpenActionPlugins/discord) for an example complete project setup using this library.
npm package: @openactive/rpde-validator
Description: A library to walk and validate an RPDE feed
Author: OpenActive Community
Latest version: 3.0.3571

# RPDE Validator

The OpenActive RPDE validator library.

[![Tests](https://github.com/openactive/rpde-validator/actions/workflows/node.js.yml/badge.svg?branch=master)](https://github.com/openactive/rpde-validator/actions/workflows/node.js.yml)
[![Known Vulnerabilities](https://snyk.io/test/github/openactive/rpde-validator/badge.svg)](https://snyk.io/test/github/openactive/rpde-validator)

## Introduction

This library allows developers to validate RPDE feeds against the latest [Realtime Paged Data Exchange](https://www.openactive.io/realtime-paged-data-exchange/) specification.

## Using in your application

This library can be used in your own application, perhaps as part of your CI pipeline.

### Install

```shell
$ npm install @openactive/rpde-validator
```

### Usage

```js
const { RpdeValidator } = require('@openactive/rpde-validator');

RpdeValidator(
  url, // The URL of the feed to test
  {
    // A callback that is called for log messages
    // Will be provided with an object that looks like:
    // {
    //   verbosity: 1, // 1-3 (higher is more verbose)
    //   percentage: 50, // The percentage complete
    //   message: '...', // String log message
    // }
    logCallback: (log) => {
      console.log(log.message);
    },
    // User agent used by the validator
    // Default: "RPDE_Validator/version (+https://validator.openactive.io/rpde)"
    userAgent: null, 
    // The time in between requests in a feed in milliseconds
    // Default: 0
    requestDelayMs: 1000,
    // The timeout in which to give up on requesting a feed URL
    // Must be non-zero
    // Default: 10000
    timeoutMs: 10000,
    // The number of feed pages to walk through
    // Must be non-zero
    // Default: 20
    pageLimit: 10,
  }
);
```

## Development

### Getting started

```shell
$ git clone git@github.com:openactive/rpde-validator.git
$ cd rpde-validator
$ npm install
```
### Running tests

This project uses [Jasmine](https://jasmine.github.io/) for its tests. All spec files are located alongside the files that they target.

To run tests locally, run:

```shell
$ npm test
```

The test run will also include a run of [eslint](https://eslint.org/). To run the tests without these, use:

```shell
$ npm run test-no-lint
```
npm package: @openaddresses/batch-error
Description: OpenAddresses Error Handler
Author: ingalls
Latest version: 2.14.1

<h1 align=center>Batch-Error</h1>

<p align=center>Errors for the HTTP Serving World</p>

## Installation

```sh
npm i @openaddresses/batch-error
```

## Example Usage

```js
const Err = require('@openaddresses/batch-error');

throw new Err(statusCode, originalErr_orNull, message);
```
npm package: @openaddresses/batch-schema
Description: Strongly Validated JSON Schema support for address
Author: ingalls
Latest version: 10.23.2

<h1 align=center>Batch-Schema</h1>

<p align=center>Express Plugin for <a href='https://github.com/sinclairzx81/typebox'>TypeBox</a> Request and Response Validation</p>

## Installation

```sh
npm i @openaddresses/batch-schema
```

## Example Usage

```js
import express from 'express';
import Schema from '@openaddresses/batch-schema';
import { Type } from '@sinclair/typebox';

const app = express();
const schema = new Schema(express.Router(), {
    logging: true,  // Enable Morgan Logging
    limit: 50       // Body size for parsing JSON
});

app.use('/api', schema.router);

server();

async function server() {
    await schema.post('/api/:param1/:param2', {
        query: Type.Object({
            example: Type.Optional(Type.Uppercase(Type.String()))
        }),
        params: Type.Object({
            param1: Type.String(),
            param2: Type.Number(),
        }),
        body: Type.Object({
            username: Type.String(),
            password: Type.String(),
        }),
        res: Type.Object({
            token: Type.String()
        }),
    }, (req, res) => {
        return res.json({
            token: 'I only return if the request meets the query & body schemas'
        });
    });
}
```

## API

```js
const schema = new Schema(<router>, <opts>);

```

| Config Option     | Notes |
| ----------------- | ----- |
| `router`          | Instantiated Express router to bind to |
| `opts`            | Optional Opts Object |
| `opts.schemas`    | Directory of named schemas |


### schema.api

```
await schema.api()
```

Adds a route called `GET /schema` which allows the caller to get a list of endpoints that the router manages
as well as full schema details for every route. If your API is public we recommend enabling this feature, however
if you do not wish for API routes to be published, this feature is disabled unless called.

Adds a route called `GET /openapi` which returns an OpenAPI / Swagger JSON Object

### schema.not_found

Adds a middlware which will catch all routes that have not been defined and return
a standard error object.

```
schema.not_found()
```

### schema.error

Adds a middlware which will convert validation errors into a standard JSON error format.
This method should be called after all routes are defined. If this method is not called,
you must provide your own middleware for converting JSON Schema Validation Errors into
express compatible responses.

```
schema.error()
```

### schema.load

Loads and runs all routes files in a directory

```
schema.load(directory, config, opts)
```

| Config Option     | Notes |
| ----------------- | ----- |
| `directory`       | Directory to load .js files from |
| `config`          | Config option to pass to each route |
| `opts`            | Optional Opts Object |
| `opts.silent`     | Squelch output |