@xopcai/xopc 0.0.362 → 0.0.363

package/dist/src/observability/sanitize.js

@@ -0,0 +1,74 @@
+//#region src/observability/sanitize.ts
+const SECRET_KEY = /authorization|api.?key|password|secret|access.?token|refresh.?token|bot.?token|cookie/i;
+const OMIT_KEY = /^(data|base64|headers|image_url|audio|video)$/i;
+function redactString(value) {
+	return value.replace(/Bearer\s+[^\s"']+/gi, "Bearer [REDACTED]").replace(/\b(?:sk-|pk-lf-|sk-lf-)[A-Za-z0-9_-]+/g, "[REDACTED]").replace(/((?:api[_-]?key|token|secret|password)\s*[=:]\s*)[^\s,;"']+/gi, "$1[REDACTED]").replace(/data:[^\s"']+;base64,[^\s"']+/gi, "[MEDIA OMITTED]");
+}
+/** Bounds traversal before serializing; never materializes an entire tool/file payload. */
+function boundedJson(value, maxBytes = 8192) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	let budget = Math.max(64, maxBytes - 256);
+	let truncated = false;
+	const walk = (v, depth) => {
+		if (budget < 32 || depth > 5) {
+			truncated = true;
+			return "[TRUNCATED]";
+		}
+		if (v === null || typeof v === "number" || typeof v === "boolean") {
+			budget -= 16;
+			return v;
+		}
+		if (typeof v === "string") {
+			const slice = v.slice(0, Math.min(budget, 4096));
+			const clean = redactString(slice);
+			const buf = Buffer.from(clean);
+			const size = Math.min(budget, 4096);
+			budget -= Math.min(buf.length, size);
+			if (slice.length < v.length || buf.length > size) truncated = true;
+			return buf.subarray(0, size).toString("utf8");
+		}
+		if (typeof v !== "object") return void 0;
+		if (seen.has(v)) return "[CIRCULAR]";
+		seen.add(v);
+		if (Array.isArray(v)) {
+			const values = [];
+			for (let i = 0; i < Math.min(v.length, 40) && budget > 32; i++) values.push(walk(v[i], depth + 1));
+			if (values.length < v.length) truncated = true;
+			return values;
+		}
+		const result = {};
+		let count = 0;
+		for (const key in v) {
+			if (!Object.hasOwn(v, key)) continue;
+			if (++count > 40 || budget < 32) {
+				truncated = true;
+				break;
+			}
+			const safeKey = key.slice(0, 80);
+			budget -= Buffer.byteLength(safeKey) + 8;
+			try {
+				result[safeKey] = SECRET_KEY.test(key) ? "[REDACTED]" : OMIT_KEY.test(key) ? "[OMITTED]" : walk(v[key], depth + 1);
+			} catch {
+				result[safeKey] = "[UNAVAILABLE]";
+			}
+		}
+		return result;
+	};
+	let data;
+	try {
+		data = walk(value, 0);
+	} catch {
+		data = "[UNAVAILABLE]";
+	}
+	const text = JSON.stringify({
+		preview: data,
+		truncated
+	});
+	if (Buffer.byteLength(text) <= maxBytes) return text;
+	return JSON.stringify({
+		preview: Buffer.from(redactString(text)).subarray(0, Math.floor(maxBytes / 8)).toString("utf8"),
+		truncated: true
+	});
+}
+//#endregion
+export { boundedJson, redactString };

package/dist/src/observability/store.d.ts

@@ -0,0 +1,20 @@
+import type { TracingConfig } from './config.js';
+import type { TraceRecord } from './types.js';
+export declare class LocalTraceStore {
+    private worker?;
+    private sequence;
+    private requests;
+    private pendingBytes;
+    private epoch;
+    private epochReady;
+    dropped: number;
+    lastError?: string;
+    constructor(config: TracingConfig, file?: string);
+    private fail;
+    request(op: string, data?: unknown): Promise<any>;
+    begin(record: TraceRecord): Promise<number>;
+    write(record: TraceRecord, epoch?: number): Promise<void>;
+    clear(): Promise<void>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/src/observability/store.js

@@ -0,0 +1,128 @@
+import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
+import { redactString } from "./sanitize.js";
+import { traceStoreWorkerSource } from "./storeWorker.js";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { Worker } from "node:worker_threads";
+//#region src/observability/store.ts
+init_paths_state();
+var LocalTraceStore = class {
+	worker;
+	sequence = 0;
+	requests = /* @__PURE__ */ new Map();
+	pendingBytes = 0;
+	epoch = 0;
+	epochReady;
+	dropped = 0;
+	lastError;
+	constructor(config, file = join(resolveStateDir(), "traces", "traces.db")) {
+		try {
+			this.worker = new Worker(traceStoreWorkerSource, {
+				eval: true,
+				execArgv: process.execArgv.filter((arg, index, args) => !arg.startsWith("--input-type") && args[index - 1] !== "--input-type"),
+				workerData: {
+					path: file,
+					config,
+					owner: randomUUID()
+				}
+			});
+			this.worker.on("message", ({ id, value, error }) => {
+				const request = this.requests.get(id);
+				if (!request) return;
+				clearTimeout(request.timer);
+				this.requests.delete(id);
+				this.pendingBytes -= request.bytes;
+				if (error) {
+					this.lastError = error;
+					request.reject(new Error(error));
+				} else request.resolve(value);
+				if (!this.requests.size) this.worker?.unref();
+			});
+			this.worker.on("error", (error) => this.fail(`Trace worker unavailable: ${redactString(error instanceof Error ? error.message : "Worker startup failed").slice(0, 200)}`));
+			this.worker.on("exit", () => {
+				if (this.worker) this.fail("Trace worker stopped");
+			});
+			this.worker.unref();
+			this.epochReady = this.request("status").then((s) => {
+				this.epoch = s.epoch;
+			}).catch(() => {});
+		} catch {
+			this.lastError = "Trace worker unavailable";
+			this.epochReady = Promise.resolve();
+		}
+	}
+	fail(message) {
+		this.lastError = message;
+		for (const r of this.requests.values()) {
+			clearTimeout(r.timer);
+			r.reject(new Error(message));
+		}
+		this.requests.clear();
+		this.pendingBytes = 0;
+		this.worker = void 0;
+	}
+	async request(op, data) {
+		if (!this.worker) throw new Error(this.lastError ?? "Trace storage unavailable");
+		const bytes = Buffer.byteLength(JSON.stringify(data ?? null));
+		if (this.requests.size >= 2e3 || this.pendingBytes + bytes > 8 * 1048576) {
+			this.dropped++;
+			throw new Error("Trace queue full");
+		}
+		const id = ++this.sequence;
+		this.pendingBytes += bytes;
+		this.worker.ref();
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.requests.delete(id);
+				this.pendingBytes -= bytes;
+				this.dropped++;
+				reject(/* @__PURE__ */ new Error("Trace storage timeout"));
+				this.worker?.terminate();
+			}, 5e3);
+			this.requests.set(id, {
+				resolve,
+				reject,
+				timer,
+				bytes
+			});
+			this.worker.postMessage({
+				id,
+				op,
+				data
+			});
+		});
+	}
+	async begin(record) {
+		await this.epochReady;
+		return this.request("put", {
+			records: [record],
+			epoch: null
+		});
+	}
+	async write(record, epoch) {
+		await this.epochReady;
+		try {
+			await this.request("put", {
+				records: [record],
+				epoch: epoch ?? this.epoch
+			});
+			this.lastError = void 0;
+		} catch (error) {
+			this.dropped++;
+			this.lastError = error instanceof Error ? error.message : "Trace write failed";
+		}
+	}
+	async clear() {
+		this.epoch = await this.request("clear");
+	}
+	async flush() {
+		await this.request("status");
+	}
+	async close() {
+		const worker = this.worker;
+		this.fail("Trace store closed");
+		await worker?.terminate();
+	}
+};
+//#endregion
+export { LocalTraceStore };

package/dist/src/observability/storeWorker.d.ts

@@ -0,0 +1,2 @@
+/** Self-contained worker source works in tsx, published unbundled Node, and Electron builds. */
+export declare const traceStoreWorkerSource: string;

package/dist/src/observability/storeWorker.js

@@ -0,0 +1,155 @@
+//#region src/observability/storeWorker.ts
+/** Self-contained worker source works in tsx, published unbundled Node, and Electron builds. */
+const traceStoreWorkerSource = String.raw`
+const { parentPort, workerData } = require('node:worker_threads');
+const { DatabaseSync } = require('node:sqlite');
+const fs = require('node:fs');
+const path = require('node:path');
+const file = workerData.path;
+fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+const db = new DatabaseSync(file);
+let config = workerData.config;
+let dropped = 0;
+let paused = false;
+let lastPruned = 0;
+function retryStartup(fn) {
+  const deadline = Date.now() + 1000;
+  const wait = new Int32Array(new SharedArrayBuffer(4));
+  while (true) {
+    try { return fn(); }
+    catch (error) {
+      if (!/database (?:table )?is locked/.test(String(error.message)) || Date.now() >= deadline) throw error;
+      Atomics.wait(wait, 0, 0, 25);
+    }
+  }
+}
+function limits() {
+  db.exec('PRAGMA max_page_count=' + Math.floor((config.local.maxStoreMiB - 4) * 1048576 / 8192));
+}
+db.exec('PRAGMA busy_timeout=100;');
+retryStartup(() => {
+if (Number(db.prepare('PRAGMA user_version').get().user_version) > 1) throw new Error('Trace database schema is newer than this runtime');
+db.exec('PRAGMA page_size=4096; PRAGMA auto_vacuum=INCREMENTAL; PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA wal_autocheckpoint=128; PRAGMA journal_size_limit=1048576;');
+db.exec('CREATE TABLE IF NOT EXISTS traces (trace_id TEXT PRIMARY KEY, started_at INTEGER NOT NULL, ended_at INTEGER, status TEXT NOT NULL, conversation_id TEXT, run_id TEXT, agent_id TEXT, owner TEXT, data TEXT NOT NULL, partial_reason TEXT); CREATE INDEX IF NOT EXISTS trace_time ON traces(started_at,trace_id); CREATE INDEX IF NOT EXISTS trace_conversation ON traces(conversation_id,started_at); CREATE TABLE IF NOT EXISTS spans (trace_id TEXT NOT NULL, span_id TEXT NOT NULL, data TEXT NOT NULL, bytes INTEGER NOT NULL, PRIMARY KEY(trace_id,span_id)); CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY, epoch INTEGER NOT NULL, window INTEGER NOT NULL, written INTEGER NOT NULL); INSERT OR IGNORE INTO state VALUES(1,0,0,0); CREATE TABLE IF NOT EXISTS leases (owner TEXT PRIMARY KEY, heartbeat INTEGER NOT NULL); PRAGMA user_version=1;');
+limits();
+});
+function size() {
+  return ['', '-wal', '-shm'].reduce((sum, suffix) => { try { return sum + fs.statSync(file + suffix).size; } catch { return sum; } }, 0);
+}
+function permissions() { for (const suffix of ['', '-wal', '-shm']) { try { fs.chmodSync(file + suffix, 0o600); } catch {} } }
+function transaction(fn) { db.exec('BEGIN IMMEDIATE'); try { const r = fn(); db.exec('COMMIT'); return r; } catch(e) { db.exec('ROLLBACK'); throw e; } }
+function heartbeat() {
+  db.prepare('INSERT INTO leases VALUES (?,?) ON CONFLICT(owner) DO UPDATE SET heartbeat=excluded.heartbeat').run(workerData.owner, Date.now());
+  const stale = db.prepare('SELECT trace_id,data FROM traces WHERE ended_at IS NULL AND (started_at < ? OR owner IN (SELECT owner FROM leases WHERE heartbeat < ?)) LIMIT 256').all(Date.now()-86400000, Date.now()-120000);
+  for (const row of stale) { const data=JSON.parse(row.data); data.endedAt=Date.now(); data.status='interrupted'; db.prepare('UPDATE traces SET ended_at=?,status=?,data=? WHERE trace_id=?').run(data.endedAt,data.status,JSON.stringify(data),row.trace_id); }
+  db.prepare('DELETE FROM leases WHERE heartbeat < ? AND NOT EXISTS (SELECT 1 FROM traces WHERE traces.owner=leases.owner AND ended_at IS NULL)').run(Date.now()-120000);
+}
+function remove(ids) {
+  for (const row of ids) { db.prepare('DELETE FROM spans WHERE trace_id=?').run(row.trace_id); db.prepare('DELETE FROM traces WHERE trace_id=?').run(row.trace_id); }
+}
+function allocatedBytes() { return (Number(db.prepare('PRAGMA page_count').get().page_count) - Number(db.prepare('PRAGMA freelist_count').get().freelist_count)) * 4096; }
+function counts() {
+  const t=db.prepare('SELECT COUNT(*) AS traces FROM traces').get();
+  const s=db.prepare('SELECT COUNT(*) AS spans,COALESCE(SUM(bytes),0) AS bytes FROM spans').get();
+  return { ...t,...s };
+}
+function prune() {
+  transaction(() => {
+    remove(db.prepare('SELECT trace_id FROM traces WHERE ended_at IS NOT NULL AND started_at < ? LIMIT 1000').all(Date.now()-config.local.retentionDays*86400000));
+    for(let i=0;i<10;i++) {
+      const c=counts();
+      if(c.traces < config.local.maxTraces && c.spans < config.local.maxSpans && c.bytes < (config.local.maxStoreMiB-4)*1048576*0.3 && allocatedBytes() < (config.local.maxStoreMiB-4)*1048576*0.3) break;
+      const old=db.prepare('SELECT trace_id FROM traces WHERE ended_at IS NOT NULL ORDER BY started_at LIMIT ?').all(Math.max(1,Math.min(100,Math.ceil(config.local.maxTraces/10))));
+      if(!old.length) break;
+      remove(old);
+    }
+  });
+  db.exec('PRAGMA wal_checkpoint(TRUNCATE); PRAGMA incremental_vacuum(16384); PRAGMA wal_checkpoint(TRUNCATE);');
+  lastPruned=Date.now();
+  permissions();
+}
+function put(records, epoch) {
+  const max=config.local.maxStoreMiB*1048576;
+  const initial=counts();
+  if(size()>max*0.75 || initial.traces>=config.local.maxTraces || initial.spans>=config.local.maxSpans || initial.bytes>(max-4194304)*0.4 || allocatedBytes()>(max-4194304)*0.4 || Date.now()-lastPruned>60000) prune();
+  if(size()>max-2097152) { paused=true; dropped+=records.length; return; }
+  paused=false;
+  let acceptedEpoch;
+  transaction(() => {
+    const state=db.prepare('SELECT * FROM state WHERE id=1').get();
+    acceptedEpoch=state.epoch;
+    if(epoch !== null && epoch !== state.epoch) { dropped+=records.length; return; }
+    const minute=Math.floor(Date.now()/60000);
+    let written=minute===state.window ? state.written : 0;
+    let c=counts();
+    for(const source of records) {
+      const r={ ...source, attributes:{ ...source.attributes } };
+      const root=!r.parentSpanId || r.attributes['xopc.localRoot']===true;
+      if(written>=config.local.maxWriteMiBPerMinute*1048576+65536) { dropped++; continue; }
+      let trace=db.prepare('SELECT * FROM traces WHERE trace_id=?').get(r.traceId);
+      if(!trace) {
+        if(c.traces>=config.local.maxTraces) { dropped++; continue; }
+        const a=r.attributes;
+        const overview={ ...r, attributes: Object.fromEntries(Object.entries(a).filter(([k]) => !k.endsWith('.input') && !k.endsWith('.output'))) };
+        db.prepare('INSERT INTO traces VALUES(?,?,?,?,?,?,?,?,?,NULL)').run(r.traceId,r.startedAt,root?r.endedAt??null:null,root?r.status:'running',a['xopc.conversationId']??null,a['xopc.runId']??null,a['xopc.agentId']??null,workerData.owner,JSON.stringify(overview));
+        c.traces++;
+        trace=db.prepare('SELECT * FROM traces WHERE trace_id=?').get(r.traceId);
+      }
+      let text=JSON.stringify(r);
+      let bytes=Buffer.byteLength(text);
+      const previous=db.prepare('SELECT bytes FROM spans WHERE trace_id=? AND span_id=?').get(r.traceId,r.spanId);
+      const total=db.prepare('SELECT COUNT(*) AS n,COALESCE(SUM(bytes),0) AS bytes FROM spans WHERE trace_id=?').get(r.traceId);
+      const limited=c.bytes+bytes>(max-4194304)*0.4 || total.bytes+bytes-(previous?.bytes??0)>config.local.maxTraceKiB*1024 || written+bytes*(root?2:1)>config.local.maxWriteMiBPerMinute*1048576;
+      if(limited) {
+        delete r.attributes['langfuse.observation.input']; delete r.attributes['langfuse.observation.output'];
+        r.attributes['xopc.partialReason']='quota'; text=JSON.stringify(r); bytes=Buffer.byteLength(text);
+        db.prepare('UPDATE traces SET partial_reason=? WHERE trace_id=?').run('quota',r.traceId);
+      }
+      if(!previous && (c.spans>=config.local.maxSpans || total.n>=1000 || total.bytes+bytes>config.local.maxTraceKiB*1024) || written+bytes*(root?2:1)>config.local.maxWriteMiBPerMinute*1048576+65536) {
+        dropped++; db.prepare('UPDATE traces SET partial_reason=? WHERE trace_id=?').run('quota',r.traceId);
+        continue;
+      } else {
+        db.prepare('INSERT INTO spans VALUES(?,?,?,?) ON CONFLICT(trace_id,span_id) DO UPDATE SET data=excluded.data,bytes=excluded.bytes').run(r.traceId,r.spanId,text,bytes);
+        if(!previous) c.spans++;
+        written+=bytes*(root?2:1); c.bytes+=bytes-(previous?.bytes??0);
+      }
+      if(r.attributes['xopc.partialReason']) db.prepare('UPDATE traces SET partial_reason=? WHERE trace_id=?').run(String(r.attributes['xopc.partialReason']),r.traceId);
+      if(root) db.prepare('UPDATE traces SET started_at=?,ended_at=?,status=?,data=?,conversation_id=?,run_id=?,agent_id=? WHERE trace_id=?').run(r.startedAt,r.endedAt??null,r.status,text,r.attributes['xopc.conversationId']??null,r.attributes['xopc.runId']??null,r.attributes['xopc.agentId']??null,r.traceId);
+    }
+    db.prepare('UPDATE state SET window=?,written=? WHERE id=1').run(minute,written);
+  });
+  permissions();
+  return acceptedEpoch;
+}
+function list(q) {
+  const where=[]; const values=[];
+  for(const [key,column] of [['status','status'],['conversationId','conversation_id'],['runId','run_id'],['agentId','agent_id']]) if(q[key]) { where.push(column+'=?'); values.push(q[key]); }
+  if(q.from!==undefined) { where.push('started_at>=?'); values.push(q.from); }
+  if(q.to!==undefined) { where.push('started_at<?'); values.push(q.to); }
+  if(q.cursor) { const [time,id]=q.cursor.split(':'); where.push('(started_at < ? OR (started_at=? AND trace_id<?))'); values.push(Number(time),Number(time),id); }
+  const limit=Math.min(100,Math.max(1,q.limit||30));
+  const rows=db.prepare('SELECT * FROM traces'+(where.length?' WHERE '+where.join(' AND '):'')+' ORDER BY started_at DESC,trace_id DESC LIMIT ?').all(...values,limit+1);
+  const more=rows.length>limit; const page=rows.slice(0,limit);
+  return { traces:page.map(row => { const r=JSON.parse(row.data); delete r.attributes['langfuse.observation.input']; delete r.attributes['langfuse.observation.output']; const stats={generations:0,tokens:0,knownCostUsd:0,unknownCostCalls:0}; for(const value of db.prepare('SELECT data FROM spans WHERE trace_id=?').all(row.trace_id)) { const span=JSON.parse(value.data); if(span.type!=='generation') continue; stats.generations++; stats.tokens+=Number(span.attributes['gen_ai.usage.input_tokens']||0)+Number(span.attributes['gen_ai.usage.output_tokens']||0); const cost=span.attributes['langfuse.observation.cost_details']; const total=cost ? JSON.parse(cost).total : undefined; if(typeof total==='number') stats.knownCostUsd+=total; else stats.unknownCostCalls++; } return {...r,partialReason:row.partial_reason,stats}; }), nextCursor:more? page.at(-1).started_at+':'+page.at(-1).trace_id:null };
+}
+retryStartup(heartbeat); permissions();
+const timer=setInterval(() => { try { heartbeat(); prune(); } catch {} },60000); timer.unref();
+parentPort.on('message', msg => {
+  try {
+    let value;
+    if(msg.op==='put') value=put(msg.data.records,msg.data.epoch);
+    if(msg.op==='configure') { config=msg.data; limits(); prune(); }
+    if(msg.op==='status') value={...counts(),physicalBytes:size(),dropped,paused,lastPruned,epoch:db.prepare('SELECT epoch FROM state WHERE id=1').get().epoch};
+    if(msg.op==='list') value=list(msg.data);
+    if(msg.op==='detail') {
+      const row=db.prepare('SELECT * FROM traces WHERE trace_id=?').get(msg.data);
+      value=row? {trace:{...JSON.parse(row.data),partialReason:row.partial_reason},spans:db.prepare('SELECT data FROM spans WHERE trace_id=? ORDER BY json_extract(data,\'$.startedAt\'),span_id LIMIT 1000').all(msg.data).map(x=>JSON.parse(x.data))}:null;
+    }
+    if(msg.op==='prune') { prune(); value=true; }
+    if(msg.op==='clear') { value=transaction(() => { db.exec('DELETE FROM spans; DELETE FROM traces; UPDATE state SET epoch=epoch+1 WHERE id=1'); return db.prepare('SELECT epoch FROM state WHERE id=1').get().epoch; }); prune(); }
+    parentPort.postMessage({id:msg.id,value});
+  } catch(error) { parentPort.postMessage({id:msg.id,error:'Trace storage operation failed: '+String(error.message).slice(0,200)}); }
+});
+`;
+//#endregion
+export { traceStoreWorkerSource };

package/dist/src/observability/types.d.ts

@@ -0,0 +1,21 @@
+export type TraceRecord = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    type: 'agent' | 'generation' | 'tool' | 'span';
+    startedAt: number;
+    endedAt?: number;
+    status: string;
+    attributes: Record<string, string | number | boolean>;
+};
+export type TraceQuery = {
+    limit?: number;
+    cursor?: string;
+    status?: string;
+    conversationId?: string;
+    runId?: string;
+    agentId?: string;
+    from?: number;
+    to?: number;
+};

package/dist/src/observability/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/platform/index.js

@@ -1,5 +1,5 @@
-import { AgentManifestSchema, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts } from "./contracts.js";
 import { init_resolution, resolveConnectedPlatformDiscovery, resolveConnectedPlatformEndpoint, setActivePlatformDiscovery } from "./resolution.js";
+import { AgentManifestSchema, PlatformCapabilitySchema, PlatformConfigSchema, PlatformDiscoverySchema, PlatformEventSchema, init_contracts } from "./contracts.js";
 import { PLATFORM_RUNTIME_PROFILE, PLATFORM_RUNTIME_PROVIDER, PlatformRuntimeClient, RuntimeCommandSchema, discoverPlatform } from "./client.js";
 import { processRuntimeCommand } from "./worker.js";
 //#region src/platform/index.ts

package/dist/src/providers/auth-runtime/resolve-auth.js

@@ -1,5 +1,5 @@
-import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
+import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getDefaultAuthProfileStore } from "./auth-profile-store.js";
 //#region src/providers/auth-runtime/resolve-auth.ts
 init_env_keys();

package/dist/src/providers/index.js

@@ -1,11 +1,11 @@
 import { __esmMin, __exportAll } from "../../_virtual/_rolldown/runtime.js";
-import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
+import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
+import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
-import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
-import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
 import { EXTENSION_PROVIDER_BASE_URL, init_constants } from "./constants.js";
 import { applyOfficialModelMetadataCorrections, getSupplementalModels, init_model_supplements } from "./model-supplements.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";

package/dist/src/providers/model-call.js

@@ -43,14 +43,21 @@ async function resolveModelCallOptions(model, options = {}, credentialOptions) {
 */
 async function completeWithResolvedCredentials(model, context, options, credentialOptions, usageContext) {
 	const resolvedOptions = await resolveModelCallOptions(model, options, credentialOptions);
-	const usageCall = startAiUsageCall(model, usageContext);
+	const usageCall = startAiUsageCall(model, usageContext, {
+		context,
+		options: {
+			reasoning: options.reasoning,
+			temperature: options.temperature,
+			maxTokens: options.maxTokens
+		}
+	});
 	try {
 		if (model.baseUrl === "extension://provider-plugin") {
-			const result = await (await createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions)).result();
+			const result = await (await usageCall.run(() => createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions))).result();
 			finishAiUsageFromMessage(usageCall, result);
 			return result;
 		}
-		const result = await completeSimple(model, context, resolvedOptions);
+		const result = await usageCall.run(() => completeSimple(model, context, resolvedOptions));
 		finishAiUsageFromMessage(usageCall, result);
 		return result;
 	} catch (error) {
@@ -68,9 +75,16 @@ async function completeWithResolvedCredentials(model, context, options, credenti
 */
 async function createResolvedModelStream(model, context, options, credentialOptions, usageContext) {
 	const resolvedOptions = await resolveModelCallOptions(model, options, credentialOptions);
-	const usageCall = startAiUsageCall(model, usageContext);
+	const usageCall = startAiUsageCall(model, usageContext, {
+		context,
+		options: {
+			reasoning: options.reasoning,
+			temperature: options.temperature,
+			maxTokens: options.maxTokens
+		}
+	});
 	try {
-		return observeAiUsageStream(await createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions), usageCall);
+		return observeAiUsageStream(await usageCall.run(() => createExtensionAwareStreamFn()(model, normalizeContext(context), resolvedOptions)), usageCall);
 	} catch (error) {
 		usageCall?.finish({
 			status: "failed",

package/dist/src/providers/model-catalog-persistence.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { init_paths_state, resolveXopcCloudCatalogCachePath } from "../config/paths-state.js";
-import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
+import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { voiceManifestSchema } from "../../packages/realtime-protocol/src/voice-catalog.js";
 import { init_voice } from "../../packages/realtime-protocol/src/voice.js";
 import { readFileSync, rmSync } from "node:fs";

package/dist/src/providers/model-registry.js

@@ -1,10 +1,10 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { resolveModelsJsonPath } from "../config/paths.js";
 import { init_resolve_config_value, resolveConfigValue, resolveHeaders } from "../config/resolve-config-value.js";
 import { getDefaultModelValues, init_models_json, validateModelsConfig } from "../config/models-json.js";
-import { getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
 import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { existsSync, readFileSync } from "fs";

package/dist/src/providers/provider-disconnect-core.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { getModelRegistry, init_model_registry } from "./model-registry.js";
 import { init_oauth_provider_lock, withOAuthProviderLock } from "../auth/oauth-provider-lock.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
+import { getModelRegistry, init_model_registry } from "./model-registry.js";
 import { getProviderAuthService, init_provider_auth_service } from "./provider-auth-service.js";
 import { evictAllEmbeddedSessionRunners } from "../agent/embedded/session-runner.js";
 //#region src/providers/provider-disconnect-core.ts

package/dist/src/providers/xopc-cloud-catalog-coordinator.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { init_oauth_provider_lock, withOAuthProviderLock } from "../auth/oauth-provider-lock.js";
 import { ModelCatalogPersistence, init_model_catalog_persistence } from "./model-catalog-persistence.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
 import { getModelRegistry, init_model_registry } from "./model-registry.js";
-import { init_oauth_provider_lock, withOAuthProviderLock } from "../auth/oauth-provider-lock.js";
 import { reloadImageGenerationProviders } from "../agent/image/generation/provider-registry.js";
 import { disconnectProviderCore } from "./provider-disconnect-core.js";
 import { XopcCloudModelSource } from "./xopc-cloud-model-source.js";

package/dist/src/storage/sqlite/ai-usage-repository.d.ts

@@ -55,6 +55,8 @@ export declare function listAiUsageEvents(query: AiUsageQuery & {
     items: {
         id: string;
         traceId: string;
+        otelTraceId: string;
+        otelSpanId: string;
         parentEventId: string;
         conversationId: string;
         runId: string;
@@ -85,6 +87,8 @@ export declare function listAiUsageEvents(query: AiUsageQuery & {
 export declare function getAiUsageEventView(id: string): {
     id: string;
     traceId: string;
+    otelTraceId: string;
+    otelSpanId: string;
     parentEventId: string;
     conversationId: string;
     runId: string;
@@ -113,6 +117,8 @@ export declare function getAiUsageEventView(id: string): {
 export declare function listAiUsageTrace(traceId: string): {
     id: string;
     traceId: string;
+    otelTraceId: string;
+    otelSpanId: string;
     parentEventId: string;
     conversationId: string;
     runId: string;

package/dist/src/storage/sqlite/ai-usage-repository.js

@@ -15,8 +15,8 @@ function insertAiUsageEvent(event) {
       started_at, finished_at, duration_ms, input_tokens, output_tokens,
       cache_read_tokens, cache_write_tokens, reasoning_tokens, total_tokens,
       estimated_cost_microusd, cost_source, pricing_snapshot_json, error_summary,
-      created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(event.id, event.traceId, event.parentEventId ?? null, event.conversationId ?? null, event.runId ?? null, event.agentId ?? null, event.category, event.operation, event.trigger, event.reasonKey, event.provider, event.model, event.status, event.startedAt, event.finishedAt ?? null, event.durationMs ?? null, event.inputTokens ?? null, event.outputTokens ?? null, event.cacheReadTokens ?? null, event.cacheWriteTokens ?? null, event.reasoningTokens ?? null, event.totalTokens ?? null, event.estimatedCostMicrousd ?? null, event.costSource, event.pricingSnapshot ? JSON.stringify(event.pricingSnapshot) : null, boundedError(event.errorSummary) ?? null, event.startedAt, event.startedAt);
+      created_at, updated_at, otel_trace_id, otel_span_id
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(event.id, event.traceId, event.parentEventId ?? null, event.conversationId ?? null, event.runId ?? null, event.agentId ?? null, event.category, event.operation, event.trigger, event.reasonKey, event.provider, event.model, event.status, event.startedAt, event.finishedAt ?? null, event.durationMs ?? null, event.inputTokens ?? null, event.outputTokens ?? null, event.cacheReadTokens ?? null, event.cacheWriteTokens ?? null, event.reasoningTokens ?? null, event.totalTokens ?? null, event.estimatedCostMicrousd ?? null, event.costSource, event.pricingSnapshot ? JSON.stringify(event.pricingSnapshot) : null, boundedError(event.errorSummary) ?? null, event.startedAt, event.startedAt, event.otelTraceId ?? null, event.otelSpanId ?? null);
 	});
 }
 function finishAiUsageEvent(id, finish) {
@@ -143,6 +143,8 @@ function eventFromRow(row) {
 	return {
 		id: String(row.id),
 		traceId: String(row.trace_id),
+		otelTraceId: row.otel_trace_id ? String(row.otel_trace_id) : void 0,
+		otelSpanId: row.otel_span_id ? String(row.otel_span_id) : void 0,
 		parentEventId: row.parent_event_id ? String(row.parent_event_id) : void 0,
 		conversationId: row.conversation_id ? String(row.conversation_id) : void 0,
 		runId: row.run_id ? String(row.run_id) : void 0,

package/dist/src/storage/sqlite/migrations/233_observability_usage_links.sql

@@ -0,0 +1,3 @@
+ALTER TABLE ai_usage_events ADD COLUMN otel_trace_id TEXT;
+ALTER TABLE ai_usage_events ADD COLUMN otel_span_id TEXT;
+CREATE INDEX idx_ai_usage_events_otel_trace ON ai_usage_events(otel_trace_id) WHERE otel_trace_id IS NOT NULL;

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 232;
+export declare const XOPC_DB_SCHEMA_VERSION = 233;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -57,7 +57,7 @@ function applySingleMigration(db, migration, discardOldScenes = false) {
 */
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 232;
+	const targetVersion = options.targetVersion ?? 233;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -95,7 +95,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 232;
+	const appVersion = options.targetVersion ?? 233;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -137,7 +137,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 232;
+	XOPC_DB_SCHEMA_VERSION = 233;
 }));
 //#endregion
 init_runner();

package/dist/src/storage/sqlite/schema.js

@@ -28,7 +28,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 232,
+		targetVersion: 233,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }