feat: AI 打字机流式输出、小程序脚本主页布局及灵感卡片优化

- life-script: 新增 aiRuntime 打字机流式服务，PathView/ScriptView/TimelineView 接入打字机效果
- mini-program: ScriptView 重构为打字机输出 + 卡片式灵感列表，主页布局优化
- web: aiRuntime 服务新增流式输出支持
- chat store: 消息状态管理和打字机流式渲染支持

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

mini-program/src/services/aiRuntime.js

@@ -7,6 +7,13 @@ const getAuthHeader = () => {
   return token ? { Authorization: `Bearer ${token}` } : {}
 }
 
+const createRequestId = () => {
+  const random = Math.random().toString(36).slice(2, 10)
+  return `mp-${Date.now()}-${random}`
+}
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms))
+
 const decodeChunk = (arrayBuffer) => {
   if (typeof TextDecoder !== 'undefined') {
     return new TextDecoder('utf-8').decode(arrayBuffer)
@@ -37,34 +44,192 @@ const parseSseFrame = (frame) => {
   }
 }
 
+const queryRuntimeResult = (requestId) => {
+  return new Promise((resolve, reject) => {
+    uni.request({
+      url: `${API_BASE_URL}/ai/runtime/result?requestId=${encodeURIComponent(requestId)}`,
+      method: 'GET',
+      header: {
+        'Content-Type': 'application/json',
+        ...getAuthHeader()
+      },
+      timeout: 15000,
+      success: (res) => {
+        const data = res.data?.data
+        if (res.statusCode >= 200 && res.statusCode < 300 && res.data?.code === 200 && data) {
+          resolve(data)
+          return
+        }
+        reject(new Error(res.data?.message || 'AI 结果还在生成中'))
+      },
+      fail: (error) => {
+        reject(new Error(error.errMsg || 'AI 结果查询失败'))
+      }
+    })
+  })
+}
+
+const recoverRuntimeOutput = async (requestId, { onDelta, onDone }) => {
+  const maxAttempts = 150
+  for (let index = 0; index < maxAttempts; index++) {
+    try {
+      const log = await queryRuntimeResult(requestId)
+      const output = String(log.outputText || '').trim()
+      if (output) {
+        onDelta?.(output, output, {
+          type: 'delta',
+          metadata: { recovered: true, requestId }
+        })
+        onDone?.({
+          type: 'done',
+          metadata: { recovered: true, requestId, source: 'call-log' }
+        }, output)
+        return output
+      }
+      if (log.status === 'failed') {
+        throw new Error(log.errorMessage || 'AI 生成失败')
+      }
+    } catch (error) {
+      if (index === maxAttempts - 1) {
+        throw error
+      }
+    }
+    await sleep(2000)
+  }
+  throw new Error('AI 生成结果暂时没有返回')
+}
+
 export const streamAiScene = ({ sceneCode, inputs = {}, onStart, onDelta, onDone, onError }) => {
   let buffer = ''
   let output = ''
   let closed = false
+  const requestId = inputs.requestId || createRequestId()
+  const requestInputs = {
+    ...inputs,
+    requestId
+  }
 
   return new Promise((resolve, reject) => {
+    let requestTask
+    let recoveryTimer
+    let recoveryPromise
+
+    const clearRecoveryTimer = () => {
+      if (recoveryTimer) {
+        clearTimeout(recoveryTimer)
+        recoveryTimer = null
+      }
+    }
+
+    const recoverOnce = () => {
+      if (!recoveryPromise) {
+        recoveryPromise = recoverRuntimeOutput(requestId, { onDelta, onDone })
+      }
+      return recoveryPromise
+    }
+
+    const completeFromRecoveredOutput = async () => {
+      if (closed) return
+      try {
+        const recoveredOutput = await recoverOnce()
+        if (closed) return
+        output = recoveredOutput
+        closed = true
+        clearRecoveryTimer()
+        requestTask?.abort?.()
+        resolve({ output })
+      } catch (error) {
+        if (!closed) {
+          recoveryPromise = null
+        }
+      }
+    }
+
+    const startRecoveryWatcher = () => {
+      clearRecoveryTimer()
+      recoveryTimer = setTimeout(() => {
+        completeFromRecoveredOutput()
+      }, 8000)
+    }
+
+    const finishRecovered = (message, event) => {
+      if (!output.trim()) return false
+      if (closed) return true
+      closed = true
+      clearRecoveryTimer()
+      onDone?.({
+        type: 'done',
+        metadata: {
+          ...(event?.metadata || {}),
+          recovered: true,
+          warningCode: event?.code,
+          warningMessage: message || event?.message
+        }
+      }, output)
+      resolve({ output })
+      return true
+    }
+
+    const recoverOrFail = async (message, event) => {
+      if (closed) return
+      if (finishRecovered(message, event)) return
+      try {
+        const recoveredOutput = await recoverOnce()
+        if (closed) return
+        output = recoveredOutput
+        closed = true
+        clearRecoveryTimer()
+        resolve({ output })
+      } catch (recoverError) {
+        if (closed) return
+        const finalMessage = message || recoverError.message || 'AI 生成结果暂时没有返回'
+        closed = true
+        clearRecoveryTimer()
+        onError?.(finalMessage, event)
+        reject(new Error(finalMessage))
+      }
+    }
+
     const failStream = (message, event) => {
+      recoverOrFail(message, event)
+    }
+
+    const failWithoutRecovery = (message, event) => {
       if (closed) return
       closed = true
+      clearRecoveryTimer()
       onError?.(message, event)
       reject(new Error(message))
     }
 
-    const requestTask = uni.request({
+    const finishWithOutputOrRecover = async () => {
+      if (closed) return
+      if (output.trim()) {
+        closed = true
+        clearRecoveryTimer()
+        resolve({ output })
+        return
+      }
+      await recoverOrFail('AI 生成结果暂时没有返回')
+    }
+
+    startRecoveryWatcher()
+
+    requestTask = uni.request({
       url: `${API_BASE_URL}/ai/runtime/stream`,
       method: 'POST',
-      data: { sceneCode, inputs },
+      data: { sceneCode, requestId, inputs: requestInputs },
       header: {
         'Content-Type': 'application/json',
         ...getAuthHeader()
       },
       enableChunked: true,
-      timeout: 120000,
-      success: (res) => {
+      timeout: 240000,
+      success: async (res) => {
         if (closed) return
         if (res.statusCode >= 400) {
           const message = res.data?.message || 'AI流式请求失败'
-          failStream(message)
+          failWithoutRecovery(message)
           return
         }
         if (typeof res.data === 'string' && res.data) {
@@ -73,8 +238,7 @@ export const streamAiScene = ({ sceneCode, inputs = {}, onStart, onDelta, onDone
         if (buffer.trim()) {
           consumeText('\n\n', failStream)
         }
-        closed = true
-        resolve({ output })
+        await finishWithOutputOrRecover()
       },
       fail: (error) => {
         failStream(error.errMsg || 'AI流式请求失败')