@skein-js/agent-protocol 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GraphSchema, SkeinStore, RunQueue, RunEventBus, AuthEngine, Assistant, Config, StreamMode, Metadata, MultitaskStrategy, RunFrame, DefaultValues, Run, RunStatus, StorePutOptions, Item, StoreSearchQuery, SearchItem, Thread, ThreadSearchQuery, ThreadState, StoreRepo } from '@skein-js/core';
+import { GraphSchema, SkeinStore, RunQueue, RunEventBus, AuthEngine, Assistant, AuthUser, Config, StreamMode, Metadata, MultitaskStrategy, RunFrame, DefaultValues, Run, RunStatus, StorePutOptions, Item, StoreSearchQuery, SearchItem, Thread, ThreadSearchQuery, ThreadState, StoreRepo } from '@skein-js/core';
 import { CompiledGraph, BaseCheckpointSaver, BaseStore, Item as Item$1, Operation, OperationResults } from '@langchain/langgraph';
 
 /** A factory export: called (optionally with per-run config) to produce a compiled graph. */
@@ -119,6 +119,14 @@ interface ProtocolContext {
     deps: ResolvedDeps;
     control: RunControlRegistry;
     locks: ThreadLocks;
+    /**
+     * The authenticated caller for the current request, populated by the authorizing handler wrapper
+     * so the run service can stamp it onto a run's kwargs. Undefined when no auth engine is
+     * configured (the default), matching `langgraph dev` — no principal is injected into the graph.
+     */
+    authUser?: AuthUser;
+    /** The current request's authenticated permission scopes (`AuthContext.scopes`), stamped with {@link authUser}. */
+    authScopes?: string[];
 }
 declare function createContext(deps: ProtocolDeps): ProtocolContext;
 

package/dist/index.js

@@ -622,7 +622,10 @@ var RESERVED_CONFIGURABLE_KEYS = /* @__PURE__ */ new Set([
   "checkpoint_id",
   "checkpoint_ns",
   "checkpoint_map",
-  "checkpoint"
+  "checkpoint",
+  "langgraph_auth_user",
+  "langgraph_auth_user_id",
+  "langgraph_auth_permissions"
 ]);
 function sanitizeConfigurable(configurable) {
   if (!configurable) return {};
@@ -633,10 +636,32 @@ function sanitizeConfigurable(configurable) {
   }
   return clean;
 }
+function withAuthUser(configurable, authUser, scopes) {
+  if (!authUser) return configurable;
+  return {
+    ...configurable,
+    langgraph_auth_user: authUser,
+    langgraph_auth_user_id: authUser.identity,
+    langgraph_auth_permissions: scopes ?? authUser.permissions
+  };
+}
+function toFactoryConfigurable(kwargs) {
+  const configurable = withAuthUser(
+    sanitizeConfigurable(kwargs.config?.configurable),
+    kwargs.auth_user,
+    kwargs.auth_scopes
+  );
+  return Object.keys(configurable).length > 0 ? configurable : void 0;
+}
 function toGraphCallOptions(kwargs, threadId, signal) {
   const options = {
-    // Drop server-owned keys from the client's configurable, then force this thread's id.
-    configurable: { ...sanitizeConfigurable(kwargs.config?.configurable), thread_id: threadId },
+    // Drop server-owned keys from the client's configurable, force this thread's id, then stamp the
+    // authenticated caller so the graph can authorize off `configurable.langgraph_auth_user`.
+    configurable: withAuthUser(
+      { ...sanitizeConfigurable(kwargs.config?.configurable), thread_id: threadId },
+      kwargs.auth_user,
+      kwargs.auth_scopes
+    ),
     streamMode: normalizeModes(kwargs.stream_mode),
     signal
   };
@@ -717,7 +742,12 @@ function describeInterrupts(snapshot) {
 // src/runs/run-engine.ts
 async function resolveGraph(deps, graphId, kwargs) {
   const resolved = await deps.graphs.load(graphId);
-  const graph = typeof resolved === "function" ? await resolved({ configurable: kwargs.config?.configurable }) : resolved;
+  const graph = typeof resolved === "function" ? (
+    // Expose the authenticated caller to a graph *factory* too, so a factory that branches on the
+    // principal sees the same `langgraph_auth_user` a node reads — sanitized identically, so a
+    // client can't spoof it via its own configurable.
+    await resolved({ configurable: toFactoryConfigurable(kwargs) })
+  ) : resolved;
   graph.checkpointer = deps.checkpointer;
   graph.store = new SkeinBaseStore(deps.store.store);
   return graph;
@@ -855,7 +885,7 @@ async function executeRun(deps, exec) {
 }
 
 // src/runs/run-service.ts
-function toKwargs(input) {
+function toKwargs(input, authUser, authScopes) {
   const kwargs = {};
   if (input.input !== void 0) kwargs.input = input.input;
   if (input.command !== void 0) kwargs.command = input.command;
@@ -864,10 +894,14 @@ function toKwargs(input) {
   if (input.stream_mode !== void 0) kwargs.stream_mode = input.stream_mode;
   if (input.interrupt_before !== void 0) kwargs.interrupt_before = input.interrupt_before;
   if (input.interrupt_after !== void 0) kwargs.interrupt_after = input.interrupt_after;
+  if (authUser !== void 0) {
+    kwargs.auth_user = authUser;
+    if (authScopes !== void 0) kwargs.auth_scopes = authScopes;
+  }
   return kwargs;
 }
 function createRunService(ctx) {
-  const { deps, control, locks } = ctx;
+  const { deps, control, locks, authUser, authScopes } = ctx;
   const requireThread = async (threadId) => {
     const thread = await deps.store.threads.get(threadId);
     if (!thread) throw SkeinHttpError5.notFound(`Thread "${threadId}" not found.`);
@@ -931,7 +965,7 @@ function createRunService(ctx) {
     async createWait(input) {
       const assistant = await requireAssistant(input.assistant_id);
       const thread = await ensureThread(input.thread_id);
-      const kwargs = toKwargs(input);
+      const kwargs = toKwargs(input, authUser, authScopes);
       const run = await createPendingRun(input, thread.thread_id, assistant.assistant_id, kwargs);
       await stampGraphOnThread(thread, assistant);
       const outcome = await runInline(run, kwargs);
@@ -940,7 +974,7 @@ function createRunService(ctx) {
     async createStream(input) {
       const assistant = await requireAssistant(input.assistant_id);
       const thread = await ensureThread(input.thread_id);
-      const kwargs = toKwargs(input);
+      const kwargs = toKwargs(input, authUser, authScopes);
       const run = await createPendingRun(input, thread.thread_id, assistant.assistant_id, kwargs);
       await stampGraphOnThread(thread, assistant);
       void runInline(run, kwargs).catch(
@@ -951,7 +985,7 @@ function createRunService(ctx) {
     async createBackground(threadId, input) {
       const assistant = await requireAssistant(input.assistant_id);
       const thread = await requireThread(threadId);
-      const kwargs = toKwargs(input);
+      const kwargs = toKwargs(input, authUser, authScopes);
       const run = await createPendingRun(
         { ...input, thread_id: threadId },
         threadId,
@@ -1410,7 +1444,7 @@ var STUDIO_USER = {
 };
 function createAuthorizingHandlers(context, engine) {
   const baseHandlers = createProtocolHandlers(buildProtocolService(context));
-  const names = Object.keys(baseHandlers);
+  const names = Object.keys(ROUTE_AUTHZ);
   const resolveAuthContext = async (req) => {
     if (!engine.studioAuthDisabled && req.headers["x-auth-scheme"] === "langsmith") {
       return { user: STUDIO_USER, scopes: [] };
@@ -1428,13 +1462,17 @@ function createAuthorizingHandlers(context, engine) {
         value: authValue(req),
         context: authContext
       });
-      if (!filters) return baseHandlers[name](req);
-      const scopedStore = createAuthScopedStore(context.deps.store, engine, filters, route.resource);
-      const scopedContext = {
+      if (!filters && !authContext) return baseHandlers[name](req);
+      const requestContext = {
         ...context,
-        deps: { ...context.deps, store: scopedStore }
+        authUser: authContext?.user,
+        authScopes: authContext?.scopes,
+        deps: filters ? {
+          ...context.deps,
+          store: createAuthScopedStore(context.deps.store, engine, filters, route.resource)
+        } : context.deps
       };
-      return createProtocolHandlers(buildProtocolService(scopedContext))[name](req);
+      return createProtocolHandlers(buildProtocolService(requestContext))[name](req);
     };
   }
   return wrapped;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skein-js/agent-protocol",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Framework-agnostic Agent Protocol engine for LangGraph.js — run engine, handlers, and SSE, driven entirely by injected dependencies.",
   "license": "Apache-2.0",
   "author": "Maina Wycliffe <wmmaina7@gmail.com>",
@@ -44,14 +44,14 @@
   },
   "dependencies": {
     "zod": "^3.25.76",
-    "@skein-js/core": "0.4.0"
+    "@skein-js/core": "0.5.0"
   },
   "peerDependencies": {
     "@langchain/langgraph": "^1.4.0",
     "@langchain/langgraph-sdk": "^1.9.0"
   },
   "devDependencies": {
-    "@skein-js/storage-memory": "0.4.0"
+    "@skein-js/storage-memory": "0.5.0"
   },
   "publishConfig": {
     "access": "public"