@struct-ai/sdk 0.1.0

package/dist/esm/integrations/langchain-content.d.ts

@@ -0,0 +1,35 @@
+import type { Part } from "./anthropic-content.js";
+export declare const PROVIDER_MAP: Record<string, string>;
+export declare const MODULE_PROVIDER_MAP: Record<string, string>;
+/** Detect LLM provider from a LangChain model instance. */
+export declare function detectProvider(model: unknown): string;
+/** Probe `modelName`, `model`, `modelId` attrs in order. */
+export declare function detectModel(model: unknown): string;
+/**
+ * Extract the messages list from LangChain invoke()'s input argument.
+ * Handles: BaseMessage[], string, PromptValue (via toChatMessages/toMessages),
+ * dict with .messages key.
+ */
+export declare function extractInputMessages(input: unknown): unknown[];
+/**
+ * Extract thread_id from LangChain/LangGraph RunnableConfig.
+ * Signature: (input, config?, ...).  Config has shape { configurable: { thread_id: "..." } }.
+ */
+export declare function extractThreadId(args: readonly unknown[], options?: unknown): string | undefined;
+/**
+ * Extract tool_call_id from LangChain ToolCall input.
+ * LangChain tool invocation input shape: { name, args, id, type: "tool_call" }.
+ */
+export declare function extractToolCallId(args: readonly unknown[]): string | undefined;
+/** Convert a LangChain message to (role, parts). Uses ._getType() first, falls back to class name. */
+export declare function langchainMessageToRoleAndParts(msg: unknown): {
+    role: string;
+    parts: Part[];
+};
+export declare function langchainToInputMessages(messages: unknown[]): string;
+export declare function langchainToOutputMessages(result: unknown): string;
+/** Last user message parts for parent invoke_agent span propagation. */
+export declare function lastUserMessageParts(messages: unknown[]): Part[] | undefined;
+/** Merge a list of LangChain AIMessageChunks into one via .concat(). */
+export declare function mergeChunks(chunks: unknown[]): unknown;
+//# sourceMappingURL=langchain-content.d.ts.map

package/dist/esm/integrations/langchain-content.js

@@ -0,0 +1,294 @@
+import { truncateAndSerialize } from "../truncation.js";
+import { LANGCHAIN_FINISH_REASON_MAP } from "../semconv.js";
+export const PROVIDER_MAP = {
+    ChatOpenAI: "openai",
+    AzureChatOpenAI: "azure.openai",
+    ChatAnthropic: "anthropic",
+    ChatGoogleGenerativeAI: "gcp.generative_ai",
+    ChatVertexAI: "gcp.vertex_ai",
+    ChatCohere: "cohere",
+    ChatMistralAI: "mistral",
+    ChatGroq: "groq",
+    ChatBedrock: "aws.bedrock",
+    ChatBedrockConverse: "aws.bedrock",
+    BedrockChat: "aws.bedrock",
+    ChatFireworks: "fireworks",
+    ChatTogether: "together",
+    ChatOllama: "ollama",
+    ChatDeepSeek: "deepseek",
+};
+export const MODULE_PROVIDER_MAP = {
+    openai: "openai",
+    anthropic: "anthropic",
+    google: "gcp.generative_ai",
+    cohere: "cohere",
+    mistral: "mistral",
+    groq: "groq",
+    bedrock: "aws.bedrock",
+    fireworks: "fireworks",
+    together: "together",
+    ollama: "ollama",
+    deepseek: "deepseek",
+};
+/** Detect LLM provider from a LangChain model instance. */
+export function detectProvider(model) {
+    if (!model || typeof model !== "object")
+        return "langchain";
+    const m = model;
+    const className = m.constructor?.name ?? "";
+    if (className in PROVIDER_MAP)
+        return PROVIDER_MAP[className];
+    // LangChain's _llmType() returns the provider string directly (e.g. "openai", "anthropic").
+    if (typeof m._llmType === "function") {
+        try {
+            const t = m._llmType();
+            if (typeof t === "string" && t in MODULE_PROVIDER_MAP) {
+                return MODULE_PROVIDER_MAP[t];
+            }
+            if (typeof t === "string" && t)
+                return t;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return "langchain";
+}
+/** Probe `modelName`, `model`, `modelId` attrs in order. */
+export function detectModel(model) {
+    if (!model || typeof model !== "object")
+        return "unknown";
+    const m = model;
+    for (const attr of ["modelName", "model", "modelId"]) {
+        const val = m[attr];
+        if (typeof val === "string" && val.length > 0)
+            return val;
+    }
+    return "unknown";
+}
+/**
+ * Extract the messages list from LangChain invoke()'s input argument.
+ * Handles: BaseMessage[], string, PromptValue (via toChatMessages/toMessages),
+ * dict with .messages key.
+ */
+export function extractInputMessages(input) {
+    if (input == null)
+        return [];
+    if (Array.isArray(input))
+        return input;
+    if (typeof input === "string") {
+        return [{ role: "user", content: input }];
+    }
+    if (typeof input === "object") {
+        const obj = input;
+        if (typeof obj.toChatMessages === "function") {
+            try {
+                return obj.toChatMessages() ?? [];
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (typeof obj.toMessages === "function") {
+            try {
+                return obj.toMessages() ?? [];
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (Array.isArray(obj.messages))
+            return obj.messages;
+    }
+    return [];
+}
+/**
+ * Extract thread_id from LangChain/LangGraph RunnableConfig.
+ * Signature: (input, config?, ...).  Config has shape { configurable: { thread_id: "..." } }.
+ */
+export function extractThreadId(args, options) {
+    const config = (args.length > 1 ? args[1] : undefined) ?? options ?? undefined;
+    if (!config || typeof config !== "object")
+        return undefined;
+    const configurable = config.configurable;
+    if (!configurable || typeof configurable !== "object")
+        return undefined;
+    const threadId = configurable.thread_id;
+    if (typeof threadId === "string" && threadId.length > 0)
+        return threadId;
+    return undefined;
+}
+/**
+ * Extract tool_call_id from LangChain ToolCall input.
+ * LangChain tool invocation input shape: { name, args, id, type: "tool_call" }.
+ */
+export function extractToolCallId(args) {
+    const input = args.length > 0 ? args[0] : undefined;
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return undefined;
+    const id = input.id;
+    if (typeof id === "string" && id.length > 0)
+        return id;
+    return undefined;
+}
+/** Convert a LangChain message to (role, parts). Uses ._getType() first, falls back to class name. */
+export function langchainMessageToRoleAndParts(msg) {
+    if (msg && typeof msg === "object" && !Array.isArray(msg)) {
+        const m = msg;
+        // Plain dict form
+        if (typeof m.role === "string" && !("_getType" in m) && !("constructor" in m && m.constructor?.name?.endsWith("Message"))) {
+            const parts = [];
+            if (m.content)
+                parts.push({ type: "text", content: String(m.content) });
+            return { role: m.role, parts };
+        }
+        let type;
+        if (typeof m._getType === "function") {
+            try {
+                type = m._getType();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (!type) {
+            const cname = m.constructor?.name ?? "";
+            if (cname === "HumanMessage")
+                type = "human";
+            else if (cname === "SystemMessage")
+                type = "system";
+            else if (cname === "AIMessage" || cname === "AIMessageChunk")
+                type = "ai";
+            else if (cname === "ToolMessage")
+                type = "tool";
+        }
+        const parts = [];
+        const content = m.content;
+        if (type === "tool") {
+            const toolCallId = typeof m.tool_call_id === "string" ? m.tool_call_id : "";
+            parts.push({
+                type: "tool_call_response",
+                id: toolCallId,
+                response: typeof content === "string" ? content : String(content ?? ""),
+            });
+            return { role: "tool", parts };
+        }
+        // Text content (string) → text part
+        if (typeof content === "string" && content.length > 0) {
+            parts.push({ type: "text", content });
+        }
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (typeof block === "string") {
+                    parts.push({ type: "text", content: block });
+                }
+                else if (block && typeof block === "object") {
+                    const b = block;
+                    const btype = b.type;
+                    if (btype === "text") {
+                        parts.push({ type: "text", content: String(b.text ?? "") });
+                    }
+                    else if (btype === "image_url") {
+                        const url = b.image_url;
+                        if (url && typeof url === "object") {
+                            const u = url.url;
+                            if (typeof u === "string") {
+                                parts.push({ type: "uri", modality: "image", uri: u });
+                            }
+                        }
+                        else if (typeof url === "string") {
+                            parts.push({ type: "uri", modality: "image", uri: url });
+                        }
+                    }
+                }
+            }
+        }
+        // AI tool_calls → tool_call parts
+        if (type === "ai" || type === "assistant") {
+            const toolCalls = m.tool_calls;
+            if (Array.isArray(toolCalls)) {
+                for (const tc of toolCalls) {
+                    const name = typeof tc.name === "string" ? tc.name : "";
+                    const part = { type: "tool_call", name };
+                    if (typeof tc.id === "string" && tc.id)
+                        part.id = tc.id;
+                    if (tc.args !== undefined)
+                        part.arguments = tc.args;
+                    parts.push(part);
+                }
+            }
+            return { role: "assistant", parts };
+        }
+        if (type === "human" || type === "user")
+            return { role: "user", parts };
+        if (type === "system")
+            return { role: "system", parts };
+        if (type === "tool")
+            return { role: "tool", parts };
+        // Fallback: honor an explicit .role if present, else "user"
+        const role = typeof m.role === "string" ? m.role : type ?? "user";
+        return { role, parts };
+    }
+    return { role: "user", parts: [] };
+}
+export function langchainToInputMessages(messages) {
+    try {
+        const result = messages.map((msg) => {
+            const { role, parts } = langchainMessageToRoleAndParts(msg);
+            return { role, parts };
+        });
+        return truncateAndSerialize(result);
+    }
+    catch {
+        return "[]";
+    }
+}
+export function langchainToOutputMessages(result) {
+    try {
+        const { parts } = langchainMessageToRoleAndParts(result);
+        const respMeta = (result && typeof result === "object"
+            ? result
+                .response_metadata
+            : undefined) ?? {};
+        const finish = (typeof respMeta.finish_reason === "string" && respMeta.finish_reason) ||
+            (typeof respMeta.stop_reason === "string" && respMeta.stop_reason) ||
+            null;
+        const msg = { role: "assistant", parts };
+        if (finish) {
+            msg.finish_reason = LANGCHAIN_FINISH_REASON_MAP[finish] ?? finish;
+        }
+        return truncateAndSerialize([msg]);
+    }
+    catch {
+        return "[]";
+    }
+}
+/** Last user message parts for parent invoke_agent span propagation. */
+export function lastUserMessageParts(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const { role, parts } = langchainMessageToRoleAndParts(messages[i]);
+        if (role === "user")
+            return parts;
+    }
+    return undefined;
+}
+/** Merge a list of LangChain AIMessageChunks into one via .concat(). */
+export function mergeChunks(chunks) {
+    if (chunks.length === 0)
+        return null;
+    let result = chunks[0];
+    for (let i = 1; i < chunks.length; i++) {
+        if (!result)
+            break;
+        try {
+            if (typeof result.concat === "function") {
+                result = result.concat(chunks[i]);
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=langchain-content.js.map

package/dist/esm/integrations/langchain.d.ts

@@ -0,0 +1,11 @@
+import type { StructSDK } from "../core.js";
+import { StructCallbackHandler } from "./langchain-callback.js";
+/**
+ * Export the handler so callers can register it explicitly
+ * (e.g. `runnable.invoke(x, { callbacks: [struct.langchainHandler] })`)
+ * when the global monkey-patch isn't an option.
+ */
+export declare function getLangchainHandler(): StructCallbackHandler | undefined;
+export declare function patch(sdk: StructSDK): Promise<void>;
+export declare function unpatch(): Promise<void>;
+//# sourceMappingURL=langchain.d.ts.map

package/dist/esm/integrations/langchain.js

@@ -0,0 +1,95 @@
+import { StructCallbackHandler } from "./langchain-callback.js";
+/**
+ * LangChain.js integration — registers a BaseCallbackHandler subclass with
+ * LangChain's CallbackManager so every chain/LLM/tool/retriever run produces
+ * an OTel span. This is the same integration pattern used by LangSmith,
+ * Arize OpenInference, Traceloop, and Langfuse.
+ *
+ * Why callbacks instead of monkey-patching: LangChain's callbacks carry
+ * parentRunId explicitly, so span parentage survives LangGraph's internal
+ * async microtask shuffling (which otherwise drops OTel's active context).
+ */
+const STRUCT_WRAPPED = Symbol.for("struct.wrapped");
+const state = {};
+/**
+ * Export the handler so callers can register it explicitly
+ * (e.g. `runnable.invoke(x, { callbacks: [struct.langchainHandler] })`)
+ * when the global monkey-patch isn't an option.
+ */
+export function getLangchainHandler() {
+    return state.handler;
+}
+export async function patch(sdk) {
+    const handler = new StructCallbackHandler(sdk, sdk.getTracer("struct-sdk-langchain"), sdk.emitEvents ? sdk.getLogger("struct-sdk-langchain") : undefined);
+    state.handler = handler;
+    // Monkey-patch CallbackManager.configure so every invoke/stream/batch call
+    // picks up our handler as an inheritable callback. This is exactly how
+    // OpenInference (@arizeai) and Traceloop hook into LangChain JS.
+    const mod = (await import("@langchain/core/callbacks/manager"));
+    const cm = mod.CallbackManager;
+    // Preserve original-function refs from any prior patch() — a second patch()
+    // call (e.g. autoInstrument then explicit patch) would otherwise wipe them,
+    // leaving unpatch() unable to restore.
+    const prev = state.cfg;
+    state.cfg = {
+        mod,
+        originalConfigure: prev?.originalConfigure,
+        originalConfigureSync: prev?.originalConfigureSync,
+    };
+    if (!cm.configure[STRUCT_WRAPPED]) {
+        const originalConfigure = cm.configure.bind(cm);
+        state.cfg.originalConfigure = originalConfigure;
+        const wrappedConfigure = function (...args) {
+            const active = state.handler;
+            if (active)
+                args[0] = injectHandler(args[0], active);
+            return originalConfigure.apply(cm, args);
+        };
+        wrappedConfigure[STRUCT_WRAPPED] = true;
+        cm.configure = wrappedConfigure;
+    }
+    if (cm._configureSync && !cm._configureSync[STRUCT_WRAPPED]) {
+        const originalSync = cm._configureSync.bind(cm);
+        state.cfg.originalConfigureSync = originalSync;
+        const wrappedSync = function (...args) {
+            const active = state.handler;
+            if (active)
+                args[0] = injectHandler(args[0], active);
+            return originalSync.apply(cm, args);
+        };
+        wrappedSync[STRUCT_WRAPPED] = true;
+        cm._configureSync = wrappedSync;
+    }
+}
+export async function unpatch() {
+    if (state.cfg?.mod) {
+        const cm = state.cfg.mod.CallbackManager;
+        if (cm.configure[STRUCT_WRAPPED] && state.cfg.originalConfigure) {
+            cm.configure = state.cfg.originalConfigure;
+        }
+        if (cm._configureSync?.[STRUCT_WRAPPED] &&
+            state.cfg.originalConfigureSync) {
+            cm._configureSync = state.cfg.originalConfigureSync;
+        }
+    }
+    state.handler = undefined;
+    state.cfg = undefined;
+}
+function injectHandler(existing, handler) {
+    if (existing == null)
+        return [handler];
+    if (Array.isArray(existing)) {
+        if (existing.some((h) => h?.name === "struct")) {
+            return existing;
+        }
+        return [...existing, handler];
+    }
+    // BaseCallbackManager instance: addHandler on it.
+    const mgr = existing;
+    if (typeof mgr.addHandler === "function" &&
+        !mgr.handlers?.some((h) => h?.name === "struct")) {
+        mgr.addHandler(handler, true);
+    }
+    return existing;
+}
+//# sourceMappingURL=langchain.js.map

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/semconv.d.ts

@@ -0,0 +1,54 @@
+export declare const GEN_AI: {
+    readonly OPERATION_NAME: "gen_ai.operation.name";
+    readonly PROVIDER_NAME: "gen_ai.provider.name";
+    readonly SYSTEM: "gen_ai.system";
+    readonly AGENT_NAME: "gen_ai.agent.name";
+    readonly AGENT_ID: "gen_ai.agent.id";
+    readonly AGENT_VERSION: "gen_ai.agent.version";
+    readonly CONVERSATION_ID: "gen_ai.conversation.id";
+    readonly REQUEST_MODEL: "gen_ai.request.model";
+    readonly REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens";
+    readonly REQUEST_TEMPERATURE: "gen_ai.request.temperature";
+    readonly REQUEST_TOP_P: "gen_ai.request.top_p";
+    readonly REQUEST_TOP_K: "gen_ai.request.top_k";
+    readonly REQUEST_FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty";
+    readonly REQUEST_PRESENCE_PENALTY: "gen_ai.request.presence_penalty";
+    readonly REQUEST_STOP_SEQUENCES: "gen_ai.request.stop_sequences";
+    readonly RESPONSE_MODEL: "gen_ai.response.model";
+    readonly RESPONSE_FINISH_REASONS: "gen_ai.response.finish_reasons";
+    readonly RESPONSE_ID: "gen_ai.response.id";
+    readonly USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens";
+    readonly USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens";
+    readonly USAGE_CACHE_READ_INPUT_TOKENS: "gen_ai.usage.cache_read.input_tokens";
+    readonly USAGE_CACHE_CREATION_INPUT_TOKENS: "gen_ai.usage.cache_creation.input_tokens";
+    readonly INPUT_MESSAGES: "gen_ai.input.messages";
+    readonly OUTPUT_MESSAGES: "gen_ai.output.messages";
+    readonly SYSTEM_INSTRUCTIONS: "gen_ai.system_instructions";
+    readonly TOOL_DEFINITIONS: "gen_ai.tool.definitions";
+    readonly TOOL_NAME: "gen_ai.tool.name";
+    readonly TOOL_CALL_ID: "gen_ai.tool.call.id";
+    readonly TOOL_CALL_ARGUMENTS: "gen_ai.tool.call.arguments";
+    readonly TOOL_CALL_RESULT: "gen_ai.tool.call.result";
+    readonly DATA_SOURCE_ID: "gen_ai.data_source.id";
+    readonly RETRIEVAL_QUERY_TEXT: "gen_ai.retrieval.query.text";
+    readonly RETRIEVAL_DOCUMENTS: "gen_ai.retrieval.documents";
+    readonly MESSAGE_INDEX: "gen_ai.message.index";
+};
+export declare const STRUCT: {
+    readonly METADATA_PREFIX: "struct.metadata.";
+    readonly AGENT_PARENT_SESSION_ID: "struct.agent.parent_session_id";
+    readonly INPUT_MESSAGE_COUNT: "struct.input.message_count";
+};
+export declare const EVENT_NAME = "event.name";
+export declare const ERROR_TYPE = "error.type";
+export declare const EVENT_NAMES: {
+    readonly USER_MESSAGE: "gen_ai.user.message";
+    readonly ASSISTANT_MESSAGE: "gen_ai.assistant.message";
+    readonly SYSTEM_MESSAGE: "gen_ai.system.message";
+    readonly TOOL_MESSAGE: "gen_ai.tool.message";
+    readonly CHOICE: "gen_ai.choice";
+};
+export declare const ROLE_TO_EVENT_NAME: Record<string, string>;
+export declare const ANTHROPIC_FINISH_REASON_MAP: Record<string, string>;
+export declare const LANGCHAIN_FINISH_REASON_MAP: Record<string, string>;
+//# sourceMappingURL=semconv.d.ts.map

package/dist/esm/semconv.js

@@ -0,0 +1,71 @@
+export const GEN_AI = {
+    OPERATION_NAME: "gen_ai.operation.name",
+    PROVIDER_NAME: "gen_ai.provider.name",
+    SYSTEM: "gen_ai.system",
+    AGENT_NAME: "gen_ai.agent.name",
+    AGENT_ID: "gen_ai.agent.id",
+    AGENT_VERSION: "gen_ai.agent.version",
+    CONVERSATION_ID: "gen_ai.conversation.id",
+    REQUEST_MODEL: "gen_ai.request.model",
+    REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens",
+    REQUEST_TEMPERATURE: "gen_ai.request.temperature",
+    REQUEST_TOP_P: "gen_ai.request.top_p",
+    REQUEST_TOP_K: "gen_ai.request.top_k",
+    REQUEST_FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty",
+    REQUEST_PRESENCE_PENALTY: "gen_ai.request.presence_penalty",
+    REQUEST_STOP_SEQUENCES: "gen_ai.request.stop_sequences",
+    RESPONSE_MODEL: "gen_ai.response.model",
+    RESPONSE_FINISH_REASONS: "gen_ai.response.finish_reasons",
+    RESPONSE_ID: "gen_ai.response.id",
+    USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+    USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+    USAGE_CACHE_READ_INPUT_TOKENS: "gen_ai.usage.cache_read.input_tokens",
+    USAGE_CACHE_CREATION_INPUT_TOKENS: "gen_ai.usage.cache_creation.input_tokens",
+    INPUT_MESSAGES: "gen_ai.input.messages",
+    OUTPUT_MESSAGES: "gen_ai.output.messages",
+    SYSTEM_INSTRUCTIONS: "gen_ai.system_instructions",
+    TOOL_DEFINITIONS: "gen_ai.tool.definitions",
+    TOOL_NAME: "gen_ai.tool.name",
+    TOOL_CALL_ID: "gen_ai.tool.call.id",
+    TOOL_CALL_ARGUMENTS: "gen_ai.tool.call.arguments",
+    TOOL_CALL_RESULT: "gen_ai.tool.call.result",
+    DATA_SOURCE_ID: "gen_ai.data_source.id",
+    RETRIEVAL_QUERY_TEXT: "gen_ai.retrieval.query.text",
+    RETRIEVAL_DOCUMENTS: "gen_ai.retrieval.documents",
+    MESSAGE_INDEX: "gen_ai.message.index",
+};
+export const STRUCT = {
+    METADATA_PREFIX: "struct.metadata.",
+    AGENT_PARENT_SESSION_ID: "struct.agent.parent_session_id",
+    INPUT_MESSAGE_COUNT: "struct.input.message_count",
+};
+export const EVENT_NAME = "event.name";
+export const ERROR_TYPE = "error.type";
+export const EVENT_NAMES = {
+    USER_MESSAGE: "gen_ai.user.message",
+    ASSISTANT_MESSAGE: "gen_ai.assistant.message",
+    SYSTEM_MESSAGE: "gen_ai.system.message",
+    TOOL_MESSAGE: "gen_ai.tool.message",
+    CHOICE: "gen_ai.choice",
+};
+export const ROLE_TO_EVENT_NAME = {
+    user: EVENT_NAMES.USER_MESSAGE,
+    assistant: EVENT_NAMES.ASSISTANT_MESSAGE,
+    system: EVENT_NAMES.SYSTEM_MESSAGE,
+    tool: EVENT_NAMES.TOOL_MESSAGE,
+};
+export const ANTHROPIC_FINISH_REASON_MAP = {
+    end_turn: "stop",
+    stop_sequence: "stop",
+    max_tokens: "length",
+    tool_use: "tool_call",
+};
+export const LANGCHAIN_FINISH_REASON_MAP = {
+    end_turn: "stop",
+    stop_sequence: "stop",
+    max_tokens: "length",
+    tool_use: "tool_calls",
+    tool_calls: "tool_calls",
+    function_call: "tool_calls",
+};
+//# sourceMappingURL=semconv.js.map

package/dist/esm/truncation.d.ts

@@ -0,0 +1,10 @@
+export declare const MAX_CONTENT_SIZE: number;
+export declare const MAX_FIELD_SIZE = 16384;
+export declare const TRUNCATION_MARKER = "\u2026 [truncated]";
+export declare function truncateField<T>(value: T, maxLen?: number): T | string;
+type Part = Record<string, unknown>;
+export declare function truncateParts(parts: Part[]): Part[];
+export declare function truncateAndSerialize(obj: unknown, maxSize?: number): string;
+export declare function safeJsonStringify(obj: unknown): string;
+export {};
+//# sourceMappingURL=truncation.d.ts.map

package/dist/esm/truncation.js

@@ -0,0 +1,96 @@
+export const MAX_CONTENT_SIZE = 128 * 1024;
+export const MAX_FIELD_SIZE = 16384;
+export const TRUNCATION_MARKER = "… [truncated]";
+export function truncateField(value, maxLen = MAX_FIELD_SIZE) {
+    if (typeof value === "string" && value.length > maxLen) {
+        return value.slice(0, maxLen) + TRUNCATION_MARKER;
+    }
+    return value;
+}
+export function truncateParts(parts) {
+    const result = [];
+    for (const original of parts) {
+        const part = { ...original };
+        if (typeof part.content === "string") {
+            part.content = truncateField(part.content);
+        }
+        if ("arguments" in part) {
+            const arg = part.arguments;
+            if (typeof arg === "string") {
+                part.arguments = truncateField(arg);
+            }
+            else if (arg && typeof arg === "object") {
+                const serialized = safeJsonStringify(arg);
+                if (serialized.length > MAX_FIELD_SIZE) {
+                    part.arguments = serialized.slice(0, MAX_FIELD_SIZE) + TRUNCATION_MARKER;
+                }
+            }
+        }
+        if ("response" in part) {
+            const resp = part.response;
+            if (typeof resp === "string") {
+                part.response = truncateField(resp);
+            }
+            else if (resp && typeof resp === "object") {
+                const serialized = safeJsonStringify(resp);
+                if (serialized.length > MAX_FIELD_SIZE) {
+                    part.response = serialized.slice(0, MAX_FIELD_SIZE) + TRUNCATION_MARKER;
+                }
+            }
+        }
+        result.push(part);
+    }
+    return result;
+}
+export function truncateAndSerialize(obj, maxSize = MAX_CONTENT_SIZE) {
+    let result;
+    if (Array.isArray(obj)) {
+        const truncated = obj.map((item) => {
+            if (!item || typeof item !== "object")
+                return item;
+            const copy = { ...item };
+            if (Array.isArray(copy.parts)) {
+                copy.parts = truncateParts(copy.parts);
+            }
+            else if (typeof copy.content === "string") {
+                copy.content = truncateField(copy.content);
+            }
+            return copy;
+        });
+        result = safeJsonStringify(truncated);
+    }
+    else {
+        result = safeJsonStringify(obj);
+    }
+    if (result.length > maxSize) {
+        const cut = result.slice(0, maxSize - 50);
+        const lastBrace = cut.lastIndexOf("}");
+        if (lastBrace > 0) {
+            result = cut.slice(0, lastBrace + 1) + "]";
+        }
+        else {
+            result = "[]";
+        }
+    }
+    return result;
+}
+export function safeJsonStringify(obj) {
+    try {
+        return JSON.stringify(obj, defaultReplacer);
+    }
+    catch {
+        return JSON.stringify(String(obj));
+    }
+}
+function defaultReplacer(_key, value) {
+    if (typeof value === "bigint")
+        return value.toString();
+    if (value instanceof Error)
+        return `${value.name}: ${value.message}`;
+    if (value instanceof Map)
+        return Object.fromEntries(value.entries());
+    if (value instanceof Set)
+        return Array.from(value);
+    return value;
+}
+//# sourceMappingURL=truncation.js.map