@xopcai/xopc 0.0.177 → 0.0.179

package/dist/src/user-context/context-compiler.js

@@ -0,0 +1,51 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getRelationshipSettings } from "../storage/sqlite/relationship-settings-repository.js";
+import "../storage/sqlite/index.js";
+import { randomUUID } from "node:crypto";
+//#region src/user-context/context-compiler.ts
+function fromRow(row) {
+	return {
+		id: row.snapshot_id,
+		traceId: row.trace_id,
+		sessionKey: row.session_key,
+		query: row.query,
+		selectedItems: JSON.parse(row.selected_items_json),
+		rejectedItems: JSON.parse(row.rejected_items_json),
+		consentRequests: JSON.parse(row.consent_requests_json),
+		relationshipPolicy: JSON.parse(row.relationship_policy_json),
+		estimatedTokens: row.estimated_tokens,
+		...row.outcome_id ? { outcomeId: row.outcome_id } : {},
+		...row.run_id ? { runId: row.run_id } : {},
+		createdAt: row.created_at
+	};
+}
+var ContextCompiler = class {
+	capture(input) {
+		const now = input.now ?? Date.now();
+		const id = randomUUID();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO context_snapshots (
+          snapshot_id, trace_id, session_key, query, selected_items_json,
+          rejected_items_json, consent_requests_json, relationship_policy_json,
+          estimated_tokens, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.plan.traceId, input.sessionKey, input.query.trim(), JSON.stringify(input.plan.items), JSON.stringify(input.plan.rejected), JSON.stringify(input.plan.consentRequests), JSON.stringify(getRelationshipSettings()), input.plan.estimatedTokens, now);
+		});
+		return this.get(id);
+	}
+	get(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM context_snapshots WHERE snapshot_id = ?").get(id);
+		return row ? fromRow(row) : void 0;
+	}
+	latestForSession(sessionKey, since = 0) {
+		const row = getSqliteDatabase().prepare(`SELECT * FROM context_snapshots
+       WHERE session_key = ? AND created_at >= ?
+       ORDER BY created_at DESC LIMIT 1`).get(sessionKey, since);
+		return row ? fromRow(row) : void 0;
+	}
+	linkToRun(input) {
+		getSqliteDatabase().prepare(`UPDATE context_snapshots SET outcome_id = ?, run_id = ? WHERE snapshot_id = ?`).run(input.outcomeId ?? null, input.runId, input.snapshotId);
+		return this.get(input.snapshotId);
+	}
+};
+//#endregion
+export { ContextCompiler };

package/dist/src/voice/local/model-files.js

@@ -2,8 +2,8 @@ import { dirname, join } from "node:path";
 import { createReadStream, createWriteStream } from "node:fs";
 import { createHash } from "node:crypto";
 import { mkdir, rm, stat } from "node:fs/promises";
-import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
 //#region src/voice/local/model-files.ts
 function resolveModelFileUrl(remoteHost, model, file) {
 	const base = remoteHost.endsWith("/") ? remoteHost : `${remoteHost}/`;

package/dist/src/voice/stt/config.d.ts

@@ -0,0 +1,4 @@
+import type { STTConfig } from './types.js';
+export declare function mergeSttConfigFromAppConfig(stt: Partial<STTConfig> | undefined, toolsMedia?: {
+    models?: STTConfig['sharedModels'];
+}): STTConfig;

package/dist/src/voice/stt/config.js

@@ -0,0 +1,26 @@
+import { DEFAULT_STT_CONFIG } from "./types.js";
+//#region src/voice/stt/config.ts
+function mergeSttProviders(base, patch) {
+	if (!base && !patch) return void 0;
+	const merged = { ...base ?? {} };
+	for (const [id, slice] of Object.entries(patch ?? {})) merged[id] = {
+		...merged[id] ?? {},
+		...slice
+	};
+	return merged;
+}
+function mergeSttConfigFromAppConfig(stt, toolsMedia) {
+	const patch = stt ?? {};
+	return {
+		...DEFAULT_STT_CONFIG,
+		...patch,
+		providers: mergeSttProviders(DEFAULT_STT_CONFIG.providers, patch.providers),
+		fallback: {
+			...DEFAULT_STT_CONFIG.fallback,
+			...patch.fallback
+		},
+		...toolsMedia?.models?.length ? { sharedModels: toolsMedia.models } : {}
+	};
+}
+//#endregion
+export { mergeSttConfigFromAppConfig };

package/dist/src/voice/stt/index.d.ts

@@ -9,6 +9,7 @@ import './providers/index.js';
 import type { STTConfig, STTOptions, STTResult } from './types.js';
 export { transcribe } from './transcribe-core.js';
 export { isSTTAvailable } from './availability.js';
+export { mergeSttConfigFromAppConfig } from './config.js';
 /**
  * Single-provider transcription helper. Used by chat-commands /stt so a user
  * can force a specific provider regardless of fallback config.

package/dist/src/voice/stt/index.js

@@ -4,6 +4,7 @@ import "./providers/index.js";
 import { resolveSTTProviderChain, resolveSTTProviderConfig, resolveSTTProviderOrder } from "./factory.js";
 import { transcribe } from "./transcribe-core.js";
 import { isSTTAvailable } from "./availability.js";
+import { mergeSttConfigFromAppConfig } from "./config.js";
 import { checkMentionInTranscription } from "./mention.js";
 import { audioPreflightTranscribe } from "./preflight.js";
 //#region src/voice/stt/index.ts
@@ -28,4 +29,4 @@ async function transcribeWithProvider(audioBuffer, providerName, config, options
 	};
 }
 //#endregion
-export { alibabaTranscriptionProvider, audioPreflightTranscribe, checkMentionInTranscription, isSTTAvailable, openAiTranscriptionProvider, resolveSTTProviderChain, resolveSTTProviderConfig, resolveSTTProviderOrder, transcribe, transcribeWithProvider };
+export { alibabaTranscriptionProvider, audioPreflightTranscribe, checkMentionInTranscription, isSTTAvailable, mergeSttConfigFromAppConfig, openAiTranscriptionProvider, resolveSTTProviderChain, resolveSTTProviderConfig, resolveSTTProviderOrder, transcribe, transcribeWithProvider };

package/dist/src/voice/stt/list-providers.js

@@ -1,6 +1,6 @@
 import { listMediaUnderstandingProviders } from "../../media-understanding/registry.js";
 import { resolveSTTProviderConfig } from "./factory.js";
-import { mergeSttConfigFromAppConfig } from "../../channels/attachments/voice-stt-webchat.js";
+import { mergeSttConfigFromAppConfig } from "./config.js";
 import { getVoiceProviderMetadata } from "../metadata/registry.js";
 import "../metadata/index.js";
 //#region src/voice/stt/list-providers.ts

package/dist/src/work/attention-governor.d.ts

@@ -0,0 +1,20 @@
+import type { WorkHomeAttention, WorkHomeDecision } from '@xopcai/gateway-contract';
+export interface AttentionProjection {
+    decisions: WorkHomeDecision[];
+    attention: WorkHomeAttention[];
+    policy: {
+        visibleDecisionCount: number;
+        suppressedDecisionCount: number;
+        visibleAttentionCount: number;
+        suppressedAttentionCount: number;
+    };
+}
+export declare class AttentionGovernor {
+    project(input: {
+        decisions: WorkHomeDecision[];
+        attention: WorkHomeAttention[];
+        proactiveEnabled: boolean;
+        maxDecisions?: number;
+        maxAttention?: number;
+    }): AttentionProjection;
+}

package/dist/src/work/attention-governor.js

@@ -0,0 +1,46 @@
+//#region src/work/attention-governor.ts
+function decisionScore(item) {
+	if (item.reason === "approval_required") return 100;
+	if (item.reason === "needs_input") return 95;
+	if (item.reason === "blocked") return 85;
+	if (item.reason === "in_review") return 80;
+	if (item.kind === "agent_judgment") return Math.round((item.judgment?.valueScore ?? 0) * 70) + (item.urgency === "now" ? 20 : 0);
+	if (item.reason === "overdue") return 70;
+	return 50;
+}
+function decisionKey(item) {
+	const title = item.title.trim().toLocaleLowerCase();
+	return item.response ? item.id : `${item.projectId ?? "global"}:${title}:${item.reason === "approval_required" ? item.id : ""}`;
+}
+function keepDecision(item, proactiveEnabled) {
+	if (item.kind !== "agent_judgment") return true;
+	if (!proactiveEnabled) return false;
+	return (item.judgment?.confidence ?? 0) >= .65 && (item.judgment?.valueScore ?? 0) >= .6;
+}
+var AttentionGovernor = class {
+	project(input) {
+		const maxDecisions = Math.max(1, Math.min(20, input.maxDecisions ?? 7));
+		const maxAttention = Math.max(1, Math.min(10, input.maxAttention ?? 5));
+		const seen = /* @__PURE__ */ new Set();
+		const eligible = [...input.decisions].filter((item) => keepDecision(item, input.proactiveEnabled)).sort((left, right) => decisionScore(right) - decisionScore(left) || right.updatedAt - left.updatedAt).filter((item) => {
+			const key = decisionKey(item);
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		const attention = [...input.attention].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, maxAttention);
+		const decisions = eligible.slice(0, maxDecisions);
+		return {
+			decisions,
+			attention,
+			policy: {
+				visibleDecisionCount: decisions.length,
+				suppressedDecisionCount: Math.max(0, input.decisions.length - decisions.length),
+				visibleAttentionCount: attention.length,
+				suppressedAttentionCount: Math.max(0, input.attention.length - attention.length)
+			}
+		};
+	}
+};
+//#endregion
+export { AttentionGovernor };

package/dist/src/work/execution-context.d.ts

@@ -0,0 +1,16 @@
+import type { SessionMetadata } from '../session/types.js';
+import type { ExecutionReceiptContext } from '../storage/sqlite/execution-receipt-repository.js';
+export interface ExecutionContext extends ExecutionReceiptContext {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    agentId?: string;
+}
+export declare function resolveExecutionContext(input: {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    metadata: SessionMetadata;
+    agentId?: string;
+}): ExecutionContext;
+export declare function executionReceiptContext(context: ExecutionContext): ExecutionReceiptContext;

package/dist/src/work/execution-context.js

@@ -0,0 +1,66 @@
+//#region src/work/execution-context.ts
+const ORIGINS = new Set([
+	"chat",
+	"goal",
+	"workflow",
+	"automation",
+	"browser",
+	"proactive"
+]);
+const TRIGGERS = new Set([
+	"user",
+	"schedule",
+	"webhook",
+	"proactive",
+	"retry"
+]);
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function metadataOrigin(metadata) {
+	const explicit = optionalString(metadata.customData?.origin);
+	if (explicit && ORIGINS.has(explicit)) return explicit;
+	if (optionalString(metadata.customData?.goalId)) return "goal";
+	if (metadata.sessionType === "workflow-run" || metadata.sessionType === "workflow-subagent") return "workflow";
+	if (metadata.sessionType === "cron") return "automation";
+	if (metadata.sessionType === "heartbeat") return "proactive";
+	if (optionalString(metadata.customData?.browserRecipeId)) return "browser";
+	return "chat";
+}
+function metadataTrigger(metadata) {
+	const explicit = optionalString(metadata.customData?.triggerKind);
+	if (explicit && TRIGGERS.has(explicit)) return explicit;
+	if (metadata.sessionType === "cron") return "schedule";
+	if (metadata.sessionType === "heartbeat") return "proactive";
+	return "user";
+}
+function resolveExecutionContext(input) {
+	return {
+		runId: input.runId,
+		sessionKey: input.sessionKey,
+		channel: input.channel,
+		agentId: input.agentId,
+		projectId: input.metadata.projectId,
+		outcomeId: optionalString(input.metadata.customData?.outcomeId),
+		goalId: optionalString(input.metadata.customData?.goalId),
+		workItemId: optionalString(input.metadata.customData?.workItemId),
+		origin: metadataOrigin(input.metadata),
+		triggerKind: metadataTrigger(input.metadata),
+		parentRunId: optionalString(input.metadata.customData?.parentRunId),
+		contextTraceId: optionalString(input.metadata.customData?.contextTraceId)
+	};
+}
+function executionReceiptContext(context) {
+	return {
+		outcomeId: context.outcomeId,
+		projectId: context.projectId,
+		goalId: context.goalId,
+		workItemId: context.workItemId,
+		origin: context.origin,
+		triggerKind: context.triggerKind,
+		parentRunId: context.parentRunId,
+		contextTraceId: context.contextTraceId
+	};
+}
+//#endregion
+export { executionReceiptContext, resolveExecutionContext };

package/dist/src/work/home-query-service.d.ts

@@ -0,0 +1,118 @@
+import type { WorkHomeResponse } from '@xopcai/gateway-contract';
+import type { GatewayService } from '../gateway/service.js';
+import { type AutomationRun } from '../automations/index.js';
+type HomeDecision = WorkHomeResponse['decisions'][number];
+type HomeAttention = WorkHomeResponse['attention'][number];
+type HomeBriefingWin = WorkHomeResponse['briefing']['wins'][number];
+type HomeAutomation = WorkHomeResponse['upcomingAutomations'][number];
+type HomeAutomationRun = {
+    id: string;
+    automationId: string;
+    automationName?: string;
+    status: AutomationRun['status'];
+    createdAtMs: number;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    error?: string;
+    summary?: string;
+    sessionKey?: string;
+    workflowRunId?: string;
+};
+type HomeSnapshot = WorkHomeResponse & {
+    recentlyOpened: unknown[];
+    inboxCount: number;
+    pendingTasks: unknown[];
+    pendingTaskCount: number;
+    recentSessions: unknown[];
+    activeAgent: {
+        id: string;
+        name?: string;
+        description?: string;
+    };
+    gateway: Record<string, unknown>;
+    recentAutomationRuns: HomeAutomationRun[];
+};
+export declare function workItemAttentionRank(item: {
+    status: string;
+    dueAt?: number;
+    priority: string;
+    updatedAt: number;
+}, nowMs: number): number;
+export declare function buildHomeBriefing(input: {
+    locale?: string;
+    decisions: HomeDecision[];
+    attention: HomeAttention[];
+    activeWorkCount: number;
+    activeWorkflowCount: number;
+    activeGoalCount: number;
+    wins: HomeBriefingWin[];
+    nextScheduled?: HomeAutomation;
+    nowMs: number;
+}): {
+    generatedAt: number;
+    summary: string;
+    focus: {
+        id: string;
+        kind: "work_item" | "goal" | "agent_judgment" | "connector_approval" | "goal_evidence";
+        title: string;
+        reason: "approval_required" | "blocked" | "needs_input" | "in_review" | "overdue" | "due_soon" | "decision_needed";
+        urgency: "now" | "soon";
+        href: string;
+        updatedAt: number;
+        detail?: string;
+        projectId?: string;
+        projectName?: string;
+        judgment?: {
+            inboxItemId: string;
+            whyNow: string;
+            impact: string;
+            workDone: string;
+            recommendation: string;
+            confidence: number;
+            valueScore?: number;
+            decision?: {
+                question: string;
+                options: {
+                    id: string;
+                    label: string;
+                    consequence: string;
+                }[];
+            };
+        };
+        response?: {
+            kind: "connector_approval";
+            approvalId: string;
+        } | {
+            kind: "goal_evidence";
+            goalId: string;
+            requirementId: string;
+        };
+    }[];
+    progress: {
+        activeWorkCount: number;
+        activeWorkflowCount: number;
+        activeGoalCount: number;
+        movingCount: number;
+    };
+    wins: {
+        id: string;
+        kind: "work_item" | "workflow_run" | "automation_run";
+        title: string;
+        href: string;
+        completedAt: number;
+    }[];
+    nextScheduled: {
+        id: string;
+        trigger: string;
+        action: string;
+        nextRunAt: string;
+        name?: string;
+    };
+};
+export declare class WorkHomeQueryService {
+    #private;
+    private readonly service;
+    constructor(service: GatewayService);
+    getSnapshot(locale?: string): Promise<HomeSnapshot>;
+}
+export {};