Text Generation
Transformers
Chinese
English
character-level
chinese
gru
mamba
Mixture of Experts
titans
Instructions to use masterofthestars/tianxuan with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use masterofthestars/tianxuan with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="masterofthestars/tianxuan")# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("masterofthestars/tianxuan", device_map="auto") - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use masterofthestars/tianxuan with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "masterofthestars/tianxuan" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "masterofthestars/tianxuan", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'Use Docker
docker model run hf.co/masterofthestars/tianxuan
- SGLang
How to use masterofthestars/tianxuan with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "masterofthestars/tianxuan" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "masterofthestars/tianxuan", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "masterofthestars/tianxuan" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "masterofthestars/tianxuan", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }' - Docker Model Runner
How to use masterofthestars/tianxuan with Docker Model Runner:
docker model run hf.co/masterofthestars/tianxuan
Tianxuan: full project + data (checkpoints, world_model, data without raw) with correct directory structure
db7bc06 Download src/server/session-engine.ts from masterofthestars/tianxuan: direct link, hf CLI and curl.
- Browser
- Download file 19.4 kB
-
https://huggingface.co/masterofthestars/tianxuan/resolve/main/src/server/session-engine.ts
- Command line
-
hf download hf://masterofthestars/tianxuan/src/server/session-engine.ts
-
curl -L -o session-engine.ts https://huggingface.co/masterofthestars/tianxuan/resolve/main/src/server/session-engine.ts
19.4 kB
| import { Engine, GenerateOptions, GenerateResult, CharRoute } from "../ml/engine"; | |
| import type { GRUState } from "../ml/engine"; | |
| import { createStation } from "../station"; | |
| import { Task, TaskResult } from "../station/types"; | |
| import { chunkText } from "../ml/data"; | |
| import { reflect } from "../ml/reflection"; | |
| import { mulberry32 } from "../ml/rng"; | |
| import { ContextWindow } from "../ml/tool_system"; | |
| import { ConfidenceFloors } from "../ml/floors"; | |
| import { TitansMemory } from "../ml/titans"; | |
| import { L0Consistency } from "../station/l0probe"; | |
| // SessionState holds all mutable state per session | |
| interface SessionState { | |
| // Core generation state | |
| state: GRUState; | |
| recentChars: string[]; | |
| memory: Map<string, string>; | |
| titansMem: TitansMemory; | |
| floors: ConfidenceFloors; | |
| l0Probe: L0Consistency; | |
| ctxWinWindow: ContextWindow; | |
| habit: () => number; | |
| options: { temperature: number; topK: number }; | |
| ctxWin: number[]; | |
| } | |
| /** | |
| * SessionEngine - 每个会话独立的引擎实例 | |
| * 包装一个共享的 Engine 实例(只读部分),维护每个会话自己的 mutable state | |
| * 解决并发请求共享可变引擎状态问题 | |
| * | |
| * [P0-1 修复 2026-10-13 第一性审核] 原实现存在 9 处编译断裂: | |
| * 1. import GRUState 自 engine (未导出) → 现 engine 已 re-export | |
| * 2. import BeautyOfWords/Characterizer 自不存在的 ../ml/beauty_of_words / characterizer → 删 (死引用) | |
| * 3. import TitansMemoryConfig (titans.ts 只导出 TitansConfig) → 现 titans.ts 补别名 | |
| * 4. import { l0Probe } (l0probe 模块无实例导出) → 现 l0probe 补共享实例; 会话侧用 per-session L0Consistency | |
| * 5. class 字段在 baseEngine 之前初始化 (TS2729) → 现改 getter 延迟读取 | |
| * 6. 直接访问 Engine 私有成员 (store/cnStore/mathStore/worldModel/bigramStats/resetSpike) → 现走公开 getter / multiNeuro 直调 | |
| * 7. advance(id, advDepth, ss) 参数顺序错 (签名 advance(chId, ss, depth)) → 现 advance(id, ss, advDepth) | |
| * 8. routes 类型与 CharRoute.memorySource 窄化不符 → 现直用 CharRoute[] | |
| * 9. baseEngine.resetSpike 私有 → 现 baseEngine.multiNeuro?.resetSpikeSeq() 直调 | |
| * | |
| * [P0-2 修复 2026-10-13] 会话工作站单元注入: | |
| * 旧实现会话 station 只有 SEED 种子 (text 链零单元) → executor 恒「零单元」分支, | |
| * MoD 路由/审计/经济性在服务器路径死代码 (真实输出全来自 peekLogits(4) 兜底, 审计恒 depth=0)。 | |
| * 现构造时 baseEngine.registerUnitsTo(station.registry, station.economics), | |
| * 把与共享 Engine 完全相同的计算单元 (gru/mamba/attn/cnn/snn/titans/world/vision/speech/output) | |
| * 注入会话工作站 → 服务器路径多神经协同真跑 (宪章第1/2条)。 | |
| * 会话黑板键: 带 task.id (= `${i}:${ctxFp}`) 与 mem:${ctxFp}, 每会话独立编号+上下文指纹, 无串读。 | |
| */ | |
| export class SessionEngine { | |
| /** 会话 ID */ | |
| public readonly sessionId: string; | |
| /** | |
| * [P0-1 修复 2026-10-13] 每会话专用 Station — 旧实现为类字段初始化器 | |
| * `station = createStation()` (TS 字段初始化器在 baseEngine 参数赋值前执行, | |
| * 且与旧字段 `model = this.baseEngine.model` 同列, 构造即崩溃 "reading 'model' of undefined")。 | |
| * 现改延迟 getter: 首次访问时创建, 构造时 registerUnitsTo 注入共享引擎单元。 | |
| */ | |
| private _station: import("../station").Station | null = null; | |
| public get station(): import("../station").Station { | |
| if (!this._station) this._station = createStation(); | |
| return this._station; | |
| } | |
| /** 每会话可变状态 */ | |
| private sessionState: SessionState; | |
| // [P0-1] 共享只读资源改 getter 延迟读取 (旧 class 字段在 baseEngine 之前初始化 → TS2729) | |
| private get model() { return this.baseEngine.model; } | |
| private get tokenizer() { return this.baseEngine.tokenizer; } | |
| private get bigramStats() { return this.baseEngine.bigramStatsGetter; } | |
| constructor(private baseEngine: Engine, sessionId: string) { | |
| this.sessionId = sessionId; | |
| // [P0-2] 注入工作站单元 (titans/gru/mamba/attn/cnn/snn/world/vision/speech/output + 经济学上界) | |
| this.baseEngine.registerUnitsTo(this.station.registry, this.station.economics); | |
| this.sessionState = this.createFreshState(); | |
| } | |
| private createFreshState(): SessionState { | |
| const cfg = this.model.cfg; | |
| return { | |
| state: this.model.newState(), | |
| recentChars: [], | |
| memory: new Map(), | |
| titansMem: new TitansMemory({ dim: cfg.emb, slots: 256 }), | |
| floors: new ConfidenceFloors(), | |
| l0Probe: new L0Consistency(), | |
| ctxWinWindow: new ContextWindow(cfg.ctx * 10), | |
| habit: mulberry32(Date.now() % 2147483647), | |
| options: { temperature: 0.1, topK: 3 }, | |
| ctxWin: [], | |
| }; | |
| } | |
| /** 重置会话状态(用于超时清理) */ | |
| reset(): void { | |
| this.sessionState = this.createFreshState(); | |
| } | |
| // ==================== 核心生成逻辑 - 复制 Engine.generate 并适配 per-session ==================== | |
| async generate(opts: GenerateOptions): Promise<GenerateResult> { | |
| const { prompt, maxLen, budget } = opts; | |
| const ss = this.sessionState; | |
| // 重置探针、选项 | |
| ss.l0Probe.reset(); | |
| ss.options = { temperature: opts.temperature, topK: opts.topK }; | |
| if (opts.seed !== undefined) ss.habit = mulberry32(opts.seed); | |
| // 重置状态 | |
| ss.state = this.model.newState(); | |
| // SNN 膜电位重置(如果有) | |
| // [P0-1] baseEngine.resetSpike 为私有 → 直接走 multiNeuro.resetSpikeSeq | |
| const spike = this.baseEngine.multiNeuro?.spike; | |
| if (spike) { | |
| this.baseEngine.multiNeuro!.resetSpikeSeq(); | |
| this.baseEngine.multiNeuro!.setSpikeInferenceMode(true); | |
| } | |
| const promptIds = this.tokenizer.encode(prompt); | |
| for (const id of promptIds) this.advance(id, ss); | |
| ss.ctxWin = promptIds.slice(-this.model.cfg.ctx); | |
| const routes: CharRoute[] = []; | |
| let text = prompt; | |
| for (let i = 0; i < maxLen; i++) { | |
| const ctx = ss.ctxWin.slice(); | |
| const ctxFp = SessionEngine.ctxFingerprint(ctx, this.model.cfg.vocabSize); | |
| const task: Task = { id: `${i}:${ctxFp}`, type: "text", input: ctx, complexity: Math.min(1, 0.4 + (i / Math.max(maxLen, 1)) * 0.4), budget }; | |
| // [P0-2] 会话侧召回: 重复缓存 (会话内) + 共享向量库 (只读) — 与 Engine.recallAt 同契约, | |
| // 命中写 mem:${ctxFp} → 会话 executor L0 分支真触发 (旧会话 recallAt 只查内存缓存, 向量库召回缺失) | |
| const recalled = this.recallAt(ctx, ss); | |
| if (recalled) this.station.blackboard.write(`mem:${ctxFp}`, recalled.char); | |
| ss.l0Probe.noteTask(); | |
| if (recalled) { | |
| const deep = this.deepTop1At(ss); | |
| ss.l0Probe.record({ | |
| ctxPreview: this.tokenizer.decode(ctx).slice(-4), | |
| chL0: recalled.char, | |
| chDeep: deep.char, | |
| deepP: deep.p, | |
| source: recalled.source, | |
| }); | |
| } | |
| // L0 记忆直出 / 深链路由 — 会话 executor 真跑 (P0-2 注入单元后) | |
| let ch = ""; | |
| let memoryHit = false; | |
| const res: TaskResult = await this.station.executor.execute(task); | |
| memoryHit = res.memoryHit ?? false; | |
| if (res.memoryHit && res.depth === 0 && res.output !== undefined && res.output !== "") { | |
| ch = String(res.output); | |
| const hitId = this.tokenizer.idOf(ch); | |
| if (hitId !== undefined) { | |
| this.advance(hitId, ss); | |
| ss.ctxWin.push(hitId); | |
| ss.ctxWin = ss.ctxWin.slice(-this.model.cfg.ctx); | |
| ss.ctxWinWindow.add({ type: "char", char: ch, id: hitId }, 1); | |
| ss.titansMem.write(Float64Array.from(this.model.embedAvg(ctx)), ch); | |
| } | |
| } | |
| if (ch === "" && res.depth > 0) { | |
| const zLogits = this.station.blackboard.read(`z:logits:${task.id}`) as Float64Array | undefined; | |
| if (zLogits) { | |
| const spikeLogits = this.station.blackboard.read(`z:spike:${task.id}`) as Float64Array | undefined; | |
| if (spikeLogits && spikeLogits.length === zLogits.length) { | |
| for (let k = 0; k < zLogits.length; k++) zLogits[k] += spikeLogits[k]; | |
| } | |
| const probs = this.model.logitsToProbs(zLogits); | |
| ch = this.tokenizer.charOf(this.sampleToken(this.penalized(probs), ss.options.topK, ss.options.temperature, ss.habit)); | |
| } | |
| } | |
| if (ch === "") { | |
| const fallbackLogits = this.peekLogits(4, ss); | |
| const probs = this.model.logitsToProbs(fallbackLogits); | |
| ch = this.tokenizer.charOf(this.sampleToken(this.penalized(probs), ss.options.topK, ss.options.temperature, ss.habit)); | |
| } | |
| // 路由深度 → 真实状态推进深度 (MoD 算力与路由结果挂钩, 同 Engine.generate P0-D 纪律) | |
| const advDepth = (res.depth >= 1 && res.depth <= 4 ? res.depth : 4) as 1 | 2 | 3 | 4; | |
| // 语义反思层 | |
| const reflection = reflect(ch, text, { | |
| minSentenceLen: 8, | |
| maxSentenceLen: 30, | |
| maxRepeatCount: 2, | |
| bigramThreshold: 0.001, | |
| punctWeight: 5.0, | |
| enabled: true, | |
| }, this.bigramStats ?? undefined); | |
| if (reflection.action === 'force_end') { | |
| ch = '。'; | |
| } else if (reflection.action === 'reject') { | |
| ch = reflection.char; | |
| } | |
| const id = this.tokenizer.idOf(ch); | |
| if (id !== undefined) { | |
| // [P0-1] 旧 advance(id, advDepth, ss) 参数顺序错 → advance(chId, ss, depth) | |
| this.advance(id, ss, advDepth); | |
| ss.ctxWin.push(id); | |
| ss.ctxWin = ss.ctxWin.slice(-this.model.cfg.ctx); | |
| ss.ctxWinWindow.add({ type: "char", char: ch, id }, 1); | |
| ss.titansMem.write(Float64Array.from(this.model.embedAvg(ctx)), ch); | |
| } | |
| // [P0-1] routes 直用 CharRoute[] (旧自定义类型 memorySource: string 与窄化联合不符) | |
| routes.push({ | |
| char: ch, | |
| depth: res.depth, | |
| confidence: res.confidence, | |
| units: res.units, | |
| memoryHit, | |
| memorySource: recalled?.source, | |
| }); | |
| this.propose(ch, ss); | |
| text += ch; | |
| if (!memoryHit && id !== undefined) ss.memory.set(ctx.join(","), ch); | |
| if (ss.memory.size > 600) { | |
| const first = ss.memory.keys().next().value; | |
| if (first !== undefined) ss.memory.delete(first); | |
| } | |
| } | |
| // 记住生成内容 - 写入到共享向量库 (带 session 前缀防自举循环; 宪章第10条: 共享库只写本会话命名空间) | |
| const sharedStore = this.baseEngine.vectorStore; | |
| if (sharedStore) { | |
| this.remember(text.substring(prompt.length)); | |
| } | |
| // SNN 膜电位恢复 (生成结束) | |
| if (spike) { | |
| this.baseEngine.multiNeuro!.setSpikeInferenceMode(false); | |
| } | |
| // 写入探针和经济性 (会话各自 30s 写盘节律) | |
| this.station.probe.writeToFile(); | |
| this.station.economics.report(); | |
| return { text, routes, budget }; | |
| } | |
| // ==================== 辅助方法 ==================== | |
| private peekLogits(depth: 1 | 2 | 3 | 4, ss: SessionState): Float64Array { | |
| const lastId = ss.ctxWin.length > 0 ? ss.ctxWin[ss.ctxWin.length - 1] : 0; | |
| const copy: GRUState = { | |
| h1: ss.state.h1.slice(), | |
| h2: ss.state.h2.slice(), | |
| hist: ss.state.hist.map((h) => h.slice()), | |
| ids: [...ss.state.ids], | |
| }; | |
| return this.model.step(lastId, copy, depth); | |
| } | |
| private advance(chId: number, ss: SessionState, depth: 1 | 2 | 3 | 4 = 4): void { | |
| this.model.step(chId, ss.state, depth); | |
| if (this.baseEngine.multiNeuro?.spike) { | |
| this.baseEngine.multiNeuro.spikeAdvance(chId); | |
| } | |
| } | |
| private sampleToken(probs: Float64Array, topK: number, temperature: number, rand: () => number): number { | |
| for (let i = 0; i < probs.length; i++) if (Number.isNaN(probs[i])) return -1; | |
| const v = probs.length; | |
| const scaled = new Float64Array(v); | |
| let sum = 0; | |
| for (let k = 0; k < v; k++) { | |
| scaled[k] = Math.exp(Math.log(probs[k] + 1e-12) / Math.max(temperature, 1e-3)); | |
| sum += scaled[k]; | |
| } | |
| const k = Math.min(topK, v); | |
| const idxs = Array.from({ length: v }, (_, i) => i).sort((a, b) => scaled[b] - scaled[a]).slice(0, k); | |
| let mass = 0; | |
| for (const i of idxs) mass += scaled[i]; | |
| let r = rand() * mass; | |
| for (const i of idxs) { | |
| r -= scaled[i]; | |
| if (r <= 0) return i; | |
| } | |
| return idxs[idxs.length - 1]; | |
| } | |
| private penalized(probs: Float64Array): Float64Array { | |
| const out = probs.slice(); | |
| out[out.length - 1] = 0; | |
| const freq = new Map<string, number>(); | |
| for (const ch of this.sessionState.recentChars) freq.set(ch, (freq.get(ch) ?? 0) + 1); | |
| for (const [ch, count] of freq) { | |
| if (count < 2) continue; | |
| const id = this.tokenizer.idOf(ch); | |
| if (id !== undefined && id < out.length) out[id] = 0; | |
| } | |
| let sum = 0; | |
| for (let i = 0; i < out.length; i++) sum += out[i]; | |
| for (let i = 0; i < out.length; i++) out[i] /= sum; | |
| return out; | |
| } | |
| private propose(ch: string, ss: SessionState): void { | |
| ss.recentChars.push(ch); | |
| if (ss.recentChars.length > 16) ss.recentChars.shift(); | |
| } | |
| private isDegenerate(ch: string): boolean { | |
| const n = this.sessionState.recentChars.length; | |
| if (n >= 3) { | |
| const last3 = this.sessionState.recentChars.slice(-3).join(""); | |
| if (last3 === ch.repeat(3)) return true; | |
| } | |
| if (n >= 16) { | |
| const a = this.sessionState.recentChars.slice(-8).join(""); | |
| const b = this.sessionState.recentChars.slice(-16, -8).join(""); | |
| if (a === b) return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * [P0-2] 会话侧召回: 重复缓存 (会话内) + 共享向量库 (只读, MEMORY_TAG 前缀隔离防自举)。 | |
| * 命中写点火标记 z:l0:act → 会话 executor L0 分支读 z:l0:act 推导置信度 (与 Engine.recallAt 同契约)。 | |
| */ | |
| private recallAt(ctxIds: number[], ss: SessionState): { char: string; source: "vector" | "repeat" | "titans" } | null { | |
| const cached = ss.memory.get(ctxIds.join(",")); | |
| if (cached !== undefined && !this.isDegenerate(cached)) { | |
| this.station.blackboard.write("z:l0:act", 0.5); | |
| return { char: cached, source: "repeat" }; | |
| } | |
| // 共享向量库召回 (只读; MEMORY_TAG + session 前缀 → 检索跳过防自举循环) | |
| const store = this.baseEngine.vectorStore; | |
| if (store) { | |
| const q = this.tokenizer.decode(ctxIds); | |
| const hits = store.search(this.model.embedAvg(ctxIds), 8); | |
| for (const hit of hits) { | |
| if (hit.text.startsWith("\uE000")) continue; | |
| const at = hit.text.indexOf(q); | |
| if (at >= 0 && at + q.length < hit.text.length) { | |
| const ch = hit.text[at + q.length]; | |
| if (!this.isDegenerate(ch)) { | |
| this.station.blackboard.write("z:l0:act", 0.5); | |
| return { char: ch, source: "vector" }; | |
| } | |
| } | |
| } | |
| } | |
| // 会话内 Titans 在线记忆召回 (与 Engine.recallAt 第三路同机制) | |
| const q = Float64Array.from(this.model.embedAvg(ctxIds)); | |
| const cache = { query: new Float64Array(0), keys: new Float64Array(0), values: new Float64Array(0), weights: new Float64Array(0) }; | |
| const mem = ss.titansMem.read(q, cache); | |
| if (mem.hitSlots > 0 && cache.weights.length > 0) { | |
| let best = 0; | |
| for (let i = 1; i < cache.weights.length; i++) if (cache.weights[i] > cache.weights[best]) best = i; | |
| if (cache.weights[best] > 0.5) { | |
| const ch = ss.titansMem.chars[best % ss.titansMem.cfg.slots]; | |
| if (ch !== undefined && ch !== "" && !this.isDegenerate(ch)) { | |
| const l0Act = mem.hitSlots / ss.titansMem.cfg.slots; | |
| this.station.blackboard.write("z:l0:act", l0Act); | |
| return { char: ch, source: "repeat" }; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| private deepTop1At(ss: SessionState): { char: string; p: number } { | |
| const logits = this.peekLogits(4, ss); | |
| const probs = this.model.logitsToProbs(logits); | |
| let best = 0; | |
| for (let i = 1; i < probs.length; i++) if (probs[i] > probs[best]) best = i; | |
| return { char: this.tokenizer.charOf(best), p: probs[best] }; | |
| } | |
| private remember(text: string): void { | |
| const store = this.baseEngine.vectorStore; | |
| if (!store) return; | |
| for (const chunk of chunkText(text, 64, 32)) { | |
| if (chunk.length < 8) continue; | |
| const ids = this.tokenizer.encode(chunk); | |
| // [P0-1] 向量库 add 接受 number[] (vectorstore.ts 签名); multiNeuro 在则用其 embedAvg, 否则空向量占位 | |
| const vec: number[] = this.baseEngine.multiNeuro | |
| ? this.baseEngine.multiNeuro.embedAvg(ids) | |
| : []; | |
| store.add(`\uE000${this.sessionId}:${chunk}`, vec); | |
| } | |
| } | |
| // 静态工具方法 | |
| static ctxFingerprint(ctx: number[], vocabSize: number): string { | |
| let h = 2166136261; | |
| for (let i = 0; i < ctx.length; i++) { | |
| h ^= ctx[i] % vocabSize; | |
| h = Math.imul(h, 16777619); | |
| } | |
| return (h >>> 0).toString(16).padStart(8, "0"); | |
| } | |
| // ==================== 查询方法 (透传共享引擎) ==================== | |
| retrieve(q: string, k = 4): Array<{ text: string; score: number }> { | |
| return this.baseEngine.retrieve(q, k); | |
| } | |
| retrieveCN(q: string, k = 4, category?: string): Array<{ text: string; score: number; category?: string }> { | |
| return this.baseEngine.retrieveCN(q, k, category); | |
| } | |
| retrieveMath(q: string, k = 6, category?: string): Array<{ expr: string; description: string; score: number; matchType: string }> { | |
| return this.baseEngine.retrieveMath(q, k, category); | |
| } | |
| reason(q: string) { | |
| return this.baseEngine.reason(q); | |
| } | |
| retrieveCount(): number { | |
| return this.baseEngine.retrieveCount(); | |
| } | |
| totalParamCount(): number { | |
| return this.baseEngine.totalParamCount(); | |
| } | |
| } | |
| /** 会话管理器:管理多个 SessionEngine,处理会话生命周期和队列 */ | |
| export class SessionManager { | |
| private sessions = new Map<string, SessionEngine>(); | |
| private static readonly SESSION_TIMEOUT = 30 * 60 * 1000; // 30 分钟 | |
| private cleanupTimer: NodeJS.Timeout | null = null; | |
| constructor(private defaultEngine: Engine) {} | |
| getSession(sessId?: string): SessionEngine { | |
| if (!sessId) sessId = this.generateSessionId(); | |
| let session = this.sessions.get(sessId); | |
| if (!session) { | |
| session = new SessionEngine(this.defaultEngine, sessId); | |
| this.sessions.set(sessId, session); | |
| this.startCleanup(); | |
| } | |
| return session; | |
| } | |
| endSession(sessId: string): void { | |
| const session = this.sessions.get(sessId); | |
| if (!session) return; | |
| session.reset(); | |
| this.sessions.delete(sessId); | |
| if (this.sessions.size === 0 && this.cleanupTimer) { | |
| clearInterval(this.cleanupTimer); | |
| this.cleanupTimer = null; | |
| } | |
| } | |
| /** [P0-1] 旧 private 但 server/index.ts /api/session 直接调用 → 放宽为 public */ | |
| generateSessionId(): string { | |
| return "session-" + Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15); | |
| } | |
| private startCleanup(): void { | |
| if (this.cleanupTimer) return; | |
| this.cleanupTimer = setInterval(() => this.cleanupStale(), SessionManager.SESSION_TIMEOUT / 2); | |
| } | |
| private cleanupStale(): void { | |
| for (const id of this.sessions.keys()) { | |
| this.endSession(id); | |
| } | |
| } | |
| getStats(): { active: number; totalParams: number } { | |
| return { active: this.sessions.size, totalParams: this.defaultEngine.totalParamCount() }; | |
| } | |
| } | |