@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/tests/discord.basic.test.ts

@@ -1,8 +1,19 @@
 import { expect, test } from 'vitest';
 
 import { buildResponseText } from '../src/channels/discord/delivery.js';
-import { isTrigger, parseCommand } from '../src/channels/discord/inbound.js';
-import { rewriteUserMentions, type MentionLookup } from '../src/channels/discord/mentions.js';
+import {
+  hasLooseBotMention,
+  isAddressedToChannel,
+  isAuthorizedCommandUser,
+  isTrigger,
+  parseCommand,
+  shouldReplyInFreeMode,
+  shouldSkipFreeReplyBecauseOtherUsersMentioned,
+} from '../src/channels/discord/inbound.js';
+import {
+  type MentionLookup,
+  rewriteUserMentions,
+} from '../src/channels/discord/mentions.js';
 
 function createLookup(entries: Record<string, string[]>): MentionLookup {
   const byAlias = new Map<string, Set<string>>();
@@ -19,7 +30,9 @@ test('rewriteUserMentions rewrites a uniquely-resolved @alias', () => {
 });
 
 test('rewriteUserMentions does not rewrite ambiguous aliases', () => {
-  const lookup = createLookup({ bob: ['111111111111111111', '222222222222222222'] });
+  const lookup = createLookup({
+    bob: ['111111111111111111', '222222222222222222'],
+  });
   const output = rewriteUserMentions('hi @bob', lookup);
   expect(output).toBe('hi @bob');
 });
@@ -71,9 +84,23 @@ test('isTrigger still allows prefixed commands when channel mode is off', () =>
   expect(shouldTrigger).toBe(true);
 });
 
+test('isTrigger allows slash-text commands when channel mode is off', () => {
+  const shouldTrigger = isTrigger({
+    content: '/status',
+    isDm: false,
+    commandsOnly: false,
+    respondToAllMessages: false,
+    guildMessageMode: 'off',
+    prefix: '!claw',
+    botMentionRegex: null,
+    hasBotMention: false,
+  });
+  expect(shouldTrigger).toBe(true);
+});
+
 test('isTrigger allows free-response mode in guild channels', () => {
   const shouldTrigger = isTrigger({
-    content: 'hello',
+    content: 'Can you review this patch?',
     isDm: false,
     commandsOnly: false,
     respondToAllMessages: false,
@@ -85,6 +112,20 @@ test('isTrigger allows free-response mode in guild channels', () => {
   expect(shouldTrigger).toBe(true);
 });
 
+test('isTrigger keeps mention mode even when respondToAllMessages is enabled', () => {
+  const shouldTrigger = isTrigger({
+    content: 'hello',
+    isDm: false,
+    commandsOnly: false,
+    respondToAllMessages: true,
+    guildMessageMode: 'mention',
+    prefix: '!claw',
+    botMentionRegex: null,
+    hasBotMention: false,
+  });
+  expect(shouldTrigger).toBe(false);
+});
+
 test('parseCommand recognizes channel command namespace', () => {
   const parsed = parseCommand('!claw channel mode free', null, '!claw');
   expect(parsed).toEqual({
@@ -93,3 +134,171 @@ test('parseCommand recognizes channel command namespace', () => {
     args: ['mode', 'free'],
   });
 });
+
+test('parseCommand recognizes usage command namespace', () => {
+  const parsed = parseCommand('!claw usage monthly', null, '!claw');
+  expect(parsed).toEqual({
+    isCommand: true,
+    command: 'usage',
+    args: ['monthly'],
+  });
+});
+
+test('parseCommand recognizes status command namespace', () => {
+  const parsed = parseCommand('!claw status', null, '!claw');
+  expect(parsed).toEqual({
+    isCommand: true,
+    command: 'status',
+    args: [],
+  });
+});
+
+test('parseCommand recognizes slash-text status command namespace', () => {
+  const parsed = parseCommand('/status', null, '!claw');
+  expect(parsed).toEqual({
+    isCommand: true,
+    command: 'status',
+    args: [],
+  });
+});
+
+test('isTrigger commands-only allows slash-text commands', () => {
+  const shouldTrigger = isTrigger({
+    content: '/status',
+    isDm: false,
+    commandsOnly: true,
+    respondToAllMessages: false,
+    guildMessageMode: 'off',
+    prefix: '!claw',
+    botMentionRegex: null,
+    hasBotMention: false,
+  });
+  expect(shouldTrigger).toBe(true);
+});
+
+test('free-mode skips non-bot user mentions', () => {
+  const shouldSkip = shouldSkipFreeReplyBecauseOtherUsersMentioned({
+    guildMessageMode: 'free',
+    hasBotMention: false,
+    hasPrefixInvocation: false,
+    botUserId: '111',
+    mentionedUserIds: ['222'],
+  });
+  expect(shouldSkip).toBe(true);
+});
+
+test('free-mode does not skip when bot is mentioned', () => {
+  const shouldSkip = shouldSkipFreeReplyBecauseOtherUsersMentioned({
+    guildMessageMode: 'free',
+    hasBotMention: true,
+    hasPrefixInvocation: false,
+    botUserId: '111',
+    mentionedUserIds: ['111', '222'],
+  });
+  expect(shouldSkip).toBe(false);
+});
+
+test('free-mode replies to actionable questions', () => {
+  const shouldReply = shouldReplyInFreeMode({
+    guildMessageMode: 'free',
+    content: 'Can you review this patch?',
+    hasBotMention: false,
+    hasPrefixInvocation: false,
+    isReplyToBot: false,
+    hasAttachments: false,
+  });
+  expect(shouldReply).toBe(true);
+});
+
+test('free-mode replies to plain-text bot-name mentions', () => {
+  const hasLooseMention = hasLooseBotMention('hybridclaw, thoughts on this?', [
+    'HybridClaw',
+    'claw',
+  ]);
+  expect(hasLooseMention).toBe(true);
+
+  const shouldReply = shouldReplyInFreeMode({
+    guildMessageMode: 'free',
+    content: 'hybridclaw please take a look',
+    hasBotMention: false,
+    hasLooseBotMention: true,
+    hasPrefixInvocation: false,
+    isReplyToBot: false,
+    hasAttachments: false,
+  });
+  expect(shouldReply).toBe(true);
+});
+
+test('free-mode replies to channel-addressed messages', () => {
+  expect(isAddressedToChannel('Hey everyone, quick status update')).toBe(true);
+
+  const shouldReply = shouldReplyInFreeMode({
+    guildMessageMode: 'free',
+    content: 'Hey everyone, quick status update',
+    hasBotMention: false,
+    hasPrefixInvocation: false,
+    isAddressedToChannel: true,
+    isReplyToBot: false,
+    hasAttachments: false,
+  });
+  expect(shouldReply).toBe(true);
+});
+
+test('free-mode ignores low-signal acknowledgements', () => {
+  const shouldReply = shouldReplyInFreeMode({
+    guildMessageMode: 'free',
+    content: 'ok',
+    hasBotMention: false,
+    hasPrefixInvocation: false,
+    isReplyToBot: false,
+    hasAttachments: false,
+  });
+  expect(shouldReply).toBe(false);
+});
+
+test('free-mode allows reply-to-bot followups', () => {
+  const shouldReply = shouldReplyInFreeMode({
+    guildMessageMode: 'free',
+    content: 'sure',
+    hasBotMention: false,
+    hasPrefixInvocation: false,
+    isReplyToBot: true,
+    hasAttachments: false,
+  });
+  expect(shouldReply).toBe(true);
+});
+
+test('command access allows all users in public mode', () => {
+  const authorized = isAuthorizedCommandUser({
+    mode: 'public',
+    userId: '222',
+    allowedUserIds: ['111'],
+    legacyCommandUserId: '333',
+  });
+  expect(authorized).toBe(true);
+});
+
+test('command access enforces allowlist in restricted mode', () => {
+  const authorized = isAuthorizedCommandUser({
+    mode: 'restricted',
+    userId: '222',
+    allowedUserIds: ['111', '222'],
+  });
+  expect(authorized).toBe(true);
+  const denied = isAuthorizedCommandUser({
+    mode: 'restricted',
+    userId: '333',
+    allowedUserIds: ['111', '222'],
+  });
+  expect(denied).toBe(false);
+});
+
+test('command access uses legacy commandUserId in restricted mode', () => {
+  const authorized = isAuthorizedCommandUser({
+    mode: 'restricted',
+    userId: '777',
+    allowedUserIds: [],
+    legacyCommandUserId: '777',
+  });
+  expect(authorized).toBe(true);
+});

package/tests/discord.human-presence.test.ts

@@ -0,0 +1,85 @@
+import { expect, test } from 'vitest';
+
+import {
+  resolveInboundDebounceMs,
+  shouldDebounceInbound,
+} from '../src/channels/discord/debounce.js';
+import {
+  getHumanDelayMs,
+  resolveHumanDelayConfig,
+} from '../src/channels/discord/human-delay.js';
+import { shouldSuppressAutoReply } from '../src/channels/discord/inbound.js';
+import { SlidingWindowRateLimiter } from '../src/channels/discord/rate-limiter.js';
+
+test('resolveHumanDelayConfig normalizes custom bounds', () => {
+  const resolved = resolveHumanDelayConfig({
+    mode: 'custom',
+    minMs: 2_500,
+    maxMs: 800,
+  });
+  expect(resolved).toEqual({
+    mode: 'custom',
+    minMs: 2_500,
+    maxMs: 2_500,
+  });
+});
+
+test('getHumanDelayMs returns 0 for off mode', () => {
+  expect(getHumanDelayMs({ mode: 'off' })).toBe(0);
+});
+
+test('getHumanDelayMs respects configured range', () => {
+  for (let i = 0; i < 20; i += 1) {
+    const value = getHumanDelayMs({ mode: 'custom', minMs: 10, maxMs: 20 });
+    expect(value).toBeGreaterThanOrEqual(10);
+    expect(value).toBeLessThanOrEqual(20);
+  }
+});
+
+test('shouldDebounceInbound skips media and control commands', () => {
+  expect(
+    shouldDebounceInbound({
+      content: 'hello',
+      hasAttachments: false,
+      isPrefixedCommand: false,
+    }),
+  ).toBe(true);
+  expect(
+    shouldDebounceInbound({
+      content: 'hello',
+      hasAttachments: true,
+      isPrefixedCommand: false,
+    }),
+  ).toBe(false);
+  expect(
+    shouldDebounceInbound({
+      content: '/stop now',
+      hasAttachments: false,
+      isPrefixedCommand: false,
+    }),
+  ).toBe(false);
+});
+
+test('resolveInboundDebounceMs uses channel override when provided', () => {
+  expect(resolveInboundDebounceMs(2500, undefined)).toBe(2500);
+  expect(resolveInboundDebounceMs(2500, 5000)).toBe(5000);
+});
+
+test('shouldSuppressAutoReply matches patterns and greeting-only text', () => {
+  expect(shouldSuppressAutoReply('brb', ['/stop', 'brb'])).toBe(true);
+  expect(shouldSuppressAutoReply('hello', ['/stop'])).toBe(true);
+  expect(shouldSuppressAutoReply('please help me debug this', ['/stop'])).toBe(
+    false,
+  );
+});
+
+test('SlidingWindowRateLimiter enforces per-minute limits', () => {
+  const limiter = new SlidingWindowRateLimiter(60_000);
+  const key = 'channel:user';
+  expect(limiter.check(key, 2, 1_000).allowed).toBe(true);
+  expect(limiter.check(key, 2, 2_000).allowed).toBe(true);
+  const blocked = limiter.check(key, 2, 3_000);
+  expect(blocked.allowed).toBe(false);
+  expect(blocked.retryAfterMs).toBeGreaterThan(0);
+  expect(limiter.check(key, 2, 62_000).allowed).toBe(true);
+});

package/tests/gateway-service.media-routing.test.ts

@@ -15,13 +15,19 @@ const SAMPLE_MEDIA: MediaContextItem[] = [
 ];
 
 test('Discord image question blocks browser_vision and prioritizes vision_analyze', () => {
-  const policy = resolveMediaToolPolicy('Was steht auf dem Bild?', SAMPLE_MEDIA);
+  const policy = resolveMediaToolPolicy(
+    'Was steht auf dem Bild?',
+    SAMPLE_MEDIA,
+  );
   expect(policy.prioritizeVisionTool).toBe(true);
   expect(policy.blockedTools).toEqual(['browser_vision']);
 });
 
 test('Explicit browser-tab question does not block browser_vision', () => {
-  const policy = resolveMediaToolPolicy('What is on the current browser tab?', SAMPLE_MEDIA);
+  const policy = resolveMediaToolPolicy(
+    'What is on the current browser tab?',
+    SAMPLE_MEDIA,
+  );
   expect(policy.prioritizeVisionTool).toBe(false);
   expect(policy.blockedTools).toBeUndefined();
 });

package/tests/hybridai-client.test.ts

@@ -0,0 +1,112 @@
+import { afterEach, expect, test, vi } from 'vitest';
+
+import {
+  callHybridAI,
+  callHybridAIStream,
+} from '../container/src/hybridai-client.js';
+
+const okResponse = {
+  id: 'resp_1',
+  model: 'gpt-5-nano',
+  choices: [
+    {
+      message: {
+        role: 'assistant',
+        content: 'ok',
+      },
+      finish_reason: 'stop',
+    },
+  ],
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+test('callHybridAI forwards max_tokens when provided', async () => {
+  const fetchMock = vi.fn(async (_url: string, init?: RequestInit) => {
+    const body = JSON.parse(String(init?.body || '{}')) as Record<
+      string,
+      unknown
+    >;
+    expect(body.max_tokens).toBe(4096);
+    return new Response(JSON.stringify(okResponse), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  });
+  vi.stubGlobal('fetch', fetchMock);
+
+  const result = await callHybridAI(
+    'https://hybridai.one',
+    'test-key',
+    'gpt-5-nano',
+    'bot_1',
+    true,
+    [{ role: 'user', content: 'hello' }],
+    [],
+    4096,
+  );
+
+  expect(result.choices[0]?.message.content).toBe('ok');
+  expect(fetchMock).toHaveBeenCalledTimes(1);
+});
+
+test('callHybridAI omits max_tokens when not provided', async () => {
+  const fetchMock = vi.fn(async (_url: string, init?: RequestInit) => {
+    const body = JSON.parse(String(init?.body || '{}')) as Record<
+      string,
+      unknown
+    >;
+    expect(body.max_tokens).toBeUndefined();
+    return new Response(JSON.stringify(okResponse), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  });
+  vi.stubGlobal('fetch', fetchMock);
+
+  await callHybridAI(
+    'https://hybridai.one',
+    'test-key',
+    'gpt-5-nano',
+    'bot_1',
+    true,
+    [{ role: 'user', content: 'hello' }],
+    [],
+  );
+
+  expect(fetchMock).toHaveBeenCalledTimes(1);
+});
+
+test('callHybridAIStream forwards stream and max_tokens', async () => {
+  const fetchMock = vi.fn(async (_url: string, init?: RequestInit) => {
+    const body = JSON.parse(String(init?.body || '{}')) as Record<
+      string,
+      unknown
+    >;
+    expect(body.stream).toBe(true);
+    expect(body.stream_options).toEqual({ include_usage: true });
+    expect(body.max_tokens).toBe(1024);
+    return new Response(JSON.stringify(okResponse), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  });
+  vi.stubGlobal('fetch', fetchMock);
+
+  const result = await callHybridAIStream(
+    'https://hybridai.one',
+    'test-key',
+    'gpt-5-nano',
+    'bot_1',
+    true,
+    [{ role: 'user', content: 'hello' }],
+    [],
+    () => {},
+    1024,
+  );
+
+  expect(result.choices[0]?.message.content).toBe('ok');
+  expect(fetchMock).toHaveBeenCalledTimes(1);
+});

package/tests/hybridai-models.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from 'vitest';
+
+import {
+  resolveModelContextWindowFallback,
+  resolveModelContextWindowFromList,
+} from '../src/hybridai-models.js';
+
+test('resolveModelContextWindowFromList matches exact model id', () => {
+  const models = [
+    { id: 'gpt-5-mini', contextWindowTokens: 272_000 },
+    { id: 'gpt-5-nano', contextWindowTokens: 128_000 },
+  ];
+
+  expect(resolveModelContextWindowFromList(models, 'gpt-5-mini')).toBe(272_000);
+});
+
+test('resolveModelContextWindowFromList matches provider-prefixed tail', () => {
+  const models = [{ id: 'openai/gpt-5', contextWindowTokens: 400_000 }];
+
+  expect(resolveModelContextWindowFromList(models, 'gpt-5')).toBe(400_000);
+});
+
+test('resolveModelContextWindowFromList returns null when unresolved', () => {
+  const models = [{ id: 'openai/gpt-5', contextWindowTokens: null }];
+
+  expect(resolveModelContextWindowFromList(models, 'gpt-5')).toBeNull();
+});
+
+test('resolveModelContextWindowFallback resolves known defaults', () => {
+  expect(resolveModelContextWindowFallback('gpt-5-mini')).toBe(400_000);
+  expect(resolveModelContextWindowFallback('openai/gpt-5-nano')).toBe(400_000);
+  expect(resolveModelContextWindowFallback('gpt-5.1')).toBe(400_000);
+  expect(resolveModelContextWindowFallback('gpt-5.3')).toBe(400_000);
+  expect(resolveModelContextWindowFallback('anthropic/claude-opus-4-6')).toBe(
+    200_000,
+  );
+  expect(resolveModelContextWindowFallback('claude-sonnet-4.6')).toBe(200_000);
+  expect(resolveModelContextWindowFallback('google/gemini-3.1-pro')).toBe(
+    1_048_576,
+  );
+  expect(resolveModelContextWindowFallback('openai:gpt-5')).toBe(400_000);
+});
+
+test('resolveModelContextWindowFallback returns null for unknown models', () => {
+  expect(resolveModelContextWindowFallback('unknown-model')).toBeNull();
+});