langgraph-api 0.0.27__py3-none-any.whl → 0.0.28__py3-none-any.whl

{langgraph_api-0.0.27.dist-info → langgraph_api-0.0.28.dist-info}/RECORD

@@ -1,40 +1,37 @@
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 langgraph_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/api/__init__.py,sha256=WBw9xUm5JkvgWVbwHs8vhR5jOf3_zhMjktB96zKNI58,4962
-langgraph_api/api/assistants.py,sha256=9wngelDC9vnSs2vYGTHDSCLf5KNds-6mgP1BWnfoY2M,12865
-langgraph_api/api/meta.py,sha256=Ui9akC-JFd8RvbgAzkPA_QS2baddxITULewLRRIrQLI,2786
+langgraph_api/api/__init__.py,sha256=vwV4VnV7wA7tHqgcsSzeaHHQz9aTNZmTKLO6yT5l9UE,5044
+langgraph_api/api/assistants.py,sha256=6K5HTUjl7lQv0sVRe4RURPrLzTW-BblUjbSYHeN2PfQ,13992
+langgraph_api/api/meta.py,sha256=ifJ_Ki0Qf2DYbmY6OKlqKhLGxbt55gm0lEqH1A0cJbw,2790
 langgraph_api/api/openapi.py,sha256=f9gfmWN2AMKNUpLCpSgZuw_aeOF9jCXPdOtFT5PaTWM,10960
-langgraph_api/api/runs.py,sha256=wAzPXi_kcYB9BcLBL4FXgkBohWwCPIpe4XERnsnWnsA,16042
+langgraph_api/api/runs.py,sha256=HWZ7QPRJwPlvtFtC8cyG5mKd3GJIjRkdR0KWlMssQ84,16574
 langgraph_api/api/store.py,sha256=VzAJVOwO0IxosBB7km5TTf2rhlWGyPkVz_LpvbxetVY,5437
 langgraph_api/api/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
-langgraph_api/asyncio.py,sha256=2fOlx-cZvuj1gQ867Kw1R_wsBsl9jdHYHcUtK2a-x-U,6264
+langgraph_api/api/ui.py,sha256=LiOZVewKOPbKEykCm30hCEaOA7vuS_Ti5hB32EEy4vw,2082
+langgraph_api/asyncio.py,sha256=ipxOGL0CuKZeHw8895ojtfoBU2fj0iJOp48uhiLAmss,7786
 langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/custom.py,sha256=oyXz7UONY1YeTJ5IBGRAbFUz_K6krkptNxW8zzjb0uk,21088
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=InScaL-HYCnxYEauhxU198gRZV9pJn9SzzBoR9Edn7g,2654
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
-langgraph_api/auth/middleware.py,sha256=qc7SbaFoeWaqxS1wbjZ2PPQ4iI2p9T0shWL7c6g0ed4,1636
+langgraph_api/auth/middleware.py,sha256=5VEC3KE0DrEgXHbEta95zpL1S6PYyD9ETXn3lWKVhqI,1684
 langgraph_api/auth/noop.py,sha256=Bk6Nf3p8D_iMVy_OyfPlyiJp_aEwzL-sHrbxoXpCbac,586
 langgraph_api/auth/studio_user.py,sha256=FzFQRROKDlA9JjtBuwyZvk6Mbwno5M9RVYjDO6FU3F8,186
 langgraph_api/cli.py,sha256=YIiuS-2D0fyqLd8BzJBIUAM3mmAJPtLUdPEMS6Awj9o,12752
-langgraph_api/config.py,sha256=TqR7aw6tbTEp_b5cFrYfPK0qSCTAM_UW3IlJLcIURjw,5433
-langgraph_api/cron_scheduler.py,sha256=MW41-TSGUe5OuXycFTy7Ax7ypxHVAv-0ImLonRT8h8o,2629
+langgraph_api/config.py,sha256=iIekoGAQL-v--hVrCzSd2StrelzuHqb1vbpJAoHgxkU,5809
+langgraph_api/cron_scheduler.py,sha256=9yzbbGxzNgJdIg4ZT7yu2oTwT_wRuPxD1c2sbbd52xs,2630
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
-langgraph_api/graph.py,sha256=FombjYQkqj8jrXJFEVkl3m2UyFcq5nSVNswR2HoRsQY,16385
-langgraph_api/http.py,sha256=XrbyxpjtfSvnaWWh5ZLGpgZmY83WoDCrP_1GPguNiXI,4712
-langgraph_api/js/.gitignore,sha256=qAah3Fq0HWAlfRj5ktZyC6QRQIsAolGLRGcRukA1XJI,33
+langgraph_api/graph.py,sha256=viFyQa8-BRRNRZqNNUzLB31cB4IypEMkMucQEJQYLWY,16556
+langgraph_api/http.py,sha256=gYbxxjY8aLnsXeJymcJ7G7Nj_yToOGpPYQqmZ1_ggfA,5240
+langgraph_api/js/.gitignore,sha256=l5yI6G_V6F1600I1IjiUKn87f4uYIrBAYU1MOyBBhg4,59
 langgraph_api/js/base.py,sha256=BpE8-xkUp8HFPRjSKx1tfUQubvoV4jYl6OwZdre3veI,209
-langgraph_api/js/build.mts,sha256=Ih5uB9nMtUH0kRSh-0ro6-ByOOHS_JboZQqEGO5iy3w,1469
-langgraph_api/js/client.mts,sha256=wjqnyK54-cXJcxBoE2h4v6BJUpcq0CFXue8u26SXP3c,23163
-langgraph_api/js/client.new.mts,sha256=c3LEbfnFs2fTYLJsfKHs5-0HdV3Sr16nbIZSWGQU-TE,24201
+langgraph_api/js/build.mts,sha256=ArAEn74HHY_KXt0JCne76FTyGP34VQCHMe6OfPyxLM8,2915
+langgraph_api/js/client.mts,sha256=heQ5LMpK-hWfSrByNeINZn0JTJ3EYaJKCepzfpiXccU,24356
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
-langgraph_api/js/global.d.ts,sha256=zR_zLYfpzyPfxpEFth5RgZoyfGulIXyZYPRf7cU0K0Y,106
-langgraph_api/js/package.json,sha256=FPgZMji0NtQZaO3_5loyPirapgdumMxMZab8I4TnjDY,1040
-langgraph_api/js/remote.py,sha256=D9cqcEgXau-fm_trpNwCHMra5BXntgUa469lgs_a9JQ,622
-langgraph_api/js/remote_new.py,sha256=-9gsJeV32cHPXd-EESFVfPoBoPC7pqR7XKhkb_q9cHA,22781
-langgraph_api/js/remote_old.py,sha256=V_3A3cyhdyFv_xm6CU6WUOQ2aqlkh_KDAMEEDWq_BQQ,22807
+langgraph_api/js/global.d.ts,sha256=cLJRZfYVGmgQ6o_xFevVNNTIi918ZUdxVRnpLVSjiAY,133
+langgraph_api/js/package.json,sha256=j6DMoVgwRqWqTwdd7R1f-kvmiTUAbO3HaUhM8K64lbE,1224
+langgraph_api/js/remote.py,sha256=jUUgdskUbDR_tuhZFrJo4OewbndQ76joczBv-mZHG9k,22637
 langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
-langgraph_api/js/server_sent_events.py,sha256=DLgXOHauemt7706vnfDUCG1GI3TidKycSizccdz9KgA,3702
 langgraph_api/js/src/graph.mts,sha256=mRyMUp03Fwd5DlmNIFl3RiUCQuJ5XwmFp1AfAeKDfVc,3169
 langgraph_api/js/src/hooks.mjs,sha256=XtktgmIHlls_DsknAuwib-z7TqCm0haRoTXvnkgzMuo,601
 langgraph_api/js/src/parser/parser.mts,sha256=wXre7teh8N8RYmGcyhZp4vMJd0kNnnFgoSGEyMVPzpQ,13007
@@ -44,54 +41,60 @@ langgraph_api/js/src/schema/types.template.mts,sha256=oAwnwWOgkEAQ3EouB8dG5Mdg4H
 langgraph_api/js/src/utils/importMap.mts,sha256=pX4TGOyUpuuWF82kXcxcv3-8mgusRezOGe6Uklm2O5A,1644
 langgraph_api/js/src/utils/pythonSchemas.mts,sha256=98IW7Z_VP7L_CHNRMb3_MsiV3BgLE2JsWQY_PQcRR3o,685
 langgraph_api/js/src/utils/serde.mts,sha256=OuyyO9btvwWd55rU_H4x91dFEJiaPxL-lL9O6Zgo908,742
-langgraph_api/js/tests/api.test.mts,sha256=fiQDSdfJj6DhOqQGghFq0RknIYnTPQ7nH_QfBjs7kAk,56931
-langgraph_api/js/tests/compose-postgres.yml,sha256=pbNfeqVUqhWILBuUdwAgQOYsVU_fgkCVm0YlTgU8og8,1721
+langgraph_api/js/sse.py,sha256=lsfp4nyJyA1COmlKG9e2gJnTttf_HGCB5wyH8OZBER8,4105
+langgraph_api/js/tests/api.test.mts,sha256=7B7uIiUsi4X3tN5ji7loaU4PGkoJyHhTIbqPN2V-7kY,57709
+langgraph_api/js/tests/compose-postgres.yml,sha256=wV1Kws7WwUWVIudPkB--v58MOPL9hOcV0MUK-cvNrpA,1738
 langgraph_api/js/tests/graphs/.gitignore,sha256=26J8MarZNXh7snXD5eTpV3CPFTht5Znv8dtHYCLNfkw,12
+langgraph_api/js/tests/graphs/agent.css,sha256=QgcOC0W7IBsrg4pSqqpull-WTgtULZfx_lF_5ZxLdag,23
 langgraph_api/js/tests/graphs/agent.mts,sha256=E9WMv0alMv0njUEECqEsqoRk9NXJUgXW7SyQJ3GOZ8k,5396
+langgraph_api/js/tests/graphs/agent.ui.tsx,sha256=JDFJdpdIS6rglkXTaROSb1Is0j1kt5wN9ML8W4cuht8,175
 langgraph_api/js/tests/graphs/delay.mts,sha256=CFneKxqI4bGGK0lYjSbe80QirowPQlsRSuhDUKfydhk,703
 langgraph_api/js/tests/graphs/error.mts,sha256=l4tk89449dj1BnEF_0ZcfPt0Ikk1gl8L1RaSnRfr3xo,487
 langgraph_api/js/tests/graphs/langgraph.json,sha256=frxd7ZWILdeMYSZgUBH6UO-IR7I2YJSOfOlx2mnO1sI,189
 langgraph_api/js/tests/graphs/nested.mts,sha256=4G7jSOSaFVQAza-_ARbK-Iai1biLlF2DIPDZXf7PLIY,1245
-langgraph_api/js/tests/graphs/package.json,sha256=U1e03aGujf7LHM9j_01fwbD7hcC59kxJM4ZvUECVF3o,118
+langgraph_api/js/tests/graphs/package.json,sha256=Kv2kdlTNeWl00vYQAhngorQ6rLab4SMc7g1AgZslrHQ,118
 langgraph_api/js/tests/graphs/weather.mts,sha256=A7mLK3xW8h5B-ZyJNAyX2M2fJJwzPJzXs4DYesJwreQ,1655
-langgraph_api/js/tests/graphs/yarn.lock,sha256=N-LBwqNAve0B_VvVZvSAGVkCCo9AQO6VDM-AznGVVLQ,10407
+langgraph_api/js/tests/graphs/yarn.lock,sha256=i2AAIgXA3XBLM8-oU45wgUefCSG-Tne4ghWHmUCUKVk,10407
 langgraph_api/js/tests/parser.test.mts,sha256=dEC8KTqKygeb1u39ZvpPqCT4HtfPD947nLmITt2buxA,27883
 langgraph_api/js/tests/utils.mts,sha256=2kTybJ3O7Yfe1q3ehDouqV54ibXkNzsPZ_wBZLJvY-4,421
-langgraph_api/js/yarn.lock,sha256=lYrYP28ph1ipV9sUwNhgk7KHJ057tnymm5PQ9f8ZQnU,103087
-langgraph_api/lifespan.py,sha256=Uj7NV-NqxxD1fgx_umM9pVqclcy-VlqrIxDljyj2he0,1820
-langgraph_api/logging.py,sha256=tiDNrEFwqaIdL5ywZv908OXlzzfXsPCws9GXeoFtBV8,3367
-langgraph_api/metadata.py,sha256=wvNCHvejBiO_VaAF12kbdlNDn1QXH4Fh_buvHD9J60U,3276
+langgraph_api/js/yarn.lock,sha256=W89dVYZMThcec08lJMcYnvEEnQK7VM5cPglvwpIdRv0,82773
+langgraph_api/lifespan.py,sha256=tcW68-Vxh10y15NDn0TJG2qAbU9RwsrQmumT5xs2HBA,2046
+langgraph_api/logging.py,sha256=rnd_pJsnTd-QbxVJQq-FswEDkd9tNzhoqp7g3_ReIzA,3598
+langgraph_api/metadata.py,sha256=jPLNIRxHi7taZ0g60UdOEXenkvDwoYdI11tsmHenb28,3443
 langgraph_api/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/middleware/http_logger.py,sha256=Sxo_q-65tElauRvkzVLt9lJojgNdgtcHGBYD0IRyX7M,3146
+langgraph_api/middleware/http_logger.py,sha256=yuFPNFIWwn-4AE1CogBfWlo8KytzywLi_Bd4ccsyVQE,3150
 langgraph_api/middleware/private_network.py,sha256=eYgdyU8AzU2XJu362i1L8aSFoQRiV7_aLBPw7_EgeqI,2111
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/models/run.py,sha256=1TzTmagDXFQD_LhIMRdguZHmrPSzztq1wiMjF63d2fc,9843
-langgraph_api/patch.py,sha256=94ddcTSZJe22JcpjxiSNjFZdYVnmeoWjk4IX4iBSoyk,1249
-langgraph_api/queue.py,sha256=2sw9HB2cYVBhYUNA3F7lcJAgRjhQJXhA_HNGhFt2BW8,14508
+langgraph_api/patch.py,sha256=82xjuFqY7tgrUm-k1XWHI6k8S6QovSD0zhe--8_xW4o,1296
+langgraph_api/queue_entrypoint.py,sha256=4xICUxXarNV8DhnaqAMhVi3xCmyVKCL3J5NzHxPA9Xc,1835
 langgraph_api/route.py,sha256=fM4qYCGbmH0a3_cV8uKocb1sLklehxO6HhdRXqLK6OM,4421
-langgraph_api/schema.py,sha256=mgam5lpuqZnrNWMm_0nQ95683gCnCvQNRKbiuFj7z8Q,5310
+langgraph_api/schema.py,sha256=hNbg6ep2wiGBBtBJVNBgMYA8uC33AfaqhRXXVUY_At8,5361
 langgraph_api/serde.py,sha256=VoJ7Z1IuqrQGXFzEP1qijAITtWCrmjtVqlCRuScjXJI,3533
 langgraph_api/server.py,sha256=CiNK327zTsEpoVGeJK1JOtZHvOBYRoz0CnBTZUmsC7c,4567
 langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
-langgraph_api/stream.py,sha256=MUYYNgwtLs1Mhq1dm12zda7j8uFYir49umigK6CnuXU,11944
+langgraph_api/stream.py,sha256=LKXxol0y9xEsrgnbsDwyeKIPBDE-75uVz01OcLI-_QE,11976
 langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
 langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
+langgraph_api/webhook.py,sha256=1ncwO0rIZcj-Df9sxSnFEzd1gP1bfS4okeZQS8NSRoE,1382
+langgraph_api/worker.py,sha256=7yQfZBANt1kgJDOEs5B5c3Xy65lzNMmngVbBqLs-r5s,9802
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/middleware.py,sha256=_ODIYzQkymr6W9_Fp9wtf1kAQspnpsmr53xuzyF2GA0,612
 langgraph_license/validation.py,sha256=Uu_G8UGO_WTlLsBEY0gTVWjRR4czYGfw5YAD3HLZoj0,203
 langgraph_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_storage/checkpoint.py,sha256=V4t2GwYEJdPCHbhq_4Udhlv0TWKDzlMu_rlNPdTDc50,3589
-langgraph_storage/database.py,sha256=Nr5zE9Fur3-tESkqe7xNXMf2QlBuw3H0CUie7jVa6Q4,6003
-langgraph_storage/ops.py,sha256=Lp6ICiPq-Td8mE7dxBRRvkw6vLh1-hkIJBw-b6XrN84,68533
-langgraph_storage/queue.py,sha256=6cTZ0ubHu3S1T43yxHMVOwsQsDaJupByiU0sTUFFls8,3261
-langgraph_storage/retry.py,sha256=uvYFuXJ-T6S1QY1ZwkZHyZQbsvS-Ab68LSbzbUUSI2E,696
-langgraph_storage/store.py,sha256=D-p3cWc_umamkKp-6Cz3cAriSACpvM5nxUIvND6PuxE,2710
+langgraph_storage/database.py,sha256=I0AgFeJ-NSTT34vxKxQBUf1z2syFP0S8QpKCqTixrzY,5652
+langgraph_storage/inmem_stream.py,sha256=8bxkILIuFpr7P7RQ37SQAxrpRKvmbHdRB_nbfFiomlk,3263
+langgraph_storage/ops.py,sha256=BB1UabucGRPg_j-S-KktUbBypvrIj9xWQ596mkZbaQQ,69504
+langgraph_storage/queue.py,sha256=UDgsUTtUMfBSRDrQ8Onis-FJO4n7KTsX6sdpbY8Hs0A,5055
+langgraph_storage/retry.py,sha256=XmldOP4e_H5s264CagJRVnQMDFcEJR_dldVR1Hm5XvM,763
+langgraph_storage/store.py,sha256=SL7VYCO1wI3O1WP20A9jD3lsxXIN990XuuyVrrj6RVY,2855
 langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=DqXpD6JD4tvSOhUgDN_6f919F8YmOSAK4CsGi1NDoiI,125252
-langgraph_api-0.0.27.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.27.dist-info/METADATA,sha256=Zj33U6YPr4wDO_HthEN9toXaw66aDAbMxRp_NeodLLI,4033
-langgraph_api-0.0.27.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.27.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.27.dist-info/RECORD,,
+openapi.json,sha256=8NhoZn3Dse6Ia0i7fXCB46sdGnEg5qAhov_8of-6m0o,125282
+langgraph_api-0.0.28.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.28.dist-info/METADATA,sha256=mDuNiHWUtLvJaA51ixXV2c6lIScZm-_uHqTP6MLa-7g,4029
+langgraph_api-0.0.28.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.28.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.28.dist-info/RECORD,,

langgraph_storage/database.py

@@ -1,7 +1,5 @@
 import asyncio
-import json
 import os
-import threading
 import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator
@@ -13,9 +11,10 @@ from uuid import UUID
 import structlog
 from langgraph.checkpoint.memory import PersistentDict
 
+from langgraph_api import config as langgraph_config
 from langgraph_api.utils import AsyncConnectionProto
 from langgraph_storage import store
-from langgraph_storage.queue import start_queue, stop_queue
+from langgraph_storage.inmem_stream import start_stream, stop_stream
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -23,6 +22,7 @@ logger = structlog.stdlib.get_logger(__name__)
 class Assistant(TypedDict):
     assistant_id: UUID
     graph_id: str
+    name: str
     created_at: NotRequired[datetime]
     updated_at: NotRequired[datetime]
     config: dict[str, Any]
@@ -66,6 +66,7 @@ class AssistantVersion(TypedDict):
     config: dict[str, Any]
     metadata: dict[str, Any]
     created_at: NotRequired[datetime]
+    name: str
 
 
 class GlobalStore(PersistentDict):
@@ -109,26 +110,12 @@ GLOBAL_RETRY_COUNTER = InMemoryRetryCounter()
 GLOBAL_STORE = GlobalStore(filename=OPS_FILENAME)
 
 
-class LockDict(defaultdict):
-    def __init__(self, *args, **kwargs):
-        self.__masterlock__ = threading.Lock()
-        super().__init__(*args, **kwargs)
-
-    def __getitem__(self, key):
-        with self.__masterlock__:
-            return super().__getitem__(key)
-
-
-GLOBAL_LOCKS = LockDict(threading.Lock)
-
-
 class InMemConnectionProto:
     def __init__(self):
         self.filename = OPS_FILENAME
         self.store = GLOBAL_STORE
         self.retry_counter = GLOBAL_RETRY_COUNTER
         self.can_execute = False
-        self.locks = GLOBAL_LOCKS
 
     @asynccontextmanager
     async def pipeline(self):
@@ -139,7 +126,6 @@ class InMemConnectionProto:
 
     def clear(self):
         self.store.clear()
-        self.locks.clear()
         keys = list(self.retry_counter._counters)
         for key in keys:
             del self.retry_counter._counters[key]
@@ -157,8 +143,8 @@ async def connect(*, __test__: bool = False) -> AsyncIterator[AsyncConnectionPro
 
 async def start_pool() -> None:
     if store._STORE_CONFIG is None:
-        if (config_val := os.getenv("LANGGRAPH_STORE")) and config_val.strip():
-            config_ = json.loads(config_val.strip())
+        if langgraph_config.STORE_CONFIG:
+            config_ = langgraph_config.STORE_CONFIG
             store.set_store_config(config_)
 
     if not os.path.exists(".langgraph_api"):
@@ -187,7 +173,7 @@ async def start_pool() -> None:
     for k in ["crons"]:
         if not GLOBAL_STORE.get(k):
             GLOBAL_STORE[k] = {}
-    await start_queue()
+    await start_stream()
 
 
 async def stop_pool() -> None:
@@ -200,7 +186,7 @@ async def stop_pool() -> None:
 
     async with Checkpointer():
         pass
-    await stop_queue()
+    await stop_stream()
 
 
 async def healthcheck() -> None:

langgraph_storage/inmem_stream.py

@@ -0,0 +1,108 @@
+import asyncio
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+from uuid import UUID
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Message:
+    topic: bytes
+    data: bytes
+
+
+class ContextQueue(asyncio.Queue):
+    """Queue that supports async context manager protocol"""
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: object | None,
+    ) -> None:
+        # Clear the queue
+        while not self.empty():
+            try:
+                self.get_nowait()
+            except asyncio.QueueEmpty:
+                break
+
+
+class StreamManager:
+    def __init__(self):
+        self.queues = defaultdict(list)  # Dict[UUID, List[asyncio.Queue]]
+        self.control_queues = defaultdict(list)
+
+    def get_queues(self, run_id: UUID) -> list[asyncio.Queue]:
+        return self.queues[run_id]
+
+    async def put(self, run_id: UUID, message: Message) -> None:
+        topic = message.topic.decode()
+        if "control" in topic:
+            self.control_queues[run_id].append(message)
+        queues = self.queues.get(run_id, [])
+        coros = [queue.put(message) for queue in queues]
+        results = await asyncio.gather(*coros, return_exceptions=True)
+        for result in results:
+            if isinstance(result, Exception):
+                logger.exception(f"Failed to put message in queue: {result}")
+
+    async def add_queue(self, run_id: UUID) -> asyncio.Queue:
+        queue = ContextQueue()
+        self.queues[run_id].append(queue)
+        for control_msg in self.control_queues[run_id]:
+            try:
+                await queue.put(control_msg)
+            except Exception:
+                logger.exception(
+                    f"Failed to put control message in queue: {control_msg}"
+                )
+
+        return queue
+
+    async def remove_queue(self, run_id: UUID, queue: asyncio.Queue):
+        if run_id in self.queues:
+            self.queues[run_id].remove(queue)
+            if not self.queues[run_id]:
+                del self.queues[run_id]
+
+
+# Global instance
+stream_manager = StreamManager()
+
+
+async def start_stream() -> None:
+    """Initialize the queue system.
+    In this in-memory implementation, we just need to ensure we have a clean StreamManager instance.
+    """
+    global stream_manager
+    stream_manager = StreamManager()
+
+
+async def stop_stream() -> None:
+    """Clean up the queue system.
+    Clear all queues and stored control messages."""
+    global stream_manager
+
+    # Send 'done' message to all active queues before clearing
+    for run_id in list(stream_manager.queues.keys()):
+        control_message = Message(topic=f"run:{run_id}:control".encode(), data=b"done")
+        for queue in stream_manager.queues[run_id]:
+            try:
+                await queue.put(control_message)
+            except (Exception, RuntimeError):
+                pass  # Ignore errors during shutdown
+
+    # Clear all stored data
+    stream_manager.queues.clear()
+    stream_manager.control_queues.clear()
+
+
+def get_stream_manager() -> StreamManager:
+    """Get the global stream manager instance."""
+    return stream_manager

langgraph_storage/ops.py

@@ -46,7 +46,7 @@ from langgraph_api.serde import Fragment
 from langgraph_api.utils import fetchone, get_auth_ctx
 from langgraph_storage.checkpoint import Checkpointer
 from langgraph_storage.database import InMemConnectionProto, connect
-from langgraph_storage.queue import Message, get_stream_manager
+from langgraph_storage.inmem_stream import Message, get_stream_manager
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -229,6 +229,7 @@ class Assistants(Authenticated):
             "config": config or {},
             "metadata": metadata or {},
             "created_at": now,
+            "name": name,
         }
         conn.store["assistants"].append(new_assistant)
         conn.store["assistant_versions"].append(new_version)
@@ -312,6 +313,7 @@ class Assistants(Authenticated):
             "config": config if config is not None else assistant["config"],
             "metadata": metadata if metadata is not None else assistant["metadata"],
             "created_at": now,
+            "name": name if name is not None else assistant["name"],
         }
         conn.store["assistant_versions"].append(new_version_entry)
 
@@ -459,6 +461,14 @@ class Assistants(Authenticated):
             "read",
             Auth.types.AssistantsRead(assistant_id=assistant_id),
         )
+        assistant = next(
+            (a for a in conn.store["assistants"] if a["assistant_id"] == assistant_id),
+            None,
+        )
+        if not assistant:
+            raise HTTPException(
+                status_code=404, detail=f"Assistant {assistant_id} not found"
+            )
         versions = [
             v
             for v in conn.store["assistant_versions"]
@@ -466,6 +476,12 @@ class Assistants(Authenticated):
             and (not metadata or is_jsonb_contained(v["metadata"], metadata))
             and (not filters or _check_filter_match(v["metadata"], filters))
         ]
+
+        # Previously, the name was not included in the assistant_versions table. So we should add them here.
+        for v in versions:
+            if "name" not in v:
+                v["name"] = assistant["name"]
+
         versions.sort(key=lambda x: x["version"], reverse=True)
 
         async def _yield_versions():
@@ -767,7 +783,7 @@ class Threads(Authenticated):
         async def has_pending_runs(conn_: InMemConnectionProto, tid: UUID) -> bool:
             """Check if thread has any pending runs."""
             return any(
-                run["status"] == "pending" and run["thread_id"] == tid
+                run["status"] in ("pending", "running") and run["thread_id"] == tid
                 for run in conn_.store["runs"]
             )
 
@@ -846,8 +862,6 @@ class Threads(Authenticated):
             raise HTTPException(
                 status_code=404, detail=f"Thread with ID {thread_id} not found"
             )
-        # Delete the thread
-        conn.locks.pop(thread_id, None)
         # Cascade delete all runs associated with this thread
         conn.store["runs"] = [
             run for run in conn.store["runs"] if run["thread_id"] != thread_id
@@ -1120,6 +1134,9 @@ class Threads(Authenticated):
             return []
 
 
+RUN_LOCK = asyncio.Lock()
+
+
 class Runs(Authenticated):
     resource = "threads"
 
@@ -1127,12 +1144,18 @@ class Runs(Authenticated):
     async def stats(conn: InMemConnectionProto) -> QueueStats:
         """Get stats about the queue."""
         pending_runs = [run for run in conn.store["runs"] if run["status"] == "pending"]
+        running_runs = [run for run in conn.store["runs"] if run["status"] == "running"]
 
-        if not pending_runs:
-            return {"n_pending": 0, "max_age_secs": None, "med_age_secs": None}
+        if not pending_runs and not running_runs:
+            return {
+                "n_pending": 0,
+                "max_age_secs": None,
+                "med_age_secs": None,
+                "n_running": 0,
+            }
 
         # Get all creation timestamps
-        created_times = [run.get("created_at") for run in pending_runs]
+        created_times = [run.get("created_at") for run in (pending_runs + running_runs)]
         created_times = [
             t for t in created_times if t is not None
         ]  # Filter out None values
@@ -1140,6 +1163,7 @@ class Runs(Authenticated):
         if not created_times:
             return {
                 "n_pending": len(pending_runs),
+                "n_running": len(running_runs),
                 "max_age_secs": None,
                 "med_age_secs": None,
             }
@@ -1154,13 +1178,13 @@ class Runs(Authenticated):
 
         return {
             "n_pending": len(pending_runs),
+            "n_running": len(running_runs),
             "max_age_secs": oldest_time,
             "med_age_secs": median_time,
         }
 
-    @asynccontextmanager
     @staticmethod
-    async def next(wait: bool) -> AsyncIterator[tuple[Run, int] | None]:
+    async def next(wait: bool, limit: int = 1) -> AsyncIterator[tuple[Run, int]]:
         """Get the next run from the queue, and the attempt number.
         1 is the first attempt, 2 is the first retry, etc."""
         now = datetime.now(UTC)
@@ -1170,7 +1194,7 @@ class Runs(Authenticated):
         else:
             await asyncio.sleep(0)
 
-        async with connect() as conn:
+        async with connect() as conn, RUN_LOCK:
             pending_runs = sorted(
                 [
                     run
@@ -1181,48 +1205,47 @@ class Runs(Authenticated):
             )
 
             if not pending_runs:
-                yield None
                 return
 
             # Try to lock and get the first available run
-            for run in pending_runs:
+            for _, run in zip(range(limit), pending_runs, strict=False):
+                if run["status"] != "pending":
+                    continue
+
                 run_id = run["run_id"]
                 thread_id = run["thread_id"]
-                lock = conn.locks[thread_id]
-                acquired = lock.acquire(blocking=False)
-                if not acquired:
-                    continue
-                try:
-                    if run["status"] != "pending":
-                        continue
+                thread = next(
+                    (t for t in conn.store["threads"] if t["thread_id"] == thread_id),
+                    None,
+                )
 
-                    thread = next(
-                        (
-                            t
-                            for t in conn.store["threads"]
-                            if t["thread_id"] == run["thread_id"]
-                        ),
-                        None,
+                if thread is None:
+                    await logger.awarning(
+                        "Unexpected missing thread in Runs.next",
+                        thread_id=run["thread_id"],
                     )
+                    continue
 
-                    if thread is None:
-                        await logger.awarning(
-                            "Unexpected missing thread in Runs.next",
-                            thread_id=run["thread_id"],
-                        )
-                        continue
+                if run["status"] != "pending":
+                    continue
 
-                    # Increment attempt counter
-                    attempt = await conn.retry_counter.increment(run_id)
-                    yield run, attempt
-                finally:
-                    lock.release()
-                return
-            yield None
+                if any(
+                    run["status"] == "running"
+                    for run in conn.store["runs"]
+                    if run["thread_id"] == thread_id
+                ):
+                    continue
+                # Increment attempt counter
+                attempt = await conn.retry_counter.increment(run_id)
+                # Set run as "running"
+                run["status"] = "running"
+                yield run, attempt
 
     @asynccontextmanager
     @staticmethod
-    async def enter(run_id: UUID) -> AsyncIterator[ValueEvent]:
+    async def enter(
+        run_id: UUID, loop: asyncio.AbstractEventLoop
+    ) -> AsyncIterator[ValueEvent]:
         """Enter a run, listen for cancellation while running, signal when done."
         This method should be called as a context manager by a worker executing a run.
         """
@@ -1234,20 +1257,18 @@ class Runs(Authenticated):
             done = ValueEvent()
             tg.create_task(listen_for_cancellation(queue, run_id, done))
 
-            try:
-                # Give done event to caller
-                yield done
-            finally:
-                # Signal done to all subscribers
-                control_message = Message(
-                    topic=f"run:{run_id}:control".encode(), data=b"done"
-                )
+            # Give done event to caller
+            yield done
+            # Signal done to all subscribers
+            control_message = Message(
+                topic=f"run:{run_id}:control".encode(), data=b"done"
+            )
 
-                # Store the control message for late subscribers
-                await stream_manager.put(run_id, control_message)
-                stream_manager.control_queues[run_id].append(control_message)
-                # Clean up this queue
-                await stream_manager.remove_queue(run_id, queue)
+            # Store the control message for late subscribers
+            await stream_manager.put(run_id, control_message)
+            stream_manager.control_queues[run_id].append(control_message)
+            # Clean up this queue
+            await stream_manager.remove_queue(run_id, queue)
 
     @staticmethod
     async def sweep(conn: InMemConnectionProto) -> list[UUID]:
@@ -1350,6 +1371,7 @@ class Runs(Authenticated):
                 created_at=datetime.now(UTC),
                 updated_at=datetime.now(UTC),
             )
+            await logger.ainfo("Creating thread", thread_id=thread_id)
             conn.store["threads"].append(thread)
         elif existing_thread:
             # Update existing thread
@@ -1382,7 +1404,7 @@ class Runs(Authenticated):
         inflight_runs = [
             r
             for r in conn.store["runs"]
-            if r["thread_id"] == thread_id and r["status"] == "pending"
+            if r["thread_id"] == thread_id and r["status"] in ("pending", "running")
         ]
         if prevent_insert_if_inflight:
             if inflight_runs:
@@ -1521,6 +1543,7 @@ class Runs(Authenticated):
             raise HTTPException(status_code=404, detail="Run not found")
 
         async def _yield_deleted():
+            await logger.ainfo("Run deleted", run_id=run_id)
             yield run_id
 
         return _yield_deleted()
@@ -1545,7 +1568,7 @@ class Runs(Authenticated):
         # wait for the run to complete
         # Rely on this join's auth
         async for mode, chunk in Runs.Stream.join(
-            run_id, thread_id=thread_id, stream_mode="values", ctx=ctx
+            run_id, thread_id=thread_id, stream_mode="values", ctx=ctx, ignore_404=True
         ):
             if mode == b"values":
                 last_chunk = chunk
@@ -1616,7 +1639,7 @@ class Runs(Authenticated):
                 coros.append(stream_manager.put(run_id, control_message))
 
                 # Update status for pending runs
-                if run["status"] == "pending":
+                if run["status"] in ("pending", "running"):
                     if queues or action != "rollback":
                         run["status"] = "interrupted"
                         run["updated_at"] = datetime.now(tz=UTC)
@@ -1793,7 +1816,7 @@ class Runs(Authenticated):
                                     ),
                                 )
                                 break
-                            elif run["status"] != "pending":
+                            elif run["status"] not in ("pending", "running"):
                                 break
             except WrappedHTTPException as e:
                 raise e.http_exception from None