@bbigbang/core 0.1.0

package/dist/web/conversationControls.js

@@ -0,0 +1,232 @@
+import { log } from '@bbigbang/runtime-acp';
+import { blockActiveTaskThreadRunsAfterReopen, closeTaskThreadRuntimeState, sealTaskThreadRuntimeState, } from './taskThreadRuntimeClosure.js';
+const AUDIT_REDACTED_FIELD_PATTERN = /prompt|content|context|text/i;
+const AUDIT_STRING_LIMIT = 500;
+function sanitizeAuditMetadata(metadata) {
+    if (!metadata)
+        return {};
+    const sanitized = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (AUDIT_REDACTED_FIELD_PATTERN.test(key) && typeof value === 'string') {
+            sanitized[key] = '[redacted]';
+        }
+        else if (AUDIT_REDACTED_FIELD_PATTERN.test(key) && value != null && typeof value === 'object') {
+            sanitized[key] = '[redacted]';
+        }
+        else if (typeof value === 'string' && value.length > AUDIT_STRING_LIMIT) {
+            sanitized[key] = `${value.slice(0, AUDIT_STRING_LIMIT)}...[truncated]`;
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+function formatAuditError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.trim() || 'unknown error';
+}
+export function createConversationControl(params) {
+    const audit = (command, result) => {
+        const suppressReplyContract = command.intent === 'memory_notice'
+            || (command.intent === 'deliver_prompt'
+                || command.intent === 'steer_preferred'
+                || command.intent === 'queue_prompt'
+                || command.intent === 'handoff_dispatch'
+                ? command.suppressReplyContract === true
+                : undefined);
+        log.info('[conversation-control] command', {
+            intent: command.intent,
+            conversationId: 'conversationId' in command ? command.conversationId : undefined,
+            taskId: 'taskId' in command ? command.taskId : undefined,
+            reason: 'reason' in command ? command.reason : undefined,
+            visibility: command.visibility,
+            delivery: command.delivery,
+            activeRunPolicy: command.activeRunPolicy,
+            activationContextMode: 'activationContextMode' in command ? command.activationContextMode : undefined,
+            allowActiveSteer: 'allowActiveSteer' in command ? command.allowActiveSteer : undefined,
+            allowQueue: 'allowQueue' in command ? command.allowQueue : undefined,
+            suppressReplyContract,
+            ...sanitizeAuditMetadata(command.audit),
+            ...sanitizeAuditMetadata(result),
+        });
+    };
+    const runPromptControl = (command) => {
+        return params.conversationManager.submitPrompt(command.conversationId, command.promptText, {
+            recordAsUserMessage: command.recordAsUserMessage,
+            activationContextMode: command.activationContextMode,
+            allowActiveSteer: command.allowActiveSteer,
+            allowQueue: command.allowQueue,
+            suppressReplyContract: command.suppressReplyContract,
+        }).then((result) => {
+            audit(command, {
+                ok: true,
+                queued: result.queued,
+                steered: result.steered,
+                runId: result.runId,
+            });
+            return result;
+        }).catch((error) => {
+            audit(command, {
+                ok: false,
+                error: formatAuditError(error),
+            });
+            throw error;
+        });
+    };
+    const runCancelControl = (command) => {
+        try {
+            const result = params.conversationManager.cancelConversationRun(command.conversationId, command.expectedRunId);
+            audit(command, { ok: result.ok, runId: result.runId, message: result.message });
+            return result;
+        }
+        catch (error) {
+            audit(command, { ok: false, error: formatAuditError(error) });
+            throw error;
+        }
+    };
+    const runSealTaskThreadControl = (command) => {
+        try {
+            const result = sealTaskThreadRuntimeState({
+                db: params.db,
+                taskId: command.taskId,
+                reason: command.reason,
+                dmUserId: command.dmUserId,
+                ownerConversationId: command.ownerConversationId,
+                ownerRunId: command.ownerRunId,
+                ownerAgentId: command.ownerAgentId,
+                onConversationStatusChange: params.onConversationStatusChange,
+            });
+            audit(command, {
+                ok: true,
+                sealed: result.sealed,
+                conversationCount: result.conversationIds.length,
+                preservedActiveRunCount: result.preservedActiveRuns.length,
+                clearedQueuedPromptCount: result.clearedQueuedPromptCount,
+                clearedAggregateCount: result.clearedAggregateCount,
+                clearedCooldownCount: result.clearedCooldownCount,
+                clearedFollowupCount: result.clearedFollowupCount,
+            });
+            return result;
+        }
+        catch (error) {
+            audit(command, { ok: false, error: formatAuditError(error) });
+            throw error;
+        }
+    };
+    const runHardCloseTaskThreadControl = (command) => {
+        try {
+            const result = closeTaskThreadRuntimeState({
+                db: params.db,
+                conversationManager: params.conversationManager,
+                taskId: command.taskId,
+                reason: command.reason,
+                onConversationStatusChange: params.onConversationStatusChange,
+            });
+            audit(command, {
+                ok: true,
+                closed: result.closed,
+                conversationCount: result.conversationIds.length,
+                cancelledRunCount: result.cancelledRunIds.length,
+                clearedQueuedPromptCount: result.clearedQueuedPromptCount,
+                clearedAggregateCount: result.clearedAggregateCount,
+                clearedCooldownCount: result.clearedCooldownCount,
+                clearedFollowupCount: result.clearedFollowupCount,
+            });
+            return result;
+        }
+        catch (error) {
+            audit(command, { ok: false, error: formatAuditError(error) });
+            throw error;
+        }
+    };
+    const runReopenTaskThreadControl = (command) => {
+        try {
+            const closeResult = closeTaskThreadRuntimeState({
+                db: params.db,
+                conversationManager: params.conversationManager,
+                taskId: command.taskId,
+                reason: 'in_review',
+                onConversationStatusChange: params.onConversationStatusChange,
+            });
+            const blockedRuns = blockActiveTaskThreadRunsAfterReopen(params.db, command.taskId);
+            audit(command, {
+                ok: true,
+                closed: closeResult.closed,
+                conversationCount: closeResult.conversationIds.length,
+                cancelledRunCount: closeResult.cancelledRunIds.length,
+                blockedRunCount: blockedRuns.length,
+            });
+            return { closeResult, blockedRuns };
+        }
+        catch (error) {
+            audit(command, { ok: false, error: formatAuditError(error) });
+            throw error;
+        }
+    };
+    const execute = (command) => {
+        switch (command.intent) {
+            case 'deliver_prompt':
+            case 'memory_notice':
+            case 'steer_preferred':
+            case 'queue_prompt':
+            case 'handoff_dispatch': {
+                return runPromptControl(command);
+            }
+            case 'cancel_run': {
+                return runCancelControl(command);
+            }
+            case 'seal_task_thread': {
+                return runSealTaskThreadControl(command);
+            }
+            case 'hard_close_task_thread': {
+                return runHardCloseTaskThreadControl(command);
+            }
+            case 'reopen_task_thread': {
+                return runReopenTaskThreadControl(command);
+            }
+            default: {
+                const exhaustive = command;
+                throw new Error(`Unhandled conversation control intent: ${String(exhaustive)}`);
+            }
+        }
+    };
+    const submitMemoryNotice = (command) => runPromptControl({
+        ...command,
+        intent: 'memory_notice',
+        visibility: 'memory_only',
+        delivery: 'steer_preferred',
+        recordAsUserMessage: false,
+        activationContextMode: 'resume_only',
+        allowActiveSteer: command.allowActiveSteer ?? true,
+        suppressReplyContract: true,
+    });
+    const sealTaskThread = (command) => runSealTaskThreadControl({
+        ...command,
+        intent: 'seal_task_thread',
+        visibility: 'system_hidden',
+        delivery: 'resume_only',
+        activeRunPolicy: command.reason === 'in_review' && command.ownerRunId ? 'allow_owner_final' : 'block_outputs',
+    });
+    const hardCloseTaskThread = (command) => runHardCloseTaskThreadControl({
+        ...command,
+        intent: 'hard_close_task_thread',
+        visibility: 'system_hidden',
+        delivery: 'drop_if_busy',
+        activeRunPolicy: 'cancel',
+    });
+    const reopenTaskThread = (command) => runReopenTaskThreadControl({
+        ...command,
+        intent: 'reopen_task_thread',
+        visibility: 'system_hidden',
+        delivery: 'dispatch_now',
+        activeRunPolicy: 'block_outputs',
+    });
+    return {
+        execute,
+        submitMemoryNotice,
+        sealTaskThread,
+        hardCloseTaskThread,
+        reopenTaskThread,
+    };
+}