@danceiny/gotry 0.0.1-rc.7 → 0.0.1-rc.9

package/dist/src/loop.js

@@ -228,6 +228,26 @@ export async function runTurn(state, userMsg, llm, history = [], solve = null) {
         } else {
             const invalid = spec ? validateSpec(spec) : '翻译器未产出 spec';
             if (spec && !invalid) {
+                const ext = await llm.extractSlots([
+                    ...history,
+                    {
+                        role: 'user',
+                        text: userMsg
+                    }
+                ]);
+                if (ext) {
+                    const { resolveSlots, specDateMismatches } = await import('./slot-spec.js');
+                    const { buildTimeAnchor } = await import('./time-anchor.js');
+                    const mismatches = specDateMismatches(spec, resolveSlots(ext, buildTimeAnchor()));
+                    if (mismatches.length > 0) {
+                        const lines = mismatches.map((m)=>`- ${m.specAt}:翻译说 ${m.specDate},你的原话换算是 ${m.slotDate}(${m.field})`);
+                        parts.push(`⚠️ 日期分歧,确认后我再算(以你为准):\n${lines.join('\n')}`);
+                        return {
+                            reply: parts.join('\n\n'),
+                            state
+                        };
+                    }
+                }
                 state.spec = spec;
                 state.solve = await solve(spec);
                 parts.push(llm.render ? await llm.render(state) : renderSolve(state));
@@ -244,50 +264,94 @@ export async function runTurn(state, userMsg, llm, history = [], solve = null) {
     };
 }
 import { join } from 'node:path';
-import { mkdir } from 'node:fs/promises';
-import { readFile, writeFile } from 'node:fs/promises';
-const ASYNC_DIR = 'gotry-state/async';
-async function asyncPath(name) {
-    await mkdir(ASYNC_DIR, {
+import { mkdir, rename, writeFile, readFile } from 'node:fs/promises';
+import { ensureLedger, openLedgerIfExists } from './state-ledger.js';
+async function asyncDir(stateRoot) {
+    const root = stateRoot === '.' ? process.cwd() : stateRoot;
+    const dir = join(root, 'gotry-state', 'async');
+    await mkdir(dir, {
         recursive: true
     });
-    return join(ASYNC_DIR, name);
+    return dir;
+}
+async function atomicWrite(path, text) {
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, text, 'utf-8');
+    await rename(tmp, path);
 }
-export async function persistAsyncTicket(ticket, state) {
-    const p = await asyncPath(`${ticket.id}.json`);
-    await writeFile(p, JSON.stringify({
+export async function persistAsyncTicket(ticket, state, stateRoot = '.') {
+    const ledger = ensureLedger(stateRoot);
+    ledger.createWorkflowRun({
+        id: ticket.id,
+        goal: ticket.objective,
+        ticket,
+        state
+    });
+    const dir = await asyncDir(stateRoot);
+    const p = join(dir, `${ticket.id}.json`);
+    await atomicWrite(p, JSON.stringify({
         ticket,
         state
-    }, null, 2), 'utf-8');
+    }, null, 2));
     return p;
 }
-export async function loadAsyncTicket(ticketId) {
+export async function loadAsyncTicket(ticketId, stateRoot = '.') {
+    const ledger = openLedgerIfExists(stateRoot);
+    const run = ledger?.getWorkflowRun(ticketId);
+    if (run) {
+        return {
+            ticket: JSON.parse(run.ticket_json),
+            state: JSON.parse(run.state_json)
+        };
+    }
     try {
-        const p = await asyncPath(`${ticketId}.json`);
+        const p = join(await asyncDir(stateRoot), `${ticketId}.json`);
         return JSON.parse(await readFile(p, 'utf-8'));
     } catch  {
         return null;
     }
 }
-export async function settleAsyncTicket(ticketId, reply) {
-    const p = await asyncPath(`${ticketId}.deliverable.md`);
-    await writeFile(p, reply, 'utf-8');
+export async function settleAsyncTicket(ticketId, reply, stateRoot = '.') {
+    openLedgerIfExists(stateRoot)?.settleWorkflowRun(ticketId, reply);
+    const dir = await asyncDir(stateRoot);
+    const p = join(dir, `${ticketId}.deliverable.md`);
+    await atomicWrite(p, reply);
     return p;
 }
+export function makeJournaledSolvePort(ledger, runId, solve, opts) {
+    return async (spec)=>{
+        const step = ledger.getWorkflowStep(runId, 'solve');
+        if (step?.status === 'done' && step.result) {
+            return JSON.parse(step.result);
+        }
+        ledger.markStepIntent(runId, 'solve');
+        opts?.onRealSolve?.();
+        const r = await solve(spec);
+        ledger.markStepDone(runId, 'solve', r);
+        return r;
+    };
+}
 export function probePoi(msg) {
     const trimmed = msg.trim();
     if (!trimmed) return null;
-    const isShort = trimmed.length <= 24 && !/[?？!！。.,，]/.test(trimmed);
-    if (isShort) {
-        const stripped = trimmed.replace(/^(查一下|查|搜|找|看看|推荐|告诉我|检索)\s*/, '').trim();
-        if (stripped.length >= 2) return stripped.slice(0, 24);
-    }
+    const cutAtPunct = (s)=>s.split(/[,，。.;；!！?？]/)[0]?.trim() ?? '';
     const m = trimmed.match(/(查一下|查|搜|找|看看|推荐|告诉我|检索)\s*(.{2,24})/);
-    if (m) return m[2].trim().slice(0, 24);
-    if (/(酒店|民宿|客栈|饭店|有什么|玩什么|有哪些)/.test(trimmed)) {
-        const place = trimmed.match(/([一-龥a-zA-Z]{2,12})\s*(?:酒店|民宿|客栈|饭店|有什么|玩什么|有哪些)/);
-        if (place) return place[1];
-        return trimmed.replace(/(酒店|民宿|客栈|饭店|有什么|玩什么|有哪些)/, '').trim().slice(0, 24) || trimmed.slice(0, 24);
+    if (m?.[2]) {
+        const obj = cutAtPunct(m[2]);
+        if (obj.length >= 2) return obj.slice(0, 24);
+    }
+    if (/(酒店|民宿|客栈|饭店)/.test(trimmed)) {
+        const parts = trimmed.split(/(酒店|民宿|客栈|饭店)/);
+        const after = cutAtPunct((parts[2] ?? '').replace(/^[的:：\s]+/, ''));
+        if (after.length >= 2 && /[A-Za-z0-9]/.test(after)) return after.slice(0, 24);
+        const nounAt = trimmed.search(/(酒店|民宿|客栈|饭店)/);
+        const pre = trimmed.slice(Math.max(0, nounAt - 6), nounAt).match(/[一-龥]{2,6}$/);
+        if (pre && !/(机票|车票|和|做|订|的)$/.test(pre[0])) return pre[0];
+    }
+    const q = trimmed.match(/([一-龥a-zA-Z]{2,12})\s*(?:有什么|玩什么|有哪些)/);
+    if (q?.[1]) return q[1];
+    if (trimmed.length <= 12 && !/[,，。.;；!！?？:：]/.test(trimmed) && !/[是有在要想得到说订吧呢]/.test(trimmed)) {
+        return trimmed.slice(0, 24);
     }
     return null;
 }

package/dist/src/memory-capture.js

@@ -0,0 +1,40 @@
+export function mergeProfile(current, patch) {
+    if (!patch) return null;
+    const base = {
+        weights: current?.weights ?? {},
+        evidence: current?.evidence ?? [],
+        hard: current?.hard ?? {}
+    };
+    const newEvidence = (patch.evidence ?? []).filter(Boolean).filter((e)=>!base.evidence.includes(e));
+    const patchWeights = patch.weights;
+    const weightsChanged = !!patchWeights && Object.keys(patchWeights).length > 0 && JSON.stringify(patchWeights) !== JSON.stringify(base.weights);
+    const hardChanged = !!patch.hard && Object.keys(patch.hard).length > 0 && JSON.stringify(patch.hard) !== JSON.stringify(base.hard);
+    if (newEvidence.length === 0 && !weightsChanged && !hardChanged) return null;
+    let weights = {
+        ...base.weights
+    };
+    if (weightsChanged && newEvidence.length > 0 && patchWeights) {
+        weights = {
+            ...weights,
+            ...patchWeights
+        };
+        const sum = Object.values(weights).reduce((a, b)=>a + b, 0);
+        if (sum > 0) for (const k of Object.keys(weights))weights[k] = Math.round(weights[k] / sum * 100) / 100;
+    }
+    return {
+        weights,
+        evidence: [
+            ...base.evidence,
+            ...newEvidence
+        ],
+        hard: hardChanged ? {
+            ...base.hard,
+            ...patch.hard ?? {}
+        } : {
+            ...base.hard
+        }
+    };
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/src/memory-capture.ts

package/dist/src/memory-decay.js

@@ -0,0 +1,31 @@
+export function windowFactor(ageDays) {
+    if (ageDays <= 30) return 1.0;
+    if (ageDays <= 90) return 0.75;
+    if (ageDays <= 180) return 0.5;
+    if (ageDays <= 365) return 0.25;
+    return 0.1;
+}
+export const KIND_WEIGHT = {
+    recalled: 0.25,
+    applied: 0.5,
+    verified_outcome: 1.0
+};
+export function ageDaysOf(ts, now) {
+    const then = new Date(ts).getTime();
+    if (Number.isNaN(then)) return Number.POSITIVE_INFINITY;
+    return Math.max(0, (now.getTime() - then) / 86_400_000);
+}
+export function eventDecayScore(ev, now) {
+    const w = KIND_WEIGHT[ev.kind] ?? 0;
+    return round4(w * windowFactor(ageDaysOf(ev.ts, now)));
+}
+export function decayedConfidence(events, now) {
+    const sum = events.reduce((acc, ev)=>acc + eventDecayScore(ev, now), 0);
+    return round4(Math.min(1, sum));
+}
+function round4(x) {
+    return Math.round(x * 10_000) / 10_000;
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/src/memory-decay.ts

package/dist/src/memory-utility.js

@@ -0,0 +1,55 @@
+export function makeEventId(ev) {
+    return [
+        ev.wish_id,
+        ev.kind,
+        ev.ctx ?? '',
+        ev.attribution ?? ''
+    ].join('|');
+}
+export function appendEvent(events, ev) {
+    const full = {
+        schema: 'memory_utility_observation.v0',
+        event_id: makeEventId(ev),
+        ...ev
+    };
+    if (events.some((e)=>e.event_id === full.event_id)) return {
+        events,
+        appended: false
+    };
+    if (ev.kind === 'verified_outcome' && !ev.attribution) {
+        return appendEvent(events, {
+            ...ev,
+            kind: 'applied'
+        });
+    }
+    return {
+        events: [
+            ...events,
+            full
+        ],
+        appended: true
+    };
+}
+export function projectUtility(events) {
+    const out = {};
+    for (const ev of events){
+        const w = out[ev.wish_id] ??= {
+            wish_id: ev.wish_id,
+            status: 'unknown',
+            recalled: 0,
+            applied: 0,
+            verified: 0
+        };
+        if (ev.kind === 'recalled') w.recalled++;
+        if (ev.kind === 'applied') w.applied++;
+        if (ev.kind === 'verified_outcome') {
+            w.verified++;
+            if (ev.attribution) w.status = ev.attribution;
+        }
+        w.last_event_ts = ev.ts;
+    }
+    return out;
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/src/memory-utility.ts

package/dist/src/mock-llm.js

@@ -50,7 +50,7 @@ const SCRIPT = [
         }
     }
 ];
-export function createMockLlm(flightPackPath) {
+export function createMockLlm(flightPackPath, slotScript = []) {
     let stepIdx = 0;
     return {
         async extractFacts (history, _state) {
@@ -88,6 +88,11 @@ export function createMockLlm(flightPackPath) {
             spec.budgetCny = 9000;
             return spec;
         },
+        async extractSlots (history) {
+            const last = history[history.length - 1]?.text ?? '';
+            const hit = slotScript.find((s)=>last.includes(s.when));
+            return hit ? structuredClone(hit.extraction) : null;
+        },
         async polishQuestion (q) {
             return `【${q.key}】${q.text}\n(为什么问:${q.why})`;
         }

package/dist/src/slot-spec.js

@@ -0,0 +1,165 @@
+import { parseAbsoluteDate, ymd } from './time-anchor.js';
+const WEEKDAY_ZH = {
+    日: 0,
+    一: 1,
+    二: 2,
+    三: 3,
+    四: 4,
+    五: 5,
+    六: 6
+};
+function addDaysYmd(today, n) {
+    const [y, m, d] = today.split('-').map(Number);
+    return ymd(new Date(y, m - 1, d + n));
+}
+function splitPlusSuffix(expr) {
+    const m = expr.match(/^(.*?)\+(\d+)天?$/);
+    if (m && m[1]) return {
+        base: m[1],
+        plusDays: Number(m[2])
+    };
+    return {
+        base: expr,
+        plusDays: 0
+    };
+}
+function neighborDayOffset(expr) {
+    if (expr === '今天') return 0;
+    if (expr === '明天') return 1;
+    if (expr === '后天') return 2;
+    if (expr === '大后天') return 3;
+    return null;
+}
+function weekdayOffsetDays(expr, today) {
+    const m = expr.match(/^(本|下|下下)周([日一二三四五六])$/);
+    if (!m || !m[2]) return null;
+    const target = WEEKDAY_ZH[m[2]];
+    if (target === undefined) return null;
+    const [y, mm, d] = today.split('-').map(Number);
+    const todayMonOffset = (new Date(y, mm - 1, d).getDay() + 6) % 7;
+    const targetMonOffset = (target + 6) % 7;
+    const weekShift = m[1] === '本' ? 0 : m[1] === '下' ? 7 : 14;
+    return weekShift + targetMonOffset - todayMonOffset;
+}
+function monthFragmentDate(expr, today) {
+    if (![
+        '下个月初',
+        '下个月中旬',
+        '下个月下旬'
+    ].includes(expr)) return null;
+    const [y, m] = today.split('-').map(Number);
+    const day = expr === '下个月初' ? 1 : expr === '下个月中旬' ? 11 : 21;
+    return ymd(new Date(y, m, day));
+}
+export function resolveSlotDate(expr, anchor) {
+    const raw = expr.trim();
+    const year = Number(anchor.today.slice(0, 4));
+    const absolute = parseAbsoluteDate(raw, year);
+    if (absolute) return {
+        raw,
+        date: absolute,
+        kind: 'absolute'
+    };
+    const { base, plusDays } = splitPlusSuffix(raw);
+    const baseAbs = parseAbsoluteDate(base, year);
+    if (baseAbs) return {
+        raw,
+        date: addDaysYmd(baseAbs, plusDays),
+        kind: 'absolute'
+    };
+    const month = monthFragmentDate(base, anchor.today);
+    if (month) return {
+        raw,
+        date: addDaysYmd(month, plusDays),
+        kind: 'card'
+    };
+    const neighbor = neighborDayOffset(base);
+    if (neighbor !== null) return {
+        raw,
+        date: addDaysYmd(anchor.today, neighbor + plusDays),
+        kind: 'card'
+    };
+    const offset = weekdayOffsetDays(base, anchor.today);
+    if (offset !== null) return {
+        raw,
+        date: addDaysYmd(anchor.today, offset + plusDays),
+        kind: 'card'
+    };
+    return {
+        raw,
+        date: null,
+        kind: 'unresolved'
+    };
+}
+const DATE_FIELDS = {
+    requisition: [
+        'start_date',
+        'end_date'
+    ],
+    flight: [
+        'departure_date',
+        'return_date'
+    ],
+    hotel: [
+        'check_in_date',
+        'check_out_date'
+    ]
+};
+export function resolveSlots(ext, anchor) {
+    const out = {
+        unresolved: []
+    };
+    for (const domain of ext.domains){
+        const slots = ext.slots[domain];
+        if (!slots) continue;
+        for (const field of DATE_FIELDS[domain] ?? []){
+            const value = slots[field];
+            if (typeof value !== 'string') continue;
+            const res = resolveSlotDate(value, anchor);
+            const bucket = out[domain] ??= {};
+            bucket[field] = res;
+            if (res.kind === 'unresolved') out.unresolved.push({
+                field: `${domain}.${field}`,
+                raw: res.raw
+            });
+        }
+    }
+    return out;
+}
+export function specDateMismatches(spec, resolved) {
+    const mismatches = [];
+    const primary = [
+        {
+            field: 'requisition.start_date',
+            res: resolved.requisition?.start_date
+        },
+        {
+            field: 'flight.departure_date',
+            res: resolved.flight?.departure_date
+        },
+        {
+            field: 'hotel.check_in_date',
+            res: resolved.hotel?.check_in_date
+        }
+    ];
+    const dated = primary.filter((p)=>p.res?.date != null);
+    if (dated.length === 0) return mismatches;
+    const datedSegs = (spec.segments ?? []).filter((s)=>typeof s.date === 'string' && s.date);
+    if (datedSegs.length !== 1) return mismatches;
+    const seg = datedSegs[0];
+    const slotDates = new Set(dated.map((s)=>s.res.date));
+    if (!slotDates.has(seg.date)) {
+        mismatches.push({
+            specAt: `segments[${(spec.segments ?? []).indexOf(seg)}].date`,
+            field: dated.map((s)=>s.field).join('|'),
+            specDate: seg.date,
+            slotDate: [
+                ...slotDates
+            ].join('|')
+        });
+    }
+    return mismatches;
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/src/slot-spec.ts