@baseline-labs/adapter-langchain 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Baseline Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# `@baseline-labs/adapter-langchain`
+
+Authority-aware LangChain tool integration for Baseline.
+
+This package wraps familiar LangChain-style tool flows while Baseline governs what is allowed to execute or commit.
+
+Use it to:
+
+- create a Baseline-native LangChain integration surface
+- wrap tools once with authority metadata
+- preserve managed authority continuity across chained steps

package/dist/buildExecuteRequest.d.ts

@@ -0,0 +1,21 @@
+import type { ExecuteRequest, ToolAuthoritySpec } from "@baseline-labs/types";
+export interface BuildLangChainExecuteRequestOptions {
+    agentId: string;
+    sessionId?: string;
+    environmentName?: string;
+    goal?: string;
+    source?: string;
+    toolAuthority?: ToolAuthoritySpec;
+    traceParent?: string;
+    runId?: string;
+    authorityToken?: string;
+    stepIndex?: number;
+    priorActions?: NonNullable<ExecuteRequest["state"]>["priorActions"];
+    tags?: string[];
+    context?: Record<string, unknown>;
+}
+export interface LangChainToolLike {
+    name: string;
+    description?: string;
+}
+export declare function buildExecuteRequest(tool: LangChainToolLike, input: unknown, options: BuildLangChainExecuteRequestOptions): ExecuteRequest;

package/dist/buildExecuteRequest.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+export function buildExecuteRequest(tool, input, options) {
+    const hasStepContext = typeof options.stepIndex === "number" ||
+        Boolean(options.priorActions?.length);
+    return {
+        requestId: randomUUID(),
+        agent: {
+            id: options.agentId,
+            framework: "langchain",
+        },
+        session: {
+            id: options.sessionId ?? randomUUID(),
+        },
+        environment: {
+            name: options.environmentName ?? "unknown",
+        },
+        action: {
+            type: "tool_call",
+            name: tool.name,
+            description: tool.description,
+            input,
+        },
+        intent: options.goal ? { goal: options.goal } : undefined,
+        state: hasStepContext
+            ? {
+                stepIndex: options.stepIndex,
+                priorActions: options.priorActions,
+            }
+            : undefined,
+        metadata: {
+            traceParent: options.traceParent,
+            runId: options.runId,
+            authorityToken: options.authorityToken,
+            source: options.source ?? "baseline-adapter-langchain",
+            tags: options.tags,
+            context: options.context,
+            toolAuthority: options.toolAuthority,
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./buildExecuteRequest.js";
+export * from "./native.js";
+export * from "./wrapTool.js";
+export * from "./wrapTools.js";
+export { authorityPresets, resolveBaselineToolDefinition, resolveToolAuthority, } from "@baseline-labs/types";
+export type { AuthorityPresetName, ToolAuthoritySpec, } from "@baseline-labs/types";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./buildExecuteRequest.js";
+export * from "./native.js";
+export * from "./wrapTool.js";
+export * from "./wrapTools.js";
+export { authorityPresets, resolveBaselineToolDefinition, resolveToolAuthority, } from "@baseline-labs/types";

package/dist/native.d.ts

@@ -0,0 +1,32 @@
+import { BaselineClient, type BaselineClientConfig } from "@baseline-labs/sdk";
+import type { BaselineManagedToolRecord, BaselineRequestContext, BaselineToolDefinition } from "@baseline-labs/types";
+import { type InvokableTool, type ManagedExecutionContext } from "./wrapTool.js";
+export { BaselineIntegrationError } from "./wrapTool.js";
+export interface BaselineLangChainOptions {
+    baseline: BaselineClient | Pick<BaselineClient, "execute" | "commit"> | (BaselineClientConfig & {
+        authorityDefaults?: BaselineRequestContext;
+        agentId?: string;
+        sessionId?: string;
+    });
+    agentId?: string;
+    sessionId?: string;
+    environmentName?: string;
+    goal?: string;
+    source?: string;
+}
+export interface BaselineLangChainClient {
+    readonly baseline: BaselineClient;
+    wrapTool<Input = unknown, Output = unknown>(tool: BaselineToolDefinition<Input, Output> | InvokableTool<Input, Output>): InvokableTool<Input, Output>;
+    wrapTools<TTool extends InvokableTool<unknown, unknown>>(tools: Array<TTool | BaselineToolDefinition<unknown, unknown>>): TTool[];
+    createManagedToolset<TTool extends InvokableTool<unknown, unknown>>(tools: Array<TTool | BaselineToolDefinition<unknown, unknown>>): {
+        tools: TTool[];
+        getExecutionContext(): ManagedExecutionContext;
+        getToolExecutionHistory(): BaselineManagedToolRecord[];
+        resetExecutionContext(): void;
+    };
+    getExecutionContext(): ManagedExecutionContext;
+    getToolExecutionHistory(): BaselineManagedToolRecord[];
+    resetExecutionContext(): void;
+}
+export declare function defineBaselineTool<Input = unknown, Output = unknown>(tool: BaselineToolDefinition<Input, Output>): BaselineToolDefinition<Input, Output>;
+export declare function createBaselineLangChain(options: BaselineLangChainOptions): BaselineLangChainClient;

package/dist/native.js

@@ -0,0 +1,131 @@
+import { BaselineClient, } from "@baseline-labs/sdk";
+import { resolveBaselineToolDefinition } from "@baseline-labs/types";
+import { createManagedToolset as createManagedWrappedToolset, wrapTools as wrapManagedTools, } from "./wrapTools.js";
+import { BaselineIntegrationError, wrapTool as wrapManagedTool, } from "./wrapTool.js";
+export { BaselineIntegrationError } from "./wrapTool.js";
+const DEFAULT_AGENT_ID = "baseline-langchain";
+function isBaselineClientExecutor(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "execute" in value &&
+        typeof value.execute === "function" &&
+        "commit" in value &&
+        typeof value.commit === "function");
+}
+function contextFromDefaults(defaults) {
+    if (!defaults) {
+        return undefined;
+    }
+    const context = {};
+    if (defaults.tenantId) {
+        context.tenantId = defaults.tenantId;
+    }
+    if (defaults.env) {
+        context.env = defaults.env;
+    }
+    if (defaults.metadata && Object.keys(defaults.metadata).length > 0) {
+        context.metadata = defaults.metadata;
+    }
+    return Object.keys(context).length > 0 ? context : undefined;
+}
+function resolveBaselineClient(baseline) {
+    if (baseline instanceof BaselineClient) {
+        return {
+            client: baseline,
+            configDefaults: {},
+        };
+    }
+    if (isBaselineClientExecutor(baseline)) {
+        return {
+            client: baseline,
+            configDefaults: {},
+        };
+    }
+    const config = baseline;
+    const { authorityDefaults, agentId, sessionId, ...clientConfig } = config;
+    return {
+        client: new BaselineClient(clientConfig),
+        defaults: authorityDefaults,
+        configDefaults: {
+            agentId,
+            sessionId,
+        },
+    };
+}
+function isBaselineToolDefinition(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "name" in value &&
+        typeof value.name === "string" &&
+        "execute" in value &&
+        typeof value.execute === "function");
+}
+function toInvokableTool(tool) {
+    if (!isBaselineToolDefinition(tool)) {
+        return tool;
+    }
+    const baselineTool = resolveBaselineToolDefinition(tool);
+    return {
+        name: baselineTool.name,
+        description: baselineTool.description,
+        authority: baselineTool.authority,
+        commit: baselineTool.commit,
+        invoke(input, context) {
+            return baselineTool.execute(input, context ?? {});
+        },
+    };
+}
+export function defineBaselineTool(tool) {
+    return resolveBaselineToolDefinition(tool);
+}
+export function createBaselineLangChain(options) {
+    const resolvedBaseline = resolveBaselineClient(options.baseline);
+    const baseline = resolvedBaseline.client;
+    const managedContext = {
+        priorActions: [],
+        history: [],
+    };
+    const sharedOptions = {
+        agentId: options.agentId ??
+            resolvedBaseline.configDefaults.agentId ??
+            DEFAULT_AGENT_ID,
+        sessionId: options.sessionId ??
+            resolvedBaseline.configDefaults.sessionId,
+        environmentName: options.environmentName ?? resolvedBaseline.defaults?.env,
+        goal: options.goal,
+        source: options.source ?? "baseline-adapter-langchain",
+        tags: resolvedBaseline.defaults?.tags,
+        context: contextFromDefaults(resolvedBaseline.defaults),
+        managedContext,
+    };
+    return {
+        baseline,
+        wrapTool(tool) {
+            return wrapManagedTool(toInvokableTool(tool), baseline, sharedOptions);
+        },
+        wrapTools(tools) {
+            return wrapManagedTools(tools.map((tool) => toInvokableTool(tool)), baseline, sharedOptions);
+        },
+        createManagedToolset(tools) {
+            return createManagedWrappedToolset(tools.map((tool) => toInvokableTool(tool)), baseline, sharedOptions);
+        },
+        getExecutionContext() {
+            return {
+                ...managedContext,
+                priorActions: [...(managedContext.priorActions ?? [])],
+                history: [...managedContext.history],
+            };
+        },
+        getToolExecutionHistory() {
+            return [...managedContext.history];
+        },
+        resetExecutionContext() {
+            managedContext.runId = undefined;
+            managedContext.lastTraceId = undefined;
+            managedContext.authorityToken = undefined;
+            managedContext.authorityExpiresAt = undefined;
+            managedContext.priorActions = [];
+            managedContext.history = [];
+        },
+    };
+}

package/dist/wrapTool.d.ts

@@ -0,0 +1,52 @@
+import { BaselineClient } from "@baseline-labs/sdk";
+import type { AuthorityPresetName, BaselineDecision, BaselineManagedToolRecord, BaselineToolCommitPlan, BaselineToolRuntimeContext, CommitResponse, ExecuteRequest, ExecuteResponse, ToolAuthoritySpec } from "@baseline-labs/types";
+import { type BuildLangChainExecuteRequestOptions } from "./buildExecuteRequest.js";
+export type BaselineIntegrationErrorKind = "approval_required" | "authority_expired" | "authority_missing" | "authority_scope_violation" | "commit_rejected" | "configuration" | "policy_reevaluation_required" | "request_failed";
+export declare class BaselineIntegrationError extends Error {
+    readonly kind: BaselineIntegrationErrorKind;
+    readonly phase: "execute" | "commit" | "transport" | "configuration";
+    readonly code?: string;
+    readonly status?: number;
+    readonly decision?: BaselineDecision;
+    readonly reason: string;
+    readonly toolName?: string;
+    readonly preset?: AuthorityPresetName;
+    readonly suggestion?: string;
+    readonly executeResponse?: ExecuteResponse;
+    readonly commitResponse?: CommitResponse;
+    constructor(input: {
+        message: string;
+        kind: BaselineIntegrationErrorKind;
+        phase: "execute" | "commit" | "transport" | "configuration";
+        code?: string;
+        status?: number;
+        decision?: BaselineDecision;
+        reason?: string;
+        toolName?: string;
+        preset?: AuthorityPresetName;
+        suggestion?: string;
+        executeResponse?: ExecuteResponse;
+        commitResponse?: CommitResponse;
+        cause?: unknown;
+    });
+}
+export interface InvokableTool<Input = unknown, Output = unknown> {
+    name: string;
+    description?: string;
+    authority?: ToolAuthoritySpec;
+    commit?: BaselineToolCommitPlan<Input>;
+    invoke(input: Input, context?: BaselineToolRuntimeContext): Promise<Output> | Output;
+}
+export interface WrapToolOptions extends BuildLangChainExecuteRequestOptions {
+    resolveModifiedTool?: (name: string) => InvokableTool<unknown, unknown> | undefined;
+    managedContext?: ManagedExecutionContext;
+}
+export interface ManagedExecutionContext {
+    runId?: string;
+    lastTraceId?: string;
+    authorityToken?: string;
+    authorityExpiresAt?: string;
+    priorActions: NonNullable<ExecuteRequest["state"]>["priorActions"];
+    history: BaselineManagedToolRecord[];
+}
+export declare function wrapTool<Input = unknown, Output = unknown>(tool: InvokableTool<Input, Output>, baseline: BaselineClient, options: WrapToolOptions): InvokableTool<Input, Output>;

package/dist/wrapTool.js

@@ -0,0 +1,390 @@
+import { randomUUID } from "node:crypto";
+import { BaselineClient, BaselineClientError, } from "@baseline-labs/sdk";
+import { resolveToolAuthority, suggestAuthorityFix, } from "@baseline-labs/types";
+import { buildExecuteRequest, } from "./buildExecuteRequest.js";
+export class BaselineIntegrationError extends Error {
+    kind;
+    phase;
+    code;
+    status;
+    decision;
+    reason;
+    toolName;
+    preset;
+    suggestion;
+    executeResponse;
+    commitResponse;
+    constructor(input) {
+        super(input.message, {
+            cause: input.cause,
+        });
+        this.name = "BaselineIntegrationError";
+        this.kind = input.kind;
+        this.phase = input.phase;
+        this.code = input.code;
+        this.status = input.status;
+        this.decision = input.decision;
+        this.reason = input.reason ?? input.message;
+        this.toolName = input.toolName;
+        this.preset = input.preset;
+        this.suggestion = input.suggestion;
+        this.executeResponse = input.executeResponse;
+        this.commitResponse = input.commitResponse;
+    }
+}
+const BASELINE_RAW_INVOKE = Symbol.for("@baseline-labs/langchain/raw-invoke");
+const BASELINE_MANAGED = Symbol.for("@baseline-labs/langchain/managed");
+function extractCode(response) {
+    return response?.explanation?.reasonCode ?? response?.audit?.explanationCode;
+}
+function classifyErrorKind(code, phase, response) {
+    if (phase === "configuration") {
+        return "configuration";
+    }
+    if (code === "authority_token_missing" || code === "credential_invalid") {
+        return "authority_missing";
+    }
+    if (code === "authority_token_expired") {
+        return "authority_expired";
+    }
+    if (code === "authority_denied_scope" ||
+        code === "scope_escalation_attempt" ||
+        code === "integration_not_allowed_for_tenant") {
+        return "authority_scope_violation";
+    }
+    if (code === "policy_reevaluation_required" ||
+        code === "approval_invalidated_policy_drift") {
+        return "policy_reevaluation_required";
+    }
+    if (response?.decision === "defer" ||
+        response?.approval?.required ||
+        code?.includes("approval")) {
+        return "approval_required";
+    }
+    if (phase === "commit") {
+        return "commit_rejected";
+    }
+    return "request_failed";
+}
+function formatIntegrationErrorMessage(input) {
+    const lines = [`Error: ${input.kind}`];
+    const preset = input.authority?.preset;
+    if (input.toolName) {
+        lines.push("", `Tool: ${input.toolName}`);
+    }
+    if (preset) {
+        lines.push(`Preset: ${preset}`);
+    }
+    lines.push("", "Reason:", input.reason);
+    const suggestion = suggestAuthorityFix({
+        kind: input.kind,
+        authority: input.authority,
+        code: input.code,
+    });
+    if (suggestion) {
+        lines.push("", "Suggestion:", suggestion);
+    }
+    return {
+        message: lines.join("\n"),
+        preset,
+        suggestion,
+    };
+}
+function integrationErrorFromDecision(input) {
+    const code = extractCode(input.response);
+    const kind = classifyErrorKind(code, input.phase, input.response);
+    const formatted = formatIntegrationErrorMessage({
+        kind,
+        reason: input.response.reason,
+        toolName: input.toolName,
+        authority: input.authority,
+        code,
+    });
+    return new BaselineIntegrationError({
+        message: formatted.message,
+        kind,
+        phase: input.phase,
+        code,
+        decision: input.response.decision,
+        reason: input.response.reason,
+        toolName: input.toolName,
+        preset: formatted.preset,
+        suggestion: formatted.suggestion,
+        executeResponse: input.phase === "execute"
+            ? input.response
+            : undefined,
+        commitResponse: input.phase === "commit"
+            ? input.response
+            : undefined,
+    });
+}
+function integrationErrorFromClientError(error, phase, context) {
+    const kind = classifyErrorKind(error.code, phase);
+    const formatted = formatIntegrationErrorMessage({
+        kind,
+        reason: error.message,
+        toolName: context?.toolName,
+        authority: context?.authority,
+        code: error.code,
+    });
+    return new BaselineIntegrationError({
+        message: formatted.message,
+        kind,
+        phase,
+        code: error.code,
+        status: error.status,
+        reason: error.message,
+        toolName: context?.toolName,
+        preset: formatted.preset,
+        suggestion: formatted.suggestion,
+        cause: error,
+    });
+}
+function rawInvokeFor(tool) {
+    const managedTool = tool;
+    if (managedTool[BASELINE_RAW_INVOKE]) {
+        return managedTool[BASELINE_RAW_INVOKE];
+    }
+    const rawInvoke = tool.invoke.bind(tool);
+    Object.defineProperty(managedTool, BASELINE_RAW_INVOKE, {
+        value: rawInvoke,
+        configurable: false,
+        enumerable: false,
+        writable: false,
+    });
+    return rawInvoke;
+}
+function hardenToolHandle(tool) {
+    const managedTool = tool;
+    rawInvokeFor(tool);
+    if (managedTool[BASELINE_MANAGED]) {
+        return;
+    }
+    Object.defineProperty(managedTool, BASELINE_MANAGED, {
+        value: true,
+        configurable: false,
+        enumerable: false,
+        writable: false,
+    });
+    tool.invoke = ((_) => {
+        throw new Error(`Tool "${tool.name}" is managed by Baseline and cannot be invoked directly. Use the wrapped tool returned by wrapTool().`);
+    });
+}
+async function invokeManagedTool(tool, input, runtimeContext) {
+    return await rawInvokeFor(tool)(input, runtimeContext);
+}
+function managedRequestOptions(options) {
+    const managedContext = options.managedContext;
+    return {
+        traceParent: managedContext?.lastTraceId,
+        runId: managedContext?.runId,
+        authorityToken: managedContext?.authorityToken,
+        stepIndex: managedContext ? (managedContext.priorActions?.length ?? 0) + 1 : undefined,
+        priorActions: managedContext?.priorActions
+            ? [...managedContext.priorActions]
+            : undefined,
+    };
+}
+function updateManagedContext(context, decision, request) {
+    if (!context) {
+        return;
+    }
+    const finalAction = decision.modification?.action ?? request.action;
+    const priorActions = context.priorActions ?? [];
+    priorActions.push({
+        type: finalAction.type,
+        name: finalAction.name,
+        traceId: decision.trace.traceId,
+        decision: decision.decision,
+        reasonCode: extractCode(decision),
+    });
+    context.priorActions = priorActions.slice(-20);
+    context.lastTraceId = decision.trace.traceId;
+    context.runId = decision.trace.runId ?? context.runId ?? decision.trace.traceId;
+    context.authorityToken = decision.trace.authorityToken;
+    context.authorityExpiresAt = decision.trace.authorityExpiresAt;
+}
+function resolveToolForAction(originalTool, action, resolveModifiedTool) {
+    if (action.name === originalTool.name) {
+        return originalTool;
+    }
+    const alternateTool = resolveModifiedTool?.(action.name);
+    if (alternateTool) {
+        alternateTool.authority = resolveToolAuthority(alternateTool.authority);
+        return alternateTool;
+    }
+    throw new BaselineIntegrationError({
+        message: `Baseline modified tool call to "${action.name}" but no matching tool is registered.`,
+        kind: "configuration",
+        phase: "configuration",
+    });
+}
+function resolvePlanValue(value, input) {
+    if (typeof value === "function") {
+        return value(input);
+    }
+    return value;
+}
+function normalizeRollbackRef(commitType, rollbackRef) {
+    if (rollbackRef) {
+        return rollbackRef;
+    }
+    return commitType === "irreversible" ? "irreversible:none" : undefined;
+}
+function shouldCommit(tool) {
+    return Boolean(tool.authority?.commitType && tool.authority.commitType !== "ephemeral");
+}
+function buildToolRuntimeContext(options, managedContext, executeResponse) {
+    return {
+        sessionId: options.sessionId,
+        environmentName: options.environmentName,
+        runId: managedContext?.runId,
+        traceId: executeResponse.trace.traceId,
+        authorityToken: managedContext?.authorityToken,
+        authorityExpiresAt: managedContext?.authorityExpiresAt,
+        tags: options.tags,
+        metadata: options.context,
+        history: managedContext?.history ? [...managedContext.history] : [],
+    };
+}
+function buildCommitRequest(tool, input, executeDecision, options, managedContext) {
+    const commitPlan = tool.commit;
+    return {
+        requestId: randomUUID(),
+        agent: {
+            id: options.agentId,
+            framework: "langchain",
+        },
+        session: {
+            id: options.sessionId ?? randomUUID(),
+        },
+        proposedCommit: {
+            type: resolvePlanValue(commitPlan?.type, input) ??
+                tool.authority.scope ??
+                tool.name,
+            system: resolvePlanValue(commitPlan?.system, input) ?? options.environmentName,
+            payload: resolvePlanValue(commitPlan?.payload, input) ?? {
+                tool: tool.name,
+                input,
+            },
+        },
+        commitType: tool.authority.commitType,
+        supportingTraceId: executeDecision.trace.traceId,
+        authorityToken: managedContext?.authorityToken ?? executeDecision.trace.authorityToken,
+        checkpointRef: resolvePlanValue(commitPlan?.checkpointRef, input),
+        rollbackRef: normalizeRollbackRef(tool.authority.commitType, resolvePlanValue(commitPlan?.rollbackRef, input)),
+        artifact: resolvePlanValue(commitPlan?.artifact, input),
+        approvalContext: resolvePlanValue(commitPlan?.approvalContext, input),
+        policyContext: resolvePlanValue(commitPlan?.policyContext, input),
+    };
+}
+async function executeViaBaseline(baseline, request, context) {
+    try {
+        return await baseline.execute(request);
+    }
+    catch (error) {
+        if (error instanceof BaselineClientError) {
+            throw integrationErrorFromClientError(error, "transport", context);
+        }
+        throw error;
+    }
+}
+async function commitViaBaseline(baseline, request, context) {
+    try {
+        return await baseline.commit(request);
+    }
+    catch (error) {
+        if (error instanceof BaselineClientError) {
+            throw integrationErrorFromClientError(error, "commit", context);
+        }
+        throw error;
+    }
+}
+export function wrapTool(tool, baseline, options) {
+    tool.authority = resolveToolAuthority(tool.authority);
+    hardenToolHandle(tool);
+    return {
+        ...tool,
+        authority: tool.authority,
+        commit: tool.commit,
+        async invoke(input) {
+            const request = buildExecuteRequest(tool, input, {
+                ...options,
+                sessionId: options.sessionId ?? randomUUID(),
+                toolAuthority: tool.authority,
+                ...managedRequestOptions(options),
+            });
+            const decision = await executeViaBaseline(baseline, request, {
+                toolName: tool.name,
+                authority: tool.authority,
+            });
+            updateManagedContext(options.managedContext, decision, request);
+            if (decision.decision === "deny" || decision.decision === "defer") {
+                if (options.managedContext) {
+                    options.managedContext.history.push({
+                        toolName: tool.name,
+                        input: request.action.input,
+                        execute: decision,
+                        executeRequest: request,
+                        executeResponse: decision,
+                    });
+                }
+                throw integrationErrorFromDecision({
+                    phase: "execute",
+                    response: decision,
+                    toolName: tool.name,
+                    authority: tool.authority,
+                });
+            }
+            const finalAction = decision.modification?.action ?? request.action;
+            const resolvedTool = resolveToolForAction(tool, finalAction, options.resolveModifiedTool);
+            const runtimeContext = buildToolRuntimeContext(options, options.managedContext, decision);
+            let commitRequest;
+            let commitResponse;
+            if (shouldCommit(resolvedTool)) {
+                commitRequest = buildCommitRequest(resolvedTool, finalAction.input, decision, options, options.managedContext);
+                commitResponse = await commitViaBaseline(baseline, commitRequest, {
+                    toolName: resolvedTool.name,
+                    authority: resolvedTool.authority,
+                });
+                if (commitResponse.decision === "deny" ||
+                    commitResponse.decision === "defer" ||
+                    commitResponse.commit?.admitted === false) {
+                    if (options.managedContext) {
+                        options.managedContext.history.push({
+                            toolName: resolvedTool.name,
+                            input: finalAction.input,
+                            execute: decision,
+                            commit: commitResponse,
+                            executeRequest: request,
+                            executeResponse: decision,
+                            commitRequest,
+                            commitResponse,
+                        });
+                    }
+                    throw integrationErrorFromDecision({
+                        phase: "commit",
+                        response: commitResponse,
+                        toolName: resolvedTool.name,
+                        authority: resolvedTool.authority,
+                    });
+                }
+            }
+            const output = (await invokeManagedTool(resolvedTool, finalAction.input, runtimeContext));
+            if (options.managedContext) {
+                options.managedContext.history.push({
+                    toolName: resolvedTool.name,
+                    input: finalAction.input,
+                    output,
+                    execute: decision,
+                    commit: commitResponse,
+                    executeRequest: request,
+                    executeResponse: decision,
+                    commitRequest,
+                    commitResponse,
+                });
+            }
+            return output;
+        },
+    };
+}

package/dist/wrapTools.d.ts

@@ -0,0 +1,15 @@
+import { BaselineClient } from "@baseline-labs/sdk";
+import type { InvokableTool, ManagedExecutionContext, WrapToolOptions } from "./wrapTool.js";
+export interface ManagedToolset<TTool extends InvokableTool<unknown, unknown>> {
+    tools: TTool[];
+    getExecutionContext(): ManagedExecutionContext;
+    getToolExecutionHistory(): ManagedExecutionContext["history"];
+    resetExecutionContext(): void;
+}
+export declare function wrapTools<TTool extends InvokableTool<unknown, unknown>>(tools: TTool[], baseline: BaselineClient, options: Omit<WrapToolOptions, "resolveModifiedTool" | "managedContext"> & {
+    managedContext?: ManagedExecutionContext;
+}): TTool[];
+export declare function createManagedToolset<TTool extends InvokableTool<unknown, unknown>>(tools: TTool[], baseline: BaselineClient, options: Omit<WrapToolOptions, "resolveModifiedTool" | "managedContext"> & {
+    managedContext?: ManagedExecutionContext;
+}): ManagedToolset<TTool>;
+export declare const createManagedLangChainTools: typeof createManagedToolset;

package/dist/wrapTools.js

@@ -0,0 +1,48 @@
+import { BaselineClient } from "@baseline-labs/sdk";
+import { wrapTool } from "./wrapTool.js";
+export function wrapTools(tools, baseline, options) {
+    const managedContext = options.managedContext ?? {
+        priorActions: [],
+        history: [],
+    };
+    const toolRegistry = new Map();
+    for (const tool of tools) {
+        toolRegistry.set(tool.name, tool);
+    }
+    return tools.map((tool) => wrapTool(tool, baseline, {
+        ...options,
+        managedContext,
+        resolveModifiedTool: (name) => toolRegistry.get(name),
+    }));
+}
+export function createManagedToolset(tools, baseline, options) {
+    const managedContext = options.managedContext ?? {
+        priorActions: [],
+        history: [],
+    };
+    return {
+        tools: wrapTools(tools, baseline, {
+            ...options,
+            managedContext,
+        }),
+        getExecutionContext() {
+            return {
+                ...managedContext,
+                priorActions: [...(managedContext.priorActions ?? [])],
+                history: [...managedContext.history],
+            };
+        },
+        getToolExecutionHistory() {
+            return [...managedContext.history];
+        },
+        resetExecutionContext() {
+            managedContext.runId = undefined;
+            managedContext.lastTraceId = undefined;
+            managedContext.authorityToken = undefined;
+            managedContext.authorityExpiresAt = undefined;
+            managedContext.priorActions = [];
+            managedContext.history = [];
+        },
+    };
+}
+export const createManagedLangChainTools = createManagedToolset;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@baseline-labs/adapter-langchain",
+  "version": "0.1.0",
+  "description": "Authority-aware LangChain tool integration for Baseline.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "node --import tsx --test src/*.test.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "baseline",
+    "langchain",
+    "tools",
+    "authority"
+  ],
+  "dependencies": {
+    "@baseline-labs/sdk": "^0.1.0",
+    "@baseline-labs/types": "^0.1.0"
+  }
+}