openclaw-openagent 1.0.12 → 1.0.14

package/src/app/hooks.ts

@@ -1,144 +0,0 @@
-/**
- * Hooks — Scene + Purpose injection + Inline Image Offload
- *
- * Registers hooks with the OpenClaw API:
- *   1. before_prompt_build — injects channel-specific rules (skill) and agent purpose
- *   2. agent_turn_prepare  — offloads inline base64 images to ~/.openclaw/media/inbound/
- *                           so the model can reference them via media://inbound/<id>
- */
-
-import { registry } from '../runtime/registry.js';
-import { logger } from '../util/logger.js';
-
-interface HookEvent {
-  [key: string]: unknown;
-}
-
-interface HookContext {
-  sessionId?: string;
-  [key: string]: unknown;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyApi = any;
-
-/**
- * Register all OpenAgent hooks with OpenClaw API.
- */
-export function registerHooks(api: AnyApi): void {
-  // ── Hook 1: Scene + Purpose injection ──
-  api.registerHook('before_prompt_build', async (_event: HookEvent, ctx: HookContext) => {
-    // Only fire for openagent channel sessions
-    if (!ctx.sessionId?.startsWith('openagent:')) return {};
-
-    const channelId = ctx.sessionId.replace('openagent:', '');
-    const rt = registry.getDefault();
-    if (!rt) return {};
-
-    const parts: string[] = [];
-
-    // Inject channel rules (skill/scene)
-    try {
-      const rules = await rt.getChannelSkill(channelId);
-      if (rules) parts.push(`[SCENE: ${channelId}]\n${rules}\n[/SCENE]`);
-    } catch (err) {
-      logger.warn(`[hooks] rules fetch failed: ${(err as Error).message}`);
-    }
-
-    // Inject agent purpose for this channel
-    try {
-      const purpose = rt.store?.getPurpose(channelId);
-      if (purpose) parts.push(`[PURPOSE]\n${purpose}\n[/PURPOSE]`);
-    } catch (err) {
-      logger.warn(`[hooks] purpose fetch failed: ${(err as Error).message}`);
-    }
-
-    if (parts.length === 0) return {};
-
-    logger.debug(`[hooks] Injected Scene+Purpose for ${channelId}`);
-    return { appendSystemContext: parts.join('\n\n') };
-  }, { name: 'openagent-scene-purpose' });
-
-  // ── Hook 2: Inline image offload ──
-  //
-  // When a user uploads a file via Web UI and the model supports vision,
-  // images < 2MB are sent inline (base64 in the message content) and never
-  // saved to disk.  This hook intercepts those inline images via the llm_input
-  // event (fires for ALL agent sessions including embedded), extracts the
-  // base64 data, and writes it to ~/.openclaw/media/inbound/ via saveMediaBuffer.
-  //
-  // The model won't see a media://inbound/ URL in its prompt, but
-  // openagent_upload_file's auto-fallback (resolveLatestInboundFile) will
-  // pick up the most recently saved file automatically.
-  //
-  api.registerHook('llm_input', async (event: HookEvent) => {
-    const historyMessages = event.historyMessages as unknown[] | undefined;
-    if (!Array.isArray(historyMessages) || historyMessages.length === 0) return;
-
-    logger.info(
-      `[hooks] llm_input FIRED imagesCount=${event.imagesCount} historyMsgs=${historyMessages.length}`,
-    );
-
-    // Scan ALL messages (not just the last user message) for inline images
-    const MAX_BYTES = 20 * 1024 * 1024;
-    let savedCount = 0;
-
-    for (const msg of historyMessages as Record<string, unknown>[]) {
-      if (!msg || typeof msg !== 'object') continue;
-      const contentRaw = msg.content;
-      const contentBlocks: Record<string, unknown>[] = Array.isArray(contentRaw)
-        ? contentRaw as Record<string, unknown>[]
-        : [];
-
-      for (const block of contentBlocks) {
-        let base64: string | undefined;
-        let mimeType: string | undefined;
-
-        // Anthropic-style: { type: "image", source: { type: "base64", media_type: "...", data: "..." } }
-        if (block?.type === 'image') {
-          const source = block.source as Record<string, unknown> | undefined;
-          if (source?.type === 'base64' && typeof source.data === 'string') {
-            base64 = source.data;
-            mimeType = (source.media_type as string) || 'image/png';
-          }
-        }
-
-        // OpenAI-style: { type: "image_url", image_url: { url: "data:image/png;base64,..." } }
-        if (!base64 && block?.type === 'image_url') {
-          const imageUrl = (block.image_url as Record<string, unknown> | undefined)?.url;
-          if (typeof imageUrl === 'string') {
-            const match = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
-            if (match) {
-              mimeType = match[1]!;
-              base64 = match[2]!;
-            }
-          }
-        }
-
-        if (!base64) continue;
-
-        const buffer = Buffer.from(base64, 'base64');
-        const mime = mimeType || 'application/octet-stream';
-        const ext = mime.split('/')[1] || 'bin';
-
-        try {
-          const { saveMediaBuffer } = await import('openclaw/plugin-sdk/media-store');
-          const saved = await saveMediaBuffer(buffer, mime, 'inbound', MAX_BYTES, `webui-inline.${ext}`);
-          savedCount++;
-          logger.info(
-            `[hooks] Offloaded inline image: media://inbound/${saved.id} ` +
-            `size=${buffer.byteLength} mime=${mime}`,
-          );
-        } catch (err) {
-          logger.warn(
-            `[hooks] Failed to save inline image: ${(err as Error).message}`,
-          );
-        }
-      }
-    }
-
-    if (savedCount > 0) {
-      logger.info(`[hooks] llm_input saved ${savedCount} inline image(s) to media store`);
-    }
-  }, { name: 'openagent-inline-image-offload' });
-}

package/src/app/index.ts

@@ -1,84 +0,0 @@
-/**
- * App — Tool + Hook registration aggregator
- *
- * Registers all tools and hooks with the OpenClaw API.
- */
-
-import {
-  createListChannelsTool,
-  createSearchChannelsTool,
-  createJoinChannelTool,
-  createLeaveChannelTool,
-  createCreateChannelTool,
-  createGetMembersTool,
-  createSetChannelSkillTool,
-  createGetChannelSkillTool,
-} from './channel-tools.js';
-
-import {
-  createSendMessageTool,
-  createGetMessagesTool,
-} from './messaging-tools.js';
-
-import {
-  createSetStrategyTool,
-  createGetStatusTool,
-  createSetPurposeTool,
-  createGetPurposeTool,
-} from './ops-tools.js';
-
-import { createCallRemoteAgentTool } from './remote-agent-tool.js';
-import {
-  createSearchAgentsTool,
-  createGetAgentDetailTool,
-} from './discovery-tools.js';
-import { createUploadFileTool } from './upload-file-tool.js';
-import { createDownloadFileTool } from './download-file-tool.js';
-
-import { registerHooks } from './hooks.js';
-
-import type { ToolFactory } from './types.js';
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk/plugin-entry';
-
-/**
- * Register all tools with OpenClaw API.
- */
-export function registerTools(api: OpenClawPluginApi): void {
-  // ── Channel management (8) — DORMANT: code preserved, not registered ──
-  // Uncomment to re-enable channel-based social networking features.
-  // api.registerTool(createListChannelsTool, { optional: false });
-  // api.registerTool(createSearchChannelsTool, { optional: false });
-  // api.registerTool(createJoinChannelTool, { optional: false });
-  // api.registerTool(createLeaveChannelTool, { optional: false });
-  // api.registerTool(createCreateChannelTool, { optional: false });
-  // api.registerTool(createGetMembersTool, { optional: false });
-  // api.registerTool(createSetChannelSkillTool, { optional: false });
-  // api.registerTool(createGetChannelSkillTool, { optional: false });
-
-  // ── Messaging (2) — DORMANT ──
-  // api.registerTool(createSendMessageTool, { optional: false });
-  // api.registerTool(createGetMessagesTool, { optional: false });
-
-  // ── Ops (4) — DORMANT ──
-  // api.registerTool(createSetStrategyTool, { optional: false });
-  // api.registerTool(createGetStatusTool, { optional: false });
-  // api.registerTool(createSetPurposeTool, { optional: false });
-  // api.registerTool(createGetPurposeTool, { optional: false });
-
-  // ── Remote Agent Orchestration (1) — ACTIVE ──
-  api.registerTool(createCallRemoteAgentTool, { optional: false });
-
-  // ── Agent Discovery (2) — ACTIVE (OASN-only) ──
-  // 搜索 / Agent 详情。TIM 模式下工具存在但返回明确错误。
-  // 注：getCategories() 传输层能力保留给 Agent Book UI 使用，不暴露为 LLM 工具。
-  api.registerTool(createSearchAgentsTool, { optional: false });
-  api.registerTool(createGetAgentDetailTool, { optional: false });
-
-  // ── File Upload / Download (2) — ACTIVE (OASN-only) ──
-  api.registerTool(createUploadFileTool, { optional: false });
-  api.registerTool(createDownloadFileTool, { optional: false });
-}
-
-export { registerHooks };
-export type { ToolDescriptor, ToolFactory } from './types.js';

package/src/app/messaging-tools.ts

@@ -1,79 +0,0 @@
-/**
- * Messaging Tools — 4 message-related tools
- *
- * send_message, get_messages, set_channel_skill, get_channel_skill
- * Note: skill tools are in channel-tools.ts since they manage channel metadata
- *
- * This file contains: send_message, get_messages
- */
-
-import { registry } from '../runtime/registry.js';
-import { logger } from '../util/logger.js';
-import { toolResult, type ToolDescriptor, type ToolParams, type ToolResult } from './types.js';
-
-function fail(error: string): ToolResult {
-  return toolResult(JSON.stringify({ success: false, error }));
-}
-
-function getRuntime() {
-  const rt = registry.getDefault();
-  if (!rt || !rt.isRunning) return null;
-  return rt;
-}
-
-export function createSendMessageTool(): ToolDescriptor {
-  return {
-    name: 'openagent_send_message',
-    label: 'Send OpenAgent Message',
-    description: 'Send a text message to a channel',
-    parameters: {
-      type: 'object',
-      properties: {
-        channelId: { type: 'string', description: 'Channel ID' },
-        text: { type: 'string', description: 'Message text' },
-      },
-      required: ['channelId', 'text'],
-    },
-    async execute(_id: unknown, params: ToolParams) {
-      const rt = getRuntime();
-      if (!rt) return fail('Not connected');
-      try {
-        const result = await rt.sendMessage(String(params.channelId), String(params.text));
-        if (rt.store) {
-          rt.store.updateLastReply(String(params.channelId));
-        }
-        return toolResult(JSON.stringify({ success: true, messageId: result.messageId }));
-      } catch (err) {
-        return fail((err as Error).message);
-      }
-    },
-  };
-}
-
-export function createGetMessagesTool(): ToolDescriptor {
-  return {
-    name: 'openagent_get_messages',
-    label: 'Get Channel Messages',
-    description: 'Get recent messages from a channel (must join channel first)',
-    parameters: {
-      type: 'object',
-      properties: {
-        channelId: { type: 'string', description: 'Channel ID' },
-        count: { type: 'integer', description: 'Number of messages (default 15)' },
-      },
-      required: ['channelId'],
-    },
-    async execute(_id: unknown, params: ToolParams) {
-      const rt = getRuntime();
-      if (!rt) return fail('Not connected');
-      try {
-        const count = (params.count as number) || 15;
-        const messages = await rt.fetchMessages(String(params.channelId), count);
-        return toolResult(JSON.stringify({ success: true, messages }));
-      } catch (err) {
-        logger.error(`[tools] getMessages error: ${(err as Error).message}`);
-        return fail((err as Error).message);
-      }
-    },
-  };
-}

package/src/app/ops-tools.ts

@@ -1,155 +0,0 @@
-/**
- * Ops Tools — 4 operational tools
- *
- * set_strategy, get_status, set_purpose, get_purpose
- *
- * Contract ref: §0.2 refactoring-plan.md
- */
-
-import { registry } from '../runtime/registry.js';
-import { toolResult, type ToolDescriptor, type ToolResult } from './types.js';
-
-function fail(error: string): ToolResult {
-  return toolResult(JSON.stringify({ success: false, error }));
-}
-
-function getRuntime() {
-  const rt = registry.getDefault();
-  if (!rt || !rt.isRunning) return null;
-  return rt;
-}
-
-export function createSetStrategyTool(): ToolDescriptor {
-  return {
-    name: 'openagent_set_strategy',
-    label: 'Set Message Strategy',
-    description: 'Configure how you receive and respond to channel messages. Changes take effect immediately.',
-    parameters: {
-      type: 'object',
-      properties: {
-        batchWindowMs: { type: 'integer', description: 'How long to collect messages before processing (ms, default 20000)' },
-        maxBatchSize: { type: 'integer', description: 'Max messages to buffer before forced flush (default 20)' },
-      },
-      required: [],
-    },
-    async execute(_id, params) {
-      const rt = getRuntime();
-      if (!rt) return fail('Not connected');
-      try {
-        const newConfig: { batchWindowMs?: number; maxBatchSize?: number } = {};
-        if (params?.batchWindowMs != null) newConfig.batchWindowMs = Number(params.batchWindowMs);
-        if (params?.maxBatchSize != null) newConfig.maxBatchSize = Number(params.maxBatchSize);
-        const current = rt.updateStrategy(newConfig);
-        return toolResult(JSON.stringify({
-          success: true,
-          batchWindowMs: current.batchWindowMs,
-          maxBatchSize: current.maxBatchSize,
-        }));
-      } catch (err) {
-        return fail((err as Error).message);
-      }
-    },
-  };
-}
-
-/**
- * get_status — frozen return shape per §0.2:
- *
- * {
- *   success, connected, agentId,
- *   schedulerQueueSize, joinedChannels,
- *   channels: [{ id, name, lastVisit, lastReply, lastMsgSeq }]
- * }
- */
-export function createGetStatusTool(): ToolDescriptor {
-  return {
-    name: 'openagent_get_status',
-    label: 'Get OpenAgent Status',
-    description: 'Get current status of the OpenAgent connection and channel state',
-    parameters: { type: 'object', properties: {}, required: [] },
-    async execute() {
-      const rt = getRuntime();
-      if (!rt) {
-        return fail('OpenAgent is not running');
-      }
-      try {
-        const joined = rt.store?.getJoinedChannels() || [];
-        return toolResult(JSON.stringify({
-          success: true,
-          connected: rt.client?.isReady ?? false,
-          agentId: rt.client?.agentId ?? '',
-          schedulerQueueSize: rt.schedulerQueueSize,
-          joinedChannels: joined.length,
-          channels: joined.map((c: { channel_id: string; channel_name: string; last_visit: number; last_reply: number; last_msg_seq: number }) => ({
-            id: c.channel_id,
-            name: c.channel_name,
-            lastVisit: c.last_visit ? new Date(c.last_visit).toISOString() : 'never',
-            lastReply: c.last_reply ? new Date(c.last_reply).toISOString() : 'never',
-            lastMsgSeq: c.last_msg_seq,
-          })),
-        }));
-      } catch (err) {
-        return fail((err as Error).message);
-      }
-    },
-  };
-}
-
-export function createSetPurposeTool(): ToolDescriptor {
-  return {
-    name: 'openagent_set_purpose',
-    label: 'Set Channel Purpose',
-    description: 'Set or update your purpose/goal for a channel',
-    parameters: {
-      type: 'object',
-      properties: {
-        channelId: { type: 'string', description: 'Channel ID' },
-        purpose: { type: 'string', description: 'Your purpose/goal for this channel' },
-      },
-      required: ['channelId', 'purpose'],
-    },
-    async execute(_id, params) {
-      const rt = getRuntime();
-      if (!rt?.store) return fail('Not connected');
-      try {
-        rt.store.setPurpose(String(params.channelId), String(params.purpose));
-        return toolResult(JSON.stringify({
-          success: true,
-          channelId: params.channelId,
-          purpose: params.purpose,
-        }));
-      } catch (err) {
-        return fail((err as Error).message);
-      }
-    },
-  };
-}
-
-export function createGetPurposeTool(): ToolDescriptor {
-  return {
-    name: 'openagent_get_purpose',
-    label: 'Get Channel Purpose',
-    description: 'Get your current purpose/goal for a channel',
-    parameters: {
-      type: 'object',
-      properties: {
-        channelId: { type: 'string', description: 'Channel ID' },
-      },
-      required: ['channelId'],
-    },
-    async execute(_id, params) {
-      const rt = getRuntime();
-      if (!rt?.store) return fail('Not connected');
-      try {
-        const purpose = rt.store.getPurpose(String(params.channelId));
-        return toolResult(JSON.stringify({
-          success: true,
-          channelId: params.channelId,
-          purpose: purpose || '(no purpose set)',
-        }));
-      } catch (err) {
-        return fail((err as Error).message);
-      }
-    },
-  };
-}