code highlighting (#186)

Author: lnhsingh

src/langgraph-platform/add-auth-server.mdx

@@ -85,7 +85,7 @@ Now you'll upgrade your authentication to validate real JWT tokens from Supabase
 
 Update `src/security/auth.py` to implement this:
 
-```python hl_lines="8-9 20-30" title="src/security/auth.py"
+```python {highlight={8-9,20-30}} title="src/security/auth.py"
 import os
 import httpx
 from langgraph_sdk import Auth

src/langgraph-platform/add-human-in-the-loop.mdx

@@ -8,9 +8,8 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
 
 <Tabs>
   <Tab title="Python">
-    ```python
+    ```python {highlight={2,34}}
     from langgraph_sdk import get_client
-    # highlight-next-line
     from langgraph_sdk.schema import Command
     client = get_client(url=<DEPLOYMENT_URL>)
 
@@ -43,18 +42,17 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
     print(await client.runs.wait(
         thread_id,
         assistant_id,
-        # highlight-next-line
         command=Command(resume="Edited text")   # (3)!
     ))
     # > {'some_text': 'Edited text'}
-    ```
+```
 
     1. The graph is invoked with some initial state.
     2. When the graph hits the interrupt, it returns an interrupt object with the payload and metadata.
     3. The graph is resumed with a `Command(resume=...)`, injecting the human's input and continuing execution.
   </Tab>
   <Tab title="JavaScript">
-    ```js
+    ```javascript {highlight={32}}
     import { Client } from "@langchain/langgraph-sdk";
     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
 
@@ -86,11 +84,10 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
     console.log(await client.runs.wait(
         threadID,
         assistantID,
-        # highlight-next-line
         { command: { resume: "Edited text" }}   # (3)!
     ));
     # > {'some_text': 'Edited text'}
-    ```
+```
 
     1. The graph is invoked with some initial state.
     2. When the graph hits the interrupt, it returns an interrupt object with the payload and metadata.
@@ -138,21 +135,19 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
   This is an example graph you can run in the LangGraph API server.
   See [LangGraph Platform quickstart](/langgraph-platform/deployment-quickstart) for more details.
 
-  ```python
+  ```python {highlight={7,13}}
   from typing import TypedDict
   import uuid
 
   from langgraph.checkpoint.memory import InMemorySaver
   from langgraph.constants import START
   from langgraph.graph import StateGraph
-  # highlight-next-line
   from langgraph.types import interrupt, Command
 
   class State(TypedDict):
       some_text: str
 
   def human_node(state: State):
-      # highlight-next-line
       value = interrupt( # (1)!
           {
               "text_to_revise": state["some_text"] # (2)!
@@ -169,7 +164,7 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
   graph_builder.add_edge(START, "human_node")
 
   graph = graph_builder.compile()
-  ```
+```
 
   1. `interrupt(...)` pauses execution at `human_node`, surfacing the given payload to a human.
   2. Any JSON serializable value can be passed to the `interrupt` function. Here, a dict containing the text to revise.
@@ -180,9 +175,8 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
 
   <Tabs>
     <Tab title="Python">
-      ```python
+      ```python {highlight={2,34}}
       from langgraph_sdk import get_client
-      # highlight-next-line
       from langgraph_sdk.schema import Command
       client = get_client(url=<DEPLOYMENT_URL>)
 
@@ -215,18 +209,17 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
       print(await client.runs.wait(
           thread_id,
           assistant_id,
-          # highlight-next-line
           command=Command(resume="Edited text")   # (3)!
       ))
       # > {'some_text': 'Edited text'}
-      ```
+```
 
       1. The graph is invoked with some initial state.
       2. When the graph hits the interrupt, it returns an interrupt object with the payload and metadata.
       3. The graph is resumed with a `Command(resume=...)`, injecting the human's input and continuing execution.
     </Tab>
     <Tab title="JavaScript">
-      ```js
+      ```javascript {highlight={32}}
       import { Client } from "@langchain/langgraph-sdk";
       const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
 
@@ -258,11 +251,10 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
       console.log(await client.runs.wait(
           threadID,
           assistantID,
-          # highlight-next-line
           { command: { resume: "Edited text" }}   # (3)!
       ));
       # > {'some_text': 'Edited text'}
-      ```
+```
 
       1. The graph is invoked with some initial state.
       2. When the graph hits the interrupt, it returns an interrupt object with the payload and metadata.
@@ -317,12 +309,9 @@ Static interrupts (also known as static breakpoints) are triggered either before
 
 You can set static interrupts by specifying `interrupt_before` and `interrupt_after` at compile time:
 
-```python
-# highlight-next-line
+```python {highlight={1,2,3}}
 graph = graph_builder.compile( # (1)!
-    # highlight-next-line
     interrupt_before=["node_a"], # (2)!
-    # highlight-next-line
     interrupt_after=["node_b", "node_c"], # (3)!
 )
 ```
@@ -335,38 +324,32 @@ Alternatively, you can set static interrupts at run time:
 
 <Tabs>
   <Tab title="Python">
-    ```python
-    # highlight-next-line
+    ```python {highlight={1,5,6}}
     await client.runs.wait( # (1)!
         thread_id,
         assistant_id,
         inputs=inputs,
-        # highlight-next-line
         interrupt_before=["node_a"], # (2)!
-        # highlight-next-line
         interrupt_after=["node_b", "node_c"] # (3)!
     )
-    ```
+```
 
     1. `client.runs.wait` is called with the `interrupt_before` and `interrupt_after` parameters. This is a run-time configuration and can be changed for every invocation.
     2. `interrupt_before` specifies the nodes where execution should pause before the node is executed.
     3. `interrupt_after` specifies the nodes where execution should pause after the node is executed.
   </Tab>
   <Tab title="JavaScript">
-    ```js
-    // highlight-next-line
+    ```javascript {highlight={1,6,7}}
     await client.runs.wait( // (1)!
         threadID,
         assistantID,
         {
         input: input,
-        # highlight-next-line
         interruptBefore: ["node_a"], // (2)!
-        # highlight-next-line
         interruptAfter: ["node_b", "node_c"] // (3)!
         }
     )
-    ```
+```
 
     1. `client.runs.wait` is called with the `interruptBefore` and `interruptAfter` parameters. This is a run-time configuration and can be changed for every invocation.
     2. `interruptBefore` specifies the nodes where execution should pause before the node is executed.

src/langgraph-platform/autogen-integration.mdx

@@ -126,9 +126,8 @@ display(Image(graph.get_graph().draw_mermaid_png()))
 
 Before deploying to LangGraph Platform, you can test the graph locally:
 
-```python
+```python {highlight={2,13}}
 # pass the thread ID to persist agent outputs for future interactions
-# highlight-next-line
 config = {"configurable": {"thread_id": "1"}}
 
 for chunk in graph.stream(
@@ -140,7 +139,6 @@ for chunk in graph.stream(
             }
         ]
     },
-    # highlight-next-line
     config,
 ):
     print(chunk)
@@ -167,7 +165,7 @@ To find numbers between 10 and 30 in the Fibonacci sequence, we can generate the
 
 Since we're leveraging LangGraph's [persistence](/oss/persistence) features we can now continue the conversation using the same thread ID -- LangGraph will automatically pass previous history to the AutoGen agent:
 
-```python
+```python {highlight={10}}
 for chunk in graph.stream(
     {
         "messages": [
@@ -177,7 +175,6 @@ for chunk in graph.stream(
             }
         ]
     },
-    # highlight-next-line
     config,
 ):
     print(chunk)

src/langgraph-platform/custom-auth.mdx

@@ -41,7 +41,7 @@ To leverage custom authentication and access user-level metadata in your deploym
   1. This handler receives the request (headers, etc.), validates the user, and returns a dictionary with at least an identity field.
   2. You can add any custom fields you want (e.g., OAuth tokens, roles, org IDs, etc.).
 2. In your `langgraph.json`, add the path to your auth file:
-  ```json hl_lines="7-9"
+  ```json {highlight={7-9}}
   {
     "dependencies": ["."],
     "graphs": {

src/langgraph-platform/custom-lifespan.mdx

@@ -23,7 +23,7 @@ langgraph new --template=new-langgraph-project-python my_new_project
 
 Once you have a LangGraph project, add the following app code:
 
-```python
+```python {highlight={19}}
 # ./src/agent/webapp.py
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
@@ -42,7 +42,6 @@ async def lifespan(app: FastAPI):
     # Clean up connections
     await engine.dispose()
 
-# highlight-next-line
 app = FastAPI(lifespan=lifespan)
 
 # ... can add custom routes if needed.

src/langgraph-platform/custom-middleware.mdx

@@ -23,12 +23,11 @@ langgraph new --template=new-langgraph-project-python my_new_project
 
 Once you have a LangGraph project, add the following app code:
 
-```python
+```python {highlight={5}}
 # ./src/agent/webapp.py
 from fastapi import FastAPI, Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
-# highlight-next-line
 app = FastAPI()
 
 class CustomHeaderMiddleware(BaseHTTPMiddleware):

src/langgraph-platform/custom-routes.mdx

@@ -20,11 +20,10 @@ langgraph new --template=new-langgraph-project-python my_new_project
 
 Once you have a LangGraph project, add the following app code:
 
-```python
+```python {highlight={4}}
 # ./src/agent/webapp.py
 from fastapi import FastAPI
 
-# highlight-next-line
 app = FastAPI()
 
 

src/langgraph-platform/human-in-the-loop-time-travel.mdx

@@ -159,15 +159,14 @@ To time travel using the LangGraph Server API (via the LangGraph SDK):
 
 <Tabs>
   <Tab title="Python">
-    ```python
+    ```python {highlight={4}}
     new_config = await client.threads.update_state(
         thread_id,
         {"topic": "chickens"},
-        # highlight-next-line
         checkpoint_id=selected_state["checkpoint_id"]
     )
     print(new_config)
-    ```
+```
   </Tab>
   <Tab title="JavaScript">
     ```js
@@ -199,30 +198,26 @@ To time travel using the LangGraph Server API (via the LangGraph SDK):
 
 <Tabs>
   <Tab title="Python">
-    ```python
+    ```python {highlight={4,5}}
     await client.runs.wait(
         thread_id,
         assistant_id,
-        # highlight-next-line
         input=None,
-        # highlight-next-line
         checkpoint_id=new_config["checkpoint_id"]
     )
-    ```
+```
   </Tab>
   <Tab title="JavaScript">
-    ```js
+    ```javascript {highlight={5,6}}
     await client.runs.wait(
       threadID,
       assistantID,
       {
-        // highlight-next-line
         input: null,
-        // highlight-next-line
         checkpointId: newConfig["checkpoint_id"]
       }
     );
-    ```
+```
   </Tab>
   <Tab title="cURL">
     ```bash

src/langgraph-platform/langgraph-basics/2-add-tools.mdx

@@ -89,7 +89,7 @@ llm = init_chat_model("anthropic:claude-3-5-sonnet-latest")
 
 We can now incorporate it into a `StateGraph`:
 
-```python hl_lines="15"
+```python {highlight={14}}
 from typing import Annotated
 
 from typing_extensions import TypedDict
@@ -103,7 +103,6 @@ class State(TypedDict):
 graph_builder = StateGraph(State)
 
 # Modification: tell the LLM which tools it can call
-# highlight-next-line
 llm_with_tools = llm.bind_tools(tools)
 
 def chatbot(state: State):
@@ -293,7 +292,7 @@ For ease of use, adjust your code to replace the following with LangGraph prebui
 
 <ChatModelTabs/>
 
-```python hl_lines="25 30"
+```python {highlight={25,30}}
 from typing import Annotated
 
 from langchain_tavily import TavilySearch

src/langgraph-platform/langgraph-basics/3-add-memory.mdx

@@ -114,11 +114,10 @@ Of course, I remember your name, Will. I always try to pay attention to importan
 
 Don't believe me? Try this using a different config.
 
-```python
+```python {highlight={4}}
 # The only difference is we change the `thread_id` here to "2" instead of "1"
 events = graph.stream(
     {"messages": [{"role": "user", "content": user_input}]},
-    # highlight-next-line
     {"configurable": {"thread_id": "2"}},
     stream_mode="values",
 )
@@ -168,7 +167,7 @@ from langchain.chat_models import init_chat_model
 llm = init_chat_model("anthropic:claude-3-5-sonnet-latest")
 ``` */}
 
-```python hl_lines="36 37"
+```python {highlight={36,37}}
 from typing import Annotated
 
 from langchain.chat_models import init_chat_model