@brunobracaioli/aibrain 0.2.0-beta.1 → 0.3.0-beta.13

package/dist/codex-protocol-fingerprint.json

@@ -0,0 +1,131 @@
+{
+  "version": 3,
+  "native": "0.163.0",
+  "consumed_pagination": {
+    "method": "thread/turns/list",
+    "request_schema": "v2/ThreadTurnsListParams.json",
+    "response_schema": "v2/ThreadTurnsListResponse.json",
+    "request_schema_sha256": "29717980579b77eb4c7cbd1118dd238fcb3e010f3ef5236d74bd4e4f6e02c005",
+    "response_schema_sha256": "b8425849527d5eec7abdae313afed8c78b0f8536a86ea13e0b565299792b354d",
+    "graph_sha256": "522a82295aadb10860029e5929d2d327ef77aa6a29bf6d5ea3e3de311ba60817",
+    "ordering": "asc",
+    "items_view": "full"
+  },
+  "roots": {
+    "v2/ThreadTurnsListParams.json": {
+      "methods": null,
+      "sha256": "29717980579b77eb4c7cbd1118dd238fcb3e010f3ef5236d74bd4e4f6e02c005"
+    },
+    "v2/ThreadTurnsListResponse.json": {
+      "methods": null,
+      "sha256": "b8425849527d5eec7abdae313afed8c78b0f8536a86ea13e0b565299792b354d"
+    },
+    "ClientRequest.json": {
+      "methods": [
+        "initialize",
+        "thread/start",
+        "thread/resume",
+        "thread/fork",
+        "thread/delete",
+        "thread/unsubscribe",
+        "thread/compact/start",
+        "thread/list",
+        "thread/read",
+        "thread/turns/list",
+        "thread/items/list",
+        "thread/inject_items",
+        "turn/start",
+        "mcpServer/tool/call",
+        "config/read",
+        "account/read"
+      ],
+      "sha256": "edc4fca01569666515db57c583f9d0d2d68387d42178856bd431cf34696b1904"
+    },
+    "ClientNotification.json": {
+      "methods": ["initialized"],
+      "sha256": "c6c3ba53650b9dd3aadea19e732ff67b566b162fce7abac361de0d03c91e6624"
+    },
+    "ServerRequest.json": {
+      "methods": [
+        "item/commandExecution/requestApproval",
+        "item/fileChange/requestApproval",
+        "item/tool/requestUserInput",
+        "mcpServer/elicitation/request",
+        "item/permissions/requestApproval",
+        "item/tool/call",
+        "account/chatgptAuthTokens/refresh",
+        "attestation/generate",
+        "currentTime/read",
+        "applyPatchApproval",
+        "execCommandApproval"
+      ],
+      "sha256": "f6dbc427473ebb6ffd634cb22a45f3330c48ea9719e2c54fb3f9b0c39f76ef22"
+    },
+    "ServerNotification.json": {
+      "methods": [
+        "error",
+        "thread/started",
+        "thread/status/changed",
+        "thread/deleted",
+        "thread/closed",
+        "thread/tokenUsage/updated",
+        "turn/started",
+        "turn/completed",
+        "item/started",
+        "item/completed",
+        "item/agentMessage/delta",
+        "item/mcpToolCall/progress",
+        "thread/compacted",
+        "warning"
+      ],
+      "sha256": "fbb6aa0b4baf418cd9334d642a60e4d070d67aff3dae7ac1792a37c4af79d95f"
+    },
+    "JSONRPCResponse.json": {
+      "methods": null,
+      "sha256": "7260ccd0d4c3aeebf068cbbd7e9cb8db122343a981f00c46c3658253a6e9bed5"
+    },
+    "JSONRPCNotification.json": {
+      "methods": null,
+      "sha256": "5573b596fa9025a65fc85af984e6f55189a8ab86d3e156efa301ca0eb586f089"
+    },
+    "v1/InitializeResponse.json": {
+      "methods": null,
+      "sha256": "3949f87454760303004691e3b22712ffcf3455bf430e132a5e6db510be888306"
+    },
+    "v2/ConfigReadResponse.json": {
+      "methods": null,
+      "sha256": "9fc9bdea31211e362cc7d5d66d0c0213c1dafc0b902e3a981866a88328476ea6"
+    },
+    "v2/McpServerToolCallResponse.json": {
+      "methods": null,
+      "sha256": "6f67616ad852f8cb2fc34803bfb8a0811817238a9ff74742368d904fb1f67b94"
+    },
+    "v2/ThreadCompactStartResponse.json": {
+      "methods": null,
+      "sha256": "30597c637d705b8086eced83a667814d8676d820164e93f55be5e644a085f07a"
+    },
+    "v2/ThreadForkResponse.json": {
+      "methods": null,
+      "sha256": "fbaee7dea57bfba20ede06458e1815725c6b9069a63011537cba6eca5cf9a724"
+    },
+    "v2/ThreadInjectItemsResponse.json": {
+      "methods": null,
+      "sha256": "30597c637d705b8086eced83a667814d8676d820164e93f55be5e644a085f07a"
+    },
+    "v2/ThreadReadResponse.json": {
+      "methods": null,
+      "sha256": "d92dbeb557402c3591713b14a55a09a331fa5e4338fe92f472a9ae0ff7c6fd0a"
+    },
+    "v2/ThreadResumeResponse.json": {
+      "methods": null,
+      "sha256": "3361e3179d0a2ac69377fad7358a37f01ae6e3b594d0d0eaedb87f0fa5bac169"
+    },
+    "v2/ThreadStartResponse.json": {
+      "methods": null,
+      "sha256": "fbaee7dea57bfba20ede06458e1815725c6b9069a63011537cba6eca5cf9a724"
+    }
+  },
+  "requiredClientFlags": ["app-server", "--listen", "stdio://"],
+  "requiredTerminalFlags": ["--remote", "unix://"],
+  "generatedFrom": "codex app-server generate-json-schema --experimental"
+}

package/dist/context-telemetry.mjs

@@ -0,0 +1,257 @@
+/**
+ * Browser safe v1 wire contract for content-free context telemetry.
+ *
+ * Keep this module free of Node, database and provider imports. Adapters use
+ * the same validator as the server boundary so an event rejected locally can
+ * never contain a larger or richer shape than the server accepts.
+ */
+export const CONTEXT_TELEMETRY_SCHEMA_VERSION = 1;
+export const CONTEXT_TELEMETRY_MAX_BYTES = 8 * 1024;
+export const CONTEXT_TELEMETRY_RETENTION_DAYS = 30;
+export const CONTEXT_TELEMETRY_FRESHNESS_SECONDS = 180;
+export const CONTEXT_TELEMETRY_PHASES = [
+    'connected',
+    'usage',
+    'disconnected',
+    'plan_prepared',
+    'selection_completed',
+    'notes_written',
+    'native_completed',
+    'recovery_attached',
+    'applied',
+    'fallback',
+    'failed',
+    'uncertain',
+];
+const PHASES = new Set(CONTEXT_TELEMETRY_PHASES);
+const REASONS = new Set([
+    'provider_unavailable',
+    'insufficient_reduction',
+    'protected_context',
+    'stale_context',
+    'rate_limited',
+    'native_error',
+    'recovery_pending',
+    'recovery_uncertain',
+    'unsupported',
+    'unknown',
+]);
+const UNITS = new Set(['tokens', 'estimated_tokens', 'characters']);
+const CLIENTS = new Set(['claude-code', 'codex-cli']);
+const OPERATION_PHASES = new Set([
+    'plan_prepared',
+    'selection_completed',
+    'notes_written',
+    'native_completed',
+    'recovery_attached',
+    'applied',
+    'fallback',
+    'failed',
+    'uncertain',
+]);
+const CLAUDE_PHASES = new Set([
+    'connected',
+    'usage',
+    'disconnected',
+    'plan_prepared',
+    'notes_written',
+    'native_completed',
+    'recovery_attached',
+    'applied',
+    'fallback',
+    'failed',
+    'uncertain',
+]);
+const CODEX_PHASES = new Set([
+    'connected',
+    'usage',
+    'disconnected',
+    'selection_completed',
+    'notes_written',
+    'native_completed',
+    'recovery_attached',
+    'failed',
+    'fallback',
+    'uncertain',
+]);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const SESSION_KEY = /^[0-9a-f]{64}$/;
+const UTC_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
+const SEMVER = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const MAX_SEQUENCE = 2_147_483_647;
+const MAX_COUNT = 1_000_000;
+const COUNT_KEYS = ['eligible', 'protected', 'kept', 'reduced', 'dropped', 'selected'];
+export class ContextTelemetryValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ContextTelemetryValidationError';
+    }
+}
+function fail(message) {
+    throw new ContextTelemetryValidationError(message);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function closed(value, allowed) {
+    const accepted = new Set(allowed);
+    for (const key of Object.keys(value))
+        if (!accepted.has(key))
+            fail('unknown telemetry field');
+}
+function stringField(value, max, pattern) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > max)
+        fail('invalid telemetry string');
+    if (pattern !== undefined && !pattern.test(value))
+        fail('invalid telemetry string');
+    return value;
+}
+function safeInteger(value, min, max) {
+    if (!Number.isSafeInteger(value) || value < min || value > max)
+        fail('invalid telemetry integer');
+    return value;
+}
+function measurement(value) {
+    if (!isRecord(value))
+        fail('invalid telemetry measurement');
+    closed(value, ['unit', 'used', 'capacity']);
+    if (typeof value.unit !== 'string' || !UNITS.has(value.unit))
+        fail('invalid measurement unit');
+    const used = safeInteger(value.used, 0, Number.MAX_SAFE_INTEGER);
+    let capacity;
+    if (value.capacity !== undefined) {
+        capacity = safeInteger(value.capacity, 1, Number.MAX_SAFE_INTEGER);
+    }
+    return {
+        unit: value.unit,
+        used,
+        ...(capacity === undefined ? {} : { capacity }),
+    };
+}
+function counts(value) {
+    if (!isRecord(value))
+        fail('invalid telemetry counts');
+    closed(value, COUNT_KEYS);
+    const result = {};
+    for (const key of COUNT_KEYS) {
+        if (value[key] !== undefined)
+            result[key] = safeInteger(value[key], 0, MAX_COUNT);
+    }
+    return result;
+}
+function bytes(value) {
+    try {
+        return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+/** Validate and return the closed v1 report without adding fields. */
+export function parseContextTelemetryReport(value, now = new Date()) {
+    if (bytes(value) > CONTEXT_TELEMETRY_MAX_BYTES)
+        fail('telemetry report is too large');
+    if (!isRecord(value))
+        fail('telemetry report must be an object');
+    closed(value, [
+        'schema_version',
+        'event_id',
+        'session_key',
+        'instance_id',
+        'sequence',
+        'observed_at',
+        'client',
+        'client_version',
+        'phase',
+        'operation_id',
+        'trigger_percent',
+        'measurement',
+        'before',
+        'after',
+        'counts',
+        'reason',
+    ]);
+    if (value.schema_version !== 1)
+        fail('unsupported telemetry schema');
+    const eventId = stringField(value.event_id, 36, UUID);
+    const sessionKey = stringField(value.session_key, 64, SESSION_KEY);
+    const instanceId = stringField(value.instance_id, 36, UUID);
+    const sequence = safeInteger(value.sequence, 1, MAX_SEQUENCE);
+    const observedAt = stringField(value.observed_at, 30, UTC_TIMESTAMP);
+    const observedMillis = Date.parse(observedAt);
+    if (!Number.isFinite(observedMillis))
+        fail('invalid telemetry timestamp');
+    const nowMillis = now.getTime();
+    if (observedMillis > nowMillis + 5 * 60_000 || observedMillis < nowMillis - 24 * 60 * 60_000)
+        fail('telemetry timestamp outside accepted window');
+    if (typeof value.client !== 'string' || !CLIENTS.has(value.client))
+        fail('invalid telemetry client');
+    const client = value.client;
+    const clientVersion = stringField(value.client_version, 40, SEMVER);
+    if (typeof value.phase !== 'string' || !PHASES.has(value.phase))
+        fail('invalid telemetry phase');
+    const phase = value.phase;
+    if (!(client === 'claude-code' ? CLAUDE_PHASES : CODEX_PHASES).has(phase))
+        fail('phase is incompatible with client');
+    const operationId = value.operation_id === undefined ? undefined : stringField(value.operation_id, 36, UUID);
+    if (OPERATION_PHASES.has(phase) !== (operationId !== undefined))
+        fail('operation id is required for this phase');
+    const triggerPercent = value.trigger_percent === undefined ? undefined : value.trigger_percent;
+    if (triggerPercent !== undefined &&
+        (typeof triggerPercent !== 'number' ||
+            !Number.isFinite(triggerPercent) ||
+            triggerPercent < 1 ||
+            triggerPercent > 95))
+        fail('invalid telemetry trigger');
+    const reportMeasurement = value.measurement === undefined ? undefined : measurement(value.measurement);
+    const before = value.before === undefined ? undefined : measurement(value.before);
+    const after = value.after === undefined ? undefined : measurement(value.after);
+    const reportCounts = value.counts === undefined ? undefined : counts(value.counts);
+    const reason = value.reason === undefined ? undefined : value.reason;
+    if (phase === 'usage' && reportMeasurement === undefined)
+        fail('usage requires measurement');
+    if ((phase === 'connected' || phase === 'disconnected') &&
+        (reportMeasurement !== undefined || before !== undefined || after !== undefined))
+        fail('session phase cannot carry measurements');
+    if (!OPERATION_PHASES.has(phase) &&
+        (before !== undefined ||
+            after !== undefined ||
+            reportCounts !== undefined ||
+            reason !== undefined))
+        fail('session phase cannot carry operation results');
+    if (before !== undefined &&
+        after !== undefined &&
+        (before.unit !== after.unit || before.capacity !== after.capacity))
+        fail('before and after measurements must match');
+    if (phase === 'applied' && after === undefined)
+        fail('applied requires an actual measurement');
+    if (reason !== undefined && (typeof reason !== 'string' || !REASONS.has(reason)))
+        fail('invalid telemetry reason');
+    return {
+        schema_version: 1,
+        event_id: eventId,
+        session_key: sessionKey,
+        instance_id: instanceId,
+        sequence,
+        observed_at: observedAt,
+        client,
+        client_version: clientVersion,
+        phase,
+        ...(operationId === undefined ? {} : { operation_id: operationId }),
+        ...(triggerPercent === undefined ? {} : { trigger_percent: triggerPercent }),
+        ...(reportMeasurement === undefined ? {} : { measurement: reportMeasurement }),
+        ...(before === undefined ? {} : { before }),
+        ...(after === undefined ? {} : { after }),
+        ...(reportCounts === undefined ? {} : { counts: reportCounts }),
+        ...(reason === undefined ? {} : { reason: reason }),
+    };
+}
+export function isContextTelemetryReport(value, now) {
+    try {
+        parseContextTelemetryReport(value, now);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}