@agent-assembly/sdk 0.0.1-alpha.3

package/dist/cjs/errors/configuration-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationError = void 0;
+/**
+ * Thrown when the SDK cannot resolve the gateway configuration —
+ * e.g. the local gateway is absent and ``aasm`` is not on ``PATH``.
+ *
+ * Mirrors ``agent_assembly.exceptions.ConfigurationError`` in the
+ * Python SDK so the cross-SDK error contract stays aligned per Epic 17 S-G.
+ */
+class ConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigurationError";
+    }
+}
+exports.ConfigurationError = ConfigurationError;

package/dist/cjs/errors/gateway-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayError = void 0;
+/**
+ * Thrown when the SDK has a gateway URL but cannot talk to it —
+ * e.g. ``aasm`` was spawned but ``/healthz`` did not become ready
+ * within the auto-start timeout window.
+ *
+ * Mirrors ``agent_assembly.exceptions.GatewayError`` in the Python SDK.
+ */
+class GatewayError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GatewayError";
+    }
+}
+exports.GatewayError = GatewayError;

package/dist/cjs/errors/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyViolationError = exports.OpTerminatedError = exports.GatewayError = exports.ConfigurationError = void 0;
+var configuration_error_js_1 = require("./configuration-error.js");
+Object.defineProperty(exports, "ConfigurationError", { enumerable: true, get: function () { return configuration_error_js_1.ConfigurationError; } });
+var gateway_error_js_1 = require("./gateway-error.js");
+Object.defineProperty(exports, "GatewayError", { enumerable: true, get: function () { return gateway_error_js_1.GatewayError; } });
+var op_terminated_error_js_1 = require("./op-terminated-error.js");
+Object.defineProperty(exports, "OpTerminatedError", { enumerable: true, get: function () { return op_terminated_error_js_1.OpTerminatedError; } });
+var policy_violation_error_js_1 = require("./policy-violation-error.js");
+Object.defineProperty(exports, "PolicyViolationError", { enumerable: true, get: function () { return policy_violation_error_js_1.PolicyViolationError; } });

package/dist/cjs/errors/op-terminated-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpTerminatedError = void 0;
+/**
+ * Raised when the gateway terminates an in-flight op (AAASM-1422 PR-F).
+ *
+ * Carries the originating `opId` so callers can correlate the failure
+ * against the operation they were awaiting. Surfaced by
+ * `OpControlSubscriber.waitForOp` when an `OP_CONTROL_SIGNAL_TERMINATE`
+ * arrives for the awaited op.
+ */
+class OpTerminatedError extends Error {
+    opId;
+    constructor(message, opId) {
+        super(message);
+        this.name = "OpTerminatedError";
+        this.opId = opId;
+    }
+}
+exports.OpTerminatedError = OpTerminatedError;

package/dist/cjs/errors/policy-violation-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyViolationError = void 0;
+class PolicyViolationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PolicyViolationError";
+    }
+}
+exports.PolicyViolationError = PolicyViolationError;

package/dist/cjs/gateway/client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoopGatewayClient = createNoopGatewayClient;
+function createNoopGatewayClient(mode) {
+    return {
+        mode,
+        start: async () => undefined,
+        close: async () => undefined,
+        check: async () => ({ denied: false, pending: false }),
+        waitForApproval: async () => ({ denied: false }),
+        record: async () => undefined,
+        recordResult: async () => undefined,
+        scanPrompts: async () => undefined
+    };
+}

package/dist/cjs/gateway/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoopGatewayClient = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "createNoopGatewayClient", { enumerable: true, get: function () { return client_js_1.createNoopGatewayClient; } });

package/dist/cjs/hooks/adapter-registry.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFrameworkHooks = registerFrameworkHooks;
+const langchain_js_1 = require("./langchain.js");
+async function registerFrameworkHooks(client) {
+    await (0, langchain_js_1.patchLangChain)(client);
+}

package/dist/cjs/hooks/ai-sdk-detection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasVercelAiSdk = hasVercelAiSdk;
+const node_module_1 = require("node:module");
+const requireFromCwd = (0, node_module_1.createRequire)(`${process.cwd()}/`);
+function hasVercelAiSdk() {
+    try {
+        requireFromCwd.resolve("ai");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cjs/hooks/ai-sdk.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vercelAiSdkPatchState = void 0;
+exports.captureOriginalToolFactory = captureOriginalToolFactory;
+exports.recordToolResultNonBlocking = recordToolResultNonBlocking;
+exports.createWrappedExecute = createWrappedExecute;
+exports.createPatchedToolFactory = createPatchedToolFactory;
+exports.patchVercelAiSdk = patchVercelAiSdk;
+exports.unpatchVercelAiSdk = unpatchVercelAiSdk;
+const policy_violation_error_js_1 = require("../errors/policy-violation-error.js");
+const agent_context_store_js_1 = require("../lineage/agent-context-store.js");
+exports.vercelAiSdkPatchState = {
+    isPatched: false,
+    originalToolFactory: undefined,
+    patchedModule: undefined
+};
+function captureOriginalToolFactory(module) {
+    const candidate = module.tool;
+    if (typeof candidate !== "function") {
+        return undefined;
+    }
+    if (!exports.vercelAiSdkPatchState.originalToolFactory) {
+        exports.vercelAiSdkPatchState.originalToolFactory = candidate;
+    }
+    return exports.vercelAiSdkPatchState.originalToolFactory;
+}
+function recordToolResultNonBlocking(gatewayClient, runId, output) {
+    void gatewayClient.recordResult({ runId, output }).catch(() => undefined);
+}
+function createWrappedExecute(originalExecute, description, gatewayClient, options) {
+    return async function wrappedExecute(args, executionOptions) {
+        const runId = executionOptions.toolCallId ?? options.fallbackRunId;
+        const executeOriginal = async () => {
+            const run = async () => {
+                const result = await originalExecute(args, executionOptions);
+                recordToolResultNonBlocking(gatewayClient, runId, result);
+                return result;
+            };
+            return options.agentId ? (0, agent_context_store_js_1.runWithAgentId)(options.agentId, run) : run();
+        };
+        let decision;
+        try {
+            decision = await gatewayClient.check({
+                action: "tool_call",
+                toolName: description,
+                args: args,
+                runId
+            });
+        }
+        catch {
+            return executeOriginal();
+        }
+        if (decision.denied) {
+            throw new policy_violation_error_js_1.PolicyViolationError(`Tool blocked by governance policy: ${decision.reason ?? "Denied"}`);
+        }
+        if (decision.pending) {
+            let approval;
+            try {
+                approval = await gatewayClient.waitForApproval(description, runId, options.approvalTimeoutMs);
+            }
+            catch {
+                return executeOriginal();
+            }
+            if (approval.denied) {
+                throw new policy_violation_error_js_1.PolicyViolationError(`Approval rejected: ${approval.reason ?? "Rejected"}`);
+            }
+        }
+        return executeOriginal();
+    };
+}
+function createPatchedToolFactory(originalToolFactory, gatewayClient, options) {
+    return function patchedTool(definition) {
+        const toolResult = originalToolFactory(definition);
+        if (!toolResult.execute) {
+            return toolResult;
+        }
+        const description = toolResult.description ?? "unknown_tool";
+        return {
+            ...toolResult,
+            execute: createWrappedExecute(toolResult.execute, description, gatewayClient, options)
+        };
+    };
+}
+async function loadVercelAiSdkModule() {
+    try {
+        const moduleName = "ai";
+        const module = (await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s))));
+        return module;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function patchVercelAiSdk(options) {
+    if (exports.vercelAiSdkPatchState.isPatched) {
+        return true;
+    }
+    const loadModule = options.loadModule ?? loadVercelAiSdkModule;
+    const module = await loadModule();
+    if (!module) {
+        return false;
+    }
+    const originalToolFactory = captureOriginalToolFactory(module);
+    if (!originalToolFactory) {
+        return false;
+    }
+    module.tool = createPatchedToolFactory(originalToolFactory, options.gatewayClient, {
+        approvalTimeoutMs: options.approvalTimeoutMs ?? 30_000,
+        fallbackRunId: options.fallbackRunId ?? "vercel-ai-sdk",
+        ...(options.agentId !== undefined ? { agentId: options.agentId } : {})
+    });
+    exports.vercelAiSdkPatchState.isPatched = true;
+    exports.vercelAiSdkPatchState.patchedModule = module;
+    return true;
+}
+function unpatchVercelAiSdk() {
+    if (!exports.vercelAiSdkPatchState.isPatched) {
+        return false;
+    }
+    if (!exports.vercelAiSdkPatchState.patchedModule) {
+        return false;
+    }
+    if (!exports.vercelAiSdkPatchState.originalToolFactory) {
+        return false;
+    }
+    exports.vercelAiSdkPatchState.patchedModule.tool =
+        exports.vercelAiSdkPatchState.originalToolFactory;
+    exports.vercelAiSdkPatchState.isPatched = false;
+    exports.vercelAiSdkPatchState.patchedModule = undefined;
+    return true;
+}

package/dist/cjs/hooks/langchain.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchLangChain = patchLangChain;
+async function patchLangChain(client) {
+    if (client.mode === "grpc-sidecar" || client.mode === "napi-inprocess") {
+        return false;
+    }
+    return false;
+}

package/dist/cjs/hooks/langgraph-detection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasLangGraph = hasLangGraph;
+const node_module_1 = require("node:module");
+const requireFromCwd = (0, node_module_1.createRequire)(`${process.cwd()}/`);
+function hasLangGraph() {
+    try {
+        requireFromCwd.resolve("@langchain/langgraph");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cjs/hooks/langgraph.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.langGraphPatchState = void 0;
+exports.wrapCompiledGraph = wrapCompiledGraph;
+exports.patchLangGraph = patchLangGraph;
+exports.unpatchLangGraph = unpatchLangGraph;
+const agent_context_store_js_1 = require("../lineage/agent-context-store.js");
+exports.langGraphPatchState = {
+    isPatched: false,
+    originalCompile: undefined,
+    patchedClass: undefined
+};
+function wrapCompiledGraph(compiled, agentId) {
+    const originalInvoke = compiled.invoke.bind(compiled);
+    const originalStream = compiled.stream.bind(compiled);
+    compiled.invoke = (...args) => (0, agent_context_store_js_1.runWithAgentId)(agentId, () => originalInvoke(...args));
+    compiled.stream = (...args) => (0, agent_context_store_js_1.runWithAgentId)(agentId, () => originalStream(...args));
+    return compiled;
+}
+async function loadLangGraphModule() {
+    try {
+        const moduleName = "@langchain/langgraph";
+        const module = (await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s))));
+        return module;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function patchLangGraph(options) {
+    if (exports.langGraphPatchState.isPatched) {
+        return true;
+    }
+    const loadModule = options.loadModule ?? loadLangGraphModule;
+    let module;
+    try {
+        module = await loadModule();
+    }
+    catch {
+        return false;
+    }
+    if (!module?.StateGraph?.prototype?.compile) {
+        return false;
+    }
+    const originalCompile = module.StateGraph.prototype.compile;
+    exports.langGraphPatchState.originalCompile = originalCompile;
+    exports.langGraphPatchState.patchedClass = module.StateGraph;
+    const { agentId } = options;
+    module.StateGraph.prototype.compile = function patchedCompile(...args) {
+        const compiled = originalCompile.apply(this, args);
+        try {
+            return wrapCompiledGraph(compiled, agentId);
+        }
+        catch (e) {
+            console.warn("[assembly] LangGraph lineage patch error on compile; falling back:", e);
+            return compiled;
+        }
+    };
+    exports.langGraphPatchState.isPatched = true;
+    return true;
+}
+function unpatchLangGraph() {
+    if (!exports.langGraphPatchState.isPatched) {
+        return false;
+    }
+    if (!exports.langGraphPatchState.patchedClass || !exports.langGraphPatchState.originalCompile) {
+        return false;
+    }
+    exports.langGraphPatchState.patchedClass.prototype.compile = exports.langGraphPatchState.originalCompile;
+    exports.langGraphPatchState.isPatched = false;
+    exports.langGraphPatchState.originalCompile = undefined;
+    exports.langGraphPatchState.patchedClass = undefined;
+    return true;
+}

package/dist/cjs/hooks/mastra-detection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMastra = hasMastra;
+const node_module_1 = require("node:module");
+const requireFromCwd = (0, node_module_1.createRequire)(`${process.cwd()}/`);
+function hasMastra() {
+    try {
+        requireFromCwd.resolve("@mastra/core");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cjs/hooks/mastra.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mastraPatchState = void 0;
+exports.patchMastra = patchMastra;
+exports.unpatchMastra = unpatchMastra;
+const agent_context_store_js_1 = require("../lineage/agent-context-store.js");
+exports.mastraPatchState = {
+    isPatched: false,
+    originalGenerate: undefined,
+    originalExecute: undefined,
+    patchedAgentClass: undefined,
+    patchedWorkflowClass: undefined
+};
+async function loadMastraModule() {
+    try {
+        const moduleName = "@mastra/core";
+        const module = (await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s))));
+        return module;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function patchMastra(options) {
+    if (exports.mastraPatchState.isPatched) {
+        return true;
+    }
+    const loadModule = options.loadModule ?? loadMastraModule;
+    let module;
+    try {
+        module = await loadModule();
+    }
+    catch {
+        return false;
+    }
+    if (!module?.Agent?.prototype?.generate) {
+        return false;
+    }
+    const { agentId } = options;
+    // Wrap Agent.prototype.generate
+    const originalGenerate = module.Agent.prototype.generate;
+    exports.mastraPatchState.originalGenerate = originalGenerate;
+    exports.mastraPatchState.patchedAgentClass = module.Agent;
+    module.Agent.prototype.generate = function patchedGenerate(...args) {
+        try {
+            return (0, agent_context_store_js_1.runWithAgentId)(agentId, () => originalGenerate.apply(this, args));
+        }
+        catch (e) {
+            console.warn("[assembly] Mastra lineage patch error on generate; falling back:", e);
+            return originalGenerate.apply(this, args);
+        }
+    };
+    // Wrap Workflow.prototype.execute if present
+    if (module.Workflow?.prototype?.execute) {
+        const originalExecute = module.Workflow.prototype.execute;
+        exports.mastraPatchState.originalExecute = originalExecute;
+        exports.mastraPatchState.patchedWorkflowClass = module.Workflow;
+        module.Workflow.prototype.execute = function patchedExecute(...args) {
+            try {
+                return (0, agent_context_store_js_1.runWithAgentId)(agentId, () => originalExecute.apply(this, args));
+            }
+            catch (e) {
+                console.warn("[assembly] Mastra lineage patch error on execute; falling back:", e);
+                return originalExecute.apply(this, args);
+            }
+        };
+    }
+    exports.mastraPatchState.isPatched = true;
+    return true;
+}
+function unpatchMastra() {
+    if (!exports.mastraPatchState.isPatched) {
+        return false;
+    }
+    if (exports.mastraPatchState.patchedAgentClass && exports.mastraPatchState.originalGenerate) {
+        exports.mastraPatchState.patchedAgentClass.prototype.generate = exports.mastraPatchState.originalGenerate;
+    }
+    if (exports.mastraPatchState.patchedWorkflowClass && exports.mastraPatchState.originalExecute) {
+        exports.mastraPatchState.patchedWorkflowClass.prototype.execute = exports.mastraPatchState.originalExecute;
+    }
+    exports.mastraPatchState.isPatched = false;
+    exports.mastraPatchState.originalGenerate = undefined;
+    exports.mastraPatchState.originalExecute = undefined;
+    exports.mastraPatchState.patchedAgentClass = undefined;
+    exports.mastraPatchState.patchedWorkflowClass = undefined;
+    return true;
+}

package/dist/cjs/hooks/openai-agents-detection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOpenAIAgentsSDK = hasOpenAIAgentsSDK;
+const node_module_1 = require("node:module");
+const requireFromCwd = (0, node_module_1.createRequire)(`${process.cwd()}/`);
+function hasOpenAIAgentsSDK() {
+    try {
+        requireFromCwd.resolve("@openai/agents");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}