wtt-connect 0.2.57 → 0.2.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.57",
+  "version": "0.2.59",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/config.js

@@ -79,6 +79,8 @@ export function loadConfig(argv = {}) {
     devinArgs: parseListEnv(process.env.WTT_DEVIN_ARGS || fileConfig.devinArgs || 'acp'),
     openclawBin: process.env.WTT_OPENCLAW_BIN || fileConfig.openclawBin || 'openclaw',
     enableChat: parseBool(process.env.WTT_CONNECT_ENABLE_CHAT, fileConfig.enableChat ?? true),
+    messageStream: parseBool(process.env.WTT_CONNECT_MESSAGE_STREAM, fileConfig.messageStream ?? true),
+    messageStreamMinIntervalMs: parseIntEnv(process.env.WTT_CONNECT_MESSAGE_STREAM_MIN_INTERVAL_MS, fileConfig.messageStreamMinIntervalMs || 250),
     publishProgress: parseBool(process.env.WTT_CONNECT_PUBLISH_PROGRESS, fileConfig.publishProgress ?? false),
     requireCommitPush: parseBool(process.env.WTT_REQUIRE_COMMIT_PUSH, fileConfig.requireCommitPush ?? true),
     heartbeatSeconds: parseIntEnv(process.env.WTT_CONNECT_HEARTBEAT_SECONDS, fileConfig.heartbeatSeconds || 25),

package/src/runner.js

@@ -170,11 +170,14 @@ export class Runner {
     if (!content && !staged.files.length) return;
     await this.wtt.typing(topicId, 'start', { statusText: 'Agent 已接收消息，正在准备执行', statusKind: 'queued', ttlMs: 30000 });
     let runtimeSelection = null;
+    let chatStream = null;
     try {
       const transcripts = await this.transcribeAttachments(staged.files);
       const modelConfig = modelConfigFromMessage(m);
       const adapter = this.registry.select({ ...m, content, model_config: modelConfig });
       runtimeSelection = { adapter: adapter.name, modelConfig };
+      chatStream = this.createChatStream(topicId, adapter.name, modelConfig);
+      await chatStream.start();
       this.recordRuntimeSelection(adapter.name, modelConfig, 'running');
       await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行${modelConfig.model ? ` · ${modelConfig.model}` : ''}`, statusKind: 'running', adapter: adapter.name, model: modelConfig.model || undefined, ttlMs: 30000 });
       const agentProfile = await this.getAgentProfile();
@@ -190,11 +193,12 @@ export class Runner {
           modelConfig,
           files: staged.files,
           images: staged.images,
-          onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
+          onProgress: (event) => this.handleChatProgress(topicId, event, adapter.name, chatStream),
         });
         if (localSlash !== null) {
           const reply = stripHiddenContextLeak(localSlash || '(empty response)') || '(empty response)';
-          await this.wtt.publish(topicId, reply, 'CHAT_REPLY');
+          await chatStream.finish(reply);
+          await this.wtt.publish(topicId, reply, 'CHAT_REPLY', { stream_id: chatStream.id });
           log('info', 'slash command replied', { topicId, adapter: adapter.name, chars: reply.length });
           return;
         }
@@ -231,16 +235,18 @@ export class Runner {
         modelConfig,
         files: staged.files,
         images: staged.images,
-        onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
+        onProgress: (event) => this.handleChatProgress(topicId, event, adapter.name, chatStream),
       });
       const prepared = prepareGeneratedFileArtifacts(stripHiddenContextLeak(output || '(empty response)') || '(empty response)');
       const reply = prepared.text || '(empty response)';
+      await chatStream.finish(reply);
       await this.maybeAttachSpeech(topicId, reply, `chat-${topicId}`);
-      await this.wtt.publish(topicId, reply, 'CHAT_REPLY');
+      await this.wtt.publish(topicId, reply, 'CHAT_REPLY', { stream_id: chatStream.id });
       await this.publishGeneratedFileArtifacts(topicId, prepared.refs, { source: 'chat', sourceId: topicId, adapter: adapter.name });
       log('info', 'chat replied', { topicId, chars: reply.length });
     } catch (err) {
-      await this.wtt.publish(topicId, `执行失败：${err.message}`, 'CHAT_REPLY');
+      await chatStream?.fail(err?.message || String(err));
+      await this.wtt.publish(topicId, `执行失败：${err.message}`, 'CHAT_REPLY', chatStream?.id ? { stream_id: chatStream.id } : null);
       log('error', 'chat failed', { topicId, error: err.message });
     } finally {
       if (runtimeSelection) this.recordRuntimeSelection(runtimeSelection.adapter, runtimeSelection.modelConfig, 'idle');
@@ -582,6 +588,71 @@ export class Runner {
     }
   }
 
+  createChatStream(topicId, adapterName = 'agent', modelConfig = {}) {
+    const enabled = this.config.messageStream !== false && Boolean(topicId);
+    const streamId = `wtt-${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
+    let seq = 0;
+    let lastText = '';
+    let lastSentAt = 0;
+    const minInterval = Math.max(100, Number(this.config.messageStreamMinIntervalMs || 250));
+
+    const send = async (state, payload = {}) => {
+      if (!enabled) return;
+      await this.wtt.streamMessage(topicId, streamId, state, {
+        ...payload,
+        seq: ++seq,
+        metadata: {
+          adapter: adapterName,
+          model: modelConfig.model || modelConfig.model_id || modelConfig.modelId || '',
+        },
+      });
+    };
+
+    return {
+      id: streamId,
+      async start() {
+        await send('start');
+      },
+      async offer(event) {
+        if (!enabled) return;
+        const extracted = extractAssistantStreamUpdate(adapterName, event, lastText);
+        if (!extracted.text) return;
+        const cleanText = stripHiddenContextLeak(extracted.text).trimEnd();
+        if (!cleanText || cleanText === lastText) return;
+        const now = Date.now();
+        const grewEnough = cleanText.length - lastText.length >= 80;
+        if (!grewEnough && now - lastSentAt < minInterval) {
+          lastText = cleanText;
+          return;
+        }
+        lastText = cleanText;
+        lastSentAt = now;
+        await send('snapshot', { fullText: cleanText });
+      },
+      async finish(finalText) {
+        if (!enabled) return;
+        const cleanText = stripHiddenContextLeak(finalText || '').trim();
+        if (cleanText && cleanText !== lastText) {
+          lastText = cleanText;
+          lastSentAt = Date.now();
+          await send('snapshot', { fullText: cleanText });
+        }
+        await send('done', { fullText: cleanText || lastText });
+      },
+      async fail(error) {
+        if (!enabled) return;
+        await send('error', { error: String(error || 'stream failed') });
+      },
+    };
+  }
+
+  async handleChatProgress(topicId, event, adapterName, chatStream) {
+    await Promise.all([
+      this.maybePublishProgress(topicId, event, adapterName),
+      chatStream?.offer(event) || Promise.resolve(),
+    ]);
+  }
+
   async maybePublishProgress(topicId, event, adapterName = 'agent') {
     if (!topicId) return;
     const normalized = normalizeAgentEvent(adapterName, event);
@@ -624,6 +695,50 @@ function adapterDisplayName(name) {
   return name || 'Agent';
 }
 
+function extractAssistantStreamUpdate(adapterName, event, previousText = '') {
+  if (!event || typeof event !== 'object') return { text: '' };
+  const role = String(event.role || event.message?.role || '').toLowerCase();
+  if (role && role !== 'assistant') return { text: '' };
+
+  const type = String(event.type || event.event || event.method || '').toLowerCase();
+  if (type.includes('tool') || type.includes('permission') || type.includes('status')) return { text: '' };
+
+  let text = '';
+  if (adapterName === 'claude-code' || type === 'assistant') {
+    text = assistantTextFromValue(event.message?.content || event.content || event.message);
+  }
+  if (!text && (type === 'item.completed' || type === 'response.output_item.done') && event.item) {
+    text = assistantTextFromValue(event.item);
+  }
+  if (!text) {
+    for (const key of ['result', 'text', 'content', 'message', 'output_text', 'response', 'final']) {
+      text = assistantTextFromValue(event[key]);
+      if (text) break;
+    }
+  }
+  if (!text) return { text: '' };
+
+  if (event.delta === true) {
+    return { text: `${previousText || ''}${text}`, mode: 'delta' };
+  }
+  return { text, mode: 'snapshot' };
+}
+
+function assistantTextFromValue(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(assistantTextFromValue).filter(Boolean).join('');
+  if (typeof value === 'object') {
+    const kind = String(value.type || '').toLowerCase();
+    if (kind && !['assistant', 'agent_message', 'message', 'text', 'output_text'].includes(kind)) return '';
+    for (const key of ['text', 'content', 'message', 'output_text', 'result']) {
+      const text = assistantTextFromValue(value[key]);
+      if (text) return text;
+    }
+  }
+  return '';
+}
+
 function isKnownAdapterSlashCommand(adapterName, command) {
   const normalized = String(command || '').trim().toLowerCase();
   if (!normalized) return false;

package/src/wtt-client.js

@@ -176,13 +176,49 @@ export class WTTClient {
       log('info', 'dry-run publish', { topicId, semanticType, chars: content.length });
       return null;
     }
-    return this.action('publish', {
+    const payload = {
       topic_id: topicId,
       content,
       content_type: 'text',
       semantic_type: semanticType,
       ...(metadata && typeof metadata === 'object' ? { metadata } : {}),
-    });
+    };
+    try {
+      return await this.action('publish', payload, 60000);
+    } catch (err) {
+      log('warn', 'websocket publish failed; trying HTTP fallback', {
+        topicId,
+        semanticType,
+        error: err?.message || err,
+      });
+      return await this.httpPublish(payload, 60000);
+    }
+  }
+
+  async streamMessage(topicId, streamId, state, payload = {}) {
+    if (this.config.dryRun) return null;
+    if (!topicId || !streamId) return null;
+    const data = {
+      topic_id: topicId,
+      stream_id: streamId,
+      state,
+      seq: payload.seq || 0,
+      ...(payload.delta ? { delta: payload.delta } : {}),
+      ...(payload.fullText ? { full_text: payload.fullText } : {}),
+      ...(payload.error ? { error: payload.error } : {}),
+      ...(payload.metadata && typeof payload.metadata === 'object' ? { metadata: payload.metadata } : {}),
+    };
+    try {
+      return await this.action('stream_message', data, payload.timeoutMs || 5000);
+    } catch (err) {
+      log('debug', 'message stream event dropped', {
+        topicId,
+        streamId,
+        state,
+        error: err?.message || err,
+      });
+      return null;
+    }
   }
 
   async typing(topicId, state, options = {}) {
@@ -251,6 +287,41 @@ export class WTTClient {
       clearTimeout(timer);
     }
   }
+
+  async httpPublish(payload, timeoutMs = 60000) {
+    const base = String(this.config.wttBaseUrl || '').replace(/\/$/, '');
+    if (!base || !this.config.agentId || !this.config.token) throw new Error('missing HTTP publish configuration');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const headers = { 'Content-Type': 'application/json' };
+      if (this.config.httpToken) headers.Authorization = `Bearer ${this.config.httpToken}`;
+      else headers['X-Agent-Token'] = this.config.token;
+      const response = await fetch(
+        `${base}/topics/${encodeURIComponent(payload.topic_id)}/messages?agent_id=${encodeURIComponent(this.config.agentId)}`,
+        {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({
+            sender_id: this.config.agentId,
+            sender_type: 'AGENT',
+            content: payload.content,
+            content_type: payload.content_type || 'text',
+            semantic_type: payload.semantic_type || 'CHAT_REPLY',
+            ...(payload.metadata ? { metadata: payload.metadata } : {}),
+          }),
+          signal: controller.signal,
+        },
+      );
+      if (!response.ok) {
+        const detail = await response.text().catch(() => '');
+        throw new Error(`HTTP publish failed: ${response.status}${detail ? ` ${detail.slice(0, 160)}` : ''}`);
+      }
+      return await response.json().catch(() => ({}));
+    } finally {
+      clearTimeout(timer);
+    }
+  }
 }
 
 function rid(prefix) {