@0xmaxma/claude-gateway 1.3.16 → 1.3.18

package/mcp/server.ts

@@ -14,6 +14,7 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 import { TelegramModule } from './tools/telegram/module';
 import { DiscordModule } from './tools/discord/module';
+import { LineModule } from './tools/line/module';
 import { CronModule } from './tools/cron/module';
 import { SkillsModule } from './tools/skills/module';
 import { AgentModule } from './tools/agent/module';
@@ -33,6 +34,7 @@ function isChannelModule(mod: AnyModule): mod is ChannelModule {
 const modules: AnyModule[] = [
   new TelegramModule(),
   new DiscordModule(),
+  new LineModule(),
   new CronModule(),
   new SkillsModule(),
   new AgentModule(),

package/mcp/tools/line/module.ts

@@ -0,0 +1,127 @@
+/**
+ * LINE outbound tool module — exposes `line_reply` to the Claude session.
+ *
+ * LINE is a ToolModule (reply-only, like ApiModule): inbound arrives via the
+ * gateway's Express webhook route (src/api/line-webhook-router.ts), not here.
+ *
+ * Delivery is reply-token-first → push fallback (matches openclaw/hermes-agent):
+ * LINE counts push/broadcast against the OA's monthly quota but reply-token
+ * messages are FREE, so we send via the reply API when a (still-valid) reply_token
+ * is passed, and fall back to push if it's absent or expired/used (the single-use
+ * token has no guaranteed lifetime — ~1 min — so push remains the safety net).
+ */
+import type { ToolModule, McpToolDefinition, McpToolResult, ToolVisibility } from '../../types';
+import { messagingApi } from '@line/bot-sdk';
+import { chunkText, planLineSend, LINE_TEXT_LIMIT } from './pure';
+
+export class LineModule implements ToolModule {
+  id = 'line';
+  toolVisibility: ToolVisibility = 'current-channel';
+
+  isEnabled(): boolean {
+    return process.env.GATEWAY_ORIGIN_CHANNEL === 'line';
+  }
+
+  getTools(): McpToolDefinition[] {
+    return [
+      {
+        name: 'line_reply',
+        description:
+          'Send a reply to the current LINE user. ' +
+          'Pass chat_id (the LINE userId shown in the <channel> tag) and text. ' +
+          'Also pass reply_token from the <channel> tag when present — it sends the ' +
+          'reply for FREE (push messages count against the LINE quota); the tool ' +
+          'automatically falls back to push if the token is expired/used. ' +
+          'Long text is split into multiple messages automatically.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            chat_id: {
+              type: 'string',
+              description: 'LINE userId to send to (the chat_id from the channel turn).',
+            },
+            text: {
+              type: 'string',
+              description: 'Message text. Automatically split into <=5000-char messages.',
+            },
+            reply_token: {
+              type: 'string',
+              description:
+                'Optional single-use reply token from the <channel> tag. When valid, the ' +
+                'reply is sent free via the reply API; falls back to push automatically.',
+            },
+          },
+          required: ['chat_id', 'text'],
+        },
+      },
+    ];
+  }
+
+  async handleTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
+    if (name === 'line_reply') return this.handleReply(args);
+    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  }
+
+  private async handleReply(args: Record<string, unknown>): Promise<McpToolResult> {
+    const chatId = typeof args.chat_id === 'string' ? args.chat_id : '';
+    const text = typeof args.text === 'string' ? args.text : '';
+    const replyToken = typeof args.reply_token === 'string' ? args.reply_token : '';
+    const token = process.env.LINE_CHANNEL_ACCESS_TOKEN ?? '';
+
+    if (!chatId) {
+      return { content: [{ type: 'text', text: 'line_reply: missing chat_id' }], isError: true };
+    }
+    if (!text) {
+      return { content: [{ type: 'text', text: 'line_reply: text cannot be empty' }], isError: true };
+    }
+
+    // Refresh mode: the gateway (LineReplyManager) is the sole LINE sender — it
+    // observes this tool call in the session output stream and delivers the
+    // reply (free reply, or cache + postback button when slow). Sending here too
+    // would double-send and contend for the single-use reply token, so skip it.
+    if (process.env.LINE_REPLY_REFRESH === '1') {
+      return { content: [{ type: 'text', text: 'Reply handed to gateway for delivery.' }] };
+    }
+    if (!token) {
+      return {
+        content: [{ type: 'text', text: 'line_reply: missing LINE_CHANNEL_ACCESS_TOKEN' }],
+        isError: true,
+      };
+    }
+
+    const client = new messagingApi.MessagingApiClient({
+      channelAccessToken: token,
+    });
+
+    const toMessages = (group: string[]) =>
+      group.map((t) => ({ type: 'text' as const, text: t }));
+    const push = (group: string[]) => client.pushMessage({ to: chatId, messages: toMessages(group) });
+
+    const chunks = chunkText(text, LINE_TEXT_LIMIT);
+    const plan = planLineSend(chunks, replyToken.length > 0);
+    let via = 'push';
+    try {
+      // Reply-token-first: the first batch goes via the FREE reply API when a token
+      // is present, falling back to push if the token is expired/used. Remaining
+      // batches always push (a reply token is single-use).
+      if (plan.replyBatch) {
+        try {
+          await client.replyMessage({ replyToken, messages: toMessages(plan.replyBatch) });
+          via = plan.pushBatches.length > 0 ? 'reply + push' : 'reply';
+        } catch {
+          await push(plan.replyBatch); // token expired/used → push fallback
+          via = 'push (reply fallback)';
+        }
+      }
+      for (const group of plan.pushBatches) await push(group);
+      return {
+        content: [{ type: 'text', text: `Sent ${chunks.length} message(s) to LINE (${via}).` }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: `line_reply failed: ${(err as Error).message}` }],
+        isError: true,
+      };
+    }
+  }
+}

package/mcp/tools/line/pure.ts

@@ -0,0 +1,62 @@
+/**
+ * Pure, dependency-free helpers for the LINE channel — unit-tested in isolation
+ * (mirrors mcp/tools/telegram/pure.ts and mcp/tools/discord/outbound.ts chunkText).
+ */
+
+/** LINE hard limit: max characters in a single text message object. */
+export const LINE_TEXT_LIMIT = 5000;
+/** LINE hard limit: max message objects per push/reply request. */
+export const LINE_MAX_MESSAGES_PER_REQUEST = 5;
+
+/**
+ * Split text into chunks each <= limit chars. Prefers to break on a newline
+ * within the limit; falls back to a hard cut. Always returns at least one chunk
+ * (an empty string in → [''], so callers always have something to send).
+ */
+export function chunkText(text: string, limit = LINE_TEXT_LIMIT): string[] {
+  if (limit <= 0) return [text];
+  if (text.length === 0) return [''];
+  const out: string[] = [];
+  let rest = text;
+  while (rest.length > limit) {
+    let cut = rest.lastIndexOf('\n', limit);
+    if (cut < 0) cut = limit; // not found — hard cut
+    else if (cut === 0) { rest = rest.slice(1); continue; } // leading newline — skip, retry
+    out.push(rest.slice(0, cut));
+    rest = rest.slice(cut).replace(/^\n/, '');
+  }
+  if (rest.length > 0) out.push(rest);
+  return out.length > 0 ? out : [''];
+}
+
+/** Group items into batches of <= size (default = LINE per-request message cap). */
+export function batch<T>(items: T[], size = LINE_MAX_MESSAGES_PER_REQUEST): T[][] {
+  const out: T[][] = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+
+export interface LineSendPlan {
+  /** First batch (<=5 objects) to send via the FREE reply API, or null when no usable reply token. */
+  replyBatch: string[] | null;
+  /** Remaining batches to send via the metered push API. */
+  pushBatches: string[][];
+}
+
+/**
+ * Decide how to deliver chunked text given whether a usable reply token exists.
+ *
+ * Reply-token-first to save push quota: LINE counts push/broadcast against the OA
+ * monthly message quota but **reply-token messages are free**. The single-use token
+ * can carry one reply call of up to LINE_MAX_MESSAGES_PER_REQUEST objects, so it
+ * takes the FIRST batch; anything beyond one batch must push. With no token,
+ * everything pushes. The runtime falls back to push if the reply call fails (token
+ * expired/invalid/already used) — that fallback lives in module.ts, not here.
+ */
+export function planLineSend(chunks: string[], hasReplyToken: boolean): LineSendPlan {
+  const batches = batch(chunks);
+  if (!hasReplyToken || batches.length === 0) {
+    return { replyBatch: null, pushBatches: batches };
+  }
+  return { replyBatch: batches[0], pushBatches: batches.slice(1) };
+}

package/mcp/tools/telegram/receiver-server.ts

@@ -710,11 +710,14 @@ const BOT_COMMANDS = [
 
 // Available AI models for /models command
 const AVAILABLE_MODELS = [
-  { id: 'claude-opus-4-8',          label: 'Opus 4.8',   alias: 'opus' },
-  { id: 'claude-opus-4-7',          label: 'Opus 4.7',   alias: 'opus47' },
-  { id: 'claude-opus-4-6',          label: 'Opus 4.6',   alias: 'opus46' },
-  { id: 'claude-sonnet-4-6',        label: 'Sonnet 4.6', alias: 'sonnet' },
-  { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5', alias: 'haiku' },
+  { id: 'claude-fable-5',            label: 'Fable 5',          alias: 'fable' },
+  { id: 'claude-opus-4-8[1m]',       label: 'Opus 4.8 (1M)',    alias: 'opus[1m]' },
+  { id: 'claude-sonnet-5[1m]',       label: 'Sonnet 5 (1M)',    alias: 'sonnet[1m]' },
+  { id: 'claude-opus-4-8',           label: 'Opus 4.8',         alias: 'opus' },
+  { id: 'claude-opus-4-6',           label: 'Opus 4.6',         alias: 'opus46' },
+  { id: 'claude-sonnet-5',           label: 'Sonnet 5',         alias: 'sonnet' },
+  { id: 'claude-sonnet-4-6',         label: 'Sonnet 4.6',       alias: 'sonnet46' },
+  { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5',        alias: 'haiku' },
 ]
 
 // Base URL for command API calls to the AgentRunner callback server.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "1.3.16",
+  "version": "1.3.18",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",
@@ -39,6 +39,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@line/bot-sdk": "^11.0.2",
     "@xterm/headless": "^6.0.0",
     "chokidar": "^3.5.0",
     "cron-parser": "^5.5.0",