@jungjaehoon/mama-core 1.7.0 → 1.8.1

package/dist/memory-inject.js

@@ -77,7 +77,7 @@ async function injectDecisionContext(userMessage) {
 async function performMemoryInjection(userMessage, startTime) {
     // 1. Generate query embedding
     const { generateEmbedding } = await import('./embeddings.js');
-    const queryEmbedding = await generateEmbedding(userMessage);
+    const queryEmbedding = await generateEmbedding(userMessage, 'query');
     const embeddingLatency = Date.now() - startTime;
     (0, debug_logger_js_1.info)(`[MAMA] Embedding generation: ${embeddingLatency}ms`);
     // 2. Adaptive threshold (shorter queries need higher confidence)

package/dist/provenance/source-ref.d.ts

@@ -0,0 +1,29 @@
+import { type ContextRef } from '../context-compile/types.js';
+export declare const STRICT_SOURCE_REF_KINDS: readonly ["memory", "raw", "entity", "case", "decision", "os_task", "agent_situation_packet", "report_slot", "context_packet", "model_run", "tool_trace", "wiki_page", "report"];
+export type StrictSourceRefKind = (typeof STRICT_SOURCE_REF_KINDS)[number];
+export declare const LEGACY_SOURCE_REF_KINDS: readonly ["message", "conversation", "raw_memory"];
+export type LegacySourceRefKind = (typeof LEGACY_SOURCE_REF_KINDS)[number];
+export type SourceRef = {
+    kind: Exclude<StrictSourceRefKind, 'raw'>;
+    id: string;
+} | {
+    kind: 'raw';
+    id: string;
+    connector: string;
+    source_id?: string;
+    channel_id?: string | null;
+} | {
+    kind: 'legacy';
+    legacy_kind: LegacySourceRefKind;
+    id: string;
+};
+export declare function fromContextRef(ref: ContextRef): SourceRef;
+export declare function toContextRef(ref: SourceRef): ContextRef | null;
+export declare function fromVerifyArtifact(artifact: {
+    type: string;
+    id: string;
+}): SourceRef;
+export declare function parseSourceRefString(value: string): SourceRef;
+export declare function serializeSourceRef(ref: SourceRef): string;
+export declare function assertNonEmptySourceRefs(refs: readonly SourceRef[]): void;
+//# sourceMappingURL=source-ref.d.ts.map

package/dist/provenance/source-ref.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_SOURCE_REF_KINDS = exports.STRICT_SOURCE_REF_KINDS = void 0;
+exports.fromContextRef = fromContextRef;
+exports.toContextRef = toContextRef;
+exports.fromVerifyArtifact = fromVerifyArtifact;
+exports.parseSourceRefString = parseSourceRefString;
+exports.serializeSourceRef = serializeSourceRef;
+exports.assertNonEmptySourceRefs = assertNonEmptySourceRefs;
+const types_js_1 = require("../context-compile/types.js");
+exports.STRICT_SOURCE_REF_KINDS = [
+    'memory',
+    'raw',
+    'entity',
+    'case',
+    'decision',
+    'os_task',
+    'agent_situation_packet',
+    'report_slot',
+    'context_packet',
+    'model_run',
+    'tool_trace',
+    'wiki_page',
+    'report',
+];
+exports.LEGACY_SOURCE_REF_KINDS = ['message', 'conversation', 'raw_memory'];
+const STRICT_SOURCE_REF_KIND_SET = new Set(exports.STRICT_SOURCE_REF_KINDS);
+const CONTEXT_REF_KIND_SET = new Set(types_js_1.CONTEXT_REF_KINDS);
+const LEGACY_SOURCE_REF_KIND_SET = new Set(exports.LEGACY_SOURCE_REF_KINDS);
+const VERIFY_ARTIFACT_KIND_SET = new Set([
+    'decision',
+    'os_task',
+    'agent_situation_packet',
+    'report_slot',
+    'context_packet',
+    'model_run',
+    'tool_trace',
+]);
+function requiredString(value, field) {
+    if (typeof value !== 'string') {
+        throw new Error(`Source ref ${field} must be a string`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`Source ref ${field} must not be empty`);
+    }
+    return trimmed;
+}
+function optionalString(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return requiredString(value, field);
+}
+function optionalNullableString(value, field) {
+    if (value === null) {
+        return null;
+    }
+    return optionalString(value, field);
+}
+function assertStrictSourceRefKind(kind) {
+    if (!STRICT_SOURCE_REF_KIND_SET.has(kind)) {
+        throw new Error(`Unsupported source ref kind: ${kind}`);
+    }
+}
+function assertLegacySourceRefKind(kind) {
+    if (!LEGACY_SOURCE_REF_KIND_SET.has(kind)) {
+        throw new Error(`Unsupported legacy source ref kind: ${kind}`);
+    }
+}
+function assertContextSourceRefKind(kind) {
+    if (kind === 'raw' || !CONTEXT_REF_KIND_SET.has(kind)) {
+        throw new Error(`Unsupported context source ref kind: ${kind}`);
+    }
+}
+function fromContextRef(ref) {
+    if (ref === null || ref === undefined) {
+        throw new Error('Context ref must not be null or undefined');
+    }
+    const input = ref;
+    const kind = requiredString(input.kind, 'kind');
+    if (kind === 'raw') {
+        const normalized = {
+            kind: 'raw',
+            id: requiredString(input.raw_id, 'raw_id'),
+            connector: requiredString(input.connector, 'connector'),
+        };
+        const sourceId = optionalString(input.source_id, 'source_id');
+        const channelId = optionalNullableString(input.channel_id, 'channel_id');
+        if (sourceId !== undefined) {
+            normalized.source_id = sourceId;
+        }
+        if (channelId !== undefined) {
+            normalized.channel_id = channelId;
+        }
+        return normalized;
+    }
+    assertContextSourceRefKind(kind);
+    return {
+        kind,
+        id: requiredString(input.id, 'id'),
+    };
+}
+function toContextRef(ref) {
+    if (ref === null || ref === undefined) {
+        return null;
+    }
+    switch (ref.kind) {
+        case 'memory':
+        case 'entity':
+        case 'case':
+            return {
+                kind: ref.kind,
+                id: requiredString(ref.id, 'id'),
+            };
+        case 'raw': {
+            const normalized = {
+                kind: 'raw',
+                raw_id: requiredString(ref.id, 'id'),
+                connector: requiredString(ref.connector, 'connector'),
+            };
+            const sourceId = optionalString(ref.source_id, 'source_id');
+            const channelId = optionalNullableString(ref.channel_id, 'channel_id');
+            if (sourceId !== undefined) {
+                normalized.source_id = sourceId;
+            }
+            if (channelId !== undefined) {
+                normalized.channel_id = channelId;
+            }
+            return normalized;
+        }
+        default:
+            return null;
+    }
+}
+function fromVerifyArtifact(artifact) {
+    if (artifact === null || artifact === undefined) {
+        throw new Error('Artifact must not be null or undefined');
+    }
+    const kind = requiredString(artifact.type, 'type');
+    if (!VERIFY_ARTIFACT_KIND_SET.has(kind)) {
+        throw new Error(`Unsupported verify artifact source ref kind: ${kind}`);
+    }
+    assertStrictSourceRefKind(kind);
+    if (kind === 'raw') {
+        throw new Error('Verify artifact source refs cannot use raw kind');
+    }
+    return {
+        kind,
+        id: requiredString(artifact.id, 'id'),
+    };
+}
+function parseSourceRefString(value) {
+    const rawValue = requiredString(value, 'value');
+    const parts = rawValue.split(':');
+    const kind = requiredString(parts[0], 'kind');
+    if (kind === 'raw') {
+        const connector = requiredString(parts[1], 'connector');
+        const id = requiredString(parts.slice(2).join(':'), 'id');
+        return { kind: 'raw', connector, id };
+    }
+    if (LEGACY_SOURCE_REF_KIND_SET.has(kind)) {
+        assertLegacySourceRefKind(kind);
+        return {
+            kind: 'legacy',
+            legacy_kind: kind,
+            id: requiredString(parts.slice(1).join(':'), 'id'),
+        };
+    }
+    assertStrictSourceRefKind(kind);
+    if (kind === 'raw') {
+        throw new Error('Raw source refs must include connector and id');
+    }
+    const sourceKind = kind;
+    return {
+        kind: sourceKind,
+        id: requiredString(parts.slice(1).join(':'), 'id'),
+    };
+}
+function serializeSourceRef(ref) {
+    if (ref === null || ref === undefined) {
+        throw new Error('Source ref must not be null or undefined');
+    }
+    switch (ref.kind) {
+        case 'raw':
+            return `raw:${requiredString(ref.connector, 'connector')}:${requiredString(ref.id, 'id')}`;
+        case 'legacy':
+            assertLegacySourceRefKind(ref.legacy_kind);
+            return `${ref.legacy_kind}:${requiredString(ref.id, 'id')}`;
+        default: {
+            assertStrictSourceRefKind(ref.kind);
+            return `${ref.kind}:${requiredString(ref.id, 'id')}`;
+        }
+    }
+}
+function assertNonEmptySourceRefs(refs) {
+    if (!Array.isArray(refs) || refs.length === 0) {
+        throw new Error('Source refs must not be empty');
+    }
+    for (const ref of refs) {
+        serializeSourceRef(ref);
+    }
+}
+//# sourceMappingURL=source-ref.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-core",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "MAMA Core - Shared modules for Memory-Augmented MCP Assistant",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,6 +50,7 @@
     "./agent-situation": "./dist/agent-situation/index.js",
     "./agent-graph": "./dist/agent-graph/index.js",
     "./context-compile": "./dist/context-compile/index.js",
+    "./provenance/source-ref": "./dist/provenance/source-ref.js",
     "./edges/types": "./dist/edges/types.js",
     "./edges/store": "./dist/edges/store.js",
     "./edges/ref-validation": "./dist/edges/ref-validation.js"