@afu_context/afu-context 0.0.0-stage → 0.1.7

package/src/afu_host_integrations/shared/runtime-client/dist/prefix.js

@@ -0,0 +1,12 @@
+/** Keep the host prefix unchanged; coverage instructions are appended at its end. */
+export function summaryPrefix(entries, ids, prompt) {
+    if (!ids?.length)
+        return { messages: [], prompt }; // artifact-only consolidation
+    const start = entries.findIndex(entry => entry.id === ids[0]);
+    if (start < 0 || ids.some((id, i) => entries[start + i]?.id !== id))
+        throw new Error("Summary source no longer matches host history");
+    const before = entries.slice(0, start).flatMap(e => [...e.messages]).length;
+    const messages = entries.slice(0, start + ids.length).flatMap(e => [...e.messages]);
+    return { messages, prompt: before === 0 ? prompt : `${prompt}\nSource scope: use only messages ${before + 1} through ${messages.length} (one-based) as new source, together with any previous summary supplied in this request. Earlier messages are context only; do not import additional facts from them. Return one replacement summary.` };
+}
+//# sourceMappingURL=prefix.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/protocol.js

@@ -0,0 +1,79 @@
+export function findAppliedArtifact(result) {
+    for (const item of result.items) {
+        const replaced = item.metadata?.replaced_item_ids;
+        if (item.kind !== "artifact" || !Array.isArray(replaced))
+            continue;
+        const replacedItemIds = replaced.filter((value) => typeof value === "string");
+        if (replacedItemIds.length === 0)
+            continue;
+        const artifactId = item.metadata?.artifact_id;
+        return {
+            item,
+            replacedItemIds,
+            ...(typeof artifactId === "string" ? { artifactId } : {}),
+        };
+    }
+    return undefined;
+}
+export function normalizeContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && value.every(isJsonObject)) {
+        return structuredClone(value);
+    }
+    return safeStringify(value);
+}
+/** Same weights as the Python HeuristicTokenEstimator. */
+function characterWeight(code) {
+    if ((code >= 0x4e00 && code <= 0x9fff) || (code >= 0x3400 && code <= 0x4dbf))
+        return 1;
+    if ((code >= 0xac00 && code <= 0xd7af) || (code >= 0x1100 && code <= 0x11ff))
+        return 1;
+    if (code >= 0x3040 && code <= 0x30ff)
+        return 1;
+    if (code >= 0x1f000)
+        return 1;
+    if (code >= 0x0370)
+        return 0.5;
+    return 0.25;
+}
+export function estimateContentTokens(content) {
+    const text = typeof content === "string" ? content : JSON.stringify(content);
+    let units = 0;
+    for (const character of text)
+        units += characterWeight(character.codePointAt(0) ?? 0);
+    return text.length === 0 ? 0 : Math.max(1, Math.ceil(units));
+}
+function isJsonObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    return Object.values(value).every(isJsonValue);
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    return isJsonObject(value);
+}
+function safeStringify(value) {
+    try {
+        const encoded = JSON.stringify(value);
+        return encoded ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** An opaque observation ID travels with the exact replacement artifact. */
+export function observationId(result) {
+    const applied = findAppliedArtifact(result);
+    if (!applied?.artifactId)
+        return undefined;
+    const artifact = result.artifacts.find(a => a.id === applied.artifactId);
+    const metadata = artifact?.metadata;
+    const id = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata.observation_id : undefined;
+    return typeof id === "string" && /^[a-f0-9]{24}$/.test(id) ? id : undefined;
+}
+//# sourceMappingURL=protocol.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/telemetry.js

@@ -0,0 +1,58 @@
+import { appendFileSync, openSync, closeSync, mkdirSync, statSync, renameSync, constants, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID, createHash } from 'node:crypto';
+export const sessionHash = (value) => createHash('sha256').update(value).digest('hex').slice(0, 16);
+const journals = new Map();
+export function journal(host) {
+    let log = journals.get(host);
+    if (!log) {
+        log = createJournal(host);
+        journals.set(host, log);
+        log('runtime_started');
+    }
+    return log;
+}
+function createJournal(host) {
+    const root = join(process.env.AFU_STATE_DIR ?? join(homedir(), '.local/share/afu-context'), 'logs');
+    const id = randomUUID().replaceAll('-', '');
+    const file = join(root, `events-${process.pid}-${id}.jsonl`);
+    let version = '0.1.0', build = 'development';
+    try {
+        const m = JSON.parse(readFileSync(join(process.env.AFU_INSTALL_ROOT ?? process.cwd(), 'release.json'), 'utf8'));
+        if (/^[a-f0-9]{12,64}$/.test(m.build))
+            build = m.build;
+        if (/^[0-9.]+$/.test(m.version))
+            version = m.version;
+    }
+    catch { }
+    return (event, fields = {}) => {
+        try {
+            const row = { event, host, version, build, runtime_id: id, pid: process.pid, time: new Date().toISOString() };
+            // COSEC: diagnostics never include raw model IDs, credentials, prompts or errors.
+            for (const [k, v] of Object.entries(fields)) {
+                if (['session', 'artifact_id', 'phase', 'reason'].includes(k) && typeof v === 'string' && /^[A-Za-z0-9_.:+-]{1,100}$/.test(v))
+                    row[k] = v;
+                if (['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens', 'context_window', 'threshold', 'duration_ms', 'host_compaction_ms'].includes(k) && typeof v === 'number' && Number.isFinite(v) && v >= 0)
+                    row[k] = v;
+                if (['cache_usage_known', 'applied', 'upstream_success'].includes(k) && typeof v === 'boolean')
+                    row[k] = v;
+            }
+            mkdirSync(root, { recursive: true, mode: 0o700 });
+            try {
+                if (statSync(file).size > 2 * 1024 * 1024)
+                    renameSync(file, file.replace('.jsonl', '.previous.jsonl'));
+            }
+            catch { }
+            const fd = openSync(file, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | (constants.O_NOFOLLOW ?? 0), 0o600);
+            try {
+                appendFileSync(fd, JSON.stringify(row) + '\n');
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        catch { } // Logging must never break a host request.
+    };
+}
+//# sourceMappingURL=telemetry.js.map