docs: add documentation for function-level and runtime customization of thought messages

Signed-off-by: Patrick Chin <8509935+thepatrickchin@users.noreply.github.com>

Author: thepatrickchin

docs/source/build-workflows/workflow-configuration.md

@@ -71,6 +71,23 @@ From the above we see that it is divided into four sections: `functions`, `llms`
 ### `functions`
 The `functions` section contains the tools used in the workflow, in our example we have two `webpage_query` and `current_datetime`. By convention, the key matches the `_type` value, however this is not a strict requirement, and can be used to include multiple instances of the same tool.
 
+#### Thought process description
+
+Agent responses in the NeMo Agent Toolkit UI include a thought process display which shows a step-by-step view of what the workflow is doing.
+
+To customize the text shown for a function in the thought process display, set `thought_description` in that function's configuration. Unlike `description`, which provides the tool's help text that the agent uses to decide when and how to call the tool, `thought_description` only affects the label shown in the thought process display. For example:
+
+```yaml
+functions:
+  webpage_query:
+    _type: webpage_query
+    thought_description: "Searching internal documentation"
+    webpage_url: https://docs.smith.langchain.com
+    description: "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!"
+    embedder_name: nv-embedqa-e5-v5
+    chunk_size: 512
+```
+If `thought_description` is not set, NeMo Agent Toolkit uses a default thought description. For runtime customization of the thought process display from within your function code, refer to [Customizing Thought Process Display](../extend/custom-components/custom-functions/functions.md#customizing-thought-process-display).
 
 ### `llms`
 This section contains the models used in the workflow. The `_type` value refers to the API hosting the model, in this case `nim` refers to an NIM model hosted on [`build.nvidia.com`](https://build.nvidia.com).

docs/source/extend/custom-components/custom-functions/functions.md

@@ -558,6 +558,80 @@ async def my_function(config: MyFunctionConfig, builder: Builder):
 
 Every function has its own set of converters and are independent of the converters used by other functions. This allows for functions to convert between common types such as `str` -> `dict` or `int` -> `float` without breaking the type safety of other functions.
 
+## Customizing Thought Process Display
+
+Agent responses in the NeMo Agent Toolkit UI include a thought process display that shows a step-by-step view of what the workflow is doing. You can customize what appears in this display at two levels:
+
+* **Function-level customization** - Set a custom label for the entire function using `thought_description` in the configuration
+* **Runtime customization** - Emit custom thoughts from within your function code for fine-grained progress updates
+
+### Function-Level Customization
+
+The simplest way to customize the thought process display is by setting `thought_description` in your function's YAML configuration. Refer to the [Workflow Configuration](../../../build-workflows/workflow-configuration.md#thought-process-description) documentation for details.
+
+### Runtime Customization with Custom Thoughts
+
+For fine-grained control during function execution, you can emit custom thoughts that appear as steps in the thought process display. NeMo Agent Toolkit provides helper functions in {py:mod}`nat.builder.thought` for emitting thoughts:
+
+* {py:func}`~nat.builder.thought.emit_thought` - Emit a complete thought (appears immediately)
+* {py:func}`~nat.builder.thought.emit_thought_start` - Start a streaming thought
+* {py:func}`~nat.builder.thought.emit_thought_chunk` - Update a streaming thought
+* {py:func}`~nat.builder.thought.emit_thought_end` - Complete a streaming thought
+
+#### Emitting Complete Thoughts
+Each call to {py:func}`~nat.builder.thought.emit_thought` in the example below appears as a completed step in the thought process display.
+
+```python
+from nat.builder.context import Context
+from nat.builder.thought import emit_thought
+
+async def process_data(dataset_name: str) -> dict:
+    ctx = Context.get()
+    
+    emit_thought(ctx, f"Loading dataset: {dataset_name}")
+    data = await load_dataset(dataset_name)
+    
+    emit_thought(ctx, "Validating data schema")
+    validate_data(data)
+    
+    emit_thought(ctx, "Applying transformations")
+    result = transform_data(data)
+    
+    emit_thought(ctx, f"Successfully processed {len(result)} records")
+    
+    return {"records_processed": len(result), "status": "complete"}
+```
+
+#### Emitting Streaming Thoughts
+The streaming thought lifecycle consists of three steps:
+1. {py:func}`~nat.builder.thought.emit_thought_start` - Creates the thought and returns a UUID
+2. {py:func}`~nat.builder.thought.emit_thought_chunk` - Updates the thought text (call multiple times)
+3. {py:func}`~nat.builder.thought.emit_thought_end` - Marks the thought as complete
+
+```python
+from nat.builder.thought import emit_thought_start, emit_thought_chunk, emit_thought_end
+
+async def process_batch(items: list[str]) -> dict:
+    ctx = Context.get()
+    
+    thought_id = emit_thought_start(ctx, "Processing batch: 0%")
+    
+    processed = 0
+    total = len(items)
+    
+    for item in items:
+        await process_item(item)
+        processed += 1
+        
+        progress = int((processed / total) * 100)
+        emit_thought_chunk(ctx, thought_id, f"Processing batch: {progress}%")
+    
+    emit_thought_end(ctx, thought_id, f"Batch processing complete: {total} items")
+    
+    return {"items_processed": total}
+```
+
+
 ## Related Documentation
 
 - [Writing Custom Function Groups](./function-groups.md) - Learn how to bundle related functions that can share configuration, resources, and runtime context.