-UiJ) UdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;mdZHGddZIGddZJd?dZKd@dZLGddZMGddZNGddZOGddZPGdd ZQddddd dAd"ZRGd#d!ZSGd$d%ZTd?d&ZUd@d'ZVGd(d)ZWGd*d+ZXGd,d-ZYGd.d/ZZGd0d1Z[dBd2Z\gZ]d3e^d4<dCd5Z_ejd67dDd8ZaedebeceebeebfeceebeebeebeebfejfZey)EaThe 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) AsyncIteratorIteratorSequence)AnyCallableLiteralOptionalUnionoverload)QueryParamTypes) All AssistantAssistantSortByAssistantVersion CancelAction CheckpointCommandConfigCronDisconnectMode GraphSchema IfNotExistsItemJsonListNamespaceResponseMultitaskStrategyOnCompletionBehaviorOnConflictBehaviorRun RunCreateRunCreateMetadata 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 p/home/jay/workspace/tools/ai-image-gen/jaaz-app/server/venv/lib/python3.12/site-packages/langgraph_sdk/client.py _get_api_keyr@Ks]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 'r8z User-Agentzlanggraph-sdk-py/r1)RESERVED_HEADERS ValueError langgraph_sdk __version__r@)r<custom_headersheaderheaderss r? _get_headersrJ[s$)rN"G ^ #;F81EF FG )-*C*C)DE G7#G&  NrAc8t|dr%t|jr|jSt|dr%t|jr|jSt |t t fr t|Stdt|d)N model_dumpdictzObject of type z is not JSON serializable) hasattrcallablerLrM isinstanceset frozensetlist TypeErrortype)objs r?_orjson_defaultrWoswsL!hs~~&>~~ f (388"4xxz C#y) *Cy/$s)4MNOOrAz5(\/threads\/(?P.+))?\/runs\/(?P.+)c|jjdx}rFtj|x}r/t |j d|j dxsdSy)z/Extract run metadata from the response headers.zContent-Locationrun_id thread_idN)rYrZ)rIget_RUN_METADATA_PATTERNsearchr"group)responsecontent_locationmatchs r?_get_run_metadata_from_responserbsh%,,001CDDD&--.>??? ;;x(kk+.6$  rA)urlr<rItimeoutLangGraphClientc 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)ri)rjhttp://localhost:8123retries,connectreadwritepoolbase_url transportrdrI)r9environr[get_asgi_transport_registered_transportsappendlanggraph_api.serverri ExceptionhttpxAsyncHTTPTransport AsyncClientTimeoutrJre)rcr<rIrdrwriclients r? get_clientrsP59I { ::>>@ AV K,*,KI " ) )) 4C .4"0.0 J ,,Q7   " MM' "qs#AFWg. F 6 "" .- .sC C.-C.ceZdZdZddZy)reaTop-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 StoreClientstoreselfrs r?__init__zLangGraphClient.__init__s^v& *4995$TYY/ tyy)  *  + rANrzhttpx.AsyncClientreturnNone__name__ __module__ __qualname____doc__rrAr?reres ,rAceZdZdZddZdddd ddZddd ddZddd ddZddd dd Zdddd  dd Z ddddd  dd Z y)rzHandle 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||_yrrrs r?rzHttpClient.__init__  rANparamsrI on_responsecK|jj|||d{}|r|| |jt|d{S72#tj$rn}|j d{7j }tjdk\r|j||tjd|||d}~wwxYw7w)Send a GET request.rrIN Error from langgraph-api: exc_info) rr[raise_for_statusr~HTTPStatusErrorareaddecodesys version_infoadd_noteloggererror _adecode_jsonrpathrrIrrebodys r?r[zHttpClient.gets++//$vw/G G  N    #1%%% H $$ '')OO++-D7* 4 G 9$@1 MG  &sK"CACACCCC,C?BACCCrIrc&K|t|d{\}}nid}}|r|j||jj|||d{}|r|| |j t|d{S7s74#t j $rn}|jd{7j} tjdk\r|j| |tjd| ||d}~wwxYw7wzSend a POST request.NrArIcontentrrr) _aencode_jsonupdaterpostrr~rrrrrrrrr rrjsonrIrrequest_headersrrrrs r?rzHttpClient.posts  -:4-@'@ $OW')3WO   " "7 +++""4'"R R  N    #1%%%%(A S $$ '')OO++-D7* 4 G 9$@1 MG  &s_DBADB D$B 4DDD D D D1B42ADD  DcKt|d{\}}|r|j||jj|||d{}|r|| |j t|d{S7n74#t j $rn}|jd{7j} tjdk\r|j| |tjd| ||d}~wwxYw7w)Send a PUT request.Nrrrr)rrrputrr~rrrrrrrrrrs r?rzHttpClient.put,s*7t)<#<    " "7 +++//$/Q Q  N    #1%%%$= R $$ '')OO++-D7* 4 G 9$@1 MG  &^D B;D  BD B-D ;D<D D DD*B-+ADDD cKt|d{\}}|r|j||jj|||d{}|r|| |j t|d{S7n74#t j $rn}|jd{7j} tjdk\r|j| |tjd| ||d}~wwxYw7w)Send a PATCH request.Nrrrr)rrrpatchrr~rrrrrrrrrrs r?rzHttpClient.patchFs*7t)<#<    " "7 +++##D/7#S S  N    #1%%%$= T $$ '')OO++-D7* 4 G 9$@1 MG  &rrrIrcK|jjd|||d{}|r|| |jy7 #tj$rn}|j d{7j }tjdk\r|j||tjd|||d}~wwxYww)Send a DELETE request.DELETErrINrrr) rrequestrr~rrrrrrrrrrrrIrrrrs r?deletezHttpClient.delete`s++%%h4%Q Q  N    R $$ '')OO++-D7* 4 G 9$@1 MG  s?#C AC AC C C.A1/ACC  C rrrIrcKt|d{\}}d|d<d|d<|r|j||jj|||||4d{} |r||  | 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-ControlrIrrrrr content-type;rJExpected response header Content-Type to contain 'text/event-stream', got  )line)rrrstreamrr~rrrrrrrrrIr[ partitionTransportErrorr.r/rstriprrmethodrrrIrrrresrr content_typedecoderrsses r?rzHttpClient.streamvs*7t)<#< $7!+5(   " "7 +;;%% D/76&    C  $$&;;??>2>HHMaPL",6**'*, !lG-c2  dnn$++e*D AF>DF> F)*D:AF)FFF!$F)F) F>F>F#F 6D97AF  FF)FF) F>"F%#F>)F;/F2 0F;7F>r rstrrOptional[QueryParamTypes]rIOptional[dict[str, str]]r*Optional[Callable[[httpx.Response], None]]rr rrrOptional[dict]rIrrrrr rrrrMrIrrrrr rrrz Optional[Any]rIrrrrr)rrrrrrrrrIrrrrAsyncIterator[StreamPart] rrrrrr[rrrrrrrAr?rrs-1,0BF &&* & * & @ & &8-1BF && & * & @ & &F-1BF && & * & @ & &>-1BF && & * & @ & &<#,0BF   *  @  6 $,0,0BF---  - * -*-@- #-rArcK|idfStjjdtj|t tj tjzd{}tt|}d}||d}||fS7#wNzapplication/json)zContent-Lengthz Content-Type) asyncioget_running_looprun_in_executororjsondumpsrWOPT_SERIALIZE_NUMPYOPT_NON_STR_KEYSrlenrrcontent_lengthrrIs r?rrs |4x))+;;   ""V%<%<<  DT^N%L!/NG D= sA"B $B%$B cK|jd{}|r;tjjdtj |d{SdS7C7wr)rrrrrloadsrrs r?rrsT?D &&(88v||TRR Rs!AA=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_idconfigr'rr(r)r* /assistantsrNrr rr,r-r'rr(r)rIr*payloads r?createzAssistantsClient.creates\ #   &GH  "*GJ  &2GN # #,GK "GFO %0GM "YY^^M^QQQQsAAAAr,r-r'r)rIr*cKi}|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} ) ``` r,r-r'r)r*rrNrr rrr,r-r'r)rIr*r1s 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.delete8s,2iil^r?/assistants/searchrNr/) rr'r,r<r=r>r?rIr1s r?r]zAssistantsClient.searchSsyN#  "*GJ  "*GJ  !(GI  $.GL !YY^^ $    sAA A A czK||d}|r||d<|jjd|d||d{S7w)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[AssistantVersion]: A list of assistant versions. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant_versions = await client.assistants.get_versions( assistant_id="my_assistant_id" ) ``` rAr'r /versionsrNr/rrr'r<r=rIr1s r? get_versionszAssistantsClient.get_versionssY@#  "*GJ YY^^<. 2'$    2;9;cjKd|i}|jjd|d||d{S7w)aPChange 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_client(url="http://localhost:2024") new_version_assistant = await client.assistants.set_latest( assistant_id="my_assistant_id", version=3 ) ``` versionr/latestrNr/rrrIrIr1s r? set_latestzAssistantsClient.set_latestsF:$-g"6YY^^<. 0w$    s *313rrrrrrrIrrrrrrzUnion[int, bool]rIrrzdict[str, list[dict[str, Any]]]rrrIrrrNF rrr$ Optional[str]r!boolrIrrr(rr,rSr-Optional[Config]r'rrrSr(Optional[OnConflictBehavior]r)rSrIrr*rSrrrrr,rSr-rVr'rr)rSrIrr*rSrrrrrIrrr)r'rr,rSr<intr=rZr>zOptional[AssistantSortBy]r?Optional[SortOrder]rIrrlist[Assistant]Nr;r rrr'rr<rZr=rZrIrrzlist[AssistantVersion]rrrIrZrIrrrrrrrrr[rrr%r2rrr]rFrLrrAr?rrs IM$S$S-E$S $ST"',0 2 2  2 * 2 ) 2 jIMr r -Er r n$(  -1 !  *  H$(<R &*26",0%)<R<R!<R  <R $ <R0<R<R*<R#<R <RD#'#'",0%)9 9  9 ! 9  9 9 *9 #9  9 ~-1 OO* O  O<"&-1*.,06 6  6  6  6 +6 (6 *6  6 v ' -1' ' '  '  ' *'  ' \-1 ! ! ! * !  ! rArc veZdZdZddZdd ddZddddddd ddZdd ddZdd dd Zdddd d dddd  dd Z dd ddZ dddd ddZ ddddd ddZ d ddddd ddZ y) raClient for managing threads in LangGraph. A thread maintains the state of a graph across multiple interactions/invocations (aka runs). It accumulates and persists the graph's state, allowing for continuity between separate invocations of the graph. ???+ example "Example" ```python client = get_client(url="http://localhost:2024")) new_thread = await client.threads.create(metadata={"user_id": "123"}) ``` c||_yrr r s r?rzThreadsClient.__init__r rANrc^K|jjd||d{S7w)aQGet 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_client(url="http://localhost:2024") thread = await 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'} } ``` /threads/rNrrrZrIs r?r[zThreadsClient.gets-FYY]]Yyk#:G]LLLLrr'rZr( superstepsr,rIc DKi}|r||d<|s|ri|xsi|rd|ini|d<|r||d<|rA|D cgc]0}d|dD cgc]} | d| jd| dd c} i2c} }|d <|jjd || d {Scc} wcc} }w7w)axCreate 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_client(url="http://localhost:2024") thread = await client.threads.create( metadata={"number":1}, thread_id="my-thread-id", if_exists="raise" ) ``` rZr,r'r(updatesvaluescommandas_noderjrkrlrg/threadsrNr[rr rr'rZr(rgr,rIr1sus r?r2zThreadsClient.createsJ#% #,GK x#>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}, ) ``` rdr'rNr5rrZr'rIs r?rzThreadsClient.updateOs?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" ) ``` rdrNr9res r?rzThreadsClient.deletens,,ii9+6HHHr:r;r)r'rjstatusr<r=r>r?rIcK||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 ) ``` rAr'rjrwr>r?/threads/searchrNr/) rr'rjrwr<r=r>r?rIr1s r?r]zThreadsClient.searchsT#  "*GJ   &GH   &GH  !(GI  $.GL !YY^^ $    r7cbK|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" ) ``` rd/copyNrr/res r?copyzThreadsClient.copys<,YY^^ {% (tW$    s &/-/F subgraphsrIc,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' } } ``` rd/state/checkpoint checkpointr~rN/state/r~r/staterrr[rrZr checkpoint_idr~rIs r? get_statezThreadsClient.get_statesX I;&78$.YG(  I;gm_=#Y/'  I;f-#Y/'   s3+BB/BB+B B BBBrlrrrIcKd|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': {} } } ``` rjrrrlrdrrNr/rrZrjrlrrrIr1s r? update_statezThreadsClient.update_state\srb f#  '4GO $ $.GL ! !(GI YY^^ {& )$    ?AAAr<beforer'rrIcKd|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<rr'rrd/historyrNr/rrZr<rr'rrIr1s r? get_historyzThreadsClient.get_historysrF U#   &GH  "*GJ  $.GL !YY^^ {( +'7$    rrMrZrrIrrr)r'rrZrSr(rWrgz7Optional[Sequence[dict[str, Sequence[dict[str, Any]]]]]r,rSrIrrr)rZrr'dict[str, Any]rIrrr)rZrrIrrr)r'rrjrrwOptional[ThreadStatus]r<rZr=rZr>zOptional[ThreadSortBy]r?r[rIrr list[Thread]NN rZrrOptional[Checkpoint]rrSr~rTrIrrr+rZrrjz%Optional[Union[dict, Sequence[dict]]]rlrSrrrrSrIrrr-rZrr<rZrzOptional[str | Checkpoint]r'rrrrIrrzlist[ThreadState]rrrrrr[r2rrr]r|rrrrrAr?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- -  - + - ! - )- *-  - rArceZdZdZd'dZeddddddddddddddddddddd d(dZeddddddddddddddddddd d)d Zdddddddddddddddddddddd  d*d Zeddddddddddddddddd  d+d Zeddddddddddddddddddd d,dZdddddddddddddddddddd d-dZd.dZedddddddddddddddddd d/dZ edddddddddddddddd d0dZ ddddddddddddddddddd d1dZ ddddd d2dZ dd d3dZ dd dd! d4d"Z dd d5d#Z ddddd$ 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||_yrr r s r?rzRunsClient.__init__r rANrjF)inputrk stream_modestream_subgraphsstream_resumabler'r-rrcheckpoint_duringinterrupt_beforeinterrupt_after feedback_keys on_disconnectwebhookmultitask_strategy if_not_exists after_secondsrIon_run_createdcyrr)rrZrrrkrrrr'r-rrrrrrrrrrrrIrs r?rzRunsClient.streams4%(rArrkrrrr'r-rrrrr on_completionrrrrIrcyrrrrZrrrkrrrr'r-rrrrrrrrrrIrs r?rzRunsClient.streams0%(rArrkrrrr'r-rrrrrrrrrrrrrIrc id|d|r'|jDcic] \}}| || c}}ndd| d|d|d|d|d |d | d |d |d |d| d| d| d|d||||d}|d|dnd}dfd }|jj|d|jDcic] \}}| || c}}|r|SdScc}}wcc}}w)a2Create 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. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. 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. on_run_created: Callback when a run is created. 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) ``` rrkNr-r'rrrrrrrrrrrrrrrrrd /runs/streamc8rt|x}r |yyyz)Callback function to handle the response.Nrbrr'rs r?rz&RunsClient.stream..on_response&/Ns/S#S8#Sx($T~rAPOSTrrhttpx.ResponseitemsrrrrZrrrkrrrr'r-rrrrrrrrrrrrrIrkvr1endpointrs ` r?rzRunsClient.streams| U GN'--/C$!QQ]ACTX f     ;   0   0  L   0    ]  w  * ]! " !2# $ !"4% & ]' (+**- 4$ {, /   ) yy  #*==?D41aam!Q$D'5    <@    ADFE C C C +C )rrkrrrr'rr-rrrrrrrIrc Kywrr)rrZrrrkrrrr'rr-rrrrrrrIrs r?r2zRunsClient.creates ,rrkrrrr'r-rrrrrrrrrrIrc KywrrrrZrrrkrrrr'r-rrrrrrrrrrIrs r?r2zRunsClient.creates 0r)rrkrrrr'r-rrrrrrrrrrrIrcKid|d|r'|jDcic] \}}| || c}}ndd|d|d|d| d|d |d | d |d |d | d| d| d|d|d|d|i}|jDcic] \}}| || }}}dfd }|jj|rd|dnd||r|ndd{Scc}}wcc}}w7w)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. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. 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. on_run_created: Optional callback to call when a run is created. 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' } ``` rrkNrrrr-r'rrrrrrrrrrrc8rt|x}r |yyyrrrs r?rz&RunsClient.create..on_responsebrrArd/runsrrrrr)rrZrrrkrrrr'r-rrrrrrrrrrrIrrrr1rs ` r?r2zRunsClient.creates~ U GN'--/C$!QQ]ACTX ;   0    0  f    L   0    w  *  ] !2! " !"4# $ ]% & ]' ( ]) ,%,MMOEDAqq}1a4EE ) YY^^,5i {% (7'5 4 $   5D&F s3C C C A C9 C C  7CCCcKdd}|Dcgc] }|| }}|jjd|d{Scc}w7 w),Create a batch of stateless background runs.c\|jDcic] \}}| || c}}Scc}}wrrr1rrs r?filter_payloadz/RunsClient.create_batch..filter_payloadq(%,]]_FTQ AqDF FF (( /runs/batch)rNr1r!r/)rpayloadsrr1s r? create_batchzRunsClient.create_batchnsJ G.on_response(rrAr __error__rz: messager)rrrrPrMr}r[)rrZrrrkr'r-rrrrrrrrrrrrrIrrrr1rrr_s ` r?rzRunsClient.waitsR U GN'--/C$!QQ]ACTX f     L   0    w  *  ]  !"4  !2  ] ]! " ]# $ ]% *2;1Fi {* -L  )  #*==?D41aam!Q$D'5 4 (   8T*x'8K0$7K(,,W56b+9N9R9RS\9]8^_ SD8E s4D, D D A*D, D$ #D$ (D,:D*;A0D,r;r)r<r=rwrIczK||d}|||d<|jjd|d||d{S7w)aList runs. Args: thread_id: The thread ID to list runs for. limit: The maximum number of results to return. offset: The number of results to skip. status: The status of the run to filter by. headers: Optional custom headers to include with the request. Returns: list[Run]: The runs for the thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.runs.list( thread_id="thread_id", limit=5, offset=5, ) ``` rANrwrdrrr)rrZr<r=rwrIrs r?rSzRunsClient.list>s\D   %F8 YY]] {% (#    rGrcdK|jjd|d||d{S7w)a Get 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 client = get_client(url="http://localhost:2024") run = await client.runs.get( thread_id="thread_id_to_delete", run_id="run_id_to_delete", ) ``` rd/runs/rNrrrZrYrIs r?r[zRunsClient.getis>2YY]] {& 17#    ru interruptractionrIc 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" ) ``` rdr /cancel?wait=r&action=Nrr/rrZrYrrrIs r?cancelzRunsClient.cancelsVFYY^^ {& 4aQ=OxX^W_ `$    rGcfK|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" ) ``` rdr/joinrNrrs r?joinzRunsClient.joins@0YY]] {& 6#    r)cancel_on_disconnectrrI last_event_idcx|jjd|d|dd||di|rd|ini|xsixsdS) 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) ``` rdr/streamGET)rr Last-Event-IDNrrr)rrZrYrrrIrs r? join_streamzRunsClient.join_streamsmNyy {& 8 (<*7DO]3"=b  rAcfK|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" ) ``` rdrrNr9rs r?rzRunsClient.delete s20ii9+VF8DgVVVs '1/1rM).rZrrrrrrkOptional[Command]r'Union[StreamMode, Sequence[StreamMode]]rrTrrTr'rr-rVrrrrSrOptional[bool]r#Optional[Union[All, Sequence[str]]]rrrOptional[Sequence[str]]rOptional[DisconnectMode]rrSrOptional[MultitaskStrategy]rOptional[IfNotExists]r Optional[int]rIrr-Optional[Callable[[RunCreateMetadata], None]]rr)*rZrrrrrrkrrrrrTrrTr'rr-rVrrrrrrrrrrrOptional[OnCompletionBehavior]rrrrSrrrIrrr rr)0rZrSrrrrrkrrrrrTrrTr'rr-rVrrrrSrrrrrrrrrrrr rrSrrrrrrrIrrr rr)&rZrrrrrrkrrrrrTrrTr'rrrr-rVrrrrrrSrr rrrrrIrrr rr *rZrrrrrrkrrrrrTrrTr'rr-rVrrrrSrrrrrrrrSrrrrrrrIrrr rr ),rZrSrrrrrkrrrrrTrrTr'rr-rVrrrrSrrrrrrrrSrrrrrr rrrIrrr rr )rlist[RunCreate]r list[Run])(rZrrrrrrkrr'rr-rVrrrrSrrrrrrrrSrrrrrrrrrrTrIrrr r!Union[list[dict], dict[str, Any]])$rZrrrrrrkrr'rr-rVrrrrrrrrSrrrr rrrrrrTrIrrr rr)*rZrSrrrrrkrr'rr-rVrrrrSrrrrrrrrSrrrr rrrrrrrrTrIrrr rr) rZrr<rZr=rZrwzOptional[RunStatus]rIrrr rZrrYrrIrrr rZrrYrrrTrrrIrrrrZrrYrrIrrrM)rZrrYrrrTr1Optional[Union[StreamMode, Sequence[StreamMode]]]rIrrrSrrrZrrYrrIrrrrrrrrr rr2rrrSr[rrrrrrAr?rrs   !%%)?G!&!&#'#'+/'+,0@D?C1526!%:>/3'+,0HL1(((  ( # (=(((!(!()(%(*(>( =!("/#($0%(&'((8)(*-+(,%-(.*/(0F1(2 #3((6 !%%)?G!&!&#'#',0@D?C15268(=(/( 0!("6#($-%(&'((%)(**+(,F-(. #/((<!%%)?G!&!&#'#'+/'+,0@D?C15268/3'+,0HL3G  G G  G # G =G G G !G !G )G %G *G >G =!G "/#G $0%G &6'G ()G *8+G ,--G .%/G 0*1G 2F3G 4 #5G R !%%)?G!&!&#',0#'@D?C!%8= 6!"-#$%%&*'(F)* +. !%%)?G!&!&#'#'+/'+,0@D?C!%:>/3'+,0HL-   # =!!)%*> =!"#$8%&-'(%)**+,F-. /<!%%)?G!&!&#'#'+/'+,0@D?C!%:>/38<'+,0HL/a  a a  a # a =a a a !a !a )a %a *a >a =!a "#a $8%a &-'a (6)a *%+a ,*-a .F/a 0 1a FB !%%)#'#'+/'+,0@D?C!%26:>/3'+ ,0HL+000  0 # 0!0!0)0%0*0>0=0000 8!0"-#0$%%0&'0(*)0*F+0, +-000 !%%)#'#',0@D?C!%2680=000060-0 %!0"#0$*%0&F'0( +)006!%%)#'#'+/'+,0@D?C!%268<:>/3'+ ,0HL-U UU  U # U!U!U)U%U*U>U=UU0U 6!U"8#U$-%U&%'U()U**+U,F-U. +/Uv&*,0) )  )  ) $ ) *)  ) XSW  &) 7O  D*,0' ' '  '  ' *'  ' TSW  &) 7O  B&+IM,0'+3 3 3 # 3 G 3 *3 %3  #3 lSWWW&)W7OW WrArc 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||_yrr r http_clients r?rzCronClient.__init__3  rAN rr'r-rrrrrrIc 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" ) ``` schedulerr-r'rrrrrrNrd /runs/cronsrr)rrZrrrr'r-rrrrrrIr1rrs r?create_for_threadzCronClient.create_for_thread6 st! (!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" ) ``` rrNrrrrrrrr'r-rrrrrrIr1rrs r?r2zCronClient.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/rNr9rcron_idrIs r?rzCronClient.delete s,0iigY7IIIr:r;rrrZr<r=rIcK||||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' } ] ``` rrZr<r=N/runs/crons/searchrr rrrZr<r=rIr1rrs r?r]zCronClient.search sjx)"   %,MMOEDAqq}1a4EEYY^^$8wPW^XXXFXs A AA$AA A)rrrr)rZrrrrrrrr'rr-rVrrrOptional[Union[All, list[str]]]rr+rrSrrSrIrrr rrrrrrr'rr-rVrrrr+rr+rrSrrSrIrrr rr%rrIrrr rrSrZrSr<rZr=rZrIrrz list[Cron] rrrrrrr2rr]rrAr?rr s. !%#'#',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 BYrArceZdZdZd 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||_yrr r s r?rzStoreClient.__init__3 r rANcK|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 ('.').r$keyvalueindexttl /store/itemsrNrDrr_provided_vals rr$r7r8r9r:rIlabelr1s r?put_itemzStoreClient.put_item6 s~D Ee| /w6gh  #  iimm !8'   s AAAAA refresh_ttlrIcK|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' } ``` r3r4r5r$r7NrBr;rrDrrr[rr$r7rBrIr?rs r?get_itemzStoreClient.get_itemh 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;rDrNr9rr$r7rIs 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=queryrB/store/items/searchrNrrr= rrMrNr<r=rOrBrIr1s 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/namespacesrNrQrr=rVrWr<r=rIr1s r?list_namespaceszStoreClient.list_namespaces sSX"  YY^^ ($    s 3<:<rMNNNr7rr8rr9z*Optional[Union[Literal[False], list[str]]]r:rrIrr$ Sequence[str]rr r7rr$r]rBrrIrrrrr7rrIrr$r]rrNr;rNNNrNzOptional[dict[str, Any]]r<rZr=rZrOrSrBrrIrrMr]rr$NNNdrNr=Optional[list[str]]rVrerWrr<rZr=rZrIrrr rrrrrr@rGrJrSrZrrAr?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 rArSyncLangGraphClientc |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") ``` rkrlrmrorpru)r~ HTTPTransportClientrrJrg)rcr<rIrdrwrs r?get_sync_clientrk@ srN {%##A.I \\" MM' "qs#AFWg. F v &&rAceZdZdZddZy)rga~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/ rANrz httpx.ClientrrrrrAr?rgrgx s  0rAceZdZdZddZdddd ddZddd ddZddd ddZddd dd Zdddd  dd Z ddddd  dd Z y)rna8Handle 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||_yrrrs r?rzSyncHttpClient.__init__ rrANrc|jj|||}|r|| |jt|S#tj$re}|j j }tjdk\r|j||tjd|||d}~wwxYw)rrrrrN) rr[rr~rrrrrrrrr _decode_jsonrs r?r[zSyncHttpClient.get s KKOODO A  N    A$$ 668??$D7* 4 G 9$@1 MG  sAB=A B88B=rc|t|\}}nid}}|r|j||jj|||}|r|| |j t|S#t j $re}|jj} tjdk\r|j| |tjd| ||d}~wwxYwr) _encode_jsonrrrrr~rrrrrrrrrrxrs r?rzSyncHttpClient.post s  '3D'9 $OW')3WO   " "7 + KK  T?G  L  N    A$$ 668??$D7* 4 G 9$@1 MG  sA--C%A C  C%ct|\}}|r|j||jj|||}|r|| |j t|S#t j $re}|jj} tjdk\r|j| |tjd| ||d}~wwxYw)rrrrrN)rzrrrrr~rrrrrrrrrrxrs r?rzSyncHttpClient.put s$0#5    " "7 + KKOOD/7O K  N    A$$ 668??$D7* 4 G 9$@1 MG   A&&C9A CCct|\}}|r|j||jj|||}|r|| |j t|S#t j $re}|jj} tjdk\r|j| |tjd| ||d}~wwxYw)rrrrrN)rzrrrrr~rrrrrrrrrrxrs r?rzSyncHttpClient.patch s$0#5    " "7 + KK  dOW  M  N    A$$ 668??$D7* 4 G 9$@1 MG  r|rcn|jjd|||}|r|| |jy#tj$re}|j j }tjdk\r|j||tjd|||d}~wwxYw)rrrrrrN) rrrr~rrrrrrrrrrs r?rzSyncHttpClient.delete s KK  $T7  K  N    $$ 668??$D7* 4 G 9$@1 MG  s<B4A B//B4rc#Kt|\}}d|d<d|d<|r|j||jj|||||5} |r||  | 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)rzrrrrr~rrrrrrrrrrIr[rrr.r0rrs r?rzSyncHttpClient.stream s$0#5 $7!+5(   " "7 + [[   D/76    C  $$&;;??>2>HHMaPL",6**'*, !lG&s+ nnT[[%78?I 1  ((  **,##w.JJt$LL#=dV!DqLQ    sJA F E:C?*BE:/E:6 F?E7A E22E77E::F?Frtrrrr)rrrrrrrrrIrrrrIterator[StreamPart]rrrAr?rnrn s-1,0BF *  *  @  8-1BF   *  @  D-1BF   *  @  @-1BF   *  @  <#,0BF   *  @  6 $,0,0BF+++  + * +*+@+ +rArnctj|ttjtjz}t t |}d}||d}||fSr)rrrWrrrrrs r?rzrzJ sR << ""V%<%<< D T^N%L!/NG D=rAcT|j}|rtj|SdSr)rrrrrs r?rxrxV s# 668D!%6<< /4/rAceZdZdZddZdd ddZddd ddZdd dd Z ddd dd Z dddddddd  dd Z ddddddd  ddZ dd ddZ dddddd d dZ d!dd d"dZ dd d#dZy)$roagClient 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||_yrr r s r?rzSyncAssistantsClient.__init__h r rANrcB|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?r[zSyncAssistantsClient.getk s#Lyy}}|L>:G}LLrAFrcJ|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__'} ] } ``` rrrrrrs r?rzSyncAssistantsClient.get_graph s4Xyy}}<. /PW  rAcD|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_schemas s%byy}}|L>BG}TTrAc|&|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. rr r!rr"rr#s r?r%z"SyncAssistantsClient.get_subgraphs6 sr$  99==|nK {C!7+!  99==|nJ7!7+! rAr&cd|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" ) ``` r,r-r'rr(r)r*r.rr/r0s r?r2zSyncAssistantsClient.createU sy\ #   &GH  "*GJ  &2GN # #,GK "GFO %0GM "yy~~m'7~KKrAr3ci}|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} ) ``` r,r-r'r)r*rrr5r6s r?rzSyncAssistantsClient.update stR#% "*GJ   &GH  "*GJ  "GFO %0GM "yy<. )  rAcD|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" ) ``` rrNr9rs r?rzSyncAssistantsClient.delete s"2 < ~6HrAr;r)r'r,r<r=rIcd||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 ) ``` rAr'r,rBrr/)rr'r,r<r=rIr1s r?r]zSyncAssistantsClient.search sQF#  "*GJ  "*GJ yy~~   rAc^||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" ) ``` rAr'rrDrr/rEs r?rFz!SyncAssistantsClient.get_versionssKB#  "*GJ yy~~<. 2'  rAcNd|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 ) ``` rIrrJrr/rKs r?rLzSyncAssistantsClient.set_latestBs8:$-g"6yy~~<. 0w  rArrnrrrNrOrPrQrRrrUrXrY) r'rr,rSr<rZr=rZrIrrr\r]r^r_r`rrAr?roro[ 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 ! ! ! * !  ! rArocjeZdZdZddZdd ddZddddddd ddZdd ddZdd dd Zdddd d dd  dd Z dd ddZ dddd ddZ ddddd ddZ d ddddd ddZ y) rpa}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||_yrr r s r?rzSyncThreadsClient.__init__tr rANrcB|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'} } ``` rdrrres r?r[zSyncThreadsClient.getws#Jyy}}y 4g}FFrArfc (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" ) ``` ) rZr,r'r(rirjrkrlrmrgrnrrorps r?r2zSyncThreadsClient.createsL#% #,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}, ) ``` rdr'rr5rts r?rzSyncThreadsClient.updates16yy { #:x*@'  rAcD|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" ) ``` rdrNr9res r?rzSyncThreadsClient.deletes"0 9YK0'BrAr;r)r'rjrwr<r=rIcr||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 ) ``` rAr'rjrwryrr/)rr'rjrwr<r=rIr1s r?r]zSyncThreadsClient.searchsUJ#  "*GJ   &GH   &GH yy~~/gw~OOrAcF|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" ) ``` rdr{Nrr/res r?r|zSyncThreadsClient.copyHs&2yy~~ )E:w~WWrAFr}c|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' } } ``` rdrrrrr~rrrrs r?rzSyncThreadsClient.get_statecsX 99>>I;&78$.YG"  99==I;gm_=#Y/!  99==I;f-#Y/! rArcxd|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': {} } } ``` rjrrrlrdrrr/rs r?rzSyncThreadsClient.update_statesd^ f#  '4GO $ $.GL ! !(GI yy~~ {& )  rArcxd|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<rr'rrdrrr/rs r?rzSyncThreadsClient.get_historysdJ U#   &GH  "*GJ  $.GL !yy~~ {( +'7  rArrrrr)r'rrjrrwrr<rZr=rZrIrrrrrrrrrrAr?rprpfs -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/ /  / + / ! / )/ */  / rArpceZdZdZd&dZedddddddddddddddddddd d'dZeddddddddddddddddddd d(d Zdddddddddddddddddddddd  d)d Zeddddddddddddddddd  d*d Zeddddddddddddddddddd d+dZdddddddddddddddddddd d,dZdd d-dZeddddddddddddddddd d.dZ eddddddddddddddd d/dZ dddddddddddddddddd d0dZ dddd d1dZ dd d2dZ dddd  d3d!Z dd d4d"Z ddddd# d5d$Zdd d6d%Zy)7rqa~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||_yrr r s r?rzSyncRunsClient.__init__]r rANrjF)rrkrrr'r-rrrrrrrrrrrrIrcyrr)rrZrrrkrrr'r-rrrrrrrrrrrrIrs r?rzSyncRunsClient.stream`s2 #rArcyrrrs r?rzSyncRunsClient.stream{s0 #rArc id|d|r'|jDcic] \}}| || c}}ndd| d|d|d|d|d |d | d |d |d |d| d| d| d|d||||d}|d|dnd}dfd }|jj|d|jDcic] \}}| || c}}|r|SdScc}}wcc}}w)aaCreate 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. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. 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. on_run_created: Optional callback to call when a run is created. 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) ``` rrkNr-r'rrrrrrrrrrrrrrrdrc8rt|x}r |yyyrrrs r?rz*SyncRunsClient.stream..on_responserrArrrrrs ` r?rzSyncRunsClient.streamsx U GN'--/C$!QQ]ACTX f     ;   0   0  L   0    ]  w  * ]! " !2# $ !"4% & ]' (+**- 4$ {, /   ) yy  #*==?D41aam!Q$D'5    <@    ADFEr)rrkrrrr'r-rrrrrrrrIrcyrr)rrZrrrkrrrr'r-rrrrrrrrIrs r?r2zSyncRunsClient.creates,rArcyrrrs r?r2zSyncRunsClient.create4s0rA)rrkrrrr'r-rrrrrrrrrrrIrcid|d|r'|jDcic] \}}| || c}}ndd|d|d|d| d|d |d | d |d |d | d| d| d|d|d|d|i}|jDcic] \}}| || }}}dfd }|jj|rd|dnd||r|SdScc}}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. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. 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. on_run_created: Optional callback to call when a run is created. 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' } ``` rrkNrrrr-r'rrrrrrrrrrrc8rt|x}r |yyyrrrs r?rz*SyncRunsClient.create..on_responserrArdrrrr)rrZrrrkrrrr'r-rrrrrrrrrrrIrrrr1rs ` r?r2zSyncRunsClient.createNs~ U GN'--/C$!QQ]ACTX ;   0    0  f    L   0    w  *  ] !2! " !"4# $ ]% & ]' ( ]) ,%,MMOEDAqq}1a4EE ) yy~~,5i {% (7'5   <@   5D&Fs C C 7 CCrczdd}|Dcgc] }|| }}|jjd||Scc}w)rc\|jDcic] \}}| || c}}Scc}}wrrrs r?rz3SyncRunsClient.create_batch..filter_payloadrrrrrr/)rrrIrr1s r?rzSyncRunsClient.create_batchsB  G.on_responserrArdrrrr)rrZrrrkr'r-rrrrrrrrrrrrIrrrr1rrs ` r?rzSyncRunsClient.wait*stR U GN'--/C$!QQ]ACTX f     L   0    w  *  ]  !"4  ]  ] !2! " ]# $ ]% * ) 2;1Fi {* -L yy~~ #*==?D41aam!Q$D'5   <@   5D8Es B: B:  C !C r;r)r<r=rIcN|jjd|d|d||S)ajList runs. Args: thread_id: The thread ID to list runs 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[Run]: The runs for the thread. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.list( thread_id="thread_id", limit=5, offset=5, ) ``` rdz /runs?limit=z&offset=rr)rrZr<r=rIs r?rSzSyncRunsClient.lists7>yy}} {,ugXfX FPW  rAcH|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", ) ``` rdrrrrs r?r[zSyncRunsClient.gets(8yy}}y 6&BG}TTrArrc ^|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" ) ``` rdrrrrrNrr/rs r?rzSyncRunsClient.cancelsHFyy~~ {& 4aQ=OxX^W_ `  rAcJ|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" ) ``` rdrrrrrs r?rzSyncRunsClient.join!s28yy}} {& 6  rA)rrrIrcx|jjd|d|dd||di|rd|ini|xsixsdS) 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"] ) ``` rdrrr)rrrNrr)rrZrYrrrIrs r?rzSyncRunsClient.join_streamAsmLyy {& 8 *(<7DO]3"=b  rAcJ|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" ) ``` rdrrNr9rs r?rzSyncRunsClient.deleteus(8 9YKvfX>PrAr),rZrrrrrrkrrrrrTr'rr-rVrrrrSrrrrrrrrrrrrSrrrrrrrIrrr rr)*rZrrrrrrkrrrrrTrrTr'rr-rVrrrrrrrrrrrr rrrrSrrrIrrr rr)0rZrSrrrrrkrrrrrTrrTr'rr-rVrrrrSrrrrrrrrrrrr rrSrrrrrrrIrrr rr)&rZrrrrrrkrrrrrTrrTr'rr-rVrrrrrrrrSrr rrrrrIrrr rr r ),rZrSrrrrrkrrrrrTrrTr'rr-rVrrrrSrrrrrrrrSrrrr rrrrrIrrr rr )rr rIrrr )&rZrrrrrrkrr'rr-rVrrrrSrrrrrrrrSrrrrrrrrrIrrr rr)"rZrrrrrrkrr'rr-rVrrrrrrrrSrrrr rrrrrIrrr rr)(rZrSrrrrrkrr'rr-rVrrrrrrSrrrrrrSrrrr rrrrrrrIrrr rr) rZrr<rZr=rZrIrrr rrr)rZrrYrrrrrTrIrrrSrrrrrrAr?rqrqOs   !%%)?G!&#'#'+/'+,0@D?C1526!%:>/3'+,0HL/###  # # #=##!#!#)#%#*#>#=# /!#"0##$%#&8'#(-)#*%+#,*-#.F/#0 1##4 !%%)?G!&!&#'#',0@D?C15268#=#/# 0!#"6##$-%#&'#(%)#**+#,F-#. /##<!%%)?G!&!&#'#'+/'+,0@D?C15268/3'+,0HL3E  E E  E # E =E E E !E !E )E %E *E >E =!E "/#E $0%E &6'E ()E *8+E ,--E .%/E 0*1E 2F3E 4 5E N !%%)?G!&!&#'#',0@D?C!%8= 6!"-#$%%&*'(F)* +. !%%)?G!&!&#'#'+/'+,0@D?C!%:>/3'+,0HL-   # =!!)%*> =!"#$8%&-'(%)**+,F-. /<!%%)?G!&!&#'#'+/'+,0@D?C!%:>8a =!a "#a $8%a &6'a (-)a *%+a ,*-a .F/a 0 1a HQU M' M5M M  M !%%)#'#'+/'+,0@D?C!%26:>/3'+,0HL)000  0 # 0!0!0)0%0*0>0=0000 8!0"-#0$%%0&*'0(F)0* ++00. !%%)#'#',0@D?C!%2680=000060-0 %!0"*#0$F%0& +'004!%%)#'#',0+/'+@D?C!%268<:>/3'+,0HL+K  K K  K # K !K !K *K )K %K >K =K K 0K 6!K "8#K $-%K &%'K (*)K *F+K , +-K b,0 ! !  !  ! * !  ! P-1 UUU * U UF*,0' ' '  '  ' *'  ' \-1    *    JJN%*,0'+2 2 2 G 2 # 2 *2 %2  2 r-1 QQQ * Q  QrArqc eZdZdZddZdddddddddd ddZdddddddddd ddZdd dd Zddd d dd  dd Zy)rraSynchronous 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||_yrr rs r?rzSyncCronClient.__init__rrAN) rr'rr-rrrrrIc ||||||| || | 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" ) ``` ) rrr-r'rrrrrrrdrrr)rrZrrrr'rr-rrrrrIr1rrs r?rz 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" ) ``` ) rrr-r'rrrrrrrrrr!s r?r2zSyncCronClient.createspn! ( 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" ) ``` r#rNr9r$s r?rzSyncCronClient.delete6s"2 <y17CrAr;rr&c||||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' } ] ``` r(r)rrr*s r?r]zSyncCronClient.searchQs_v)"   %,MMOEDAqq}1a4EEyy~~2'~RRFs A A )rrnrr)rZrrrrrrrr'rrrr-rVrr+rr+rrSrrSrIrrr r,r-r.r/rrAr?rrrrs" !%#',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 ASrArrceZdZdZd dZ d d dZddd d dZ d ddZ d ddZ d dd Z y)rsaA 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||_yrr r s r?rzSyncStoreClient.__init__r rANc|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"} ) ``` r3r4r5r6r;rNr<r>s r?r@zSyncStoreClient.put_itemsjD Ee| /w6gh  #   n>'+BG TrArAc|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' } ``` r3r4r5r7r$rBr;rrErFs r?rGzSyncStoreClient.get_itemssV Ee| /w6gh  388I+>?  "$/F= !yy}}^FG}LLrAcF|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;rrNr9rIs r?rJzSyncStoreClient.delete_item s'6  9!Ew  rAcb||||||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 ... ] } ``` rLrPrrQrRs r?rSzSyncStoreClient.search_items+sFt!1&  yy~~ !w(?  rAc`|||||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"], ... ] ``` rUrXrrQrYs r?rZzSyncStoreClient.list_namespacespsC\"  yy~~ nW&=w  rArr[r\r^rr_r`rarbrdrfrrAr?rsrss =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 rArsc\|jDcic] \}}| || c}}Scc}}wrr)drrs r?r=r=s(WWY 8TQ!-AqD 88 8rzlist[httpx.ASGITransport]rzc(tD] }||_ yr)rzri)rirws r?configure_loopback_transportsrs+  rAr)maxsizecf ddlm}|jS#t$rtjcYSwxYw)Nrasgi_transport) langgraph_apir ASGITransport ImportErrorr~rs r?ryrys1#0+++ #"""#s 00r)r<rSrrS)r<rSrGrrzdict[str, str])rVrrr)r_rrzOptional[RunCreateMetadata]) rcrSr<rSrIrrdOptional[TimeoutTypes]rre)rrrztuple[dict[str, str], bytes])rrrr) rcrSr<rSrIrrdrrrg)rrM)rirrr)rztype[httpx.ASGITransport])fr __future__rr functoolsloggingr9rercollections.abcrrrtypingrrr r r r r~r httpx._typesr rElanggraph_sdk.schemarrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-langgraph_sdk.sser.r/r0 getLoggerrrrCr@rJrWcompiler\rbrrerrrrrrrrrkrgrnrzrxrorprqrrrsr=rz__annotations__r lru_cacheryfloattupler TimeoutTypesrrAr?rs# == (!!!!!!!!!DJI   8 $"   ,D(P# <    "!(,&* D# D#D#& D# $ D#  D#N,,(yyx  V V rn n bO WO WdGYGYTX X z!(,&* 5' 5'5'& 5' $ 5'  5'p00.xxv 0 H H Vf f RB QB QJ~S~SBQ Q h95716 Q# #  (5/8E? *+ (5/8E?HUOXe_ LM MM  rA