@xopcai/xopc 0.0.362 → 0.0.364

package/dist/src/gateway/service/config-coordinator.d.ts

@@ -1,28 +1,3 @@
-/**
- * GatewayConfigCoordinator — owns config persistence, hot-reload, and the
- * per-section reload handlers.
- *
- * Was 350 lines of `GatewayService` covering nine concerns:
- *   - manual `reloadConfig()` (CLI/UI trigger)
- *   - `saveConfig()` / `updateConfig()` (PATCH /api/config)
- *   - `setExtensionActivationTarget` (extension lifecycle)
- *   - `afterWeixinCredentialsPersisted` / `afterFeishuCredentialsPersisted`
- *     (QR-login follow-ups that bypass the watcher)
- *   - `ConfigHotReloader` (fs.watch → debounced per-section dispatch)
- *   - Section reload handlers (models / agents / channels /
- *     tools / mcp / extensions)
- *   - `scheduleChannelPluginsAfterPersist` (coalesces rapid saves so
- *     Telegram/Weixin do not stop/start repeatedly)
- *
- * Pulled out so the gateway composition root stays focused on lifecycle, and
- * each handler is reachable from one place when adding a new config section.
- *
- * **Config state ownership.** `GatewayService.config` is still the single
- * source of truth — this coordinator reads it via `getConfig()` and writes it
- * back via `setConfig()` after every reload / persist. We pass through rather
- * than holding our own copy so other coordinators (sessions, marketplace,
- * agent runner) see the latest config the moment a reload commits.
- */
 import type { Config } from '../../config/schema.js';
 import type { AgentService } from '../../agent/service.js';
 import type { ChannelManager } from '../../channels/manager.js';

package/dist/src/gateway/service/config-coordinator.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { configureTracing } from "../../observability/runtime.js";
 import { getModelRegistry } from "../../providers/model-registry.js";
 import { init_providers } from "../../providers/index.js";
 import { disposeAllSessionMcpRuntimes } from "../../agent/mcp/bundle-mcp-runtime.js";
@@ -11,6 +12,31 @@ import "../../config/index.js";
 import { computeExtensionActivationPatch } from "../../extensions/bundled-extension-activation.js";
 import { sanitizeTunnelConfig } from "../../tunnel/tunnel-config.js";
 //#region src/gateway/service/config-coordinator.ts
+/**
+* GatewayConfigCoordinator — owns config persistence, hot-reload, and the
+* per-section reload handlers.
+*
+* Was 350 lines of `GatewayService` covering nine concerns:
+*   - manual `reloadConfig()` (CLI/UI trigger)
+*   - `saveConfig()` / `updateConfig()` (PATCH /api/config)
+*   - `setExtensionActivationTarget` (extension lifecycle)
+*   - `afterWeixinCredentialsPersisted` / `afterFeishuCredentialsPersisted`
+*     (QR-login follow-ups that bypass the watcher)
+*   - `ConfigHotReloader` (fs.watch → debounced per-section dispatch)
+*   - Section reload handlers (models / agents / channels /
+*     tools / mcp / extensions)
+*   - `scheduleChannelPluginsAfterPersist` (coalesces rapid saves so
+*     Telegram/Weixin do not stop/start repeatedly)
+*
+* Pulled out so the gateway composition root stays focused on lifecycle, and
+* each handler is reachable from one place when adding a new config section.
+*
+* **Config state ownership.** `GatewayService.config` is still the single
+* source of truth — this coordinator reads it via `getConfig()` and writes it
+* back via `setConfig()` after every reload / persist. We pass through rather
+* than holding our own copy so other coordinators (sessions, marketplace,
+* agent runner) see the latest config the moment a reload commits.
+*/
 init_providers();
 init_logger();
 const log = createLogger("GatewayConfigCoordinator");
@@ -26,6 +52,10 @@ var GatewayConfigCoordinator = class {
 	startHotReloader() {
 		if (this.configReloader) return;
 		this.configReloader = new ConfigHotReloader(this.opts.configPath, this.opts.getConfig(), {
+			onTracingReload: async (next) => {
+				this.opts.setConfig(next);
+				await configureTracing(next.observability?.tracing);
+			},
 			onModelsReload: (newConfig) => this.handleModelsReload(newConfig),
 			onChannelsReload: (newConfig) => this.handleChannelsReload(newConfig),
 			onCronReload: (newConfig) => this.handleAutomationReload(newConfig),
@@ -316,6 +346,7 @@ var GatewayConfigCoordinator = class {
 		await saveConfig(configToWrite, this.opts.configPath);
 		const reloaded = loadConfig(this.opts.configPath);
 		this.opts.setConfig(reloaded);
+		await configureTracing(reloaded.observability?.tracing);
 		if (sanitizeTunnelConfig(reloaded)) await saveConfig(reloaded, this.opts.configPath);
 		this.opts.getAgentService().applyRuntimeConfiguration(reloaded);
 		await this.opts.reconcileMemoryMaintenanceAutomations().catch((err) => {

package/dist/src/gateway/service.js

@@ -17,14 +17,15 @@ import { init_session_repository, listSessionMetadata, patchSessionMetadata } fr
 import { getSessionConfig, init_config_repository } from "../storage/sqlite/config-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { normalizeAgentId } from "../agent-catalog/id.js";
+import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { init_paths, resolveConfigPath, resolveExtensionsDir } from "../config/paths.js";
+import { flushTracing } from "../observability/runtime.js";
 import { init_config, resolveKnowledgeReadPolicy } from "../user-context/config.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
 import { init_agent_session_key, resolveAgentMainConversationId } from "../routing/agent-session-key.js";
 import { init_session_key, resolveConversationId, sanitizeSegment } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { init_paths, resolveConfigPath, resolveExtensionsDir } from "../config/paths.js";
 import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_providers, providers_exports } from "../providers/index.js";
 import { AI_USAGE_RETENTION_MS, markStaleAiUsageEventsUnknown, pruneAiUsageEvents } from "../storage/sqlite/ai-usage-repository.js";
@@ -78,6 +79,7 @@ import "../config/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
+import { PersonalReplyComposer } from "../personal-agent/reply-composer.js";
 import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
@@ -89,6 +91,10 @@ import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
+import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
+import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
+import { HomeIntelligenceHost } from "../home-intelligence/host.js";
+import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
@@ -151,10 +157,6 @@ import { TaskMainUpdateDecisionService } from "../tasks/task-main-update-decisio
 import { selectTaskMainUpdateAttempt, submitAndConfirmTaskMainUpdate } from "../tasks/task-main-update-input.js";
 import { checkAppContextAccess, prepareAppContext } from "./service/app-context-access.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
-import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
-import { HomeIntelligenceHost } from "../home-intelligence/host.js";
-import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
-import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
 import crypto from "node:crypto";
 //#region src/gateway/service.ts
 init_session_repository();
@@ -883,7 +885,7 @@ var GatewayService = class {
 		}, `Main Agent update dispatch failed: ${errorMessage}`);
 	});
 	taskResultDispatch = createBackgroundTask(async () => {
-		await new TaskResultDeliveryService().drain((conversationId, deliveryId) => {
+		const notify = (conversationId, deliveryId) => {
 			this.realtime.broker.publish("sessions", "session.task-result", {
 				conversationId,
 				deliveryId
@@ -892,6 +894,13 @@ var GatewayService = class {
 				key: conversationId,
 				deliveryId
 			});
+		};
+		await new TaskResultDeliveryService().drain(notify);
+		new PersonalReplyComposer().drain(notify).catch((err) => {
+			log.error({
+				err,
+				phase: "task_result_reply"
+			}, "Task result reply delivery failed");
 		});
 	}, (err) => {
 		log.error({
@@ -1513,6 +1522,7 @@ var GatewayService = class {
 		}
 	}
 	async stop() {
+		await flushTracing();
 		if (!this.running) return;
 		this.stopping = true;
 		this.taskRunDispatcher?.stop();
@@ -1563,7 +1573,7 @@ var GatewayService = class {
 		await disposeAllSessionMcpRuntimes().catch((err) => {
 			log.warn({ err }, "MCP runtime shutdown failed");
 		});
-		this._agentService?.stop();
+		await this._agentService?.stop();
 		this.running = false;
 		this.bus.shutdown();
 		this.lastDeferredChannelConnectIds = [];

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -1,8 +1,8 @@
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { getAvailableModels, init_providers } from "../providers/index.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
 init_repository();

package/dist/src/home-intelligence/host.js

@@ -1,10 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { HomeAdviceBudgetExceededError } from "./generator.js";
 import { homePatternKey } from "./strategy.js";
-import { HomeAdvicePolicy } from "./policy.js";
 import { HomeIntelligenceRepository } from "./repository.js";
 import { HomeOpportunityApplicationService } from "./application-service.js";
+import { HomeAdvicePolicy } from "./policy.js";
+import { HomeAdviceBudgetExceededError } from "./generator.js";
 import { buildHomeOpportunityNotification } from "./notification.js";
 import { createHash } from "node:crypto";
 //#region src/home-intelligence/host.ts

package/dist/src/infra/update-restart.js

@@ -2,8 +2,8 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveConfigPath } from "../config/paths.js";
 import { loadConfig } from "../config/loader.js";
-import { resolveGatewayService } from "../daemon/service.js";
 import { isRestartEnabled } from "../config/commands.flags.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "./restart.js";
 import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
 import { refreshGatewayServiceAfterUpdate } from "./update-service-refresh.js";

package/dist/src/local-apps/service.js

@@ -5,10 +5,10 @@ import { currentOperationId, init_operation_context } from "../infra/operation-c
 import { afterSqliteCommit, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions } from "../../packages/gateway-contract/src/extension-capabilities.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { CapabilityError } from "../capabilities/runtime/errors.js";
 import { init_paths, resolveExtensionsDir } from "../config/paths.js";
 import { LocalAppStore } from "./store.js";
 import { slugifyProjectName } from "../projects/project-store.js";
-import { CapabilityError } from "../capabilities/runtime/errors.js";
 import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { validateLocalAppCapabilityContracts } from "./capabilities/contracts.js";
 import { buildLocalAppFixGuidance } from "./fix-guidance.js";

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const TracingConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    capture: z.ZodDefault<z.ZodEnum<{
+        metadata: "metadata";
+        redacted: "redacted";
+        detailed: "detailed";
+    }>>;
+    detailedUntil: z.ZodOptional<z.ZodNumber>;
+    local: z.ZodPrefault<z.ZodObject<{
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+        maxStoreMiB: z.ZodDefault<z.ZodNumber>;
+        maxTraces: z.ZodDefault<z.ZodNumber>;
+        maxSpans: z.ZodDefault<z.ZodNumber>;
+        maxTraceKiB: z.ZodDefault<z.ZodNumber>;
+        maxWriteMiBPerMinute: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    langfuse: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        baseUrl: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type TracingConfig = z.infer<typeof TracingConfigSchema>;
+export declare const defaultTracingConfig: () => {
+    enabled: boolean;
+    capture: "metadata" | "redacted" | "detailed";
+    local: {
+        retentionDays: number;
+        maxStoreMiB: number;
+        maxTraces: number;
+        maxSpans: number;
+        maxTraceKiB: number;
+        maxWriteMiBPerMinute: number;
+    };
+    langfuse: {
+        enabled: boolean;
+        baseUrl: string;
+    };
+    detailedUntil?: number;
+};

package/dist/src/observability/config.js

@@ -0,0 +1,31 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/observability/config.ts
+var TracingConfigSchema, defaultTracingConfig;
+var init_config = __esmMin((() => {
+	TracingConfigSchema = z.object({
+		enabled: z.boolean().default(true),
+		capture: z.enum([
+			"metadata",
+			"redacted",
+			"detailed"
+		]).default("redacted"),
+		detailedUntil: z.number().int().nonnegative().optional(),
+		local: z.object({
+			retentionDays: z.number().int().min(1).max(90).default(7),
+			maxStoreMiB: z.number().int().min(16).max(4096).default(256),
+			maxTraces: z.number().int().min(10).max(1e5).default(1e4),
+			maxSpans: z.number().int().min(100).max(1e6).default(1e5),
+			maxTraceKiB: z.number().int().min(16).max(4096).default(1024),
+			maxWriteMiBPerMinute: z.number().int().min(1).max(100).default(2)
+		}).prefault({}),
+		langfuse: z.object({
+			enabled: z.boolean().default(false),
+			baseUrl: z.string().url().max(2048).refine((value) => ["http:", "https:"].includes(new URL(value).protocol), "HTTP(S) URL required").default("https://cloud.langfuse.com")
+		}).prefault({})
+	}).strict();
+	defaultTracingConfig = () => TracingConfigSchema.parse({});
+}));
+//#endregion
+init_config();
+export { TracingConfigSchema, defaultTracingConfig, init_config };

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

@@ -0,0 +1,31 @@
+import type { TraceRecord } from './types.js';
+/** Bounded OTLP/HTTP JSON exporter. No hidden SDK queue or durable replay. */
+export declare class LangfuseTarget {
+    private baseUrl;
+    private publicKey;
+    private secretKey;
+    private queue;
+    private bytes;
+    private timer?;
+    private sending?;
+    private controller?;
+    private closed;
+    private lastWarning;
+    dropped: number;
+    lastSuccess?: number;
+    lastFailure?: number;
+    lastError?: string;
+    constructor(baseUrl: string, publicKey: string, secretKey: string);
+    status(): {
+        state: string;
+        pending: number;
+        dropped: number;
+        lastSuccess: number;
+        lastFailure: number;
+        lastError: string;
+    };
+    enqueue(record: TraceRecord): void;
+    flush(): Promise<void>;
+    private send;
+    close(): void;
+}

package/dist/src/observability/langfuse.js

@@ -0,0 +1,180 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+//#region src/observability/langfuse.ts
+init_logger();
+const log = createLogger("Observability:Langfuse");
+function otlp(record) {
+	const attributes = Object.entries(record.attributes).map(([key, value]) => ({
+		key,
+		value: typeof value === "number" ? { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
+	}));
+	return {
+		traceId: record.traceId,
+		spanId: record.spanId,
+		parentSpanId: record.parentSpanId,
+		name: record.name,
+		kind: 1,
+		startTimeUnixNano: String(BigInt(Math.floor(record.startedAt * 1e3)) * 1000n),
+		endTimeUnixNano: String(BigInt(Math.floor((record.endedAt ?? record.startedAt) * 1e3)) * 1000n),
+		attributes,
+		status: { code: record.status === "error" ? 2 : 1 }
+	};
+}
+/** Bounded OTLP/HTTP JSON exporter. No hidden SDK queue or durable replay. */
+var LangfuseTarget = class {
+	queue = [];
+	bytes = 0;
+	timer;
+	sending;
+	controller;
+	closed = false;
+	lastWarning = 0;
+	dropped = 0;
+	lastSuccess;
+	lastFailure;
+	lastError;
+	constructor(baseUrl, publicKey, secretKey) {
+		this.baseUrl = baseUrl;
+		this.publicKey = publicKey;
+		this.secretKey = secretKey;
+	}
+	status() {
+		return {
+			state: this.lastError ? "degraded" : "ready",
+			pending: this.queue.length,
+			dropped: this.dropped,
+			lastSuccess: this.lastSuccess,
+			lastFailure: this.lastFailure,
+			lastError: this.lastError
+		};
+	}
+	enqueue(record) {
+		if (this.closed) return;
+		const bytes = Buffer.byteLength(JSON.stringify(record));
+		if (this.queue.length >= 2e3 || this.bytes + bytes > 8 * 1048576) {
+			this.dropped++;
+			this.lastError = "Export queue full";
+			return;
+		}
+		this.queue.push({
+			record,
+			bytes
+		});
+		this.bytes += bytes;
+		if (this.queue.length >= 100) this.flush();
+		else if (!this.timer) {
+			this.timer = setTimeout(() => {
+				this.timer = void 0;
+				this.flush();
+			}, 5e3);
+			this.timer.unref();
+		}
+	}
+	async flush() {
+		if (this.sending) {
+			await this.sending;
+			if (this.queue.length && !this.closed) await this.flush();
+			return;
+		}
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		if (this.closed || !this.queue.length) return;
+		const batch = this.queue.splice(0, 100);
+		this.bytes -= batch.reduce((n, row) => n + row.bytes, 0);
+		this.sending = this.send(batch.map((row) => row.record)).finally(() => {
+			this.sending = void 0;
+		});
+		await this.sending;
+		if (this.queue.length && !this.closed && !this.timer) {
+			this.timer = setTimeout(() => {
+				this.timer = void 0;
+				this.flush();
+			}, 5e3);
+			this.timer.unref();
+		}
+	}
+	async send(records) {
+		for (let attempt = 0; attempt < 3 && !this.closed; attempt++) {
+			this.controller = new AbortController();
+			const timeout = setTimeout(() => this.controller?.abort(), 5e3);
+			try {
+				const response = await fetch(this.baseUrl.replace(/\/$/, "") + "/api/public/otel/v1/traces", {
+					method: "POST",
+					redirect: "error",
+					signal: this.controller.signal,
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Basic ${Buffer.from(`${this.publicKey}:${this.secretKey}`).toString("base64")}`,
+						"x-langfuse-ingestion-version": "4"
+					},
+					body: JSON.stringify({ resourceSpans: [{
+						resource: { attributes: [{
+							key: "service.name",
+							value: { stringValue: "xopc" }
+						}] },
+						scopeSpans: [{
+							scope: { name: "xopc.observability" },
+							spans: records.map(otlp)
+						}]
+					}] })
+				});
+				if (!response.ok) {
+					await response.body?.cancel();
+					throw new Error(`Langfuse returned HTTP ${response.status}`);
+				}
+				if (response.body) {
+					const reader = response.body.getReader();
+					const chunks = [];
+					let size = 0;
+					try {
+						while (true) {
+							const chunk = await reader.read();
+							if (chunk.done) break;
+							size += chunk.value.length;
+							if (size > 16384) {
+								await reader.cancel();
+								throw new Error("Oversized ingestion response");
+							}
+							chunks.push(chunk.value);
+						}
+						const text = Buffer.concat(chunks).toString("utf8");
+						if (text && Number(JSON.parse(text).partialSuccess?.rejectedSpans ?? 0) > 0) throw new Error("Ingestion rejected spans");
+					} finally {
+						reader.releaseLock();
+					}
+				}
+				this.lastSuccess = Date.now();
+				this.lastError = void 0;
+				return;
+			} catch (error) {
+				this.lastFailure = Date.now();
+				if (Date.now() - this.lastWarning > 6e4) {
+					this.lastWarning = Date.now();
+					log.warn({
+						phase: "langfuse_export",
+						attempt: attempt + 1
+					}, "Langfuse trace export failed; local recording continues");
+				}
+				this.lastError = error instanceof Error && /^Langfuse returned HTTP \d+$/.test(error.message) ? error.message : "Langfuse export failed";
+			} finally {
+				clearTimeout(timeout);
+			}
+			if (attempt < 2 && !this.closed) await new Promise((resolve) => {
+				setTimeout(resolve, 250 * 2 ** attempt).unref();
+			});
+		}
+		this.dropped += records.length;
+	}
+	close() {
+		this.closed = true;
+		this.controller?.abort();
+		if (this.timer) clearTimeout(this.timer);
+		this.dropped += this.queue.length;
+		this.queue = [];
+		this.bytes = 0;
+	}
+};
+//#endregion
+export { LangfuseTarget };

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

@@ -0,0 +1,57 @@
+import { type Span, type Attributes } from '@opentelemetry/api';
+import { type TracingConfig } from './config.js';
+import { LocalTraceStore } from './store.js';
+import type { TraceRecord } from './types.js';
+export type TraceIdentity = {
+    conversationId?: string;
+    runId?: string;
+    agentId?: string;
+    transcriptId?: string;
+};
+export declare function localStore(): LocalTraceStore;
+export declare function tracingConfig(): TracingConfig;
+export declare function configureTracing(value?: unknown): Promise<void>;
+export declare function tracingStatus(): Promise<{
+    local: any;
+    langfuse: {
+        state: string;
+        pending: number;
+        dropped: number;
+        lastSuccess: number;
+        lastFailure: number;
+        lastError: string;
+    } | {
+        state: string;
+        pending: number;
+        dropped: number;
+    };
+    active: number;
+    dropped: number;
+}>;
+export declare function traceIds(): {
+    traceId?: string;
+    spanId?: string;
+};
+export type Observation = {
+    span?: Span;
+    run: <T>(fn: () => T) => T;
+    finish: (status?: string, output?: unknown) => void;
+    input: (value: unknown) => void;
+    update: (values: Attributes) => void;
+};
+export declare function startObservation(name: string, type: TraceRecord['type'], identity?: TraceIdentity): Observation;
+export declare function traceRun<T extends {
+    ok?: boolean;
+    stopReason?: string;
+    errorMessage?: string;
+    lastAssistantText?: string;
+}>(name: string, identity: TraceIdentity, fn: () => Promise<T>, input?: unknown): Promise<T>;
+export declare function traceTools<T extends {
+    name: string;
+    execute: (...args: any[]) => any;
+}>(tools: T[]): T[];
+export declare function flushTracing(): Promise<void>;
+export declare function testLangfuse(): Promise<boolean>;
+export declare function closeTracing(): Promise<void>;
+export declare function traceOperation<T>(name: string, fn: () => Promise<T>, attributes?: Attributes): Promise<T>;
+export declare function setTraceIdentity(identity: TraceIdentity): void;