langgraph-api 0.4.46__tar.gz → 0.4.48__tar.gz

{langgraph_api-0.4.46 → langgraph_api-0.4.48}/Makefile

@@ -210,13 +210,14 @@ start-js-server:
 	$(MAKE) start-go-server
 	@trap '$(MAKE) -C $(CURDIR) stop-go-server' INT TERM EXIT; \
 	echo "Installing JS server dependencies..."; \
-	cd ../public-api-server-js && npm install; \
+	cd ../public-api-server-js && yarn install; \
 	echo "Building JS server..."; \
-	cd ../public-api-server-js && npm run build; \
+	cd ../public-api-server-js && yarn run build; \
 	echo "Starting JS server on port 9123..."; \
 	cd ../public-api-server-js && FF_USE_CORE_API=true \
 	LANGSERVE_GRAPHS=$(LANGSERVE_GRAPHS_ALL) \
-	PORT=9123 npm start
+	LANGGRAPH_CONFIG='{"agent": {"configurable": {"model_name": "openai"}}}' \
+	PORT=9123 yarn start
 
 VERSION_KIND ?= patch
 

{langgraph_api-0.4.46 → langgraph_api-0.4.48}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.4.46
+Version: 0.4.48
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: cloudpickle>=3.0.0
 Requires-Dist: cryptography<45.0,>=42.0.0
-Requires-Dist: grpcio-tools<2.0.0,>=1.75.0
+Requires-Dist: grpcio-tools==1.75.1
 Requires-Dist: grpcio<2.0.0,>=1.75.0
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0

{langgraph_api-0.4.46 → langgraph_api-0.4.48}/benchmark/Makefile

@@ -18,7 +18,7 @@ benchmark-burst:
 
 benchmark-ramp:
 	make benchmark-reset
-	k6 run --out json=raw_data_$(shell date +%Y-%m-%dT%H-%M-%S).json ramp.js
+	k6 run --out json=raw_data_$(shell date +%Y-%m-%dT%H-%M-%S).json --system-tags=[] ramp.js
 
 benchmark-capacity:
 	rm -f capacity_summary_t*.json capacity_report_*.json capacity_raw_t*.json capacity_hist_*.png capacity_pie_*.png

langgraph_api-0.4.48/benchmark/benchmark-runners/assistant.js

@@ -0,0 +1,84 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+import http from 'k6/http';
+import { check } from 'k6';
+// Uses crypto which is globally available in k6: https://grafana.com/docs/k6/latest/javascript-api/#crypto
+
+export class Assistant extends BenchmarkRunner {
+    /**
+     * Create an assistant, search for it, get it, patch it, get it again, count the number of assistants, delete the assistant
+     */
+    static run(baseUrl, requestParams) {
+        const graph_id = 'benchmark';
+        let metadata = { description: `Test benchmark assistant ${crypto.randomUUID()}` };
+
+        // Create an assistant
+        const createPayload = JSON.stringify({ graph_id, metadata });
+        const createResponse = http.post(`${baseUrl}/assistants`, createPayload, requestParams);
+        const assistantId = createResponse.json().assistant_id;
+
+        // Search for the assistant
+        const searchPayload = JSON.stringify({ graph_id, metadata, limit: 1 });
+        const searchResponse = http.post(`${baseUrl}/assistants/search`, searchPayload, requestParams);
+
+        // Get the assistant
+        const getResponse = http.get(`${baseUrl}/assistants/${assistantId}`, requestParams);
+
+        // Patch the assistant
+        metadata = { description: `Test benchmark assistant ${crypto.randomUUID()}` };
+        const patchPayload = JSON.stringify({ metadata });
+        const patchResponse = http.patch(`${baseUrl}/assistants/${assistantId}`, patchPayload, requestParams);
+
+        // Get the assistant again
+        const getResponse2 = http.get(`${baseUrl}/assistants/${assistantId}`, requestParams);
+
+        // Count the number of assistants
+        const countPayload = JSON.stringify({ graph_id, metadata });
+        const countResponse = http.post(`${baseUrl}/assistants/count`, countPayload, requestParams);
+
+        // Delete the assistant
+        http.del(`${baseUrl}/assistants/${assistantId}`, requestParams);
+        return {
+            assistantId,
+            searchResponse,
+            getResponse,
+            patchResponse,
+            getResponse2,
+            countResponse,
+        };
+    }
+
+    static validate(result, errorMetrics, benchmarkGraphOptions) {
+        let success = false;
+        try {
+            success = check(result, {
+                'Search response contains a single assistant': (r) => r.searchResponse.json().length === 1,
+                'Search response contains the correct assistant': (r) => r.searchResponse.json()[0].assistant_id === result.assistantId,
+                'Get response contains the correct assistant': (r) => r.getResponse.json().assistant_id === result.assistantId,
+                'Patch response contains the correct assistant': (r) => r.patchResponse.json().assistant_id === result.assistantId,
+                'Get response 2 contains the correct assistant': (r) => r.getResponse2.json().assistant_id === result.assistantId,
+                'Get response 2 contains the new description': (r) => r.getResponse2.json().metadata.description != result.getResponse.json().metadata.description && result.getResponse2.json().metadata.description === result.patchResponse.json().metadata.description,
+                'Count response contains the correct number of assistants': (r) => parseInt(r.countResponse.json()) === 1,
+            });
+        } catch (error) {
+            console.log(`Unknown error checking response: ${error.message}`);
+        }
+
+        if (!success) {
+            if (result.searchResponse.status >= 500 || result.getResponse.status >= 500 || result.patchResponse.status >= 500 || result.getResponse2.status >= 500 || result.countResponse.status >= 500) {
+                errorMetrics.server_errors.add(1);
+                console.log(`Server error: ${result.searchResponse.status}, ${result.getResponse.status}, ${result.patchResponse.status}, ${result.getResponse2.status}, ${result.countResponse.status}`);
+            } else if (result.searchResponse.status === 408 || result.getResponse.status === 408 || result.patchResponse.status === 408 || result.getResponse2.status === 408 || result.countResponse.status === 408) {
+                errorMetrics.timeout_errors.add(1);
+                console.log(`Timeout error: ${result.searchResponse.error}, ${result.getResponse.error}, ${result.patchResponse.error}, ${result.getResponse2.error}, ${result.countResponse.error}`);
+            } else {
+                errorMetrics.other_errors.add(1);
+                console.log(`Other error: ${result.searchResponse.body}, ${result.getResponse.body}, ${result.patchResponse.body}, ${result.getResponse2.body}, ${result.countResponse.body}`);
+            }
+        }
+        return success;
+    }
+
+    static toString() {
+        return 'assistants';
+    }
+}

langgraph_api-0.4.48/benchmark/benchmark-runners/benchmark-runner.js

@@ -0,0 +1,34 @@
+/**
+ * Abstract class for running a benchmark type.
+ */
+export class BenchmarkRunner {
+    /**
+     * Run the benchmark type.
+     * @param {string} baseUrl - The base URL of the LangGraph server.
+     * @param {any} requestParams - The parameters to use for the request. Includes headers and other config like timeout.
+     * @param {any} benchmarkGraphOptions - The options for the benchmark graph.
+     * @returns {any} - The result of the benchmark type. This format will vary by benchmark type.
+     */
+    static run(baseUrl, requestParams, benchmarkGraphOptions) {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Convert the benchmark name to a string.
+     * @returns {string} - A string representation of the benchmark name.
+     */
+    static toString() {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Validate the result of the benchmark run.
+     * @param {any} result - The result of the benchmark run. This format will vary by benchmark type.
+     * @param {any} errorMetrics - A dictionary of error metrics that can be used to more granularly track errors.
+     * @param {any} benchmarkGraphOptions - The options for the benchmark graph.
+     * @returns {boolean} - True if the benchmark run was successful, false otherwise.
+     */
+    static validate(result, errorMetrics, benchmarkGraphOptions) {
+        throw new Error('Not implemented');
+    }
+}

langgraph_api-0.4.48/benchmark/benchmark-runners/benchmarks.js

@@ -0,0 +1,18 @@
+import { WaitWrite } from './wait_write.js';
+import { StreamWrite } from './stream_write.js';
+import { Assistant } from './assistant.js';
+
+export class Benchmarks {
+    static getRunner(type) {
+        switch (type) {
+            case WaitWrite.toString():
+                return WaitWrite;
+            case StreamWrite.toString():
+                return StreamWrite;
+            case Assistant.toString():
+                return Assistant;
+            default:
+                throw new Error(`Unknown benchmark type: ${type}`);
+        }
+    }
+}

langgraph_api-0.4.48/benchmark/benchmark-runners/stream_write.js

@@ -0,0 +1,98 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+import { check } from 'k6';
+import http from 'k6/http';
+
+function parseSSE(text) {
+    const events = [];
+    const lines = text.split('\r\n');
+    let currentEvent = { event: '', data: '' };
+    
+    for (const line of lines) {
+        if (line.startsWith('event:')) {
+            currentEvent.event = line.substring(6).trim();
+        } else if (line.startsWith('data:')) {
+            const dataContent = line.substring(5).trim();
+            currentEvent.data = dataContent;
+        } else if (line === '') {
+            // Empty line marks end of event
+            if (currentEvent.data) {
+                try {
+                    events.push({
+                        event: currentEvent.event,
+                        data: JSON.parse(currentEvent.data)
+                    });
+                } catch (e) {
+                    // Some events might not be JSON
+                    events.push(currentEvent);
+                }
+            }
+            currentEvent = { event: '', data: '' };
+        }
+    }
+    
+    return events;
+}
+
+export class StreamWrite extends BenchmarkRunner {
+    static run(baseUrl, requestParams, benchmarkGraphOptions) {
+        let url = `${baseUrl}/runs/stream`;
+
+        // Create a payload with the LangGraph agent configuration
+        const payload = JSON.stringify({
+            assistant_id: benchmarkGraphOptions.graph_id,
+            input: benchmarkGraphOptions.input,
+            config: {
+                recursion_limit: benchmarkGraphOptions.input.expand + 2,
+            },
+        });
+
+        // If the request is stateful, create a thread first and use it in the url
+        if (benchmarkGraphOptions.stateful) {
+            const thread = http.post(`${baseUrl}/threads`, "{}", requestParams);
+            const threadId = thread.json().thread_id;
+            url = `${baseUrl}/threads/${threadId}/runs/stream`;
+        }
+
+        const response = http.post(url, payload, requestParams);
+        const events = parseSSE(response.body);
+        return { events, response };
+    }
+
+    static validate(result, errorMetrics, benchmarkGraphOptions) {
+        const expected_messages = benchmarkGraphOptions.input.mode === 'single' ? 1 : benchmarkGraphOptions.input.expand + 1;
+        const expected_events = expected_messages + 2; // +2 for the metadata and initial values event
+        let success = false;
+        try {
+            success = check(result, {
+                'Run completed successfully': (r) => r.response.status === 200,
+                'Response contains expected number of events': (r) => r.events.length === expected_events,
+                'Response contains metadata event': (r) => r.events[0].event === 'metadata',
+                'Response contains expected number of messages': (r) => r.events[expected_events - 1].data.messages.length === expected_messages,
+            });
+        } catch (error) {
+            console.log(`Unknown error checking result: ${error.message}`);
+        }
+
+        if (!success) {
+            // Classify error based on status code or response
+            if (result.response.status >= 500) {
+                errorMetrics.server_errors.add(1);
+                console.log(`Server error: ${result.response.status}`);
+            } else if (result.response.status === 408 || result.response.error?.includes('timeout')) {
+                errorMetrics.timeout_errors.add(1);
+                console.log(`Timeout error: ${result.response.error}`);
+            } else if (result.response.status === 200 && result.events[expected_events - 1].data.messages.length !== expected_messages) {
+                errorMetrics.missing_message_errors.add(1);
+                console.log(`Missing message error: Status ${result.response.status}, ${JSON.stringify(result.response.body)}, ${result.response.headers?.['Content-Location']}`);
+            } else {
+                errorMetrics.other_errors.add(1);
+                console.log(`Other error: Status ${result.response.status}, ${JSON.stringify(result.response.body)}, ${result.events}`);
+            }
+        }
+        return success;
+    }
+
+    static toString() {
+        return 'stream_write';
+    }
+}

langgraph_api-0.4.48/benchmark/benchmark-runners/wait_write.js

@@ -0,0 +1,65 @@
+import { BenchmarkRunner } from './benchmark-runner.js';
+import http from 'k6/http';
+import { check } from 'k6';
+
+export class WaitWrite extends BenchmarkRunner {
+    static run(baseUrl, requestParams, benchmarkGraphOptions) {
+        let url = `${baseUrl}/runs/wait`;
+
+        // Create a payload with the LangGraph agent configuration
+        const payload = JSON.stringify({
+            assistant_id: benchmarkGraphOptions.graph_id,
+            input: benchmarkGraphOptions.input,
+            config: {
+                recursion_limit: benchmarkGraphOptions.input.expand + 2,
+            },
+        });
+
+        // If the request is stateful, create a thread first and use it in the url
+        if (benchmarkGraphOptions.stateful) {
+            const thread = http.post(`${baseUrl}/threads`, "{}", requestParams);
+            const threadId = thread.json().thread_id;
+            url = `${baseUrl}/threads/${threadId}/runs/wait`;
+        }
+
+        // Make a single request to the wait endpoint
+        const result = http.post(url, payload, requestParams);
+
+        return result;
+    }
+
+    static validate(result, errorMetrics, benchmarkGraphOptions) {
+        const expected_length = benchmarkGraphOptions.input.mode === 'single' ? 1 : benchmarkGraphOptions.input.expand + 1;
+        let success = false;
+        try {
+            success = check(result, {
+                'Run completed successfully': (r) => r.status === 200,
+                'Response contains expected number of messages': (r) => r.json().messages?.length === expected_length,
+            });
+        } catch (error) {
+            console.log(`Unknown error checking result: ${error.message}`);
+        }
+
+        if (!success) {
+            // Classify error based on status code or response
+            if (result.status >= 500) {
+                errorMetrics.server_errors.add(1);
+                console.log(`Server error: ${result.status}`);
+            } else if (result.status === 408 || result.error?.includes('timeout')) {
+                errorMetrics.timeout_errors.add(1);
+                console.log(`Timeout error: ${result.error}`);
+            } else if (result.status === 200 && result.json().messages?.length !== expected_length) {
+                errorMetrics.missing_message_errors.add(1);
+                console.log(`Missing message error: Status ${result.status}, ${JSON.stringify(result.body)}, ${result.headers?.['Content-Location']}`);
+            } else {
+                errorMetrics.other_errors.add(1);
+                console.log(`Other error: Status ${result.status}, ${JSON.stringify(result.body)}`);
+            }
+        }
+        return success;
+    }
+
+    static toString() {
+        return 'wait_write';
+    }
+}

{langgraph_api-0.4.46 → langgraph_api-0.4.48}/benchmark/ramp.js

@@ -1,7 +1,7 @@
-import http from 'k6/http';
-import { check, sleep } from 'k6';
+import { sleep } from 'k6';
 import { Counter, Trend } from 'k6/metrics';
 import { randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';
+import { Benchmarks } from './benchmark-runners/benchmarks.js';
 
 // Custom metrics
 const runDuration = new Trend('run_duration');
@@ -13,6 +13,14 @@ const serverErrors = new Counter('server_errors');
 const missingMessageErrors = new Counter('missing_message_errors');
 const otherErrors = new Counter('other_errors');
 
+const errorMetrics = {
+  timeout_errors: timeoutErrors,
+  connection_errors: connectionErrors,
+  server_errors: serverErrors,
+  missing_message_errors: missingMessageErrors,
+  other_errors: otherErrors,
+}
+
 // URL of your LangGraph server
 const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
 // LangSmith API key only needed with a custom server endpoint
@@ -22,6 +30,7 @@ const LANGSMITH_API_KEY = __ENV.LANGSMITH_API_KEY;
 const LOAD_SIZE = parseInt(__ENV.LOAD_SIZE || '500');
 const LEVELS = parseInt(__ENV.LEVELS || '2');
 const PLATEAU_DURATION = parseInt(__ENV.PLATEAU_DURATION || '300');
+const BENCHMARK_TYPE = __ENV.BENCHMARK_TYPE || 'wait_write';
 const STATEFUL = __ENV.STATEFUL === 'true';
 
 // Params for the agent
@@ -61,94 +70,53 @@ export let options = {
   },
 };
 
+const runner = Benchmarks.getRunner(BENCHMARK_TYPE);
+
+const benchmarkGraphOptions = {
+  graph_id: "benchmark",
+  input: {
+    data_size: DATA_SIZE,
+    delay: DELAY,
+    expand: EXPAND,
+    mode: MODE,
+  },
+  stateful: STATEFUL,
+}
+
 // Main test function
 export default function() {
   const startTime = new Date().getTime();
-  let response;
 
-  try {
-    // Prepare the request payload
-    const headers = { 'Content-Type': 'application/json' };
-    if (LANGSMITH_API_KEY) {
-      headers['x-api-key'] = LANGSMITH_API_KEY;
-    }
+  // Prepare the request payload
+  const headers = { 'Content-Type': 'application/json' };
+  if (LANGSMITH_API_KEY) {
+    headers['x-api-key'] = LANGSMITH_API_KEY;
+  }
+  const requestParams = {
+    headers,
+    timeout: '120s',  // k6 request timeout slightly longer than the server timeout
+  };
 
-    // Create a payload with the LangGraph agent configuration
-    const payload = JSON.stringify({
-        assistant_id: "benchmark",
-        input: {
-          data_size: DATA_SIZE,
-          delay: DELAY,
-          expand: EXPAND,
-          mode: MODE,
-        },
-        config: {
-          recursion_limit: EXPAND + 2,
-        },
-    });
-
-    // If the request is stateful, create a thread first and use it in the url
-    let url = `${BASE_URL}/runs/wait`;
-    if (STATEFUL) {
-      const thread = http.post(`${BASE_URL}/threads`, payload, {
-        headers,
-        timeout: '120s'  // k6 request timeout slightly longer than the server timeout
-      });
-      const threadId = thread.json().thread_id;
-      url = `${BASE_URL}/threads/${threadId}/runs/wait`;
-    }
+  let result;
+  try {
+    result = runner.run(BASE_URL, requestParams, benchmarkGraphOptions);
+  } catch (error) {
+    failedRuns.add(1);
+    otherErrors.add(1);
+    console.log(`Unknown error running benchmark: ${error.message}`);
+  }
 
-    // Make a single request to the wait endpoint
-    response = http.post(url, payload, {
-      headers,
-      timeout: '120s'  // k6 request timeout slightly longer than the server timeout
-    });
-
-    // Don't include verification in the duration of the request
-    const duration = new Date().getTime() - startTime;
-
-    // Check the response
-    const expected_length = MODE === 'single' ? 1 : EXPAND + 1;
-    let success = false;
-    try {
-      success = check(response, {
-        'Run completed successfully': (r) => r.status === 200,
-        'Response contains expected number of messages': (r) => JSON.parse(r.body)?.messages?.length === expected_length,
-      });
-    } catch (error) {
-      console.log(`Error checking response: ${error}`);
-    }
+  // Don't include verification in the duration of the request
+  const duration = new Date().getTime() - startTime;
 
+  let success = runner.validate(result, errorMetrics, benchmarkGraphOptions);
 
-    if (success) {
-      // Record success metrics
-      runDuration.add(duration);
-      successfulRuns.add(1);
-    } else {
-      // Handle failure
-      failedRuns.add(1);
-
-      // Classify error based on status code or response
-      if (response.status >= 500) {
-        serverErrors.add(1);
-        console.log(`Server error: ${response.status}`);
-      } else if (response.status === 408 || response.error?.includes('timeout')) {
-        timeoutErrors.add(1);
-        console.log(`Timeout error: ${response.error}`);
-      } else if (response.status === 200 && response.body?.messages?.length !== expected_length) {
-        missingMessageErrors.add(1);
-        console.log(`Missing message error: Status ${response.status}, ${JSON.stringify(response.body)}, ${response.headers?.['Content-Location']}`);
-      } else {
-        otherErrors.add(1);
-        console.log(`Other error: Status ${response.status}, ${JSON.stringify(response.body)}`);
-      }
-    }
-  } catch (error) {
-    // Handle truly unexpected errors
+  if (success) {
+    runDuration.add(duration);
+    successfulRuns.add(1);
+  } else {
+    // Don't log the duration for failed runs
     failedRuns.add(1);
-    otherErrors.add(1);
-    console.log(response);
-    console.log(`Unexpected error: ${error.message}, Response Body: ${response?.body}`);
   }
 
   // Add a small random sleep between iterations to prevent thundering herd

langgraph_api-0.4.48/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.48"

{langgraph_api-0.4.46 → langgraph_api-0.4.48}/langgraph_api/api/threads.py

@@ -5,6 +5,8 @@ from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 
+from langgraph_api.feature_flags import FF_USE_CORE_API
+from langgraph_api.grpc_ops.ops import Threads as GrpcThreads
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
 from langgraph_api.schema import THREAD_FIELDS, ThreadStreamMode
 from langgraph_api.sse import EventSourceResponse
@@ -30,6 +32,8 @@ from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Threads
 from langgraph_runtime.retry import retry_db
 
+CrudThreads = GrpcThreads if FF_USE_CORE_API else Threads
+
 
 @retry_db
 async def create_thread(
@@ -41,7 +45,7 @@ async def create_thread(
         validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
         thread_id = thread_id or str(uuid4())
-        iter = await Threads.put(
+        iter = await CrudThreads.put(
             conn,
             thread_id,
             metadata=payload.get("metadata"),
@@ -78,7 +82,7 @@ async def search_threads(
     limit = int(payload.get("limit") or 10)
     offset = int(payload.get("offset") or 0)
     async with connect() as conn:
-        threads_iter, next_offset = await Threads.search(
+        threads_iter, next_offset = await CrudThreads.search(
             conn,
             status=payload.get("status"),
             values=payload.get("values"),
@@ -103,7 +107,7 @@ async def count_threads(
     """Count threads."""
     payload = await request.json(ThreadCountRequest)
     async with connect() as conn:
-        count = await Threads.count(
+        count = await CrudThreads.count(
             conn,
             status=payload.get("status"),
             values=payload.get("values"),
@@ -277,7 +281,7 @@ async def get_thread(
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
-        thread = await Threads.get(conn, thread_id)
+        thread = await CrudThreads.get(conn, thread_id)
     return ApiResponse(await fetchone(thread))
 
 
@@ -290,7 +294,7 @@ async def patch_thread(
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     payload = await request.json(ThreadPatch)
     async with connect() as conn:
-        thread = await Threads.patch(
+        thread = await CrudThreads.patch(
             conn,
             thread_id,
             metadata=payload.get("metadata", {}),
@@ -305,7 +309,7 @@ async def delete_thread(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
-        tid = await Threads.delete(conn, thread_id)
+        tid = await CrudThreads.delete(conn, thread_id)
     await fetchone(tid)
     return Response(status_code=204)
 
@@ -314,7 +318,7 @@ async def delete_thread(request: ApiRequest):
 async def copy_thread(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     async with connect() as conn:
-        iter = await Threads.copy(conn, thread_id)
+        iter = await CrudThreads.copy(conn, thread_id)
     return ApiResponse(await fetchone(iter, not_found_code=409))
 
 

{langgraph_api-0.4.46 → langgraph_api-0.4.48}/langgraph_api/cli.py

@@ -8,12 +8,10 @@ import typing
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
-from typing_extensions import TypedDict
-
 if typing.TYPE_CHECKING:
     from packaging.version import Version
 
-    from langgraph_api.config import HttpConfig, StoreConfig
+    from langgraph_api.config import AuthConfig, HttpConfig, StoreConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -81,51 +79,6 @@ def patch_environment(**kwargs):
                 os.environ[key] = value
 
 
-class SecurityConfig(TypedDict, total=False):
-    securitySchemes: dict
-    security: list
-    # path => {method => security}
-    paths: dict[str, dict[str, list]]
-
-
-class CacheConfig(TypedDict, total=False):
-    cache_keys: list[str]
-    ttl_seconds: int
-    max_size: int
-
-
-class AuthConfig(TypedDict, total=False):
-    path: str
-    """Path to the authentication function in a Python file."""
-    disable_studio_auth: bool
-    """Whether to disable auth when connecting from the LangSmith Studio."""
-    openapi: SecurityConfig
-    """The schema to use for updating the openapi spec.
-
-    Example:
-        {
-            "securitySchemes": {
-                "OAuth2": {
-                    "type": "oauth2",
-                    "flows": {
-                        "password": {
-                            "tokenUrl": "/token",
-                            "scopes": {
-                                "me": "Read information about the current user",
-                                "items": "Access to create and manage items"
-                            }
-                        }
-                    }
-                }
-            },
-            "security": [
-                {"OAuth2": ["me"]}  # Default security requirement for all endpoints
-            ]
-        }
-    """
-    cache: CacheConfig | None
-
-
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -141,7 +94,7 @@ def run_server(
     reload_includes: Sequence[str] | None = None,
     reload_excludes: Sequence[str] | None = None,
     store: typing.Optional["StoreConfig"] = None,
-    auth: AuthConfig | None = None,
+    auth: typing.Optional["AuthConfig"] = None,
     http: typing.Optional["HttpConfig"] = None,
     ui: dict | None = None,
     ui_config: dict | None = None,