@genesis-agent/channel-sdk 0.5.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@genesis-agent/channel-sdk",
+  "version": "0.5.0",
+  "description": "SDK for building Genesis channel adapters in Node.js / TypeScript",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deadraid/genesis.git",
+    "directory": "packaging/channel-sdk-node"
+  },
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "files": ["src/"],
+  "engines": {
+    "node": ">=16"
+  },
+  "keywords": [
+    "genesis",
+    "channel",
+    "sdk",
+    "ai",
+    "agent",
+    "telegram",
+    "discord",
+    "slack"
+  ]
+}

package/src/index.d.ts

@@ -0,0 +1,65 @@
+export interface Capabilities {
+  text?: boolean;
+  markdown?: boolean;
+  images?: boolean;
+  files?: boolean;
+  buttons?: boolean;
+  inline_buttons?: boolean;
+  typing_indicator?: boolean;
+  edit_message?: boolean;
+  delete_message?: boolean;
+  threads?: boolean;
+  reactions?: boolean;
+  voice?: boolean;
+  max_message_length?: number;
+}
+
+export interface SendParams {
+  to: { channel_identity: string };
+  content: { text?: string; format?: string; file?: { name: string; data: string } };
+}
+
+export interface TypingParams {
+  to: { channel_identity: string };
+  active: boolean;
+}
+
+export interface RequestAuthParams {
+  to: { channel_identity: string };
+  request_id: string;
+  prompt: string;
+  options?: Array<{ label: string; value: string }>;
+  timeout_ms?: number;
+}
+
+export interface ChannelConfig {
+  capabilities?: Capabilities;
+  systemPrompt?: string;
+  onSend?: (params: SendParams) => void | Promise<unknown>;
+  onEdit?: (params: SendParams) => void | Promise<unknown>;
+  onDelete?: (params: { to: { channel_identity: string } }) => void | Promise<unknown>;
+  onTyping?: (params: TypingParams) => void;
+  onRequestAuth?: (params: RequestAuthParams) => void | Promise<unknown>;
+  onStartup?: () => void | Promise<void>;
+}
+
+export interface Channel {
+  emitMessage(channelIdentity: string, displayName: string, text: string, timestamp?: number): void;
+  emitFileMessage(channelIdentity: string, displayName: string, fileName: string, fileDataB64: string, caption?: string, timestamp?: number): void;
+  emitEvent(channelIdentity: string, displayName: string, eventType: string, data: string): void;
+  sendStatus(state: string): void;
+  splitMessage(text: string, maxLen: number): string[];
+  respond(id: number | string, result?: object, error?: object): void;
+}
+
+export function createChannel(config: ChannelConfig): Channel;
+
+export function writeJsonLine(obj: object): void;
+export function notify(method: string, params: object): void;
+export function respond(id: number | string, result?: object, error?: object): void;
+export function sendHello(capabilities: Capabilities, systemPrompt?: string): void;
+export function sendStatus(state: string): void;
+export function emitMessage(channelIdentity: string, displayName: string, text: string, timestamp?: number): void;
+export function emitFileMessage(channelIdentity: string, displayName: string, fileName: string, fileDataB64: string, caption?: string, timestamp?: number): void;
+export function emitEvent(channelIdentity: string, displayName: string, eventType: string, data: string): void;
+export function splitMessage(text: string, maxLen: number): string[];

package/src/index.js

@@ -0,0 +1,171 @@
+"use strict";
+
+const readline = require("readline");
+
+function writeJsonLine(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+
+function notify(method, params) {
+  writeJsonLine({ jsonrpc: "2.0", method, params });
+}
+
+function respond(id, result, error) {
+  const msg = { jsonrpc: "2.0", id };
+  if (error) msg.error = error;
+  else msg.result = result || {};
+  writeJsonLine(msg);
+}
+
+function sendHello(capabilities, systemPrompt) {
+  const params = { capabilities };
+  if (systemPrompt) params.system_prompt = systemPrompt;
+  notify("channel.hello", params);
+}
+
+function sendStatus(state) {
+  notify("channel.status", { state });
+}
+
+function emitMessage(channelIdentity, displayName, text, timestamp) {
+  notify("channel.message", {
+    from: { channel_identity: channelIdentity, display_name: displayName },
+    text,
+    timestamp: timestamp || Math.floor(Date.now() / 1000),
+  });
+}
+
+function emitFileMessage(channelIdentity, displayName, fileName, fileDataB64, caption, timestamp) {
+  notify("channel.message", {
+    from: { channel_identity: channelIdentity, display_name: displayName },
+    text: caption || "",
+    timestamp: timestamp || Math.floor(Date.now() / 1000),
+    file: { name: fileName, data: fileDataB64 },
+  });
+}
+
+function emitEvent(channelIdentity, displayName, eventType, data) {
+  notify("channel.event", {
+    from: { channel_identity: channelIdentity, display_name: displayName },
+    type: eventType,
+    data,
+  });
+}
+
+function splitMessage(text, maxLen) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = maxLen;
+    while (splitAt > 0 && remaining[splitAt - 1] !== "\n") splitAt--;
+    if (splitAt === 0) splitAt = maxLen;
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt);
+  }
+  return chunks;
+}
+
+function createChannel(config) {
+  const {
+    capabilities = { text: true, max_message_length: 4096 },
+    systemPrompt,
+    onSend,
+    onEdit,
+    onDelete,
+    onTyping,
+    onRequestAuth,
+    onStartup,
+  } = config;
+
+  sendHello(capabilities, systemPrompt);
+
+  if (onStartup) {
+    Promise.resolve(onStartup()).catch((err) => {
+      process.stderr.write(`[channel] startup error: ${err}\n`);
+    });
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+  rl.on("line", (raw) => {
+    raw = raw.trim();
+    if (!raw) return;
+
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      process.stderr.write(`[channel] invalid json: ${raw}\n`);
+      return;
+    }
+
+    const method = msg.method;
+    const params = msg.params || {};
+    const id = msg.id;
+
+    const handleResult = (promise, fallback) => {
+      if (!promise) {
+        if (id != null) respond(id, { ok: true });
+        return;
+      }
+      Promise.resolve(promise)
+        .then((result) => {
+          if (id != null) respond(id, result || { ok: true });
+        })
+        .catch((err) => {
+          process.stderr.write(`[channel] ${method}: ${err}\n`);
+          if (id != null) respond(id, null, { code: -32000, message: String(err) });
+        });
+    };
+
+    switch (method) {
+      case "channel.send":
+        handleResult(onSend ? onSend(params) : null);
+        break;
+      case "channel.edit":
+        handleResult(onEdit ? onEdit(params) : null);
+        break;
+      case "channel.delete":
+        handleResult(onDelete ? onDelete(params) : null);
+        break;
+      case "channel.typing":
+        if (onTyping) onTyping(params);
+        break;
+      case "channel.request_auth":
+        handleResult(onRequestAuth ? onRequestAuth(params) : null);
+        break;
+      default:
+        if (id != null) {
+          respond(id, null, { code: -32601, message: `Method not found: ${method}` });
+        }
+    }
+  });
+
+  rl.on("close", () => process.exit(0));
+
+  return {
+    emitMessage,
+    emitFileMessage,
+    emitEvent,
+    sendStatus,
+    splitMessage,
+    respond,
+  };
+}
+
+module.exports = {
+  createChannel,
+  writeJsonLine,
+  notify,
+  respond,
+  sendHello,
+  sendStatus,
+  emitMessage,
+  emitFileMessage,
+  emitEvent,
+  splitMessage,
+};