聊天

storvia.chat.send({
  message: string,       // 必填：用户消息内容
  topic?: string,        // 可选：话题标识，隔离对话历史
  sceneKey?: string,      // 可选：场景 key，引用创作台预设的场景设定
  extract?: { start, end },  // 可选：内容过滤规则，详见「内容过滤」章节
  stream?: boolean,      // 可选：是否流式输出（默认 false）
  onChunk?: (text) => void,         // stream=true 时：收到文本片段的回调
  onDone?: (id) => void,            // stream=true 时：生成完成的回调，id 为消息UUID
  onState?: (delta, full) => void,  // stream=true 时：AI 本轮有属性变更时触发；非流式通过返回值的 delta/full 字段获取
  onThinking?: (status) => void,    // stream=true 时：模型 reasoning 状态变更（'start' = 开始思考，'end' = 开始输出正文），仅支持思考型模型
})

const reply = await storvia.chat.send({
  message: '你好',
  topic: 'dm_npc1',
  sceneKey: 'dm_scene',
});

console.log(reply.id);       // 消息 UUID
console.log(reply.content);  // AI 回复内容

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "content": "干嘛，这么晚找我？",
  "delta": { ... },
  "full": { ... }
}

{
  "world": {
    "time": "晚上 22:00",
    "location": "秦照野的直播间"
  },
  "player": {
    "经验": 180
  },
  "characters": [
    {
      "id": "秦照野",
      "op": "update",
      "attrs": { "好感度": 50, "心情": "开心" }
    },
    {
      "id": "路人甲",
      "op": "add",
      "attrs": { "好感度": 0 }
    }
  ],
  "items": [
    { "name": "玫瑰花", "op": "add", "count": 3 },
    { "name": "旧钥匙", "op": "remove" }
  ],
  "relations": [
    { "from": "玩家", "to": "秦照野", "op": "update", "好感度": 50, "关系阶段": "朋友" }
  ],
  "locations": [
    { "name": "秘密基地", "op": "add", "region": "城东", "description": "隐蔽的据点" }
  ]
}

await storvia.chat.send({
  message: '你好',
  topic: 'dm_npc1',
  sceneKey: 'dm_scene',
  stream: true,
  onChunk: (text) => {
    // 每收到一个文本片段就会调用
    // text 是增量内容，不是完整内容
    chatBubble.textContent += text;
  },
  onDone: (id) => {
    // 流式输出完成
    console.log('消息ID:', id);
  },
  onState: (delta, full) => {
    // AI 本轮有属性变更时触发（仅在确实改动了世界/玩家/角色等字段时）
    // delta 是本轮的变更内容（增量），full 是合并后的完整快照
    console.log('好感度变了:', delta.characters);
    updateUI(full.current);
  },
});

data: {"type":"start","ai_message_uuid":"550e8400-...","is_streaming":true}

data: {"type":"thinking","status":"start"}
data: {"type":"thinking","status":"end"}

data: {"type":"delta","content":"干"}
data: {"type":"delta","content":"嘛"}

data: {"type":"state_updating","updating":true}
data: {"type":"state_updating","updating":false}

data: {"type":"state","delta":{...},"full":{...}}

data: {"type":"done","ai_message_uuid":"550e8400-..."}

storvia.chat.save({
  role: 'user' | 'assistant',  // 必填：消息角色
  content: string,              // 必填：消息内容
  topic?: string,               // 可选：话题标识
})

{ id: string }  // 保存的消息 UUID

// 保存一条用户消息到群聊话题
await storvia.chat.save({
  role: 'user',
  content: '大家好！',
  topic: 'group_chat',
});

// 也可以保存 AI 消息（比如本地生成的内容）
await storvia.chat.save({
  role: 'assistant',
  content: '欢迎回来～',
  topic: 'group_chat',
});

storvia.chat.generate({
  topic?: string,        // 可选：话题标识
  sceneKey?: string,      // 可选：场景 key
  extract?: { start, end },  // 可选：内容过滤规则，详见「内容过滤」章节
  stream?: boolean,      // 可选：是否流式（默认 false）
  onChunk?: (text) => void,
  onDone?: (id) => void,
  onState?: (delta, full) => void,
  onThinking?: (status) => void,    // 同 send()，仅思考型模型触发
})

// 角色在群聊中回复（AI 能看到 group_chat 的历史，包括之前 save 的消息）
const reply = await storvia.chat.generate({
  topic: 'group_chat',
  sceneKey: 'group_chat_scene',
});

console.log(reply.content);  // "哟，稀客"

storvia.chat.retry({
  topic?: string,        // 可选：重试指定 topic 下的最后一条 AI 消息
  sceneKey?: string,      // 可选：场景 key
  extract?: { start, end },  // 可选：内容过滤规则，详见「内容过滤」章节
  stream?: boolean,      // 可选：是否流式（默认 false）
  onChunk?: (text) => void,
  onDone?: (id) => void,
  onState?: (delta, full) => void,
  onThinking?: (status) => void,    // 同 send()，仅思考型模型触发
})

const reply = await storvia.chat.retry({
  topic: 'dm_npc1',
  sceneKey: 'dm_scene',
});

console.log(reply.content);  // 新生成的回复

await storvia.chat.retry({
  topic: 'dm_npc1',
  sceneKey: 'dm_scene',
  stream: true,
  onChunk: (text) => {
    chatBubble.textContent += text;
  },
  onDone: (id) => {
    console.log('重新生成完成，消息ID:', id);
  },
});

storvia.chat.messages({
  order: 'asc' | 'desc',             // 必填：asc=从旧到新（历史展示），desc=从新到旧（聊天框）
  limit?: number,                     // 可选：单次最大返回条数，1-50，默认 20
  topic?: string,                     // 可选：按 topic 过滤，不传则返回全部
  cursor?: {                          // 可选：翻页游标，首次不传
    uuid: string,
    createdAt: string,
  },
})

{
  data: Array<{
    uuid: string,
    role: 'user' | 'assistant',
    content: string,
    topic: string | null,
    status: string,
    model: string | null,
    createdAt: string,
  }>,
  hasMore: boolean,                    // 是否还有更多消息
  nextCursor: { uuid, createdAt } | null, // 下一页游标；直接传给下次调用的 cursor 字段
}

// 首次加载：最新 20 条
let result = await storvia.chat.messages({
  order: 'desc',
  topic: 'dm_npc1',
});
renderMessages(result.data);

// 用户向上滚动，加载更旧的消息
if (result.hasMore) {
  result = await storvia.chat.messages({
    order: 'desc',
    topic: 'dm_npc1',
    cursor: result.nextCursor,
  });
  prependMessages(result.data);
}

// 首次加载：最旧 20 条
let result = await storvia.chat.messages({
  order: 'asc',
  topic: 'dm_npc1',
});
renderMessages(result.data);

// 用户向下滚动，加载更新的消息
if (result.hasMore) {
  result = await storvia.chat.messages({
    order: 'asc',
    topic: 'dm_npc1',
    cursor: result.nextCursor,
  });
  appendMessages(result.data);
}

storvia.chat.edit({
  uuid: string;
  content: string;
}): Promise<{
  uuid: string;
  role: string;
  content: string;
  updatedAt: string;
}>;

// 1. 通过 messages() 拿到目标消息的 uuid
const list = await storvia.chat.messages({ order: 'desc', limit: 10 });
const target = list.data[0];

// 2. 编辑文本
const updated = await storvia.chat.edit({
  uuid: target.uuid,
  content: '修改后的内容',
});
console.log(updated.content);    // "修改后的内容"
console.log(updated.updatedAt);   // 新的 ISO 时间戳

storvia.chat.delete({
  uuid: string;
}): Promise<{
  uuid: string;
}>;

// 1. 通过 messages() 拿到目标消息的 uuid
const list = await storvia.chat.messages({ order: 'desc', limit: 10 });
const target = list.data[0];

// 2. 删除该消息
const { uuid } = await storvia.chat.delete({ uuid: target.uuid });
console.log('已删除:', uuid);

storvia.chat.rollback({
  uuid: string;
}): Promise<{
  deletedCount: number;
  deletedUuids: string[];
  restoredGameState: { current: unknown; dormant: unknown } | null;
}>;

// 1. 通过 messages() 拿到目标消息的 uuid
const list = await storvia.chat.messages({ order: 'asc', limit: 100 });
const checkpoint = list.data[10]; // 想回到第 11 条消息

// 2. 回溯
try {
  const r = await storvia.chat.rollback({ uuid: checkpoint.uuid });
  console.log(`已删除 ${r.deletedCount} 条后续消息`);
  if (r.restoredGameState) {
    console.log('状态已从快照恢复:', r.restoredGameState);
  }
} catch (err) {
  if (err.code === 'DAISY_CARD_REQUIRED') {
    showUpgradePrompt('回溯功能仅限雏菊卡会员使用');
  } else if (err.code === 'MESSAGE_TOO_OLD') {
    showToast('该消息已超过 30 天，无法回溯');
  } else {
    throw err;
  }
}

// 1. 玩家发消息 → 保存到 group_chat topic
await storvia.chat.save({
  role: 'user',
  content: '大家晚上好！',
  topic: 'group_chat',
});

// 2. 请求秦照野回复
// AI 能看到 group_chat 历史中的「大家晚上好！」
const reply1 = await storvia.chat.generate({
  topic: 'group_chat',
  sceneKey: 'group_chat_scene',
});
showMessage('秦照野', reply1.content);

// 3. 请求宋亦回复
// AI 能看到玩家的消息 + 秦照野的回复
const reply2 = await storvia.chat.generate({
  topic: 'group_chat',
  sceneKey: 'group_chat_scene',
});
showMessage('宋亦', reply2.content);

// 和秦照野的私聊，始终传同一个 topic
await storvia.chat.send({ message: '你好', topic: 'dm_qin_zhaoye' })
await storvia.chat.send({ message: '昨天的事情…', topic: 'dm_qin_zhaoye' }) // AI 能看到上一条

// ✅ 推荐：固定 topic，首次用 generate，后续重复生成走 retry
const first = await storvia.chat.generate({
  topic: 'danmaku',
  sceneKey: 'danmaku_scene',
})

// 用户点击"换一条" —— 覆盖上一条，不产生新消息
const next = await storvia.chat.retry({
  topic: 'danmaku',
  sceneKey: 'danmaku_scene',
})

const reply = await storvia.chat.send({
  message: '你好',
  topic: 'dm_npc1',
  sceneKey: 'dm_scene',  // 引用创作台预设的场景设定
});

请严格按以下格式输出，不要有任何额外文字：
<title>标题文本</title>
<summary>一段摘要</summary>
<tags>标签1,标签2,标签3</tags>

const reply = await storvia.chat.send({ message, sceneKey: 'card_scene' });
const title = reply.content.match(/<title>([\s\S]*?)<\/title>/)?.[1];
const summary = reply.content.match(/<summary>([\s\S]*?)<\/summary>/)?.[1];
const tags = reply.content.match(/<tags>([\s\S]*?)<\/tags>/)?.[1]?.split(',');

const reply = await storvia.chat.send({
  message: '你好',
  topic: 'main',
  extract: { start: '<reply>', end: '</reply>' },
});

// reply.content 包含首尾标记 + 中间内容
// 例如 AI 输出 "让我想想...<reply>干嘛，这么晚找我？</reply>"
// reply.content → "<reply>干嘛，这么晚找我？</reply>"
console.log(reply.content);

try {
  await storvia.chat.send({
    message: '你好',
    stream: true,
    onChunk: (text) => { chatBubble.textContent += text; },
    onDone: (id) => { console.log('完成:', id); },
  });
} catch (err) {
  switch (err.code) {
    case 'REQUEST_TIMEOUT':
      console.log('请求超时，请检查网络');
      break;
    case 'MODEL_LOADING_TIMEOUT':
      console.log('模型响应超时，请稍后重试');
      break;
    case 'STREAM_INACTIVITY':
      console.log('连接中断，请重试');
      break;
  }
}