@rikaidev/yomi 0.5.0 → 0.6.1

package/dist/work-item/line-adapter.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+function asBytes(bytes) {
+    if (!bytes)
+        return undefined;
+    return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+}
+function normalizeAttachment(input, messageId, index) {
+    const bytes = asBytes(input.bytes);
+    return {
+        id: String(input.id ?? `${messageId}:attachment:${index}`),
+        fileName: input.fileName ?? null,
+        mimeType: input.mimeType ?? input.mediaType ?? null,
+        byteLength: input.byteLength ?? input.size ?? bytes?.byteLength ?? null,
+        sha256: bytes ? createHash('sha256').update(bytes).digest('hex') : null,
+        ...(bytes ? { bytes } : {}),
+        ...(input.url || input.mediaUrl
+            ? { sourceUrl: input.url ?? input.mediaUrl ?? undefined }
+            : {}),
+    };
+}
+function messageAttachments(input, messageId) {
+    const values = [
+        ...(input.attachments ?? []),
+        ...(input.attachment ? [input.attachment] : []),
+    ];
+    if (values.length === 0 && (input.mediaUrl || input.fileName)) {
+        values.push({
+            fileName: input.fileName,
+            mediaType: input.mediaType,
+            mediaUrl: input.mediaUrl,
+        });
+    }
+    return values.map((item, index) => normalizeAttachment(item, messageId, index));
+}
+export function isLineWorkItemMessage(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        (typeof input.id === 'string' ||
+            typeof input.id === 'number'));
+}
+export class LineWorkItemAdapter {
+    id = 'line.message';
+    platform = 'line';
+    canNormalize(input) {
+        return (isLineWorkItemMessage(input) ||
+            (Array.isArray(input) && input.every(isLineWorkItemMessage)));
+    }
+    normalize(input) {
+        const inputs = Array.isArray(input) ? [...input] : [input];
+        if (inputs.length === 0)
+            throw new Error('LINE work item requires at least one message');
+        const normalized = inputs.map((message) => {
+            const messageId = String(message.id);
+            const conversationId = String(message.conversationId ?? message.chatId ?? '');
+            if (!conversationId)
+                throw new Error('LINE work item requires conversationId');
+            const sentAt = message.timestamp ?? Date.now();
+            const source = {
+                adapter: this.id,
+                platform: this.platform,
+                conversationId,
+                messageIds: [messageId],
+                latestMessageAt: sentAt,
+            };
+            return {
+                conversationId,
+                evidence: {
+                    source,
+                    sourceMessageId: messageId,
+                    senderId: message.senderId ?? message.fromMid ?? null,
+                    senderName: message.senderName ?? message.fromName ?? null,
+                    sentAt,
+                    text: message.text ?? message.content ?? null,
+                    attachments: messageAttachments(message, messageId),
+                },
+            };
+        });
+        const seen = new Set();
+        const evidence = normalized
+            .sort((a, b) => a.evidence.sentAt - b.evidence.sentAt ||
+            a.evidence.sourceMessageId.localeCompare(b.evidence.sourceMessageId))
+            .flatMap((message) => {
+            const key = `${message.conversationId}:${message.evidence.sourceMessageId}`;
+            if (seen.has(key))
+                return [];
+            seen.add(key);
+            return [message.evidence];
+        });
+        const sourceByConversation = new Map();
+        for (const item of evidence) {
+            const itemSource = item.source;
+            const existing = sourceByConversation.get(itemSource.conversationId);
+            if (existing) {
+                existing.messageIds.push(...itemSource.messageIds);
+                existing.latestMessageAt = Math.max(existing.latestMessageAt, itemSource.latestMessageAt);
+            }
+            else {
+                sourceByConversation.set(itemSource.conversationId, {
+                    ...itemSource,
+                    messageIds: [...itemSource.messageIds],
+                });
+            }
+        }
+        const sources = [...sourceByConversation.values()];
+        return {
+            source: sources[0],
+            sources,
+            evidence,
+        };
+    }
+}

package/dist/work-item/llama-cpp-work-event-adapter.js

@@ -0,0 +1,239 @@
+const ACTS = [
+    'inform',
+    'ask',
+    'answer',
+    'directive',
+    'commit',
+    'delegate',
+    'acknowledge',
+    'deliver',
+    'accept',
+    'reject',
+    'cancel',
+];
+const OWNER_STATES = ['unassigned', 'owned', 'delegated', 'unknown'];
+const PARTICIPANT_KINDS = [
+    'self',
+    'conversation_member',
+    'external_party',
+    'unknown',
+];
+const DEPENDENCIES = [
+    'none',
+    'waiting_person',
+    'waiting_external_system',
+    'waiting_decision',
+    'unknown',
+];
+const LIFECYCLES = [
+    'proposed',
+    'committed',
+    'in_progress',
+    'blocked',
+    'delivered',
+    'accepted',
+    'cancelled',
+    'resolved',
+    'uncertain',
+];
+const evidenceField = {
+    type: 'object',
+    required: ['confidence', 'evidenceMessageIds'],
+    properties: {
+        confidence: { type: 'number', minimum: 0, maximum: 1 },
+        evidenceMessageIds: { type: 'array', items: { type: 'string' } },
+    },
+};
+export const WORK_EVENT_GRAPH_JSON_SCHEMA = {
+    type: 'object',
+    required: ['dialogue', 'candidates'],
+    properties: {
+        dialogue: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['messageId', 'acts', 'confidence'],
+                properties: {
+                    messageId: { type: 'string' },
+                    acts: {
+                        type: 'array',
+                        minItems: 1,
+                        items: { type: 'string', enum: ACTS },
+                    },
+                    confidence: { type: 'number', minimum: 0, maximum: 1 },
+                },
+            },
+        },
+        candidates: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: [
+                    'candidateKey',
+                    'createsWork',
+                    'action',
+                    'ownership',
+                    'dependency',
+                    'lifecycle',
+                    'completion',
+                ],
+                properties: {
+                    candidateKey: { type: 'string' },
+                    createsWork: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: { type: 'boolean' },
+                        },
+                    },
+                    action: {
+                        anyOf: [
+                            { type: 'null' },
+                            {
+                                type: 'object',
+                                required: [
+                                    'predicate',
+                                    'object',
+                                    'expectedOutcome',
+                                    'dueAt',
+                                    'sourceMessageIds',
+                                    'confidence',
+                                ],
+                                properties: {
+                                    predicate: { type: 'string' },
+                                    object: { type: ['string', 'null'] },
+                                    expectedOutcome: { type: ['string', 'null'] },
+                                    dueAt: { type: ['number', 'null'] },
+                                    sourceMessageIds: {
+                                        type: 'array',
+                                        minItems: 1,
+                                        items: { type: 'string' },
+                                    },
+                                    confidence: { type: 'number', minimum: 0, maximum: 1 },
+                                },
+                            },
+                        ],
+                    },
+                    ownership: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: {
+                                type: 'object',
+                                required: ['state', 'owners'],
+                                properties: {
+                                    state: { type: 'string', enum: OWNER_STATES },
+                                    owners: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            required: ['kind', 'stableId', 'displayName'],
+                                            properties: {
+                                                kind: { type: 'string', enum: PARTICIPANT_KINDS },
+                                                stableId: { type: ['string', 'null'] },
+                                                displayName: { type: ['string', 'null'] },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    dependency: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: {
+                                type: 'object',
+                                required: ['state', 'on'],
+                                properties: {
+                                    state: { type: 'string', enum: DEPENDENCIES },
+                                    on: { type: ['object', 'null'] },
+                                },
+                            },
+                        },
+                    },
+                    lifecycle: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: { type: 'string', enum: LIFECYCLES },
+                        },
+                    },
+                    completion: {
+                        ...evidenceField,
+                        required: ['value', 'confidence', 'evidenceMessageIds'],
+                        properties: {
+                            ...evidenceField.properties,
+                            value: {
+                                type: 'object',
+                                required: ['delivered', 'accepted', 'cancelled'],
+                                properties: {
+                                    delivered: { type: 'boolean' },
+                                    accepted: { type: 'boolean' },
+                                    cancelled: { type: 'boolean' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+const SYSTEM_PROMPT = `Infer a revisable work-event graph from the complete event context. Dialogue acts are message-level. Return zero or more distinct candidates; one message may cancel one action and propose another, so candidates may share evidence. Information and answers can create work. Acknowledgement is not acceptance. Never infer work from read state, names, or account identity. Action frames must cite source message IDs. If uncertain, use low confidence rather than inventing evidence.`;
+export class LlamaCppWorkEventAdapter {
+    model;
+    request;
+    timeoutMs;
+    id;
+    endpoint;
+    constructor(baseUrl, model, request = fetch, timeoutMs = 120_000) {
+        this.model = model;
+        this.request = request;
+        this.timeoutMs = timeoutMs;
+        const url = new URL(baseUrl);
+        if (url.protocol !== 'http:' ||
+            !['127.0.0.1', '::1', '[::1]', 'localhost'].includes(url.hostname)) {
+            throw new Error('Work-event model endpoint must be loopback HTTP');
+        }
+        this.endpoint = new URL('/v1/chat/completions', url);
+        this.id = `llama.cpp:${model}`;
+    }
+    async generate(input) {
+        const response = await this.request(this.endpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            signal: AbortSignal.timeout(this.timeoutMs),
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    { role: 'system', content: SYSTEM_PROMPT },
+                    { role: 'user', content: input },
+                ],
+                response_format: {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'work_event_graph',
+                        strict: true,
+                        schema: WORK_EVENT_GRAPH_JSON_SCHEMA,
+                    },
+                },
+                temperature: 0,
+                max_tokens: 1800,
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`Local model request failed (${response.status})`);
+        const payload = (await response.json());
+        const content = payload?.choices?.[0]?.message?.content;
+        if (typeof content !== 'string' || content.length > 1024 * 1024)
+            throw new Error('Local model response is missing or oversized');
+        const parsed = JSON.parse(content);
+        return { ...parsed, modelId: this.id };
+    }
+}

package/dist/work-item/local-provider.js

@@ -0,0 +1,38 @@
+import { validateProviderCapabilities, } from './provider.js';
+/**
+ * A local review sink. It deliberately never opens a socket or invokes a
+ * system share panel, so preview/delivery can be exercised safely in tests.
+ */
+export class LocalReviewProvider {
+    id = 'local.review';
+    displayName = 'Local review';
+    capabilities = {
+        operations: ['share', 'message', 'issue', 'review'],
+        attachments: true,
+        maxAttachments: 100,
+        requiresApproval: true,
+    };
+    delivered = new Map();
+    validate(draft) {
+        return validateProviderCapabilities(this, draft);
+    }
+    async deliver(draft) {
+        const validation = this.validate(draft);
+        if (!validation.valid)
+            throw new Error(validation.errors.join('; '));
+        // Keep the in-process object available to a local UI/reviewer only.
+        this.delivered.set(draft.id, structuredClone(draft));
+        return {
+            delivery: {
+                providerId: this.id,
+                deliveredAt: Date.now(),
+                external: false,
+                reference: `local-review://${draft.id}`,
+            },
+        };
+    }
+    get(id) {
+        const draft = this.delivered.get(id);
+        return draft ? structuredClone(draft) : null;
+    }
+}

package/dist/work-item/local-work-event-provider.js

@@ -0,0 +1,56 @@
+import { validateFactorizedGraphModelOutput, } from './work-event-inference.js';
+import { assertProductionEligibleModel, } from './work-event-model-manifest.js';
+export class LocalModelOutputError extends Error {
+    reasons;
+    constructor(reasons) {
+        super(`Local work-event model output is invalid: ${reasons.join(', ')}`);
+        this.reasons = reasons;
+    }
+}
+export function serializeEventContextForModel(context) {
+    const messages = context.messages.map((message, index) => JSON.stringify({
+        index,
+        messageId: message.messageId,
+        speaker: message.isSelf ? 'self' : 'other',
+        sentAt: message.sentAt,
+        text: message.text,
+        mediaType: message.mediaType ?? null,
+        mentionsSelf: message.mentionsSelf ?? false,
+    }));
+    const edges = context.edges.map((edge) => JSON.stringify({
+        parentId: edge.parentId,
+        childId: edge.childId,
+        weight: edge.weight,
+        entropy: edge.entropy,
+    }));
+    return [
+        JSON.stringify({
+            schemaVersion: 1,
+            chatId: context.chatId,
+            anchorMessageIds: context.anchorMessageIds,
+            complete: context.complete,
+            boundary: context.boundary,
+        }),
+        ...messages,
+        'EDGES',
+        ...edges,
+    ].join('\n');
+}
+export class LocalFactorizedWorkEventProvider {
+    adapter;
+    id;
+    constructor(adapter, manifest) {
+        this.adapter = adapter;
+        assertProductionEligibleModel(manifest);
+        if (manifest.modelId !== adapter.id)
+            throw new Error('Model manifest does not match the local adapter');
+        this.id = `local:${adapter.id}`;
+    }
+    async infer(context) {
+        const raw = await this.adapter.generate(serializeEventContextForModel(context));
+        const reasons = validateFactorizedGraphModelOutput(raw);
+        if (reasons.length > 0)
+            throw new LocalModelOutputError(reasons);
+        return { ...raw, modelId: this.id };
+    }
+}

package/dist/work-item/onnx-work-event-adapter.js

@@ -0,0 +1,223 @@
+import { AutoModel, AutoTokenizer } from '@huggingface/transformers';
+const ACTS = [
+    'inform',
+    'ask',
+    'answer',
+    'directive',
+    'commit',
+    'delegate',
+    'acknowledge',
+    'deliver',
+    'accept',
+    'reject',
+    'cancel',
+];
+const OWNER_STATES = ['unassigned', 'owned', 'delegated', 'unknown'];
+const DEPENDENCIES = [
+    'none',
+    'waiting_person',
+    'waiting_external_system',
+    'waiting_decision',
+    'unknown',
+];
+const LIFECYCLES = [
+    'proposed',
+    'committed',
+    'in_progress',
+    'blocked',
+    'delivered',
+    'accepted',
+    'cancelled',
+    'resolved',
+    'uncertain',
+];
+function sigmoid(x) {
+    return 1 / (1 + Math.exp(-x));
+}
+function softmax(logits) {
+    const max = Math.max(...logits);
+    const exp = logits.map((val) => Math.exp(val - max));
+    const sum = exp.reduce((acc, val) => acc + val, 0);
+    return exp.map((val) => val / sum);
+}
+function argmax(values) {
+    let bestIdx = 0;
+    let bestVal = values[0];
+    for (let i = 1; i < values.length; i++) {
+        if (values[i] > bestVal) {
+            bestVal = values[i];
+            bestIdx = i;
+        }
+    }
+    return bestIdx;
+}
+export class OnnxWorkEventAdapter {
+    modelDir;
+    id;
+    tokenizer = null;
+    model = null;
+    loadPromise = null;
+    constructor(modelDir = './research/models/student-a100-v1', id = 'onnx-student-a100-v1') {
+        this.modelDir = modelDir;
+        this.id = id;
+    }
+    async ensureLoaded() {
+        if (this.model && this.tokenizer)
+            return;
+        if (!this.loadPromise) {
+            this.loadPromise = (async () => {
+                this.tokenizer = await AutoTokenizer.from_pretrained(this.modelDir);
+                this.model = await AutoModel.from_pretrained(this.modelDir, {
+                    local_files_only: true,
+                });
+            })();
+        }
+        await this.loadPromise;
+    }
+    async generate(serializedInput) {
+        await this.ensureLoaded();
+        // Extract target message and context from serializedInput
+        const lines = serializedInput.split('\n');
+        const messages = [];
+        for (const line of lines) {
+            if (line === 'EDGES' || !line.trim())
+                break;
+            try {
+                const parsed = JSON.parse(line);
+                if (typeof parsed.index === 'number' && parsed.messageId) {
+                    messages.push(parsed);
+                }
+            }
+            catch {
+                // Skip header or non-message lines
+            }
+        }
+        if (messages.length === 0) {
+            return {
+                dialogue: [],
+                candidates: [],
+                modelId: this.id,
+            };
+        }
+        const targetMsg = messages[messages.length - 1];
+        const turns = messages.map((m, idx) => {
+            const marker = idx === messages.length - 1 ? 'TARGET' : 'CONTEXT';
+            const text = m.text || (m.mediaType ? `[${m.mediaType}]` : '');
+            return `[${marker} speaker=${m.speaker}] ${text}`;
+        });
+        const prompt = turns.join('\n');
+        const inputs = await this.tokenizer(prompt);
+        const outputs = await this.model(inputs);
+        // Parse creates_work
+        const createsWorkLogit = Number(outputs.creates_work.data[0]);
+        const createsWorkConf = sigmoid(createsWorkLogit);
+        const createsWork = createsWorkConf >= 0.5;
+        // Parse dialogue acts
+        const dialogueActsLogits = Array.from(outputs.dialogue.data);
+        const detectedActs = [];
+        let maxActIdx = 0;
+        let maxActVal = -Infinity;
+        for (let i = 0; i < dialogueActsLogits.length; i++) {
+            const conf = sigmoid(dialogueActsLogits[i]);
+            if (conf >= 0.5)
+                detectedActs.push(ACTS[i]);
+            if (dialogueActsLogits[i] > maxActVal) {
+                maxActVal = dialogueActsLogits[i];
+                maxActIdx = i;
+            }
+        }
+        if (detectedActs.length === 0)
+            detectedActs.push(ACTS[maxActIdx]);
+        // Parse ownership
+        const ownershipLogits = Array.from(outputs.ownership.data);
+        const ownershipProbs = softmax(ownershipLogits);
+        const ownIdx = argmax(ownershipProbs);
+        const ownState = OWNER_STATES[ownIdx];
+        const ownConfidence = ownershipProbs[ownIdx];
+        const ownerKinds = ownState === 'owned'
+            ? [targetMsg.speaker === 'self' ? 'self' : 'conversation_member']
+            : ownState === 'delegated'
+                ? ['external_party']
+                : ['unknown'];
+        // Parse dependency
+        const dependencyLogits = Array.from(outputs.dependency.data);
+        const dependencyProbs = softmax(dependencyLogits);
+        const depIdx = argmax(dependencyProbs);
+        const depState = DEPENDENCIES[depIdx];
+        const depConfidence = dependencyProbs[depIdx];
+        // Parse lifecycle
+        const lifecycleLogits = Array.from(outputs.lifecycle.data);
+        const lifecycleProbs = softmax(lifecycleLogits);
+        const lifeIdx = argmax(lifecycleProbs);
+        const lifeState = LIFECYCLES[lifeIdx];
+        const lifeConfidence = lifecycleProbs[lifeIdx];
+        // Parse completion
+        const completionLogits = Array.from(outputs.completion.data);
+        const delivered = sigmoid(completionLogits[0]) >= 0.5;
+        const accepted = sigmoid(completionLogits[1]) >= 0.5;
+        const cancelled = sigmoid(completionLogits[2]) >= 0.5;
+        const candidate = {
+            candidateKey: targetMsg.messageId,
+            createsWork: {
+                value: createsWork,
+                confidence: createsWork ? createsWorkConf : 1 - createsWorkConf,
+                evidenceMessageIds: [targetMsg.messageId],
+            },
+            action: createsWork
+                ? {
+                    predicate: 'handle',
+                    object: targetMsg.text?.slice(0, 40) ?? null,
+                    expectedOutcome: 'task completion',
+                    dueAt: null,
+                    sourceMessageIds: [targetMsg.messageId],
+                    confidence: createsWorkConf,
+                }
+                : null,
+            ownership: {
+                value: {
+                    state: ownState,
+                    owners: ownerKinds.map((k) => ({
+                        kind: k,
+                        stableId: null,
+                        displayName: null,
+                    })),
+                },
+                confidence: ownConfidence,
+                evidenceMessageIds: [targetMsg.messageId],
+            },
+            dependency: {
+                value: {
+                    state: depState,
+                    on: null,
+                },
+                confidence: depConfidence,
+                evidenceMessageIds: [targetMsg.messageId],
+            },
+            lifecycle: {
+                value: lifeState,
+                confidence: lifeConfidence,
+                evidenceMessageIds: [targetMsg.messageId],
+            },
+            completion: {
+                value: {
+                    delivered,
+                    accepted,
+                    cancelled,
+                },
+                confidence: Math.max(sigmoid(completionLogits[0]), sigmoid(completionLogits[1]), sigmoid(completionLogits[2])),
+                evidenceMessageIds: [targetMsg.messageId],
+            },
+        };
+        return {
+            dialogue: [
+                {
+                    messageId: targetMsg.messageId,
+                    acts: detectedActs,
+                    confidence: sigmoid(maxActVal),
+                },
+            ],
+            candidates: [candidate],
+            modelId: this.id,
+        };
+    }
+}

package/dist/work-item/provider.js

@@ -0,0 +1,21 @@
+export function validateProviderCapabilities(provider, draft) {
+    const errors = [];
+    if (!provider.capabilities.operations.includes(draft.action)) {
+        errors.push(`Provider ${provider.id} does not support ${draft.action}`);
+    }
+    const attachmentCount = draft.evidence.reduce((count, evidence) => count + evidence.attachments.length, 0);
+    if (!provider.capabilities.attachments && attachmentCount > 0) {
+        errors.push(`Provider ${provider.id} does not support attachments`);
+    }
+    else if (attachmentCount > provider.capabilities.maxAttachments) {
+        errors.push(`Provider ${provider.id} accepts at most ${provider.capabilities.maxAttachments} attachments`);
+    }
+    // The service passes `sending` after atomically recording approval. A
+    // direct provider call still requires the draft to be approved first.
+    if (provider.capabilities.requiresApproval &&
+        draft.status !== 'approved' &&
+        draft.status !== 'sending') {
+        errors.push(`Provider ${provider.id} requires an approved work item`);
+    }
+    return { valid: errors.length === 0, errors };
+}