c i`dZddlmZddlmZmZmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZGddZd S) z5Synchronous client for managing threads in LangGraph.) annotations)IteratorMappingSequence)Any)SyncHttpClient) CheckpointJsonOnConflictBehavior PruneStrategyQueryParamTypes SortOrder StreamPartThreadThreadSelectField ThreadSortBy ThreadState ThreadStatusThreadStreamModeThreadUpdateStateResponsec  eZdZdZd^dZddddd_dZdddddddddd`dZdddddad!Zddd"dbd#Zddddd$d%ddddddd& dcd7Z dddddd8ddd9Z ddd"dbd:Z d;ddd<dedBZ dfdCdddDdgdKZ ddddddLdhdPZd$ddddddQdidVZdWddddXdjd]ZdS)kSyncThreadsClienta}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"}) ``` httprreturnNonec||_dS)N)r)selfrs C:\Users\Dell Inspiron 16\Desktop\tws\AgrotaPowerBi\back-agrota-powerbi\mcp-client-agrota\venv\Lib\site-packages\langgraph_sdk/_sync/threads.py__init__zSyncThreadsClient.__init__)s  N)includeheadersparams thread_idstrr!Sequence[str] | Noner"Mapping[str, str] | Noner#QueryParamTypes | Nonerci}|rd||d<|r|||jd|||pdS)aGet 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_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'} } ``` ,r! /threads/Nr"r#)joinupdaterget)rr$r!r"r# query_paramss rr/zSyncThreadsClient.get,swR(*  8&)hhw&7&7L #  (    ' ' 'y}} # # #'4   r )metadatar$ if_exists superstepsgraph_idttlr"r#r1r str | Noner2OnConflictBehavior | Noner34Sequence[dict[str, Sequence[dict[str, Any]]]] | Noner4r5int | Mapping[str, Any] | Noneci} |r|| d<|s|ri|pi|rd|ini| d<|r|| d<|rd|D| d<|*t|ttfr |dd | d <n|| d <|jd | || S) 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" ) ``` ) r$r4r1r2c6g|]}dd|dDiS)updatescXg|]'}|d|d|dd(S)valuescommandas_node)r>r?r@)r/).0us r z7SyncThreadsClient.create...sN     '(k'(uuY'7'7'(|   r )rAss rrCz,SyncThreadsClient.create..sQ % % %   "#9      % % %r r3Ndeleter5strategyr5z/threadsjsonr"r#) isinstanceintfloatrpost) rr1r$r2r3r4r5r"r#payloads rcreatezSyncThreadsClient.create`sV#%  -#,GK  x #>r#-5=J))2#GJ   -#,GK   % %$ % % %GL ! ?#U|,, %),(!C!C!$y~~jwPV~WWWr )r5r"r#Mapping[str, Any]cd|i}|*t|ttfr |dd|d<n||d<|jd||||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, ) ``` r1NrFrGr5r+rI)rKrLrMrpatch)rr$r1r5r"r#rOs rr.zSyncThreadsClient.updateswD$.x"8 ?#U|,, %),(!C!C!$y # # #    r r,cF|jd|||dS)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" ) ``` r+r,N)rrFrr$r"r#s rrFzSyncThreadsClient.deletes04 0Y00'&QQQQQr r) r1r>idsstatuslimitoffsetsort_by sort_orderselectextractr"r#r>rWrXThreadStatus | NonerYrLrZr[ThreadSortBy | Noner\SortOrder | Noner]list[ThreadSelectField] | Noner^dict[str, str] | None list[Thread]c ||d} |r|| d<|r|| d<|r|| d<|r|| d<|r|| d<|r|| d<| r| | d<| r| | d <|jd | | | 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. 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_sync_client(url="http://localhost:2024") threads = client.threads.search( metadata={"number":1}, status="interrupted", limit=15, offset=5 ) ``` )rYrZr1r>rWrXr[r\r]r^z/threads/searchrIrrN)rr1r>rWrXrYrZr[r\r]r^r"r#rOs rsearchzSyncThreadsClient.searchsl# #   +"*GJ   ' &GH   ! GEN  ' &GH   )!(GI   /$.GL !  ' &GH   )!(GI y~~ GWV   r )r1r>rXr"r#cli}|r||d<|r||d<|r||d<|jd|||S)aCount 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. r1r>rXz/threads/countrIrf)rr1r>rXr"r#rOs rcountzSyncThreadsClient.countCse*#%  +"*GJ   ' &GH   ' &GH y~~ 7GF   r cF|jd|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" ) ``` r+z/copyNrIrfrUs rcopyzSyncThreadsClient.copycs56y~~ ( ( ( (tWV   r rF)rHr"r# thread_ids Sequence[str]rHr dict[str, Any]c\d|i}|dkr||d<|jd|||S)aXPrune 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_sync_client(url="http://localhost:2024") result = client.threads.prune( thread_ids=["thread_1", "thread_2"], ) print(result) # {'pruned_count': 2} ``` rlrFrHz/threads/prunerIrf)rrlrHr"r#rOs rprunezSyncThreadsClient.prunesNB *#  x  "*GJ y~~ 7GF   r F) subgraphsr"r# checkpointCheckpoint | None checkpoint_idrqboolrc@|r%|jd|d||d||S|r>8I888$.YGG "   %y1J <; ;d6ll; 9===I==m==!!  &y1J <; ;d6ll; 9==-I---!! r )r@rrrtr"r#&dict[str, Any] | Sequence[dict] | Noner@rcxd|i}|r||d<|r||d<|r||d<|jd|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': {} } } ``` r>rtrrr@r+rwrIrf) rr$r>r@rrrtr"r#rOs r update_statezSyncThreadsClient.update_state2s{` f#   5'4GO $  /$.GL !  )!(GI y~~ ) ) ) )QW   r )rYbeforer1rrr"r#r~str | Checkpoint | NoneMapping[str, Any] | Nonelist[ThreadState]cxd|i}|r||d<|r||d<|r||d<|jd|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"} ) ``` rYr~r1rrr+z/historyrIrf) rr$rYr~r1rrr"r#rOs r get_historyzSyncThreadsClient.get_historyns}L U#   ' &GH   +"*GJ   /$.GL !y~~ + + + +    r run_modes) stream_mode last_event_idr"r#r-ThreadStreamMode | Sequence[ThreadStreamMode]rIterator[StreamPart]cd|i}|r|||jd|ddi|rd|ini|pi|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) ``` rr+z/streamGETz Last-Event-IDr,)r.rstream)rr$rrr"r#r0s r join_streamzSyncThreadsClient.join_streamsD ;   (    ' ' 'y * * * * 7DLO]33"=b     r )rrrr) r$r%r!r&r"r'r#r(rr)r1r r$r6r2r7r3r8r4r6r5r9r"r'r#r(rr) r$r%r1rQr5r9r"r'r#r(rr)r$r%r"r'r#r(rr)r1r r>r rWr&rXr_rYrLrZrLr[r`r\rar]rbr^rcr"r'r#r(rrd) r1r r>r rXr_r"r'r#r(rrL) rlrmrHr r"r'r#r(rrn)NN)r$r%rrrsrtr6rqrur"r'r#r(rr)r$r%r>r{r@r6rrrsrtr6r"r'r#r(rr)r$r%rYrLr~rr1rrrrsr"r'r#r(rr) r$r%rrrr6r"r'r#r(rr)__name__ __module__ __qualname____doc__rr/rPr.rFrgrirkrprzr}rrrDr rrrs  )-,0)- 2 2 2 2 2 2 n $/3KO#.2,0)-IXIXIXIXIXIX`/3,0)-- - - - - - f-1)- RRRRRR>$(&*'+'+15)-,0)-K K K K K K `&*,0)-      H-1)-       F#+,0)- ' ' ' ' ' ' X)-$( E  ,0)-EEEEEEX#(,$(,0)-: : : : : : @*.-1(,,0)-3 3 3 3 3 3 rFQ$(,0)-. . . . . . . . r rN)r __future__rcollections.abcrrrtypingrlanggraph_sdk._sync.httprlanggraph_sdk.schemar r r r r rrrrrrrrrrrDr rrs;;;""""""7777777777333333$v  v  v  v  v  v  v  v  v  v  r