853 lines
43 KiB
TypeScript
853 lines
43 KiB
TypeScript
/* =====================================================================
|
||
* ai.ts — AI 内容创作引擎
|
||
* - OpenAI 兼容 /chat/completions
|
||
* - Anthropic 兼容 /v1/messages
|
||
* - 流式 SSE 解析、AbortController 中断
|
||
* - 三类调用：generate / polish / chat
|
||
* 由 ai.js 迁移：逻辑几乎不变，仅改为 TS + ESM
|
||
* ===================================================================== */
|
||
import type { AiOp, ChartItem, Deck, Slide, SlideElement, ElementStyle, RichLine } from './types'
|
||
import { elementTypes, uid } from './sample'
|
||
import { store } from './store'
|
||
import { normSegments } from './richtext'
|
||
import { isTauri, aiProxy, aiProxyStream } from './bridge'
|
||
|
||
const SEP = '%%PPT_JSON%%' // 对话模式中，自然语言回复与结构化操作的分隔标记
|
||
const VALID_TYPES = ['title', 'text', 'list', 'stat', 'quote', 'image', 'video', 'shape', 'chart', 'card', 'table', 'code', 'formula'] as const
|
||
|
||
/* 智谱/通用错误码 → 可操作提示 */
|
||
const ERROR_HINTS: Record<string, string> = {
|
||
'1113': '该 Key 账户按量计费余额不足或无资源包。智谱 Coding Plan 套餐额度仅限官方工具(Claude Code 等)使用，网页应用需走按量计费——请到 bigmodel.cn 充值后重试。',
|
||
'1309': 'GLM Coding Plan 套餐已到期，需续订后使用。',
|
||
'1211': '模型名错误，请在设置里检查模型名（如 glm-4.6）。',
|
||
'1234': '模型名错误，请检查模型名拼写。',
|
||
'1123': 'API Key 无效或已过期，请检查设置中的 Key。',
|
||
'1303': '该 Key 无对应模型权限，请更换模型或 Key。'
|
||
}
|
||
const ERROR_HINTS_BY_STATUS: Record<number, string> = {
|
||
401: '鉴权失败：API Key 无效或格式错误，请检查设置。',
|
||
403: '无权限或来源被拒：Key 无该模型权限，或调用来源受限。',
|
||
404: '接口路径错误：请检查 Base URL 与所选协议是否匹配。',
|
||
429: '限流或额度不足，请稍后重试或检查账户额度。'
|
||
}
|
||
|
||
/* ============================================================
|
||
* Prompt 模板
|
||
* ============================================================ */
|
||
const SYS_BASE =
|
||
'你是「u-ppt」的内容创作助手，擅长把主题变成结构清晰、视觉现代、带入场动效的中文演示稿。\n' +
|
||
'输出必须严格遵循下面的数据模型，坐标用百分比(0-100)，字号为数字。\n\n' +
|
||
'幻灯片模型：\n' +
|
||
'{ "slides": [ { "background": "bg|panel|primary|accent|g-primary|g-deep|g-soft", "elements": [ 元素, ... ] } ] }\n' +
|
||
'背景：bg/panel=浅底；primary/accent=纯色深底；g-primary=主→强调渐变(深)；g-deep=深色渐变；g-soft=浅色渐变。\n\n' +
|
||
'元素类型 type：title 标题 | text 正文 | list 列表 | stat 数据 | quote 金句 | image 图片 | video 视频 | shape 形状 | chart 图表 | card 卡片 | table 表格 | code 代码 | formula 公式\n' +
|
||
'元素：{ "type":..., "x":数字,"y":数字,"w":数字,"h":数字 (0-100), "content":字符串, "style":{...} }\n' +
|
||
' - title/text/list/quote：content 为文字，list 用 \\n 分多行\n' +
|
||
' - stat：content 为大数字(如 "65%")，style.label 为说明\n' +
|
||
' - card：content 第一行=标题、其余行=正文；style.accent=顶部色条键，style.icon=emoji 图标\n' +
|
||
' - shape：style.shapeType=rect|circle|ellipse|triangle|diamond|pentagon|hexagon|star|arrow|chevron|bubble，style.fill=颜色键，style.gradient=true 渐变，style.opacity=0~1\n' +
|
||
' - chart：content 为 JSON，两种格式：\n' +
|
||
' 单系列：[{"label":"","value":数字}, ...]\n' +
|
||
' 多系列：{"series":["Q1","Q2"], "items":[{"label":"华东","values":[120,150]}, ...]}\n' +
|
||
' style.max=最大值，style.chartType=bar|line|area|pie|doughnut|radar|hbar|progress（默认 bar）\n' +
|
||
' style.legend=true 显示图例，style.grid=true 显示网格线，style.stack=true 堆叠（多系列柱状）\n' +
|
||
' 图表类型选择建议：柱状(bar)对比离散类型；折线(line)显示趋势；面积(area)累计趋势；\n' +
|
||
' 饼图(pie)占比构成；环形(doughnut)轻量占比；雷达(radar)多维度对比；条形(hbar)长标签对比；进度(progress)完成率。\n' +
|
||
' - table：content 为 Markdown 管道表格字符串（首行表头，用 | 分列，换行分行），style.header=true 首行加粗\n' +
|
||
' - code：content 为代码文本（保留符原样，不要转义），style.lang=语言如 js/python（可选）\n' +
|
||
' - formula：content 为 LaTeX 公式字符串（不含 $$ 分隔符），如 "E = mc^2"、"\\sum_{i=1}^n x_i"\n' +
|
||
' - image：content 留空\n' +
|
||
' - video：content 填视频 URL\n\n' +
|
||
'可选 segments 字段（结构化富文本，同一行内不同片段可有不同样式）：\n' +
|
||
' segments: [[ {"text":"华东 "}, {"text":"增长 23%","bold":true,"color":"accent"} ], ...]\n' +
|
||
' 每个 segment 支持：bold/italic/underline/strike/color(主题键或#hex)/highlight(黄底)/code/sup/sub/fontSize/link\n' +
|
||
' 仅在需要行内混合样式时用 segments；纯文本继续用 content 即可。segments 与 content 二选一。\n\n' +
|
||
'style 公共字段：fontSize 数字、color 颜色键、align left|center|right、bold 布尔、italic 布尔、label/labelColor/labelSize、radius\n' +
|
||
'颜色 color/fill/accent：一律用主题键 primary|accent|text|muted（系统按背景深浅自动反相，深底文字自动变白，不要手填 #ffffff）。\n\n' +
|
||
'入场动画 style.anim（重要，给主要元素都加上，演示时逐个入场）：\n' +
|
||
' 可选：fade-up(默认上浮) | fade | scale | zoom | slide-l | slide-r | pop(弹现) | rotate(旋转) | bounce(弹跳) | flip(翻转) | blur(聚焦)\n' +
|
||
' 建议：标题/金句用 pop 或 scale；正文/列表用 fade-up；卡片用 fade-up 或 slide-l/slide-r；装饰形状用 scale。\n\n' +
|
||
'版式规范：\n' +
|
||
'- 画布逻辑 1280×720。封面标题 y≈30 h≈18；内容标题 y≈8-10。\n' +
|
||
'- 字号：title 44-66、text 22-28、list 24-30、stat 数字 64-80、quote 40-52。\n' +
|
||
'- 一页一个观点，留白充足，列表不超过 5 条。\n' +
|
||
'- 现代版式：多用 card 分组；封面/金句/结尾用 g-primary；目录用 3-4 张卡片网格；数据页 stat+chart。\n' +
|
||
'- emoji 极克制：默认不给 card.icon，除非确有助于理解，多数卡片留空。\n\n' +
|
||
'内容准则（重要——避免「AI 味」，写得像该领域的真人）：\n' +
|
||
'- 标题写具体事实而非口号：「华东 Q3 增长 23%」而非「业绩腾飞」；「同屏字+口述记忆降 50%」而非「效率革命」。\n' +
|
||
'- 正文要有实质：具体数字、案例、步骤、来源；少用「赋能/助力/打造/引领/开启/一站式」这类空词。\n' +
|
||
'- 禁用万能金句：「少即是多」「一图胜千言」「未来已来」「让 X 更简单」「不止是 X，更是 Y」。\n' +
|
||
'- 列表每条是可执行/可验证的要点，不是三词排比（避免「清晰、简洁、高效」式口号）。\n' +
|
||
'- 有判断、有观点，像从业者写的；数据尽量给来源（人名/书名/研究）。\n' +
|
||
'- 不要使用 markdown 代码块，直接输出 JSON。'
|
||
|
||
const SYS_GENERATE =
|
||
SYS_BASE +
|
||
'\n任务：根据用户主题生成一套完整演示（封面、目录、3-5 页内容、结尾，共 6-8 页）。\n' +
|
||
'要求：每个主要元素都加 style.anim；封面与结尾用 g-primary；至少 2 张 card；数据页用 stat+chart。\n' +
|
||
'严格输出：{"action":"create_all","slides":[...]}'
|
||
|
||
const SYS_POLISH =
|
||
SYS_BASE +
|
||
'\n任务：按指令优化给定的“单页”，保持主题一致、布局合理，并为各元素补充 style.anim。\n' +
|
||
'严格输出：{"action":"update_page","slides":[ 优化后的单页 ],"note":"一句话说明改动"}'
|
||
|
||
const SYS_CHAT =
|
||
SYS_BASE +
|
||
'\n任务：与用户对话式编辑当前演示。先用中文流式回复用户（解释你将做什么），' +
|
||
'如需修改 PPT，在回复最后另起一行输出分隔标记 ' + SEP + '，紧随其后输出 JSON 操作。\n' +
|
||
'JSON 操作格式：{"action":"add_page|update_page|create_all|answer","slides":[...],"target":页码(从1开始,可选)}\n' +
|
||
'- add_page：在 target 页后插入新页；- update_page：替换 target 页；- create_all：整体替换；- answer：仅回答不改稿。\n' +
|
||
'没有改动时不要输出分隔标记，仅回复即可。'
|
||
|
||
/* ============================================================
|
||
* 上下文摘要
|
||
* ============================================================ */
|
||
function deckContext(currentIdx: number, selectedEl?: SlideElement | null): string {
|
||
const deck: Deck = store.getDeck()
|
||
/** 图片/超长 content 脱敏：base64 会撑爆上下文，替换为占位说明 */
|
||
const sanitizeEl = (el: SlideElement): SlideElement => {
|
||
if (el.type === 'image' || el.type === 'video') {
|
||
const src = el.content || ''
|
||
const label = el.type === 'video' ? '视频' : '图片'
|
||
const desc = src.startsWith('data:')
|
||
? `[${label} base64 ${Math.round(src.length / 1024)}KB]`
|
||
: (src ? `[${label}URL: ${src.slice(0, 80)}${src.length > 80 ? '…' : ''}]` : `[空${label}]`)
|
||
return { ...el, content: desc }
|
||
}
|
||
if (el.content && el.content.length > 2000) {
|
||
return { ...el, content: el.content.slice(0, 2000) + `…[截断，共${el.content.length}字符]` }
|
||
}
|
||
return el
|
||
}
|
||
const lines = ['当前主题: ' + deck.theme + '，共 ' + deck.slides.length + ' 页。']
|
||
deck.slides.forEach((s, i) => {
|
||
const types = s.elements.map(e => e.type).join('/')
|
||
const head = (s.elements[0] && s.elements[0].type === 'title') ? (' 标题:"' + (s.elements[0].content || '') + '"') : ''
|
||
lines.push('第' + (i + 1) + '页 [' + types + ']' + head + (i === currentIdx ? ' ← 当前页' : ''))
|
||
})
|
||
const cur = store.currentSlide.value
|
||
const curSanitized = { ...cur, elements: cur.elements.map(sanitizeEl) }
|
||
lines.push('\n当前页(第' + (currentIdx + 1) + '页)完整JSON:\n' + JSON.stringify(curSanitized))
|
||
// 选中元素上下文：让 AI 知道用户正在编辑哪个元素，对话直接围绕它
|
||
if (selectedEl) {
|
||
const typeLabel = selectedEl.type
|
||
const preview = (selectedEl.content || '').replace(/\n/g, ' ').slice(0, 100)
|
||
lines.push('\n【用户当前选中的元素】（第' + (currentIdx + 1) + '页）')
|
||
lines.push('类型: ' + typeLabel + '，内容预览: "' + preview + '"')
|
||
lines.push('完整JSON: ' + JSON.stringify(sanitizeEl(selectedEl)))
|
||
lines.push('用户接下来的对话默认针对此元素，除非明确说整页/整套。')
|
||
}
|
||
return lines.join('\n')
|
||
}
|
||
|
||
/* ============================================================
|
||
* 底层：流式请求
|
||
* ============================================================ */
|
||
interface StreamOpts {
|
||
jsonMode?: boolean
|
||
onVisible?: (text: string) => void
|
||
signal?: AbortSignal
|
||
}
|
||
|
||
interface Message { role: 'system' | 'user' | 'assistant'; content: string }
|
||
|
||
async function streamChat(messages: Message[], opts: StreamOpts): Promise<{ json: any; reply: string; op: any }> {
|
||
const cfg = store.getCfg()
|
||
const isLocal = /localhost|127\.0\.0\.1/i.test(cfg.base || '')
|
||
if (!cfg.key && !isLocal) throw new Error('未配置 API Key，请点击右上角 ⚙ 填写。')
|
||
if (cfg.protocol === 'anthropic') return runAnthropic(messages, opts, cfg)
|
||
return runOpenAI(messages, opts, cfg)
|
||
}
|
||
|
||
function apiUrl(cfg: { proxy: string; base: string }): string {
|
||
return (cfg.proxy || cfg.base || '').replace(/\/+$/, '')
|
||
}
|
||
|
||
/**
|
||
* 桌面流式请求：Rust ai_proxy_stream 转发 SSE 原始 chunk，
|
||
* 事件桥逐 chunk 喂 SSE 解析器（与浏览器路径共用 createSSESink，保留打字机效果与 SEP 协议）。
|
||
* 返回 null 表示桌面桥不可用（回退浏览器 fetch 路径）。
|
||
*/
|
||
async function desktopStream(
|
||
url: string, apiKey: string, body: Record<string, unknown>,
|
||
extractDelta: (obj: any) => string | null, opts: StreamOpts
|
||
): Promise<{ json: any; reply: string; op: any } | null> {
|
||
const sink = createSSESink(extractDelta, opts)
|
||
const full = await aiProxyStream(url, apiKey, JSON.stringify(body), (chunk) => sink.push(chunk))
|
||
if (!full) return null
|
||
if (full.status === 0 && full.error) throw new Error('桌面代理请求失败：' + full.error)
|
||
// 非 200：按 consumeStream 相同格式报错（含智谱错误码翻译）
|
||
if (full.status >= 400) {
|
||
let msg = '接口返回 ' + full.status
|
||
const hint = ERROR_HINTS_BY_STATUS[full.status]
|
||
try {
|
||
const err = JSON.parse(full.body).error
|
||
if (err) {
|
||
msg += ' [' + err.code + '] ' + (err.message || '')
|
||
if (err.code && ERROR_HINTS[err.code]) msg += '\n\n💡 ' + ERROR_HINTS[err.code]
|
||
} else msg += ' ' + (full.body || '').slice(0, 200)
|
||
} catch { msg += ' ' + (full.body || '').slice(0, 200) }
|
||
if (hint && !msg.includes('💡')) msg += '\n\n💡 ' + hint
|
||
throw new Error(msg)
|
||
}
|
||
return sink.finish()
|
||
}
|
||
|
||
/**
|
||
* 统一 POST 入口：
|
||
* - 桌面（Tauri）→ Rust 侧 reqwest 代理（无 CORS）
|
||
* - Web → 浏览器 fetch（支持 CORS 的网关如智谱可直连）
|
||
* 桌面流式请求的 SSE 由 bridge 内部转为 onVisible 增量回调
|
||
*/
|
||
async function postJSON(url: string, headers: Record<string, string>, body: unknown, signal?: AbortSignal): Promise<Response> {
|
||
const bodyStr = JSON.stringify(body)
|
||
// 桌面代理路径：headers 中取鉴权（Authorization Bearer 或 x-api-key）
|
||
if (isTauri()) {
|
||
const apiKey = headers['Authorization']?.replace(/^Bearer\s+/i, '') || headers['x-api-key'] || ''
|
||
const proxied = await aiProxy(url, apiKey, bodyStr)
|
||
if (proxied) {
|
||
if (proxied.status === 0 && proxied.error) throw new Error('桌面代理请求失败：' + proxied.error)
|
||
return new Response(proxied.body, { status: proxied.status })
|
||
}
|
||
}
|
||
try {
|
||
return await fetch(url, { method: 'POST', headers, body: bodyStr, signal })
|
||
} catch (e: any) {
|
||
if (e.name === 'AbortError') throw e
|
||
throw new Error('请求失败（可能是 CORS 跨域拦截）。可在设置中配置"代理 URL"。\n' + e.message)
|
||
}
|
||
}
|
||
|
||
// OpenAI 兼容
|
||
async function runOpenAI(messages: Message[], opts: StreamOpts, cfg: ReturnType<typeof store.getCfg>) {
|
||
const url = apiUrl(cfg) + '/chat/completions'
|
||
const body: Record<string, unknown> = { model: cfg.model || 'glm-4.6', messages, stream: true, temperature: 0.75 }
|
||
if (opts.jsonMode) body.response_format = { type: 'json_object' }
|
||
|
||
// 桌面流式：Rust 事件桥推送 SSE 增量（保留打字机效果），完成后一次性解析
|
||
if (isTauri() && opts.onVisible) {
|
||
const extract = (obj: any) => {
|
||
const ch = obj.choices && obj.choices[0]
|
||
return (ch && ch.delta && ch.delta.content) || null
|
||
}
|
||
const r = await desktopStream(url, cfg.key, body, extract, opts)
|
||
if (r) return r
|
||
}
|
||
const resp = await postJSON(url,
|
||
{ 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + cfg.key }, body, opts.signal)
|
||
return consumeStream(resp, (obj: any) => {
|
||
const ch = obj.choices && obj.choices[0]
|
||
return ch && ch.delta && ch.delta.content
|
||
}, opts)
|
||
}
|
||
|
||
// Anthropic 兼容
|
||
async function runAnthropic(messages: Message[], opts: StreamOpts, cfg: ReturnType<typeof store.getCfg>) {
|
||
const url = apiUrl(cfg) + '/v1/messages'
|
||
const sysParts: string[] = []
|
||
const msgs: Message[] = []
|
||
messages.forEach(m => {
|
||
if (m.role === 'system') { if (m.content) sysParts.push(m.content) }
|
||
else msgs.push({ role: m.role, content: m.content })
|
||
})
|
||
const body: Record<string, unknown> = {
|
||
model: cfg.model || 'glm-4.6',
|
||
messages: msgs,
|
||
max_tokens: opts.jsonMode ? 8192 : 4096,
|
||
stream: true,
|
||
temperature: 0.75
|
||
}
|
||
if (sysParts.length) body.system = sysParts.join('\n\n')
|
||
|
||
// 桌面流式（同 OpenAI 路径）
|
||
if (isTauri() && opts.onVisible) {
|
||
const extract = (obj: any) => {
|
||
if (obj.type === 'content_block_delta' && obj.delta) return obj.delta.text || null
|
||
return null
|
||
}
|
||
const r = await desktopStream(url, cfg.key, body, extract, opts)
|
||
if (r) return r
|
||
}
|
||
const headers = {
|
||
'Content-Type': 'application/json',
|
||
'x-api-key': cfg.key,
|
||
'anthropic-version': '2023-06-01',
|
||
'anthropic-dangerous-direct-browser-access': 'true'
|
||
}
|
||
const resp = await postJSON(url, headers, body, opts.signal)
|
||
return consumeStream(resp, (obj: any) => {
|
||
if (obj.type === 'content_block_delta' && obj.delta) return obj.delta.text || ''
|
||
return null
|
||
}, opts)
|
||
}
|
||
|
||
// 通用 SSE 消费（浏览器 fetch 流）
|
||
async function consumeStream(resp: Response, extractDelta: (obj: any) => string | null, opts: StreamOpts): Promise<{ json: any; reply: string; op: any }> {
|
||
if (!resp.ok) {
|
||
let t = ''; try { t = await resp.text() } catch (e) {}
|
||
let msg = '接口返回 ' + resp.status
|
||
let hint = ERROR_HINTS_BY_STATUS[resp.status]
|
||
try {
|
||
const err = JSON.parse(t).error
|
||
if (err) {
|
||
msg += ' [' + err.code + '] ' + (err.message || '')
|
||
if (err.code && ERROR_HINTS[err.code]) hint = ERROR_HINTS[err.code]
|
||
} else { msg += ' ' + (t || '').slice(0, 200) }
|
||
} catch (e) { msg += ' ' + (t || '').slice(0, 200) }
|
||
if (hint) msg += '\n\n💡 ' + hint
|
||
throw new Error(msg)
|
||
}
|
||
const reader = resp.body!.getReader()
|
||
const dec = new TextDecoder('utf-8')
|
||
const sseSink = createSSESink(extractDelta, opts)
|
||
for (;;) {
|
||
const chunk = await reader.read()
|
||
if (chunk.done) break
|
||
sseSink.push(dec.decode(chunk.value, { stream: true }))
|
||
}
|
||
return sseSink.finish()
|
||
}
|
||
|
||
/**
|
||
* SSE 解析核心：数据源无关（fetch 流 / Tauri 事件流通用）。
|
||
* push() 喂原始 chunk（可能含多行/半行），finish() 返回与 consumeStream 相同结构。
|
||
*/
|
||
function createSSESink(extractDelta: (obj: any) => string | null, opts: StreamOpts) {
|
||
let sseBuf = ''
|
||
let full = ''
|
||
let pending = ''
|
||
let sepMode = false
|
||
|
||
function feed(delta: string | null) {
|
||
if (delta == null) return
|
||
full += delta
|
||
if (opts.jsonMode || sepMode) return
|
||
pending += delta
|
||
const i = pending.indexOf(SEP)
|
||
if (i >= 0) {
|
||
emit(pending.slice(0, i))
|
||
sepMode = true
|
||
pending = ''
|
||
return
|
||
}
|
||
const keep = SEP.length - 1
|
||
if (pending.length > keep) {
|
||
const safe = pending.slice(0, pending.length - keep)
|
||
emit(safe)
|
||
pending = pending.slice(safe.length)
|
||
}
|
||
}
|
||
function emit(text: string) { if (opts.onVisible) opts.onVisible(text) }
|
||
|
||
return {
|
||
/** 喂一个网络 chunk（SSE 帧文本，可跨界） */
|
||
push(chunk: string) {
|
||
sseBuf += chunk.replace(/\r/g, '')
|
||
const lines = sseBuf.split('\n')
|
||
sseBuf = lines.pop() || ''
|
||
for (const line of lines) {
|
||
const l = line.trim()
|
||
if (!l || l.indexOf('data:') !== 0) continue
|
||
const payload = l.slice(5).trim()
|
||
if (!payload || payload === '[DONE]') continue
|
||
let obj: any; try { obj = JSON.parse(payload) } catch (e) { continue }
|
||
const delta = extractDelta(obj)
|
||
if (delta != null) feed(delta)
|
||
}
|
||
},
|
||
/** 流结束：解析残留行并汇总 */
|
||
finish(): { json: any; reply: string; op: any } {
|
||
const tail = sseBuf.trim()
|
||
if (tail.indexOf('data:') === 0) {
|
||
const tp = tail.slice(5).trim()
|
||
if (tp && tp !== '[DONE]') {
|
||
let to: any; try { to = JSON.parse(tp) } catch (e) { to = null }
|
||
if (to) { const td = extractDelta(to); if (td != null) feed(td) }
|
||
}
|
||
}
|
||
if (!opts.jsonMode && !sepMode && pending) emit(pending)
|
||
if (opts.jsonMode) return { json: tryParse(full), reply: '', op: null }
|
||
const parts = full.split(SEP)
|
||
return {
|
||
json: null,
|
||
reply: (parts[0] || '').trim(),
|
||
op: parts.length > 1 ? tryParse(parts.slice(1).join(SEP)) : null
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function tryParse(s: string): any {
|
||
if (!s) return null
|
||
s = String(s).replace(/```json/gi, '').replace(/```/g, '').trim()
|
||
const i = s.indexOf('{'), j = s.lastIndexOf('}')
|
||
if (i < 0 || j < 0) return null
|
||
const candidate = s.slice(i, j + 1)
|
||
try { return JSON.parse(candidate) }
|
||
catch (e) {
|
||
try { return JSON.parse(candidate.replace(/,(\s*[}\]])/g, '$1')) }
|
||
catch (e2) { return null }
|
||
}
|
||
}
|
||
|
||
/* ============================================================
|
||
* 数据规范化（AI 输出 → 可入库）
|
||
* ============================================================ */
|
||
function validColor(v: string): string | undefined {
|
||
if (!v) return v
|
||
if (v.charAt(0) === '#') return /^#[0-9a-f]{3,8}$/i.test(v) ? v : undefined
|
||
return ['primary', 'accent', 'text', 'muted'].indexOf(v) >= 0 ? v : undefined
|
||
}
|
||
|
||
function normStyle(st: any): ElementStyle {
|
||
st = st || {}
|
||
const out: any = { ...st }
|
||
if (out.fontSize != null) out.fontSize = Number(out.fontSize) || 24
|
||
if (out.bold != null) out.bold = !!out.bold
|
||
if (out.italic != null) out.italic = !!out.italic
|
||
if (out.labelSize != null) out.labelSize = Number(out.labelSize) || 16
|
||
if (out.radius != null) out.radius = Number(out.radius) || 0
|
||
if (out.max != null) out.max = Number(out.max) || 0
|
||
// 图表子类型校验
|
||
const VALID_CHART_TYPES = ['bar', 'line', 'pie', 'area', 'doughnut', 'radar', 'hbar', 'progress']
|
||
if (out.chartType != null && !VALID_CHART_TYPES.includes(out.chartType)) delete out.chartType
|
||
if (out.legend != null) out.legend = !!out.legend
|
||
if (out.stack != null) out.stack = !!out.stack
|
||
if (out.grid != null) out.grid = !!out.grid
|
||
if (out.header != null) out.header = !!out.header
|
||
if (out.inline != null) out.inline = !!out.inline
|
||
if (out.autoplay != null) out.autoplay = !!out.autoplay
|
||
if (out.loop != null) out.loop = !!out.loop
|
||
if (out.muted != null) out.muted = !!out.muted
|
||
if (typeof out.lang === 'string' && out.lang.length > 16) out.lang = out.lang.slice(0, 16)
|
||
;['color', 'fill', 'accent', 'labelColor'].forEach(k => {
|
||
if (validColor(out[k]) === undefined && out[k] != null) delete out[k]
|
||
})
|
||
if (typeof out.icon === 'string' && out.icon.length > 8) out.icon = out.icon.slice(0, 8)
|
||
return out
|
||
}
|
||
|
||
function normElement(e: any): SlideElement | null {
|
||
if (!e || typeof e !== 'object') return null
|
||
const type = (VALID_TYPES as readonly string[]).indexOf(e.type) >= 0 ? e.type : 'text'
|
||
const out: SlideElement = {
|
||
id: e.id || uid('el'),
|
||
type: type as SlideElement['type'],
|
||
x: clampNum(e.x, 0, 100, 10),
|
||
y: clampNum(e.y, 0, 100, 10),
|
||
w: clampNum(e.w, 3, 100, 60),
|
||
h: clampNum(e.h, 3, 100, 15),
|
||
content: (e.content == null ? '' : String(e.content)),
|
||
style: normStyle(e.style || {})
|
||
}
|
||
// 可选 segments（结构化富文本）
|
||
if (e.segments) {
|
||
const segs = normSegments(e.segments)
|
||
if (segs) (out as any).segments = segs
|
||
}
|
||
return out
|
||
}
|
||
|
||
const VALID_BGS = ['bg', 'panel', 'primary', 'accent', 'g-primary', 'g-deep', 'g-soft']
|
||
|
||
function normSlide(s: any): Slide | null {
|
||
if (!s || typeof s !== 'object') return null
|
||
const bg = VALID_BGS.indexOf(s.background) >= 0 ? s.background
|
||
: (typeof s.background === 'string' && s.background.charAt(0) === '#' ? s.background : 'bg')
|
||
const els = (Array.isArray(s.elements) ? s.elements : []).map(normElement).filter(Boolean) as SlideElement[]
|
||
return { id: uid('s'), background: bg as Slide['background'], elements: els }
|
||
}
|
||
|
||
function normSlides(arr: any[]): Slide[] {
|
||
return (Array.isArray(arr) ? arr : []).map(normSlide).filter((s): s is Slide => s !== null)
|
||
}
|
||
|
||
function clampNum(v: number, lo: number, hi: number, dflt: number): number {
|
||
const n = Number(v)
|
||
if (isNaN(n)) return dflt
|
||
return Math.max(lo, Math.min(hi, n))
|
||
}
|
||
|
||
/* ============================================================
|
||
* 高层 API
|
||
* ============================================================ */
|
||
|
||
/** 生成整套 */
|
||
export async function generate(opts: { topic: string; count?: number; signal?: AbortSignal }): Promise<{ action: 'create_all'; slides: Slide[] }> {
|
||
const count = opts.count || 7
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_GENERATE },
|
||
{ role: 'user', content: '主题：' + opts.topic + '\n请生成约 ' + count + ' 页（含封面与结尾），中文内容。' }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 输出无法解析为 JSON，请重试。')
|
||
const slides = normSlides(r.json.slides || r.json)
|
||
if (!slides.length) throw new Error('AI 未生成有效幻灯片，请重试或换一个主题。')
|
||
return { action: 'create_all', slides }
|
||
}
|
||
|
||
/** 文档内容 → AI 分析后生成幻灯片 */
|
||
export async function generateFromDocument(opts: {
|
||
text: string
|
||
filename?: string
|
||
signal?: AbortSignal
|
||
}): Promise<{ action: 'create_all'; slides: Slide[] }> {
|
||
const SYS_DOC =
|
||
SYS_BASE +
|
||
'\n任务：分析下方提供的文档内容，将其提炼为 5-10 页专业演示稿（含封面 1 页 + 内容 3-7 页 + 结尾 1 页）。\n' +
|
||
'要求：\n' +
|
||
'- 提取文档中的核心观点、关键数据、重要结论，不要遗漏重要信息\n' +
|
||
'- 每页只有一个主题，标题具体、有信息量，如「Q3 营收增长 23%」而非「业绩回顾」\n' +
|
||
'- 正文有实质内容，包含具体数字、案例、来源；避免空泛口号\n' +
|
||
'- 合理运用 card（对比/分组）、stat（突出数据）、chart（趋势/分布）等元素\n' +
|
||
'- 每个主要元素都加 style.anim 入场动画\n' +
|
||
'- 封面用 g-primary 渐变，结尾可用 g-primary 或 g-deep，内容页用 bg/panel 浅底\n' +
|
||
'严格输出 JSON：{"action":"create_all","slides":[...]}'
|
||
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_DOC },
|
||
{ role: 'user', content: '文档' + (opts.filename ? '（' + opts.filename + '）' : '') + '内容如下：\n\n' + opts.text }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 输出无法解析为 JSON，请重试。')
|
||
const slides = normSlides(r.json.slides || r.json)
|
||
if (!slides.length) throw new Error('AI 未生成有效幻灯片，请重试或检查文档内容。')
|
||
return { action: 'create_all', slides }
|
||
}
|
||
|
||
/** 润色单页 */
|
||
export async function polish(opts: { slide: Slide; instruction?: string; signal?: AbortSignal }): Promise<{ action: 'update_page'; slide: Slide; note: string }> {
|
||
const instruction = opts.instruction || '让这页内容更有吸引力、表达更精炼'
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_POLISH },
|
||
{ role: 'user', content: '指令：' + instruction + '\n当前页JSON：\n' + JSON.stringify(opts.slide) }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 输出无法解析，请重试。')
|
||
const arr = r.json.slides || (r.json.slide ? [r.json.slide] : (r.json.elements ? [r.json] : []))
|
||
const slides = normSlides(arr)
|
||
if (!slides.length) throw new Error('AI 未返回有效页面。')
|
||
return { action: 'update_page', slide: slides[0], note: r.json.note || '' }
|
||
}
|
||
|
||
/** 对话式编辑 */
|
||
export async function chat(opts: {
|
||
history: Message[]
|
||
input: string
|
||
onVisible?: (text: string) => void
|
||
signal?: AbortSignal
|
||
/** 当前选中的元素（可选，注入上下文让对话围绕它） */
|
||
selectedElement?: SlideElement | null
|
||
}): Promise<{ reply: string; op: AiOp | null }> {
|
||
const messages: Message[] = [{ role: 'system', content: SYS_CHAT + '\n\n' + deckContext(store.getCurrentIndex(), opts.selectedElement || null) }]
|
||
;(opts.history || []).forEach(m => messages.push(m))
|
||
messages.push({ role: 'user', content: opts.input })
|
||
const r = await streamChat(messages, { jsonMode: false, onVisible: opts.onVisible, signal: opts.signal })
|
||
return { reply: r.reply, op: normalizeOp(r.op) }
|
||
}
|
||
|
||
/** SEP 分隔标记（对话回复与 JSON 操作的分隔），导出给 relay 等 Transport 复用 */
|
||
export const CHAT_SEP = SEP
|
||
|
||
/**
|
||
* 解析 chat 协议回复文本：SEP 前为自然语言回复，SEP 后为 JSON 操作。
|
||
* 供 AiPanel（SSE 路径）与 AgentPanel（relay 路径）共用，避免复制粘贴。
|
||
*/
|
||
export function parseChatReply(text: string): { reply: string; op: AiOp | null } {
|
||
const parts = text.split(SEP)
|
||
return {
|
||
reply: (parts[0] || '').trim(),
|
||
op: parts.length > 1 ? normalizeOp(tryParse(parts.slice(1).join(SEP))) : null
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 组装 Agent 请求 prompt：用户指令 + chat 协议要求 + deck 上下文。
|
||
* 大 deck（序列化 >700KB）降级为「当前页完整 JSON + 全deck大纲摘要」，防超 1MiB 帧上限。
|
||
*/
|
||
export function buildAgentPrompt(input: string, selectedElement?: SlideElement | null, history?: { role: string; content: string }[]): string {
|
||
const SYS_AGENT =
|
||
SYS_BASE +
|
||
'\n任务：你是通过中继接入的远程 Agent。根据用户指令编辑当前演示。\n' +
|
||
'回复格式：先用中文说明你将做什么，如需修改 PPT，在回复最后另起一行输出分隔标记 ' + SEP + '，紧随其后输出 JSON 操作。\n' +
|
||
'JSON 操作格式：{"action":"add_page|update_page|create_all|answer|outline|gen_page","slides":[...],"target":页码(从1开始,可选)}\n' +
|
||
'- add_page：在 target 页后插入新页；- update_page：替换 target 页；- create_all：整体替换；- answer：仅回答不改稿。\n' +
|
||
'- outline：用户要求「拟定大纲/先出大纲」时返回，格式 {"action":"outline","title":"整份标题","items":[...]}；\n' +
|
||
' items 结构：{ "kind":"cover|toc|content|quote|end", "title":"页标题", "points":["要点 1","要点 2"], "hint":"可选补充指令" }；\n' +
|
||
' kind 取值：cover(封面)/toc(目录)/content(内容)/quote(金句)/end(结尾)，封面与结尾各 1 页，目录可选；\n' +
|
||
' 页数遵循用户指令（指定具体页数照办；未指定/「自动」则按主题信息量在 5-12 页裁量：概念介绍 5-7、常规 7-9、复杂多维度 9-12）；hint 给后续生成幻灯片的补充指令。\n' +
|
||
'- gen_page：用户给出大纲条目要求生成该页时返回，格式 {"action":"gen_page","slides":[单个slide对象]}。\n' +
|
||
'没有改动时不要输出分隔标记。不要使用 markdown 代码块。'
|
||
const deck = store.getDeck()
|
||
let body: string
|
||
const full = JSON.stringify(deck)
|
||
if (full.length > 700 * 1024) {
|
||
// 超大 deck 降级：大纲摘要 + 当前页完整 JSON
|
||
body = deckContext(store.getCurrentIndex(), null)
|
||
} else {
|
||
body = '完整 deck JSON：\n' + full + '\n当前页码：第 ' + (store.getCurrentIndex() + 1) + ' 页'
|
||
}
|
||
// 选中元素上下文：与 direct 通道对话行为对齐
|
||
if (selectedElement) {
|
||
const typeLabel = selectedElement.type
|
||
const preview = (selectedElement.content || '').replace(/\n/g, ' ').slice(0, 100)
|
||
body += '\n\n【用户当前选中的元素】（第' + (store.getCurrentIndex() + 1) + '页）'
|
||
body += '\n类型: ' + typeLabel + '，内容预览: "' + preview + '"'
|
||
body += '\n用户接下来的指令默认针对此元素，除非明确说整页/整套。'
|
||
}
|
||
// 多轮对话历史（不含本次输入）；单条截断防长回复撑爆 1MiB 帧上限
|
||
let hist = ''
|
||
if (history && history.length) {
|
||
hist = '\n\n对话历史：\n' + history
|
||
.map(m => (m.role === 'user' ? '用户: ' : '助手: ') + m.content.slice(0, 1500))
|
||
.join('\n')
|
||
}
|
||
return SYS_AGENT + '\n\n' + hist + '\n\n' + body + '\n\n用户指令：' + input
|
||
}
|
||
|
||
/** 大纲条目规范化（outline() 与 normalizeOp 的 outline 分支共用） */
|
||
function normOutlineItems(arr: any[]): OutlineItem[] {
|
||
return (Array.isArray(arr) ? arr : []).map((it: any, i: number) => ({
|
||
id: 'ol-' + Date.now() + '-' + i,
|
||
kind: ['cover', 'toc', 'content', 'quote', 'end'].includes(it.kind) ? it.kind : 'content',
|
||
title: String(it.title || '未命名').slice(0, 80),
|
||
points: Array.isArray(it.points) ? it.points.map((p: any) => String(p).slice(0, 200)).filter(Boolean).slice(0, 6) : [],
|
||
hint: it.hint ? String(it.hint).slice(0, 120) : undefined,
|
||
done: false
|
||
}))
|
||
}
|
||
|
||
function normalizeOp(json: any): AiOp | null {
|
||
if (!json) return null
|
||
let action: AiOp['action'] = json.action || 'answer'
|
||
const slides = normSlides(json.slides)
|
||
const target = json.target != null ? (Number(json.target) - 1) : null
|
||
// outline：agent 返回整份大纲，条目规范化（复用 outline() 的逻辑）
|
||
if (action === 'outline') {
|
||
const items = normOutlineItems(json.items)
|
||
if (!items.length) action = 'answer'
|
||
else return { action, slides, target: null, note: json.note || '', outline: { title: String(json.title || '').slice(0, 80) || '未命名大纲', topic: '', items } }
|
||
}
|
||
// gen_page：按大纲条目生成的单页，空则降级 answer
|
||
if (action === 'gen_page' && !slides.length) action = 'answer'
|
||
if (action === 'update_page' && slides.length) action = 'update_page'
|
||
if (action === 'add_page' && slides.length) action = 'add_page'
|
||
if ((action === 'update_page' || action === 'add_page') && !slides.length) action = 'answer'
|
||
return { action, slides, target: isNaN(target as number) ? null : target, note: json.note || '' }
|
||
}
|
||
|
||
export function isConfigured(): boolean { return !!(store.getCfg().key) }
|
||
|
||
/* ============================================================
|
||
* AI 深化能力：大纲 / 逐页生成 / 配图 / 主题建议 / 一键美化
|
||
* ============================================================ */
|
||
|
||
import type { Outline, OutlineItem, ThemeSuggestion, ImageGenResult } from './types'
|
||
|
||
/* ---------- Prompt 模板 ---------- */
|
||
|
||
const SYS_OUTLINE =
|
||
'你是「u-ppt」的演示策划助手。用户给你一个主题，你先制定大纲，不要直接写完整幻灯片。\n\n' +
|
||
'大纲要素：先拟定一个具体、有信息量的整份标题（不要「关于 X 的分享」这类空泛标题）；\n' +
|
||
'然后拆成页（页数遵循用户指令：指定了具体页数就照办；「自动」则按主题的信息量在 5-12 页间裁量，' +
|
||
'概念介绍 5-7 页、常规主题 7-9 页、多维度复杂主题 9-12 页），每页给出：页类型 kind、标题 title、3-5 条要点 points、可选 hint。\n' +
|
||
'kind 取值：cover(封面) / toc(目录) / content(内容) / quote(金句) / end(结尾)。\n' +
|
||
'封面与结尾各 1 页，目录可选。\n' +
|
||
'hint 用来给后续生成幻灯片的 AI 补充指令，例如「数据页：用 stat+chart」「对比页：双 card 并置」「引言页：深色背景金句」。\n\n' +
|
||
'内容准则：\n' +
|
||
'- 标题写具体事实而非口号（「华东 Q3 增长 23%」而非「业绩腾飞」）。\n' +
|
||
'- 要点每条是可验证的论点或具体数字，不要三词排比。\n' +
|
||
'- 有判断、有观点，像该领域从业者写的；数据尽量给来源。\n' +
|
||
'- 禁用万能金句：「少即是多」「一图胜千言」「未来已来」。\n\n' +
|
||
'严格输出 JSON：\n' +
|
||
'{ "title": "整份标题", "items": [ { "kind":"cover", "title":"页标题", "points":["要点 1","要点 2"], "hint":"可选" } ] }\n' +
|
||
'不要使用 markdown 代码块，直接输出 JSON。'
|
||
|
||
const SYS_GEN_PAGE =
|
||
SYS_BASE +
|
||
'\n任务：根据大纲中的一条，生成「一页」幻灯片。严格遵循要点与 hint，不要偏离主题。\n' +
|
||
'严格输出：{ "background":"...", "elements":[ ... ] }（单个 slide 对象，不要数组）。\n' +
|
||
'kind=cover 用 g-primary 背景；kind=quote 用 g-deep；kind=end 用 g-primary；kind=content 数据页用 stat+chart。'
|
||
|
||
const SYS_THEME =
|
||
'你是配色设计师。根据主题关键词，推荐一套现代、专业的 6 色配色（primary 主色、accent 强调色、bg 背景、panel 面板、text 正文、muted 次要文字）。\n\n' +
|
||
'要求：\n' +
|
||
'- 主色饱和度适中，不刺眼；强调色与主色形成对比但不冲突。\n' +
|
||
'- bg 与 panel 接近白色，差异轻微。\n' +
|
||
'- text 深于 primary，muted 为中性灰。\n' +
|
||
'- 所有颜色用 #hex 格式。\n\n' +
|
||
'可选背景推荐：bg/panel（浅底）/primary/accent（深底）/g-primary（主→强调渐变）/g-deep（深色渐变）。\n' +
|
||
'内容页优先 bg/panel；封面/结尾优先 g-primary；金句页优先 g-deep。\n\n' +
|
||
'严格输出 JSON：\n' +
|
||
'{ "name":"主题名","primary":"#...","accent":"#...","bg":"#...","panel":"#...","text":"#...","muted":"#...","recommendBg":"g-primary","reason":"一句话设计理由" }\n' +
|
||
'不要使用 markdown 代码块。'
|
||
|
||
const SYS_BEAUTIFY =
|
||
SYS_BASE +
|
||
'\n任务：优化给定页面的「排版」（位置、尺寸、字号、对齐、装饰元素），保持文字内容不变。\n' +
|
||
'如果布局合理则微调；如果有明显问题（元素重叠、字号失衡、留白不足）则重排。\n' +
|
||
'严格输出：{ "background":"原背景或更合适的键", "elements":[ ... ], "note":"一句话说明" }\n' +
|
||
'不要改动文字内容本身，只优化视觉。'
|
||
|
||
/* ---------- 1. 大纲生成 ---------- */
|
||
|
||
export async function outline(opts: { topic: string; count?: number | 'auto'; signal?: AbortSignal }): Promise<Outline> {
|
||
const count = opts.count || 'auto'
|
||
const countHint = count === 'auto'
|
||
? '页数自动裁量（结合主题信息量在 5-12 页之间取舍）'
|
||
: '请拟定约 ' + count + ' 页'
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_OUTLINE },
|
||
{ role: 'user', content: '主题：' + opts.topic + '\n' + countHint + '的大纲（含封面与结尾），中文。' }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 未返回有效大纲，请重试。')
|
||
const items = normOutlineItems(r.json.items)
|
||
if (!items.length) throw new Error('大纲为空，请重试或换一个主题。')
|
||
return { title: String(r.json.title || opts.topic).slice(0, 80), topic: opts.topic, items }
|
||
}
|
||
|
||
/* ---------- 2. 按大纲条目生成单页 ---------- */
|
||
|
||
export async function generatePage(opts: { item: OutlineItem; index: number; total: number; signal?: AbortSignal }): Promise<Slide> {
|
||
const user =
|
||
'大纲第 ' + (opts.index + 1) + '/' + opts.total + ' 页：\n' +
|
||
'类型：' + opts.item.kind + '\n' +
|
||
'标题：' + opts.item.title + '\n' +
|
||
'要点：' + opts.item.points.map((p, i) => (i + 1) + '. ' + p).join('\n') +
|
||
(opts.item.hint ? '\n补充指令：' + opts.item.hint : '')
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_GEN_PAGE },
|
||
{ role: 'user', content: user }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 未返回有效页面。')
|
||
const slides = normSlides([r.json])
|
||
if (!slides.length) throw new Error('AI 输出无法解析为页面。')
|
||
return slides[0]
|
||
}
|
||
|
||
/* ---------- 3. AI 配图 ---------- */
|
||
|
||
/** 图像生成——当前支持 DALL-E 协议（OpenAI /images/generations）与通用返回 URL 的网关 */
|
||
export async function generateImage(opts: { prompt: string; signal?: AbortSignal }): Promise<ImageGenResult> {
|
||
const cfg = store.getCfg()
|
||
const imgBase = (cfg.imgBase || cfg.base || '').replace(/\/+$/, '')
|
||
const imgKey = cfg.imgKey || cfg.key
|
||
// 图像模型默认值跟随服务商：智谱用 cogview，其余走 OpenAI 兼容默认
|
||
const imgModel = cfg.imgModel || (imgBase.includes('bigmodel.cn') ? 'cogview-3-plus' : 'dall-e-3')
|
||
if (!imgKey) throw new Error('未配置 API Key，无法生成图片。')
|
||
const url = imgBase + '/images/generations'
|
||
const body: Record<string, unknown> = {
|
||
model: imgModel,
|
||
prompt: opts.prompt,
|
||
n: 1,
|
||
size: '1024x1024'
|
||
}
|
||
// 智谱 CogView 不支持 response_format 参数（会报错），仅对 OpenAI 兼容网关传 b64_json
|
||
if (!imgBase.includes('bigmodel.cn')) body.response_format = 'b64_json'
|
||
let resp: Response
|
||
try {
|
||
resp = await fetch(url, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + imgKey },
|
||
body: JSON.stringify(body),
|
||
signal: opts.signal
|
||
})
|
||
} catch (e: any) {
|
||
if (e.name === 'AbortError') throw e
|
||
throw new Error('图片生成请求失败（可能是 CORS）。\n' + e.message)
|
||
}
|
||
if (!resp.ok) {
|
||
let t = ''; try { t = await resp.text() } catch (e) {}
|
||
throw new Error('图片生成失败 ' + resp.status + '：' + t.slice(0, 200))
|
||
}
|
||
const json = await resp.json()
|
||
const item = json.data && json.data[0]
|
||
if (!item) throw new Error('图片生成返回为空。')
|
||
const dataUrl = item.b64_json
|
||
? 'data:image/png;base64,' + item.b64_json
|
||
: (item.url || '')
|
||
if (!dataUrl) throw new Error('图片生成返回无图像数据。')
|
||
// 返回的是临时 URL 而非 base64：链接会过期导致日后裂图，先抓回本地存 data URL
|
||
if (/^https?:/i.test(dataUrl)) {
|
||
try {
|
||
const imgResp = await fetch(dataUrl, { signal: opts.signal })
|
||
if (imgResp.ok) {
|
||
const blob = await imgResp.blob()
|
||
const b64 = await new Promise<string>((resolve, reject) => {
|
||
const r = new FileReader()
|
||
r.onload = () => resolve(r.result as string)
|
||
r.onerror = () => reject(r.error)
|
||
r.readAsDataURL(blob)
|
||
})
|
||
return { url: b64, revisedPrompt: item.revised_prompt }
|
||
}
|
||
} catch (e: any) {
|
||
if (e?.name === 'AbortError') throw e
|
||
// 抓取失败（常见为 CORS）——退回原 URL，仍可显示但有过期风险
|
||
}
|
||
}
|
||
return { url: dataUrl, revisedPrompt: item.revised_prompt }
|
||
}
|
||
|
||
/** 判断是否配置了图像生成能力（当前以主 Key 是否存在为信号） */
|
||
export function isImageConfigured(): boolean {
|
||
const cfg = store.getCfg()
|
||
return !!(cfg.imgKey || cfg.key)
|
||
}
|
||
|
||
/** 检查写入图片后是否超 localStorage 上限（约 5MB 字符），返回错误文案或 null */
|
||
export function checkImageQuota(dataUrl: string): string | null {
|
||
const QUOTA_CHARS = 4_500_000
|
||
let deckChars = 0
|
||
try { deckChars = JSON.stringify(store.getDeck()).length } catch (e) { /* ignore */ }
|
||
if (deckChars + dataUrl.length > QUOTA_CHARS) {
|
||
return '图片写入后将超本地存储上限（约 5MB），已取消。请删除部分旧图，或导出 JSON 备份后清理文库'
|
||
}
|
||
return null
|
||
}
|
||
|
||
/* ---------- 4. AI 主题/配色建议 ---------- */
|
||
|
||
export async function suggestTheme(opts: { topic: string; signal?: AbortSignal }): Promise<ThemeSuggestion> {
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_THEME },
|
||
{ role: 'user', content: '主题关键词：' + opts.topic + '\n请推荐一套配色，并说明设计理由（一句话）。' }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 未返回有效配色方案。')
|
||
const j = r.json
|
||
// 基本校验，非法 hex 回退中性灰
|
||
const safeHex = (v: string, dflt: string) => /^#[0-9a-f]{6}$/i.test(v) ? v : dflt
|
||
return {
|
||
name: String(j.name || '自定义').slice(0, 20),
|
||
primary: safeHex(j.primary, '#4f46e5'),
|
||
accent: safeHex(j.accent, '#06b6d4'),
|
||
bg: safeHex(j.bg, '#ffffff'),
|
||
panel: safeHex(j.panel, '#f8fafc'),
|
||
text: safeHex(j.text, '#1e293b'),
|
||
muted: safeHex(j.muted, '#64748b'),
|
||
recommendBg: j.recommendBg || 'g-primary',
|
||
reason: j.reason ? String(j.reason).slice(0, 200) : undefined
|
||
}
|
||
}
|
||
|
||
/* ---------- 5. 一键美化单页（排版优化，内容不变） ---------- */
|
||
|
||
export async function beautifyPage(opts: { slide: Slide; signal?: AbortSignal }): Promise<{ slide: Slide; note: string }> {
|
||
const messages: Message[] = [
|
||
{ role: 'system', content: SYS_BEAUTIFY },
|
||
{ role: 'user', content: '当前页 JSON：\n' + JSON.stringify(opts.slide) }
|
||
]
|
||
const r = await streamChat(messages, { jsonMode: true, signal: opts.signal })
|
||
if (!r.json) throw new Error('AI 未返回有效页面。')
|
||
const slides = normSlides([r.json])
|
||
if (!slides.length) throw new Error('AI 输出无法解析。')
|
||
return { slide: slides[0], note: r.json.note || '' }
|
||
}
|
||
|
||
/** 导出 ChartItem 类型供组件用 */
|
||
export type { ChartItem, Outline, OutlineItem, ThemeSuggestion, ImageGenResult }
|