@baseline-labs/adapter-langchain 0.1.0 → 0.1.2

package/dist/buildExecuteRequest.d.ts

@@ -7,6 +7,7 @@ export interface BuildLangChainExecuteRequestOptions {
     source?: string;
     toolAuthority?: ToolAuthoritySpec;
     traceParent?: string;
+    parentOperationId?: string;
     runId?: string;
     authorityToken?: string;
     stepIndex?: number;

package/dist/buildExecuteRequest.js

@@ -28,6 +28,7 @@ export function buildExecuteRequest(tool, input, options) {
             }
             : undefined,
         metadata: {
+            parentOperationId: options.parentOperationId,
             traceParent: options.traceParent,
             runId: options.runId,
             authorityToken: options.authorityToken,

package/dist/native.d.ts

@@ -3,7 +3,7 @@ import type { BaselineManagedToolRecord, BaselineRequestContext, BaselineToolDef
 import { type InvokableTool, type ManagedExecutionContext } from "./wrapTool.js";
 export { BaselineIntegrationError } from "./wrapTool.js";
 export interface BaselineLangChainOptions {
-    baseline: BaselineClient | Pick<BaselineClient, "execute" | "commit"> | (BaselineClientConfig & {
+    baseline: BaselineClient | Pick<BaselineClient, "executeV2" | "commitV2" | "getOperation"> | (BaselineClientConfig & {
         authorityDefaults?: BaselineRequestContext;
         agentId?: string;
         sessionId?: string;

package/dist/native.js

@@ -7,10 +7,12 @@ 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");
+        "executeV2" in value &&
+        typeof value.executeV2 === "function" &&
+        "commitV2" in value &&
+        typeof value.commitV2 === "function" &&
+        "getOperation" in value &&
+        typeof value.getOperation === "function");
 }
 function contextFromDefaults(defaults) {
     if (!defaults) {

package/dist/wrapTool.d.ts

@@ -49,4 +49,6 @@ export interface ManagedExecutionContext {
     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>;
+type BaselineV2ClientExecutor = Pick<BaselineClient, "executeV2" | "commitV2" | "getOperation">;
+export declare function wrapTool<Input = unknown, Output = unknown>(tool: InvokableTool<Input, Output>, baseline: BaselineV2ClientExecutor, options: WrapToolOptions): InvokableTool<Input, Output>;
+export {};

package/dist/wrapTool.js

@@ -80,6 +80,7 @@ function formatIntegrationErrorMessage(input) {
         kind: input.kind,
         authority: input.authority,
         code: input.code,
+        reason: input.reason,
     });
     if (suggestion) {
         lines.push("", "Suggestion:", suggestion);
@@ -140,6 +141,145 @@ function integrationErrorFromClientError(error, phase, context) {
         cause: error,
     });
 }
+const DEFAULT_OPERATION_POLL_ATTEMPTS = 20;
+const DEFAULT_OPERATION_POLL_DELAY_MS = 25;
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function continuationCode(state) {
+    switch (state) {
+        case "expired":
+            return "authority_token_expired";
+        case "revoked":
+            return "authority_surface_revoked";
+        case "reevaluation_required":
+            return "policy_reevaluation_required";
+        case "invalid":
+            return "authority_token_invalid";
+        default:
+            return undefined;
+    }
+}
+function toExecuteResponse(request, operation) {
+    const decision = operation.status === "pending_approval"
+        ? "defer"
+        : operation.status === "denied" || operation.status === "invalidated"
+            ? "deny"
+            : operation.result === "changed"
+                ? "modify"
+                : "allow";
+    const explanationCode = operation.status === "pending_approval"
+        ? "approval_required"
+        : continuationCode(operation.continuation.state) ??
+            (operation.result === "changed" ? "action_modified" : undefined);
+    return {
+        requestId: operation.requestId ?? request.requestId,
+        decision,
+        reason: operation.message,
+        risk: {
+            score: 0,
+            level: "low",
+            factors: [],
+        },
+        execution: {
+            allowed: decision !== "deny" && decision !== "defer",
+            modified: operation.result === "changed",
+            deferred: decision === "defer",
+            requiresApproval: operation.status === "pending_approval",
+        },
+        modification: operation.result === "changed" && operation.nextAction.action
+            ? {
+                action: operation.nextAction.action,
+            }
+            : undefined,
+        approval: operation.status === "pending_approval"
+            ? {
+                required: true,
+                status: "pending",
+            }
+            : undefined,
+        trace: {
+            traceId: operation.operationId,
+            runId: operation.operationId,
+            authorityToken: operation.continuation.handle,
+            authorityExpiresAt: operation.continuation.expiresAt,
+        },
+        audit: {
+            timestamp: operation.updatedAt,
+            explanationCode,
+        },
+    };
+}
+function toCommitResponse(request, operation) {
+    const denied = operation.status === "denied" ||
+        operation.status === "failed" ||
+        operation.status === "invalidated" ||
+        operation.status === "superseded";
+    const deferred = operation.status === "pending_approval";
+    const admitted = operation.status === "completed";
+    const explanationCode = operation.status === "pending_approval"
+        ? "approval_required"
+        : operation.status === "partially_completed"
+            ? "partial_commit_requires_operator"
+            : operation.status === "rollback_incomplete"
+                ? "rollback_incomplete"
+                : continuationCode(operation.continuation.state) ??
+                    (denied ? "commit_denied" : undefined);
+    return {
+        requestId: operation.requestId ?? request.requestId,
+        decision: deferred ? "defer" : denied ? "deny" : "allow",
+        reason: operation.message,
+        state: operation.status === "pending_approval"
+            ? "pending_approval"
+            : admitted
+                ? "committed"
+                : "rejected",
+        trace: {
+            traceId: operation.operationId,
+            runId: operation.operationId,
+        },
+        approval: operation.approval.state === "pending"
+            ? {
+                required: true,
+                status: "pending",
+            }
+            : operation.approval.state === "denied"
+                ? {
+                    required: false,
+                    status: "denied",
+                }
+                : undefined,
+        audit: {
+            timestamp: operation.updatedAt,
+            explanationCode,
+            commitType: request.commitType,
+        },
+        commit: {
+            admitted,
+            type: request.commitType,
+            state: admitted ? "committed" : deferred ? "pending_approval" : "rejected",
+            persisted: admitted,
+        },
+    };
+}
+async function settleOperation(baseline, operationId, phase) {
+    let operation = await baseline.getOperation(operationId);
+    for (let attempt = 0; operation.status === "processing" && attempt < DEFAULT_OPERATION_POLL_ATTEMPTS; attempt += 1) {
+        await delay(DEFAULT_OPERATION_POLL_DELAY_MS);
+        operation = await baseline.getOperation(operationId);
+    }
+    if (operation.status === "processing") {
+        throw new BaselineIntegrationError({
+            message: `Baseline operation ${operationId} is still processing.`,
+            kind: "request_failed",
+            phase,
+            reason: operation.message,
+        });
+    }
+    return operation;
+}
 function rawInvokeFor(tool) {
     const managedTool = tool;
     if (managedTool[BASELINE_RAW_INVOKE]) {
@@ -176,7 +316,7 @@ async function invokeManagedTool(tool, input, runtimeContext) {
 function managedRequestOptions(options) {
     const managedContext = options.managedContext;
     return {
-        traceParent: managedContext?.lastTraceId,
+        parentOperationId: managedContext?.lastTraceId,
         runId: managedContext?.runId,
         authorityToken: managedContext?.authorityToken,
         stepIndex: managedContext ? (managedContext.priorActions?.length ?? 0) + 1 : undefined,
@@ -269,7 +409,7 @@ function buildCommitRequest(tool, input, executeDecision, options, managedContex
             },
         },
         commitType: tool.authority.commitType,
-        supportingTraceId: executeDecision.trace.traceId,
+        supportingOperationId: executeDecision.trace.traceId,
         authorityToken: managedContext?.authorityToken ?? executeDecision.trace.authorityToken,
         checkpointRef: resolvePlanValue(commitPlan?.checkpointRef, input),
         rollbackRef: normalizeRollbackRef(tool.authority.commitType, resolvePlanValue(commitPlan?.rollbackRef, input)),
@@ -280,7 +420,11 @@ function buildCommitRequest(tool, input, executeDecision, options, managedContex
 }
 async function executeViaBaseline(baseline, request, context) {
     try {
-        return await baseline.execute(request);
+        const immediate = await baseline.executeV2(request, {
+            idempotencyKey: request.requestId,
+        });
+        const operation = await settleOperation(baseline, immediate.operation.id, "execute");
+        return toExecuteResponse(request, operation);
     }
     catch (error) {
         if (error instanceof BaselineClientError) {
@@ -291,7 +435,11 @@ async function executeViaBaseline(baseline, request, context) {
 }
 async function commitViaBaseline(baseline, request, context) {
     try {
-        return await baseline.commit(request);
+        const immediate = await baseline.commitV2(request, {
+            idempotencyKey: request.requestId,
+        });
+        const operation = await settleOperation(baseline, immediate.operation.id, "commit");
+        return toCommitResponse(request, operation);
     }
     catch (error) {
         if (error instanceof BaselineClientError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baseline-labs/adapter-langchain",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Authority-aware LangChain tool integration for Baseline.",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
     "authority"
   ],
   "dependencies": {
-    "@baseline-labs/sdk": "^0.1.0",
-    "@baseline-labs/types": "^0.1.0"
+    "@baseline-labs/sdk": "^0.1.1",
+    "@baseline-labs/types": "^0.1.2"
   }
 }