@agenticrun/sdk 0.1.0-alpha.0

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { _ as TokenUsage, a as AgenticRunOptions, c as CreateTracingSessionOptions, d as CreateTraceOptions, f as StartSpanOptions, g as ModelCall, h as MessageContentBlock, i as AgenticRunConfigurationError, l as AgenticRunTrace, m as Attributes, n as LoadAgentRuntimeConfigurationOptions, o as createAgenticRunClient, p as TraceSpan, r as loadAgentRuntimeConfiguration, s as AgenticRunTracingSession, t as AgenticRunApiError, u as CompleteSpanOptions, v as TraceContent } from "./index-brUCQYsX.mjs";
+export { AgenticRunApiError, AgenticRunConfigurationError, type AgenticRunOptions, type AgenticRunTrace, type AgenticRunTracingSession, type Attributes, type CompleteSpanOptions, type CreateTraceOptions, type CreateTracingSessionOptions, type LoadAgentRuntimeConfigurationOptions, type MessageContentBlock, type ModelCall, type StartSpanOptions, type TokenUsage, type TraceContent, type TraceSpan, createAgenticRunClient, loadAgentRuntimeConfiguration };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { d as loadAgentRuntimeConfiguration, n as createAgenticRunClient, t as AgenticRunConfigurationError, u as AgenticRunApiError } from "./core-BxLvIHye.mjs";
+export { AgenticRunApiError, AgenticRunConfigurationError, createAgenticRunClient, loadAgentRuntimeConfiguration };

package/dist/langchain.d.mts

@@ -0,0 +1,17 @@
+import { a as AgenticRunOptions, c as CreateTracingSessionOptions, i as AgenticRunConfigurationError, s as AgenticRunTracingSession, t as AgenticRunApiError } from "./index-brUCQYsX.mjs";
+import { z } from "zod";
+import { RunnableConfig } from "@langchain/core/runnables";
+//#region src/integrations/langchain/createLangChainSession.d.ts
+type LangChainTracingSession = {
+  readonly id: string;
+  createInvocationConfig(): RunnableConfig;
+};
+//#endregion
+//#region src/integrations/langchain/createAgenticRun.d.ts
+export declare const createAgenticRun: (options?: AgenticRunOptions) => Promise<{
+  model: import("@langchain/core/language_models/chat_models").BaseChatModel<import("@langchain/core/language_models/chat_models").BaseChatModelCallOptions, import("langchain").AIMessageChunk<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>>;
+  middleware: import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[], readonly []>[];
+  createSession: (options?: Parameters<(options?: CreateTracingSessionOptions) => AgenticRunTracingSession>[0]) => LangChainTracingSession;
+}>;
+//#endregion
+export { AgenticRunApiError, AgenticRunConfigurationError, type AgenticRunOptions, type CreateTracingSessionOptions, type LangChainTracingSession };

package/dist/langchain.mjs

@@ -0,0 +1,466 @@
+import { a as safeJson, c as tokenUsageSchema, i as omittedContent, l as tracingLimits, n as createAgenticRunClient, o as validatedAttributes, r as isSensitiveAttributeKey, s as validatedContent, t as AgenticRunConfigurationError, u as AgenticRunApiError } from "./core-BxLvIHye.mjs";
+import { randomUUID } from "node:crypto";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatGoogle } from "@langchain/google/node";
+import { ChatOpenAI } from "@langchain/openai";
+import { AIMessage, BaseMessage, coerceMessageLikeToMessage } from "@langchain/core/messages";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { createMiddleware } from "langchain";
+//#region src/integrations/langchain/createLangChainModel.ts
+const createLangChainModel = ({ apiKey, model, provider }) => {
+	return {
+		anthropic: () => new ChatAnthropic({
+			apiKey,
+			model
+		}),
+		google: () => new ChatGoogle({
+			apiKey,
+			model
+		}),
+		openai: () => new ChatOpenAI({
+			apiKey,
+			model
+		}),
+		"openai-compatible": () => new ChatOpenAI({
+			apiKey,
+			model,
+			configuration: { baseURL: provider.baseUrl }
+		})
+	}[provider.adapter]();
+};
+//#endregion
+//#region src/integrations/langchain/tracing/langChainAttributes.ts
+const langChainAttributes = (metadata) => {
+	if (!metadata) return void 0;
+	const attributes = {};
+	for (const [key, value] of Object.entries(metadata)) {
+		if (isSensitiveAttributeKey(key) || key.startsWith("agenticrun.")) continue;
+		if (isAttributeValue(value)) attributes[`langchain.${key}`] = value;
+	}
+	return validatedAttributes(attributes);
+};
+const isAttributeValue = (value) => value === null || [
+	"string",
+	"number",
+	"boolean"
+].includes(typeof value) || Array.isArray(value) && value.length <= tracingLimits.attributeArrayEntries && value.every((item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean");
+//#endregion
+//#region src/integrations/langchain/tracing/langChainContent.ts
+const contentFromMessages = (messages) => {
+	const normalized = [];
+	for (const message of messages) {
+		const content = [];
+		if (typeof message.content === "string") content.push({
+			type: "text",
+			text: message.content
+		});
+		else for (const block of message.content) {
+			const normalizedBlock = normalizeContentBlock(block);
+			if (!normalizedBlock) return omittedContent(message.content, "unsupported");
+			content.push(normalizedBlock);
+		}
+		if (AIMessage.isInstance(message)) for (const toolCall of message.tool_calls ?? []) content.push({
+			type: "tool-call",
+			toolName: toolCall.name,
+			callId: toolCall.id ?? randomUUID(),
+			arguments: safeJson(toolCall.args)
+		});
+		const toolCallId = propertyString(message, "tool_call_id");
+		if (message.type === "tool" && toolCallId) {
+			normalized.push({
+				...message.id ? { id: message.id } : {},
+				role: "tool",
+				...message.name ? { name: message.name } : {},
+				content: [{
+					type: "tool-result",
+					callId: toolCallId,
+					result: safeJson(message.content)
+				}]
+			});
+			continue;
+		}
+		normalized.push({
+			...message.id ? { id: message.id } : {},
+			role: messageRole(message),
+			...message.name ? { name: message.name } : {},
+			content: content.length > 0 ? content : [{
+				type: "text",
+				text: ""
+			}]
+		});
+	}
+	return validatedContent({
+		type: "messages",
+		messages: normalized
+	});
+};
+const contentFromValue = (value) => {
+	const candidates = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.messages) ? value.messages : void 0;
+	if (candidates?.length && candidates.every((message) => BaseMessage.isInstance(message) || isRecord(message) && [
+		"user",
+		"assistant",
+		"system",
+		"developer",
+		"tool"
+	].includes(String(message.role)) && (typeof message.content === "string" || Array.isArray(message.content)))) try {
+		return contentFromMessages(candidates.map((message) => coerceMessageLikeToMessage(message)));
+	} catch {}
+	if (typeof value === "string") return validatedContent({
+		type: "text",
+		text: value
+	});
+	return validatedContent({
+		type: "json",
+		value: safeJson(value)
+	});
+};
+const contentFromToolCall = (toolName, callId, argumentsValue) => validatedContent({
+	type: "tool-call",
+	toolName,
+	callId,
+	arguments: safeJson(argumentsValue)
+});
+const contentFromToolResult = (callId, result) => validatedContent({
+	type: "tool-result",
+	callId,
+	result: safeJson(result)
+});
+const contentFromDocuments = (documents) => validatedContent({
+	type: "documents",
+	documents: documents.map((document) => ({
+		...document.id ? { id: document.id } : {},
+		content: document.pageContent,
+		attributes: langChainAttributes(document.metadata)
+	}))
+});
+const contentFromLlmResult = (output) => {
+	const messages = output.generations.flatMap((generations) => generations.flatMap((generation) => "message" in generation && BaseMessage.isInstance(generation.message) ? [generation.message] : []));
+	if (messages.length > 0) return contentFromMessages(messages);
+	return contentFromValue(output.generations.map((generations) => generations.map((generation) => generation.text)));
+};
+const normalizeContentBlock = (block) => {
+	if (!isRecord(block) || typeof block.type !== "string") return {
+		type: "json",
+		value: safeJson(block)
+	};
+	if (block.type === "text" && typeof block.text === "string") return {
+		type: "text",
+		text: block.text
+	};
+	if ((block.type === "tool-call" || block.type === "tool_call") && typeof block.name === "string") return {
+		type: "tool-call",
+		toolName: block.name,
+		callId: typeof block.id === "string" ? block.id : randomUUID(),
+		arguments: safeJson(block.args)
+	};
+	if (block.type === "reasoning" && typeof block.reasoning === "string") return {
+		type: "reasoning",
+		text: block.reasoning
+	};
+	if (block.type === "thinking" && typeof block.thinking === "string") return {
+		type: "reasoning",
+		text: block.thinking
+	};
+	if (/(image|audio|file)/i.test(block.type)) return void 0;
+	return {
+		type: "json",
+		value: safeJson(block)
+	};
+};
+const messageRole = (message) => {
+	if (message.type === "human") return "user";
+	if (message.type === "ai") return "assistant";
+	if (message.type === "tool") return "tool";
+	if (message.type === "system") return propertyString(message, "role") === "developer" ? "developer" : "system";
+	return "user";
+};
+const propertyString = (value, key) => {
+	const property = value[key];
+	return typeof property === "string" && property.length > 0 ? property : void 0;
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+//#endregion
+//#region src/integrations/langchain/tracing/langChainModelResult.ts
+const usageFromLlmResult = (output, provider) => {
+	const generations = output.generations.flat();
+	if (generations.length !== 1) return void 0;
+	const generation = generations[0];
+	if (!("message" in generation) || !AIMessage.isInstance(generation.message)) return void 0;
+	const usage = generation.message.usage_metadata;
+	if (!usage) return void 0;
+	const result = tokenUsageSchema.safeParse({
+		inputTokensTotal: usage.input_tokens,
+		inputTokensCacheRead: usage.input_token_details?.cache_read,
+		inputTokensCacheWrite: provider === "google" && usage.input_token_details?.cache_creation === void 0 ? 0 : usage.input_token_details?.cache_creation,
+		outputTokensTotal: usage.output_tokens,
+		outputTokensReasoning: usage.output_token_details?.reasoning
+	});
+	return result.success ? result.data : void 0;
+};
+const responseAttributesFromLlmResult = (output, provider) => {
+	const generation = output.generations[0]?.[0];
+	const metadata = (generation && "message" in generation && BaseMessage.isInstance(generation.message) ? generation.message : void 0)?.response_metadata;
+	const candidates = {
+		[`${provider}.response_model`]: metadata?.model_name ?? metadata?.model ?? metadata?.response_model,
+		[`${provider}.finish_reason`]: metadata?.finish_reason ?? metadata?.finishReason ?? metadata?.stop_reason ?? generation?.generationInfo?.finish_reason,
+		[`${provider}.request_id`]: metadata?.request_id ?? metadata?.id,
+		[`${provider}.system_fingerprint`]: metadata?.system_fingerprint
+	};
+	const attributes = Object.fromEntries(Object.entries(candidates).filter((entry) => [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof entry[1])));
+	return validatedAttributes(attributes);
+};
+const modelCallFromResult = (configured, output) => {
+	const generation = output.generations[0]?.[0];
+	const metadata = generation && "message" in generation && AIMessage.isInstance(generation.message) ? generation.message.response_metadata : {};
+	const responseModelId = metadata.model_name ?? metadata.model ?? metadata.response_model ?? output.llmOutput?.model;
+	return {
+		...configured,
+		...typeof responseModelId === "string" && responseModelId.trim().length > 0 && responseModelId.length <= 200 ? { responseModelId } : {}
+	};
+};
+//#endregion
+//#region src/integrations/langchain/tracing/langChainTracingCallback.ts
+var AgenticRunTracingCallback = class extends BaseCallbackHandler {
+	name = "AgenticRunTracingCallback";
+	model;
+	provider;
+	session;
+	runs = /* @__PURE__ */ new Map();
+	rootRunId;
+	trace;
+	constructor(options) {
+		super({
+			raiseError: false,
+			_awaitHandler: true
+		});
+		this.model = options.model;
+		this.provider = options.provider;
+		this.session = options.session;
+	}
+	async handleChainStart(_chain, inputs, runId, _runType, tags, metadata, runName, parentRunId) {
+		if (this.trace?.completed) return;
+		const rootSpan = {
+			sourceSpanId: runId,
+			name: runName ?? "agent",
+			spanType: "agent",
+			input: contentFromValue(inputs),
+			attributes: langChainAttributes(metadata),
+			tags
+		};
+		if (!this.trace) {
+			this.rootRunId = runId;
+			this.trace = this.session.createTrace({
+				sourceTraceId: runId,
+				attributes: compactAttributes({
+					"langchain.run_name": runName,
+					[`${this.provider}.provider`]: this.provider,
+					[`${this.provider}.request_model`]: this.model
+				}),
+				rootSpan
+			});
+			this.runs.set(runId, { span: this.trace.rootSpan });
+			await this.trace.started;
+		} else this.startSpan({
+			runId,
+			parentRunId,
+			...rootSpan,
+			name: runName ?? "workflow",
+			spanType: "workflow"
+		});
+	}
+	async handleChainEnd(outputs, runId) {
+		this.completeSpan(runId, {
+			status: "success",
+			output: contentFromValue(outputs)
+		});
+		if (runId === this.rootRunId) await this.trace?.complete("success");
+	}
+	async handleChainError(error, runId) {
+		this.completeSpan(runId, errorResult(error));
+		if (runId === this.rootRunId) await this.trace?.complete(isAbortError(error) ? "cancelled" : "error");
+	}
+	handleChatModelStart(_model, messages, runId, parentRunId, _extraParams, tags, metadata, runName) {
+		this.startSpan({
+			runId,
+			parentRunId,
+			name: runName ?? this.model,
+			spanType: "model",
+			input: contentFromMessages(messages.flat()),
+			attributes: compactAttributes({
+				...langChainAttributes(metadata),
+				[`${this.provider}.request_model`]: this.model
+			}),
+			tags
+		});
+	}
+	handleLLMStart(_model, prompts, runId, parentRunId, _extraParams, tags, metadata, runName) {
+		this.startSpan({
+			runId,
+			parentRunId,
+			name: runName ?? this.model,
+			spanType: "model",
+			input: contentFromValue(prompts),
+			attributes: compactAttributes({
+				...langChainAttributes(metadata),
+				[`${this.provider}.request_model`]: this.model
+			}),
+			tags
+		});
+	}
+	handleLLMNewToken(_token, _indices, runId) {
+		this.runs.get(runId)?.span.markFirstToken();
+	}
+	handleLLMEnd(output, runId) {
+		this.completeSpan(runId, {
+			status: "success",
+			output: contentFromLlmResult(output)
+		}, {
+			usage: usageFromLlmResult(output, this.provider),
+			responseModelId: modelCallFromResult({
+				providerId: this.provider,
+				modelId: this.model
+			}, output).responseModelId,
+			attributes: responseAttributesFromLlmResult(output, this.provider)
+		});
+	}
+	handleLLMError(error, runId) {
+		this.completeSpan(runId, errorResult(error));
+	}
+	handleToolStart(tool, input, runId, parentRunId, tags, metadata, runName, toolCallId) {
+		const name = runName ?? serializedName(tool) ?? "tool";
+		this.startSpan({
+			runId,
+			parentRunId,
+			name,
+			spanType: "tool",
+			input: contentFromToolCall(name, toolCallId ?? runId, parseToolInput(input)),
+			attributes: langChainAttributes(metadata),
+			tags,
+			toolCallId: toolCallId ?? runId
+		});
+	}
+	handleToolEnd(output, runId) {
+		const run = this.runs.get(runId);
+		this.completeSpan(runId, {
+			status: "success",
+			output: contentFromToolResult(run?.toolCallId ?? runId, output)
+		});
+	}
+	handleToolError(error, runId) {
+		this.completeSpan(runId, errorResult(error));
+	}
+	handleRetrieverStart(_retriever, query, runId, parentRunId, tags, metadata, name) {
+		this.startSpan({
+			runId,
+			parentRunId,
+			name: name ?? "retriever",
+			spanType: "retrieval",
+			input: contentFromValue(query),
+			attributes: langChainAttributes(metadata),
+			tags
+		});
+	}
+	handleRetrieverEnd(documents, runId) {
+		this.completeSpan(runId, {
+			status: "success",
+			output: contentFromDocuments(documents)
+		});
+	}
+	handleRetrieverError(error, runId) {
+		this.completeSpan(runId, errorResult(error));
+	}
+	startSpan(input) {
+		if (!this.trace || this.runs.has(input.runId)) return;
+		const span = this.trace.startSpan({
+			sourceSpanId: input.runId,
+			parentSpanId: input.parentRunId ? this.runs.get(input.parentRunId)?.span.id : void 0,
+			name: input.name,
+			spanType: input.spanType,
+			input: input.input,
+			attributes: input.attributes,
+			tags: input.tags
+		});
+		if (span) this.runs.set(input.runId, {
+			span,
+			toolCallId: input.toolCallId
+		});
+	}
+	completeSpan(runId, result, details = {}) {
+		this.runs.get(runId)?.span.complete(result, details);
+	}
+};
+const errorResult = (error) => {
+	const normalized = error instanceof Error ? error : new Error(String(error));
+	return {
+		status: isAbortError(error) ? "cancelled" : "error",
+		error: {
+			type: (normalized.name || "Error").slice(0, 200),
+			message: normalized.message.slice(0, 32768)
+		}
+	};
+};
+const isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+const parseToolInput = (input) => {
+	try {
+		return safeJson(JSON.parse(input));
+	} catch {
+		return input;
+	}
+};
+const serializedName = (value) => {
+	if (!value || typeof value !== "object") return void 0;
+	const record = value;
+	if (typeof record.name === "string") return record.name;
+	if (Array.isArray(record.id)) {
+		const name = record.id.at(-1);
+		return typeof name === "string" ? name : void 0;
+	}
+};
+const compactAttributes = (attributes) => {
+	return validatedAttributes(Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== void 0)));
+};
+//#endregion
+//#region src/integrations/langchain/createLangChainSession.ts
+const createLangChainSession = (session, model) => ({
+	get id() {
+		return session.id;
+	},
+	createInvocationConfig() {
+		return { callbacks: [new AgenticRunTracingCallback({
+			...model,
+			session
+		})] };
+	}
+});
+//#endregion
+//#region src/integrations/langchain/createAgenticRun.ts
+const createAgenticRun = async (options = {}) => {
+	const client = await createAgenticRunClient(options);
+	const { configuration, provider } = client;
+	const middleware = createMiddleware({
+		name: "AgenticRun",
+		afterModel: (state) => {
+			const lastMessage = state.messages.at(-1);
+			const tokensUsed = lastMessage && AIMessage.isInstance(lastMessage) ? lastMessage.usage_metadata?.total_tokens ?? 0 : 0;
+			console.log("[Agentic Run] afterModel", { tokensUsed });
+		}
+	});
+	return {
+		model: createLangChainModel({
+			apiKey: configuration.credential.apiKey,
+			model: configuration.modelId,
+			provider
+		}),
+		middleware: [middleware],
+		createSession: (options) => createLangChainSession(client.createSession(options), {
+			model: configuration.modelId,
+			provider: configuration.provider
+		})
+	};
+};
+//#endregion
+export { AgenticRunApiError, AgenticRunConfigurationError, createAgenticRun };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@agenticrun/sdk",
+  "version": "0.1.0-alpha.0",
+  "description": "Agenticrun client and LangChain integration for managed agent configuration and tracing",
+  "license": "UNLICENSED",
+  "type": "module",
+  "engines": {
+    "node": ">=24.12.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./langchain": {
+      "types": "./dist/langchain.d.mts",
+      "import": "./dist/langchain.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "dependencies": {
+    "@langchain/anthropic": "^1.0.0",
+    "@langchain/core": "^1.0.0",
+    "@langchain/google": "^0.2.0",
+    "@langchain/openai": "^1.0.0",
+    "langchain": "^1.0.0",
+    "zod": "^4.5.4"
+  }
+}