@posthog/ai 8.16.1 → 8.16.2

package/dist/langchain/middleware/index.mjs

@@ -219,6 +219,10 @@ const redactor = new BinaryContentRedactor();
 const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
 const sanitizeLangChain = (data, client) => sanitize(data, client);
 //#endregion
+//#region src/privacyMode.ts
+/** Per-call settings can turn redaction on but never off. */
+const isPrivacyModeEnabled = (client, privacyMode = false) => privacyMode === true || client?.privacyMode === true || client?.privacy_mode === true || client?.options?.privacyMode === true;
+//#endregion
 //#region src/utils.ts
 const STRING_FORMAT = "utf8";
 new TextEncoder();
@@ -268,7 +272,6 @@ const getModelParams = (params, responseServiceTier) => {
 	if (responseServiceTier != null) modelParams.service_tier = responseServiceTier;
 	return modelParams;
 };
-const isPrivacyModeEnabled = (client, privacyMode) => Boolean(client.privacy_mode || privacyMode);
 const withPrivacyMode = (client, privacyMode, input) => {
 	return isPrivacyModeEnabled(client, privacyMode) ? null : input;
 };
@@ -281,12 +284,40 @@ function sanitizeValues(obj) {
 	return jsonSafe;
 }
 //#endregion
+//#region src/mcpCredentials.ts
+const MCP_CREDENTIAL_FIELDS = ["headers", "authorization"];
+const MCP_PROVIDER_TOOL_IDS = /* @__PURE__ */ new Set([
+	"openai.mcp",
+	"xai.mcp",
+	"google.mcp_server"
+]);
+const isMcpProviderTool = (tool) => (tool.type === "provider" || tool.type === "provider-defined") && typeof tool.id === "string" && MCP_PROVIDER_TOOL_IDS.has(tool.id);
+const withoutMcpCredentials = (config) => {
+	const redacted = { ...config };
+	for (const field of MCP_CREDENTIAL_FIELDS) if (field in redacted) redacted[field] = "[REDACTED]";
+	return redacted;
+};
+/** Hides the credentials of a remote MCP tool definition; everything else is kept as sent. */
+function redactMcpToolDefinition(tool) {
+	if (!isObject(tool)) return tool;
+	if (tool.type === "mcp") return withoutMcpCredentials(tool);
+	if (isMcpProviderTool(tool) && isObject(tool.args)) return {
+		...tool,
+		args: withoutMcpCredentials(tool.args)
+	};
+	return tool;
+}
+function redactMcpToolCredentials(tools) {
+	return Array.isArray(tools) ? tools.map(redactMcpToolDefinition) : tools;
+}
+//#endregion
 //#region package.json
-var version = "8.16.1";
+var version = "8.16.2";
 //#endregion
 //#region src/serializeError.ts
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
+const OMITTED_FIELD = "requestBodyValues";
 function serializeError(value, depth = DEFAULT_MAX_DEPTH) {
 	if (depth < 0 || value === null || typeof value !== "object") return value;
 	if (value instanceof Error) {
@@ -295,16 +326,17 @@ function serializeError(value, depth = DEFAULT_MAX_DEPTH) {
 			message: value.message,
 			stack: truncateStack(value.stack)
 		};
-		for (const key of Object.keys(value)) out[key] = serializeError(value[key], depth - 1);
+		for (const key of Object.keys(value)) if (key !== OMITTED_FIELD) out[key] = serializeError(Reflect.get(value, key), depth - 1);
 		if (value.cause !== void 0) out.cause = serializeError(value.cause, depth - 1);
 		return out;
 	}
 	if (Array.isArray(value)) return value.map((item) => serializeError(item, depth - 1));
 	return value;
 }
+const omitRequestBody = (key, value) => key === OMITTED_FIELD ? void 0 : value;
 function stringifyError(error) {
 	try {
-		return JSON.stringify(sanitizeValues(serializeError(error)));
+		return JSON.stringify(sanitizeValues(serializeError(error)), omitRequestBody);
 	} catch {
 		if (error instanceof Error) return JSON.stringify({
 			name: error.name,
@@ -313,6 +345,105 @@ function stringifyError(error) {
 		return JSON.stringify({ message: String(error) });
 	}
 }
+const CLASS_NAME = /^[A-Za-z_$][A-Za-z0-9_$.]{0,127}$/;
+const PROVIDER_CODE = /^[A-Za-z0-9_.:-]{1,64}$/;
+const PARAM = /^[A-Za-z0-9_.[\]-]{1,128}$/;
+const REQUEST_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+const MAX_CAUSES = 3;
+const readField = (value, key) => {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return;
+	try {
+		return Reflect.get(value, key);
+	} catch {
+		return;
+	}
+};
+const matching = (value, grammar) => typeof value === "string" && grammar.test(value) ? value : void 0;
+const firstMatching = (values, grammar) => {
+	for (const value of values) {
+		const match = matching(value, grammar);
+		if (match !== void 0) return match;
+	}
+};
+const className = (value) => {
+	if (!(value instanceof Error)) return "NonErrorThrown";
+	const name = readField(value, "name");
+	return firstMatching([
+		name === "Error" ? void 0 : name,
+		readField(readField(value, "constructor"), "name"),
+		name
+	], CLASS_NAME) ?? "Error";
+};
+const httpStatus = (error) => {
+	for (const key of ["status", "statusCode"]) {
+		const value = readField(error, key);
+		if (typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599) return value;
+	}
+};
+const unwrapEnvelope = (body) => {
+	const inner = readField(body, "error");
+	return inner !== null && typeof inner === "object" ? inner : body;
+};
+const parsedResponseBody = (error) => {
+	const responseBody = readField(error, "responseBody");
+	if (typeof responseBody !== "string") return;
+	try {
+		return unwrapEnvelope(JSON.parse(responseBody));
+	} catch {
+		return;
+	}
+};
+const causeNames = (error) => {
+	const names = [];
+	let cause = readField(error, "cause");
+	while (cause !== void 0 && cause !== null && names.length < MAX_CAUSES) {
+		names.push(className(cause));
+		cause = readField(cause, "cause");
+	}
+	return names;
+};
+const describeError = (error) => {
+	const sources = [
+		error,
+		unwrapEnvelope(readField(error, "error")),
+		parsedResponseBody(error)
+	];
+	const codes = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const key of [
+		"code",
+		"type",
+		"status"
+	]) {
+		const code = matching(readField(source, key), PROVIDER_CODE);
+		if (code !== void 0) codes.add(code);
+	}
+	const status = httpStatus(error);
+	const param = firstMatching(sources.map((source) => readField(source, "param")), PARAM);
+	const requestId = firstMatching([readField(error, "requestID"), readField(error, "request_id")], REQUEST_ID);
+	const causes = causeNames(error);
+	let summary = className(error);
+	if (status !== void 0) summary += `: ${status}`;
+	for (const code of codes) summary += ` ${code}`;
+	if (param !== void 0) summary += ` param=${param}`;
+	if (requestId !== void 0) summary += ` request_id=${requestId}`;
+	if (causes.length > 0) summary += ` (caused by ${causes.join(", ")})`;
+	return summary;
+};
+/**
+* Describes an error for `$ai_error` without its message, stack, or arbitrary fields, which
+* routinely echo the prompt. Only structured fields that pass a strict grammar are kept.
+* The format matches the Python SDK.
+*/
+function summarizeErrorForPrivacy(error) {
+	try {
+		return describeError(error);
+	} catch {
+		return error instanceof Error ? "Error" : "NonErrorThrown";
+	}
+}
+function formatAiError(error, privacyMode) {
+	return privacyMode ? summarizeErrorForPrivacy(error) : stringifyError(error);
+}
 function truncateStack(stack) {
 	if (!stack) return stack;
 	const lines = stack.split("\n");
@@ -563,6 +694,9 @@ var LangChainCallbackHandler = class extends BaseCallbackHandler {
 		if (parentRunId && !this.parentTree[parentRunId]) return traceId;
 		return parentRunId;
 	}
+	_isPrivacyModeEnabled() {
+		return isPrivacyModeEnabled(this.client, this.privacyMode);
+	}
 	_safeCapture(message) {
 		try {
 			captureAiEvent(this.client, message);
@@ -602,7 +736,7 @@ var LangChainCallbackHandler = class extends BaseCallbackHandler {
 				const interrupts = outputs.interrupts;
 				if (interrupts !== void 0) eventProperties["$ai_output_state"] = withPrivacyMode(this.client, this.privacyMode, sanitizeLangChain({ __interrupt__: interrupts }, this.client));
 			} else {
-				eventProperties["$ai_error"] = stringifyError(outputs);
+				eventProperties["$ai_error"] = formatAiError(outputs, this._isPrivacyModeEnabled());
 				eventProperties["$ai_is_error"] = true;
 			}
 		} else if (outputs !== void 0) eventProperties["$ai_output_state"] = withPrivacyMode(this.client, this.privacyMode, sanitizeLangChain(outputs, this.client));
@@ -651,10 +785,10 @@ var LangChainCallbackHandler = class extends BaseCallbackHandler {
 			...eventPropertiesServedTier
 		};
 		if (parentRunId) eventProperties["$ai_parent_id"] = parentRunId;
-		if (run.tools) eventProperties["$ai_tools"] = run.tools;
+		if (run.tools) eventProperties["$ai_tools"] = redactMcpToolCredentials(run.tools);
 		if (output instanceof Error) {
 			eventProperties["$ai_http_status"] = output.status || 500;
-			eventProperties["$ai_error"] = stringifyError(output);
+			eventProperties["$ai_error"] = formatAiError(output, this._isPrivacyModeEnabled());
 			eventProperties["$ai_is_error"] = true;
 		} else {
 			const [inputTokens, outputTokens, additionalTokenData] = this.parseUsage(output, run.provider, run.model);
@@ -949,7 +1083,11 @@ const stringify = (value) => {
 		}
 	}
 };
-const toError = (error) => error instanceof Error ? error : new Error(stringify(error));
+const toError = (error, privacyMode) => {
+	if (error instanceof Error) return error;
+	return privacyMode ? Object.assign(/* @__PURE__ */ new Error(), { name: "NonErrorThrown" }) : new Error(stringify(error));
+};
+const toolMessageError = (message, privacyMode) => new Error(privacyMode ? "Tool returned an error" : toContentString(message.content));
 const safely = (callback) => {
 	try {
 		callback();
@@ -1024,6 +1162,7 @@ const toLLMResult = (response) => {
 const createPostHogMiddleware = (options) => {
 	const { stateSchema, ...callbackOptions } = options;
 	const callback = new LangChainMiddlewareCallbackHandler(callbackOptions);
+	const privacyMode = () => isPrivacyModeEnabled(callbackOptions.client, callbackOptions.privacyMode);
 	const middlewareStateSchema = stateSchema ? extendInteropZodObject(stateSchema, postHogStateSchema.shape) : postHogStateSchema;
 	return createMiddleware({
 		name: "PostHogMiddleware",
@@ -1065,7 +1204,7 @@ const createPostHogMiddleware = (options) => {
 				safely(() => callback.handleLLMEnd(toLLMResult(response), runId, parentRunId));
 				return response;
 			} catch (error) {
-				safely(() => callback.handleLLMError(toError(error), runId));
+				safely(() => callback.handleLLMError(toError(error, privacyMode()), runId));
 				throw error;
 			}
 		},
@@ -1086,11 +1225,11 @@ const createPostHogMiddleware = (options) => {
 			safely(() => callback.handleToolStart(serializedTool, stringify(request.toolCall.args), runId, parentRunId, void 0, void 0, toolName));
 			try {
 				const result = await handler(request);
-				if (ToolMessage.isInstance(result) && result.status === "error") safely(() => callback.handleToolError(new Error(toContentString(result.content)), runId, parentRunId));
+				if (ToolMessage.isInstance(result) && result.status === "error") safely(() => callback.handleToolError(toolMessageError(result, privacyMode()), runId, parentRunId));
 				else safely(() => callback.handleToolEnd(result, runId, parentRunId));
 				return result;
 			} catch (error) {
-				safely(() => callback.handleToolError(toError(error), runId));
+				safely(() => callback.handleToolError(toError(error, privacyMode()), runId));
 				throw error;
 			}
 		}