@valuya/bot-channel-server-core 0.2.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Valuya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# @valuya/bot-channel-server-core
+
+Shared server/bootstrap helpers for gated bot-channel packages.
+
+This package is intentionally small and transport-neutral. It provides:
+
+- env helpers
+- request body / path helpers
+- internal JSON message endpoint handling
+- OpenAI Responses API runner for schema-driven souls
+
+Channel packages keep only their transport-specific webhook/polling glue on top.

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export declare function requiredEnv(name: string): string;
+export declare function getRequestPath(rawUrl?: string | null): string;
+export declare function readRequestBody(req: AsyncIterable<unknown>): Promise<string>;
+export declare function parseJsonBody(req: AsyncIterable<unknown>): Promise<Record<string, unknown>>;
+export declare function resolveRequestUrl(args: {
+    headers: Record<string, string | string[] | undefined>;
+    url?: string | null;
+}): string;
+export declare function handleInternalJsonMessage(args: {
+    req: AsyncIterable<unknown>;
+    internalApiToken?: string;
+    providedToken?: string | null;
+    onMessage: (body: Record<string, unknown>) => Promise<{
+        reply: string;
+        metadata?: Record<string, unknown>;
+    }>;
+}): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}>;
+export declare function createOpenAIResponsesRunner(args: {
+    apiKey: string;
+    model: string;
+}): (input: {
+    system: string;
+    user: string;
+}) => Promise<Record<string, unknown> | string>;
+export declare function tryParseJson(value: string): Record<string, unknown> | null;
+export declare function safeParseJson(response: Response): Promise<unknown>;
+export declare function extractResponseObject(body: unknown): Record<string, unknown> | string;

package/dist/index.js

@@ -0,0 +1,125 @@
+export function requiredEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`${name}_required`);
+    return value;
+}
+export function getRequestPath(rawUrl) {
+    if (!rawUrl)
+        return "/";
+    try {
+        return new URL(rawUrl, "http://localhost").pathname;
+    }
+    catch {
+        return "/";
+    }
+}
+export async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+export async function parseJsonBody(req) {
+    const raw = await readRequestBody(req);
+    if (!raw.trim())
+        return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+}
+export function resolveRequestUrl(args) {
+    const forwardedProto = normalizeHeaderValue(args.headers["x-forwarded-proto"]);
+    const forwardedHost = normalizeHeaderValue(args.headers["x-forwarded-host"]);
+    const host = normalizeHeaderValue(args.headers.host);
+    const proto = forwardedProto || "http";
+    const resolvedHost = forwardedHost || host || "localhost";
+    return `${proto}://${resolvedHost}${args.url || "/"}`;
+}
+export async function handleInternalJsonMessage(args) {
+    if (args.internalApiToken) {
+        const provided = String(args.providedToken || "").trim();
+        if (provided !== args.internalApiToken) {
+            return {
+                status: 401,
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ ok: false, error: "unauthorized" }),
+            };
+        }
+    }
+    const body = await parseJsonBody(args.req);
+    const result = await args.onMessage(body);
+    return {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ok: true, reply: result.reply, metadata: result.metadata || {} }),
+    };
+}
+export function createOpenAIResponsesRunner(args) {
+    return async (input) => {
+        const response = await fetch("https://api.openai.com/v1/responses", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${args.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: args.model,
+                input: [
+                    { role: "system", content: input.system },
+                    { role: "user", content: input.user },
+                ],
+            }),
+        });
+        const body = await safeParseJson(response);
+        if (!response.ok) {
+            throw new Error(`bot_channel_openai_failed:${response.status}:${JSON.stringify(body).slice(0, 300)}`);
+        }
+        return extractResponseObject(body);
+    };
+}
+export function tryParseJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function safeParseJson(response) {
+    const text = await response.text();
+    if (!text.trim())
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+export function extractResponseObject(body) {
+    const record = body && typeof body === "object" ? body : {};
+    if (typeof record.output_text === "string" && record.output_text.trim()) {
+        const parsed = tryParseJson(record.output_text);
+        return parsed || record.output_text.trim();
+    }
+    const output = Array.isArray(record.output) ? record.output : [];
+    const chunks = [];
+    for (const item of output) {
+        const content = Array.isArray(item?.content)
+            ? item.content
+            : [];
+        for (const part of content) {
+            if (typeof part.text === "string" && part.text.trim())
+                chunks.push(part.text.trim());
+        }
+    }
+    const text = chunks.join("\n").trim();
+    return tryParseJson(text) || text;
+}
+function normalizeHeaderValue(value) {
+    if (Array.isArray(value))
+        return String(value[0] || "").split(",")[0]?.trim() || "";
+    return String(value || "").split(",")[0]?.trim() || "";
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@valuya/bot-channel-server-core",
+  "version": "0.2.0-beta.1",
+  "description": "Shared server/bootstrap helpers for gated bot-channel packages",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.0.10"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "test": "pnpm run build && node --test dist/*.test.js"
+  }
+}