tgo-widget-miniprogram 1.0.0

package/miniprogram_dist/core/i18n.js

@@ -0,0 +1,66 @@
+/**
+ * Simple i18n module (zh/en)
+ */
+var locales = {
+  zh: {
+    'common.retry': '重试',
+    'common.cancel': '取消',
+    'common.loading': '加载中…',
+    'messageInput.placeholder': '提出问题...',
+    'messageInput.send': '发送',
+    'messageInput.interrupt': '中断',
+    'messageList.loadingHistory': '加载中…',
+    'messageList.noMoreMessages': '没有更多消息',
+    'messageList.sending': '发送中…',
+    'messageList.uploading': '上传中…',
+    'errors.authFail': '认证失败，无法发送消息',
+    'errors.networkError': '网络异常或超时，请检查网络后重试',
+    'errors.systemError': '系统错误，请稍后重试',
+    'system.staffAssigned': '已为您接入人工客服，客服 {name0} 为您服务。',
+    'system.sessionTransferred': '会话已转接。客服 {name0} 已将您转接给客服 {name1}。',
+    'system.sessionClosed': '会话已结束。客服 {name0} 已完成本次服务。',
+    'system.sessionClosedNoAgent': '会话已结束。'
+  },
+  en: {
+    'common.retry': 'Retry',
+    'common.cancel': 'Cancel',
+    'common.loading': 'Loading...',
+    'messageInput.placeholder': 'Ask a question...',
+    'messageInput.send': 'Send',
+    'messageInput.interrupt': 'Stop',
+    'messageList.loadingHistory': 'Loading...',
+    'messageList.noMoreMessages': 'No more messages',
+    'messageList.sending': 'Sending...',
+    'messageList.uploading': 'Uploading...',
+    'errors.authFail': 'Authentication failed, cannot send message',
+    'errors.networkError': 'Network error or timeout, please check your connection',
+    'errors.systemError': 'System error, please try again later',
+    'system.staffAssigned': 'You have been connected to customer service. Agent {name0} will assist you.',
+    'system.sessionTransferred': 'Session transferred. Agent {name0} has transferred you to Agent {name1}.',
+    'system.sessionClosed': 'Session ended. Agent {name0} has completed the service.',
+    'system.sessionClosedNoAgent': 'Session ended.'
+  }
+}
+
+var currentLang = 'zh'
+
+function setLang(lang) {
+  currentLang = (lang === 'en') ? 'en' : 'zh'
+}
+
+function getLang() {
+  return currentLang
+}
+
+function t(key, params) {
+  var dict = locales[currentLang] || locales.zh
+  var str = dict[key] || key
+  if (params) {
+    Object.keys(params).forEach(function (k) {
+      str = str.replace(new RegExp('\\{' + k + '\\}', 'g'), params[k])
+    })
+  }
+  return str
+}
+
+module.exports = { setLang: setLang, getLang: getLang, t: t }

package/miniprogram_dist/core/platformStore.js

@@ -0,0 +1,86 @@
+/**
+ * Platform configuration store (Observable singleton)
+ */
+var platformService = require('../services/platform')
+var storage = require('../adapters/storage')
+
+var WELCOME_KEY = function (apiBase, platformApiKey) {
+  return 'tgo:welcome-shown:' + apiBase + ':' + platformApiKey
+}
+
+var defaultConfig = {
+  position: 'bottom-right',
+  theme_color: '#2f80ed',
+  widget_title: 'Tgo',
+  welcome_message: undefined,
+  logo_url: undefined
+}
+
+function PlatformStore() {
+  this._state = {
+    loading: false,
+    error: null,
+    config: Object.assign({}, defaultConfig),
+    welcomeInjected: false,
+    _apiBase: '',
+    _platformApiKey: ''
+  }
+  this._listeners = []
+}
+
+PlatformStore.prototype.getState = function () {
+  return this._state
+}
+
+PlatformStore.prototype._setState = function (partial) {
+  Object.assign(this._state, partial)
+  var state = this._state
+  this._listeners.forEach(function (fn) { try { fn(state) } catch (e) {} })
+}
+
+PlatformStore.prototype.subscribe = function (fn) {
+  this._listeners.push(fn)
+  var self = this
+  return function () {
+    var idx = self._listeners.indexOf(fn)
+    if (idx >= 0) self._listeners.splice(idx, 1)
+  }
+}
+
+PlatformStore.prototype.markWelcomeInjected = function () {
+  this._setState({ welcomeInjected: true })
+  try {
+    var apiBase = this._state._apiBase
+    var apiKey = this._state._platformApiKey
+    if (apiBase && apiKey) storage.setJSON(WELCOME_KEY(apiBase, apiKey), true)
+  } catch (e) {}
+}
+
+PlatformStore.prototype.init = function (apiBase, platformApiKey) {
+  if (!apiBase || !platformApiKey) return Promise.resolve()
+  if (this._state.loading) return Promise.resolve()
+  var self = this
+  this._setState({ loading: true, error: null, _apiBase: apiBase, _platformApiKey: platformApiKey })
+
+  // Read welcome injected from storage
+  try {
+    var injected = !!storage.getJSON(WELCOME_KEY(apiBase, platformApiKey))
+    if (injected) self._setState({ welcomeInjected: true })
+  } catch (e) {}
+
+  return platformService.fetchPlatformInfo({
+    apiBase: apiBase,
+    platformApiKey: platformApiKey
+  }).then(function (info) {
+    var cfg = (info && info.config) || {}
+    self._setState({
+      config: Object.assign({}, self._state.config, cfg)
+    })
+  }).catch(function (e) {
+    self._setState({ error: e && e.message ? e.message : String(e) })
+  }).then(function () {
+    self._setState({ loading: false })
+  })
+}
+
+module.exports = new PlatformStore()

package/miniprogram_dist/core/types.js

@@ -0,0 +1,192 @@
+/**
+ * Message type constants and helper functions
+ */
+
+// Payload types
+var MSG_TYPE_TEXT = 1
+var MSG_TYPE_IMAGE = 2
+var MSG_TYPE_FILE = 3
+var MSG_TYPE_MIXED = 12
+var MSG_TYPE_COMMAND = 99
+var MSG_TYPE_AI_LOADING = 100
+
+// System message types (1000-2000)
+function isSystemMessageType(type) {
+  return typeof type === 'number' && type >= 1000 && type <= 2000
+}
+
+/**
+ * Try to parse a string as JSON, falling back to base64 decode + JSON parse.
+ */
+function tryParsePayloadString(str) {
+  try { return JSON.parse(str) } catch (e) {}
+  // Mini program doesn't have atob, use wx base64 decode
+  try {
+    var buf = wx.base64ToArrayBuffer(str)
+    var text = String.fromCharCode.apply(null, new Uint8Array(buf))
+    return JSON.parse(text)
+  } catch (e) {}
+  return null
+}
+
+/**
+ * Normalize raw payload to structured format
+ */
+function toPayloadFromAny(raw) {
+  if (typeof raw === 'string') {
+    var parsed = tryParsePayloadString(raw)
+    if (parsed && typeof parsed === 'object') return toPayloadFromAny(parsed)
+    return { type: MSG_TYPE_TEXT, content: raw }
+  }
+  if (!raw) return { type: MSG_TYPE_TEXT, content: '' }
+
+  var t = raw.type
+  if (t === MSG_TYPE_TEXT && typeof raw.content === 'string') {
+    return { type: MSG_TYPE_TEXT, content: raw.content }
+  }
+  if (t === MSG_TYPE_IMAGE && typeof raw.url === 'string') {
+    return { type: MSG_TYPE_IMAGE, url: raw.url, width: raw.width || 0, height: raw.height || 0 }
+  }
+  if (t === MSG_TYPE_FILE && typeof raw.url === 'string' && typeof raw.name === 'string') {
+    return { type: MSG_TYPE_FILE, content: raw.content || '[文件]', url: raw.url, name: raw.name, size: raw.size || 0 }
+  }
+  if (t === MSG_TYPE_MIXED && typeof raw.content === 'string' && Array.isArray(raw.images)) {
+    var images = raw.images
+      .filter(function (i) { return i && typeof i.url === 'string' })
+      .map(function (i) { return { url: i.url, width: i.width || 0, height: i.height || 0 } })
+    return { type: MSG_TYPE_MIXED, content: raw.content, images: images }
+  }
+  if (t === MSG_TYPE_COMMAND && typeof raw.cmd === 'string') {
+    return { type: MSG_TYPE_COMMAND, cmd: raw.cmd, param: raw.param || {} }
+  }
+  if (t === MSG_TYPE_AI_LOADING) {
+    return { type: MSG_TYPE_AI_LOADING }
+  }
+  if (isSystemMessageType(t) && typeof raw.content === 'string') {
+    return { type: t, content: raw.content, extra: Array.isArray(raw.extra) ? raw.extra : undefined }
+  }
+  return { type: MSG_TYPE_TEXT, content: typeof raw.content === 'string' ? raw.content : JSON.stringify(raw) }
+}
+
+/**
+ * Map history API message to ChatMessage format
+ */
+var jsonRenderUtils = require('../utils/jsonRender')
+
+function mapHistoryToChatMessage(m, myUid) {
+  // Check event_meta for stream content (Stream API v2)
+  var streamContent
+  if (m && m.event_meta && m.event_meta.has_events) {
+    var events = m.event_meta.events || []
+    for (var i = 0; i < events.length; i++) {
+      var ev = events[i]
+      if (ev.event_key === 'main' && ev.snapshot && ev.snapshot.kind === 'text' && ev.snapshot.text) {
+        streamContent = ev.snapshot.text
+        break
+      }
+    }
+  }
+
+  // Parse mixed content from historical snapshot using MixedStreamParser
+  var uiParts
+  var rawContent = streamContent
+  if (rawContent) {
+    try {
+      var parts = []
+      var parser = jsonRenderUtils.createMixedStreamParser({
+        onText: function (text) { parts.push({ type: 'text', text: text + '\n' }) },
+        onPatch: function (patch) { parts.push({ type: 'data-spec', data: { type: 'patch', patch: patch } }) }
+      })
+      var normalised = rawContent.replace(/([^\n])```spec/g, '$1\n```spec')
+      parser.push(normalised)
+      parser.flush()
+
+      // Backwards compatibility: old messages may have a separate "json_render"
+      // event channel whose snapshot.text contains concatenated JSON patch arrays
+      if (m && m.event_meta && m.event_meta.has_events) {
+        var evts = m.event_meta.events || []
+        for (var k = 0; k < evts.length; k++) {
+          var jrEvt = evts[k]
+          if (jrEvt.event_key === 'json_render' && jrEvt.snapshot && jrEvt.snapshot.text) {
+            try {
+              var norm = '[' + jrEvt.snapshot.text.replace(/\]\s*\[/g, ',') + ']'
+              var outer = JSON.parse(norm)
+              var flat = Array.isArray(outer) ? outer : [outer]
+              // Flatten nested arrays
+              var stack = flat.slice()
+              while (stack.length > 0) {
+                var item = stack.pop()
+                if (Array.isArray(item)) {
+                  for (var x = 0; x < item.length; x++) stack.push(item[x])
+                } else if (item && typeof item === 'object' && 'op' in item && 'path' in item) {
+                  parts.push({ type: 'data-spec', data: { type: 'patch', patch: item } })
+                }
+              }
+            } catch (e) { /* ignore legacy parse failures */ }
+            break
+          }
+        }
+      }
+
+      if (parts.length > 0) {
+        var hasNonEmpty = false
+        for (var p = 0; p < parts.length; p++) {
+          if (parts[p].type !== 'text' || (parts[p].text && parts[p].text.trim())) {
+            hasNonEmpty = true
+            break
+          }
+        }
+        if (hasNonEmpty) uiParts = parts
+      }
+    } catch (e) {
+      console.warn('Failed to parse mixed stream content for historical message:', e)
+    }
+  }
+
+  // Build display content from text parts, or use streamContent as-is
+  var displayContent
+  if (uiParts) {
+    displayContent = ''
+    for (var d = 0; d < uiParts.length; d++) {
+      if (uiParts[d].type === 'text') displayContent += uiParts[d].text || ''
+    }
+  } else {
+    displayContent = streamContent
+  }
+
+  var payload
+  if (displayContent) {
+    payload = { type: MSG_TYPE_TEXT, content: displayContent }
+  } else {
+    payload = toPayloadFromAny(m && m.payload)
+  }
+
+  var errorMessage = m && m.error ? String(m.error) : undefined
+
+  var result = {
+    id: (m.message_id_str || m.client_msg_no || 'h-' + m.message_seq),
+    role: (m.from_uid && myUid && m.from_uid === myUid) ? 'user' : 'agent',
+    payload: payload,
+    time: new Date((m.timestamp || 0) * 1000),
+    messageSeq: typeof m.message_seq === 'number' ? m.message_seq : undefined,
+    clientMsgNo: m.client_msg_no ? String(m.client_msg_no) : undefined,
+    fromUid: m.from_uid ? String(m.from_uid) : undefined,
+    channelId: m.channel_id ? String(m.channel_id) : undefined,
+    channelType: typeof m.channel_type === 'number' ? m.channel_type : undefined,
+    errorMessage: errorMessage
+  }
+  if (uiParts) result.uiParts = uiParts
+  return result
+}
+
+module.exports = {
+  MSG_TYPE_TEXT: MSG_TYPE_TEXT,
+  MSG_TYPE_IMAGE: MSG_TYPE_IMAGE,
+  MSG_TYPE_FILE: MSG_TYPE_FILE,
+  MSG_TYPE_MIXED: MSG_TYPE_MIXED,
+  MSG_TYPE_COMMAND: MSG_TYPE_COMMAND,
+  MSG_TYPE_AI_LOADING: MSG_TYPE_AI_LOADING,
+  isSystemMessageType: isSystemMessageType,
+  toPayloadFromAny: toPayloadFromAny,
+  mapHistoryToChatMessage: mapHistoryToChatMessage
+}

package/miniprogram_dist/services/chat.js

@@ -0,0 +1,67 @@
+/**
+ * Chat completion & cancel services
+ * API: POST /v1/chat/completion
+ * API: POST /v1/ai/runs/cancel-by-client
+ */
+var adapter = require('../adapters/request')
+
+function sendChatCompletion(params) {
+  var apiBase = (params.apiBase || '').replace(/\/$/, '')
+  var url = apiBase + '/v1/chat/completion'
+
+  var body = {
+    api_key: params.platformApiKey,
+    message: params.message,
+    from_uid: params.fromUid,
+    wukongim_only: true,
+    forward_user_message_to_wukongim: false,
+    stream: false
+  }
+  if (params.channelId) body.channel_id = params.channelId
+  if (params.channelType != null) body.channel_type = params.channelType
+
+  return adapter.request({
+    url: url,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: body,
+    timeout: 30000
+  }).then(function (res) {
+    return res.json().then(function (data) {
+      if (data && data.event_type === 'error') {
+        throw new Error(data.message || data.detail || 'Unknown error')
+      }
+      if (!res.ok) {
+        throw new Error('/v1/chat/completion failed: ' + (data.message || data.detail || res.status))
+      }
+      return data
+    })
+  })
+}
+
+function cancelStreaming(params) {
+  var apiBase = (params.apiBase || '').replace(/\/$/, '')
+  var url = apiBase + '/v1/ai/runs/cancel-by-client'
+
+  return adapter.request({
+    url: url,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: {
+      platform_api_key: params.platformApiKey,
+      client_msg_no: params.clientMsgNo,
+      reason: params.reason || 'user_cancel'
+    },
+    timeout: 10000
+  }).then(function (res) {
+    if (!res.ok) {
+      console.warn('[Chat] Cancel streaming failed:', res.status)
+    }
+    return res
+  })
+}
+
+module.exports = {
+  sendChatCompletion: sendChatCompletion,
+  cancelStreaming: cancelStreaming
+}

package/miniprogram_dist/services/messageHistory.js

@@ -0,0 +1,46 @@
+/**
+ * Message history sync service
+ * API: POST /v1/visitors/messages/sync
+ */
+var adapter = require('../adapters/request')
+
+function syncVisitorMessages(params) {
+  var apiBase = (params.apiBase || '').replace(/\/$/, '')
+  var platformApiKey = params.platformApiKey || ''
+  var url = apiBase + '/v1/visitors/messages/sync'
+
+  var body = {
+    platform_api_key: platformApiKey,
+    channel_id: params.channelId,
+    channel_type: params.channelType,
+    start_message_seq: params.startSeq != null ? params.startSeq : null,
+    end_message_seq: params.endSeq != null ? params.endSeq : null,
+    limit: params.limit != null ? params.limit : null,
+    pull_mode: params.pullMode != null ? params.pullMode : null
+  }
+
+  return adapter.request({
+    url: url,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Platform-API-Key': platformApiKey
+    },
+    body: body,
+    timeout: 10000
+  }).then(function (res) {
+    if (!res.ok) {
+      return res.text().then(function (text) {
+        throw new Error('[History] sync failed: ' + res.status + ' ' + text)
+      })
+    }
+    return res.json().then(function (data) {
+      if (!data || !Array.isArray(data.messages)) {
+        throw new Error('[History] invalid response')
+      }
+      return data
+    })
+  })
+}
+
+module.exports = { syncVisitorMessages: syncVisitorMessages }

package/miniprogram_dist/services/platform.js

@@ -0,0 +1,27 @@
+/**
+ * Platform info service
+ * API: GET /v1/platforms/info?platform_api_key=...
+ */
+var adapter = require('../adapters/request')
+
+function fetchPlatformInfo(params) {
+  var apiBase = (params.apiBase || '').replace(/\/$/, '')
+  var platformApiKey = params.platformApiKey || ''
+  var url = apiBase + '/v1/platforms/info?platform_api_key=' + encodeURIComponent(platformApiKey)
+
+  return adapter.request({
+    url: url,
+    method: 'GET',
+    headers: { 'X-Platform-API-Key': platformApiKey },
+    timeout: 10000
+  }).then(function (res) {
+    if (!res.ok) {
+      return res.text().then(function (text) {
+        throw new Error('[Platform] info failed: ' + res.status + ' ' + text)
+      })
+    }
+    return res.json()
+  })
+}
+
+module.exports = { fetchPlatformInfo: fetchPlatformInfo }

package/miniprogram_dist/services/upload.js

@@ -0,0 +1,74 @@
+/**
+ * File upload service using wx.uploadFile
+ * API: POST /v1/chat/upload
+ */
+
+function uploadChatFile(params) {
+  var apiBase = (params.apiBase || '').replace(/\/$/, '')
+  var apiKey = params.apiKey || ''
+  var channelId = params.channelId || ''
+  var channelType = params.channelType || 251
+  var filePath = params.filePath
+  var onProgress = params.onProgress
+
+  return new Promise(function (resolve, reject) {
+    var task = wx.uploadFile({
+      url: apiBase + '/v1/chat/upload',
+      filePath: filePath,
+      name: 'file',
+      header: {
+        'X-Platform-API-Key': apiKey
+      },
+      formData: {
+        channel_id: channelId,
+        channel_type: String(channelType)
+      },
+      success: function (res) {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            var data = JSON.parse(res.data)
+            if (!data || !data.file_id) {
+              return reject(new Error('[Upload] invalid response'))
+            }
+            resolve(data)
+          } catch (e) {
+            reject(new Error('[Upload] invalid JSON response'))
+          }
+        } else {
+          reject(new Error('[Upload] failed: ' + res.statusCode))
+        }
+      },
+      fail: function (err) {
+        reject(new Error('[Upload] ' + (err.errMsg || 'upload failed')))
+      }
+    })
+
+    if (onProgress && task) {
+      task.onProgressUpdate(function (r) {
+        onProgress(r.progress)
+      })
+    }
+  })
+}
+
+/**
+ * Get image dimensions using wx.getImageInfo
+ */
+function getImageInfo(filePath) {
+  return new Promise(function (resolve) {
+    wx.getImageInfo({
+      src: filePath,
+      success: function (res) {
+        resolve({ width: res.width, height: res.height })
+      },
+      fail: function () {
+        resolve(null)
+      }
+    })
+  })
+}
+
+module.exports = {
+  uploadChatFile: uploadChatFile,
+  getImageInfo: getImageInfo
+}

package/miniprogram_dist/services/visitor.js

@@ -0,0 +1,67 @@
+/**
+ * Visitor registration & caching service
+ * API: POST /v1/visitors/register
+ */
+var adapter = require('../adapters/request')
+var storage = require('../adapters/storage')
+
+function _cacheKey(apiBase, platformApiKey) {
+  return 'tgo:visitor:' + apiBase + ':' + platformApiKey
+}
+
+function loadCachedVisitor(apiBase, platformApiKey) {
+  return storage.getJSON(_cacheKey(apiBase, platformApiKey))
+}
+
+function saveCachedVisitor(apiBase, platformApiKey, v, expiresAtMs) {
+  var cached = {
+    apiBase: apiBase,
+    platform_api_key: platformApiKey,
+    visitor_id: v.id,
+    platform_open_id: v.platform_open_id,
+    channel_id: v.channel_id,
+    channel_type: v.channel_type,
+    im_token: v.im_token,
+    project_id: v.project_id,
+    platform_id: v.platform_id,
+    created_at: v.created_at,
+    updated_at: v.updated_at,
+    expires_at: expiresAtMs
+  }
+  storage.setJSON(_cacheKey(apiBase, platformApiKey), cached)
+}
+
+function registerVisitor(params) {
+  var apiBase = (params.apiBase || '').replace(/\/$/, '')
+  var platformApiKey = params.platformApiKey || ''
+  var extra = params.extra || {}
+  var url = apiBase + '/v1/visitors/register'
+
+  var body = Object.assign({ platform_api_key: platformApiKey }, extra)
+
+  return adapter.request({
+    url: url,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: body,
+    timeout: 10000
+  }).then(function (res) {
+    if (!res.ok) {
+      return res.text().then(function (text) {
+        throw new Error('[Visitor] register failed: ' + res.status + ' ' + text)
+      })
+    }
+    return res.json().then(function (data) {
+      if (!data || !data.id || !data.channel_id) {
+        throw new Error('[Visitor] invalid register response: missing id/channel_id')
+      }
+      return data
+    })
+  })
+}
+
+module.exports = {
+  loadCachedVisitor: loadCachedVisitor,
+  saveCachedVisitor: saveCachedVisitor,
+  registerVisitor: registerVisitor
+}