@jungjaehoon/mama-core 1.5.0 → 1.7.0

package/dist/agent-graph/types.d.ts

@@ -0,0 +1,162 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { EntityAlias, EntityAliasLabelType, EntityNode } from '../entities/types.js';
+import type { TwinEdgeRecord, TwinEdgeType, TwinProjectRef, TwinRef, TwinScopeRef } from '../edges/types.js';
+export type AgentGraphAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export interface AgentGraphEdgeFilters {
+    edge_types?: TwinEdgeType[];
+}
+export interface ResolveEntityInput {
+    label: string;
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    project_refs?: TwinProjectRef[];
+    tenant_id?: string | null;
+    context_refs?: TwinRef[];
+    limit?: number;
+    as_of_ms?: number | null;
+}
+export interface ResolvedEntityCandidate {
+    entity: EntityNode;
+    matched_label: string;
+    match_source: 'preferred_label' | 'alias' | 'observation';
+    score: number;
+}
+export interface ResolveEntityResult {
+    entity: EntityNode | null;
+    candidates: ResolvedEntityCandidate[];
+}
+export interface GraphNeighborhoodInput {
+    ref: TwinRef;
+    depth?: number;
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    project_refs?: TwinProjectRef[];
+    tenant_id?: string | null;
+    edge_filters?: AgentGraphEdgeFilters;
+    as_of_ms?: number | null;
+    limit?: number;
+}
+export interface AgentGraphResult {
+    nodes: TwinRef[];
+    edges: TwinEdgeRecord[];
+}
+export interface GraphPathsInput {
+    from_ref: TwinRef;
+    to_ref: TwinRef;
+    max_depth?: number;
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    project_refs?: TwinProjectRef[];
+    tenant_id?: string | null;
+    edge_filters?: AgentGraphEdgeFilters;
+    as_of_ms?: number | null;
+    limit?: number;
+}
+export interface AgentGraphPath {
+    refs: TwinRef[];
+    edges: TwinEdgeRecord[];
+}
+export interface GraphPathsResult {
+    paths: AgentGraphPath[];
+}
+export interface GraphTimelineInput {
+    ref: TwinRef;
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    project_refs?: TwinProjectRef[];
+    tenant_id?: string | null;
+    edge_filters?: AgentGraphEdgeFilters;
+    from_ms?: number;
+    to_ms?: number;
+    as_of_ms?: number | null;
+    limit?: number;
+}
+export interface AgentGraphTimelineMemoryEvent {
+    kind: 'memory';
+    at_ms: number;
+    ref: Extract<TwinRef, {
+        kind: 'memory';
+    }>;
+    memory: {
+        id: string;
+        topic: string | null;
+        decision: string | null;
+        created_at: number;
+        event_datetime: number | null;
+    };
+}
+export interface AgentGraphTimelineCaseEvent {
+    kind: 'case';
+    at_ms: number;
+    ref: Extract<TwinRef, {
+        kind: 'case';
+    }>;
+    case: {
+        case_id: string;
+        title: string;
+        status: string;
+        created_at: string | number;
+        updated_at: string | number;
+        last_activity_at: string | null;
+    };
+}
+export interface AgentGraphTimelineEntityEvent {
+    kind: 'entity';
+    at_ms: number;
+    ref: Extract<TwinRef, {
+        kind: 'entity';
+    }>;
+    entity: EntityNode;
+}
+export interface AgentGraphTimelineRawEvent {
+    kind: 'raw';
+    at_ms: number;
+    ref: Extract<TwinRef, {
+        kind: 'raw';
+    }>;
+    raw: {
+        event_index_id: string;
+        source_connector: string;
+        source_type: string;
+        source_id: string;
+        source_locator: string | null;
+        title: string | null;
+        event_datetime: number | null;
+        source_timestamp_ms: number;
+    };
+}
+export interface AgentGraphTimelineEdgeEvent {
+    kind: 'edge';
+    at_ms: number;
+    edge: TwinEdgeRecord;
+}
+export type AgentGraphTimelineEvent = AgentGraphTimelineMemoryEvent | AgentGraphTimelineCaseEvent | AgentGraphTimelineEntityEvent | AgentGraphTimelineRawEvent | AgentGraphTimelineEdgeEvent;
+export interface GraphTimelineResult {
+    ref: TwinRef;
+    events: AgentGraphTimelineEvent[];
+}
+export interface AttachEntityAliasWithEdgeInput {
+    entity_id: string;
+    label: string;
+    label_type?: EntityAliasLabelType;
+    lang?: string | null;
+    script?: string | null;
+    confidence?: number | null;
+    source_type: string;
+    source_ref?: string | null;
+    source_refs?: TwinRef[];
+    agent_id: string;
+    model_run_id: string;
+    envelope_hash: string;
+    request_idempotency_key?: string;
+    edge_idempotency_key?: string;
+    scopes?: TwinScopeRef[];
+    connectors?: string[];
+    project_refs?: TwinProjectRef[];
+    tenant_id?: string | null;
+}
+export interface AttachEntityAliasWithEdgeResult {
+    alias: EntityAlias;
+    edge: TwinEdgeRecord;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/agent-graph/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/agent-situation/builder.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import { type AgentSituationSourceReadInput, type VisibleAgentSituationSources } from './source-readers.js';
+import type { AgentSituationInput, AgentSituationPacketRecord } from './types.js';
+type SituationBuilderAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export declare function listVisibleAgentSituationSources(adapter: SituationBuilderAdapter, input: AgentSituationSourceReadInput): VisibleAgentSituationSources;
+export declare function buildAgentSituationPacketRecord(adapter: SituationBuilderAdapter, input: AgentSituationInput): AgentSituationPacketRecord;
+export {};
+//# sourceMappingURL=builder.d.ts.map

package/dist/agent-situation/builder.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listVisibleAgentSituationSources = listVisibleAgentSituationSources;
+exports.buildAgentSituationPacketRecord = buildAgentSituationPacketRecord;
+const node_crypto_1 = require("node:crypto");
+const canonicalize_js_1 = require("../canonicalize.js");
+const cache_key_js_1 = require("./cache-key.js");
+const ranking_policy_js_1 = require("./ranking-policy.js");
+const source_readers_js_1 = require("./source-readers.js");
+function iso(ms) {
+    return new Date(ms).toISOString();
+}
+function ttlForRange(rangeStartMs, rangeEndMs) {
+    const rangeMs = Math.max(0, rangeEndMs - rangeStartMs);
+    const dayMs = 24 * 60 * 60 * 1000;
+    if (rangeMs <= 7 * dayMs) {
+        return 120;
+    }
+    if (rangeMs <= 30 * dayMs) {
+        return 300;
+    }
+    return 900;
+}
+function topStrings(values, limit = 3) {
+    return values
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .slice(0, limit);
+}
+function refKey(ref) {
+    return `${ref.kind}:${ref.id}`;
+}
+function buildBriefing(sources) {
+    const memories = sources.memories;
+    const openQuestions = memories.filter((memory) => memory.is_open_question);
+    const lowConfidence = [...memories, ...sources.cases, ...sources.edges].filter((candidate) => typeof candidate.confidence === 'number' && candidate.confidence < 0.6);
+    return {
+        decisions: topStrings(memories.map((memory) => memory.summary || memory.title)),
+        facts: topStrings(sources.raw.map((raw) => raw.summary)),
+        open_questions: topStrings(openQuestions.map((memory) => memory.summary || memory.title)),
+        risks: topStrings([
+            ...lowConfidence.map((candidate) => candidate.summary || candidate.title),
+            ...sources.cases
+                .filter((item) => item.status === 'blocked')
+                .map((item) => `${item.title}: ${item.status}`),
+        ]),
+    };
+}
+function buildCoverage(sources, input) {
+    const coverage = [];
+    for (const connector of input.effective_filters.connectors) {
+        for (const scope of input.effective_filters.scopes) {
+            const raw = sources.raw.filter((item) => item.connector === connector &&
+                item.scope?.kind === scope.kind &&
+                item.scope.id === scope.id);
+            const memories = sources.memories.filter((item) => item.scope?.kind === scope.kind && item.scope.id === scope.id);
+            const cases = sources.cases.filter((item) => item.scope?.kind === scope.kind && item.scope.id === scope.id);
+            const rowRefs = new Set([...raw, ...memories, ...cases].map((item) => refKey(item.ref)));
+            const edges = sources.edges.filter((item) => rowRefs.has(refKey(item.subject_ref)) && rowRefs.has(refKey(item.object_ref)));
+            const lastSeenMs = Math.max(0, ...raw.map((item) => item.timestamp_ms), ...memories.map((item) => item.timestamp_ms), ...cases.map((item) => item.timestamp_ms), ...edges.map((item) => item.timestamp_ms));
+            coverage.push({
+                connector,
+                channel_id: raw[0]?.channel_id ?? null,
+                memory_scope: scope,
+                raw_count: raw.length,
+                memory_count: memories.length,
+                case_count: cases.length,
+                edge_count: edges.length,
+                last_seen: lastSeenMs > 0 ? iso(lastSeenMs) : null,
+                stale: lastSeenMs > 0
+                    ? (input.now_ms ?? Date.now()) - lastSeenMs > 30 * 24 * 60 * 60 * 1000
+                    : true,
+            });
+        }
+    }
+    return coverage;
+}
+function buildRankedItems(sources, limit) {
+    const policy = (0, ranking_policy_js_1.getAgentSituationRankingPolicy)();
+    const candidates = [...sources.raw, ...sources.memories, ...sources.cases, ...sources.edges];
+    return candidates
+        .map((candidate) => {
+        const score = (0, ranking_policy_js_1.scoreAgentSituationCandidate)(candidate, policy);
+        return {
+            ref: candidate.ref,
+            kind: candidate.kind,
+            score: score.score,
+            reasons: score.reasons,
+            caveats: score.caveats,
+        };
+    })
+        .sort((left, right) => right.score - left.score || left.ref.id.localeCompare(right.ref.id))
+        .slice(0, limit);
+}
+function buildRecommendations(sources, rankedItems) {
+    const recommendations = [];
+    const expectedRefs = rankedItems.map((item) => item.ref);
+    if (sources.memories.some((memory) => memory.is_open_question) || sources.raw.length > 0) {
+        recommendations.push({
+            tool: 'raw.searchAll',
+            args: {
+                query: sources.memories.find((memory) => memory.is_open_question)?.title ?? 'recent work',
+            },
+            reason: 'visible_open_question_needs_evidence',
+            expected_refs: expectedRefs.filter((ref) => ref.kind === 'raw' || ref.kind === 'memory'),
+        });
+    }
+    const topRaw = sources.raw[0];
+    if (topRaw) {
+        recommendations.push({
+            tool: 'raw.window',
+            args: { raw_id: topRaw.ref.id },
+            reason: 'inspect_visible_raw_context',
+            expected_refs: [topRaw.ref],
+        });
+    }
+    return recommendations;
+}
+function sourceRefs(sources) {
+    return [
+        ...sources.raw.map((item) => item.ref),
+        ...sources.memories.map((item) => item.ref),
+        ...sources.cases.map((item) => item.ref),
+        ...sources.edges.map((item) => item.ref),
+    ];
+}
+function primaryScope(input) {
+    const scope = input.scope[0] ?? input.effective_filters.scopes[0];
+    if (!scope) {
+        throw new Error('agent.situation requires at least one effective memory scope');
+    }
+    return scope;
+}
+function primaryProjectId(input) {
+    const project = input.effective_filters.project_refs[0];
+    if (!project) {
+        throw new Error('agent.situation requires at least one effective project ref');
+    }
+    return project.id;
+}
+function json(value) {
+    return (0, canonicalize_js_1.canonicalizeJSON)(value);
+}
+function listVisibleAgentSituationSources(adapter, input) {
+    return (0, source_readers_js_1.listVisibleAgentSituationSources)(adapter, input);
+}
+function buildAgentSituationPacketRecord(adapter, input) {
+    const rankingPolicyVersion = input.ranking_policy_version ?? ranking_policy_js_1.AGENT_SITUATION_V0_POLICY_VERSION;
+    const nowMs = Math.floor(input.now_ms ?? Date.now());
+    const limit = Math.floor(input.limit);
+    const effectiveFilters = (0, cache_key_js_1.normalizeAgentSituationEffectiveFilters)(input.effective_filters);
+    const normalizedInput = { ...input, effective_filters: effectiveFilters };
+    const sources = (0, source_readers_js_1.listVisibleAgentSituationSources)(adapter, {
+        effective_filters: effectiveFilters,
+        range_start_ms: input.range_start_ms,
+        range_end_ms: input.range_end_ms,
+        limit,
+    });
+    const key = (0, cache_key_js_1.buildAgentSituationCacheKey)({
+        ...effectiveFilters,
+        range_start_ms: input.range_start_ms,
+        range_end_ms: input.range_end_ms,
+        focus: input.focus,
+        limit,
+        ranking_policy_version: rankingPolicyVersion,
+    });
+    const ttlSeconds = ttlForRange(input.range_start_ms, input.range_end_ms);
+    const expiresAt = nowMs + ttlSeconds * 1000;
+    const scope = primaryScope(input);
+    const rankedItems = buildRankedItems(sources, limit);
+    const briefing = buildBriefing(sources);
+    const coverage = buildCoverage(sources, normalizedInput);
+    const visibleSourceRefs = sourceRefs(sources);
+    const pendingHumanQuestions = sources.memories
+        .filter((memory) => memory.is_open_question)
+        .slice(0, 3)
+        .map((memory) => ({
+        memory_id: memory.ref.id,
+        title: memory.title,
+        summary: memory.summary,
+    }));
+    const caveats = visibleSourceRefs.length === 0 ? ['no_visible_sources'] : [];
+    const recommendedNextTools = buildRecommendations(sources, rankedItems);
+    const topMemoryRefs = sources.memories.map((memory) => memory.ref.id).slice(0, limit);
+    const freshness = {
+        generated_at_ms: nowMs,
+        visible_source_count: visibleSourceRefs.length,
+    };
+    return {
+        packet_id: `situ_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`,
+        cache_key: key.cacheKey,
+        scope_json: json(input.scope),
+        scope: input.scope,
+        scope_hash: key.scopeHash,
+        range_start_ms: Math.floor(input.range_start_ms),
+        range_end_ms: Math.floor(input.range_end_ms),
+        focus_json: json(input.focus),
+        focus: input.focus,
+        envelope_hash: input.envelope_hash,
+        envelope_effective_filters_json: json(effectiveFilters),
+        envelope_effective_filters: effectiveFilters,
+        envelope_effective_filters_hash: key.filtersHash,
+        ranking_policy_version: rankingPolicyVersion,
+        generated_at: nowMs,
+        expires_at: expiresAt,
+        ttl_seconds: ttlSeconds,
+        freshness_json: json(freshness),
+        freshness,
+        source_coverage_json: json(coverage),
+        source_coverage: coverage,
+        briefing_json: json(briefing),
+        briefing,
+        ranked_items_json: json(rankedItems),
+        ranked_items: rankedItems,
+        top_memory_refs_json: json(topMemoryRefs),
+        top_memory_refs: topMemoryRefs,
+        pending_human_questions_json: json(pendingHumanQuestions),
+        pending_human_questions: pendingHumanQuestions,
+        entity_clusters_json: '[]',
+        entity_clusters: [],
+        recommended_next_tools_json: json(recommendedNextTools),
+        recommended_next_tools: recommendedNextTools,
+        generated_from_slice_ids_json: '[]',
+        generated_from_slice_ids: [],
+        caveats_json: json(caveats),
+        caveats,
+        agent_id: input.agent_id,
+        model_run_id: input.model_run_id,
+        input_snapshot_ref: `situation:${key.cacheKey}`,
+        source_refs_json: json(visibleSourceRefs),
+        source_refs: visibleSourceRefs,
+        tenant_id: effectiveFilters.tenant_id,
+        project_id: primaryProjectId(normalizedInput),
+        memory_scope_kind: scope.kind,
+        memory_scope_id: scope.id,
+        created_at: nowMs,
+    };
+}
+//# sourceMappingURL=builder.js.map

package/dist/agent-situation/cache-key.d.ts

@@ -0,0 +1,4 @@
+import type { AgentSituationCacheKeyInput, AgentSituationCacheKeyResult, AgentSituationEffectiveFilters } from './types.js';
+export declare function normalizeAgentSituationEffectiveFilters(input: AgentSituationEffectiveFilters): AgentSituationEffectiveFilters;
+export declare function buildAgentSituationCacheKey(input: AgentSituationCacheKeyInput): AgentSituationCacheKeyResult;
+//# sourceMappingURL=cache-key.d.ts.map

package/dist/agent-situation/cache-key.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAgentSituationEffectiveFilters = normalizeAgentSituationEffectiveFilters;
+exports.buildAgentSituationCacheKey = buildAgentSituationCacheKey;
+const node_crypto_1 = require("node:crypto");
+const canonicalize_js_1 = require("../canonicalize.js");
+function sha256Hex(value) {
+    return (0, node_crypto_1.createHash)('sha256').update((0, canonicalize_js_1.canonicalizeJSON)(value), 'utf8').digest('hex');
+}
+function uniqueSorted(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
+}
+function normalizeScopes(scopes) {
+    const byKey = new Map();
+    for (const scope of scopes) {
+        const normalized = { kind: scope.kind, id: scope.id.trim() };
+        if (normalized.id.length > 0) {
+            byKey.set(`${normalized.kind}:${normalized.id}`, normalized);
+        }
+    }
+    return [...byKey.values()].sort((left, right) => `${left.kind}:${left.id}`.localeCompare(`${right.kind}:${right.id}`));
+}
+function normalizeProjectRefs(projectRefs) {
+    const byId = new Map();
+    for (const project of projectRefs) {
+        const normalized = { kind: 'project', id: project.id.trim() };
+        if (normalized.id.length > 0) {
+            byId.set(normalized.id, normalized);
+        }
+    }
+    return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function normalizeFocus(focus) {
+    return [...new Set(focus)].sort();
+}
+function normalizeAgentSituationEffectiveFilters(input) {
+    return {
+        scopes: normalizeScopes(input.scopes),
+        connectors: uniqueSorted(input.connectors),
+        project_refs: normalizeProjectRefs(input.project_refs),
+        tenant_id: input.tenant_id.trim() || 'default',
+        as_of: input.as_of ?? null,
+    };
+}
+function buildAgentSituationCacheKey(input) {
+    const effective = normalizeAgentSituationEffectiveFilters(input);
+    const canonicalInput = {
+        ...effective,
+        range_start_ms: Math.floor(input.range_start_ms),
+        range_end_ms: Math.floor(input.range_end_ms),
+        focus: normalizeFocus(input.focus),
+        limit: Math.floor(input.limit),
+        ranking_policy_version: input.ranking_policy_version,
+    };
+    const canonicalJson = (0, canonicalize_js_1.canonicalizeJSON)(canonicalInput);
+    return {
+        cacheKey: (0, node_crypto_1.createHash)('sha256').update(canonicalJson, 'utf8').digest('hex'),
+        canonicalInput,
+        canonicalJson,
+        filtersHash: sha256Hex(effective),
+        scopeHash: sha256Hex(effective.scopes),
+    };
+}
+//# sourceMappingURL=cache-key.js.map

package/dist/agent-situation/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './cache-key.js';
+export * from './ranking-policy.js';
+export { listVisibleRawCandidates, listVisibleMemoryCandidates, listVisibleCaseCandidates, listVisibleEdgeCandidates, type AgentSituationSourceReadInput, type VisibleAgentSituationSources, type VisibleRawCandidate, type VisibleMemoryCandidate, type VisibleCaseCandidate, type VisibleEdgeCandidate, } from './source-readers.js';
+export * from './builder.js';
+export * from './packet-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agent-situation/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listVisibleEdgeCandidates = exports.listVisibleCaseCandidates = exports.listVisibleMemoryCandidates = exports.listVisibleRawCandidates = void 0;
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./cache-key.js"), exports);
+__exportStar(require("./ranking-policy.js"), exports);
+var source_readers_js_1 = require("./source-readers.js");
+Object.defineProperty(exports, "listVisibleRawCandidates", { enumerable: true, get: function () { return source_readers_js_1.listVisibleRawCandidates; } });
+Object.defineProperty(exports, "listVisibleMemoryCandidates", { enumerable: true, get: function () { return source_readers_js_1.listVisibleMemoryCandidates; } });
+Object.defineProperty(exports, "listVisibleCaseCandidates", { enumerable: true, get: function () { return source_readers_js_1.listVisibleCaseCandidates; } });
+Object.defineProperty(exports, "listVisibleEdgeCandidates", { enumerable: true, get: function () { return source_readers_js_1.listVisibleEdgeCandidates; } });
+__exportStar(require("./builder.js"), exports);
+__exportStar(require("./packet-store.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/agent-situation/packet-store.d.ts

@@ -0,0 +1,27 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { AgentSituationLease, AgentSituationPacketRecord } from './types.js';
+type PacketStoreAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export interface AcquireAgentSituationLeaseInput {
+    cacheKey: string;
+    rankingPolicyVersion: string;
+    leaseOwner: string;
+    nowMs: number;
+    leaseSeconds: number;
+}
+export interface AgentSituationRefreshInput {
+    cacheKey: string;
+    rankingPolicyVersion: string;
+    nowMs: number;
+    leaseOwner: string;
+    leaseSeconds?: number;
+    pollIntervalMs?: number;
+    maxPollMs?: number;
+    refresh?: boolean;
+}
+export declare function getFreshAgentSituationPacket(adapter: PacketStoreAdapter, cacheKey: string, rankingPolicyVersion: string, nowMs: number): AgentSituationPacketRecord | null;
+export declare function insertAgentSituationPacket(adapter: PacketStoreAdapter, packet: AgentSituationPacketRecord): AgentSituationPacketRecord;
+export declare function acquireAgentSituationLease(adapter: PacketStoreAdapter, input: AcquireAgentSituationLeaseInput): AgentSituationLease | null;
+export declare function releaseAgentSituationLease(adapter: PacketStoreAdapter, cacheKey: string, leaseOwner: string): void;
+export declare function getOrRefreshAgentSituationPacket(adapter: PacketStoreAdapter, input: AgentSituationRefreshInput, builder: () => Promise<AgentSituationPacketRecord> | AgentSituationPacketRecord): Promise<AgentSituationPacketRecord>;
+export {};
+//# sourceMappingURL=packet-store.d.ts.map