@hybridaione/hybridclaw 0.1.22 → 0.2.1

package/CHANGELOG.md

@@ -8,6 +8,85 @@
 
 ### Fixed
 
+## [0.2.1](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.1)
+
+### Added
+
+- **Discord `message` tool actions**: Added OpenClaw-style `message` tool support in the container with `read`, `member-info`, and `channel-info` actions, routed via the gateway API.
+- **Gateway Discord action endpoint**: Added `POST /api/discord/action` to execute Discord context actions for tools and automated runs.
+
+### Changed
+
+- **Discord presence handling**: Switched from prompt-injected presence snapshots to cache-backed presence data returned by `member-info` (`status` + `activities`) when available.
+- **Discord context guidance**: Updated safety prompt policy to explicitly route recap/member lookup questions through `message` tool actions instead of guessing.
+- **Tool allowlists**: Enabled `message` in heartbeat and base subagent allowed tool sets for delegated and automated workflows.
+- **Container gateway auth context**: Container input now carries gateway base URL/token and maps loopback hosts to `host.docker.internal` for in-container API reachability.
+- **Gateway token fallback**: Runtime now generates an internal gateway API token when no explicit token is configured, while preserving env/config overrides.
+
+### Fixed
+
+
+## [0.2.0](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.0)
+
+### Added
+
+- **Personality switcher skill**: Added `skills/personality/SKILL.md` with `/personality` command workflow (`list`, `set`, `reset`) and a 25-profile persona set (including expert, style, and role personas like `pirate`, `noir`, `german`, `coach`, `doctor`, `soldier`, and `lawyer`).
+- **Ralph loop runtime mode**: Added configurable autonomous iteration (`proactive.ralph.maxIterations`) in the container tool loop. When enabled, turns continue automatically until the model emits `<choice>STOP</choice>` (or the configured loop budget is reached).
+- **Ralph command controls**: Added gateway/TUI command support for `ralph on|off|set <n>|info`, with immediate current-session container restart to apply loop settings without waiting for idle recycle.
+- **Skill creator authoring toolkit**: Added bundled `skills/skill-creator/` (invocable skill, references, and helper scripts) for initializing, validating, packaging, and generating `agents/openai.yaml` metadata for new skills.
+- **Discord context enrichment pipeline**: Added pending guild-history context, participant alias memory, `@name` mention-to-ID rewrite support, and optional per-channel presence snapshots for better grounded Discord replies.
+
+### Changed
+
+- **Personality persistence contract**: Standardized the managed `SOUL.md` personality block to `Name`, `Definition`, and `Rules`, so active persona behavior is fully file-driven.
+- **Personality style policy**: Updated persona rules so style signals are explicitly visible for the active personality (instead of only a subset).
+- **Personality skill prompt mode**: Set personality switching to command-only behavior (`always: false`, `disable-model-invocation: true`) to avoid per-turn prompt overhead while keeping `/personality` invocations available.
+- **Workspace AGENTS template behavior**: Updated `templates/AGENTS.md` group-chat guidance with explicit "Quality > quantity" speaking rules and emoji-reaction social-signal policy (`React Like a Human`, one reaction per message).
+- **Runtime self-awareness hook**: Prompt assembly now always injects runtime metadata (`version`, UTC date, model/default model, chatbot/channel/guild IDs, node/OS/host/workspace) and keeps it active in `minimal` mode.
+- **Discord runtime controls**: Added and hot-wired `discord.{guildMembersIntent,presenceIntent,respondToAllMessages,commandsOnly,commandUserId}` config behavior for intent selection, trigger policy, and command-user authorization.
+- **Gateway status reporting**: `status` command output now includes the running HybridClaw version line.
+
+### Fixed
+
+## [0.1.24](https://github.com/HybridAIOne/hybridclaw/tree/v0.1.24)
+
+### Added
+
+- **Discord edit-in-place streaming pipeline**: Added end-to-end assistant text delta streaming from container runtime to Discord delivery, including NDJSON `text` events and incremental Discord message edits.
+- **Discord stream/chunk primitives**: Added `src/discord-stream.ts` (stream lifecycle manager with throttled edits and rollover) and `src/chunk.ts` (boundary-aware chunking with code-fence preservation and line limits).
+- **Discord conversational event handling**: Added message debounce batching, in-flight run tracking, message edit/delete interruption handling, and thumbs-down reaction feedback capture for subsequent context.
+
+### Changed
+
+- **Discord reply delivery semantics**: Replaced fixed 2000-char truncation with complete multi-message delivery and chunk-safe send/edit behavior.
+- **Discord responsiveness model**: Message handling now keeps typing indicators alive during long turns, updates presence while processing, and acknowledges queued work with processing reactions.
+- **Discord context assembly**: Conversation turns now prepend reply-chain/thread context and include parsed attachment context (inline text/code where readable, metadata fallback for unsupported types).
+
+### Fixed
+
+- **Long response truncation**: Removed `.slice(0, 2000)` response truncation paths that dropped tail content and broke code blocks.
+- **Perceived Discord stalls**: Fixed single-shot typing behavior by introducing a periodic typing loop for long-running turns.
+- **Mid-turn user correction handling**: Edited/deleted source messages now cancel in-flight processing and clean up partial streamed output to prevent orphaned replies.
+- **Screenshot reply verbosity in Discord**: Image-attachment responses now suppress workspace-path narration and default to concise delivery text (`Here it is.`/`Here they are.`).
+
+## [0.1.23](https://github.com/HybridAIOne/hybridclaw/tree/v0.1.23)
+
+### Added
+
+- **Token usage observability fields**: `model.usage` audit events now include prompt/completion/total token counts (API-reported when available, deterministic estimates as fallback), model-call counts, and char-level prompt/completion sizing.
+- **Context optimization telemetry**: Added `context.optimization` audit events with history compression statistics (per-message truncation count, dropped chars/messages, and applied history budgets).
+
+### Changed
+
+- **Runtime-config migration logging clarity**: Startup schema normalization now logs a dedicated `normalized config schema vN` message when version is unchanged, instead of reporting a misleading `migrated ... from vN to vN`.
+- **History prompt assembly**: Conversation history now applies per-message truncation plus head/tail-aware budget compression to reduce token load while preserving recent context.
+- **Bootstrap file truncation strategy**: Oversized workspace context files now use head/tail truncation (70/20 split) instead of head-only clipping.
+- **Prompt mode tiers**: Prompt hooks now support `full`/`minimal`/`none` modes; pre-compaction memory flush uses `minimal` mode to reduce static prompt overhead.
+
+### Fixed
+
+- **Local runtime-state git noise**: Added `.hybridclaw/` to `.gitignore` so container image fingerprint state files are no longer reported as untracked changes.
+
 ## [0.1.22](https://github.com/HybridAIOne/hybridclaw/tree/v0.1.22)
 
 ### Added

package/README.md

@@ -11,6 +11,16 @@ npm install -g @hybridaione/hybridclaw
 hybridclaw onboarding
 ```
 
+Latest release: [v0.2.1](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.2.1)
+
+## What's new in v0.2.1
+
+- Added OpenClaw-style Discord `message` tool actions (`read`, `member-info`, `channel-info`) to the container runtime
+- Added gateway endpoint `POST /api/discord/action` for Discord context lookups from tools
+- Replaced prompt-time Discord presence snapshots with cache-backed `member-info` presence fields (`status`, `activities`)
+- Routed Discord context lookups through gateway API from container with host remapping and token propagation
+- Enabled `message` tool in heartbeat and base subagent allowlists
+
 ## HybridAI Advantage
 
 - Security-focused foundation
@@ -75,9 +85,13 @@ HybridClaw best-in-class capabilities:
 - explicit trust-model acceptance during onboarding (recorded in `config.json`)
 - typed `config.json` runtime settings with defaults, validation, and hot reload
 - formal prompt hook orchestration (`bootstrap`, `memory`, `safety`)
+- Discord conversational UX: edit-in-place streaming responses, fence-safe chunking beyond Discord's 2000-char limit, typing keepalive, debounce batching, reply-chain-aware context, and concise attachment-first screenshot replies
+- token-efficient context assembly: per-message history truncation, hard history budgets with head/tail preservation, and head/tail truncation for oversized bootstrap files
+- runtime self-awareness in prompts: exact HybridClaw version/date, model, and runtime host metadata injected each turn for reliable "what version/model are you?" answers
 - proactive runtime layer with active-hours gating, push delegation (`single`/`parallel`/`chain`), depth-aware tool policy, and retry controls
 - structured audit trail: append-only hash-chained wire logs (`data/audit/<session>/wire.jsonl`) with tamper-evident immutability, normalized SQLite audit tables, and verification/search CLI commands
 - observability export: incremental `events:batch` forwarding with durable cursor tracking and bot-scoped ingest token lifecycle via `ingest-token:ensure`
+- model token telemetry in audit/observability events (`model.usage`) with API usage + deterministic fallback estimates
 - gateway lifecycle controls: managed + unmanaged restart/stop flows with graceful shutdown fallback paths
 - instruction-integrity approval flow: core instruction docs (`AGENTS.md`, `SECURITY.md`, `TRUST_MODEL.md`) are hash-verified against a local approved baseline before TUI start
 
@@ -87,11 +101,18 @@ HybridClaw uses typed runtime config in `config.json` (auto-created on first run
 
 - Start from `config.example.json` (reference)
 - Runtime watches `config.json` and hot-reloads most settings (model defaults, heartbeat, prompt hooks, limits, etc.)
+- `discord.guildMembersIntent` enables richer guild member context and better `@name` mention resolution in replies (requires enabling **Server Members Intent** in Discord Developer Portal)
+- `discord.presenceIntent` enables Discord presence events (requires enabling **Presence Intent** in Discord Developer Portal)
+- `discord.respondToAllMessages` changes guild trigger behavior: `false` (default) replies only on mention/`!claw`; `true` replies to every user message in the channel
+- `discord.commandUserId` restricts `!claw <command>` admin commands to a single Discord user ID (all other messages still use normal chat handling)
+- `discord.commandsOnly` optional hard mode: if `true`, the bot ignores non-`!claw` messages and only accepts prefixed commands (optionally limited by `discord.commandUserId`)
 - `skills.extraDirs` adds additional enterprise/shared skill roots (lowest precedence tier)
-- `proactive.*` controls autonomous behavior (`activeHours`, `delegation`, `autoRetry`)
+- `proactive.*` controls autonomous behavior (`activeHours`, `delegation`, `autoRetry`, `ralph`)
+- `proactive.ralph.maxIterations` enables Ralph loop (`0` off, `-1` unlimited, `>0` extra autonomous iterations before forcing completion)
+- TUI/Gateway command: `ralph on|off|set <n>|info` (`0` off, `-1` unlimited, `1-64` extra iterations)
 - `observability.*` controls push ingest into HybridAI (`events:batch` endpoint, batching, identity metadata)
 - Some settings require restart to fully apply (for example HTTP bind host/port)
-- Default bot is configured via `hybridai.defaultChatbotId` in `config.json` (legacy `HYBRIDAI_CHATBOT_ID` values are auto-migrated on startup)
+- Default bot is configured via `hybridai.defaultChatbotId` in `config.json`
 
 Secrets remain in `.env`:
 
@@ -139,6 +160,7 @@ HybridClaw can forward structured audit records to HybridAI's ingest API:
 - transport: bearer ingest token auto-fetched via `POST /api/v1/agent-observability/ingest-token:ensure` using `HYBRIDAI_API_KEY`
 - delivery: incremental batches with persisted cursor (`observability_offsets` table), max 1000 events and max 2,000,000-byte payload per request
 - token handling: token cache is stored locally in SQLite (`observability_ingest_tokens`) and automatically refreshed on ingest auth failures
+- token visibility: `model.usage` payloads include `promptTokens`, `completionTokens`, `totalTokens`, plus estimated and API-native counters for accuracy/coverage
 
 Config keys (in `config.json`):
 
@@ -252,6 +274,29 @@ Explicit invocation is supported via:
 Example skill in this repo:
 
 - `skills/repo-orientation/SKILL.md`
+- `skills/current-time/SKILL.md`
+- `skills/personality/SKILL.md`
+- `skills/skill-creator/SKILL.md`
+
+### Personality switching skill
+
+HybridClaw includes a command-only personality skill that updates the active persona contract in `SOUL.md`.
+
+- List current/available persona: `/personality` (or `/personality list`)
+- Activate persona: `/personality <name>`
+- Reset to default persona: `/personality reset`
+
+The skill writes/updates a managed block in `SOUL.md`:
+
+- `## Active personality`
+- `Name: ...`
+- `Definition: ...` (copied from the selected profile in `skills/personality/SKILL.md`)
+- `Rules: ...` (runtime style/behavior constraints)
+
+Notes:
+
+- The personality skill is intentionally command-only (`always: false`, `disable-model-invocation: true`) to avoid adding per-turn prompt overhead.
+- Profiles are defined in `skills/personality/SKILL.md` and currently include 25 switchable personas (expert, style, and role personas).
 
 ## Agent tools
 
@@ -315,6 +360,7 @@ CLI runtime commands:
 - `hybridclaw gateway <command...>` — Send a command to a running gateway (for example `sessions`, `bot info`)
 - `hybridclaw tui` — Start terminal client connected to gateway
 - `hybridclaw onboarding` — Run HybridAI account/API key onboarding
+- `hybridclaw update [status|--check] [--yes]` — Check for updates and upgrade global npm installs (source checkouts get git-based update instructions)
 - `hybridclaw audit ...` — Verify and inspect structured audit trail (`recent`, `search`, `approvals`, `verify`, `instructions`)
 
 In Discord, use `!claw help` to see all commands. Key ones:

package/config.example.json

@@ -1,5 +1,5 @@
 {
-  "version": 2,
+  "version": 3,
   "security": {
     "trustModelAccepted": false,
     "trustModelAcceptedAt": "",
@@ -10,7 +10,12 @@
     "extraDirs": []
   },
   "discord": {
-    "prefix": "!claw"
+    "prefix": "!claw",
+    "guildMembersIntent": false,
+    "presenceIntent": false,
+    "respondToAllMessages": false,
+    "commandsOnly": false,
+    "commandUserId": ""
   },
   "hybridai": {
     "baseUrl": "https://hybridai.one",
@@ -94,6 +99,9 @@
       "maxAttempts": 3,
       "baseDelayMs": 2000,
       "maxDelayMs": 8000
+    },
+    "ralph": {
+      "maxIterations": 0
     }
   }
 }

package/container/package-lock.json

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

package/container/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.1.22",
+  "version": "0.2.1",
   "type": "module",
   "scripts": {
     "build": "tsc",

package/container/src/hybridai-client.ts

@@ -1,4 +1,4 @@
-import type { ChatCompletionResponse, ChatMessage, ToolDefinition } from './types.js';
+import type { ChatCompletionResponse, ChatMessage, ToolCall, ToolDefinition } from './types.js';
 
 export class HybridAIRequestError extends Error {
   status: number;
@@ -12,18 +12,45 @@ export class HybridAIRequestError extends Error {
   }
 }
 
-export async function callHybridAI(
-  baseUrl: string,
-  apiKey: string,
+interface StreamToolCallDelta {
+  index?: number;
+  id?: string;
+  type?: 'function';
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+}
+
+interface StreamChoiceChunk {
+  delta?: {
+    role?: string;
+    content?: string | null;
+    tool_calls?: StreamToolCallDelta[];
+  };
+  message?: {
+    role?: string;
+    content?: string | null;
+    tool_calls?: ToolCall[];
+  };
+  finish_reason?: string | null;
+}
+
+interface StreamChunkPayload {
+  id?: string;
+  model?: string;
+  usage?: ChatCompletionResponse['usage'];
+  choices?: StreamChoiceChunk[];
+}
+
+function buildRequestBody(
   model: string,
   chatbotId: string,
   enableRag: boolean,
   messages: ChatMessage[],
   tools: ToolDefinition[],
-): Promise<ChatCompletionResponse> {
-  const url = `${baseUrl}/v1/chat/completions`;
-
-  const body: Record<string, unknown> = {
+): Record<string, unknown> {
+  return {
     model,
     chatbot_id: chatbotId,
     messages,
@@ -31,6 +58,65 @@ export async function callHybridAI(
     tool_choice: 'auto',
     enable_rag: enableRag,
   };
+}
+
+function parseStreamPayloadLine(rawLine: string): string | null {
+  const trimmed = rawLine.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith(':')) return null;
+  if (trimmed.startsWith('event:')) return null;
+  if (trimmed.startsWith('id:')) return null;
+  if (trimmed.startsWith('data:')) {
+    return trimmed.slice(5).trim();
+  }
+  return trimmed;
+}
+
+function ensureToolCall(toolCalls: ToolCall[], index: number): ToolCall {
+  while (toolCalls.length <= index) {
+    toolCalls.push({
+      id: '',
+      type: 'function',
+      function: {
+        name: '',
+        arguments: '',
+      },
+    });
+  }
+  return toolCalls[index];
+}
+
+function mergeToolCallDelta(target: ToolCall, delta: StreamToolCallDelta): void {
+  if (typeof delta.id === 'string' && delta.id) {
+    target.id = target.id ? `${target.id}${delta.id}` : delta.id;
+  }
+  if (typeof delta.type === 'string') {
+    target.type = delta.type;
+  }
+  if (delta.function) {
+    if (typeof delta.function.name === 'string' && delta.function.name) {
+      target.function.name = target.function.name
+        ? `${target.function.name}${delta.function.name}`
+        : delta.function.name;
+    }
+    if (typeof delta.function.arguments === 'string' && delta.function.arguments) {
+      target.function.arguments += delta.function.arguments;
+    }
+  }
+}
+
+export async function callHybridAI(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  chatbotId: string,
+  enableRag: boolean,
+  messages: ChatMessage[],
+  tools: ToolDefinition[],
+): Promise<ChatCompletionResponse> {
+  const url = `${baseUrl}/v1/chat/completions`;
+
+  const body = buildRequestBody(model, chatbotId, enableRag, messages, tools);
 
   const response = await fetch(url, {
     method: 'POST',
@@ -48,3 +134,179 @@ export async function callHybridAI(
 
   return (await response.json()) as ChatCompletionResponse;
 }
+
+export async function callHybridAIStream(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  chatbotId: string,
+  enableRag: boolean,
+  messages: ChatMessage[],
+  tools: ToolDefinition[],
+  onTextDelta: (delta: string) => void,
+): Promise<ChatCompletionResponse> {
+  const url = `${baseUrl}/v1/chat/completions`;
+  const body = {
+    ...buildRequestBody(model, chatbotId, enableRag, messages, tools),
+    stream: true,
+  };
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream, application/x-ndjson, application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new HybridAIRequestError(response.status, text);
+  }
+
+  const contentType = (response.headers.get('content-type') || '').toLowerCase();
+  if (
+    contentType.includes('application/json')
+    && !contentType.includes('ndjson')
+    && !contentType.includes('event-stream')
+  ) {
+    return (await response.json()) as ChatCompletionResponse;
+  }
+
+  if (!response.body) {
+    return (await response.json()) as ChatCompletionResponse;
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+
+  let buffer = '';
+  let streamId = '';
+  let streamModel = model;
+  let finishReason: string | null = null;
+  let usage: ChatCompletionResponse['usage'] | undefined;
+  let role: string = 'assistant';
+  let textContent = '';
+  const toolCalls: ToolCall[] = [];
+  let sawPayload = false;
+  let streamDone = false;
+
+  const consumePayload = (payloadText: string): void => {
+    if (!payloadText || payloadText === '[DONE]') {
+      if (payloadText === '[DONE]') streamDone = true;
+      return;
+    }
+
+    let payload: StreamChunkPayload;
+    try {
+      payload = JSON.parse(payloadText) as StreamChunkPayload;
+    } catch {
+      return;
+    }
+
+    sawPayload = true;
+    if (typeof payload.id === 'string' && payload.id) streamId = payload.id;
+    if (typeof payload.model === 'string' && payload.model) streamModel = payload.model;
+    if (payload.usage && typeof payload.usage === 'object') usage = payload.usage;
+
+    const choice = Array.isArray(payload.choices) ? payload.choices[0] : undefined;
+    if (!choice) return;
+
+    if (choice.message) {
+      const message = choice.message;
+      if (typeof message.role === 'string' && message.role) role = message.role;
+      if (typeof message.content === 'string') {
+        const nextContent = message.content;
+        const delta = nextContent.startsWith(textContent)
+          ? nextContent.slice(textContent.length)
+          : nextContent;
+        textContent = nextContent;
+        if (delta) onTextDelta(delta);
+      }
+      if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+        toolCalls.length = 0;
+        for (const call of message.tool_calls) {
+          toolCalls.push({
+            id: call.id || '',
+            type: call.type || 'function',
+            function: {
+              name: call.function?.name || '',
+              arguments: call.function?.arguments || '',
+            },
+          });
+        }
+      }
+    }
+
+    if (choice.delta) {
+      const delta = choice.delta;
+      if (typeof delta.role === 'string' && delta.role) role = delta.role;
+      if (typeof delta.content === 'string' && delta.content) {
+        textContent += delta.content;
+        onTextDelta(delta.content);
+      }
+      if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+        for (const callDelta of delta.tool_calls) {
+          const index = typeof callDelta.index === 'number' && callDelta.index >= 0 ? callDelta.index : 0;
+          const target = ensureToolCall(toolCalls, index);
+          mergeToolCallDelta(target, callDelta);
+        }
+      }
+    }
+
+    if (typeof choice.finish_reason === 'string' && choice.finish_reason) {
+      finishReason = choice.finish_reason;
+    }
+  };
+
+  try {
+    while (!streamDone) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const rawLine of lines) {
+        const payloadText = parseStreamPayloadLine(rawLine);
+        if (!payloadText) continue;
+        consumePayload(payloadText);
+        if (streamDone) break;
+      }
+    }
+
+    if (!streamDone && buffer.trim()) {
+      const payloadText = parseStreamPayloadLine(buffer);
+      if (payloadText) {
+        consumePayload(payloadText);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    decoder.decode();
+  }
+
+  if (!sawPayload) {
+    throw new Error('Streaming response ended without payload');
+  }
+
+  const finalFinishReason = finishReason || (toolCalls.length > 0 ? 'tool_calls' : 'stop');
+  return {
+    id: streamId || 'stream',
+    model: streamModel,
+    choices: [
+      {
+        message: {
+          role,
+          content: textContent || null,
+          ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        },
+        finish_reason: finalFinishReason,
+      },
+    ],
+    ...(usage ? { usage } : {}),
+  };
+}