@dobby.ai/dobby 0.1.0

package/config/gateway.example.json

@@ -0,0 +1,128 @@
+{
+  "extensions": {
+    "allowList": [
+      {
+        "package": "@dobby.ai/provider-pi",
+        "enabled": true
+      },
+      {
+        "package": "@dobby.ai/connector-discord",
+        "enabled": true
+      },
+      {
+        "package": "@dobby.ai/connector-feishu",
+        "enabled": false
+      },
+      {
+        "package": "@dobby.ai/provider-claude-cli",
+        "enabled": false
+      }
+    ]
+  },
+  "providers": {
+    "default": "pi.main",
+    "items": {
+      "pi.main": {
+        "type": "provider.pi",
+        "provider": "custom-openai",
+        "model": "example-model",
+        "thinkingLevel": "off",
+        "modelsFile": "./models.custom.json"
+      }
+    }
+  },
+  "connectors": {
+    "items": {
+      "discord.main": {
+        "type": "connector.discord",
+        "botName": "dobby-main",
+        "botToken": "REPLACE_WITH_DISCORD_BOT_TOKEN",
+        "reconnectStaleMs": 60000,
+        "reconnectCheckIntervalMs": 10000
+      }
+    }
+  },
+  "sandboxes": {
+    "default": "host.builtin",
+    "items": {}
+  },
+  "routes": {
+    "defaults": {
+      "provider": "pi.main",
+      "sandbox": "host.builtin",
+      "tools": "full",
+      "mentions": "required"
+    },
+    "items": {
+      "projectA": {
+        "projectRoot": "/Users/you/workspace/project-a"
+      }
+    }
+  },
+  "bindings": {
+    "items": {
+      "discord.main.projectA": {
+        "connector": "discord.main",
+        "source": {
+          "type": "channel",
+          "id": "YOUR_DISCORD_CHANNEL_ID_A"
+        },
+        "route": "projectA"
+      }
+    }
+  },
+  "_examples": {
+    "connectors": {
+      "items": {
+        "feishu.main": {
+          "type": "connector.feishu",
+          "appId": "cli_xxx",
+          "appSecret": "REPLACE_WITH_FEISHU_APP_SECRET",
+          "domain": "feishu",
+          "botName": "dobby-feishu",
+          "messageFormat": "card_markdown",
+          "replyMode": "direct",
+          "cardTitle": "Dobby",
+          "downloadAttachments": true
+        }
+      }
+    },
+    "providers": {
+      "items": {
+        "claude-cli.main": {
+          "type": "provider.claude-cli",
+          "model": "claude-sonnet-4-5",
+          "maxTurns": 20,
+          "command": "claude",
+          "commandArgs": [],
+          "authMode": "auto",
+          "permissionMode": "bypassPermissions",
+          "streamVerbose": true
+        }
+      }
+    },
+    "routes": {
+      "items": {
+        "projectA": {
+          "provider": "claude-cli.main"
+        }
+      }
+    },
+    "bindings": {
+      "items": {
+        "feishu.main.projectA": {
+          "connector": "feishu.main",
+          "source": {
+            "type": "chat",
+            "id": "oc_xxx"
+          },
+          "route": "projectA"
+        }
+      }
+    }
+  },
+  "data": {
+    "rootDir": "./data",
+    "dedupTtlMs": 604800000
+  }
+}

package/config/models.custom.example.json

@@ -0,0 +1,27 @@
+{
+  "providers": {
+    "custom-openai": {
+      "baseUrl": "https://api.example.com/v1",
+      "api": "openai-completions",
+      "apiKey": "CUSTOM_PROVIDER_AUTH_TOKEN",
+      "models": [
+        {
+          "id": "example-model",
+          "name": "example-model",
+          "reasoning": false,
+          "input": [
+            "text"
+          ],
+          "contextWindow": 128000,
+          "maxTokens": 8192,
+          "cost": {
+            "input": 0,
+            "output": 0,
+            "cacheRead": 0,
+            "cacheWrite": 0
+          }
+        }
+      ]
+    }
+  }
+}

package/dist/src/agent/event-forwarder.js

@@ -0,0 +1,341 @@
+function truncate(text, max) {
+    if (max === undefined)
+        return text;
+    if (max <= 0)
+        return "";
+    if (text.length <= max)
+        return text;
+    const suffix = "\n...(truncated)";
+    if (max <= suffix.length) {
+        return text.slice(0, max);
+    }
+    return `${text.slice(0, max - suffix.length)}${suffix}`;
+}
+function splitForMaxLength(text, max, options = {}) {
+    if (max === undefined) {
+        return [text];
+    }
+    if (max <= 0) {
+        return [""];
+    }
+    if (text.length <= max) {
+        return [text];
+    }
+    const preserveWhitespace = options.preserveWhitespace ?? false;
+    const chunks = [];
+    let offset = 0;
+    while (offset < text.length) {
+        const remainingLength = text.length - offset;
+        if (remainingLength <= max) {
+            chunks.push(text.slice(offset));
+            break;
+        }
+        if (preserveWhitespace) {
+            chunks.push(text.slice(offset, offset + max));
+            offset += max;
+            continue;
+        }
+        const hardLimit = offset + max;
+        let splitAt = text.lastIndexOf("\n", hardLimit);
+        if (splitAt < offset + Math.floor(max * 0.6)) {
+            splitAt = hardLimit;
+        }
+        else {
+            splitAt += 1;
+        }
+        chunks.push(text.slice(offset, splitAt));
+        offset = splitAt;
+    }
+    return chunks;
+}
+export class EventForwarder {
+    connector;
+    inbound;
+    logger;
+    rootMessageId;
+    responseText = "";
+    appendEmittedText = "";
+    pendingFlush = null;
+    flushSerial = Promise.resolve();
+    pendingOps = [];
+    updateIntervalMs;
+    toolMessageMode;
+    maxTextLength;
+    onOutboundActivity;
+    updateStrategy;
+    lastEditPrimaryText = null;
+    constructor(connector, inbound, rootMessageId, logger, options = {}) {
+        this.connector = connector;
+        this.inbound = inbound;
+        this.logger = logger;
+        this.rootMessageId = rootMessageId;
+        this.updateIntervalMs = options.updateIntervalMs ?? 400;
+        this.toolMessageMode = options.toolMessageMode ?? "none";
+        this.onOutboundActivity = options.onOutboundActivity;
+        this.updateStrategy = this.connector.capabilities.updateStrategy;
+        const capabilityMaxTextLength = this.connector.capabilities.maxTextLength;
+        this.maxTextLength = typeof capabilityMaxTextLength === "number" && capabilityMaxTextLength > 0
+            ? capabilityMaxTextLength
+            : undefined;
+    }
+    primaryMessageId() {
+        return this.rootMessageId;
+    }
+    handleEvent = (event) => {
+        if (event.type === "message_delta") {
+            this.responseText += event.delta;
+            if (this.updateStrategy !== "final_only") {
+                this.scheduleFlush();
+            }
+            return;
+        }
+        if (event.type === "message_complete") {
+            if (event.text.trim().length > 0) {
+                this.responseText = event.text;
+                if (this.updateStrategy !== "final_only") {
+                    void this.flushNow();
+                }
+            }
+            return;
+        }
+        if (event.type === "tool_start") {
+            this.logger.info({
+                toolName: event.toolName,
+                conversation: `${this.inbound.platform}:${this.inbound.accountId}:${this.inbound.chatId}:${this.inbound.threadId ?? "root"}`,
+            }, "Tool execution started");
+            if (this.updateStrategy !== "final_only" && this.toolMessageMode === "all") {
+                this.enqueueSend(`_-> Running tool: ${event.toolName}_`);
+            }
+            return;
+        }
+        if (event.type === "tool_end") {
+            const summary = event.output;
+            this.logger.info({
+                toolName: event.toolName,
+                isError: event.isError,
+                conversation: `${this.inbound.platform}:${this.inbound.accountId}:${this.inbound.chatId}:${this.inbound.threadId ?? "root"}`,
+            }, event.isError ? "Tool execution finished with error" : "Tool execution finished");
+            if (this.updateStrategy !== "final_only" &&
+                (this.toolMessageMode === "all" || (this.toolMessageMode === "errors" && event.isError))) {
+                const prefix = event.isError ? "ERR" : "OK";
+                const header = `*${prefix} ${event.toolName}*\n\`\`\`\n`;
+                const footer = "\n```";
+                const availableSummaryLength = this.maxTextLength === undefined
+                    ? undefined
+                    : Math.max(0, this.maxTextLength - header.length - footer.length);
+                this.enqueueSend(`${header}${truncate(summary, availableSummaryLength)}${footer}`);
+            }
+            return;
+        }
+        if (event.type === "status") {
+            if (this.updateStrategy === "final_only") {
+                return;
+            }
+            this.enqueueSend(`_${event.message}_`);
+        }
+    };
+    async finalize() {
+        if (this.updateStrategy === "final_only") {
+            await this.finalizeFinalOnly();
+            await Promise.allSettled(this.pendingOps);
+            return;
+        }
+        if (this.updateStrategy === "append") {
+            await this.finalizeAppend();
+            await Promise.allSettled(this.pendingOps);
+            return;
+        }
+        await this.finalizeEdit();
+        await Promise.allSettled(this.pendingOps);
+    }
+    baseEnvelope() {
+        return {
+            platform: this.inbound.platform,
+            accountId: this.inbound.accountId,
+            chatId: this.inbound.chatId,
+            ...(this.inbound.threadId ? { threadId: this.inbound.threadId } : {}),
+        };
+    }
+    scheduleFlush() {
+        if (this.pendingFlush)
+            return;
+        this.pendingFlush = setTimeout(() => {
+            void this.flushNow();
+        }, this.updateIntervalMs);
+    }
+    async flushNow() {
+        const run = this.flushSerial.then(async () => {
+            if (this.pendingFlush) {
+                clearTimeout(this.pendingFlush);
+                this.pendingFlush = null;
+            }
+            if (this.responseText.trim().length === 0) {
+                return;
+            }
+            try {
+                if (this.updateStrategy === "append") {
+                    await this.flushAppendProgress();
+                    return;
+                }
+                if (this.updateStrategy === "edit") {
+                    const content = truncate(this.responseText, this.maxTextLength);
+                    await this.sendEditPrimary(content);
+                }
+            }
+            catch (error) {
+                this.logger.warn({
+                    err: error,
+                    connectorId: this.inbound.connectorId,
+                    chatId: this.inbound.chatId,
+                    targetMessageId: this.rootMessageId,
+                    contentLength: this.responseText.length,
+                    updateStrategy: this.updateStrategy,
+                }, "Failed to flush streaming update");
+            }
+        });
+        this.flushSerial = run.catch(() => {
+            // keep chain alive for future flush calls
+        });
+        await run;
+    }
+    enqueueSend(text) {
+        const promise = this.connector
+            .send({
+            ...this.baseEnvelope(),
+            mode: "create",
+            ...(this.rootMessageId ? { replyToMessageId: this.rootMessageId } : {}),
+            text,
+        })
+            .then(() => {
+            this.noteOutboundActivity();
+        })
+            .catch((error) => {
+            this.logger.warn({
+                err: error,
+                connectorId: this.inbound.connectorId,
+                chatId: this.inbound.chatId,
+                replyToMessageId: this.rootMessageId,
+            }, "Failed to send connector update message");
+        });
+        this.pendingOps.push(promise);
+    }
+    async sendEditPrimary(text) {
+        if (this.rootMessageId && this.lastEditPrimaryText === text) {
+            return;
+        }
+        if (this.rootMessageId) {
+            await this.connector.send({
+                ...this.baseEnvelope(),
+                mode: "update",
+                targetMessageId: this.rootMessageId,
+                text,
+            });
+            this.lastEditPrimaryText = text;
+            this.noteOutboundActivity();
+            return;
+        }
+        const created = await this.connector.send({
+            ...this.baseEnvelope(),
+            mode: "create",
+            text,
+        });
+        this.rootMessageId = created.messageId ?? this.rootMessageId;
+        this.lastEditPrimaryText = text;
+        this.noteOutboundActivity();
+    }
+    async sendCreate(text) {
+        const created = await this.connector.send({
+            ...this.baseEnvelope(),
+            mode: "create",
+            ...(this.rootMessageId ? { replyToMessageId: this.rootMessageId } : {}),
+            text,
+        });
+        this.rootMessageId = this.rootMessageId ?? created.messageId ?? null;
+        this.noteOutboundActivity();
+    }
+    async flushAppendProgress() {
+        if (this.responseText.startsWith(this.appendEmittedText)) {
+            const unsent = this.responseText.slice(this.appendEmittedText.length);
+            if (unsent.length === 0) {
+                return;
+            }
+            const chunks = splitForMaxLength(unsent, this.maxTextLength, { preserveWhitespace: true });
+            for (const chunk of chunks) {
+                await this.sendCreate(chunk);
+            }
+            this.appendEmittedText = this.responseText;
+            return;
+        }
+        const snapshotChunks = splitForMaxLength(this.responseText, this.maxTextLength);
+        for (const chunk of snapshotChunks) {
+            await this.sendCreate(chunk);
+        }
+        this.appendEmittedText = this.responseText;
+    }
+    async finalizeEdit() {
+        await this.flushNow();
+        if (this.responseText.trim().length === 0) {
+            await this.sendEditPrimary("(completed with no text response)");
+            return;
+        }
+        const chunks = splitForMaxLength(this.responseText, this.maxTextLength);
+        try {
+            await this.sendEditPrimary(chunks[0] ?? "");
+            for (const chunk of chunks.slice(1)) {
+                await this.sendCreate(chunk);
+            }
+        }
+        catch (error) {
+            this.logger.warn({
+                err: error,
+                connectorId: this.inbound.connectorId,
+                chatId: this.inbound.chatId,
+                targetMessageId: this.rootMessageId,
+            }, "Failed to send split final response");
+        }
+    }
+    async finalizeFinalOnly() {
+        if (this.pendingFlush) {
+            clearTimeout(this.pendingFlush);
+            this.pendingFlush = null;
+        }
+        try {
+            if (this.responseText.trim().length === 0) {
+                await this.sendCreate("(completed with no text response)");
+                return;
+            }
+            const chunks = splitForMaxLength(this.responseText, this.maxTextLength);
+            for (const chunk of chunks) {
+                await this.sendCreate(chunk);
+            }
+        }
+        catch (error) {
+            this.logger.warn({
+                err: error,
+                connectorId: this.inbound.connectorId,
+                chatId: this.inbound.chatId,
+                updateStrategy: this.updateStrategy,
+            }, "Failed to send final-only response");
+        }
+    }
+    async finalizeAppend() {
+        await this.flushNow();
+        if (this.responseText.trim().length > 0 || this.appendEmittedText.trim().length > 0) {
+            return;
+        }
+        try {
+            await this.sendCreate("(completed with no text response)");
+        }
+        catch (error) {
+            this.logger.warn({
+                err: error,
+                connectorId: this.inbound.connectorId,
+                chatId: this.inbound.chatId,
+                updateStrategy: this.updateStrategy,
+            }, "Failed to send append fallback response");
+        }
+    }
+    noteOutboundActivity() {
+        this.onOutboundActivity?.();
+    }
+}

package/dist/src/agent/tests/event-forwarder.test.js

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { EventForwarder } from "../event-forwarder.js";
+class FakeConnector {
+    id = "connector.test";
+    platform = "test";
+    name = "test";
+    capabilities;
+    sent = [];
+    sentCount = 0;
+    constructor(updateStrategy, maxTextLength) {
+        this.capabilities = {
+            updateStrategy,
+            supportsThread: false,
+            supportsTyping: false,
+            supportsFileUpload: false,
+            ...(maxTextLength !== undefined ? { maxTextLength } : {}),
+        };
+    }
+    async start(_ctx) { }
+    async send(message) {
+        this.sent.push(message);
+        this.sentCount += 1;
+        return { messageId: `msg-${this.sentCount}` };
+    }
+    async stop() { }
+}
+const noopLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+};
+function createInbound() {
+    return {
+        connectorId: "connector.test",
+        platform: "test",
+        accountId: "bot",
+        routeId: "route.main",
+        routeChannelId: "route.main",
+        chatId: "chat.main",
+        messageId: "inbound-1",
+        userId: "user-1",
+        text: "hello",
+        attachments: [],
+        timestampMs: Date.now(),
+        raw: {},
+        isDirectMessage: false,
+        mentionedBot: true,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+test("edit strategy keeps create+update flow", async () => {
+    const connector = new FakeConnector("edit");
+    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
+        updateIntervalMs: 1,
+    });
+    forwarder.handleEvent({ type: "message_complete", text: "hello" });
+    await sleep(5);
+    forwarder.handleEvent({ type: "message_complete", text: "hello world" });
+    await sleep(5);
+    await forwarder.finalize();
+    assert.equal(connector.sent.length, 2);
+    assert.equal(connector.sent[0]?.mode, "create");
+    assert.equal(connector.sent[0]?.text, "hello");
+    assert.equal(connector.sent[1]?.mode, "update");
+    assert.equal(connector.sent[1]?.text, "hello world");
+});
+test("final_only suppresses tool/status outbound messages", async () => {
+    const connector = new FakeConnector("final_only");
+    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
+        toolMessageMode: "all",
+        updateIntervalMs: 1,
+    });
+    forwarder.handleEvent({ type: "status", message: "starting" });
+    forwarder.handleEvent({ type: "tool_start", toolName: "bash" });
+    forwarder.handleEvent({ type: "message_delta", delta: "hello " });
+    forwarder.handleEvent({ type: "tool_end", toolName: "bash", isError: false, output: "ok" });
+    forwarder.handleEvent({ type: "message_delta", delta: "world" });
+    await forwarder.finalize();
+    assert.equal(connector.sent.length, 1);
+    assert.equal(connector.sent[0]?.mode, "create");
+    assert.equal(connector.sent[0]?.text, "hello world");
+});
+test("final_only splits long final text into multiple create messages", async () => {
+    const connector = new FakeConnector("final_only", 5);
+    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger);
+    forwarder.handleEvent({ type: "message_complete", text: "12345678901" });
+    await forwarder.finalize();
+    assert.equal(connector.sent.length, 3);
+    assert.deepEqual(connector.sent.map((message) => ({ mode: message.mode, text: message.text })), [
+        { mode: "create", text: "12345" },
+        { mode: "create", text: "67890" },
+        { mode: "create", text: "1" },
+    ]);
+});
+test("append sends streaming increments as create messages only", async () => {
+    const connector = new FakeConnector("append");
+    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
+        updateIntervalMs: 5,
+    });
+    forwarder.handleEvent({ type: "message_delta", delta: "hello" });
+    await sleep(20);
+    forwarder.handleEvent({ type: "message_delta", delta: " world" });
+    await sleep(20);
+    await forwarder.finalize();
+    assert.deepEqual(connector.sent.map((message) => message.mode), ["create", "create"]);
+    assert.deepEqual(connector.sent.map((message) => message.text), ["hello", " world"]);
+});