ޠjrSrSSKJr SSKrSSKJrJrJr SSKJ r J r J r SSK J r SSKJr SSKJr SS KJrJrJrJrJrJrJrJrJrJrJrJrJrJ r "S S 5r!g) z/Async client for managing threads in LangGraph.) annotationsN) AsyncIteratorMappingSequence)AnyLiteraloverload) HttpClient)AsyncThreadStream)_quote_path_param) CheckpointJsonOnConflictBehavior PruneStrategyQueryParamTypes SortOrder StreamPartThreadThreadSelectField ThreadSortBy ThreadState ThreadStatusThreadStreamModeThreadUpdateStateResponsec n\rSrSrSrS)SjrSSSS.S*SjjrSSSSSSSSS.S+Sjjr\SS SSS .S,S jj5r \SSSS .S-S jj5r \SSSS .S.Sjj5r SS SSS .S.Sjjr SSS.S/Sjjr SSSSSSSSSSSSS. S0Sjjr SSSSSS.S1Sjjr SSS.S/Sjjr SSSS.S2SjjrS3S SSS.S4SjjjrSSSSSS.S5SjjrSSSSSSS .S6S!jjrS7SSS"S#.S8S$jjjrSS%SSS&.S9S'jjrS(rg): ThreadsClientaClient 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"}) ``` cXlgNhttp)selfr!s V/var/www/html/gaurav/venv/lib/python3.13/site-packages/langgraph_sdk/_async/threads.py__init__ThreadsClient.__init__-s N)includeheadersparamsc# 0nU(aSRU5US'U(aURU5 URRS[ U53UU=(d SS9IShvN $N7f)a2Get a thread by ID. Args: thread_id: The ID of the thread to get. include: Additional fields to include in the response. Supported values: `"ttl"`. 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'} } ``` ,r' /threads/Nr(r))joinupdater!getr )r" thread_idr'r(r) query_paramss r#r0ThreadsClient.get0stT(* &)hhw&7L #     'YY]]))45 6'4#    sA)A2+A0,A2)metadatar1 if_exists superstepsgraph_idttlr(r)c # 0n U(aX)S'U(dU(a0U=(d 0EU(aSU0O0EU S'U(aX9S'U(aEUV V s/sH3n SU SV s/sHn U SU RS5U SS .PM sn 0PM5 sn n U S 'Ub([U[[45(a US S .U S'OXiS'URR SXUS9IS hvN $s sn fs sn n fN7f)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" ) ``` r1r7r4r5updatesvaluescommandas_node)r;r<r=r6Ndeleter8strategyr8z/threadsjsonr(r))r0 isinstanceintfloatr!post) r"r4r1r5r6r7r8r(r)payloadsus r#createThreadsClient.createes&V#% #,K x#>r#-5J)2#GJ  #,K $ %$A "#9   ".A '(k'(uuY'7'(| ".   $ %GL ! ?#U|,,),(!C!$YY^^ Wf$   #  %& s7AC- C%$C C% AC-C+C- C%%C-F)r8return_minimalr(r)c # g7frr"r1r4r8rLr(r)s r#r/ThreadsClient.updates )r8r(r)c # g7frrNrOs r#r/rPs rQc # g7frrNrOs r#r/rPs rQc# SU0nUb([U[[45(a USS.US'OX7S'[U=(d 05nU(aSUS'URR S[ U53UU=(d SUS 9IShvN $N7f) a7Update 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"). return_minimal: If `True`, request a 204 response with no body. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: The updated thread, or `None` when `return_minimal=True`. ???+ 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, ) ``` r4Nr>r?r8zreturn=minimalPreferr,rA)rCrDrEdictr!patchr ) r"r1r4r8rLr(r)rGrequest_headerss r#r/rPsH$.x"8 ?#U|,,),(!C!$w}"- (8OH %YY__))45 6#+t %    sBB B B r-cl# URRS[U53X#S9IShvN gN7f)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" ) ``` r,r-N)r!r>r r"r1r(r)s r#r>ThreadsClient.delete s;6ii))45 6   s *424 r) r4r;idsstatuslimitoffsetsort_by sort_orderselectextractr(r)c # UUS.n U(aXS'U(aX-S'U(aX=S'U(aXMS'U(aX}S'U(aXS'U (aXS'U (aXS 'URRS U U U S 9IS hvN $N7f) 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. sort_by: Sort by field. sort_order: Sort order. select: List of fields to include in the response. extract: Dictionary mapping aliases to JSONB paths to extract from thread data. Paths use dot notation for nested keys and bracket notation for array indices (e.g., `{"last_msg": "values.messages[-1]"}`). Extracted values are returned in an `extracted` field on each thread. Maximum 10 paths per request. 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 ) ``` )r_r`r4r;r]r^rarbrcrdz/threads/searchrANr!rF)r"r4r;r]r^r_r`rarbrcrdr(r)rGs r#searchThreadsClient.search)sn#  "*J   &H   EN  &H  !(I  $.L !  &H  !(I YY^^  $    sA=B?BB)r4r;r^r(r)c# 0nU(aXS'U(aX&S'U(aX6S'URRSXdUS9IShvN $N7f)acCount 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. r4r;r^z/threads/countrANrf)r"r4r;r^r(r)rGs r#countThreadsClient.countzsX*#% "*J   &H   &H YY^^ 7F$    sAA A A cp# URRS[U5S3SUUS9IShvN $N7f)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,z/copyNrAr!rFr rZs r#copyThreadsClient.copysG6YY^^))45U ; $    -646r>)r@r(r)cp# SU0nUS:waX%S'URRSXSUS9IShvN $N7f)aPrune threads by ID. Args: thread_ids: List of thread IDs to prune. strategy: The prune strategy. `"delete"` removes threads entirely. `"keep_latest"` prunes old checkpoints but keeps threads and their latest state. Defaults to `"delete"`. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: A dict containing `pruned_count` (number of threads pruned). ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") result = await client.threads.prune( thread_ids=["thread_1", "thread_2"], ) print(result) # {'pruned_count': 2} ``` thread_idsr>r@z/threads/prunerANrf)r"rrr@r(r)rGs r#pruneThreadsClient.prunesQB *#  x "*J YY^^ 7F$    rp) subgraphsr(r)c# U(a3URRS[U5S3X$S.UUS9IShvN $U(aUSU0nU(a0UE[U5EnURR S[U5S[U53UUS9IShvN $SU0nU(a0UE[U5EnURR S[U5S 3UUS9IShvN $NNPN7f) 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,z/state/checkpoint) checkpointrurANruz/state/)r)r(/state)r!rFr rVr0)r"r1rw checkpoint_idrur(r) get_paramss r# get_stateThreadsClient.get_states\ -i899JK$.G (  %y1J; ;d6l; -i89ARS`Aa@bc!'  &y1J; ;d6l; -i89@!' 's56C)C#AC)C%A C)C'C)%C)'C))r=rwryr(r)c# SU0nU(aXXS'U(aXHS'U(aX8S'URRS[U5S3UUUS9IShvN $N7f) 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': {} } } ``` r;ryrwr=r,rxrANrm) r"r1r;r=rwryr(r)rGs r# update_stateThreadsClient.update_statemswf f#  '4O $ $.L ! !(I YY^^))45V < $    AAAA)r_beforer4rwr(r)c# SU0nU(aX8S'U(aXHS'U(aXXS'URRS[U5S3UUUS9IShvN $N7f) aGet 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, ) ``` r_rr4rwr,z/historyrANrm) r"r1r_rr4rwr(r)rGs r# get_historyThreadsClient.get_historyswJ U#   &H  "*J  $.L !YY^^))45X > $    rsse)r(run_start_timeout transportc US;a [S5e[URUbUO[[R "55UUUUSLUS9$)uOpen a v3 thread-centric streaming session. When `thread_id` is None, a fresh UUIDv4 is minted client-side and included in the URL of subsequent `POST /threads/{thread_id}/...` calls. The server creates the thread row lazily on the first `run.start` (internal server detail — the SDK does not send any `if_not_exists` flag). The v3 protocol response carries only `run_id`, never `thread_id` — that's why the SDK mints the id client-side. Args: thread_id: optional explicit thread identifier. Defaults to a fresh UUIDv4. assistant_id: assistant the run will use. Required. headers: optional headers forwarded on every command and event request for this stream session. run_start_timeout: optional seconds to wait for an in-flight `run.start` before subscribing operations raise `asyncio.TimeoutError`. Defaults to `None` (wait forever). transport: event transport to use — `"sse"` (default) or `"websocket"`. Returns: An `AsyncThreadStream` to use as an async context manager. )r websocketz'transport must be 'sse' or 'websocket'.N)r!r1 assistant_idr(rexplicit_thread_idtransport_kind) ValueErrorr r!struuiduuid4)r"r1rr(rrs r#streamThreadsClient.streamsWD 0 0FG G #,#8ic$**,>O%/(4$  r& run_modes) last_event_id stream_moder(r)c# SU0nU(aURU5 URRS[U5S3S0U(aSU0O0EU=(d 0EUS9$7f)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,z/streamGETz Last-Event-IDr-)r/r!rr )r"r1rrr(r)r2s r# join_streamThreadsClient.join_streamsB ;      'yy))45W = 7DO]3"=b    sAA r )r!r returnNone) r1rr'Sequence[str] | Noner(Mapping[str, str] | Noner)QueryParamTypes | Nonerr)r4rr1 str | Noner5zOnConflictBehavior | Noner6z4Sequence[dict[str, Sequence[dict[str, Any]]]] | Noner7rr8int | Mapping[str, Any] | Noner(rr)rrr)r1rr4Mapping[str, Any]r8rrLzLiteral[False]r(rr)rrr)r1rr4rr8rrLz Literal[True]r(rr)rrr)r1rr4rr8rrLboolr(rr)rrz Thread | None)r1rr(rr)rrr)r4rr;rr]rr^ThreadStatus | Noner_rDr`rDrazThreadSortBy | NonerbzSortOrder | Nonerczlist[ThreadSelectField] | Nonerdzdict[str, str] | Noner(rr)rrz list[Thread]) r4rr;rr^rr(rr)rrrD) rrz Sequence[str]r@rr(rr)rrzdict[str, Any])NN)r1rrwCheckpoint | Noneryrrurr(rr)rrr)r1rr;z&dict[str, Any] | Sequence[dict] | Noner=rrwrryrr(rr)rrr)r1rr_rDrzstr | Checkpoint | Noner4zMapping[str, Any] | Nonerwrr(rr)rrzlist[ThreadState]r) r1rrrr(rrz float | NonerzLiteral['sse', 'websocket']rr ) r1rrrrz-ThreadStreamMode | Sequence[ThreadStreamMode]r(rr)rrzAsyncIterator[StreamPart])__name__ __module__ __qualname____firstlineno____doc__r$r0rJr r/r>rgrjrnrsr{r~rrr__static_attributes__rNr&r#rrs )-,0)- 3 3 & 3 * 3 ' 3  3 p $/3KO#.2,0)-K K  K - K I K K ,K *K 'K  K Z /3).,0)-  $  ,  ' * '     /3,0)-  $  ,  & * '     /3,0)-  $  ,   * '     /3$,0)-2 2 $ 2 , 2  2 *2 '2  2 p-1)-   *  '    D$(&*'+'+15)-,0)-O O  O " O $ O O O %O %O /O 'O *O 'O  O h&*,0)-    $  *  '   H-1)-    *  '    L#+,0)- ' !'  ' * ' ' '  ' X)-$( F  ,0)-FF&F" F  F*F'F FZ#(,$(,0)-@ @ 7@  @ & @ "@ *@ '@  #@ L*.-1(,,0)-2 2  2 ( 2 + 2 &2 *2 '2  2 l!%, -1*.16, ,  , * , ( , /,  , d%)EP,0)-- - " - C - * - '-  #- - r&r)"r __future__rrcollections.abcrrrtypingrrr langgraph_sdk._async.httpr langgraph_sdk._async.streamr langgraph_sdk._shared.utilitiesr langgraph_sdk.schemar rrrrrrrrrrrrrrrNr&r#rsC5" <<))09=$`  `  r&