>'hd UdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZddlZddlZddlmZddlZddlmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;mZ?dZ@d6d7d ZA d8d ZBd9d ZCddddd  d:dZDGdd ZEGddZFd;dZGdd/ZXgZYd0eZd1<d?d2Z[ejd34d@d5Z]eee^e_ee^ee^ee^ee^fejfZay)AaThe LangGraph client implementations connect to the LangGraph API. This module provides both asynchronous ([get_client(url="http://localhost:2024"))](#get_client) or [LangGraphClient](#LangGraphClient)) and synchronous ([get_sync_client(url="http://localhost:2024"))](#get_sync_client) or [SyncLanggraphClient](#SyncLanggraphClient)) clients to interacting with the LangGraph API's core resources such as Assistants, Threads, Runs, and Cron jobs, as well as its persistent document Store. ) annotationsN) Any AsyncIteratorDictIteratorListLiteralOptionalSequenceTypeUnionoverload)QueryParamTypes)All AssistantAssistantSortByAssistantVersion CancelAction CheckpointCommandConfigCronDisconnectMode GraphSchema IfNotExistsItemJsonListNamespaceResponseMultitaskStrategyOnCompletionBehaviorOnConflictBehaviorRun RunCreate RunStatusSearchItemsResponse SortOrder StreamMode StreamPart SubgraphsThread ThreadSortBy ThreadState ThreadStatusThreadUpdateStateResponse) SSEDecoderaiter_lines_rawiter_lines_raw) x-api-keyc|r|SdD]L}tj|dx}s|jjdjdcSy)zGet the API key from the environment. Precedence: 1. explicit argument 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY ) LANGGRAPH LANGSMITH LANGCHAIN_API_KEY"'N)osgetenvstrip)api_keyprefixenvs [/home/kushmeetdev/Regenta/Chatbot/venv/lib/python3.12/site-packages/langgraph_sdk/client.py _get_api_keyrAMs]95))vhh/0 03 099;$$S)//4 45 c|xsi}tD]}||vstd|dddtji|}t |}|r||d<|S)z1Combine api_key and custom user-provided headers.zCannot set reserved header 'r9z User-Agentzlanggraph-sdk-py/r2)RESERVED_HEADERS ValueError langgraph_sdk __version__rA)r=custom_headersheaderheaderss r@ _get_headersrK]s$)rN"G ^ #;F81EF FG )-*C*C)DE G7#G&  NrBc8t|dr%t|jr|jSt|dr%t|jr|jSt |t t fr t|Stdt|d)N model_dumpdictzObject of type z is not JSON serializable) hasattrcallablerMrN isinstanceset frozensetlist TypeErrortype)objs r@_orjson_defaultrXqswsL!hs~~&>~~ f (388"4xxz C#y) *Cy/$s)4MNOOrB)urlr=rJtimeoutLangGraphClientc d}|gtjjddk(r*tdd}tj |d}n ddlm}d}t|d }|tjd }tj|||tj|ntjd d d d t||}t|S#t$rd }YwxYw)aGet a LangGraphClient instance. Args: url: The URL of the LangGraph API. api_key: The API key. If not provided, it will be read from the environment. Precedence: 1. explicit argument 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY headers: Optional custom headers timeout: Optional timeout configuration for the HTTP client. Accepts an httpx.Timeout instance, a float (seconds), or a tuple of timeouts. Tuple format is (connect, read, write, pool) If not provided, defaults to connect=5s, read=300s, write=300s, and pool=5s. Returns: LangGraphClient: The top-level client for accessing AssistantsClient, ThreadsClient, RunsClient, and CronClient. ???+ example "Example" ```python from langgraph_sdk import get_client # get top-level LangGraphClient client = get_client(url="http://localhost:8123") # example usage: client..() assistants = await client.assistants.get(assistant_id="some_uuid") ``` N$__LANGGRAPH_DEFER_LOOPBACK_TRANSPORTtruez/noauth)app root_pathz http://apir)r_)r`http://localhost:8123retries,connectreadwritepoolbase_url transportrZrJ)r:environgetget_asgi_transport_registered_transportsappendlanggraph_api.serverr_ ExceptionhttpxAsyncHTTPTransport AsyncClientTimeoutrKr[)rYr=rJrZrmr_clients r@ get_clientrz|sP59I { ::>>@ AV K,*,KI " ) )) 4C .4"0.0 J ,,Q7   " MM' "qs#AFWg. F 6 "" .- .sC C.-C.ceZdZdZddZy)r[aTop-level client for LangGraph API. Attributes: assistants: Manages versioned configuration for your graphs. threads: Handles (potentially) multi-turn interactions, such as conversational threads. runs: Controls individual invocations of the graph. crons: Manages scheduled operations. store: Interfaces with persistent, shared data storage. c(t||_t|j|_t |j|_t |j|_t|j|_ t|j|_ yN) HttpClienthttpAssistantsClient assistants ThreadsClientthreads RunsClientruns CronClientcrons StoreClientstoreselfrys r@__init__zLangGraphClient.__init__s^v& *4995$TYY/ tyy)  *  + rBNryzhttpx.AsyncClientreturnNone__name__ __module__ __qualname____doc__rrBr@r[r[s ,rBceZdZdZddZddd ddZdd ddZdd ddZdd dd Zddd  dd Z dddd  dd Z y)r~zHandle async requests to the LangGraph API. Adds additional error messaging & content handling above the provided httpx client. Attributes: client (httpx.AsyncClient): Underlying HTTPX async client. c||_yr}ryrs r@rzHttpClient.__init__  rBNparamsrJcK|jj|||d{} |jt|d{S7(#tj$rn}|j d{7j }tjdk\r|j||tjd|||d}~wwxYw7w)Send a GET request.rN Error from langgraph-api: exc_info) ryroraise_for_statusruHTTPStatusErrorareaddecodesys version_infoadd_noteloggererror _adecode_jsonrpathrrJrebodys r@rozHttpClient.gets++//$vw/G G    #1%%% H$$ '')OO++-D7* 4 G 9$@1 MG  &sJ"CA CACC CC"C 5A86AC  CCrJcK|t|d{\}}nid}}|r|j||jj|||d{} |j t|d{S7i7*#t j $rn}|jd{7j}tjdk\r|j||tjd|||d}~wwxYw7wzSend a POST request.NrBrJcontentrrr) _aencode_jsonupdaterypostrrurrrrrrrrr rrjsonrJrequest_headersrrrrs r@rzHttpClient.posts  -:4-@'@ $OW')3WO   " "7 +++""4'"R R    #1%%%!(A S$$ '')OO++-D7* 4 G 9$@1 MG  &s_DA=ADA?DB*D8D9D?DDC='B*(AC==DDcKt|d{\}}|r|j||jj|||d{} |j t|d{S7d7*#t j $rn}|jd{7j}tjdk\r|j||tjd|||d}~wwxYw7w)Send a PUT request.Nrrrr)rrryputrrurrrrrrrrrrs r@rzHttpClient.puts*7t)<#<    " "7 +++//$/Q Q    #1%%%$= R$$ '')OO++-D7* 4 G 9$@1 MG  &^DA6;D A8DA:#D1C>2D8D:C; C6 B#!AC66C;;DcKt|d{\}}|r|j||jj|||d{} |j t|d{S7d7*#t j $rn}|jd{7j}tjdk\r|j||tjd|||d}~wwxYw7w)Send a PATCH request.Nrrrr)rrrypatchrrurrrrrrrrrrs r@rzHttpClient.patch&s*7t)<#<    " "7 +++##D/7#S S    #1%%%$= T$$ '')OO++-D7* 4 G 9$@1 MG  &rrrJcK|jjd|||d{} |jy7#tj$rn}|j d{7j }tjdk\r|j||tjd|||d}~wwxYww)Send a DELETE request.DELETErNrrr) ryrequestrrurrrrrrrrrrrrJrrrs r@deletezHttpClient.delete9s++%%h4%Q Q     R$$ '')OO++-D7* 4 G 9$@1 MG  s;#C<C>CB?B:$A'%AB::B??CrrrJclKt|d{\}}d|d<d|d<|r|j||jj|||||4d{} |j |jjd d j!d d } d| vrt j"d| t%} t'|23d{} | j| j)d}|-|377#t j $rn} |jd{7j} tjdk\r| j| | tjd| | | d} ~ wwxYw76dddd{7y#1d{7swYyxYww)zStream results using SSE.Ntext/event-streamAcceptno-store Cache-ControlrJrrrrr content-type;rJExpected response header Content-Type to contain 'text/event-stream', got  )line)rrrystreamrrurrrrrrrrrJro partitionTransportErrorr/r0rstriprrmethodrrrJrrresrr content_typedecoderrsses r@rzHttpClient.streamLs*7t)<#< $7!+5(   " "7 +;;%% D/76&     $$&;;??>2>HHMaPL",6**'*, !lG-c2  dnn$++e*=0.0.45 Returns: Assistant: The created assistant. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant = await client.assistants.create( graph_id="agent", config={"configurable": {"model_name": "openai"}}, metadata={"number":1}, assistant_id="my-assistant-id", if_exists="do_nothing", name="my_name" ) ``` graph_idconfigrrrrr /assistantsrNrr rrrrrrrrJrpayloads r@createzAssistantsClient.creates\ #   &GH  "*GJ  &2GN # #,GK "GFO %0GM "YY^^M^QQQQsAAAArrrrrJrcKi}|r||d<|r||d<|r||d<|r||d<|r||d<|jjd|||d{S7w) aUpdate an assistant. Use this to point to a different graph, update the configuration, or change the metadata of an assistant. Args: assistant_id: Assistant to update. graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. If None, assistant will keep pointing to same graph. config: Configuration to use for the graph. metadata: Metadata to merge with existing assistant metadata. name: The new name for the assistant. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 Returns: Assistant: The updated assistant. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant = await client.assistants.update( assistant_id='e280dad7-8618-443f-87f1-8e41841c180f', graph_id="other-graph", config={"configurable": {"model_name": "anthropic"}}, metadata={"number":2} ) ``` rrrrrrrNrr rrrrrrrJrr#s r@rzAssistantsClient.updatesT#% "*GJ   &GH  "*GJ  "GFO %0GM "YY__<. )%    A A A Ac`K|jjd||d{y7w)aDelete an assistant. Args: assistant_id: The assistant ID to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.assistants.delete( assistant_id="my_assistant_id" ) ``` rrNrrrs r@rzAssistantsClient.delete s,2iil^r#-5J)2#GJ  #,GK $ % "#9    '(k'(uuY'7'(|   %GL !YY^^JWg^NNN  %Os3/B  B"B B&(B BB BB cdK|jjd|d|i|d{S7w)a=Update a thread. Args: thread_id: ID of thread to update. metadata: Metadata to merge with existing thread metadata. headers: Optional custom headers to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") thread = await client.threads.update( thread_id="my-thread-id", metadata={"number":1}, ) ``` rWrrNr'rrYrrJs r@rzThreadsClient.update"s?6YY__ { #:x*@'%    '0.0c`K|jjd||d{y7w)aDelete a thread. Args: thread_id: The ID of the thread to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost2024) await client.threads.delete( thread_id="my_thread_id" ) ``` rWrNr+rXs r@rzThreadsClient.deleteAs,,ii9+6HHHr,r-r)rr^statusr.r/r0r1rJcK||d} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|jjd| |d {S7w) aSearch for threads. Args: metadata: Thread metadata to filter on. values: State values to filter on. status: Thread status to filter on. Must be one of 'idle', 'busy', 'interrupted' or 'error'. limit: Limit on number of threads to return. offset: Offset in threads table to start search from. sort_by: Sort by field. sort_order: Sort order. headers: Optional custom headers to include with the request. Returns: list[Thread]: List of the threads matching the search parameters. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") threads = await client.threads.search( metadata={"number":1}, status="interrupted", limit=15, offset=5 ) ``` r3rr^rkr0r1/threads/searchrNr!) rrr^rkr.r/r0r1rJr#s r@r5zThreadsClient.searchYsT#  "*GJ   &GH   &GH  !(GI  $.GL !YY^^ $    r)cbK|jjd|dd|d{S7w)aCopy a thread. Args: thread_id: The ID of the thread to copy. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) await client.threads.copy( thread_id="my_thread_id" ) ``` rW/copyNrr!rXs r@copyzThreadsClient.copys<,YY^^ {% (tW$    s &/-/F subgraphsrJc,K|r-|jjd|d||d|d{S|r.|jjd|d|d|i|d{S|jjd|d d|i|d{S7`727w) aGet the state of a thread. Args: thread_id: The ID of the thread to get the state of. checkpoint: The checkpoint to get the state of. checkpoint_id: (deprecated) The checkpoint ID to get the state of. subgraphs: Include subgraphs states. headers: Optional custom headers to include with the request. Returns: ThreadState: the thread of the state. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) thread_state = await client.threads.get_state( thread_id="my_thread_id", checkpoint_id="my_checkpoint_id" ) print(thread_state) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- { 'values': { 'messages': [ { 'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False }, { 'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None } ] }, 'next': [], 'checkpoint': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1' } 'metadata': { 'step': 1, 'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2', 'source': 'loop', 'writes': { 'agent': { 'messages': [ { 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'name': None, 'type': 'ai', 'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'example': False, 'tool_calls': [], 'usage_metadata': None, 'additional_kwargs': {}, 'response_metadata': {}, 'invalid_tool_calls': [] } ] } }, 'user_id': None, 'graph_id': 'agent', 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'created_by': 'system', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'created_at': '2024-07-25T15:35:44.184703+00:00', 'parent_config': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f' } } ``` rW/state/checkpoint checkpointrrrN/state/rrr/staterrrorrYrv checkpoint_idrrrJs r@ get_statezThreadsClient.get_statesX I;&78$.YG(  I;gm_=#Y/'  I;f-#Y/'   s3+BB/BB+B B BBBr`rvr{rJcKd|i}|r||d<|r||d<|r||d<|jjd|d||d{S7w) aUpdate the state of a thread. Args: thread_id: The ID of the thread to update. values: The values to update the state with. as_node: Update the state as if this node had just executed. checkpoint: The checkpoint to update the state of. checkpoint_id: (deprecated) The checkpoint ID to update the state of. headers: Optional custom headers to include with the request. Returns: ThreadUpdateStateResponse: Response after updating a thread's state. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) response = await client.threads.update_state( thread_id="my_thread_id", values={"messages":[{"role": "user", "content": "hello!"}]}, as_node="my_node", ) print(response) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- { 'checkpoint': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1', 'checkpoint_map': {} } } ``` r^r{rvr`rWrxrNr!rrYr^r`rvr{rJr#s r@ update_statezThreadsClient.update_state/srb f#  '4GO $ $.GL ! !(GI YY^^ {& )$    ?AAAr.beforerrvrJcKd|i}|r||d<|r||d<|r||d<|jjd|d||d{S7w) aBGet the state history of a thread. Args: thread_id: The ID of the thread to get the state history for. checkpoint: Return states for this subgraph. If empty defaults to root. limit: The maximum number of states to return. before: Return states before this checkpoint. metadata: Filter states by metadata key-value pairs. headers: Optional custom headers to include with the request. Returns: list[ThreadState]: the state history of the thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) thread_state = await client.threads.get_history( thread_id="my_thread_id", limit=5, ) ``` r.rrrvrW/historyrNr!rrYr.rrrvrJr#s r@ get_historyzThreadsClient.get_historylsrF U#   &GH  "*GJ  $.GL !YY^^ {( +'7$    rr@rYrrJrrr*rrrYrFrrJr[z7Optional[Sequence[dict[str, Sequence[dict[str, Any]]]]]rrFrJrrr*rYrrdict[str, Any]rJrrr*rYrrJrrr)rrr^rrkOptional[ThreadStatus]r.rMr/rMr0zOptional[ThreadSortBy]r1rNrJrr list[Thread]NN rYrrvOptional[Checkpoint]r{rFrrrGrJrrr,rYrr^z%Optional[Union[dict, Sequence[dict]]]r`rFrvrr{rFrJrrr.rYrr.rMrzOptional[str | Checkpoint]rrrvrrJrrzlist[ThreadState]rrrrrror$rrr5rpr|rrrrBr@rrs FJ#M#M*B#M #MP#'26NR"&,0>O>O! >O 0 >O L >O >O*>O >OJ-1   !  *    @FJII*BI I6)-*.*.,0; ;  ; ' ;  ; ; (; (; *;  ; |FJ  *B  :,0'+ }  ,0}})}% }  }*} }H"&+/'+,0; ; 6;  ; ) ; %; *;  #; B-1#'+/,0- -  - + - ! - )- *-  - rBrcbeZdZdZd'dZeddddddddddddddddddd d(dZeddddddddddddddddd d)d Zdddddddddddddddddddd  d*d Zeddddddddddddddd  d+d Zeddddddddddddddddd d,dZdddddddddddddddddd d-dZd.dZeddddddddddddddddd d/dZ eddddddddddddddd d0dZ dddddddddddddddddd d1dZ ddddd d2dZ dd d3dZ dd dd! d4d"Z dd d5d#Z dddd$ d6d%Zdd d7d&Zy)8raClient for managing runs in LangGraph. A run is a single assistant invocation with optional input, config, and metadata. This client manages runs, which can be stateful (on threads) or stateless. ???+ example "Example" ```python client = get_client(url="http://localhost:2024") run = await client.runs.create(assistant_id="asst_123", thread_id="thread_456", input={"query": "Hello"}) ``` c||_yr}rrs r@rzRunsClient.__init__rrBNr^Finputr_ stream_modestream_subgraphsrrrvr{checkpoint_duringinterrupt_beforeinterrupt_after feedback_keys on_disconnectwebhookmultitask_strategy if_not_exists after_secondsrJcyr}rrrYrrr_rrrrrvr{rrrrrrrrrrJs r@rzRunsClient.streams0%(rBrr_rrrrrrrrr on_completionrrrrJcyr}rrrYrrr_rrrrrrrrrrrrrrJs r@rzRunsClient.streams,%(rBrr_rrrrrvr{rrrrrrrrrrrJc |id|d|r'|jDcic] \}}| || c}}ndd|d|d|d|d|d | d | d |d |d | d| d| d|d|d|||d}|d|dnd}|jj|d|jDcic] \}}| || c}}|Scc}}wcc}}w)aBCreate a run and stream the results. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: A command to execute. Cannot be combined with input. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. metadata: Metadata to assign to the run. config: The configuration for the assistant. checkpoint: The checkpoint to resume from. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. feedback_keys: Feedback keys to assign to run. on_disconnect: The disconnect mode to use. Must be one of 'cancel' or 'continue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. Returns: AsyncIterator[StreamPart]: Asynchronous iterator of stream results. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) async for chunk in client.runs.stream( thread_id=None, assistant_id="agent", input={"messages": [{"role": "user", "content": "how are you?"}]}, stream_mode=["values","debug"], metadata={"name":"my_run"}, config={"configurable": {"model_name": "anthropic"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], feedback_keys=["my_feedback_key_1","my_feedback_key_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ): print(chunk) ``` ```shell ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}) StreamPart(event='end', data=None) ``` rr_Nrrrrrrrrrrvr{rrrrrrrW /runs/streamPOSTritemsrrrrYrrr_rrrrrvr{rrrrrrrrrrrJkvr#endpoints r@rzRunsClient.streamswr U GN'--/C$!QQ]ACTX f     ;   0  L   0    ]  w  *  ] !2! " !"4# $ ]% & ]' (+*+ 2$ {, /  yy  #*==?D41aam!Q$D    3D8E B2 B2  B8#B8)rr_rrrrrrrrrrrrJc Kywr}r)rrYrrr_rrrrrrrrrrrrJs r@r$zRunsClient.create[s (rr_rrrrrvr{rrrrrrrrJc Kywr}rrrYrrr_rrrrrvr{rrrrrrrrJs r@r$zRunsClient.createqs ,r)rr_rrrrrvr{rrrrrrrrrJcKid|d|r'|jDcic] \}}| || c}}ndd|d|d|d|d|d | d | d |d | d | d| d|d|d|d|}|jDcic] \}}| || }}}|r)|jjd|d|d{S|jjd|d{Scc}}wcc}}w757w)aCreate a background run. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: A command to execute. Cannot be combined with input. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. metadata: Metadata to assign to the run. config: The configuration for the assistant. checkpoint: The checkpoint to resume from. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. Returns: Run: The created background run. ???+ example "Example Usage" ```python background_run = await client.runs.create( thread_id="my_thread_id", assistant_id="my_assistant_id", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, config={"configurable": {"model_name": "openai"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) print(background_run) ``` ```shell -------------------------------------------------------------------------------- { 'run_id': 'my_run_id', 'thread_id': 'my_thread_id', 'assistant_id': 'my_assistant_id', 'created_at': '2024-07-25T15:35:42.598503+00:00', 'updated_at': '2024-07-25T15:35:42.598503+00:00', 'metadata': {}, 'status': 'pending', 'kwargs': { 'input': { 'messages': [ { 'role': 'user', 'content': 'how are you?' } ] }, 'config': { 'metadata': { 'created_by': 'system' }, 'configurable': { 'run_id': 'my_run_id', 'user_id': None, 'graph_id': 'agent', 'thread_id': 'my_thread_id', 'checkpoint_id': None, 'model_name': "openai", 'assistant_id': 'my_assistant_id' } }, 'webhook': "https://my.fake.webhook.com", 'temporary': False, 'stream_mode': ['values'], 'feedback_keys': None, 'interrupt_after': ["node_to_stop_after_1","node_to_stop_after_2"], 'interrupt_before': ["node_to_stop_before_1","node_to_stop_before_2"] }, 'multitask_strategy': 'interrupt' } ``` rr_Nrrrrrrrrrvr{rrrrrrW/runsrrrr)rrYrrr_rrrrrvr{rrrrrrrrrJrrr#s r@r$zRunsClient.createswt U GN'--/C$!QQ]ACTX ;   0   f    L   0    w  *  ]  !2 !"4! " ]# $ ]% & ]' *%,MMOEDAqq}1a4EE )I;e(D7SS Sg>> >-D$FS>sEC' C C AC'4 C?C)C'-C#.$C'C%C'%C'cKdd}|Dcgc] }|| }}|jjd|d{Scc}w7 w),Create a batch of stateless background runs.c\|jDcic] \}}| || c}}Scc}}wr}rr#rrs r@filter_payloadz/RunsClient.create_batch..filter_payload!(%,]]_FTQ AqDF FF (( /runs/batchrNr#r#r!)rpayloadsrr#s r@ create_batchzRunsClient.create_batchsJ G2YY]] {& 17#    ri interruptractionrJc zK|jjd|d|d|rdndd|d|d{S7w) aGet a run. Args: thread_id: The thread ID to cancel. run_id: The run ID to cancel. wait: Whether to wait until run has completed. action: Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. Default is `interrupt`. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.runs.cancel( thread_id="thread_id_to_cancel", run_id="run_id_to_cancel", wait=True, action="interrupt" ) ``` rWr /cancel?wait=r&action=Nrr!rrYrrrrJs r@cancelzRunsClient.cancel+sVFYY^^ {& 4aQ=OxX^W_ `$    r:cfK|jjd|d|d|d{S7w)a8Block until a run is done. Returns the final state of the thread. Args: thread_id: The thread ID to join. run_id: The run ID to join. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") result =await client.runs.join( thread_id="thread_id_to_join", run_id="run_id_to_join" ) ``` rWr/joinrNrrs r@joinzRunsClient.joinTs@0YY]] {& 6#    r )cancel_on_disconnectrrJcT|jjd|d|dd||d|S)a-Stream output from a run in real-time, until the run is done. Output is not buffered, so any output produced before this call will not be received here. Args: thread_id: The thread ID to join. run_id: The run ID to join. cancel_on_disconnect: Whether to cancel the run when the stream is disconnected. stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed when creating the run. Background runs default to having the union of all stream modes. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") async for part in client.runs.join_stream( thread_id="thread_id_to_join", run_id="run_id_to_join", stream_mode=["values", "debug"] ): print(part) ``` rWr/streamGET)rrrrr)rrYrrrrJs r@ join_streamzRunsClient.join_streampsFLyy {& 8 (<*   rBcfK|jjd|d||d{y7w)aDelete a run. Args: thread_id: The thread ID to delete. run_id: The run ID to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.runs.delete( thread_id="thread_id_to_delete", run_id="run_id_to_delete" ) ``` rWrrNr+rs r@rzRunsClient.deletes20ii9+VF8DgVVVs '1/1r@)*rYrrrrrr_Optional[Command]r'Union[StreamMode, Sequence[StreamMode]]rrGrrrrIrvrr{rFrOptional[bool]r#Optional[Union[All, Sequence[str]]]rrrOptional[Sequence[str]]rOptional[DisconnectMode]rrFrOptional[MultitaskStrategy]rOptional[IfNotExists]r Optional[int]rJrrr)&rYrrrrrr_rrrrrGrrrrIrrrrrrrrrrrOptional[OnCompletionBehavior]rrrrFrrrJrrr),rYrFrrrrr_rrrrrGrrrrIrvrr{rFrrrrrrrrrrrrrrFrrrrrrrJrrr)"rYrrrrrr_rrrrrGrrrrrrIrrrrrrFrrrrrrrJrrr"&rYrrrrrr_rrrrrGrrrrIrvrr{rFrrrrrrrrFrrrrrrrJrrr")(rYrFrrrrr_rrrrrGrrrrIrvrr{rFrrrrrrrrFrrrrrrrrrJrrr")rlist[RunCreate]r list[Run])&rYrrrrrr_rrrrrIrvrr{rFrrrrrrrrFrrrrrrrrrrGrJrr!Union[list[dict], dict[str, Any]])"rYrrrrrr_rrrrrIrrrrrrrrFrrrrrrrrrrGrJrrr)(rYrFrrrrr_rrrrrIrvrr{rFrrrrrrrrFrrrrrrrrrrrrGrJrrr) rYrr.rMr/rMrkzOptional[RunStatus]rJrr List[Run]rYrrrrJrrr" rYrrrrrGrrrJrrrrYrrrrJrrrN) rYrrrrrGr1Optional[Union[StreamMode, Sequence[StreamMode]]]rJrrrrYrrrrJrrrrrrrrrrr$rrrTrorrrrrrBr@rrs   !%%)?G!&#'#'+/'+,0@D?C1526!%:>/3'+,0-(((  ( # (=((!(!()(%(*(>(=( /!("0#($%(&8'((-)(*%+(,*-(. #/((2 !%%)?G!&#'#',0@D?C15268(=(/(0( 6!("-#($%(&%'((*)(* #+((8!%%)?G!&#'#'+/'+,0@D?C15268/3'+,0/z  z z  z # z =z z !z !z )z %z *z >z =z /!z "0#z $6%z &'z (8)z *-+z ,%-z .*/z 0 #1z x !%%)?G!&#',0#'@D?C!%8=6 -!"%#$*%& '* !%%)?G!&#'#'+/'+,0@D?C!%:>/3'+,0)   # =!!)%*>= !"8#$-%&%'(*)* +8!%%)?G!&#'#'+/'+,0@D?C!%:>/38<'+,0+S? S?S?  S? # S?=S?S?!S?!S?)S?%S?*S?>S?=S? !S?"8#S?$-%S?&6'S?(%)S?**+S?, -S?jB !%%)#'#'+/'+,0@D?C!%26:>/3'+ ,0)000  0 # 0!0!0)0%0*0>0=0000 8!0"-#0$%%0&'0(*)0* ++00. !%%)#'#',0@D?C!%2680=000060-0 %!0"#0$*%0& +'004!%%)#'#'+/'+,0@D?C!%268<:>/3'+ ,0+L LL  L # L!L!L)L%L*L>L=LL0L 6!L"8#L$-%L&%'L()L**+L, +-Ld&*,0) )  )  ) $ ) *)  ) XSW  &) 7O  D*,0' ' '  '  ' *'  ' TSW  &) 7O  B&+IM,0. . . # . G . *.  #. bSWWW&)W7OW WrBrc eZdZdZd dZdddddddddd d dZdddddddddd ddZ d ddZdddd dd  dd Zy)raClient for managing recurrent runs (cron jobs) in LangGraph. A run is a single invocation of an assistant with optional input and config. This client allows scheduling recurring runs to occur automatically. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024")) cron_job = await client.crons.create_for_thread( thread_id="thread_123", assistant_id="asst_456", schedule="0 9 * * *", input={"message": "Daily update"} ) ``` !!! note "Feature Availability" The crons client functionality is not supported on all licenses. Please check the relevant license documentation for the most up-to-date details on feature availability. c||_yr}rr http_clients r@rzCronClient.__init__  rBN rrrrrrrrrJc K|||||||| | d } | r| | d<| jDcic] \}}| || } }}|jjd|d| | d{Scc}}w7 w)aCreate a cron job for a thread. Args: thread_id: the thread ID to run the cron job on. assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") cron_run = await client.crons.create_for_thread( thread_id="my-thread-id", assistant_id="agent", schedule="27 15 * * *", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, config={"configurable": {"model_name": "openai"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` schedulerrrrrrrrrNrW /runs/cronsrr)rrYrr rrrrrrrrrJr#rrs r@create_for_threadzCronClient.create_for_threadst! (!2 0.   ,>G( )$+MMOEDAqq}1a4EEYY^^ {+ .Wg$   F s 'A. A&A&(A.!A," A.c K||||||||| d } | r| | d<| jD cic] \} }| | | } } }|jjd| | d{Scc}} w7 w)aCreate a cron run. Args: assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") cron_run = client.crons.create( assistant_id="agent", schedule="27 15 * * *", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, config={"configurable": {"model_name": "openai"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` rrNr rrrrr rrrrrrrrrJr#rrs r@r$zCronClient.create! sl! (!2 0.   ,>G( )$+MMOEDAqq}1a4EEYY^^M^QQQFQs 'A* A"A"$A*A( A*c`K|jjd||d{y7w)aDelete a cron. Args: cron_id: The cron ID to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.crons.delete( cron_id="cron_to_delete" ) ``` /runs/crons/rNr+rcron_idrJs r@rzCronClient.deletef s,0iigY7IIIr,r-rrrYr.r/rJcK||||d}|jDcic] \}}| || }}}|jjd||d{Scc}}w7 w)aGet a list of cron jobs. Args: assistant_id: The assistant ID or graph name to search for. thread_id: the thread ID to search for. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. Returns: list[Cron]: The list of cron jobs returned by the search, ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") cron_jobs = await client.crons.search( assistant_id="my_assistant_id", thread_id="my_thread_id", limit=5, offset=5, ) print(cron_jobs) ``` ```shell ---------------------------------------------------------- [ { 'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b', 'assistant_id': 'my_assistant_id', 'thread_id': 'my_thread_id', 'user_id': None, 'payload': { 'input': {'start_time': ''}, 'schedule': '4 * * * *', 'assistant_id': 'my_assistant_id' }, 'schedule': '4 * * * *', 'next_run_date': '2024-07-25T17:04:00+00:00', 'end_time': None, 'created_at': '2024-07-08T06:02:23.073257+00:00', 'updated_at': '2024-07-08T06:02:23.073257+00:00' } ] ``` rrYr.r/N/runs/crons/searchrr rrrYr.r/rJr#rrs r@r5zCronClient.search sjx)"   %,MMOEDAqq}1a4EEYY^^$8wPW^XXXFXs A AA$AA A)rr~rr)rYrrrr rrrrrrrIrrrOptional[Union[All, list[str]]]rrrrFrrFrJrrr"rrr rrrrrrrIrrrrrrrrFrrFrJrrr"r}rrrJrrr rrFrYrFr.rMr/rMrJrrz list[Cron] rrrrrr r$rr5rrBr@rrs. !%#'#',0<@;?!%,0,0I I I  I  I !I !I *I :I 9I I *I *I  I `!%#'#',0<@;?!%,0,0CRCR CR  CR ! CR!CR*CR:CR9CRCR*CR*CR CRP-1JJ*J  J:'+#',0BY$BY! BY  BY  BY*BY BYrBrceZdZdZd dZ d d dZddd d dZ d ddZ d ddZ d dd Z y)raClient for interacting with the graph's shared storage. The Store provides a key-value storage system for persisting data across graph executions, allowing for stateful operations and data sharing across threads. ???+ example "Example" ```python client = get_client(url="http://localhost:2024") await client.store.put_item(["users", "user123"], "mem-123451342", {"name": "Alice", "score": 100}) ``` c||_yr}rrs r@rzStoreClient.__init__ rrBNcK|D]}d|vstd|d|||||d}|jjdt||d{y7w)aStore or update an item. Args: namespace: A list of strings representing the namespace path. key: The unique identifier for the item within the namespace. value: A dictionary containing the item's data. index: Controls search indexing - None (use defaults), False (disable), or list of field paths to index. ttl: Optional time-to-live in minutes for the item, or None for no expiration. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.store.put_item( ["documents", "user123"], key="item456", value={"title": "My Document", "content": "Hello World"} ) ``` .Invalid namespace label '1'. Namespace labels cannot contain periods ('.').rkeyvalueindexttl /store/itemsrNrErr_provided_vals rrr#r$r%r&rJlabelr#s r@put_itemzStoreClient.put_item s~D Ee| /w6gh  #  iimm !8'   s AAAAA refresh_ttlrJcK|D]}d|vstd|ddj||d}|||d<|jjd||d{S7w) ayRetrieve a single item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. refresh_ttl: Whether to refresh the TTL on this read operation. If None, uses the store's default behavior. Returns: Item: The retrieved item. headers: Optional custom headers to include with the request. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") item = await client.store.get_item( ["documents", "user123"], key="item456", ) print(item) ``` ```shell ---------------------------------------------------------------- { 'namespace': ['documents', 'user123'], 'key': 'item456', 'value': {'title': 'My Document', 'content': 'Hello World'}, 'created_at': '2024-07-30T12:00:00Z', 'updated_at': '2024-07-30T12:00:00Z' } ``` rr r!rr#Nr.r'rrErrrorrr#r.rJr+rs r@get_itemzStoreClient.get_item s}V Ee| /w6gh  #xx 23?  "$/F= !YY]]>&']RRRRs A A A AA cbK|jjd||d|d{y7w)a'Delete an item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.store.delete_item( ["documents", "user123"], key="item456", ) ``` r'r0rNr+rrr#rJs r@ delete_itemzStoreClient.delete_item= s76ii (5   s %/-/c~K||||||d}|jjdt||d{S7w)aSearch for items within a namespace prefix. Args: namespace_prefix: List of strings representing the namespace prefix. filter: Optional dictionary of key-value pairs to filter results. limit: Maximum number of items to return (default is 10). offset: Number of items to skip before returning results (default is 0). query: Optional query for natural language search. refresh_ttl: Whether to refresh the TTL on items returned by this search. If None, uses the store's default behavior. headers: Optional custom headers to include with the request. Returns: List[Item]: A list of items matching the search criteria. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") items = await client.store.search_items( ["documents"], filter={"author": "John Doe"}, limit=5, offset=0 ) print(items) ``` ```shell ---------------------------------------------------------------- { "items": [ { "namespace": ["documents", "user123"], "key": "item789", "value": { "title": "Another Document", "author": "John Doe" }, "created_at": "2024-07-30T12:00:00Z", "updated_at": "2024-07-30T12:00:00Z" }, # ... additional items ... ] } ``` namespace_prefixfilterr.r/queryr./store/items/searchrNrrr) rr9r:r.r/r;r.rJr#s r@ search_itemszStoreClient.search_items^ sVv!1&  YY^^ !($    s 4=;=c|K|||||d}|jjdt||d{S7w)aList namespaces with optional match conditions. Args: prefix: Optional list of strings representing the prefix to filter namespaces. suffix: Optional list of strings representing the suffix to filter namespaces. max_depth: Optional integer specifying the maximum depth of namespaces to return. limit: Maximum number of namespaces to return (default is 100). offset: Number of namespaces to skip before returning results (default is 0). headers: Optional custom headers to include with the request. Returns: List[List[str]]: A list of namespaces matching the criteria. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") namespaces = await client.store.list_namespaces( prefix=["documents"], max_depth=3, limit=10, offset=0 ) print(namespaces) ---------------------------------------------------------------- [ ["documents", "user123", "reports"], ["documents", "user456", "invoices"], ... ] ``` r>suffix max_depthr.r//store/namespacesrNr=rr>rBrCr.r/rJr#s r@list_namespaceszStoreClient.list_namespaces sSX"  YY^^ ($    s 3<:<r@NNNr#rr$rr%z*Optional[Union[Literal[False], list[str]]]r&rrJrr Sequence[str]rr r#rrrIr.rrJrrrr}r#rrJrrrIrrNr-rNNNr:zOptional[dict[str, Any]]r.rMr/rMr;rFr.rrJrr9rIrr%NNNdrNr>Optional[List[str]]rBrQrCrr.rMr/rMrJrrr rrrrrr,r3r6r?rFrrBr@rr s =A!,00  0  0 : 0 0 *0  0  0 p'+,03S 3S 3S $ 3S*3S 3St-1    *      J,0#&*,0G ) G  G  G G $G *G 'G  G V'+&*#',06 #6 $6 ! 6  6  6 *6  6 rBrSyncLangGraphClientc |d}tjd}tj|||tj|ntjddddt ||}t |S)aGet a synchronous LangGraphClient instance. Args: url: The URL of the LangGraph API. api_key: The API key. If not provided, it will be read from the environment. Precedence: 1. explicit argument 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY headers: Optional custom headers timeout: Optional timeout configuration for the HTTP client. Accepts an httpx.Timeout instance, a float (seconds), or a tuple of timeouts. Tuple format is (connect, read, write, pool) If not provided, defaults to connect=5s, read=300s, write=300s, and pool=5s. Returns: SyncLangGraphClient: The top-level synchronous client for accessing AssistantsClient, ThreadsClient, RunsClient, and CronClient. ???+ example "Example" ```python from langgraph_sdk import get_sync_client # get top-level synchronous LangGraphClient client = get_sync_client(url="http://localhost:8123") # example usage: client..() assistant = client.assistants.get(assistant_id="some_uuid") ``` rarbrcrerfrk)ru HTTPTransportClientrxrKrS)rYr=rJrZrmrys r@get_sync_clientrW srN {%##A.I \\" MM' "qs#AFWg. F v &&rBceZdZdZddZy)rSa~Synchronous client for interacting with the LangGraph API. This class provides synchronous access to LangGraph API endpoints for managing assistants, threads, runs, cron jobs, and data storage. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.get("asst_123") ``` c(t||_t|j|_t |j|_t |j|_t|j|_ t|j|_ yr}) SyncHttpClientrSyncAssistantsClientrSyncThreadsClientrSyncRunsClientrSyncCronClientrSyncStoreClientrrs r@rzSyncLangGraphClient.__init__& s^"6* .tyy9(3 "499- #DII. $TYY/ rBNryz httpx.ClientrrrrrBr@rSrS s  0rBceZdZdZddZddd ddZdd ddZdd ddZdd dd Zddd  dd Z dddd  dd Z y)rZa8Handle synchronous requests to the LangGraph API. Provides error messaging and content handling enhancements above the underlying httpx client, mirroring the interface of [HttpClient](#HttpClient) but for sync usage. Attributes: client (httpx.Client): Underlying HTTPX sync client. c||_yr}rrs r@rzSyncHttpClient.__init__: rrBNrcl|jj|||} |jt|S#tj$re}|j j }tjdk\r|j||tjd|||d}~wwxYw)rrrrrN) ryrorrurrhrrrrrr _decode_jsonrs r@rozSyncHttpClient.get= s KKOODO A    A$$ 668??$D7* 4 G 9$@1 MG  s;B3A B..B3rc|t|\}}nid}}|r|j||jj|||} |j t|S#t j $re}|jj}tjdk\r|j||tjd|||d}~wwxYwr) _encode_jsonrryrrrurrhrrrrrrrdrs r@rzSyncHttpClient.postQ s  '3D'9 $OW')3WO   " "7 + KK  T?G  L    A$$ 668??$D7* 4 G 9$@1 MG  sA##C6A CCct|\}}|r|j||jj|||} |j t|S#t j $re}|jj}tjdk\r|j||tjd|||d}~wwxYw)rrrrrN)rfrryrrrurrhrrrrrrrdrs r@rzSyncHttpClient.putk s$0#5    " "7 + KKOOD/7O K    A$$ 668??$D7* 4 G 9$@1 MG  AC/A CCct|\}}|r|j||jj|||} |j t|S#t j $re}|jj}tjdk\r|j||tjd|||d}~wwxYw)rrrrrN)rfrryrrrurrhrrrrrrrdrs r@rzSyncHttpClient.patch s$0#5    " "7 + KK  dOW  M    A$$ 668??$D7* 4 G 9$@1 MG  rhrcZ|jjd|||} |jy#tj$re}|j j }tjdk\r|j||tjd|||d}~wwxYw)rrrrrrN) ryrrrurrhrrrrrrrs r@rzSyncHttpClient.delete s KK  $T7  K    $$ 668??$D7* 4 G 9$@1 MG  s2B*A B%%B*rc#Kt|\}}d|d<d|d<|r|j||jj|||||5} |j |jjd d j!d d } d| vrt j"d| t%} t'|D])} | j| j)d}|&|+ d d d y #t j $re} |jj} tjdk\r| j| | tjd| | | d } ~ wwxYw#1swYy xYww)z*Stream the results of a request using SSE.rrrrrrrrNrrrrrr)rfrryrrrurrhrrrrrrrJrorrr/r1rrs r@rzSyncHttpClient.stream s$0#5 $7!+5(   " "7 + [[   D/76     $$&;;??>2>HHMaPL",6**'*, !lG&s+ nnT[[%78?I -   ((  **,##w.JJt$LL#=dV!DqLQ     sJA E<E0C5 BE0%E0, E<5E-A E((E--E00E95E<r`rrrr) rrrrrrrrrJrrIterator[StreamPart]rrrBr@rZrZ/ sD-1,0 *  *  2-1   *  6MQ"&1I *MQ"&1I .#,0   *   0 $,0,0(((  ( * (*( (rBrZctj|ttjtjz}t t |}d}||d}||fSr)rrrXrrrrrs r@rfrf sR << ""V%<%<< D T^N%L!/NG D=rBcT|j}|rtj|SdSr})rhrrrs r@rdrd s# 668D!%6<< /4/rBceZdZdZddZdd ddZddd ddZdd dd Z ddd dd Z dddddddd  dd Z ddddddd  ddZ dd ddZ dddddd d dZ d!dd d"dZ dd d#dZy)$r[agClient for managing assistants in LangGraph synchronously. This class provides methods to interact with assistants, which are versioned configurations of your graph. ???+ example "Examples" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.get("assistant_id_123") ``` c||_yr}rrs r@rzSyncAssistantsClient.__init__ rrBNrcB|jjd||S)aGet an assistant by ID. Args: assistant_id: The ID of the assistant to get OR the name of the graph (to use the default assistant). headers: Optional custom headers to include with the request. Returns: Assistant: Assistant Object. ???+ example "Example Usage" ```python assistant = client.assistants.get( assistant_id="my_assistant_id" ) print(assistant) ``` ```shell ---------------------------------------------------- { 'assistant_id': 'my_assistant_id', 'graph_id': 'agent', 'created_at': '2024-06-25T17:10:33.109781+00:00', 'updated_at': '2024-06-25T17:10:33.109781+00:00', 'config': {}, 'metadata': {'created_by': 'system'} } ``` rrrrs r@rozSyncAssistantsClient.get s#Lyy}}|L>:G}LLrBFrcJ|jjd|dd|i|S)aGet the graph of an assistant by ID. Args: assistant_id: The ID of the assistant to get the graph of. xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included. headers: Optional custom headers to include with the request. Returns: Graph: The graph information for the assistant in JSON format. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") graph_info = client.assistants.get_graph( assistant_id="my_assistant_id" ) print(graph_info) -------------------------------------------------------------------------------------------------------------------------- { 'nodes': [ {'id': '__start__', 'type': 'schema', 'data': '__start__'}, {'id': '__end__', 'type': 'schema', 'data': '__end__'}, {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}}, ], 'edges': [ {'source': '__start__', 'target': 'agent'}, {'source': 'agent','target': '__end__'} ] } ``` rr rrrr s r@r zSyncAssistantsClient.get_graph s4Xyy}}<. /PW  rBcD|jjd|d|S)abGet the schemas of an assistant by ID. Args: assistant_id: The ID of the assistant to get the schema of. headers: Optional custom headers to include with the request. Returns: GraphSchema: The graph schema for the assistant. ???+ example " Example Usage" ```python client = get_sync_client(url="http://localhost:2024") schema = client.assistants.get_schemas( assistant_id="my_assistant_id" ) print(schema) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------- { 'graph_id': 'agent', 'state_schema': { 'title': 'LangGraphInput', '$ref': '#/definitions/AgentState', 'definitions': { 'BaseMessage': { 'title': 'BaseMessage', 'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.', 'type': 'object', 'properties': { 'content': { 'title': 'Content', 'anyOf': [ {'type': 'string'}, {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}} ] }, 'additional_kwargs': { 'title': 'Additional Kwargs', 'type': 'object' }, 'response_metadata': { 'title': 'Response Metadata', 'type': 'object' }, 'type': { 'title': 'Type', 'type': 'string' }, 'name': { 'title': 'Name', 'type': 'string' }, 'id': { 'title': 'Id', 'type': 'string' } }, 'required': ['content', 'type'] }, 'AgentState': { 'title': 'AgentState', 'type': 'object', 'properties': { 'messages': { 'title': 'Messages', 'type': 'array', 'items': {'$ref': '#/definitions/BaseMessage'} } }, 'required': ['messages'] } } }, 'config_schema': { 'title': 'Configurable', 'type': 'object', 'properties': { 'model_name': { 'title': 'Model Name', 'enum': ['anthropic', 'openai'], 'type': 'string' } } } } ``` rrrrrs r@rz SyncAssistantsClient.get_schemasI s%byy}}|L>BG}TTrBc|&|jjd|d|d|i|S|jjd|dd|i|S)aGet the schemas of an assistant by ID. Args: assistant_id: The ID of the assistant to get the schema of. headers: Optional custom headers to include with the request. Returns: Subgraphs: The graph schema for the assistant. rrrrrrrs r@rz"SyncAssistantsClient.get_subgraphs sr$  99==|nK {C!7+!  99==|nJ7!7+! rBrcd|i} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|jjd| | S) aCreate a new assistant. Useful when graph is configurable and you want to create different assistants based on different configurations. Args: graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. config: Configuration to use for the graph. metadata: Metadata to add to assistant. assistant_id: Assistant ID to use, will default to a random UUID if not provided. if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant). name: The name of the assistant. Defaults to 'Untitled' under the hood. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 Returns: Assistant: The created assistant. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.create( graph_id="agent", config={"configurable": {"model_name": "openai"}}, metadata={"number":1}, assistant_id="my-assistant-id", if_exists="do_nothing", name="my_name" ) ``` rrrrrrrr rr!r"s r@r$zSyncAssistantsClient.create sy\ #   &GH  "*GJ  &2GN # #,GK "GFO %0GM "yy~~m'7~KKrBr%ci}|r||d<|r||d<|r||d<|r||d<|r||d<|jjd|||S)aUpdate an assistant. Use this to point to a different graph, update the configuration, or change the metadata of an assistant. Args: assistant_id: Assistant to update. graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. If None, assistant will keep pointing to same graph. config: Configuration to use for the graph. metadata: Metadata to merge with existing assistant metadata. name: The new name for the assistant. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 Returns: Assistant: The updated assistant. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.update( assistant_id='e280dad7-8618-443f-87f1-8e41841c180f', graph_id="other-graph", config={"configurable": {"model_name": "anthropic"}}, metadata={"number":2} ) ``` rrrrrrrr'r(s r@rzSyncAssistantsClient.update stR#% "*GJ   &GH  "*GJ  "GFO %0GM "yy<. )  rBcD|jjd||y)aDelete an assistant. Args: assistant_id: The assistant ID to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.assistants.delete( assistant_id="my_assistant_id" ) ``` rrNr+rs r@rzSyncAssistantsClient.deleteS s"2 < ~6HrBr-r)rrr.r/rJcd||d}|r||d<|r||d<|jjd||S)abSearch for assistants. Args: metadata: Metadata to filter by. Exact match filter for each KV pair. graph_id: The ID of the graph to filter by. The graph ID is normally set in your langgraph.json configuration. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. Returns: list[Assistant]: A list of assistants. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistants = client.assistants.search( metadata = {"name":"my_name"}, graph_id="my_graph_id", limit=5, offset=5 ) ``` r3rrr4rr!)rrrr.r/rJr#s r@r5zSyncAssistantsClient.searchn sQF#  "*GJ  "*GJ yy~~   rBc^||d}|r||d<|jjd|d||S)aList all versions of an assistant. Args: assistant_id: The assistant ID to get versions for. metadata: Metadata to filter versions by. Exact match filter for each KV pair. limit: The maximum number of versions to return. offset: The number of versions to skip. headers: Optional custom headers to include with the request. Returns: list[Assistant]: A list of assistants. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant_versions = client.assistants.get_versions( assistant_id="my_assistant_id" ) ``` r3rrr7rr!r8s r@r9z!SyncAssistantsClient.get_versions sKB#  "*GJ yy~~<. 2'  rBcNd|i}|jjd|d||S)aOChange the version of an assistant. Args: assistant_id: The assistant ID to delete. version: The version to change to. headers: Optional custom headers to include with the request. Returns: Assistant: Assistant Object. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") new_version_assistant = client.assistants.set_latest( assistant_id="my_assistant_id", version=3 ) ``` r<rr=rr!r>s r@r?zSyncAssistantsClient.set_latest s8:$-g"6yy~~<. 0w  rBrrZrrrArBrCrDrEr}rHrKrL) rrrrFr.rMr/rMrJrrrOrPrQrRrSrrBr@r[r[ s -1 &M&M* &M  &MX"',0 . .  . * . ) . h-1 qUqU* qU  qUl$(  -1 !  *  D$(<L &*26",0%)<L<L!<L  <L $ <L0<L<L*<L#<L <LD#'#'",0%)8 8  8 ! 8  8 8 *8 #8  8 |-1 II* I  I<"&,0. .  .  .  . *.  . f ( -1( ( (  (  ( *(  ( ^-1 ! ! ! * !  ! rBr[cjeZdZdZddZdd ddZddddddd ddZdd ddZdd dd Zdddd d dd  dd Z dd ddZ dddd ddZ ddddd ddZ d ddddd ddZ y) r\a}Synchronous client for managing threads in LangGraph. This class provides methods to create, retrieve, and manage threads, which represent conversations or stateful interactions. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.create(metadata={"user_id": "123"}) ``` c||_yr}rrs r@rzSyncThreadsClient.__init__ rrBNrcB|jjd||S)aOGet a thread by ID. Args: thread_id: The ID of the thread to get. headers: Optional custom headers to include with the request. Returns: Thread: Thread object. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.get( thread_id="my_thread_id" ) print(thread) ``` ```shell ----------------------------------------------------- { 'thread_id': 'my_thread_id', 'created_at': '2024-07-18T18:35:15.540834+00:00', 'updated_at': '2024-07-18T18:35:15.540834+00:00', 'metadata': {'graph_id': 'agent'} } ``` rWrrrXs r@rozSyncThreadsClient.get s#Jyy}}y 4g}FFrBrZc (i}|r||d<|s|ri|xsi|rd|ini|d<|r||d<|rA|D cgc]0}d|dD cgc]} | d| jd| dd c} i2c} }|d <|jjd || Scc} wcc} }w) aCreate a new thread. Args: metadata: Metadata to add to thread. thread_id: ID of thread. If None, ID will be a randomly generated UUID. if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread). supersteps: Apply a list of supersteps when creating a thread, each containing a sequence of updates. Each update has `values` or `command` and `as_node`. Used for copying a thread between deployments. graph_id: Optional graph ID to associate with the thread. headers: Optional custom headers to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.create( metadata={"number":1}, thread_id="my-thread-id", if_exists="raise" ) ``` ) rYrrrr]r^r_r`rar[rbrrcrds r@r$zSyncThreadsClient.create$sL#% #,GK x#>r#-5J)2#GJ  #,GK $ % "#9    '(k'(uuY'7'(|   %GL !yy~~jw~HH  %s B"B B BcH|jjd|d|i|S)a<Update a thread. Args: thread_id: ID of thread to update. metadata: Metadata to merge with existing thread metadata. headers: Optional custom headers to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.update( thread_id="my-thread-id", metadata={"number":1}, ) ``` rWrrr'rhs r@rzSyncThreadsClient.updatees16yy { #:x*@'  rBcD|jjd||y)atDelete a thread. Args: thread_id: The ID of the thread to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client.threads.delete( thread_id="my_thread_id" ) ``` rWrNr+rXs r@rzSyncThreadsClient.deletes"0 9YK0'BrBr-r)rr^rkr.r/rJcr||d}|r||d<|r||d<|r||d<|jjd||S)avSearch for threads. Args: metadata: Thread metadata to filter on. values: State values to filter on. status: Thread status to filter on. Must be one of 'idle', 'busy', 'interrupted' or 'error'. limit: Limit on number of threads to return. offset: Offset in threads table to start search from. headers: Optional custom headers to include with the request. Returns: list[Thread]: List of the threads matching the search parameters. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") threads = client.threads.search( metadata={"number":1}, status="interrupted", limit=15, offset=5 ) ``` r3rr^rkrmrr!)rrr^rkr.r/rJr#s r@r5zSyncThreadsClient.searchsUJ#  "*GJ   &GH   &GH yy~~/gw~OOrBcF|jjd|dd|S)aCopy a thread. Args: thread_id: The ID of the thread to copy. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.threads.copy( thread_id="my_thread_id" ) ``` rWroNrr!rXs r@rpzSyncThreadsClient.copys&2yy~~ )E:w~WWrBFrqc|r%|jjd|d||d|S|r&|jjd|d|d|i|S|jjd|dd|i|S) aoGet the state of a thread. Args: thread_id: The ID of the thread to get the state of. checkpoint: The checkpoint to get the state of. subgraphs: Include subgraphs states. headers: Optional custom headers to include with the request. Returns: ThreadState: the thread of the state. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread_state = client.threads.get_state( thread_id="my_thread_id", checkpoint_id="my_checkpoint_id" ) print(thread_state) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- { 'values': { 'messages': [ { 'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False }, { 'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None } ] }, 'next': [], 'checkpoint': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1' } 'metadata': { 'step': 1, 'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2', 'source': 'loop', 'writes': { 'agent': { 'messages': [ { 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'name': None, 'type': 'ai', 'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'example': False, 'tool_calls': [], 'usage_metadata': None, 'additional_kwargs': {}, 'response_metadata': {}, 'invalid_tool_calls': [] } ] } }, 'user_id': None, 'graph_id': 'agent', 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'created_by': 'system', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'created_at': '2024-07-25T15:35:44.184703+00:00', 'parent_config': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f' } } ``` rWrtrurrwrrrrxryrzs r@r|zSyncThreadsClient.get_statesX 99>>I;&78$.YG"  99==I;gm_=#Y/!  99==I;f-#Y/! rBr}cxd|i}|r||d<|r||d<|r||d<|jjd|d||S)aUpdate the state of a thread. Args: thread_id: The ID of the thread to update. values: The values to update the state with. as_node: Update the state as if this node had just executed. checkpoint: The checkpoint to update the state of. headers: Optional custom headers to include with the request. Returns: ThreadUpdateStateResponse: Response after updating a thread's state. ???+ example "Example Usage" ```python response = await client.threads.update_state( thread_id="my_thread_id", values={"messages":[{"role": "user", "content": "hello!"}]}, as_node="my_node", ) print(response) ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- { 'checkpoint': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1', 'checkpoint_map': {} } } ``` r^r{rvr`rWrxrr!rs r@rzSyncThreadsClient.update_statehsd^ f#  '4GO $ $.GL ! !(GI yy~~ {& )  rBrcxd|i}|r||d<|r||d<|r||d<|jjd|d||S)aTGet the state history of a thread. Args: thread_id: The ID of the thread to get the state history for. checkpoint: Return states for this subgraph. If empty defaults to root. limit: The maximum number of states to return. before: Return states before this checkpoint. metadata: Filter states by metadata key-value pairs. headers: Optional custom headers to include with the request. Returns: list[ThreadState]: the state history of the thread. ???+ example "Example Usage" ```python thread_state = client.threads.get_history( thread_id="my_thread_id", limit=5, before="my_timestamp", metadata={"name":"my_name"} ) ``` r.rrrvrWrrr!rs r@rzSyncThreadsClient.get_historysdJ U#   &GH  "*GJ  $.GL !yy~~ {( +'7  rBr{rrrr)rrr^rrkrr.rMr/rMrJrrrrrrrrrrBr@r\r\ s -1 %G%G* %G  %GT#'26NR"&,0?I?I! ?I 0 ?I L ?I ?I*?I ?IL-1   !  *    F-1 CC* C  C:)-,0.P.P .P ' .P  .P.P*.P .Ph-1 XX* X  X<,0'+ }  ,0}})}% }  }*} }H"&+/'+,09 9 69  9 ) 9 %9 *9  #9 ~-1#'+/,0/ /  / + / ! / )/ */  / rBr\cZeZdZdZd&dZeddddddddddddddddddd d'dZeddddddddddddddddd d(d Zdddddddddddddddddddd  d)d Zeddddddddddddddd  d*d Zeddddddddddddddddd d+dZdddddddddddddddddd d,dZdd d-dZedddddddddddddddd d.dZ edddddddddddddd d/dZ ddddddddddddddddd d0dZ dddd d1dZ dd d2dZ dddd  d3d!Z dd d4d"Z dddd# d5d$Zdd d6d%Zy)7r]a~Synchronous client for managing runs in LangGraph. This class provides methods to create, retrieve, and manage runs, which represent individual executions of graphs. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") run = client.runs.create(thread_id="thread_123", assistant_id="asst_456") ``` c||_yr}rrs r@rzSyncRunsClient.__init__rrBNr^Frcyr}rrs r@rzSyncRunsClient.streams0 #rBrcyr}rrs r@rzSyncRunsClient.streams, #rBrc |id|d|r'|jDcic] \}}| || c}}ndd|d|d|d|d|d | d | d |d |d | d| d| d|d|d|||d}|d|dnd}|jj|d|jDcic] \}}| || c}}|Scc}}wcc}}w)a`Create a run and stream the results. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: The command to execute. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. metadata: Metadata to assign to the run. config: The configuration for the assistant. checkpoint: The checkpoint to resume from. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. feedback_keys: Feedback keys to assign to run. on_disconnect: The disconnect mode to use. Must be one of 'cancel' or 'continue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. Returns: Iterator[StreamPart]: Iterator of stream results. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") async for chunk in client.runs.stream( thread_id=None, assistant_id="agent", input={"messages": [{"role": "user", "content": "how are you?"}]}, stream_mode=["values","debug"], metadata={"name":"my_run"}, config={"configurable": {"model_name": "anthropic"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], feedback_keys=["my_feedback_key_1","my_feedback_key_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ): print(chunk) ``` ```shell ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}) StreamPart(event='end', data=None) ``` rr_Nrrrrrrrrrrvr{rrrrrrWrrrrrs r@rzSyncRunsClient.streamswn U GN'--/C$!QQ]ACTX f     ;   0  L   0    ]  w  *  ] !2! " !"4# $ ]% & ]' (+*+ 2$ {, /  yy  #*==?D41aam!Q$D    3D8Er)rr_rrrrrrrrrrrrJcyr}r)rrYrrr_rrrrrrrrrrrrJs r@r$zSyncRunsClient.creates(rBrcyr}rrs r@r$zSyncRunsClient.creates,rB)rr_rrrrrvr{rrrrrrrrrJcid|d|r'|jDcic] \}}| || c}}ndd|d|d|d|d|d | d | d |d | d | d| d|d|d|d|}|jDcic] \}}| || }}}|r"|jjd|d||S|jjd||Scc}}wcc}}w)aCreate a background run. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: The command to execute. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. metadata: Metadata to assign to the run. config: The configuration for the assistant. checkpoint: The checkpoint to resume from. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. Returns: Run: The created background run. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") background_run = client.runs.create( thread_id="my_thread_id", assistant_id="my_assistant_id", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, config={"configurable": {"model_name": "openai"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) print(background_run) ``` ```shell -------------------------------------------------------------------------------- { 'run_id': 'my_run_id', 'thread_id': 'my_thread_id', 'assistant_id': 'my_assistant_id', 'created_at': '2024-07-25T15:35:42.598503+00:00', 'updated_at': '2024-07-25T15:35:42.598503+00:00', 'metadata': {}, 'status': 'pending', 'kwargs': { 'input': { 'messages': [ { 'role': 'user', 'content': 'how are you?' } ] }, 'config': { 'metadata': { 'created_by': 'system' }, 'configurable': { 'run_id': 'my_run_id', 'user_id': None, 'graph_id': 'agent', 'thread_id': 'my_thread_id', 'checkpoint_id': None, 'model_name': "openai", 'assistant_id': 'my_assistant_id' } }, 'webhook': "https://my.fake.webhook.com", 'temporary': False, 'stream_mode': ['values'], 'feedback_keys': None, 'interrupt_after': ["node_to_stop_after_1","node_to_stop_after_2"], 'interrupt_before': ["node_to_stop_before_1","node_to_stop_before_2"] }, 'multitask_strategy': 'interrupt' } ``` rr_Nrrrrrrrrrvr{rrrrrrWrrr)rrYrrr_rrrrrvr{rrrrrrrrrJrrr#s r@r$zSyncRunsClient.createstt U GN'--/C$!QQ]ACTX ;   0   f    L   0    w  *  ]  !2 !"4! " ]# $ ]% & ]' *%,MMOEDAqq}1a4EE 99>>I;e,7G" 99>>'>I I1D$Fs C C 2 C =C rczdd}|Dcgc] }|| }}|jjd||Scc}w)rc\|jDcic] \}}| || c}}Scc}}wr}rrs r@rz3SyncRunsClient.create_batch..filter_payload\rrrrrr!)rrrJrr#s r@rzSyncRunsClient.create_batchWsB  Gyy}} {,ugXfX FPW  rBcH|jjd|d||S)aGet a run. Args: thread_id: The thread ID to get. run_id: The run ID to get. headers: Optional custom headers to include with the request. Returns: Run: Run object. ???+ example "Example Usage" ```python run = client.runs.get( thread_id="thread_id_to_delete", run_id="run_id_to_delete", ) ``` rWrrrrs r@rozSyncRunsClient.get5s(8yy}}y 6&BG}TTrBrrc ^|jjd|d|d|rdndd|d|S) aGet a run. Args: thread_id: The thread ID to cancel. run_id: The run ID to cancel. wait: Whether to wait until run has completed. action: Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. Default is `interrupt`. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.cancel( thread_id="thread_id_to_cancel", run_id="run_id_to_cancel", wait=True, action="interrupt" ) ``` rWrrrrrNrr!rs r@rzSyncRunsClient.cancelSsHFyy~~ {& 4aQ=OxX^W_ `  rBcJ|jjd|d|d|S)a/Block until a run is done. Returns the final state of the thread. Args: thread_id: The thread ID to join. run_id: The run ID to join. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.join( thread_id="thread_id_to_join", run_id="run_id_to_join" ) ``` rWrrrrrs r@rzSyncRunsClient.join|s28yy}} {& 6  rB)rrrJcT|jjd|d|dd||d|S)aStream output from a run in real-time, until the run is done. Output is not buffered, so any output produced before this call will not be received here. Args: thread_id: The thread ID to join. run_id: The run ID to join. stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed when creating the run. Background runs default to having the union of all stream modes. cancel_on_disconnect: Whether to cancel the run when the stream is disconnected. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.join_stream( thread_id="thread_id_to_join", run_id="run_id_to_join", stream_mode=["values", "debug"] ) ``` rWrrr)rrrr)rrYrrrrJs r@rzSyncRunsClient.join_streamsFJyy {& 8 *(<   rBcJ|jjd|d||y)aDelete a run. Args: thread_id: The thread ID to delete. run_id: The run ID to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.delete( thread_id="thread_id_to_delete", run_id="run_id_to_delete" ) ``` rWrrNr+rs r@rzSyncRunsClient.deletes(8 9YKvfX>PrBr{)*rYrrrrrr_rrrrrGrrrrIrvrr{rFrrrrrrrrrrrrFrrrrrrrJrrrl)&rYrrrrrr_rrrrrGrrrrIrrrrrrrrrrrrrrrrFrrrJrrrl),rYrFrrrrr_rrrrrGrrrrIrvrr{rFrrrrrrrrrrrrrrFrrrrrrrJrrrl)"rYrrrrrr_rrrrrGrrrrIrrrrrrrrFrrrrrrrJrrr"r)(rYrFrrrrr_rrrrrGrrrrIrvrr{rFrrrrrrrrFrrrrrrrrrJrrr")rrrJrrr)$rYrrrrrr_rrrrrIrvrr{rFrrrrrrrrFrrrrrrrrrJrrr) rYrrrrrr_rrrrrIrrrrrrrrFrrrrrrrrrJrrr)&rYrFrrrrr_rrrrrIrrrvrr{rFrrrrrrFrrrrrrrrrrrJrrr) rYrr.rMr/rMrJrrrrrr) rYrrrrrrrGrJrrrlrrrrBr@r]r]s   !%%)?G!&#'#'+/'+,0@D?C1526!%:>/3'+,0-###  # # #=##!#!#)#%#*#>#=# /!#"0##$%#&8'#(-)#*%+#,*-#. /##2 !%%)?G!&#'#',0@D?C15268#=#/#0# 6!#"-##$%#&%'#(*)#* +##8!%%)?G!&#'#'+/'+,0@D?C15268/3'+,0/x  x x  x # x =x x !x !x )x %x *x >x =x /!x "0#x $6%x &'x (8)x *-+x ,%-x .*/x 0 1x t !%%)?G!&#'#',0@D?C!%8=6 -!"%#$*%& '* !%%)?G!&#'#'+/'+,0@D?C!%:>/3'+,0)   # =!!)%*>= !"8#$-%&%'(*)* +8!%%)?G!&#'#'+/'+,0@D?C!%:>8UJ=UJ !UJ"8#UJ$6%UJ&-'UJ(%)UJ**+UJ, -UJpQU M' M5M M  M !%%)#'#'+/'+,0@D?C!%26:>/3'+,0'000  0 # 0!0!0)0%0*0>0=0000 8!0"-#0$%%0&*'0( +)00, !%%)#'#',0@D?C!%2680=000060-0 %!0"*#0$ +%002!%%)#'#',0+/'+@D?C!%268<:>/3'+,0)B  B B  B # B !B !B *B )B %B >B =B B 0B 6!B "8#B $-%B &%'B (*)B * ++B P,0 ! !  !  ! * !  ! P-1 UUU * U UF*,0' ' '  '  ' *'  ' \-1    *    JJN%*,0- - - G - # - *-  - h-1 QQQ * Q  QrBr]c eZdZdZddZdddddddddd ddZdddddddddd ddZdd dd Zddd d dd  dd Zy)r^aSynchronous client for managing cron jobs in LangGraph. This class provides methods to create and manage scheduled tasks (cron jobs) for automated graph executions. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:8123") cron_job = client.crons.create_for_thread(thread_id="thread_123", assistant_id="asst_456", schedule="0 * * * *") ``` !!! note "Feature Availability" The crons client functionality is not supported on all licenses. Please check the relevant license documentation for the most up-to-date details on feature availability. c||_yr}rrs r@rzSyncCronClient.__init__rrBN) rrrrrrrrrJc ||||||| || | d } | jDcic] \}}| || } }}|jjd|d| | Scc}}w)aCreate a cron job for a thread. Args: thread_id: the thread ID to run the cron job on. assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") cron_run = client.crons.create_for_thread( thread_id="my-thread-id", assistant_id="agent", schedule="27 15 * * *", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, config={"configurable": {"model_name": "openai"}}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` ) r rrrrrrrrrrWr rr)rrYrr rrrrrrrrrJr#rrs r@r z SyncCronClient.create_for_threadsp! ( 0.!2"4  %,MMOEDAqq}1a4EEyy~~ {+ .Wg  Fs AArc |||||||| || d } | jD cic] \} }| | | } } }|jjd| | Scc}} w)a-Create a cron run. Args: assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") cron_run = client.crons.create( assistant_id="agent", schedule="27 15 * * *", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, config={"configurable": {"model_name": "openai"}}, checkpoint_during=True, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` ) r rrrrrrrrrr rrr s r@r$zSyncCronClient.createGspn! ( 0.!2"4  %,MMOEDAqq}1a4EEyy~~m'7~KKFs AArcD|jjd||y)aDelete a cron. Args: cron_id: The cron ID to delete. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") client.crons.delete( cron_id="cron_to_delete" ) ``` rrNr+rs r@rzSyncCronClient.deletes"2 <y17CrBr-rrc||||d}|jDcic] \}}| || }}}|jjd||Scc}}w)aGet a list of cron jobs. Args: assistant_id: The assistant ID or graph name to search for. thread_id: the thread ID to search for. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. Returns: list[Cron]: The list of cron jobs returned by the search, ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") cron_jobs = client.crons.search( assistant_id="my_assistant_id", thread_id="my_thread_id", limit=5, offset=5, ) print(cron_jobs) ``` ```shell ---------------------------------------------------------- [ { 'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b', 'assistant_id': 'my_assistant_id', 'thread_id': 'my_thread_id', 'user_id': None, 'payload': { 'input': {'start_time': ''}, 'schedule': '4 * * * *', 'assistant_id': 'my_assistant_id' }, 'schedule': '4 * * * *', 'next_run_date': '2024-07-25T17:04:00+00:00', 'end_time': None, 'created_at': '2024-07-08T06:02:23.073257+00:00', 'updated_at': '2024-07-08T06:02:23.073257+00:00' } ] ``` rrrrrs r@r5zSyncCronClient.searchs_v)"   %,MMOEDAqq}1a4EEyy~~2'~RRFs A A )rrZrr)rYrrrr rrrrrrrrrIrrrrrrFrrFrJrrr"rrrrrrBr@r^r^s" !%#',0#'<@;?!%,0,0F F F  F  F !F *F !F :F 9F F *F *F  F Z!%#'#',0<@;?!%,0,0CLCL CL  CL ! CL!CL*CL:CL9CLCL*CL*CL CLR-1 DD* D  D<'+#',0AS$AS! AS  AS  AS*AS ASrBr^ceZdZdZd dZ d d dZddd d dZ d ddZ d ddZ d dd Z y)r_aA client for synchronous operations on a key-value store. Provides methods to interact with a remote key-value store, allowing storage and retrieval of items within namespaced hierarchies. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024")) client.store.put_item(["users", "profiles"], "user123", {"name": "Alice", "age": 30}) ``` c||_yr}rrs r@rzSyncStoreClient.__init__rrBNc|D]}d|vstd|d|||||d}|jjdt||y)aStore or update an item. Args: namespace: A list of strings representing the namespace path. key: The unique identifier for the item within the namespace. value: A dictionary containing the item's data. index: Controls search indexing - None (use defaults), False (disable), or list of field paths to index. ttl: Optional time-to-live in minutes for the item, or None for no expiration. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") client.store.put_item( ["documents", "user123"], key="item456", value={"title": "My Document", "content": "Hello World"} ) ``` rr r!r"r'rNr(r*s r@r,zSyncStoreClient.put_itemsjD Ee| /w6gh  #   n>'+BG TrBr-c|D]}d|vstd|d|dj|d}|||d<|jjd||S)axRetrieve a single item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. refresh_ttl: Whether to refresh the TTL on this read operation. If None, uses the store's default behavior. headers: Optional custom headers to include with the request. Returns: Item: The retrieved item. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") item = client.store.get_item( ["documents", "user123"], key="item456", ) print(item) ``` ```shell ---------------------------------------------------------------- { 'namespace': ['documents', 'user123'], 'key': 'item456', 'value': {'title': 'My Document', 'content': 'Hello World'}, 'created_at': '2024-07-30T12:00:00Z', 'updated_at': '2024-07-30T12:00:00Z' } ``` rr r!r#rr.r'rr1r2s r@r3zSyncStoreClient.get_item,ssV Ee| /w6gh  388I+>?  "$/F= !yy}}^FG}LLrBcF|jjd||d|y)a&Delete an item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. headers: Optional custom headers to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") client.store.delete_item( ["documents", "user123"], key="item456", ) ``` r'rrNr+r5s r@r6zSyncStoreClient.delete_itembs'6  9!Ew  rBcb||||||d}|jjdt||S)aSearch for items within a namespace prefix. Args: namespace_prefix: List of strings representing the namespace prefix. filter: Optional dictionary of key-value pairs to filter results. limit: Maximum number of items to return (default is 10). offset: Number of items to skip before returning results (default is 0). query: Optional query for natural language search. refresh_ttl: Whether to refresh the TTL on items returned by this search. If None, uses the store's default behavior. headers: Optional custom headers to include with the request. Returns: List[Item]: A list of items matching the search criteria. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") items = client.store.search_items( ["documents"], filter={"author": "John Doe"}, limit=5, offset=0 ) print(items) ``` ```shell ---------------------------------------------------------------- { "items": [ { "namespace": ["documents", "user123"], "key": "item789", "value": { "title": "Another Document", "author": "John Doe" }, "created_at": "2024-07-30T12:00:00Z", "updated_at": "2024-07-30T12:00:00Z" }, # ... additional items ... ] } ``` r8r<rr=r>s r@r?zSyncStoreClient.search_itemssFt!1&  yy~~ !w(?  rBc`|||||d}|jjdt||S)aList namespaces with optional match conditions. Args: prefix: Optional list of strings representing the prefix to filter namespaces. suffix: Optional list of strings representing the suffix to filter namespaces. max_depth: Optional integer specifying the maximum depth of namespaces to return. limit: Maximum number of namespaces to return (default is 100). offset: Number of namespaces to skip before returning results (default is 0). headers: Optional custom headers to include with the request. Returns: List[List[str]]: A list of namespaces matching the criteria. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") namespaces = client.store.list_namespaces( prefix=["documents"], max_depth=3, limit=10, offset=0 ) print(namespaces) ``` ```shell ---------------------------------------------------------------- [ ["documents", "user123", "reports"], ["documents", "user456", "invoices"], ... ] ``` rArDrr=rEs r@rFzSyncStoreClient.list_namespacessC\"  yy~~ nW&=w  rBr{rGrHrJr}rKrLrMrNrPrRrrBr@r_r_s =A!,0.U .U  .U : .U.U*.U .U .Ul'+,04M 4M 4M $ 4M*4M 4Mv-1    *      F,0#&*,0C ) C  C  C C $C *C 'C  C N'+&*#',06 #6 $6 ! 6  6  6 *6  6 rBr_c\|jDcic] \}}| || c}}Scc}}wr}r)drrs r@r)r)s(WWY 8TQ!-AqD 88 8rzlist[httpx.ASGITransport]rqc(tD] }||_ yr})rqr_)r_rms r@configure_loopback_transportsrs+  rBr)maxsizecf ddlm}|jS#t$rtjcYSwxYw)Nrasgi_transport) langgraph_apir ASGITransport ImportErrorrurs r@rprp s1#0+++ #"""#s 00r})r=rFrrF)r=rFrHrrzdict[str, str])rWrrr) rYrFr=rFrJrrZOptional[TimeoutTypes]rr[)rrrztuple[dict[str, str], bytes])rzhttpx.Responserr) rYrFr=rFrJrrZrrrS)rrN)r_rrr)rzType[httpx.ASGITransport])br __future__rr functoolsloggingr:rtypingrrrrrr r r r r rrur httpx._typesrrFlanggraph_sdk.schemarrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.langgraph_sdk.sser/r0r1 getLoggerrrrDrArKrXrzr[r~rrrrrrrrWrSrZrfrdr[r\r]r^r_r)rq__annotations__r lru_cacherpfloattuplerx TimeoutTypesrrBr@rs#      (         BJI   8 $"   ,D(P!(,&* D# D#D#& D# $ D#  D#N,,(__D  V V rn n b\ W\ W~GYGYTX X z!(,&* 5' 5'5'& 5' $ 5'  5'p00.^^B 0 H H Vf f RR QR Qj~S~SBQ Q h95716 Q# # UO (5/8E?HUOXe_ LM MM rB