@agenticrun/sdk 0.1.0-alpha.0 → 0.1.0-alpha.1

package/README.md

@@ -1,7 +1,7 @@
 # @agenticrun/sdk
 
-Agenticrun SDK for trusted Node.js applications (Node.js 24.12 or newer, ESM).
-The SDK loads managed agent configuration and credentials from Agenticrun and
+Agentic Run SDK for trusted Node.js applications (Node.js 24.12 or newer, ESM).
+The SDK loads managed agent configuration and credentials from Agentic Run and
 sends session traces to the backend. Never use it in a browser or expose the
 Agent API key or returned provider credential to end users.
 
@@ -16,14 +16,32 @@ Set `AGENTICRUN_AGENT_API_KEY` to your Agent API key. Optionally set
 
 ```ts
 import { createAgenticRun } from '@agenticrun/sdk/langchain'
-import { createAgent } from 'langchain'
 
-const { model, middleware, createSession } = await createAgenticRun()
-const agent = createAgent({ model, middleware })
-const session = createSession()
-const result = await agent.invoke({ messages: [{ role: 'user', content: 'Hello!' }] }, session.createInvocationConfig())
+const agenticrun = await createAgenticRun({
+  modelOptions: { google: { thinkingBudget: 2_048 } }
+})
+const agent = agenticrun.createAgent({ tools, checkpointer })
+const session = agenticrun.createSession({ id: 'conversation-1' })
+const result = await agent.invoke({ messages: [{ role: 'user', content: 'Hello!' }] }, session)
 ```
 
+`createAgenticRun()` loads model configuration and credentials once. Existing
+instances retain that configuration; dashboard changes apply after creating a
+new instance. `createAgent()` supplies the managed model and binds tracing to
+the returned native LangChain agent. For a custom compiled LangGraph, use
+`agenticrun.bind(compiledGraph)` once. Native invocation options and user
+callbacks remain available.
+
+`createSession()` only returns a reusable native configuration containing
+`configurable.thread_id`; the checkpointer remains responsible for conversation
+memory. The backend associates sessions by tenant, agent and thread ID. Each
+outer invocation creates a separate trace. `modelInfo` exposes the credential-free
+provider, model ID, label and configuration version loaded by this instance.
+Expected LangGraph interrupts complete the current trace as waiting for input;
+resuming the same thread creates a new trace in the same session. Repeated
+bindings from the same instance are idempotent, while binding an already bound
+runnable to another Agentic Run instance is rejected.
+
 ## Framework-independent core
 
 ```ts
@@ -39,7 +57,7 @@ await trace.complete('success')
 
 The root entrypoint does not load LangChain. Both entrypoints belong to the same
 package. Provider and LangChain libraries remain runtime dependencies; shared
-Agenticrun code and TypeScript declarations are included in the release.
+Agentic Run code and TypeScript declarations are included in the release.
 
 Tracing delivery is timeout-bounded and does not reject the agent result when
 delivery fails. Heartbeats and recovery of abandoned traces are not implemented.

package/dist/{core-BxLvIHye.mjs → core-BQOuQ_C7.mjs}

@@ -738,6 +738,7 @@ const traceCompletedEventSchema = z.strictObject({
 	type: z.literal("trace.completed"),
 	id: z.uuid(),
 	status: z.enum([
+		"waiting_for_input",
 		"success",
 		"error",
 		"cancelled"
@@ -1038,7 +1039,7 @@ const createTrace = (context, options) => {
 		const spanId = randomUUID();
 		let spanCompleted = false;
 		let firstTokenAt;
-		const model = input.spanType === "model" ? { ...context.model } : void 0;
+		const model = input.spanType === "model" && input.model !== false ? { ...input.model ?? context.model } : void 0;
 		const tags = input.tags?.map((tag) => tag.trim().slice(0, 100)).filter(Boolean).slice(0, 50);
 		events.push({
 			type: "span.started",
@@ -1108,6 +1109,13 @@ const createTrace = (context, options) => {
 const now = () => (/* @__PURE__ */ new Date()).toISOString();
 //#endregion
 //#region src/core/tracing/createTracingSession.ts
+const validateExternalSessionId = (id) => {
+	tracingSessionResolutionSchema.parse({
+		id: randomUUID(),
+		externalSessionId: id
+	});
+	return id;
+};
 const createTracingSessionFactory = (context) => (options = {}) => {
 	const sensitiveAttribute = Object.keys(options.attributes ?? {}).find(isSensitiveAttributeKey);
 	if (sensitiveAttribute) throw new TypeError(`Agentic Run tracing attribute "${sensitiveAttribute}" may contain sensitive data.`);
@@ -1255,4 +1263,4 @@ const createAgenticRunClient = async (options = {}) => {
 	};
 };
 //#endregion
-export { safeJson as a, tokenUsageSchema as c, loadAgentRuntimeConfiguration as d, omittedContent as i, tracingLimits as l, createAgenticRunClient as n, validatedAttributes as o, isSensitiveAttributeKey as r, validatedContent as s, AgenticRunConfigurationError as t, AgenticRunApiError as u };
+export { omittedContent as a, validatedContent as c, AgenticRunApiError as d, loadAgentRuntimeConfiguration as f, isSensitiveAttributeKey as i, tokenUsageSchema as l, createAgenticRunClient as n, safeJson as o, validateExternalSessionId as r, validatedAttributes as s, AgenticRunConfigurationError as t, tracingLimits as u };

package/dist/{index-brUCQYsX.d.mts → index-BpX7kWI_.d.mts}

@@ -99,6 +99,7 @@ declare const traceCompletedEventSchema: z.ZodReadonly<z.ZodObject<{
   type: z.ZodLiteral<"trace.completed">;
   id: z.ZodUUID;
   status: z.ZodEnum<{
+    waiting_for_input: "waiting_for_input";
     error: "error";
     success: "success";
     cancelled: "cancelled";
@@ -451,6 +452,7 @@ type SpanCompletedEvent = z.infer<typeof spanCompletedEventSchema>;
 //#region src/core/tracing/createTrace.d.ts
 type StartSpanOptions = Pick<SpanStartedEvent, 'name' | 'spanType' | 'input' | 'attributes' | 'tags' | 'sourceSpanId'> & {
   readonly parentSpanId?: string;
+  readonly model?: ModelCall | false;
 };
 type CompleteSpanOptions = Pick<SpanCompletedEvent, 'attributes' | 'usage'> & {
   readonly responseModelId?: string;

package/dist/index.d.mts

@@ -1,2 +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";
+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-BpX7kWI_.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

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

package/dist/langchain.d.mts

@@ -1,17 +1,99 @@
-import { a as AgenticRunOptions, c as CreateTracingSessionOptions, i as AgenticRunConfigurationError, s as AgenticRunTracingSession, t as AgenticRunApiError } from "./index-brUCQYsX.mjs";
+import { a as AgenticRunOptions, c as CreateTracingSessionOptions, i as AgenticRunConfigurationError, t as AgenticRunApiError } from "./index-BpX7kWI_.mjs";
 import { z } from "zod";
 import { RunnableConfig } from "@langchain/core/runnables";
-//#region src/integrations/langchain/createLangChainSession.d.ts
-type LangChainTracingSession = {
+import { ChatAnthropicInput } from "@langchain/anthropic";
+import { ChatGoogleParams } from "@langchain/google/node";
+import { ChatOpenAIFields } from "@langchain/openai";
+import { CreateAgentParams, createAgent } from "langchain";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+//#region ../modules/src/credentials/providers.contract.d.ts
+declare const providerModelPricingSchema: z.ZodReadonly<z.ZodObject<{
+  currency: z.ZodString;
+  unit: z.ZodLiteral<"million_tokens">;
+  rates: z.ZodReadonly<z.ZodObject<{
+    input: z.ZodNullable<z.ZodString>;
+    cacheRead: z.ZodNullable<z.ZodString>;
+    cacheWrite: z.ZodNullable<z.ZodString>;
+    output: z.ZodNullable<z.ZodString>;
+    reasoning: z.ZodNullable<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>>;
+type ProviderModelPricing = z.infer<typeof providerModelPricingSchema>;
+type ProviderAdapter = 'openai' | 'openai-compatible' | 'anthropic' | 'google';
+type ProviderModelDefinition = {
+  readonly id: string;
+  readonly name: string;
+  readonly active: boolean;
+  readonly pricing: ProviderModelPricing;
+};
+type ProviderDefinitionBase = {
   readonly id: string;
-  createInvocationConfig(): RunnableConfig;
+  readonly name: string;
+  readonly active: boolean;
+  readonly keyHintLength?: number;
+  readonly models: readonly ProviderModelDefinition[];
+};
+type NativeProviderDefinition = {
+  readonly adapter: Exclude<ProviderAdapter, 'openai-compatible'>;
+  readonly baseUrl?: never;
 };
+type OpenAICompatibleProviderDefinition = {
+  readonly adapter: 'openai-compatible';
+  readonly baseUrl: string;
+};
+type ProviderDefinition = ProviderDefinitionBase & (NativeProviderDefinition | OpenAICompatibleProviderDefinition);
 //#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;
+//#region src/integrations/langchain/createLangChainModel.d.ts
+type ManagedAnthropicOptions = Omit<ChatAnthropicInput, 'apiKey' | 'clientOptions' | 'createClient' | 'model' | 'modelName'>;
+type ManagedGoogleOptions = Omit<ChatGoogleParams, 'apiKey' | 'baseUrl' | 'model' | 'modelName'>;
+type ManagedOpenAIOptions = Omit<ChatOpenAIFields, 'apiKey' | 'configuration' | 'model' | 'modelName'>;
+type ManagedOpenAICompatibleOptions = ManagedOpenAIOptions;
+type ManagedModelOptions = {
+  readonly anthropic?: ManagedAnthropicOptions;
+  readonly google?: ManagedGoogleOptions;
+  readonly openai?: ManagedOpenAIOptions;
+  readonly 'openai-compatible'?: ManagedOpenAICompatibleOptions;
+};
+declare const createLangChainModel: ({ apiKey, model, provider, modelOptions }: {
+  readonly apiKey: string;
+  readonly model: string;
+  readonly provider: ProviderDefinition;
+  readonly modelOptions?: ManagedModelOptions;
+}) => BaseChatModel;
+//#endregion
+//#region src/integrations/langchain/createLangChainSession.d.ts
+type LangChainSession = RunnableConfig<{
+  readonly thread_id: string;
 }>;
+declare const createLangChainSession: (options?: {
+  readonly id?: string;
+}) => LangChainSession;
+//#endregion
+//#region src/integrations/langchain/createAgenticRun.d.ts
+type LangChainAgenticRunOptions = AgenticRunOptions & {
+  readonly modelOptions?: {
+    readonly anthropic?: ManagedAnthropicOptions;
+    readonly google?: ManagedGoogleOptions;
+    readonly openai?: ManagedOpenAIOptions;
+    readonly 'openai-compatible'?: ManagedOpenAICompatibleOptions;
+  };
+};
+type ManagedCreateAgentParams = Omit<CreateAgentParams, 'model'> & {
+  readonly model?: never;
+};
+type AgenticRunModelInfo = {
+  readonly provider: string;
+  readonly modelId: string;
+  readonly label: string;
+  readonly configurationVersion: number;
+};
+type LangChainAgenticRun = {
+  readonly model: ReturnType<typeof createLangChainModel>;
+  readonly modelInfo: AgenticRunModelInfo;
+  readonly createAgent: (params: ManagedCreateAgentParams) => ReturnType<typeof createAgent>;
+  readonly bind: <T extends object>(runnable: T) => T;
+  readonly createSession: typeof createLangChainSession;
+};
+export declare const createAgenticRun: (options?: LangChainAgenticRunOptions) => Promise<LangChainAgenticRun>;
 //#endregion
-export { AgenticRunApiError, AgenticRunConfigurationError, type AgenticRunOptions, type CreateTracingSessionOptions, type LangChainTracingSession };
+export { AgenticRunApiError, AgenticRunConfigurationError, type AgenticRunModelInfo, type AgenticRunOptions, type CreateTracingSessionOptions, type LangChainAgenticRun, type LangChainAgenticRunOptions, type LangChainSession, type ManagedAnthropicOptions, type ManagedGoogleOptions, type ManagedOpenAICompatibleOptions, type ManagedOpenAIOptions };

package/dist/langchain.mjs

@@ -1,34 +1,12 @@
-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 { a as omittedContent, c as validatedContent, d as AgenticRunApiError, i as isSensitiveAttributeKey, l as tokenUsageSchema, n as createAgenticRunClient, o as safeJson, r as validateExternalSessionId, s as validatedAttributes, t as AgenticRunConfigurationError, u as tracingLimits } from "./core-BQOuQ_C7.mjs";
 import { randomUUID } from "node:crypto";
+import { AIMessage, BaseMessage, coerceMessageLikeToMessage } from "@langchain/core/messages";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { ensureConfig, mergeConfigs } from "@langchain/core/runnables";
 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
+import { createAgent } from "langchain";
 //#region src/integrations/langchain/tracing/langChainAttributes.ts
 const langChainAttributes = (metadata) => {
 	if (!metadata) return void 0;
@@ -226,6 +204,7 @@ const modelCallFromResult = (configured, output) => {
 //#region src/integrations/langchain/tracing/langChainTracingCallback.ts
 var AgenticRunTracingCallback = class extends BaseCallbackHandler {
 	name = "AgenticRunTracingCallback";
+	ownerId;
 	model;
 	provider;
 	session;
@@ -237,6 +216,7 @@ var AgenticRunTracingCallback = class extends BaseCallbackHandler {
 			raiseError: false,
 			_awaitHandler: true
 		});
+		this.ownerId = options.ownerId;
 		this.model = options.model;
 		this.provider = options.provider;
 		this.session = options.session;
@@ -277,18 +257,19 @@ var AgenticRunTracingCallback = class extends BaseCallbackHandler {
 			status: "success",
 			output: contentFromValue(outputs)
 		});
-		if (runId === this.rootRunId) await this.trace?.complete("success");
+		if (runId === this.rootRunId) await this.trace?.complete(hasInterrupt(outputs) ? "waiting_for_input" : "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) {
+	handleChatModelStart(serializedModel, messages, runId, parentRunId, _extraParams, tags, metadata, runName) {
 		this.startSpan({
 			runId,
 			parentRunId,
 			name: runName ?? this.model,
 			spanType: "model",
+			model: managedModel(serializedModel, this.model, this.provider),
 			input: contentFromMessages(messages.flat()),
 			attributes: compactAttributes({
 				...langChainAttributes(metadata),
@@ -297,12 +278,13 @@ var AgenticRunTracingCallback = class extends BaseCallbackHandler {
 			tags
 		});
 	}
-	handleLLMStart(_model, prompts, runId, parentRunId, _extraParams, tags, metadata, runName) {
+	handleLLMStart(serializedModel, prompts, runId, parentRunId, _extraParams, tags, metadata, runName) {
 		this.startSpan({
 			runId,
 			parentRunId,
 			name: runName ?? this.model,
 			spanType: "model",
+			model: managedModel(serializedModel, this.model, this.provider),
 			input: contentFromValue(prompts),
 			attributes: compactAttributes({
 				...langChainAttributes(metadata),
@@ -380,6 +362,7 @@ var AgenticRunTracingCallback = class extends BaseCallbackHandler {
 			parentSpanId: input.parentRunId ? this.runs.get(input.parentRunId)?.span.id : void 0,
 			name: input.name,
 			spanType: input.spanType,
+			model: input.model,
 			input: input.input,
 			attributes: input.attributes,
 			tags: input.tags
@@ -393,6 +376,25 @@ var AgenticRunTracingCallback = class extends BaseCallbackHandler {
 		this.runs.get(runId)?.span.complete(result, details);
 	}
 };
+const managedModel = (serialized, model, provider) => {
+	const value = safeJson(serialized);
+	if (JSON.stringify(value).includes(model)) return {
+		providerId: provider,
+		modelId: model
+	};
+	return findDeclaredModel(value) === void 0 ? {
+		providerId: provider,
+		modelId: model
+	} : false;
+};
+const findDeclaredModel = (value) => {
+	if (!value || typeof value !== "object") return void 0;
+	for (const [key, candidate] of Object.entries(value)) {
+		if ((key === "model" || key === "modelName" || key === "model_name") && typeof candidate === "string") return candidate;
+		const nested = findDeclaredModel(candidate);
+		if (nested !== void 0) return nested;
+	}
+};
 const errorResult = (error) => {
 	const normalized = error instanceof Error ? error : new Error(String(error));
 	return {
@@ -404,6 +406,7 @@ const errorResult = (error) => {
 	};
 };
 const isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+const hasInterrupt = (outputs) => Array.isArray(outputs.__interrupt__) && outputs.__interrupt__.length > 0;
 const parseToolInput = (input) => {
 	try {
 		return safeJson(JSON.parse(input));
@@ -424,42 +427,136 @@ const compactAttributes = (attributes) => {
 	return validatedAttributes(Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== void 0)));
 };
 //#endregion
+//#region src/integrations/langchain/bindTracing.ts
+const binding = Symbol("AgenticRunBinding");
+const bindTracing = (runnable, owner) => {
+	if (typeof Reflect.get(runnable, "invoke") !== "function") throw new TypeError("Agentic Run can only bind LangChain runnables with an invoke() method.");
+	const existing = Reflect.get(runnable, binding);
+	if (existing?.id === owner.id) return runnable;
+	if (existing) throw new TypeError("This LangChain runnable is already bound to another Agentic Run instance.");
+	return new Proxy(runnable, { get(target, property) {
+		if (property === binding) return owner;
+		if (property === "invoke" || property === "stream" || property === "streamEvents") return (input, options) => Reflect.apply(Reflect.get(target, property), target, [input, tracedConfig(options, owner)]);
+		if (property === "batch") return (inputs, options, batchOptions) => {
+			const configurations = Array.isArray(options) ? options.map((option) => tracedConfig(option, owner)) : inputs.map(() => tracedConfig(options, owner));
+			return Reflect.apply(Reflect.get(target, property), target, [
+				inputs,
+				configurations,
+				batchOptions
+			]);
+		};
+		if (property === "withConfig") return (config) => bindTracing(Reflect.apply(Reflect.get(target, property), target, [config]), owner);
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+};
+const tracedConfig = (options, owner) => {
+	const config = ensureConfig(options);
+	if (hasOwnerCallback(config, owner.id)) return config;
+	const externalSessionId = readThreadId(config);
+	const session = owner.createSession(externalSessionId);
+	return mergeConfigs(config, { callbacks: [new AgenticRunTracingCallback({
+		ownerId: owner.id,
+		model: owner.model,
+		provider: owner.provider,
+		session
+	})] });
+};
+const readThreadId = (config) => {
+	const value = config.configurable?.thread_id;
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new TypeError("LangChain configurable.thread_id must be a string.");
+	return value;
+};
+const hasOwnerCallback = (config, ownerId) => {
+	const callbacks = config.callbacks;
+	return (Array.isArray(callbacks) ? callbacks : callbacks?.handlers)?.some((handler) => handler instanceof AgenticRunTracingCallback && handler.ownerId === ownerId) ?? false;
+};
+//#endregion
+//#region src/integrations/langchain/createLangChainModel.ts
+const createLangChainModel = ({ apiKey, model, provider, modelOptions = {} }) => {
+	const selected = modelOptions[provider.adapter] ?? {};
+	assertManagedFields(selected);
+	return {
+		anthropic: () => new ChatAnthropic({
+			...selected,
+			apiKey,
+			model
+		}),
+		google: () => new ChatGoogle({
+			...selected,
+			apiKey,
+			model
+		}),
+		openai: () => new ChatOpenAI({
+			...selected,
+			apiKey,
+			model
+		}),
+		"openai-compatible": () => new ChatOpenAI({
+			...selected,
+			apiKey,
+			model,
+			configuration: { baseURL: provider.baseUrl }
+		})
+	}[provider.adapter]();
+};
+const managedFields = [
+	"apiKey",
+	"baseUrl",
+	"baseURL",
+	"clientOptions",
+	"configuration",
+	"createClient",
+	"model",
+	"modelName"
+];
+const assertManagedFields = (options) => {
+	const field = managedFields.find((key) => Object.hasOwn(options, key));
+	if (field) throw new TypeError(`Agentic Run model option "${field}" is managed and cannot be overridden.`);
+};
+//#endregion
 //#region src/integrations/langchain/createLangChainSession.ts
-const createLangChainSession = (session, model) => ({
-	get id() {
-		return session.id;
-	},
-	createInvocationConfig() {
-		return { callbacks: [new AgenticRunTracingCallback({
-			...model,
-			session
-		})] };
-	}
-});
+const createLangChainSession = (options = {}) => {
+	const threadId = options.id ?? randomUUID();
+	if (threadId !== threadId.trim()) throw new TypeError("Agentic Run session IDs cannot start or end with whitespace.");
+	validateExternalSessionId(threadId);
+	return { configurable: { thread_id: threadId } };
+};
 //#endregion
 //#region src/integrations/langchain/createAgenticRun.ts
 const createAgenticRun = async (options = {}) => {
-	const client = await createAgenticRunClient(options);
+	const { modelOptions, ...clientOptions } = options;
+	const client = await createAgenticRunClient(clientOptions);
 	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 });
-		}
+	const configuredModel = provider.models.find((candidate) => candidate.id === configuration.modelId);
+	const model = createLangChainModel({
+		apiKey: configuration.credential.apiKey,
+		model: configuration.modelId,
+		provider,
+		modelOptions
 	});
+	const owner = {
+		id: Symbol("AgenticRunInstance"),
+		model: configuration.modelId,
+		provider: configuration.provider,
+		createSession: (externalSessionId) => client.createSession(externalSessionId === void 0 ? void 0 : { externalSessionId })
+	};
+	const bind = (runnable) => bindTracing(runnable, owner);
 	return {
-		model: createLangChainModel({
-			apiKey: configuration.credential.apiKey,
-			model: configuration.modelId,
-			provider
+		model,
+		modelInfo: Object.freeze({
+			provider: configuration.provider,
+			modelId: configuration.modelId,
+			label: configuredModel.name,
+			configurationVersion: configuration.agentConfigurationVersion
 		}),
-		middleware: [middleware],
-		createSession: (options) => createLangChainSession(client.createSession(options), {
-			model: configuration.modelId,
-			provider: configuration.provider
-		})
+		createAgent: (params) => bind(createAgent({
+			...params,
+			model
+		})),
+		bind,
+		createSession: createLangChainSession
 	};
 };
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agenticrun/sdk",
-  "version": "0.1.0-alpha.0",
-  "description": "Agenticrun client and LangChain integration for managed agent configuration and tracing",
+  "version": "0.1.0-alpha.1",
+  "description": "Agentic Run client and LangChain integration for managed agent configuration and tracing",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
@@ -26,9 +26,9 @@
     "tag": "alpha"
   },
   "dependencies": {
-    "@langchain/anthropic": "^1.0.0",
+    "@langchain/anthropic": "^1.5.10",
     "@langchain/core": "^1.0.0",
-    "@langchain/google": "^0.2.0",
+    "@langchain/google": "^0.2.4",
     "@langchain/openai": "^1.0.0",
     "langchain": "^1.0.0",
     "zod": "^4.5.4"