@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/tasks/tools/taskTools.js

@@ -1,265 +0,0 @@
-import { z } from "zod";
-import { logger } from "../../utils/logger.js";
-import { TaskError } from "../errors.js";
-import { tool } from "../../utils/tool.js";
-/**
- * Parse a schedule object from tool input.
- * Accepts: { type: "cron", expression } | { type: "interval", every } | { type: "once", at }
- */
-function parseSchedule(input) {
-    const type = input.type;
-    if (type === "cron") {
-        if (!input.expression || typeof input.expression !== "string") {
-            throw TaskError.create("SCHEDULE_FAILED", "Cron schedule requires an 'expression' field");
-        }
-        return {
-            type: "cron",
-            expression: input.expression,
-            ...(input.timezone ? { timezone: input.timezone } : {}),
-        };
-    }
-    if (type === "interval") {
-        if (typeof input.every !== "number" ||
-            !isFinite(input.every) ||
-            input.every <= 0) {
-            throw TaskError.create("SCHEDULE_FAILED", "Interval schedule requires a positive 'every' field (milliseconds)");
-        }
-        return { type: "interval", every: input.every };
-    }
-    if (type === "once") {
-        if (!input.at) {
-            throw TaskError.create("SCHEDULE_FAILED", "Once schedule requires an 'at' field (ISO 8601 date string)");
-        }
-        return { type: "once", at: input.at };
-    }
-    throw TaskError.create("SCHEDULE_FAILED", `Invalid schedule type: "${type}". Must be "cron", "interval", or "once".`);
-}
-/**
- * Create task management tools bound to a TaskManager instance.
- *
- * These tools follow the same factory pattern as `createFileTools()` in
- * `src/lib/files/fileTools.ts`. The `manager` is captured via closure,
- * eliminating the need for module-level singleton state.
- *
- * @param manager - The TaskManager instance to bind to
- * @returns Record of tool name to tool definition
- *
- * @example
- * ```typescript
- * const manager = new TaskManager(neurolink, config);
- * const tools = createTaskTools(manager);
- * // tools.createTask, tools.listTasks, tools.getTaskRuns, etc.
- * ```
- */
-export function createTaskTools(manager) {
-    return {
-        createTask: tool({
-            description: 'Schedule a recurring or one-shot task that runs a prompt on a schedule. Use schedule type "cron" for calendar-based (e.g. "0 9 * * *"), "interval" for fixed frequency (every N milliseconds), or "once" for a single future execution.',
-            inputSchema: z.object({
-                name: z.string().describe("Human-readable task name"),
-                prompt: z.string().describe("The prompt to execute on each run"),
-                schedule: z
-                    .object({
-                    type: z.enum(["cron", "interval", "once"]),
-                    expression: z
-                        .string()
-                        .optional()
-                        .describe('Cron expression (for type "cron"), e.g. "0 9 * * *"'),
-                    timezone: z
-                        .string()
-                        .optional()
-                        .describe('IANA timezone for cron, e.g. "America/New_York"'),
-                    every: z
-                        .number()
-                        .optional()
-                        .describe('Interval in milliseconds (for type "interval")'),
-                    at: z
-                        .string()
-                        .optional()
-                        .describe('ISO 8601 timestamp (for type "once")'),
-                })
-                    .describe("When to run the task"),
-                mode: z
-                    .enum(["isolated", "continuation"])
-                    .optional()
-                    .describe('Execution mode. "isolated" = fresh context per run (default). "continuation" = preserves conversation history across runs.'),
-            }),
-            execute: async ({ name, prompt, schedule, mode }) => {
-                try {
-                    const parsedSchedule = parseSchedule(schedule);
-                    const task = await manager.create({
-                        name,
-                        prompt,
-                        schedule: parsedSchedule,
-                        mode: mode,
-                    });
-                    return {
-                        success: true,
-                        taskId: task.id,
-                        name: task.name,
-                        status: task.status,
-                        mode: task.mode,
-                        nextRunAt: task.nextRunAt,
-                        schedule: task.schedule,
-                    };
-                }
-                catch (error) {
-                    logger.error("[taskTools] createTask failed", {
-                        error: String(error),
-                    });
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
-        }),
-        listTasks: tool({
-            description: "List all scheduled tasks and their current status.",
-            inputSchema: z.object({
-                status: z
-                    .enum([
-                    "active",
-                    "paused",
-                    "completed",
-                    "failed",
-                    "cancelled",
-                    "pending",
-                ])
-                    .optional()
-                    .describe("Filter by task status"),
-            }),
-            execute: async ({ status }) => {
-                try {
-                    const tasks = await manager.list(status
-                        ? {
-                            status: status,
-                        }
-                        : undefined);
-                    return {
-                        success: true,
-                        count: tasks.length,
-                        tasks: tasks.map((t) => ({
-                            taskId: t.id,
-                            name: t.name,
-                            status: t.status,
-                            mode: t.mode,
-                            schedule: t.schedule,
-                            runCount: t.runCount,
-                            lastRunAt: t.lastRunAt,
-                            nextRunAt: t.nextRunAt,
-                        })),
-                    };
-                }
-                catch (error) {
-                    logger.error("[taskTools] listTasks failed", {
-                        error: String(error),
-                    });
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
-        }),
-        getTaskRuns: tool({
-            description: "Get the run history of a scheduled task, showing recent executions and their results.",
-            inputSchema: z.object({
-                taskId: z.string().describe("The task ID"),
-                limit: z
-                    .number()
-                    .optional()
-                    .describe("Max results to return (default: 10)"),
-            }),
-            execute: async ({ taskId, limit }) => {
-                try {
-                    const runs = await manager.runs(taskId, { limit: limit ?? 10 });
-                    return {
-                        success: true,
-                        taskId,
-                        count: runs.length,
-                        runs: runs.map((r) => ({
-                            runId: r.runId,
-                            status: r.status,
-                            output: r.output
-                                ? r.output.length > 500
-                                    ? r.output.slice(0, 500) + "..."
-                                    : r.output
-                                : undefined,
-                            durationMs: r.durationMs,
-                            timestamp: r.timestamp,
-                            error: r.error,
-                        })),
-                    };
-                }
-                catch (error) {
-                    logger.error("[taskTools] getTaskRuns failed", {
-                        error: String(error),
-                    });
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
-        }),
-        deleteTask: tool({
-            description: "Cancel and permanently remove a scheduled task.",
-            inputSchema: z.object({
-                taskId: z.string().describe("The task ID to delete"),
-            }),
-            execute: async ({ taskId }) => {
-                try {
-                    const task = await manager.get(taskId);
-                    if (!task) {
-                        return { success: false, error: `Task not found: ${taskId}` };
-                    }
-                    await manager.delete(taskId);
-                    return { success: true, deletedTask: task.name, taskId };
-                }
-                catch (error) {
-                    logger.error("[taskTools] deleteTask failed", {
-                        error: String(error),
-                    });
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
-        }),
-        runTaskNow: tool({
-            description: "Immediately execute a scheduled task outside of its normal schedule. Returns the run result.",
-            inputSchema: z.object({
-                taskId: z.string().describe("The task ID to run"),
-            }),
-            execute: async ({ taskId }) => {
-                try {
-                    const result = await manager.run(taskId);
-                    return {
-                        success: true,
-                        runId: result.runId,
-                        status: result.status,
-                        output: result.output
-                            ? result.output.length > 1000
-                                ? result.output.slice(0, 1000) + "..."
-                                : result.output
-                            : undefined,
-                        durationMs: result.durationMs,
-                        error: result.error,
-                    };
-                }
-                catch (error) {
-                    logger.error("[taskTools] runTaskNow failed", {
-                        error: String(error),
-                    });
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            },
-        }),
-    };
-}
-//# sourceMappingURL=taskTools.js.map

package/dist/lib/telemetry/attributes.d.ts

@@ -1,136 +0,0 @@
-export declare const ATTR: {
-    readonly GEN_AI_SYSTEM: "gen_ai.system";
-    readonly GEN_AI_MODEL: "gen_ai.request.model";
-    readonly GEN_AI_OPERATION: "gen_ai.operation.name";
-    readonly GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens";
-    readonly GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens";
-    readonly GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason";
-    readonly GEN_AI_COST_USD: "gen_ai.cost_usd";
-    readonly GEN_AI_TOOL_NAME: "gen_ai.tool.name";
-    readonly GEN_AI_TEMPERATURE: "gen_ai.request.temperature";
-    readonly GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens";
-    readonly NL_PROVIDER: "neurolink.provider";
-    readonly NL_MODEL: "neurolink.model";
-    readonly NL_STREAM_MODE: "neurolink.stream_mode";
-    readonly NL_TOOL_COUNT: "neurolink.tool_count";
-    readonly NL_MESSAGE_COUNT: "neurolink.message_count";
-    readonly NL_HAS_TOOLS: "neurolink.has_tools";
-    readonly NL_INPUT_LENGTH: "neurolink.input_length";
-    readonly NL_OUTPUT_LENGTH: "neurolink.output_length";
-    readonly NL_REQUEST_ID: "neurolink.request_id";
-    readonly NL_PATH: "neurolink.path";
-    readonly NL_HAS_MEMORY: "neurolink.has_conversation_memory";
-    readonly NL_COST: "neurolink.cost";
-    readonly NL_STRUCTURED_OUTPUT: "neurolink.structured_output";
-    readonly NL_HAS_FALLBACK: "neurolink.has_fallback";
-    readonly MCP_SERVER_ID: "mcp.server_id";
-    readonly MCP_TOOL_NAME: "mcp.tool_name";
-    readonly MCP_TIMEOUT_MS: "mcp.timeout_ms";
-    readonly MCP_TRANSPORT: "mcp.transport";
-    readonly MCP_CIRCUIT_STATE: "mcp.circuit_state";
-    readonly SESSION_ID: "session.id";
-    readonly USER_ID: "user.id";
-    readonly MEMORY_TYPE: "memory.type";
-    readonly MESSAGE_COUNT: "message.count";
-    readonly CONTENT_LENGTH: "content.length";
-    readonly RAG_FILE_COUNT: "rag.file_count";
-    readonly RAG_STRATEGY: "rag.strategy";
-    readonly RAG_CHUNK_SIZE: "rag.chunk_size";
-    readonly RAG_TOP_K: "rag.top_k";
-    readonly RAG_RESULT_COUNT: "rag.result_count";
-    readonly MSG_COUNT: "message.build.count";
-    readonly MSG_HAS_IMAGES: "message.has_images";
-    readonly MSG_HAS_FILES: "message.has_files";
-    readonly MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt";
-    readonly MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length";
-    readonly MSG_IS_MULTIMODAL: "message.is_multimodal";
-    readonly FILE_NAME: "file.name";
-    readonly FILE_MIMETYPE: "file.mimetype";
-    readonly FILE_SIZE_BYTES: "file.size_bytes";
-    readonly FILE_CATEGORY: "file.category";
-    readonly FILE_OUTPUT_LENGTH: "file.output_length";
-    readonly FILE_SUCCESS: "file.success";
-    readonly FILE_PROCESSOR_USED: "file.processor_used";
-    readonly FILE_CONFIDENCE: "file.detection_confidence";
-    readonly FILE_HAS_IMAGES: "file.has_images";
-    readonly FILE_IMAGE_COUNT: "file.image_count";
-    readonly FILE_ERROR: "file.error";
-    readonly FILE_SKIPPED_REASON: "file.skipped_reason";
-    readonly FILE_TOTAL_COUNT: "file.total_count";
-    readonly FILE_INCLUDED_COUNT: "file.included_count";
-    readonly FILE_CONTENT_TYPE: "file.content_type";
-    readonly VIDEO_DURATION_SEC: "video.duration_sec";
-    readonly VIDEO_WIDTH: "video.width";
-    readonly VIDEO_HEIGHT: "video.height";
-    readonly VIDEO_CODEC: "video.codec";
-    readonly VIDEO_AUDIO_CODEC: "video.audio_codec";
-    readonly VIDEO_FORMAT: "video.format";
-    readonly VIDEO_BITRATE: "video.bitrate";
-    readonly VIDEO_KEYFRAMES_EXTRACTED: "video.keyframes_extracted";
-    readonly VIDEO_TARGET_FRAMES: "video.target_frames";
-    readonly VIDEO_INTERVAL_SEC: "video.interval_sec";
-    readonly VIDEO_FRAME_QUALITY: "video.frame_quality";
-    readonly VIDEO_FRAME_RESIZE_PX: "video.frame_resize_px";
-    readonly VIDEO_FRAMES_RESIZED: "video.frames_resized";
-    readonly VIDEO_TOTAL_FRAME_BYTES: "video.total_frame_bytes";
-    readonly VIDEO_HAS_SUBTITLES: "video.has_subtitles";
-    readonly VIDEO_SUBTITLE_LENGTH: "video.subtitle_length";
-    readonly VIDEO_TEXT_CONTENT_LENGTH: "video.text_content_length";
-    readonly VIDEO_HAS_METADATA: "video.has_metadata";
-    readonly VIDEO_HAS_KEYFRAMES: "video.has_keyframes";
-    readonly VIDEO_TEMP_PATH: "video.temp_path";
-    readonly VIDEO_BYTES_WRITTEN: "video.bytes_written";
-    readonly VIDEO_WRITE_DURATION_MS: "video.write_duration_ms";
-    readonly VIDEO_STEP: "video.step";
-    readonly CONTEXT_STAGE: "context.compaction_stage";
-    readonly CONTEXT_TOKENS_BEFORE: "context.tokens_before";
-    readonly CONTEXT_TOKENS_AFTER: "context.tokens_after";
-    readonly MW_COUNT: "middleware.count";
-    readonly MW_NAMES: "middleware.names";
-    readonly AR_TAG: "autoresearch.tag";
-    readonly AR_BRANCH: "autoresearch.branch";
-    readonly AR_PHASE: "autoresearch.phase";
-    readonly AR_PHASE_FROM: "autoresearch.phase_from";
-    readonly AR_PHASE_TO: "autoresearch.phase_to";
-    readonly AR_RUN_COUNT: "autoresearch.run_count";
-    readonly AR_KEEP_COUNT: "autoresearch.keep_count";
-    readonly AR_STATUS: "autoresearch.status";
-    readonly AR_METRIC: "autoresearch.metric";
-    readonly AR_BEST_METRIC: "autoresearch.best_metric";
-    readonly AR_DIRECTION: "autoresearch.metric_direction";
-    readonly AR_COMMIT: "autoresearch.commit";
-    readonly AR_DURATION_MS: "autoresearch.duration_ms";
-    readonly AR_DESCRIPTION: "autoresearch.description";
-    readonly AR_ERROR_CODE: "autoresearch.error_code";
-};
-/**
- * Langfuse observation/trace attribute names recognised by `@langfuse/otel`'s
- * LangfuseSpanProcessor (already registered on the global TracerProvider). They
- * let native (non-AI-SDK) provider paths emit spans that render as proper
- * generation / tool observations — the same data the Vercel AI SDK's
- * `experimental_telemetry` produced before providers moved to native SDKs.
- */
-export declare const LANGFUSE_ATTR: {
-    readonly TRACE_NAME: "langfuse.trace.name";
-    readonly TRACE_INPUT: "langfuse.trace.input";
-    readonly TRACE_OUTPUT: "langfuse.trace.output";
-    readonly OBSERVATION_TYPE: "langfuse.observation.type";
-    readonly OBSERVATION_INPUT: "langfuse.observation.input";
-    readonly OBSERVATION_OUTPUT: "langfuse.observation.output";
-    readonly OBSERVATION_METADATA: "langfuse.observation.metadata";
-    readonly OBSERVATION_MODEL_NAME: "langfuse.observation.model.name";
-    readonly OBSERVATION_MODEL_PARAMETERS: "langfuse.observation.model.parameters";
-    readonly OBSERVATION_USAGE_DETAILS: "langfuse.observation.usage_details";
-    readonly OBSERVATION_LEVEL: "langfuse.observation.level";
-    readonly OBSERVATION_STATUS_MESSAGE: "langfuse.observation.status_message";
-    readonly OBSERVATION_COMPLETION_START_TIME: "langfuse.observation.completion_start_time";
-};
-/** Default ceiling for serialized span attribute values. */
-export declare const SPAN_ATTRIBUTE_MAX_CHARS = 40000;
-/**
- * Serialize an arbitrary value for a span attribute, hard-capped at
- * `maxChars` so a pathological prompt or tool result can't put megabytes
- * on a single span. Strings pass through unserialized; everything else is
- * JSON-stringified with a String() fallback for circular structures.
- */
-export declare function spanJsonAttribute(value: unknown, maxChars?: number): string;

package/dist/lib/telemetry/attributes.js

@@ -1,165 +0,0 @@
-export const ATTR = {
-    // GenAI standard (OpenTelemetry semantic conventions)
-    GEN_AI_SYSTEM: "gen_ai.system",
-    GEN_AI_MODEL: "gen_ai.request.model",
-    GEN_AI_OPERATION: "gen_ai.operation.name",
-    GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens",
-    GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
-    GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason",
-    GEN_AI_COST_USD: "gen_ai.cost_usd",
-    GEN_AI_TOOL_NAME: "gen_ai.tool.name",
-    GEN_AI_TEMPERATURE: "gen_ai.request.temperature",
-    GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens",
-    // NeuroLink custom
-    NL_PROVIDER: "neurolink.provider",
-    NL_MODEL: "neurolink.model",
-    NL_STREAM_MODE: "neurolink.stream_mode",
-    NL_TOOL_COUNT: "neurolink.tool_count",
-    NL_MESSAGE_COUNT: "neurolink.message_count",
-    NL_HAS_TOOLS: "neurolink.has_tools",
-    NL_INPUT_LENGTH: "neurolink.input_length",
-    NL_OUTPUT_LENGTH: "neurolink.output_length",
-    NL_REQUEST_ID: "neurolink.request_id",
-    NL_PATH: "neurolink.path",
-    NL_HAS_MEMORY: "neurolink.has_conversation_memory",
-    NL_COST: "neurolink.cost",
-    NL_STRUCTURED_OUTPUT: "neurolink.structured_output",
-    NL_HAS_FALLBACK: "neurolink.has_fallback",
-    // MCP
-    MCP_SERVER_ID: "mcp.server_id",
-    MCP_TOOL_NAME: "mcp.tool_name",
-    MCP_TIMEOUT_MS: "mcp.timeout_ms",
-    MCP_TRANSPORT: "mcp.transport",
-    MCP_CIRCUIT_STATE: "mcp.circuit_state",
-    // Session/Memory
-    SESSION_ID: "session.id",
-    USER_ID: "user.id",
-    MEMORY_TYPE: "memory.type",
-    MESSAGE_COUNT: "message.count",
-    CONTENT_LENGTH: "content.length",
-    // RAG
-    RAG_FILE_COUNT: "rag.file_count",
-    RAG_STRATEGY: "rag.strategy",
-    RAG_CHUNK_SIZE: "rag.chunk_size",
-    RAG_TOP_K: "rag.top_k",
-    RAG_RESULT_COUNT: "rag.result_count",
-    // Message building
-    MSG_COUNT: "message.build.count",
-    MSG_HAS_IMAGES: "message.has_images",
-    MSG_HAS_FILES: "message.has_files",
-    MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt",
-    MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length",
-    MSG_IS_MULTIMODAL: "message.is_multimodal",
-    // File processing
-    FILE_NAME: "file.name",
-    FILE_MIMETYPE: "file.mimetype",
-    FILE_SIZE_BYTES: "file.size_bytes",
-    FILE_CATEGORY: "file.category",
-    FILE_OUTPUT_LENGTH: "file.output_length",
-    FILE_SUCCESS: "file.success",
-    FILE_PROCESSOR_USED: "file.processor_used",
-    FILE_CONFIDENCE: "file.detection_confidence",
-    FILE_HAS_IMAGES: "file.has_images",
-    FILE_IMAGE_COUNT: "file.image_count",
-    FILE_ERROR: "file.error",
-    FILE_SKIPPED_REASON: "file.skipped_reason",
-    FILE_TOTAL_COUNT: "file.total_count",
-    FILE_INCLUDED_COUNT: "file.included_count",
-    FILE_CONTENT_TYPE: "file.content_type",
-    // Video processing
-    VIDEO_DURATION_SEC: "video.duration_sec",
-    VIDEO_WIDTH: "video.width",
-    VIDEO_HEIGHT: "video.height",
-    VIDEO_CODEC: "video.codec",
-    VIDEO_AUDIO_CODEC: "video.audio_codec",
-    VIDEO_FORMAT: "video.format",
-    VIDEO_BITRATE: "video.bitrate",
-    VIDEO_KEYFRAMES_EXTRACTED: "video.keyframes_extracted",
-    VIDEO_TARGET_FRAMES: "video.target_frames",
-    VIDEO_INTERVAL_SEC: "video.interval_sec",
-    VIDEO_FRAME_QUALITY: "video.frame_quality",
-    VIDEO_FRAME_RESIZE_PX: "video.frame_resize_px",
-    VIDEO_FRAMES_RESIZED: "video.frames_resized",
-    VIDEO_TOTAL_FRAME_BYTES: "video.total_frame_bytes",
-    VIDEO_HAS_SUBTITLES: "video.has_subtitles",
-    VIDEO_SUBTITLE_LENGTH: "video.subtitle_length",
-    VIDEO_TEXT_CONTENT_LENGTH: "video.text_content_length",
-    VIDEO_HAS_METADATA: "video.has_metadata",
-    VIDEO_HAS_KEYFRAMES: "video.has_keyframes",
-    VIDEO_TEMP_PATH: "video.temp_path",
-    VIDEO_BYTES_WRITTEN: "video.bytes_written",
-    VIDEO_WRITE_DURATION_MS: "video.write_duration_ms",
-    VIDEO_STEP: "video.step",
-    // Context
-    CONTEXT_STAGE: "context.compaction_stage",
-    CONTEXT_TOKENS_BEFORE: "context.tokens_before",
-    CONTEXT_TOKENS_AFTER: "context.tokens_after",
-    // Middleware
-    MW_COUNT: "middleware.count",
-    MW_NAMES: "middleware.names",
-    // Autoresearch
-    AR_TAG: "autoresearch.tag",
-    AR_BRANCH: "autoresearch.branch",
-    AR_PHASE: "autoresearch.phase",
-    AR_PHASE_FROM: "autoresearch.phase_from",
-    AR_PHASE_TO: "autoresearch.phase_to",
-    AR_RUN_COUNT: "autoresearch.run_count",
-    AR_KEEP_COUNT: "autoresearch.keep_count",
-    AR_STATUS: "autoresearch.status",
-    AR_METRIC: "autoresearch.metric",
-    AR_BEST_METRIC: "autoresearch.best_metric",
-    AR_DIRECTION: "autoresearch.metric_direction",
-    AR_COMMIT: "autoresearch.commit",
-    AR_DURATION_MS: "autoresearch.duration_ms",
-    AR_DESCRIPTION: "autoresearch.description",
-    AR_ERROR_CODE: "autoresearch.error_code",
-};
-/**
- * Langfuse observation/trace attribute names recognised by `@langfuse/otel`'s
- * LangfuseSpanProcessor (already registered on the global TracerProvider). They
- * let native (non-AI-SDK) provider paths emit spans that render as proper
- * generation / tool observations — the same data the Vercel AI SDK's
- * `experimental_telemetry` produced before providers moved to native SDKs.
- */
-export const LANGFUSE_ATTR = {
-    TRACE_NAME: "langfuse.trace.name",
-    TRACE_INPUT: "langfuse.trace.input",
-    TRACE_OUTPUT: "langfuse.trace.output",
-    OBSERVATION_TYPE: "langfuse.observation.type",
-    OBSERVATION_INPUT: "langfuse.observation.input",
-    OBSERVATION_OUTPUT: "langfuse.observation.output",
-    OBSERVATION_METADATA: "langfuse.observation.metadata",
-    OBSERVATION_MODEL_NAME: "langfuse.observation.model.name",
-    OBSERVATION_MODEL_PARAMETERS: "langfuse.observation.model.parameters",
-    OBSERVATION_USAGE_DETAILS: "langfuse.observation.usage_details",
-    OBSERVATION_LEVEL: "langfuse.observation.level",
-    OBSERVATION_STATUS_MESSAGE: "langfuse.observation.status_message",
-    OBSERVATION_COMPLETION_START_TIME: "langfuse.observation.completion_start_time",
-};
-/** Default ceiling for serialized span attribute values. */
-export const SPAN_ATTRIBUTE_MAX_CHARS = 40_000;
-/**
- * Serialize an arbitrary value for a span attribute, hard-capped at
- * `maxChars` so a pathological prompt or tool result can't put megabytes
- * on a single span. Strings pass through unserialized; everything else is
- * JSON-stringified with a String() fallback for circular structures.
- */
-export function spanJsonAttribute(value, maxChars = SPAN_ATTRIBUTE_MAX_CHARS) {
-    let serialized;
-    try {
-        serialized =
-            typeof value === "string"
-                ? value
-                : (JSON.stringify(value) ?? String(value));
-    }
-    catch {
-        serialized = String(value);
-    }
-    if (serialized.length > maxChars) {
-        const truncationSuffix = `...[truncated ${serialized.length - maxChars} chars]`;
-        const keepLength = Math.max(0, maxChars - truncationSuffix.length);
-        return `${serialized.slice(0, keepLength)}${truncationSuffix}`;
-    }
-    return serialized;
-}
-//# sourceMappingURL=attributes.js.map

package/dist/lib/telemetry/index.d.ts

@@ -1,20 +0,0 @@
-export { TelemetryService } from "./telemetryService.js";
-export { tracers } from "./tracers.js";
-export { withSpan, withClientSpan, withStreamSpan, withClientStreamSpan, } from "./withSpan.js";
-export { ATTR, LANGFUSE_ATTR, SPAN_ATTRIBUTE_MAX_CHARS, spanJsonAttribute, } from "./attributes.js";
-/**
- * Initialize telemetry for NeuroLink
- * Reuses an existing global TracerProvider when one is already registered,
- * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
- */
-export declare function initializeTelemetry(): Promise<import("./telemetryService.js").TelemetryService>;
-/**
- * Get telemetry status
- */
-export declare function getTelemetryStatus(): Promise<{
-    enabled: boolean;
-    initialized: boolean;
-    endpoint?: string;
-    service?: string;
-    version?: string;
-}>;

package/dist/lib/telemetry/index.js

@@ -1,28 +0,0 @@
-// Optional Telemetry Infrastructure (Phase 2)
-export { TelemetryService } from "./telemetryService.js";
-export { tracers } from "./tracers.js";
-export { withSpan, withClientSpan, withStreamSpan, withClientStreamSpan, } from "./withSpan.js";
-export { ATTR, LANGFUSE_ATTR, SPAN_ATTRIBUTE_MAX_CHARS, spanJsonAttribute, } from "./attributes.js";
-import { logger } from "../utils/logger.js";
-/**
- * Initialize telemetry for NeuroLink
- * Reuses an existing global TracerProvider when one is already registered,
- * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
- */
-export async function initializeTelemetry() {
-    const { TelemetryService } = await import("./telemetryService.js");
-    const telemetry = TelemetryService.getInstance();
-    if (telemetry.isEnabled()) {
-        await telemetry.initialize();
-        logger.info("[NeuroLink] Telemetry initialized");
-    }
-    return telemetry;
-}
-/**
- * Get telemetry status
- */
-export async function getTelemetryStatus() {
-    const { TelemetryService } = await import("./telemetryService.js");
-    return TelemetryService.getInstance().getStatus();
-}
-//# sourceMappingURL=index.js.map

package/dist/lib/telemetry/telemetryService.d.ts

@@ -1,58 +0,0 @@
-import type { HealthMetrics } from "../types/index.js";
-export declare class TelemetryService {
-    private static instance;
-    private tracerProvider?;
-    private enabled;
-    private initialized;
-    private usingExternalTracerProvider;
-    private meter?;
-    private tracer?;
-    private aiRequestCounter?;
-    private aiRequestDuration?;
-    private aiTokensUsed?;
-    private aiProviderErrors?;
-    private aiCostUsd?;
-    private mcpToolCalls?;
-    private connectionCounter?;
-    private responseTimeHistogram?;
-    private activeConnectionCount;
-    private errorCount;
-    private requestCount;
-    private totalResponseTime;
-    private responseTimeCount;
-    private constructor();
-    static getInstance(): TelemetryService;
-    private isTelemetryEnabled;
-    private hasExternalTracerProvider;
-    private adoptExternalTracerProvider;
-    private initializeTelemetry;
-    private initializeMetrics;
-    initialize(): Promise<void>;
-    /**
-     * @deprecated Vercel AI SDK's experimental_telemetry creates ai.generateText/ai.streamText
-     * spans automatically via OpenTelemetry. Using this method would create duplicate spans.
-     * Kept for potential future use with non-Vercel providers (e.g., Amazon Bedrock).
-     * See: TelemetryHandler.getTelemetryConfig() for the active telemetry path.
-     */
-    traceAIRequest<T>(provider: string, operation: () => Promise<T>, operationType?: string): Promise<T>;
-    recordAIRequest(provider: string, model: string, tokens: number, duration: number, cost?: number): void;
-    recordAIError(provider: string, error: Error): void;
-    recordMCPToolCall(toolName: string, duration: number, success: boolean): void;
-    recordConnection(type: "websocket" | "sse" | "http"): void;
-    recordConnectionClosed(type: "websocket" | "sse" | "http"): void;
-    recordResponseTime(endpoint: string, method: string, duration: number): void;
-    recordCustomMetric(name: string, value: number, labels?: Record<string, string>): void;
-    recordCustomHistogram(name: string, value: number, labels?: Record<string, string>): void;
-    getHealthMetrics(): Promise<HealthMetrics>;
-    isEnabled(): boolean;
-    getStatus(): {
-        enabled: boolean;
-        initialized: boolean;
-        endpoint?: string;
-        service?: string;
-        version?: string;
-    };
-    private getDurationBucket;
-    private getStatusBucket;
-    shutdown(): Promise<void>;
-}