@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/learning-trigger.d.ts

@@ -0,0 +1,18 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { EvidenceRef } from './domain.js';
+export interface LearningTriggerMatch {
+    reason: 'explicit-correction';
+    evidenceRef: Extract<EvidenceRef, {
+        type: 'session-events';
+    }>;
+    excerpt: string;
+}
+export interface LearningTrigger {
+    readonly name: string;
+    detect(events: readonly SessionEvent[], turn: number): LearningTriggerMatch | undefined;
+}
+export declare class ExplicitCorrectionTrigger implements LearningTrigger {
+    readonly name = "explicit-correction";
+    detect(events: readonly SessionEvent[], turn: number): LearningTriggerMatch | undefined;
+}
+//# sourceMappingURL=learning-trigger.d.ts.map

package/lib/learning-trigger.js

@@ -0,0 +1,92 @@
+const EXPLICIT_CORRECTION_PATTERNS = [
+    /(?:请)?记住(?:这(?:一点|一条|件事)?|[\s：:,，。]|$)/u,
+    /(?:从现在起|以后|下次).{0,40}(?:必须|应该|要|请|不要|不能|别)/u,
+    /(?:不要|别)再/u,
+    /(?:刚才|前面|上次).{0,50}(?:错了|不对|错误)/u,
+    /(?:正确的?(?:做法|方式|规则)|应该改成)/u,
+    /\b(?:please\s+)?remember\b/i,
+    /\bfrom now on\b/i,
+    /\bnext time\b.{0,80}\b(?:must|should|please|do not|don't|never)\b/i,
+    /\b(?:do not|don't|never)\b.{0,80}\bagain\b/i,
+    /\b(?:that|this|your previous).{0,40}\b(?:was|is)\s+(?:wrong|incorrect)\b/i,
+];
+export class ExplicitCorrectionTrigger {
+    name = 'explicit-correction';
+    detect(events, turn) {
+        const startIndex = findTurnStart(events, turn);
+        if (startIndex < 0)
+            return undefined;
+        const nextTurn = events.findIndex((event, index) => index > startIndex && event.type === 'turn/start');
+        const turnEvents = events.slice(startIndex, nextTurn < 0 ? undefined : nextTurn);
+        for (let index = turnEvents.length - 1; index >= 0; index -= 1) {
+            const event = turnEvents[index];
+            if (event?.type !== 'user/message' || event.data.source.kind !== 'user')
+                continue;
+            const text = textContent(event.data.content).trim();
+            if (text.length === 0 || !EXPLICIT_CORRECTION_PATTERNS.some(pattern => pattern.test(text)))
+                continue;
+            // Dispatch alone is not learning: failed, aborted, or unfinished writes must
+            // still reach the checkpoint. A later correction also needs its own write.
+            if (hasCompletedLearning(turnEvents, event.seq))
+                return undefined;
+            return {
+                reason: 'explicit-correction',
+                evidenceRef: {
+                    type: 'session-events',
+                    sessionId: '',
+                    fromSeq: event.seq,
+                    toSeq: event.seq,
+                },
+                excerpt: boundText(text, 4000),
+            };
+        }
+        return undefined;
+    }
+}
+function hasCompletedLearning(events, afterSeq) {
+    const calls = new Set();
+    const codeStarts = new Map();
+    const isLearningTool = (name) => name === 'bizagent_memory_remember'
+        || name === 'bizagent_learning_checkpoint';
+    for (const raw of events) {
+        // Programmatic tool calls are dispatch events declared by dsh-tools, outside the session union.
+        const event = raw;
+        if (event.type === 'tool/ptc-dispatch-start')
+            codeStarts.set(event.data.subCallId, event.seq);
+        if (event.seq <= afterSeq)
+            continue;
+        if (event.type === 'tool/call' && isLearningTool(event.data.name))
+            calls.add(event.data.callId);
+        if (event.type === 'tool/result' && event.data.error === undefined) {
+            const result = event.data.message;
+            if (calls.has(result.toolCallId) && !result.isError)
+                return true;
+        }
+        if (event.type === 'tool/ptc-dispatch' && isLearningTool(event.data.name)
+            && !event.data.isError && (codeStarts.get(event.data.subCallId) ?? event.seq) > afterSeq)
+            return true;
+    }
+    return false;
+}
+function findTurnStart(events, turn) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === 'turn/start' && event.data.turn === turn)
+            return index;
+    }
+    return -1;
+}
+function textContent(content) {
+    return content.flatMap((block) => {
+        if (typeof block !== 'object' || block === null)
+            return [];
+        const candidate = block;
+        return candidate.type === 'text' && typeof candidate.text === 'string' ? [candidate.text] : [];
+    }).join('\n');
+}
+function boundText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+//# sourceMappingURL=learning-trigger.js.map

package/lib/learning-usage.d.ts

@@ -0,0 +1,18 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/** A projection of the dedicated worker's durable model-call evidence. No price is inferred. */
+export interface LearningUsage {
+    status: 'reported' | 'partial' | 'unavailable';
+    reported?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        reasoningTokens: number;
+    };
+    reportedSteps: number;
+    unreportedSteps: number;
+    lastEventSeq: number | null;
+    costUsd: null;
+}
+export declare function summarizeLearningUsage(events: readonly SessionEvent[]): LearningUsage;
+//# sourceMappingURL=learning-usage.d.ts.map

package/lib/learning-usage.js

@@ -0,0 +1,49 @@
+export function summarizeLearningUsage(events) {
+    const steps = new Map();
+    for (const event of events) {
+        if (event.type !== 'step/start' && event.type !== 'assistant/attempt'
+            && event.type !== 'assistant/message')
+            continue;
+        const key = `${event.data.turn}:${event.data.step}`;
+        const step = steps.get(key) ?? { started: false, usages: [] };
+        if (event.type === 'step/start')
+            step.started = true;
+        else {
+            // Each model attempt (failed retries included) counts once: its streamed usage reports,
+            // or the message's own total when the adapter reported no usage chunk.
+            const streamed = (event.data.stream ?? []).flatMap(record => record.type === 'chunk' && record.chunk.type === 'usage' ? [record.chunk.usage] : []);
+            if (streamed.length > 0)
+                step.usages.push(...streamed);
+            else if (event.type === 'assistant/message' && event.data.usage !== undefined)
+                step.usages.push(event.data.usage);
+        }
+        steps.set(key, step);
+    }
+    const reported = { inputTokens: 0, outputTokens: 0,
+        cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0 };
+    let reportedSteps = 0;
+    let unreportedSteps = 0;
+    for (const step of steps.values()) {
+        const usages = step.usages;
+        if (usages.length === 0) {
+            if (step.started)
+                unreportedSteps += 1;
+            continue;
+        }
+        reportedSteps += 1;
+        for (const usage of usages) {
+            reported.inputTokens += usage.inputTokens;
+            reported.outputTokens += usage.outputTokens;
+            reported.cacheReadTokens += usage.cacheReadTokens ?? 0;
+            reported.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+            reported.reasoningTokens += usage.reasoningTokens ?? 0;
+        }
+    }
+    return {
+        status: reportedSteps === 0 ? 'unavailable' : unreportedSteps > 0 ? 'partial' : 'reported',
+        ...(reportedSteps > 0 ? { reported } : {}),
+        reportedSteps, unreportedSteps,
+        lastEventSeq: events.at(-1)?.seq ?? null, costUsd: null,
+    };
+}
+//# sourceMappingURL=learning-usage.js.map

package/lib/ledger.d.ts

@@ -0,0 +1,191 @@
+import { type DomainFacility } from '@deepseek-ai/dsh-storage-domain';
+import { type SharedKnowledgeProposal } from './shared-knowledge.js';
+import { type AgentFrameState, type InboxDelivery, type InboxHumanNotification, type HumanNotificationPreference, type UserAddress, type InboxMessage, type InboxWakeOrigin, type InboxWakePlan, type InboxReturnRoute, type FitnessReceipt, type LearningCheckpoint, type LearningMaterialObservation, type LearningMaterialReview, type LearningBatchRun, type LearningLaunch, type LearningScheduleCursor, type LearningSchedulePolicy, type MemoryProposal, type ProjectTurnParticipation, type SessionBinding } from './domain.js';
+export declare const BIZAGENT_DOMAIN: {
+    name: string;
+    version: number;
+    tables: {
+        bindings: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            sessionId: string;
+            homeAddress: string;
+            boundAt: string;
+            cwd?: string | undefined;
+        }>;
+        proposals: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            fromAddress: string;
+            toAddress: string;
+            proposedKind: "memory" | "insight" | "knowledge" | "method" | "identity";
+            description: string;
+            body: string;
+            tags: string[];
+            sourceRefs: ({
+                type: "session-events";
+                sessionId: string;
+                fromSeq: number;
+                toSeq: number;
+            } | {
+                type: "worklog";
+                sessionId: string;
+                revisionId: string;
+                fingerprint: string;
+            } | {
+                type: "tool-result";
+                sessionId: string;
+                eventSeq: number;
+                toolCallId: string;
+            } | {
+                type: "artifact";
+                uri: string;
+                digest: string;
+            } | {
+                type: "document";
+                uri: string;
+                digest: string;
+                authority?: string | undefined;
+            } | {
+                type: "asset";
+                ownerAddress: string;
+                assetId: string;
+                revision: number;
+            } | {
+                type: "user-confirmation";
+                sessionId: string;
+                eventSeq: number;
+            })[];
+            status: "rejected" | "pending" | "accepted" | "withdrawn";
+            createdAt: string;
+            baseAsset?: {
+                id: string;
+                revision: number;
+                bodySha256: string;
+            } | undefined;
+            targetAssetId?: string | undefined;
+            appliedAssetRevision?: number | undefined;
+            appliedBodySha256?: string | undefined;
+            humanReview?: {
+                reviewerId: string;
+                authorityRef: string;
+                action: "accept" | "reject";
+                decision: string;
+                reviewedAt: string;
+            } | undefined;
+            decision?: string | undefined;
+            decidedAt?: string | undefined;
+        }>;
+        receipts: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            assetId: string;
+            ownerAddress: string;
+            sessionId: string;
+            signal: "retrieved" | "applied" | "confirmed" | "contradicted" | "failed";
+            createdAt: string;
+            eventSeq?: number | undefined;
+            assetRevision?: number | undefined;
+            assetBodySha256?: string | undefined;
+            outcome?: string | undefined;
+        }>;
+        metadata: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            key: string;
+            value: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export declare class LearningLedger {
+    private readonly domain;
+    private receiptTail;
+    private learningBatchTail;
+    private readonly materialReviewWrites;
+    private readonly frameMutationTail;
+    private inboxMutationTail;
+    private projectTurnTail;
+    private proposalTail;
+    private constructor();
+    static open(facility: DomainFacility): Promise<LearningLedger>;
+    getBinding(sessionId: string): SessionBinding | undefined;
+    putBinding(binding: SessionBinding): Promise<void>;
+    /** Roll back a pre-creation reservation only after the host has verified that no Session materialized. */
+    removeUnmaterializedBinding(binding: SessionBinding): Promise<boolean>;
+    /** Forget a binding the current rules no longer make, so its Session binds afresh on its next turn. */
+    releaseBinding(binding: SessionBinding): Promise<boolean>;
+    listBindings(homeAddress?: string): SessionBinding[];
+    listProjectTurns(projectId?: string): ProjectTurnParticipation[];
+    putProjectTurn(input: Omit<ProjectTurnParticipation, 'schemaVersion' | 'recordedAt'>): Promise<ProjectTurnParticipation>;
+    getFrameState(sessionId: string): AgentFrameState | undefined;
+    updateFrameState(sessionId: string, update: (current: AgentFrameState | undefined) => AgentFrameState): Promise<AgentFrameState>;
+    withInboxWrite<T>(update: () => Promise<T>): Promise<T>;
+    getInboxMessage(id: string): InboxMessage | undefined;
+    listInboxMessages(): InboxMessage[];
+    putInboxMessage(message: InboxMessage): Promise<void>;
+    getInboxDelivery(messageId: string, recipient: string): InboxDelivery | undefined;
+    putInboxDelivery(delivery: InboxDelivery): Promise<void>;
+    getInboxHumanNotification(messageId: string, recipient: string): InboxHumanNotification | undefined;
+    getHumanNotificationPreference(recipient: string): HumanNotificationPreference | undefined;
+    setHumanNotificationPreference(recipient: string, enabled: boolean, expectedRevision: number): Promise<HumanNotificationPreference>;
+    /** The external provider was never called; this terminal record survives later opt-in. */
+    suppressInboxHumanNotification(messageId: string, recipient: string, reason: string): Promise<InboxHumanNotification>;
+    private putSuppressedHumanNotification;
+    /** Persist an opt-out while holding the same lock as preference updates and channel reservations. */
+    suppressInboxHumanNotificationIfOptedOut(messageId: string, recipient: UserAddress): Promise<InboxHumanNotification | undefined>;
+    /** Reserve before calling the channel; a crash leaves unknown and never causes an automatic resend. */
+    reserveInboxHumanNotification(messageId: string, recipient: string): Promise<{
+        notification: InboxHumanNotification;
+        reserved: boolean;
+    }>;
+    settleInboxHumanNotification(messageId: string, recipient: string, outcome: {
+        status: 'sent';
+        providerReceipt: string;
+    } | {
+        status: 'rejected';
+        reason: string;
+    }): Promise<InboxHumanNotification>;
+    /** A definite rejection permits one explicit new attempt; unknown and sent never do. */
+    retryRejectedInboxHumanNotification(messageId: string, recipient: string): Promise<InboxHumanNotification>;
+    getInboxWakeOrigin(sessionId: string): InboxWakeOrigin | undefined;
+    putInboxWakeOrigin(origin: InboxWakeOrigin): Promise<InboxWakeOrigin>;
+    getInboxWakePlan(id: string): InboxWakePlan | undefined;
+    listInboxWakePlans(): InboxWakePlan[];
+    /** Caller holds withInboxWrite so plan selection and reservation share one local writer. */
+    putInboxWakePlan(plan: InboxWakePlan): Promise<InboxWakePlan>;
+    markInboxWakeDispatched(id: string, dispatchedAt: string, retiredReason?: string): Promise<InboxWakePlan>;
+    getInboxReturnRoute(messageId: string, recipient: string): InboxReturnRoute | undefined;
+    putInboxReturnRoute(route: InboxReturnRoute): Promise<InboxReturnRoute>;
+    getMaterialObservation(id: string): LearningMaterialObservation | undefined;
+    putMaterialObservation(observation: LearningMaterialObservation): Promise<LearningMaterialObservation>;
+    getMaterialReview(materialId: string): LearningMaterialReview | undefined;
+    putMaterialReview(review: LearningMaterialReview): Promise<LearningMaterialReview>;
+    withLearningBatchWrite<T>(update: () => Promise<T>): Promise<T>;
+    getLearningBatch(id: string): LearningBatchRun | undefined;
+    listLearningBatches(homeAddress: string): LearningBatchRun[];
+    putLearningBatch(run: LearningBatchRun): Promise<LearningBatchRun>;
+    getLearningLaunch(id: string): LearningLaunch | undefined;
+    listLearningLaunches(homeAddress?: string): LearningLaunch[];
+    putLearningLaunch(launch: LearningLaunch): Promise<LearningLaunch>;
+    getLearningScheduleCursor(homeAddress: string): LearningScheduleCursor | undefined;
+    putLearningScheduleCursor(cursor: LearningScheduleCursor): Promise<LearningScheduleCursor>;
+    getLearningSchedulePolicy(homeAddress: string): LearningSchedulePolicy | undefined;
+    /** Caller holds the learning batch write lock and checks the prior revision. */
+    putLearningSchedulePolicy(policy: LearningSchedulePolicy): Promise<LearningSchedulePolicy>;
+    getProposal(id: string): MemoryProposal | undefined;
+    putProposal(proposal: MemoryProposal): Promise<void>;
+    listProposals(options?: {
+        fromAddress?: string;
+        toAddress?: string;
+        status?: MemoryProposal['status'];
+    }): MemoryProposal[];
+    getSharedKnowledgeProposal(id: string): SharedKnowledgeProposal | undefined;
+    listSharedKnowledgeProposals(status?: SharedKnowledgeProposal['status']): SharedKnowledgeProposal[];
+    putSharedKnowledgeProposal(input: SharedKnowledgeProposal): Promise<SharedKnowledgeProposal>;
+    putReceipt(receipt: FitnessReceipt): Promise<boolean>;
+    listReceipts(assetId?: string): FitnessReceipt[];
+    getCheckpoint(id: string): LearningCheckpoint | undefined;
+    putCheckpoint(checkpoint: LearningCheckpoint): Promise<void>;
+    listCheckpoints(options?: {
+        sessionId?: string;
+        homeAddress?: string;
+        status?: LearningCheckpoint['status'];
+    }): LearningCheckpoint[];
+    close(): Promise<void>;
+}
+//# sourceMappingURL=ledger.d.ts.map