9i,`UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z mZmZddlmZddlmZmZmZmZddlZddlZddlZddlmZmZddlmZmZm 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHdd lImJZJmKZKmLZLejeNZOd ZPedeQZReRfd:d ZS d;d ZTddZYGddZZGddZ[d?dZ\d@dZ]GddZ^GddZ_GddZ`GddZaGd d!ZbdeRddd dAd#ZcGd$d"ZdGd%d&ZedBd'Zfd@d(ZgGd)d*ZhGd+d,ZiGd-d.ZjGd/d0ZkGd1d2ZldCd3ZmgZnd4eod5<dDd6Zpejd78dEd9ZrdeszetesdzesdzfzetesdzesdzesdzesdzfzejzZvy)FaThe LangGraph client implementations connect to the LangGraph API. This module provides both asynchronous (`get_client(url="http://localhost:2024")` or `LangGraphClient`) and synchronous (`get_sync_client(url="http://localhost:2024")` or `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) AsyncIteratorCallableIteratorMappingSequence) TracebackType)AnyLiteralcastoverload)_araise_for_status_typed_raise_for_status_typed)+All AssistantAssistantSelectFieldAssistantSortByAssistantsSearchResponseAssistantVersion CancelAction CheckpointCommandConfigContextCronCronSelectField CronSortByDisconnectMode Durability GraphSchema IfNotExistsInputItemJsonListNamespaceResponseMultitaskStrategyOnCompletionBehaviorOnConflictBehaviorQueryParamTypesRun RunCreateRunCreateMetadataRunSelectField RunStatusSearchItemsResponse SortOrder StreamMode StreamPart SubgraphsThreadThreadSelectField ThreadSortBy ThreadState ThreadStatusThreadStreamModeThreadUpdateStateResponse) SSEDecoderaiter_lines_rawiter_lines_raw) x-api-keyct|tr|S|turQdD]L}tj|dx}s|j j dj dcSy)aGet the API key from the environment. Precedence: 1. explicit string argument 2. LANGGRAPH_API_KEY (if api_key not provided) 3. LANGSMITH_API_KEY (if api_key not provided) 4. LANGCHAIN_API_KEY (if api_key not provided) Args: api_key: The API key to use. Can be: - A string: use this exact API key - None: explicitly skip loading from environment - NOT_PROVIDED (default): auto-load from environment variables ) LANGGRAPH LANGSMITH LANGCHAIN_API_KEY"'N) isinstancestr NOT_PROVIDEDosgetenvstrip)api_keyprefixenvs ^/var/www/html/backtest/airagagent/rag_env/lib/python3.12/site-packages/langgraph_sdk/client.py _get_api_keyrPXsl'3,= 9Fii6(( 344s4yy{((-33C88 9 c|xsi}tD]}||vstd|dddtji|}t |}|r||d<|S)z1Combine api_key and custom user-provided headers.zCannot set reserved header 'rEz User-Agentzlanggraph-sdk-py/r>)RESERVED_HEADERS ValueError langgraph_sdk __version__rP)rLcustom_headersheaderheadersresolved_api_keys rO _get_headersr[qs $)rN"G ^ #;F81EF FG )-*C*C)DE G$G,/  NrQct|t}t|dr8t|jr#|rt d|d||j St|dr8t|j r#|rt d|d||j St|ttfr t|St dt|d)N model_dumpz#Cannot JSON-serialize type object: zI. Did you mean to pass an instance of the object instead? Received type: dictzObject of type z is not JSON serializable) rFtypehasattrcallabler] TypeErrorr^set frozensetlist)objis_classs rO_orjson_defaultrhs#t$HsL!hs~~&> 5cW=$$'7, ~~ f (388"4 5cW=$$'7, xxz C#y) *Cy/$s)4MNOOrQz5(\/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)rjrk)rYget_RUN_METADATA_PATTERNsearchr,group)responsecontent_locationmatchs rO_get_run_metadata_from_responserssh%,,001CDDD&--.>??? ;;x(kk+.6$  rQ)urlrLrYtimeoutLangGraphClientc Vd}|ed}tjjddk(r(tdd}tj |n ddlm}t|d }|tjd }tj|||tj|ntjd ddd t||}t!|S#t$rAtjd d tdd}tj |YwxYw)a Create and configure a LangGraphClient. The client provides programmatic access to LangSmith Deployment. It supports both remote servers and local in-process connections (when running inside a LangGraph server). Args: url: Base URL of the LangGraph API. - If `None`, the client first attempts an in-process connection via ASGI transport. If that fails, it defers registration until after app initialization. This only works if the client is used from within the Agent server. api_key: API key for authentication. Can be: - A string: use this exact API key - `None`: explicitly skip loading from environment variables - Not provided (default): auto-load from environment in this order: 1. `LANGGRAPH_API_KEY` 2. `LANGSMITH_API_KEY` 3. `LANGCHAIN_API_KEY` headers: Additional HTTP headers to include in requests. Merged with authentication headers. timeout: HTTP timeout configuration. May be: - `httpx.Timeout` instance - float (total seconds) - tuple `(connect, read, write, pool)` in seconds Defaults: connect=5, read=300, write=300, pool=5. Returns: LangGraphClient: A top-level client exposing sub-clients for assistants, threads, runs, and cron operations. ???+ example "Connect to a remote server:" ```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") ``` ???+ example "Connect in-process to a running LangGraph server:" ```python from langgraph_sdk import get_client client = get_client(url=None) async def my_node(...): subagent_result = await client.runs.wait( thread_id=None, assistant_id="agent", input={"messages": [{"role": "user", "content": "Foo"}]}, ) ``` ???+ example "Skip auto-loading API key from environment:" ```python from langgraph_sdk import get_client # Don't load API key from environment variables client = get_client( url="http://localhost:8123", api_key=None ) ``` Nz http://api$__LANGGRAPH_DEFER_LOOPBACK_TRANSPORTtruez/noauth)app root_pathr)rz)r{zJFailed to connect to in-process LangGraph server. Deferring configuration.Texc_inforetries,connectreadwritepoolbase_url transportrurY)rIenvironrlget_asgi_transport_registered_transportsappendlanggraph_api.serverrz ExceptionloggerdebughttpxAsyncHTTPTransport AsyncClientTimeoutr[rv)rtrLrYrurrzclients rO get_clientrs`26I { ::>>@ AV K,*,KI " ) )) 4 940.0 J ,,Q7   " MM' "qs#AFWg. F 6 "") 9 `!1.0TYO &--i8  9sCAD('D(c@eZdZdZddZddZ d dZd dZy) rvaTop-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 rO__init__zLangGraphClient.__init__.s^v& *4995$TYY/ tyy)  *  + rQcK|Sw)z Enter the async context manager.rs rO __aenter__zLangGraphClient.__aenter__6s  sc@K|jd{y7w)zExit the async context manager.N)acloserexc_typeexc_valexc_tbs rO __aexit__zLangGraphClient.__aexit__:skkms cKt|dr-|jjjd{yy7wz!Close the underlying HTTP client.rN)r`rrrrs rOrzLangGraphClient.acloseCs4 4 ))""))+ + + ! +s 4?=?Nrzhttpx.AsyncClientreturnNone)rrvrztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerrrr)__name__ __module__ __qualname____doc__rrrrrrQrOrvrv#sA,,&%   ,rQc@eZdZdZddZdddd ddZdddd ddZdddd ddZdddd ddZddddd  dd Z ddddd d  dd Z ddddd  ddZ 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 rOrzHttpClient.__init__S  rQNparamsrY on_responsecK|jj|||d{}|r||t|d{t|d{S7477w)Send a `GET` request.rrYN)rrlr _adecode_jsonrpathrrYrrs rOrlzHttpClient.getVsY++//$vw/G G  N&q)))"1%%% H *%s3"AAAAAAAAAc(K|t|d{\}}nid}}|r|j||jj||||d{}|r||t |d{t |d{S7v7677 w)Send a `POST` request.NrQrYcontentr) _aencode_jsonupdaterpostrr rrjsonrrYrrequest_headersrrs rOrzHttpClient.postes  -:4-@'@ $OW')3WO   " "7 +++"" /76#    N&q)))"1%%%(A  *%sFBB ABB B2B3BBB BBBcKt|d{\}}|r|j||jj||||d{}|r||t |d{t |d{S7q7677 w)Send a `PUT` request.Nr)rrrputrrrs rOrzHttpClient.put~s*7t)<#<    " "7 +++// /76"    N&q)))"1%%%$= *%EB BB ?B B B  B cKt|d{\}}|r|j||jj||||d{}|r||t |d{t |d{S7q7677 w)Send a `PATCH` request.Nr)rrrpatchrrrs rOrzHttpClient.patchs*7t)<#<    " "7 +++## /76$    N&q)))"1%%%$= *%rrrrYrcK|jjd||||d{}|r||t|d{y7"7wzSend a `DELETE` request.DELETErrrYN)rrequestrrrrrrYrrs rOdeletezHttpClient.deletesV++%% dfg&    N&q)))  *s!$A A A A A  A r~rrrYrreconnect_limitc Kt|d{\}} |r|j||jj|||| |4d{} |r||  | j | jjd} |dks| s$t!| d{cdddd{S t!| d{cdddd{S77#t j $rn} | jd{7j} tjdk\r| j| | tjd| | | d} ~ wwxYw7777#t j"$rit%j&d| d | j)d{7|j+| d ||d z d{7cYcdddd{7SwxYw#1d{7swYyxYww)@Send a request that automatically reconnects to Location header.Nr Error from langgraph-api: r|locationr2Request failed, attempting reconnect to Location:  stacklevelGETrYr)rrrstreamraise_for_statusrHTTPStatusErrorareaddecodesys version_infoadd_notererrorrYrlr HTTPErrorwarningswarnrrequest_reconnectrrmethodrrrYrrrrrebodylocs rOrzHttpClient.request_reconnects*7t)<#<    " "7 +;;%% D/76&    A ""$))-- +C!#3*1--!   " *1--%   $= (( ggi//1##w.JJt$LL#=dV!DqLQ  .! $.% &??  HN hhj  !33+$3a$7 43   & '   sG?C>G?CG? G* C00G* E#!G*$ G?0E%1G?7E+E'E+ G?E)G?G?E 2EDAEE  G*%G?'E+)G?+AG'+F., G' G G'G* G?G" G?&G''G**G<0G3 1G<8G?c:Kt|d{\}}d|d<d|d<|r|j||jD cic]\} } | jdvr| | } } } d} d} d}d} t | |n| }| | |d <| |nd }| |nd}| |nd}d }|j j || xs|||| 4d{}| |r||t|d{|jjddjdd}d|vrtjd||jjd}|r|} t} t|23d{}|jt!d|j#d}|7|j$ |j$} |j&s |j(h|n7cc} } w777w6 |jdx}rT|j$ |j$} |j&s |j($|n#tj*$r| d }YnwxYwdddd{7n#1d{7swYnxYw|r!|dz }||kDrtjd'yw)zStream results using SSE.Ntext/event-streamAcceptno-store Cache-Controlcontent-length content-typerr~T Last-Event-IDrFrr;JExpected response header Content-Type to contain 'text/event-stream', got rbytes )linerQr*Exceeded maximum SSE reconnection attempts)rritemslowerr^rrrrYrl partitionrTransportErrorr;r<rr rstrip last_event_ideventdatarrrrrrrYrrrkeyvaluereconnect_headersrreconnect_pathreconnect_attemptsmax_reconnect_attemptscurrent_headerscurrent_methodcurrent_contentcurrent_paramsretryres content_typereconnect_locationdecoderrsses rOrzHttpClient.streams*7t)<#< $7!+5(   " "7 +.335 Uyy{"DD J  %) %)!""#1#9?PO(3@0'5'=V5N)7)?gTO'5'=V4NE{{))&$''% *0 &0 & !)k$.s333"{{~rBLLSQRST &l:..+.0 &)[[__Z%@"%%7N%,&&5c&:**d%nn$w2E2L2LU2SnT?&44@070E0E "yyCHH,@&) }$= .0 &4 *&:&nnS11s1"00<,3,A,AM99(< #&I!&- E !C0 &0 &0 &0 &0 &b"a'"%(>>..D sJG7J G(AJG J I"%G#&A7I" H2)G'-G%.G'1.H2 0H2H2JJ#I"%G''H2)A I"2I  I" I  I" JIJ"I4(I+ )I40+Jr rrGrQueryParamTypes | NonerYMapping[str, str] | Noner'Callable[[httpx.Response], None] | Nonerr rrGrzdict[str, Any] | list | Nonerr3rYr4rr5rr rrGrr^rr3rYr4rr5rr rrGrz Any | Nonerr3rYr4rr5rrrrGrrGrdict[str, Any] | Nonerr3rYr4rr5rintrr )rrGrrGrr:rr3rYr4rr5rAsyncIterator[StreamPart] rrrrrrlrrrrrrrrQrOrrIs;*.,0?C & &' & * & = &  &(*.,0?C&&+ & ' & * &=& &<*.,0?C&& & ' & * &=& &4*.,0?C&& & ' & * &=& &2 )-,0?C** * ' * * *=* *,'+)-,0?C ... $ . ' .*.=.. .j'+)-,0?Caaa $ a ' a*a=a #arQrcK|idfStjjdtj|t tj tjzd{}tt|}d}||d}||fS7#wNzapplication/json)zContent-Lengthz Content-Type) asyncioget_running_looprun_in_executororjsondumpsrhOPT_SERIALIZE_NUMPYOPT_NON_STR_KEYSrGlenrrcontent_lengthr.rYs rOrrMs |4x))+;;   ""V%<%<<  DT^N%L!/NG D= sA"B $B%$B cK|jd{}|r;tjjdtj |d{SdS7C7wr)rr@rArBrCloadsrrs rOrr]sT?D &&(88v||TRR Rs!AA=0.0.45 params: Optional query parameters to include with the request. Returns: Assistant: The created assistant. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant = await client.assistants.create( graph_id="agent", context={"model_name": "openai"}, metadata={"number":1}, assistant_id="my-assistant-id", if_exists="do_nothing", name="my_name" ) ``` graph_idconfigrmrnrWrorprq /assistantsrrYrNrr rrsrtrmrnrWrorprYrqrpayloads rOcreatezAssistantsClient.create}sf #   &GH  !(GI  "*GJ  &2GN # #,GK "GFO %0GM "YY^^ $    sAA!AA!rsrtrmrnrprYrqrcKi} |r|| d<|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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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 params: Optional query parameters to include with the request. Returns: 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", context={"model_name": "anthropic"}, metadata={"number":2} ) ``` rsrtrmrnrprqrTrvNrr rrWrsrtrmrnrprYrqrrys rOrzAssistantsClient.updates^#% "*GJ   &GH  !(GI  "*GJ  "GFO %0GM "YY__<. ) %    sAAAAcbK|jjd|||d{y7w)aDelete an assistant. Args: assistant_id: The assistant ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters 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" ) ``` rTrRNrrrVs rOrzAssistantsClient.deletes76ii<. )76   %/-/ r rnrsrplimitoffsetsort_by sort_orderselectrYrc  Kywrr rrnrsrprrrrrresponse_formatrYrs rOrnzAssistantsClient.search&s $'array rnrsrprrrrrrrYrc  Kywrrrs rOrnzAssistantsClient.search7s rc BK| dvrtd| ||d} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d <d dfd } ttt|jj d | | | | d k(r| nd d {}| d k(r|dS|S7w)asSearch 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. name: The name of the assistant to filter by. The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name. limit: The maximum number of results to return. offset: The number of results to skip. sort_by: The field to sort by. sort_order: The order to sort by. select: Specific assistant fields to include in the response. response_format: Controls the response shape. Use ``"array"`` (default) to return a bare list of assistants, or ``"object"`` to return a mapping containing assistants plus pagination metadata. Defaults to "array", though this default will be changed to "object" in a future release. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: A list of assistants (when ``response_format="array"``) or a mapping with the assistants and the next pagination cursor (when ``response_format="object"``). ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") response = await client.assistants.search( metadata = {"name":"my_name"}, graph_id="my_graph_id", limit=5, offset=5, response_format="object" ) next_cursor = response["next"] assistants = response["assistants"] ``` robjectz1response_format must be 'array' or 'object', got rrrnrsrprrrNc<|jjdyNzX-Pagination-NextrYrlrp next_cursors rOcapture_paginationz3AssistantsClient.search..capture_pagination"**../BCKrQ/assistants/searchrrrYrrrnextrphttpx.ResponserrrTr rerrrrrnrsrprrrrrrrYrryrrrs @rOrnzAssistantsClient.searchHsn "5 5COCVW #  "*GJ  "*GJ  "GFO !(GI  $.GL !  &GH "&  D O))..$2AX2M.SW !    h &",kB B sBBB BrnrsrprYrcKi}|r||d<|r||d<|r||d<|jjd|||d{S7w)OCount assistants matching filters. Args: metadata: Metadata to filter by. Exact match for each key/value. graph_id: Optional graph id to filter by. name: Optional name to filter by. The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: int: Number of assistants matching the criteria. rnrsrp/assistants/countrvNrwrrnrsrprYrrys rOcountzAssistantsClient.counts`,#% "*GJ  "*GJ  "GFOYY^^ gwv$    :AAAc|K||d}|r||d<|jjd|d|||d{S7w)a%List 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. params: Optional query parameters to include with the request. Returns: 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" ) ``` rrnrT /versionsrvNrwrrWrnrrrYrrys rO get_versionszAssistantsClient.get_versionss^D#  "*GJ YY^^<. 2 $    3<:<clKd|i}|jjd|d|||d{S7w)aChange 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. params: Optional query parameters to include with the request. Returns: 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 ) ``` versionrT/latestrvNrwrrWrrYrrys rO set_latestzAssistantsClient.set_latestsK>$-g"6YY^^<. 0 $    s +424rrrrrWrGrYr4rr3rr rWrGrZz int | boolrYr4rr3rzdict[str, list[dict[str, Any]]]rWrGrYr4rr3rr NF rWrGri str | NonereboolrYr4rr3rr3rrsrrt Config | NonermContext | Nonernr$rWrroOnConflictBehavior | NonerprrYr4rqrrr3rrrWrGrsrrtrrmrrnr$rprrYr4rqrrr3rrrWrGrYr4rr3rrrnr$rsrrprrr;rr;rAssistantSortBy | NonerSortOrder | Noner!list[AssistantSelectField] | NonerzLiteral['object']rYr4rr3rrrnr$rsrrprrr;rr;rrrrrrrzLiteral['array']rYr4rr3rzlist[Assistant]rnr$rsrrprrr;rr;rrrrrrrzLiteral['array', 'object']rYr4rr3rz*AssistantsSearchResponse | list[Assistant] rnr$rsrrprrYr4rr3rr;NrrrWrGrnr$rr;rr;rYr4rr3rzlist[AssistantVersion] rWrGrr;rYr4rr3rrrrrrrrlr`rcrkrzrrr rnrrrrrQrOrrfsm -1)- + + * + ' +  + b!,0)- 8 8  8 * 8 ' 8  )8 |-1)- w w * w ' w  w x!% $ -1)-$$$ $ * $'$ $R!%E #'#'/3,0"&)-E E E  E  E !E -E E *E  E 'E  E V $ $"&,0"&)-A A  A  A  A A A *A  A 'A  A N-1)-   *  '    >#*.'+48,0)-'' '  '  ''('%'2'+'*''' "'' #*.'+48,3,0)-     (%2**' &#*.'+486=,0)-]] ]  ]  ]](]%]2]4]*]'] 4]D#,0)-      *  '   H , -1)-, , ,  ,  , *, ',  , f-1)- & & & * & ' &  & rQrc eZdZdZddZddd ddZddddddddd ddZdddd dd Zddd d d Zddddd d dddddd d!dZ dddddd d"dZ ddd d dZ d#dddd d$dZ dddddd d%dZ d dddddd d&dZddddd d'dZy)(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||_yrrOrPs rOrzThreadsClient.__init__.rQrQNrRc`K|jjd|||d{S7w)aGet a thread by ID. Args: thread_id: The ID of the thread to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: 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/rRNrUrrkrYrs rOrlzThreadsClient.get1s;PYY]] { #WV#    rXrnrkro superstepsrsttlrYrc Ki} |r|| d<|s|ri|xsi|rd|ini| d<|r|| d<|rA|D cgc]0} d| dD cgc]} | d| jd| dd c} i2c} } | d <|$t|ttfr |d d | d<n|| d<|jj d| ||d {Scc} wcc} } w7w)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. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: 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" ) ``` rkrsrnroupdatesvaluescommandas_noderrrrNrrstrategyr/threadsrvrlrFr;floatrr rrnrkrorrsrrYrrysus rOrzzThreadsClient.create]sV#% #,GK x#>r#-5J)2#GJ  #,GK $ % "#9    '(k'(uuY'7'(|   %GL ! ?#U|,),(!C!$YY^^ Wgf$   #  %& s4/C B?"B: B?&AC5C6C:B??CrrYrcKd|i}|$t|ttfr |dd|d<n||d<|jj d||||d{S7w)amUpdate a thread. Args: thread_id: ID of thread to update. metadata: Metadata to merge with existing thread metadata. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: 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}, ttl=43_200, ) ``` rnNrrrrrvrFr;rrrrrkrnrrYrrys rOrzThreadsClient.updatestD$.x"8 ?#U|,),(!C!$YY__ { # %    sAAAAcbK|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. params: Optional query parameters 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" ) ``` rrRNrrs rOrzThreadsClient.deletes/6ii9+6PVWWWrrr rnridsstatusrrrrrrYrc K||d} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d<| r| | d<|jjd | | | d {S7w) a/Search for threads. Args: metadata: Thread metadata to filter on. values: State values to filter on. ids: List of thread IDs to filter by. 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. params: Optional query parameters to include with the request. Returns: 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 ) ``` rrnrrrrrr/threads/searchrvNrw rrnrrrrrrrrrYrrys rOrnzThreadsClient.searchs^#  "*GJ   &GH   GEN  &GH  !(GI  $.GL !  &GH YY^^  $    sAA"A A"rnrrrYrcKi}|r||d<|r||d<|r||d<|jjd|||d{S7w)Count threads matching filters. Args: metadata: Thread metadata to filter on. values: State values to filter on. status: Thread status to filter on. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: int: Number of threads matching the criteria. rnrr/threads/countrvNrwrrnrrrYrrys rOrzThreadsClient.count=sa*#% "*GJ   &GH   &GH YY^^ 7GF$    rcdK|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. params: Optional query parameters 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" ) ``` r/copyNrvrwrs rOcopyzThreadsClient.copy]s>6YY^^ {% (tWV$    s '0.0F subgraphsrYrcVK|r.|jjd|d||d||d{S|r8d|i}|ri||}|jjd|d|||d{Sd|i}|ri||}|jjd|d ||d{S7t7<7w) 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. params: Optional query parameters to include with the request. Returns: 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' } } ``` r/state/checkpoint checkpointrrvNr/state/r/staterrrlrrkr checkpoint_idrrYrrjs rO get_statezThreadsClient.get_state|s\ I;&78$.YG (  %y1J5 5f5 I;gm_=!'  &y1J5 5f5 I;f-!' 's3,B)B#9B)(B%)5B)B'B)%B)'B)rrrrYrcKd|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. params: Optional query parameters to include with the request. Returns: 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': {} } } ``` rrrrrrrvNrw rrkrrrrrYrrys rO update_statezThreadsClient.update_statesuf f#  '4GO $ $.GL ! !(GI YY^^ {& )QW$    AA AA rbeforernrrYrcKd|i}|r||d<|r||d<|r||d<|jjd|d|||d{S7w) azGet 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. params: Optional query parameters to include with the request. Returns: 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, ) ``` rrrnrr/historyrvNrw rrkrrrnrrYrrys rO get_historyzThreadsClient.get_historyCswJ U#   &GH  "*GJ  $.GL !YY^^ {( + $    r run_modes)r stream_moderYrcKd|i}|r|j||jjd|ddi|rd|ini|xsi|Sw)aGet a stream of events for a thread. Args: thread_id: The ID of the thread to get the stream for. last_event_id: The ID of the last event to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: An iterator of stream parts. ???+ example "Example Usage" ```python for chunk in client.threads.join_stream( thread_id="my_thread_id", last_event_id="my_event_id", ): print(chunk) ``` rr/streamrrrRrrr)rrkrrrYrr_s rO join_streamzThreadsClient.join_streamwszB ;      'yy {' * 7DO]3"=b    sA A rrkrGrYr4rr3rr4rnr$rkrrorrz4Sequence[dict[str, Sequence[dict[str, Any]]]] | Nonersrrint | Mapping[str, Any] | NonerYr4rr3rr4 rkrGrnMapping[str, Any]rrrYr4rr3rr4rkrGrYr4rr3rrrnr$rr$rSequence[str] | NonerThreadStatus | Nonerr;rr;rzThreadSortBy | Nonerrrzlist[ThreadSelectField] | NonerYr4rr3rz list[Thread] rnr$rr$rrrYr4rr3rr;NNrkrGrCheckpoint | NonerrrrrYr4rr3rr7rkrGrz&dict[str, Any] | Sequence[dict] | NonerrrrrrrYr4rr3rr:rkrGrr;rzstr | Checkpoint | NonernMapping[str, Any] | NonerrrYr4rr3rzlist[ThreadState]) rkrGrrr-ThreadStreamMode | Sequence[ThreadStreamMode]rYr4rr3rr<rrrrrrlrzrrrnrrrrr rrrQrOrrs -1)- * * * * ' *  * ^ $/3KO#.2,0)-K K  K - K I K K ,K *K 'K  K d/3,0)-- - $ - , - * - '-  - f-1)- XX* X ' X  X@$(&*'+'+15,0)-E E  E " E $ E E E %E %E /E *E 'E  E T&*,0)-    $  *  '   H-1)-   *  '    D)-$( F  ,0)-FF&F" F  F*F'F FZ#(,$(,0)-= = 7=  = & = "= *= '=  #= F*.-1(,,0)-2 2  2 ( 2 + 2 &2 *2 '2  2 p%)EP,0)-- - " - C - * - '-  #- rQrczeZdZdZd'dZeddddddddddddddddddddddd d(dZedddddddddddddddddddd d)d Zddddddddddddddddddddddddd  d*d Zeddddddddddddddddddd  d+d Zeddddddddddddddddddddd d,dZddddddddddddddddddddddd d-dZddd d.dZedddddddddddddddddddd d/dZ edddddddddddddddddd d0dZ dddddddddddddddddddddd d1dZ ddddddd d2dZ ddd d3dZ dd ddd! d4d"Z ddd d5d#Z dddddd$ d6d%Zddd d7d&Zy)8raClient for managing runs in LangGraph. A run is a single assistant invocation with optional input, config, context, 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||_yrrOrPs rOrzRunsClient.__init__rQrQNrF)inputrrstream_subgraphsstream_resumablernrtrmrrcheckpoint_duringinterrupt_beforeinterrupt_after feedback_keys on_disconnectwebhookmultitask_strategy if_not_exists after_secondsrYron_run_createdcyrr)rrkrWr'rrr(r)rnrtrmrrr*r+r,r-r.r/r0r1r2rYrr3s rOrzRunsClient.streams8%(rQ)r'rrr(r)rnrtr*r+r,r-r. on_completionr1r/r2rYrr3cyrr)rrkrWr'rrr(r)rnrtr*r+r,r-r.r5r1r/r2rYrr3s rOrzRunsClient.streams2%(rQr'rrr(r)rnrtrmrrr*r+r,r-r.r5r/r0r1r2rYrr3 durabilityc | tjdtdid|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)aCreate 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) 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. params: Optional query parameters to include with the request. on_run_created: Callback when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: 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"}, context={"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) ``` Nd`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.rrr'rrtrmrnrr(r)rWr+r,r-r/rrr*r0r1r.r5r2r8r /runs/streamc8rt|x}r |yyyz)Callback function to handle the response.Nrsr-rnr3s rOrz&RunsClient.stream..on_response&/Ns/S#S8#Sx($T~rQPOSTrr-rrrDeprecationWarningrrr rrkrWr'rrr(r)rnrtrmrrr*r+r,r-r.r5r/r0r1r2rYrr3r8kvryendpointrs ` rOrzRunsClient.streamsR  ( MMv"   U GN'--/C$!QQ]ACTX f  w     ;   0   0  L   0    ]  w *! " ]# $ !2% & !"4' (+***$1 8$ {, /   ) yy  #*==?D41aam!Q$D'5    <@    EDJE C% C% C+ C+)r'rrr(r)rnr*rtrmr+r,r/r5r1r2rYrr3c Kywrr)rrkrWr'rrr(r)rnr*rtrmr+r,r/r5r1r2rYrr3s rOrzzRunsClient.creates 0rr'rrr(r)rnrtrmrrr*r+r,r/r0r1r2rYrr3c KywrrrrkrWr'rrr(r)rnrtrmrrr*r+r,r/r0r1r2rYrr3s rOrzzRunsClient.creates 4rr'rrr(r)rnrtrmrrr*r+r,r/r0r1r5r2rYrr3r8cK| tjdtdid|d|r'|jDcic] \}}| || c}}ndd|d|d |d | d | d |d |d|d|d|d| d| d| d|d||||d}|jDcic] \}}| || }}}dfd }|jj |rd|dnd|||r|ndd{Scc}}wcc}}w7w)a<Create 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) 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. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: 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"}, context={"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, 'assistant_id': 'my_assistant_id' }, }, 'context': { 'model_name': 'openai' } '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' } ``` Nr:rrr'rrr(r)rtrmrnrWr+r,r/rrr*r0r1r5r2r8c8rt|x}r |yyyr>r?r@s rOrz&RunsClient.create..on_responsep rArQr/runsrrCrrrErrrrrkrWr'rrr(r)rnrtrmrrr*r+r,r/r0r1r5r2rYrr3r8rGrHryrs ` rOrzzRunsClient.createsV  ( MMv"   U GN'--/C$!QQ]ACTX ;   0    0  f  w    L   0    w  * ]! " !2# $ !"4% & ]' (+*$- 0%,MMOEDAqq}1a4EE ) YY^^,5i {% (7'5 4 $   9D*F s59C4 C& C& A C4 C,$C,)8C4!C2"C4rRcKdd}|Dcgc] }|| }}|jjd|||d{Scc}w7 w),Create a batch of stateless background runs.c\|jDcic] \}}| || c}}Scc}}wrrryrGrHs rOfilter_payloadz/RunsClient.create_batch..filter_payload (%,]]_FTQ AqDF FF (( /runs/batchrvNryr+rwrpayloadsrYrr[ryfiltereds rO create_batchzRunsClient.create_batch} sZ Gr?r@s rOrz$RunsClient.wait..on_responseT rArQrBr __error__rz: messagerC) rrrErrrrFr^rrl)rrkrWr'rrnrtrmrrr*r+r,r/r.r5r0r1r2rerYrr3r8rGrHryrIrrps ` rOrhzRunsClient.wait sd  ( MMv"   U GN'--/C$!QQ]ACTX f  w     L   0    w  *  ]  !"4  !2 ]! " ]# $ ]% & ]' ( *) .2;1Fi {* -L  ) 44  #*==?D41aam!Q$D'5 4 5   8T*x'8K0$7K(,,W56b+9N9R9RS\9]8^_ [D>E s69E E E A2E> E  E E!E"A0ErrrrrrrYrcK||d}|||d<|r||d<|r|j||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. params: Optional query parameters to include with the request. Returns: 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, ) ``` rNrrrrSrr] rrkrrrrrYrr_s rOrezRunsClient.listl szJ(   %+L " %+L "     'YY]] {% (w#    sA AAAcfK|jjd|d|||d{S7w)aUGet 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. params: Optional query parameters to include with the request. Returns: `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", ) ``` r/runs/rRNrUrrkrjrYrs rOrlzRunsClient.get s@>YY]] {& 176#    s (1/1 interruptrhactionrYrcK|rdnd|d}|r|j||r.|jjd|d|dd||d {S|jjd|d|dd || d {S727w) a]Get 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. params: Optional query parameters 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" ) ``` rrrhryrru/cancelrBrNrrrrrrrkrjrhryrYrr_s rOcancelzRunsClient.cancel sLA1      ' 44I;fVHG<# 5 I;fVHG<# ( s$AB A= -B8A?9B?BcjK|jjd|d|dd||d{S7w)aBlock 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. params: Optional query parameters 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" ) ``` rru/joinrrRNrrrvs rOjoinzRunsClient.join sI<YY00 {& 6  1    s *313cancel_on_disconnectrrYrrc||d}|r|j||jjd|d|dd|i|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. 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. params: Optional query parameters to include with the request. last_event_id: The last event ID to use for the stream. Returns: The stream of parts. ???+ 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) ``` )rrrrurrrNrr rrkrjrrrYrrr_s rOrzRunsClient.join_stream sV%9&      'yy {& 8 7DO]3"=b  rQchK|jjd|d|||d{y7w)aSDelete 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. params: Optional query parameters 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" ) ``` rrurRNrrvs rOrzRunsClient.delete[ s=<ii {& 176   s (202r)2rkrGrWrGr' Input | NonerCommand | Noner!StreamMode | Sequence[StreamMode]r(rr)rrnr"rtrrmrrrrrr* bool | Noner+All | Sequence[str] | Noner,rr-rr.DisconnectMode | Noner/rr0MultitaskStrategy | Noner1IfNotExists | Noner2 int | NonerYr4rr3r3*Callable[[RunCreateMetadata], None] | Nonerr<),rkrrWrGr'rrrrrr(rr)rrnr"rtrr*rr+rr,rr-rr.rr5OnCompletionBehavior | Noner1rr/rr2rrYr4rr3r3rrr<)6rkrrWrGr'rrrrrr(rr)rrnr"rtrrmrrrrrr*rr+rr,rr-rr.rr5rr/rr0rr1rr2rrYr4rr3r3rr8Durability | Nonerr<)*rkrrWrGr'rrrrrr(rr)rrnr"r*rrtrrmrr+rr,rr/rr5rr1rr2rrYr4rr3r3rrr*.rkrGrWrGr'rrrrrr(rr)rrnr"rtrrmrrrrrr*rr+rr,rr/rr0rr1rr2rrYr4rr3r3rrr*2rkrrWrGr'rrrrrr(rr)rrnr"rtrrmrrrrrr*rr+rr,rr/rr0rr1rr5rr2rrYr4rr3r3rr8rrr*razlist[RunCreate]rYr4rr3r list[Run],rkrGrWrGr'rrrrnr"rtrrmrrrrrr*rr+rr,rr/rr.rr0rr1rr2rrerrYr4rr3r3rrlist[dict] | dict[str, Any](rkrrWrGr'rrrrnr"rtrrmrr*rr+rr,rr/rr.rr5rr1rr2rrerrYr4rr3r3rrr)0rkrrWrGr'rrrrnr"rtrrmrrrrrr*rr+rr,rr/rr.rr5rr0rr1rr2rrerrYr4rr3r3rr8rrrrkrGrr;rr;rzRunStatus | Nonerzlist[RunSelectField] | NonerYr4rr3rr rkrGrjrGrYr4rr3rr*rkrGrjrGrhrryrrYr4rr3rr rkrGrjrGrYr4rr3rr^)rkrGrjrGrrr(StreamMode | Sequence[StreamMode] | NonerYr4rr3rrrr< rkrGrjrGrYr4rr3rrrrrrrr rrzrcrhrerlrrrrrrQrOrrsL   #"&9A!&!&-1 $"&(,$()-7;6:.2/3"7;,0$(,0)-EI5(((  (  (7(((+(( (&("('( 5!("4#($,%(&-'(()(*5+(,*-(."/(0*1(2'3(4C5(6 #7((: #"&9A!&!&-1 $)-7;6:.2/359,0"$(,0)-EI/(((  (  (7(((+(('(5(4(,( -!("3#($*%(&'((")(**+(,'-(.C/(0 #1((>#"&9A!&!&-1 $"&(,$()-7;6:.2/359"7;,0$(,0)-EI(,9\ \ \  \  \ 7\ \ \ +\ \  \ &\ "\ '\ 5!\ "4#\ $,%\ &-'\ (3)\ *+\ ,5-\ .*/\ 0"1\ 2*3\ 4'5\ 6C7\ 8&9\ : #;\ | #"&9A!&!&-1)- $"&7;6:"59,0$(,0)-EI-    7+' 54 !"3#$*%&"'(*)*'+,C-. /2 #"&9A!&!&-1 $"&(,$()-7;6:"7;,0$(,0)-EI1    7+ &"' 5!"4#$%&5'(*)*"+,*-.'/0C12 3@#"&9A!&!&-1 $"&(,$()-7;6:"7;,059$(,0)-EI(,5v v v  v  v 7v v v +v v  v &v "v 'v 5!v "4#v $%v &5'v (*)v *3+v ,"-v .*/v 0'1v 2C3v 4&5v 6 7v x-1)-  ! *  '    " #"&-1 $"&(,$()-7;6:"/37;,0$( ,0)-EI/***  *  *+** *&*"*'*5*4** -!*"5#*$*%*&"'*()***+*,'-*.C/*0 %1**4 #"&-1 $"&)-7;6:"/359,0$( ,0)-EI+***  *  *+** *'*5*4**-*3* *!*""#*$%*&*'*(')**C+*, %-**:#"&-1 $"&(,$()-7;6:"/3597;,0$( ,0)-EI(,3hhh  h  h+hh h&h"h'h5h4hh -!h"3#h$5%h&*'h(")h*+h,*-h.'/h0C1h2&3h4 %5h\#'.2,0)-0 0  0  0 ! 0 ,0 *0 '0  0 n-1)- ! ! ! * ! ' !  ! P*,0)-888  8  8*8'8 8~-1)- # # # * # ' #  # T&+@D,0)-$(9 9 9 # 9 > 9 *9 '9 "9  #9 @-1)-      *  '     rQrc TeZdZdZddZdddddddddddd ddZdddddddddddd ddZddd ddZddd d dddddd dd Zddddd  ddZ y)ra%Client for managing recurrent runs (cron jobs) in LangGraph. A run is a single invocation of an assistant with optional input, config, and context. 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||_yrrOr http_clients rOrzCronClient.__init__  rQN r'rnrtrmr*r+r,r/r0rYrc K|||||||| | | d }| r| |d<|jDcic] \}}| || }}}|jjd|d|| |d{Scc}}w7 w)a3Create 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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. params: Optional query parameters to include with the request. Returns: 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"}, context={"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" ) ``` scheduler'rtrnrmrWr*r+r,r/r0Nr /runs/cronsrvrrrrrkrWrr'rnrtrmr*r+r,r/r0rYrryrGrHs rOcreate_for_threadzCronClient.create_for_thread s~! (!2 0.   ,>G( )$+MMOEDAqq}1a4EEYY^^ {+ . $   F s (A0 A(A()A0#A.$ A0c K||||||||| | d }| r| |d<|jDcic] \}}| || }}}|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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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. params: Optional query parameters to include with the request. Returns: 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"}, context={"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" ) ``` rr0NrrvrrrWrr'rnrtrmr*r+r,r/r0rYrryrGrHs rOrzzCronClient.create sv! (!2 0.   ,>G( )$+MMOEDAqq}1a4EEYY^^ $   F s (A, A$A$%A,A* A,rRcbK|jjd|||d{y7w)aDelete a cron. Args: cron_id: The cron ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters 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/rRNrrcron_idrYrs rOrzCronClient.delete; s/6iigY7QWXXXrrr rWrkrrrrrrYrc K||||d} |r|| d<|r|| d<|r|| d<| jD cic] \} } |  | |  } } } |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. params: Optional query parameters to include with the request. Returns: 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' } ] ``` rWrkrrrrrN/runs/crons/searchrvr rrWrkrrrrrrYrryrGrHs rOrnzCronClient.searchX sB)"   !(GI  $.GL !  &GH $+MMOEDAqq}1a4EEYY^^ w$   F s!0A4 A,A,%A4'A2( A4rWrkrYrc|Ki}|r||d<|r||d<|jjd|||d{S7w)|Count cron jobs matching filters. Args: assistant_id: Assistant ID to filter by. thread_id: Thread ID to filter by. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: int: Number of crons matching the criteria. rWrk/runs/crons/countrvNrwrrWrkrYrrys rOrzCronClient.count sT&#% &2GN # #,GK YY^^ gwv$    r)rrrrrkrGrWrGrrGr'rrnr"rtrrmrr*rr+All | list[str] | Noner,rr/rr0rrYr4rr3rr*rWrGrrGr'rrnr"rtrrmrr*rr+rr,rr/rr0rrYr4rr3rr*rrGrYr4rr3rrrWrrkrrr;rr;rzCronSortBy | Nonerrrzlist[CronSelectField] | NonerYr4rr3rz list[Cron] rWrrkrrYr4rr3rr; rrrrrrrzrrnrrrQrOrr~ s0 #-1 $"&)-3726")-,0)-!R R R  R  R +R R  R 'R 1R 0R R 'R *R '!R " #R r#-1 $"&)-3726")-,0)-K K  K  K + K K  K 'K 1K 0K K 'K *K 'K !K b-1)- YY* Y ' Y  Y@$( $%)'+/3,0)-O !O  O  O  O #O %O -O *O 'O  O h$( $,0)-  !   *  '    rQrceZdZdZd dZ d d dZdddd 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||_yrrOrPs rOrzStoreClient.__init__ rQrQNcK|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. params: Optional query parameters 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 ('.').rir"r#indexr /store/itemsrvNrTrr_provided_vals rrir"r#rrrYrlabelrys rOput_itemzStoreClient.put_item sH Ee| /w6gh  #  iimm !8'RX   s AAAAA refresh_ttlrYrcK|D]}d|vstd|ddj||d}|||d<|ri||}|jjd||d{S7w) aRetrieve 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. params: Optional query parameters 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' } ``` rrrrir"Nrrr)rTrrrl)rrir"rrYrrrjs rOget_itemzStoreClient.get_item sZ Ee| /w6gh  $'88I#6sC  "(3J} % 1J1&1JYY]]>*g]VVVVs A(AA(!A&"A(cdK|jjd||d||d{y7w)atDelete 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. params: Optional query parameters 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", ) ``` rrrvNrrrir"rYrs rO delete_itemzStoreClient.delete_itemD s::ii (5    s &0.0c K||||||d} |jjdt| ||d{S7w)a,Search 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. params: Optional query parameters to include with the request. Returns: 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_prefixfilterrrqueryr/store/items/searchrvNrrr rrrrrrrrYrrys rO search_itemszStoreClient.search_itemsh sYz!1&  YY^^ !( $    s 5><>c~K|||||d}|jjdt|||d{S7w)a3List 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. params: Optional query parameters to include with the request. Returns: 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"], ... ] ``` rMsuffix max_depthrr/store/namespacesrvNr rrMrrrrrYrrys rOlist_namespaceszStoreClient.list_namespaces sV\"  YY^^ ( $    s 4=;=rNNNNr"rGr#rrz!Literal[False] | list[str] | NonerrrYr4rr3ri Sequence[str]rr r"rGrirrrrYr4rr3rr#r r"rGrYr4rr3rirrrNrrNNNNrr"rr;rr;rrrrrYr4rr3rrrr/)NNNdrNNrMlist[str] | Nonerrrrrr;rr;rYr4rr3rr% rrrrrrrrrrrrQrOrr s 48,0)-2  2 ! 2 1 2 2 *2 '2  2  2 t$(,0)-7W 7W 7W ! 7W*7W'7W 7W|-1)- "  " * " ' "  "  " P,0 #',0)-J ) J  J  J J !J *J 'J 'J  J \$(#' $,0)-9  9 !9  9  9  9 *9 '9  9 rQrSyncLangGraphClientc |d}tjd}tj|||tj|ntjddddt ||}t |S)aeGet a synchronous LangGraphClient instance. Args: url: The URL of the LangGraph API. api_key: API key for authentication. Can be: - A string: use this exact API key - `None`: explicitly skip loading from environment variables - Not provided (default): auto-load from environment in this order: 1. `LANGGRAPH_API_KEY` 2. `LANGSMITH_API_KEY` 3. `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") ``` ???+ example "Skip auto-loading API key from environment:" ```python from langgraph_sdk import get_sync_client # Don't load API key from environment variables client = get_sync_client( url="http://localhost:8123", api_key=None ) ``` zhttp://localhost:8123r~rrrr)r HTTPTransportClientrr[r)rtrLrYrurrs rOget_sync_clientr srh {%##A.I \\" MM' "qs#AFWg. F v &&rQc@eZdZdZddZddZ d dZd dZy) ra~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 rOrzSyncLangGraphClient.__init__Cs^"6* .tyy9(3 "499- #DII. $TYY/ rQc|S)zEnter the sync context manager.rrs rO __enter__zSyncLangGraphClient.__enter__Ks rQc$|jy)zExit the sync context manager.N)closers rO__exit__zSyncLangGraphClient.__exit__Os  rQcft|dr%|jjjyyr)r`rrrrs rOrzSyncLangGraphClient.closeXs' 4 II   " " $ !rQNrz httpx.Clientrr)rrrr)rrrrrrr rrrQrOrr5sA 0,&%   %rQc@eZdZdZddZdddd ddZdddd ddZdddd ddZdddd ddZddddd  dd Z ddddd d  dd Z ddddd  ddZ y)ra8Handle 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 rOrzSyncHttpClient.__init__irrQNrc~|jj|||}|r||t|t|S)rr)rrlr _decode_jsonrs rOrlzSyncHttpClient.getls8 KKOODO A  N"ArQc|t|\}}nid}}|r|j||jj||||}|r||t |t |S)rrQr) _encode_jsonrrrrrrs rOrzSyncHttpClient.post{ss  '3D'9 $OW')3WO   " "7 + KK   /76    N"ArQct|\}}|r|j||jj||||}|r||t |t |S)rr)rrrrrrrs rOrzSyncHttpClient.putsb$0#5    " "7 + KKOO /76    N"ArQct|\}}|r|j||jj||||}|r||t |t |S)rr)rrrrrrrs rOrzSyncHttpClient.patchsd$0#5    " "7 + KK   /76    N"ArQrcn|jjd||||}|r||t|yr)rrrrs rOrzSyncHttpClient.deletes< KK   dfg    N"rQr~rc (t|\}} |r|j||jj|||| |5} |r||  | j | jjd} |dks| st!| cdddS t!| cdddS#t j $re} | jj} tjdk\r| j| | tjd| | | d} ~ wwxYw#t j"$rNt%j&d| d | j)|j+| d ||d z cYcdddSwxYw#1swYyxYw)rrrrr|Nrrrrrrrr)rrrrrrrrrrrrrrrYrlrrrrrrrs rOrz SyncHttpClient.request_reconnects$0#5    " "7 + [[   D/76    A ""$))-- +C!#3#A!  " #A%  (( vvx(##w.JJt$LL#=dV!DqLQ  ??  HN  --+$3a$7 .3  & '  sP FB),F D$)D!-E-Ee-LM?&44@070E0E "yyCHH,@&) *&nnS11s1"00<,3,A,AM99(<#&I[- &\"a'"%(>>..D Y n!&- E !A- &- &s]AI(H8'AI(B I >H> 0H>=H>AI 2I(>IIIII%!I(r r2r6r7r8r9)rrGrrGrr:rr3rYr4rr5rIterator[StreamPart]r=rrQrOrr^s;*.,0?C  '  *  =   (*.,0?C+  '  * = :*.,0?C  '  * = 6*.,0?C  '  * = 2 )-,0?C## # ' # * #=# #,'+)-,0?C ... $ . ' .*.=.. .j'+)-,0?C``` $ ` ' `*`=` `rQrctj|ttjtjz}t t |}d}||d}||fSr?)rCrDrhrErFrGrGrHs rOrrbsR << ""V%<%<< D T^N%L!/NG D=rQcT|j}|rtj|SdSr)rrCrKrLs rOrrns# 668D!%6<< /4/rQc eZdZdZddZddd ddZdddd ddZddd dd Z d ddd d!d Z d"ddddddddd  d#d Z ddddddddd  d$dZ ddd d%dZ e ddddddddddd d&dZ e dddddddddddd d'dZ dddddddddddd d(dZ dddddd d)dZ d*ddd d+dZddd d,dZy)-rafClient for managing assistants in LangGraph synchronously. This class provides methods to interact with assistants, which are versioned configurations of your graph. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.get("assistant_id_123") ``` c||_yrrOrPs rOrzSyncAssistantsClient.__init__rQrQNrRcD|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. params: Optional query parameters to include with the request. Returns: `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': {}, 'context': {}, 'metadata': {'created_by': 'system'} } ``` rTrRrUrVs rOrlzSyncAssistantsClient.gets-Ryy}}<. )76  rQFrYctd|i}|r|j||jjd|d||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. params: Optional query parameters to include with the request. Returns: 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__'} ] } ``` rZrTr\rr]r^s rOr`zSyncAssistantsClient.get_graphsI\~     'yy}}<. / g  rQcF|jjd|d||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. params: Optional query parameters 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' } } }, 'context_schema': { 'title': 'Context', 'type': 'object', 'properties': { 'model_name': { 'title': 'Model Name', 'enum': ['anthropic', 'openai'], 'type': 'string' } } } } ``` rTrbrRrUrVs rOrcz SyncAssistantsClient.get_schemass/Byy}}<. 176  rQcd|i}|ri||}|$|jjd|d|||S|jjd|d||S)aiGet 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. params: Optional query parameters to include with the request. Returns: Subgraphs: The graph schema for the assistant. rerTrfrrgrUrhs rOrkz"SyncAssistantsClient.get_subgraphsjs( ) 1J1&1J  99==|nK {C!!  99==|nJ7!! rQrlcd|i} |r|| d<|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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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 params: Optional query parameters to include with the request. Returns: The created assistant. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.create( graph_id="agent", context={"model_name": "openai"}, metadata={"number":1}, assistant_id="my-assistant-id", if_exists="do_nothing", name="my_name" ) ``` rsrtrmrnrWrorprqrurvrwrxs rOrzzSyncAssistantsClient.createsf #   &GH  !(GI  "*GJ  &2GN # #,GK "GFO %0GM "yy~~   rQr{ci} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|jjd|| || S) azUpdate 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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: 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", context={"model_name": "anthropic"}, metadata={"number":2} ) ``` rsrtrmrnrprqrTrvr}r~s rOrzSyncAssistantsClient.updatesZ#% "*GJ   &GH  !(GI  "*GJ  "GFO %0GM "yy<. )   rQcF|jjd|||y)aDelete an assistant. Args: assistant_id: The assistant ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters 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" ) ``` rTrRNrrVs rOrzSyncAssistantsClient.deletes%6 < ~6PVWrQrrrc yrrrs rOrnzSyncAssistantsClient.search3s$'rQrrc yrrrs rOrnzSyncAssistantsClient.searchDsrQc  | dvr td||d} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d <d dfd } ttt|jj d | | | | d k(r| nd }| d k(r|dS|S)a(Search 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. name: The name of the assistant to filter by. The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name. limit: The maximum number of results to return. offset: The number of results to skip. sort_by: The field to sort by. sort_order: The order to sort by. select: Specific assistant fields to include in the response. response_format: Controls the response shape. Use ``"array"`` (default) to return a bare list of assistants, or ``"object"`` to return a mapping containing assistants plus pagination metadata. Defaults to "array", though this default will be changed to "object" in a future release. headers: Optional custom headers to include with the request. Returns: A list of assistants (when ``response_format="array"``) or a mapping with the assistants and the next pagination cursor (when ``response_format="object"``). ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") response = client.assistants.search( metadata = {"name":"my_name"}, graph_id="my_graph_id", limit=5, offset=5, response_format="object", ) assistants = response["assistants"] next_cursor = response["next"] ``` rz+response_format must be 'array' or 'object'rrnrsrprrrNc<|jjdyrrrs rOrz7SyncAssistantsClient.search..capture_paginationrrQrrrrrrrs @rOrnzSyncAssistantsClient.searchUsl "5 5JK K#  "*GJ  "*GJ  "GFO !(GI  $.GL !  &GH "&  D O IINN$2AX2M.SW     h &",kB BrQrcni}|r||d<|r||d<|r||d<|jjd|||S)rrnrsrprrvrwrs rOrzSyncAssistantsClient.countsR,#% "*GJ  "*GJ  "GFOyy~~ gwv  rQc`||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: 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" ) ``` rrnrTrrvrwrs rOrz!SyncAssistantsClient.get_versionssPD#  "*GJ yy~~<. 2   rQcPd|i}|jjd|d|||S)aFChange 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` 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 ) ``` rrTrrvrwrs rOrzSyncAssistantsClient.set_latests=<$-g"6yy~~<. 0   rQrrrrrrrrrrrrrrrrrrrrrrrQrOrrssg -1)- + + * + ' +  + b!,0)- 3 3  3 * 3 ' 3  )3 r-1)- C C * C ' C  C P!% " -1)-""" " * "'" "N!%E #'#'/3,0"&)-E E E  E  E !E -E E *E  E 'E  E V $ $"&,0"&)-? ?  ?  ?  ? ? ? *?  ? '?  ? J-1)- XX* X ' X  X:#*.'+48,0)-'' '  '  ''('%'2'+'*''' "'' #*.'+48,3,0)-     (%2**' &#*.'+486=,0)-ZZ Z  Z  ZZ(Z%Z2Z4Z*Z'Z 4Z~#,0)-      *  '   H , -1)-, , ,  ,  , *, ',  , f-1)- % % % * % ' %  % rQrc eZdZdZddZddd ddZddddddddd ddZdddd dd Zddd d d Zddddd d dddddd d!dZ dddddd d"dZ ddd d dZ d#dddd d$dZ dddddd d%dZ d dddddd d&dZddddd d'dZy)(ra}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||_yrrOrPs rOrzSyncThreadsClient.__init__6rQrQNrRcD|jjd|||S)aIGet 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` 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'} } ``` rrRrUrs rOrlzSyncThreadsClient.get9s%Lyy}}y 4gf}UUrQrc vi} |r|| d<|s|ri|xsi|rd|ini| d<|r|| d<|rA|D cgc]0} d| dD cgc]} | d| jd| dd c} i2c} } | d <|$t|ttfr |d d | d <n|| d <|jj d| ||Scc} wcc} } w)aRCreate 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. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. Returns: 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" ) ``` ) rkrsrnrorrrrrrrrrrrvrrs rOrzzSyncThreadsClient.createas V#% #,GK x#>r#-5J)2#GJ  #,GK $ % "#9    '(k'(uuY'7'(|   %GL ! ?#U|,),(!C!$yy~~jwPV~WW#  %s B5"B0B50B5rcd|i}|$t|ttfr |dd|d<n||d<|jj d||||S)anUpdate a thread. Args: thread_id: ID of thread to update. metadata: Metadata to merge with existing thread metadata. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: 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}, ttl=43_200, ) ``` rnrrrrrvrrs rOrzSyncThreadsClient.updatesfD$.x"8 ?#U|,),(!C!$yy { #   rQcF|jjd|||y)aDelete a thread. Args: thread_id: The ID of the thread to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: `None` ???+ example "Example Usage" ```python client.threads.delete( thread_id="my_thread_id" ) ``` rrRNrrs rOrzSyncThreadsClient.deletes$4 9YK0'&QrQrrrc ||d} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d<| r| | d<|jjd | | | S) aSearch for threads. Args: metadata: Thread metadata to filter on. values: State values to filter on. ids: List of thread IDs to filter by. 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 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 ) ``` rrnrrrrrrrrvrwrs rOrnzSyncThreadsClient.searchsV#  "*GJ   &GH   GEN  &GH  !(GI  $.GL !  &GH yy~~ GWV  rQrcni}|r||d<|r||d<|r||d<|jjd|||S)rrnrrrrvrwrs rOrzSyncThreadsClient.count7sS*#% "*GJ   &GH   &GH yy~~ 7GF  rQcH|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. params: Optional query parameters 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" ) ``` rrNrvrwrs rOrzSyncThreadsClient.copyWs06yy~~ {% (tWV  rQFrc|r&|jjd|d||d||S|r0d|i}|ri||}|jjd|d|||Sd|i}|ri||}|jjd|d||S) abGet 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: 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' } } ``` rrrrvrrrrrrs rOrzSyncThreadsClient.get_statevsZ 99>>I;&78$.YG "  %y1J5 5f5 99==I;gm_=!!  &y1J5 5f5 99==I;f-!! rQrczd|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: 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': {} } } ``` rrrrrrrvrwrs rOrzSyncThreadsClient.update_statesg` f#  '4GO $ $.GL ! !(GI yy~~ {& )QW  rQrczd|i}|r||d<|r||d<|r||d<|jjd|d|||S)aCGet 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: 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"} ) ``` rrrnrrr rvrwr s rOr zSyncThreadsClient.get_history9siL U#   &GH  "*GJ  $.GL !yy~~ {( +   rQr )rrrYrcd|i}|r|j||jjd|ddi|rd|ini|xsi|S)aGet a stream of events for a thread. Args: thread_id: The ID of the thread to get the stream for. last_event_id: The ID of the last event to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: An iterator of stream parts. ???+ example "Example Usage" ```python for chunk in client.threads.join_stream( thread_id="my_thread_id", last_event_id="my_event_id", stream_mode="run_modes", ): print(chunk) ``` rrrrrrRr)rrkrrrYrr_s rOrzSyncThreadsClient.join_streamnsvD ;      'yy {' * 7DO]3"=b    rQr*rrrrrrrrr r!) rkrGrr#rrrYr4rr3rrr$rrQrOrr(s -1)- &V&V* &V ' &V  &VV $/3KO#.2,0)-IXIX IX - IX I IXIX,IX*IX'IX IX`/3,0)-- - $ - , - * - '-  - f-1)- RR* R ' R  R>$(&*'+'+15,0)-> >  > " > $ > > > %> %> /> *> '>  > F&*,0)-    $  *  '   H-1)-   *  '    D)-$( E  ,0)-EE&E" E  E*E'E EX#(,$(,0)-: : 7:  : & : ": *: ':  #: @*.-1(,,0)-3 3  3 ( 3 + 3 &3 *3 '3  3 rFQ$(,0)-. . C . " . * . '.  . rQrczeZdZdZd'dZedddddddddddddddddddddd d(dZeddddddddddddddddddddd d)d Zddddddddddddddddddddddddd  d*d Zeddddddddddddddddddd  d+d Zeddddddddddddddddddddd d,dZddddddddddddddddddddddd d-dZddd d.dZedddddddddddddddddddd d/dZ edddddddddddddddddd d0dZ dddddddddddddddddddddd d1dZ ddddddd d2dZ ddd d3dZ dd ddd! d4d"Z ddd d5d#Z dddddd$ d6d%Zddd d7d&Zy)8ra~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||_yrrOrPs rOrzSyncRunsClient.__init__rQrQNrF)r'rrr(rnrtrmrrr*r+r,r-r.r/r0r1r2rYrr3cyrr)rrkrWr'rrr(rnrtrmrrr*r+r,r-r.r/r0r1r2rYrr3s rOrzSyncRunsClient.streams6 #rQ)r'rrr(r)rnrtrmr*r+r,r-r.r5r1r/r2rYrr3cyrr)rrkrWr'rrr(r)rnrtrmr*r+r,r-r.r5r1r/r2rYrr3s rOrzSyncRunsClient.streams4 #rQr7c | tjdtdid|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)aCreate 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) 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. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: 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"}, context={"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) ``` Nr:rrr'rrtrmrnrr(r)rWr+r,r-r/rrr*r0r;rr<c8rt|x}r |yyyr>r?r@s rOrz*SyncRunsClient.stream..on_responseurArQrBrrCrDrFs ` rOrzSyncRunsClient.streamsL  ( MMv"   U GN'--/C$!QQ]ACTX f  w     ;   0   0  L   0    ]  w *! " ]# $ !2% & !"4' (+***$1 8$ {, /   ) yy  #*==?D41aam!Q$D'5    <@    EDJErJ)r'rrr(r)rnrtrmr*r+r,r/r5r1r2rYrr3cyrr)rrkrWr'rrr(r)rnrtrmr*r+r,r/r5r1r2rYrr3s rOrzzSyncRunsClient.creates0rQrLcyrrrNs rOrzzSyncRunsClient.creates4rQrOc| tjdtdid|d|r'|jDcic] \}}| || c}}ndd|d|d |d | d | d |d |d|d|d|d| d| d| d|d||||d}|jDcic] \}}| || }}}dfd }|jj |rd|dnd|||r|SdScc}}wcc}}w)a\Create 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) 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. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: 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"}, context={"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, 'assistant_id': 'my_assistant_id' } }, 'context': { 'model_name': 'openai' }, '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' } ``` Nr:rrr'rrr(r)rtrmrnrWr+r,r/rrr*r0r1rQc8rt|x}r |yyyr>r?r@s rOrz*SyncRunsClient.create..on_responsedrArQrrSrrCrTrUs ` rOrzzSyncRunsClient.createsV  ( MMv"   U GN'--/C$!QQ]ACTX ;   0    0  f  w    L   0    w  * ]! " !2# $ !"4% & ]' (+*$- 0%,MMOEDAqq}1a4EE ) yy~~,5i {% (7'5   <@   9D*Fs C! C!  C'"C'rRc|dd}|Dcgc] }|| }}|jjd|||Scc}w)rWc\|jDcic] \}}| || c}}Scc}}wrrYrZs rOr[z3SyncRunsClient.create_batch..filter_payloadzr\r]r^rvr_rwr`s rOrczSyncRunsClient.create_batchqsL Gr?r@s rOrz(SyncRunsClient.wait..on_responseHrArQrrmrBrrC)rrrErrr)rrkrWr'rrnrtrmr*rrr+r,r/r.r5r0r1r2rerYrr3r8rGrHryrrIs ` rOrhzSyncRunsClient.waitsh  ( MMv"   U GN'--/C$!QQ]ACTX f  w     L   0    w  *  ]  !"4  ] ]! " !2# $ ]% & ]' ('$+ 0 ) 2;1Fi {* -L yy**  #*==?D41aam!Q$D'5 +  <@ +  ;D@Es C" C" = C(C(rrrqc||d}|||d<|r||d<|r|j||jjd|d||S)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. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: 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, ) ``` rrrrrSrr]rss rOrezSyncRunsClient.listYsgF27&'I  %+L " %+L "     'yy}} {% (w  rQcJ|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` object. ???+ example "Example Usage" ```python run = client.runs.get( thread_id="thread_id_to_delete", run_id="run_id_to_delete", ) ``` rrurRrUrvs rOrlzSyncRunsClient.gets2:yy}} {& 176  rQrwrxc|rdnd|d}|r|j||r'|jjd|d|ddd|| S|jjd|d|dd|| S) a\Get 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. params: Optional query parameters 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" ) ``` rrr{rrur|rBNrr}r~s rOrzSyncRunsClient.cancelsLA1      ' 99..I;fVHG<# / yy~~ {& 8   rQcN|jjd|d|dd||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. params: Optional query parameters 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" ) ``` rrurrrRrrvs rOrzSyncRunsClient.joins;<yy** {& 6  +  rQrc||d}|r|j||jjd|d|dd|i|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. params: Optional query parameters to include with the request. last_event_id: The last event ID to use for the stream. 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"] ) ``` )rrrrurrrNrrrs rOrzSyncRunsClient.join_streamsT'$8      'yy {& 8 7DO]3"=b  rQcL|jjd|d|||y)aRDelete 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. params: Optional query parameters 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" ) ``` rrurRNrrvs rOrzSyncRunsClient.deleteAs/<  {& 176  rQr*)0rkrGrWrGr'rrrrrr(rrnr"rtrrmrrrrrr*rr+rr,rr-rr.rr/rr0rr1rr2rrYr4rr3r3rrr).rkrrWrGr'rrrrrr(rr)rrnr"rtrrmrr*rr+rr,rr-rr.rr5rr1rr/rr2rrYr4rr3r3rrr)6rkrrWrGr'rrrrrr(rr)rrnr"rtrrmrrrrrr*rr+rr,rr-rr.rr5rr/rr0rr1rr2rrYr4rr3r3rr8rrr)*rkrrWrGr'rrrrrr(rr)rrnr"rtrrmrr*rr+rr,rr/rr5rr1rr2rrYr4rr3r3rrr*rrrrr)0rkrrWrGr'rrrrnr"rtrrmrr*rrrrrr+rr,rr/rr.rr5rr0rr1rr2rrerrYr4rr3r3rr8rrrrrrr)rkrGrjrGrrrrrYr4rr3rrrrrrrrQrOrrsM   #"&9A!&-1 $"&(,$()-7;6:.2/3"7;,0$(,0)-EI3###  #  #7##+## #&#"#'#5# 4!#",##$-%#&'#(5)#**+#,"-#.*/#0'1#2C3#4 5##8 #"&9A!&!&-1 $"&)-7;6:.2/359,0"$(,0)-EI1###  #  #7###+## #'#5#4# ,!#"-##$3%#&*'#()#*"+#,*-#.'/#0C1#2 3##@#"&9A!&!&-1 $"&(,$()-7;6:.2/359"7;,0$(,0)-EI(,9X X X  X  X 7X X X +X X  X &X "X 'X 5!X "4#X $,%X &-'X (3)X *+X ,5-X .*/X 0"1X 2*3X 4'5X 6C7X 8&9X : ;X t #"&9A!&!&-1 $"&)-7;6:"59,0$(,0)-EI-    7+ '54 !"3#$*%&"'(*)*'+,C-. /2 #"&9A!&!&-1 $"&(,$()-7;6:"7;,0$(,0)-EI1    7+ &"' 5!"4#$%&5'(*)*"+,*-.'/0C12 3@#"&9A!&!&-1 $"&(,$()-7;6:"7;,059$(,0)-EI(,5v v v  v  v 7v v v +v v  v &v "v 'v 5!v "4#v $%v &5'v (*)v *3+v ,"-v .*/v 0'1v 2C3v 4&5v 6 7v x-1)-  ! *  '    " #"&-1 $"&(,$()-7;6:"/37;,0$( ,0)-EI/***  *  *+** *&*"*'*5*4** -!*"5#*$*%*&"'*()***+*,'-*.C/*0 %1**4 #"&-1 $"&)-7;6:"/359,0$( ,0)-EI+***  *  *+** *'*5*4**-*3* *!*""#*$%*&*'*(')**C+*, %-**:#"&-1 $"&)-(,$(7;6:"/3597;,0$( ,0)-EI(,3a a a  a  a +a a  a 'a &a "a 5a 4a a -!a "3#a $5%a &*'a (")a *+a ,*-a .'/a 0C1a 2&3a 4 %5a N#'.2,0)-, ,  ,  , ! , ,, *, ',  , f-1)-    *  '    L*,0)-8 8 8  8  8 *8 '8  8 ~-1)- # # # * # ' #  # T&+@D,0)-$(8 8 8 # 8 > 8 *8 '8 "8  8 ~-1)-      *  '     rQrc TeZdZdZddZdddddddddddd ddZdddddddddddd ddZddd ddZddd d dddddd dd Zddddd  ddZ y)raSynchronous 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||_yrrOrs rOrzSyncCronClient.__init__wrrQNrc ||||||| | || | 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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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: 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"}, context={"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" ) ``` ) rr'rtrnrmrWr+r,r*r/r0rrrvrrs rOrz SyncCronClient.create_for_threadzsx! ( 0.!2"4  %,MMOEDAqq}1a4EEyy~~ {+ .   Fs AAc |||||||| | || d }|jDcic] \}}| || }}}|jjd|| | Scc}}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. context: Static context to add to the assistant. !!! version-added "Added in version 0.6.0" 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: 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"}, context={"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" ) ``` ) rr'rtrnrmrWr+r,r/r*r0rrvrrs rOrzzSyncCronClient.creates}v! ( 0.!2"4  %,MMOEDAqq}1a4EEyy~~   Fs AArRcF|jjd|||y)aDelete a cron. Args: cron_id: The cron ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters 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" ) ``` rrRNrrs rOrzSyncCronClient.deletes$6 <y176RrQrrrc ||||d} |r|| d<|r|| d<|r|| d<| jD cic] \} } |  | |  } } } |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: 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' } ] ``` rrrrrrvrrs rOrnzSyncCronClient.search3s~)"   !(GI  $.GL !  &GH $+MMOEDAqq}1a4EEyy~~ w  Fs A"A"rc`i}|r||d<|r||d<|jjd|||S)rrWrkrrvrwrs rOrzSyncCronClient.countsF&#% &2GN # #,GK yy~~ gwv  rQ)rrrrrrrrrrrrQrOrrds$ #-1 $"&)-3726")-,0)-!N N N  N  N +N N  N 'N 1N 0N N 'N *N '!N " #N j#-1 $"&)-3726")-,0)-J J  J  J + J J  J 'J 1J 0J J 'J *J 'J !J `-1)- SS* S ' S  S@$( $%)'+/3,0)-M !M  M  M  M #M %M -M *M 'M  M d$( $,0)-  !   *  '    rQrceZdZdZd dZ d d dZdddd ddZ d ddZ d ddZ dddd  dd Z y)raA 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||_yrrOrPs rOrzSyncStoreClient.__init__rQrQNc|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. params: Optional query parameters 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"} ) ``` rrrrrrvNrrs rOrzSyncStoreClient.put_itemssH Ee| /w6gh  #   !8'RX  rQrc|D]}d|vstd|d|dj|d}|||d<|r|j||jj d||S)atRetrieve 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: 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' } ``` rrrr"rirrr)rTrrrrl)rrir"rrYrrr_s rOrzSyncStoreClient.get_itemsX Ee| /w6gh  #)1DE  "*5L '     'yy}}^L'}RRrQcH|jjd||d||y)asDelete 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. params: Optional query parameters 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", ) ``` rrYrvNrrs rOrzSyncStoreClient.delete_items,:  95  rQc d||||||d} |jjdt| ||S)a*Search 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. params: Optional query parameters to include with the request. Returns: 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 ... ] } ``` rrrvrrs rOrzSyncStoreClient.search_itemsAsKx!1&  yy~~ !(   rQrRcb|||||d}|jjdt|||S)a List 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: 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"], ... ] ``` rrrvrrs rOrzSyncStoreClient.list_namespacessH`"  yy~~ (   rQr*rrrrrrr)NNNrrrrrrQrOrrs 48,0)-2  2 ! 2 1 2 2 *2 '2  2  2 t$(,0)-7S 7S 7S ! 7S*7S'7S 7S|-1)- "  " * " ' "  "  " P,0 #',0)-H ) H  H  H H !H *H 'H 'H  H X$(#' $ ; -1)-;  ; !;  ;  ;  ; *; ';  ; rQrc\|jDcic] \}}| || c}}Scc}}wrrY)drGrHs rOrrs(WWY 8TQ!-AqD 88 8r]zlist[httpx.ASGITransport]rc(tD] }||_ yr)rrz)rzrs rOconfigure_loopback_transportsr`s+  rQr)maxsizecf ddlm}|jS#t$rtjcYSwxYw)Nrasgi_transport) langgraph_apird ASGITransport ImportErrorrrcs rOrrs1#0+++ #"""#s 00)rLrrr)rLrrWr4rzdict[str, str])rfr rr )rprrzRunCreateMetadata | None) rtrrLrrYr4ruTimeoutTypes | Nonerrv)rr rz#tuple[dict[str, str], bytes | None])rrrr ) rtrrLrrYr4rurhrr)rr rztuple[dict[str, str], bytes])r^rrzdict[str, Any])rzr rr)rztype[httpx.ASGITransport])wr __future__rr@ functoolsloggingrIrerrcollections.abcrrrrrtypesr typingr r r r rrCrUlanggraph_sdk.errorsrrlanggraph_sdk.schemarrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:langgraph_sdk.sser;r<r= getLoggerrrrSrrHrPr[rhcompilermrsrrvrrrrrrrrrrrrrrrrrrrr__annotations__r` lru_cacherrtupler TimeoutTypesrrQrOrys# PP R,,,,,,,,,,,,ZJI   8 $"D&(# (42 ,*P.# <   "&(,#' o# o#o#& o# ! o#  o#d#,#,LAAH  v  v  rE  E  PT T nE E P g g X &(,#' B' B'B'& B' ! B'  B'J&%&%RAAH 0 r  r  jt  t  nB B Jx x v g g T 95716 Q# #    EDL%$, &'( EDL%$, edl BCD mm  rQ