@hybridaione/hybridclaw 0.2.7 → 0.2.10

package/CHANGELOG.md

@@ -2,7 +2,69 @@
 
 ## [Unreleased]
 
-No unreleased changes.
+### Added
+
+### Changed
+
+### Fixed
+
+## [0.2.10](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.10)
+
+### Added
+
+- **Model retry policy helpers + tests**: Added shared model stream-fallback/retry predicates with dedicated unit coverage for retryable/non-retryable HybridAI error classes.
+- **Message tool schema regression test**: Added explicit schema test coverage to enforce valid `components` parameter structure for the `message` tool definition.
+
+### Changed
+
+- **Stream failure fallback behavior**: Container model-call flow now applies stream-to-non-stream fallback policy through centralized retry helpers for consistent error classification.
+
+### Fixed
+
+- **HybridAI function schema rejection**: Fixed `message` tool `components` schema by defining `items` for the array variant, resolving `invalid_function_parameters` 400 failures.
+- **HybridAI 500 handling robustness**: Streamed 5xx API failures now trigger the non-stream fallback path before hard-failing the turn.
+
+## [0.2.9](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.9)
+
+### Added
+
+- **Release bundle guard scripts**: Added root and container `release:check` scripts that validate `npm pack --dry-run` contents and fail on forbidden files (tests, source, CI/config artifacts).
+- **Dry-run publish helpers**: Added `publish:dry` scripts for root and container package smoke checks before publish.
+
+### Changed
+
+- **NPM package allowlists**: Added explicit `files` allowlists for root and container packages so publish output is limited to runtime assets and docs/templates/skills that HybridClaw loads at runtime.
+- **Prepack gating**: Root and container packages now run clean build + release bundle validation during `prepack`.
+- **CI packaging checks**: CI now runs root/container release bundle checks to catch publish-regression changes on PRs and pushes.
+- **Silent reply token handling**: Centralized `__MESSAGE_SEND_HANDLED__` parsing/cleanup, added streaming prefix buffering for Discord/API output paths, and aligned prompt token constants with shared silent-reply utilities.
+- **CLI build output mode**: Root `build` script now enforces executable mode on `dist/cli.js` after TypeScript compilation.
+
+### Fixed
+
+- **Silent token leakage in streams/history**: Streaming token fragments are now suppressed until divergence/confirmation, trailing silent tokens are stripped from mixed replies, and silent assistant placeholders are filtered from conversation history before model calls.
+
+## [0.2.8](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.8)
+
+### Added
+
+- **Discord send policy controls**: Added runtime config for `discord.sendPolicy` (`open|allowlist|disabled`) with global/channel/guild/user/role allowlist checks for outbound sends.
+- **Channel-aware prompt adapters**: Added channel-specific message-tool hint adapters (including Discord action/component guidance) injected into system prompts.
+- **Expanded Discord message actions**: Added `react`, `quote-reply`, `edit`, `delete`, `pin`, `unpin`, `thread-create`, and `thread-reply` actions to the `message` tool path.
+- **Message-tool regression coverage**: Added focused unit coverage for action aliases, target normalization, member/channel lookup behavior, send-policy checks, and channel hint injection.
+
+### Changed
+
+- **Message-tool intent guidance**: System prompt guidance now includes explicit send/post/DM/notify triggers, send parameter guidance (`to` + message), and reply suppression token handling for tool-only sends.
+- **Action alias + target normalization**: Message action normalization now supports natural aliases (`dm`, `post`, `reply`, `respond`, `history`, `fetch`, `lookup`, `whois`) and normalizes Discord prefixes/mentions.
+- **Tool description enrichment**: `message` tool descriptions now emphasize natural-language intent phrases and enumerate current/other configured Discord channels with supported actions.
+- **Single-call DM targeting**: `send` now resolves user targets inline (IDs, mentions, usernames/display names with guild context), including fallback via `user`/`username` when no explicit channel target is passed.
+- **Discord action API flexibility**: `/api/discord/action` now accepts normalized aliases and extended send payload fields (`components`, `contextChannelId`, threading/message mutation fields).
+
+### Fixed
+
+- **Structured target-resolution errors**: Member/user lookup failures now return structured JSON errors with disambiguation candidates and actionable hints.
+- **Ambiguous target handling**: Added `resolveAmbiguous` support (`error|best`) to allow safe candidate return or best-match auto-resolution for member/user lookups.
+- **Duplicate send-reply leakage**: Gateway chat responses now strip the message-send silent reply token and normalize final user-visible success text.
 
 ## [0.2.7](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.7)
 

package/README.md

@@ -11,17 +11,13 @@ npm install -g @hybridaione/hybridclaw
 hybridclaw onboarding
 ```
 
-Latest release: [v0.2.7](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.2.7)
+Latest release: [v0.2.10](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.2.10)
 
-## Release highlights (v0.2.7)
+## Release highlights (v0.2.10)
 
-- Private approval flow via `/approve [view|yes|session|agent|no] [approval_id]` with ephemeral responses, and DM-ready global slash registration for `/status` + `/approve`.
-- Discord command access controls now support `discord.commandMode` (`public|restricted`) plus `discord.commandAllowedUserIds` (with legacy `commandUserId` compatibility).
-- Free-mode Discord replies now apply stronger relevance gating (for example short acknowledgements/URL-only chatter are skipped, and messages mentioning other users are de-prioritized).
-- `browser_upload` now supports selector targets and automatic fallback from wrapper refs to detected `input[type="file"]` elements.
-- HybridAI status/usage context metrics now use a curated static context-window catalog (Claude/Gemini/GPT-5) with family-aware fallback matching, and runtime supports `hybridai.maxTokens` for default completion budgeting.
-- Model-usage telemetry now captures cache read/write token counters where providers expose them, and prompt-dump diagnostics include media plus allowed/blocked tool context.
-- CLI container readiness checks now resolve the package install root to avoid non-root invocation failures.
+- Fixed HybridAI `400 invalid_function_parameters` failures by correcting `message.components` schema (`array` now defines `items`).
+- Improved HybridAI reliability by centralizing stream-fallback/retry error classification in the container runtime.
+- Added regression tests for message-tool schema validity and HybridAI retry/fallback behavior.
 
 ## HybridAI Advantage
 

package/config.example.json

@@ -19,6 +19,8 @@
     "commandAllowedUserIds": [],
     "commandUserId": "",
     "groupPolicy": "open",
+    "sendPolicy": "open",
+    "sendAllowedChannelIds": [],
     "freeResponseChannels": [],
     "textChunkLimit": 2000,
     "maxLinesPerMessage": 17,

package/container/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.2.7",
+  "version": "0.2.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hybridclaw-agent",
-      "version": "0.2.7",
+      "version": "0.2.10",
       "dependencies": {
         "@mozilla/readability": "^0.6.0",
         "agent-browser": "^0.15.1",

package/container/package.json

@@ -1,10 +1,19 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.2.7",
+  "version": "0.2.10",
   "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist/",
+    "Dockerfile"
+  ],
   "scripts": {
+    "clean": "node -e \"const fs=require('node:fs');fs.rmSync('dist',{recursive:true,force:true});\"",
     "build": "tsc",
-    "lint": "tsc --noEmit --noUnusedLocals --noUnusedParameters"
+    "lint": "tsc --noEmit --noUnusedLocals --noUnusedParameters",
+    "prepack": "npm run clean && npm run build && npm run release:check",
+    "release:check": "node ./scripts/release-check.mjs",
+    "publish:dry": "npm publish --dry-run"
   },
   "dependencies": {
     "@mozilla/readability": "^0.6.0",

package/container/src/index.ts

@@ -8,12 +8,12 @@ import {
   runAfterToolHooks,
   runBeforeToolHooks,
 } from './extensions.js';
-import {
-  callHybridAI,
-  callHybridAIStream,
-  HybridAIRequestError,
-} from './hybridai-client.js';
+import { callHybridAI, callHybridAIStream } from './hybridai-client.js';
 import { waitForInput, writeOutput } from './ipc.js';
+import {
+  isRetryableModelError,
+  shouldFallbackFromStreamError,
+} from './model-retry.js';
 import {
   accumulateApiUsage,
   createTokenUsageStats,
@@ -23,6 +23,7 @@ import {
 } from './token-usage.js';
 import {
   executeTool,
+  getMessageToolDescription,
   getPendingSideEffects,
   resetSideEffects,
   setGatewayContext,
@@ -304,16 +305,6 @@ function emitStreamDelta(delta: string): void {
   console.error(`[stream] ${payload}`);
 }
 
-function isRetryableError(err: unknown): boolean {
-  if (err instanceof HybridAIRequestError) {
-    return err.status === 429 || (err.status >= 500 && err.status <= 504);
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  return /fetch failed|network|socket|timeout|timed out|ECONNRESET|ECONNREFUSED|EAI_AGAIN/i.test(
-    message,
-  );
-}
-
 function inferToolError(result: string, blockedReason: string | null): boolean {
   if (blockedReason) return true;
   return /\b(error|failed|denied|forbidden|timed out|timeout|exception|invalid)\b/i.test(
@@ -537,11 +528,7 @@ async function callHybridAIWithRetry(params: {
             maxTokens,
           );
         } catch (streamErr) {
-          const fallbackEligible =
-            streamErr instanceof HybridAIRequestError &&
-            streamErr.status >= 400 &&
-            streamErr.status < 500 &&
-            streamErr.status !== 429;
+          const fallbackEligible = shouldFallbackFromStreamError(streamErr);
           if (!fallbackEligible) throw streamErr;
           response = await callHybridAI(
             baseUrl,
@@ -574,7 +561,9 @@ async function callHybridAIWithRetry(params: {
       return response;
     } catch (err) {
       const retryable =
-        RETRY_ENABLED && isRetryableError(err) && attempt < RETRY_MAX_ATTEMPTS;
+        RETRY_ENABLED &&
+        isRetryableModelError(err) &&
+        attempt < RETRY_MAX_ATTEMPTS;
       await emitRuntimeEvent({
         event: retryable ? 'model_retry' : 'model_error',
         attempt,
@@ -940,6 +929,16 @@ function resolveTools(input: ContainerInput): ToolDefinition[] {
     );
     tools = tools.filter((tool) => !blocked.has(tool.function.name));
   }
+  tools = tools.map((tool) => {
+    if (tool.function.name !== 'message') return tool;
+    return {
+      ...tool,
+      function: {
+        ...tool.function,
+        description: getMessageToolDescription(input.channelId),
+      },
+    };
+  });
   // Sort alphabetically for deterministic tool ordering (request/cache stability)
   tools.sort((a, b) => a.function.name.localeCompare(b.function.name));
   return tools;
@@ -979,6 +978,7 @@ async function main(): Promise<void> {
     firstInput.gatewayBaseUrl,
     firstInput.gatewayApiToken,
     firstInput.channelId,
+    firstInput.configuredDiscordChannels,
   );
   setModelContext(
     firstInput.baseUrl,
@@ -1074,6 +1074,7 @@ async function main(): Promise<void> {
       input.gatewayBaseUrl,
       input.gatewayApiToken,
       input.channelId,
+      input.configuredDiscordChannels,
     );
     setModelContext(input.baseUrl, apiKey, input.model, input.chatbotId);
     setMediaContext(input.media);

package/container/src/model-retry.ts

@@ -0,0 +1,19 @@
+import { HybridAIRequestError } from './hybridai-client.js';
+
+const TRANSIENT_NETWORK_ERROR_RE =
+  /fetch failed|network|socket|timeout|timed out|ECONNRESET|ECONNREFUSED|EAI_AGAIN/i;
+
+export function shouldFallbackFromStreamError(error: unknown): boolean {
+  if (!(error instanceof HybridAIRequestError)) return false;
+  // Keep 429 on retry/backoff path; fallback does not help throttling.
+  if (error.status === 429) return false;
+  return error.status >= 400 && error.status <= 599;
+}
+
+export function isRetryableModelError(error: unknown): boolean {
+  if (error instanceof HybridAIRequestError) {
+    return error.status === 429 || (error.status >= 500 && error.status <= 504);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return TRANSIENT_NETWORK_ERROR_RE.test(message);
+}