aiqtoolkit 1.1.0a20250429__py3-none-any.whl → 1.1.0a20250502__py3-none-any.whl

aiq/front_ends/fastapi/fastapi_front_end_config.py

@@ -57,7 +57,7 @@ class AIQEvaluateStatusResponse(BaseModel):
 
 class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     """
-    A FastAPI based front end that allows an AgentIQ workflow to be served as a microservice.
+    A FastAPI based front end that allows an AIQ Toolkit workflow to be served as a microservice.
     """
 
     class EndpointBase(BaseModel):
@@ -119,7 +119,7 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
         path="/generate",
         websocket_path="/websocket",
         openai_api_path="/chat",
-        description="Executes the default AgentIQ workflow from the loaded configuration ",
+        description="Executes the default AIQ Toolkit workflow from the loaded configuration ",
     )
 
     evaluate: typing.Annotated[EndpointBase, Field(description="Endpoint for evaluating workflows.")] = EndpointBase(
@@ -131,7 +131,7 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     endpoints: list[Endpoint] = Field(
         default_factory=list,
         description=(
-            "Additional endpoints to add to the FastAPI app which run functions within the AgentIQ configuration. "
+            "Additional endpoints to add to the FastAPI app which run functions within the AIQ Toolkit configuration. "
             "Each endpoint must have a unique path."))
 
     cors: CrossOriginResourceSharing = Field(
@@ -144,7 +144,7 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     )
     runner_class: str | None = Field(
         default=None,
-        description=("The AgentIQ runner class to use when launching the FastAPI app from multiple processes. "
-                     "Each runner is responsible for loading and running the AgentIQ workflow. "
+        description=("The AIQ Toolkit runner class to use when launching the FastAPI app from multiple processes. "
+                     "Each runner is responsible for loading and running the AIQ Toolkit workflow. "
                      "Note: This is different from the worker class used by Gunicorn."),
     )

aiq/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -49,7 +49,7 @@ from aiq.front_ends.fastapi.job_store import JobInfo
 from aiq.front_ends.fastapi.job_store import JobStore
 from aiq.front_ends.fastapi.response_helpers import generate_single_response
 from aiq.front_ends.fastapi.response_helpers import generate_streaming_response_as_str
-from aiq.front_ends.fastapi.response_helpers import generate_streaming_response_raw_as_str
+from aiq.front_ends.fastapi.response_helpers import generate_streaming_response_full_as_str
 from aiq.front_ends.fastapi.step_adaptor import StepAdaptor
 from aiq.front_ends.fastapi.websocket import AIQWebSocket
 from aiq.runtime.session import AIQSessionManager
@@ -82,7 +82,7 @@ class FastApiFrontEndPluginWorkerBase(ABC):
         @asynccontextmanager
         async def lifespan(starting_app: FastAPI):
 
-            logger.debug("Starting AgentIQ server from process %s", os.getpid())
+            logger.debug("Starting AIQ Toolkit server from process %s", os.getpid())
 
             async with WorkflowBuilder.from_config(self.config) as builder:
 
@@ -96,7 +96,7 @@ class FastApiFrontEndPluginWorkerBase(ABC):
                     logger.info("Cancelling cleanup task")
                     cleanup_task.cancel()
 
-            logger.debug("Closing AgentIQ server from process %s", os.getpid())
+            logger.debug("Closing AIQ Toolkit server from process %s", os.getpid())
 
         aiq_app = FastAPI(lifespan=lifespan)
 
@@ -396,14 +396,16 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
 
         def get_streaming_raw_endpoint(streaming: bool, result_type: type | None, output_type: type | None):
 
-            async def get_stream():
+            async def get_stream(filter_steps: str | None = None):
 
                 return StreamingResponse(headers={"Content-Type": "text/event-stream; charset=utf-8"},
-                                         content=generate_streaming_response_raw_as_str(None,
-                                                                                        session_manager=session_manager,
-                                                                                        streaming=streaming,
-                                                                                        result_type=result_type,
-                                                                                        output_type=output_type))
+                                         content=generate_streaming_response_full_as_str(
+                                             None,
+                                             session_manager=session_manager,
+                                             streaming=streaming,
+                                             result_type=result_type,
+                                             output_type=output_type,
+                                             filter_steps=filter_steps))
 
             return get_stream
 
@@ -443,14 +445,16 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
             Stream raw intermediate steps without any step adaptor translations.
             """
 
-            async def post_stream(payload: request_type):
+            async def post_stream(payload: request_type, filter_steps: str | None = None):
 
                 return StreamingResponse(headers={"Content-Type": "text/event-stream; charset=utf-8"},
-                                         content=generate_streaming_response_raw_as_str(payload,
-                                                                                        session_manager=session_manager,
-                                                                                        streaming=streaming,
-                                                                                        result_type=result_type,
-                                                                                        output_type=output_type))
+                                         content=generate_streaming_response_full_as_str(
+                                             payload,
+                                             session_manager=session_manager,
+                                             streaming=streaming,
+                                             result_type=result_type,
+                                             output_type=output_type,
+                                             filter_steps=filter_steps))
 
             return post_stream
 
@@ -478,11 +482,14 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 )
 
                 app.add_api_route(
-                    path=f"{endpoint.path}/stream/full",
+                    path=f"{endpoint.path}/full",
                     endpoint=get_streaming_raw_endpoint(streaming=True,
                                                         result_type=GenerateStreamResponseType,
                                                         output_type=GenerateStreamResponseType),
                     methods=[endpoint.method],
+                    description="Stream raw intermediate steps without any step adaptor translations.\n"
+                    "Use filter_steps query parameter to filter steps by type (comma-separated list) or\
+                        set to 'none' to suppress all intermediate steps.",
                 )
 
             elif (endpoint.method == "POST"):
@@ -510,14 +517,16 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 )
 
                 app.add_api_route(
-                    path=f"{endpoint.path}/stream/full",
+                    path=f"{endpoint.path}/full",
                     endpoint=post_streaming_raw_endpoint(request_type=GenerateBodyType,
                                                          streaming=True,
                                                          result_type=GenerateStreamResponseType,
                                                          output_type=GenerateStreamResponseType),
                     methods=[endpoint.method],
                     response_model=GenerateStreamResponseType,
-                    description="Stream raw intermediate steps without any step adaptor translations",
+                    description="Stream raw intermediate steps without any step adaptor translations.\n"
+                    "Use filter_steps query parameter to filter steps by type (comma-separated list) or \
+                        set to 'none' to suppress all intermediate steps.",
                     responses={500: response_500},
                 )
 

aiq/front_ends/fastapi/response_helpers.py

@@ -117,16 +117,26 @@ async def generate_single_response(
         return await runner.result(to_type=result_type)
 
 
-async def generate_streaming_response_raw(payload: typing.Any,
-                                          *,
-                                          session_manager: AIQSessionManager,
-                                          streaming: bool,
-                                          result_type: type | None = None,
-                                          output_type: type | None = None) -> AsyncGenerator[AIQResponseSerializable]:
+async def generate_streaming_response_full(payload: typing.Any,
+                                           *,
+                                           session_manager: AIQSessionManager,
+                                           streaming: bool,
+                                           result_type: type | None = None,
+                                           output_type: type | None = None,
+                                           filter_steps: str | None = None) -> AsyncGenerator[AIQResponseSerializable]:
     """
     Similar to generate_streaming_response but provides raw AIQResponseIntermediateStep objects
     without any step adaptor translations.
     """
+    # Parse filter_steps into a set of allowed types if provided
+    # Special case: if filter_steps is "none", suppress all steps
+    allowed_types = None
+    if filter_steps:
+        if filter_steps.lower() == "none":
+            allowed_types = set()  # Empty set means no steps allowed
+        else:
+            allowed_types = set(filter_steps.split(','))
+
     async with session_manager.run(payload) as runner:
         q: AsyncIOProducerConsumerQueue[AIQResponseSerializable] = AsyncIOProducerConsumerQueue()
 
@@ -150,7 +160,9 @@ async def generate_streaming_response_raw(payload: typing.Any,
 
             async for item in q:
                 if (isinstance(item, AIQResponseIntermediateStep)):
-                    yield item
+                    # Filter intermediate steps if filter_steps is provided
+                    if allowed_types is None or item.type in allowed_types:
+                        yield item
                 else:
                     yield AIQResponsePayloadOutput(payload=item)
         except Exception as e:
@@ -160,20 +172,22 @@ async def generate_streaming_response_raw(payload: typing.Any,
             await q.close()
 
 
-async def generate_streaming_response_raw_as_str(payload: typing.Any,
-                                                 *,
-                                                 session_manager: AIQSessionManager,
-                                                 streaming: bool,
-                                                 result_type: type | None = None,
-                                                 output_type: type | None = None) -> AsyncGenerator[str]:
+async def generate_streaming_response_full_as_str(payload: typing.Any,
+                                                  *,
+                                                  session_manager: AIQSessionManager,
+                                                  streaming: bool,
+                                                  result_type: type | None = None,
+                                                  output_type: type | None = None,
+                                                  filter_steps: str | None = None) -> AsyncGenerator[str]:
     """
-    Similar to generate_streaming_response_raw but converts the response to a string format.
+    Similar to generate_streaming_response but converts the response to a string format.
     """
-    async for item in generate_streaming_response_raw(payload,
-                                                      session_manager=session_manager,
-                                                      streaming=streaming,
-                                                      result_type=result_type,
-                                                      output_type=output_type):
+    async for item in generate_streaming_response_full(payload,
+                                                       session_manager=session_manager,
+                                                       streaming=streaming,
+                                                       result_type=result_type,
+                                                       output_type=output_type,
+                                                       filter_steps=filter_steps):
         if (isinstance(item, AIQResponseIntermediateStep) or isinstance(item, AIQResponsePayloadOutput)):
             yield item.get_stream_data()
         else:

aiq/memory/__init__.py

@@ -13,8 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """
-AgentIQ Memory Module
+AIQ Toolkit Memory Module
 
 This package provides foundational classes and interfaces
-for managing text-based memory in AgentIQ's LLM-based agents.
+for managing text-based memory in AIQ Toolkit's LLM-based agents.
 """

aiq/meta/pypi.md

@@ -6,7 +6,7 @@ Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
-http:/www.apache.org/licenses/LICENSE-2.0
+http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
@@ -15,39 +15,39 @@ See the License for the specific language governing permissions and
 limitations under the License.
 -->
 
-![NVIDIA AgentIQ](https://media.githubusercontent.com/media/NVIDIA/AgentIQ/refs/heads/main/docs/source/_static/agentiq_banner.png "AgentIQ banner image")
+![NVIDIA Agent Intelligence Toolkit](https://media.githubusercontent.com/media/NVIDIA/AIQToolkit/refs/heads/main/docs/source/_static/aiqtoolkit_banner.png "AIQ Toolkit banner image")
 
-# NVIDIA AgentIQ
+# NVIDIA Agent Intelligence Toolkit
 
-AgentIQ is a flexible library designed to seamlessly integrate your enterprise agents—regardless of framework—with various data sources and tools. By treating agents, tools, and agentic workflows as simple function calls, AgentIQ enables true composability: build once and reuse anywhere.
+AIQ Toolkit is a flexible library designed to seamlessly integrate your enterprise agents—regardless of framework—with various data sources and tools. By treating agents, tools, and agentic workflows as simple function calls, AIQ Toolkit enables true composability: build once and reuse anywhere.
 
 ## Key Features
 
-- [**Framework Agnostic:**](https://docs.nvidia.com/agentiq/latest/concepts/plugins.html) Works with any agentic framework, so you can use your current technology stack without replatforming.
-- [**Reusability:**](https://docs.nvidia.com/agentiq/latest/guides/sharing-workflows-and-tools.html) Every agent, tool, or workflow can be combined and repurposed, allowing developers to leverage existing work in new scenarios.
-- [**Rapid Development:**](https://docs.nvidia.com/agentiq/latest/guides/create-customize-workflows.html) Start with a pre-built agent, tool, or workflow, and customize it to your needs.
-- [**Profiling:**](https://docs.nvidia.com/agentiq/latest/guides/profiler.html) Profile entire workflows down to the tool and agent level, track input/output tokens and timings, and identify bottlenecks.
-- [**Observability:**](https://docs.nvidia.com/agentiq/latest/guides/observe-workflow-with-phoenix.html) Monitor and debug your workflows with any OpenTelemetry-compatible observability tool.
-- [**Evaluation System:**](https://docs.nvidia.com/agentiq/latest/guides/evaluate.html) Validate and maintain accuracy of agentic workflows with built-in evaluation tools.
-- [**User Interface:**](https://docs.nvidia.com/agentiq/latest/guides/using-agentiq-ui-and-server.html) Use the AgentIQ UI chat interface to interact with your agents, visualize output, and debug workflows.
-- [**MCP Compatibility**](https://docs.nvidia.com/agentiq/latest/components/mcp.html) Compatible with Model Context Protocol (MCP), allowing tools served by MCP Servers to be used as AgentIQ functions.
+- [**Framework Agnostic:**](https://docs.nvidia.com/aiqtoolkit/latest/concepts/plugins.html) Works with any agentic framework, so you can use your current technology stack without replatforming.
+- [**Reusability:**](https://docs.nvidia.com/aiqtoolkit/latest/guides/sharing-workflows-and-tools.html) Every agent, tool, or workflow can be combined and repurposed, allowing developers to leverage existing work in new scenarios.
+- [**Rapid Development:**](https://docs.nvidia.com/aiqtoolkit/latest/guides/create-customize-workflows.html) Start with a pre-built agent, tool, or workflow, and customize it to your needs.
+- [**Profiling:**](https://docs.nvidia.com/aiqtoolkit/latest/guides/profiler.html) Profile entire workflows down to the tool and agent level, track input/output tokens and timings, and identify bottlenecks.
+- [**Observability:**](https://docs.nvidia.com/aiqtoolkit/latest/guides/observe-workflow-with-phoenix.html) Monitor and debug your workflows with any OpenTelemetry-compatible observability tool.
+- [**Evaluation System:**](https://docs.nvidia.com/aiqtoolkit/latest/guides/evaluate.html) Validate and maintain accuracy of agentic workflows with built-in evaluation tools.
+- [**User Interface:**](https://docs.nvidia.com/aiqtoolkit/latest/guides/using-aiqtoolkit-ui-and-server.html) Use the AIQ Toolkit UI chat interface to interact with your agents, visualize output, and debug workflows.
+- [**MCP Compatibility**](https://docs.nvidia.com/aiqtoolkit/latest/components/mcp.html) Compatible with Model Context Protocol (MCP), allowing tools served by MCP Servers to be used as AIQ Toolkit functions.
 
-With AgentIQ, you can move quickly, experiment freely, and ensure reliability across all your agent-driven projects.
+With AIQ Toolkit, you can move quickly, experiment freely, and ensure reliability across all your agent-driven projects.
 
 ## Links
- * [Documentation](https://docs.nvidia.com/agentiq/latest/index.html): Explore the full documentation for AgentIQ.
- * [About AgentIQ](https://docs.nvidia.com/agentiq/latest/intro/why-agentiq.html): Learn more about the benefits of using AgentIQ.
+ * [Documentation](https://docs.nvidia.com/aiqtoolkit/latest/index.html): Explore the full documentation for AIQ Toolkit.
+ * [About AIQ Toolkit](https://docs.nvidia.com/aiqtoolkit/latest/intro/why-aiqtoolkit.html): Learn more about the benefits of using AIQ Toolkit.
 
 ## First time user?
- If this is your first time using AgentIQ, it is recommended to install the latest version from the [source repository](https://github.com/NVIDIA/AgentIQ?tab=readme-ov-file#get-started) on GitHub. This package is intended for users who are familiar with AgentIQ applications and need to add AgentIQ as a dependency to their project.
+ If this is your first time using AIQ Toolkit, it is recommended to install the latest version from the [source repository](https://github.com/NVIDIA/AIQToolkit?tab=readme-ov-file#get-started) on GitHub. This package is intended for users who are familiar with AIQ Toolkit applications and need to add AIQ Toolkit as a dependency to their project.
 
 ## Feedback
 
-We would love to hear from you! Please file an issue on [GitHub](https://github.com/NVIDIA/AgentIQ/issues) if you have any feedback or feature requests.
+We would love to hear from you! Please file an issue on [GitHub](https://github.com/NVIDIA/AIQToolkit/issues) if you have any feedback or feature requests.
 
 ## Acknowledgements
 
-We would like to thank the following open source projects that made AgentIQ possible:
+We would like to thank the following open source projects that made AIQ Toolkit possible:
 
 - [CrewAI](https://github.com/crewAIInc/crewAI)
 - [FastAPI](https://github.com/tiangolo/fastapi)

aiq/observability/async_otel_listener.py

@@ -16,6 +16,7 @@
 import logging
 import re
 from contextlib import asynccontextmanager
+from contextlib import contextmanager
 from typing import Any
 
 from openinference.semconv.trace import OpenInferenceSpanKindValues
@@ -30,6 +31,17 @@ from aiq.builder.context import AIQContextState
 from aiq.data_models.intermediate_step import IntermediateStep
 from aiq.data_models.intermediate_step import IntermediateStepState
 
+try:
+    from weave.trace.context import weave_client_context
+    from weave.trace.context.call_context import get_current_call
+    from weave.trace.context.call_context import set_call_stack
+    from weave.trace.weave_client import Call
+    WEAVE_AVAILABLE = True
+except ImportError:
+    WEAVE_AVAILABLE = False
+    # we simply don't do anything if weave is not available
+    pass
+
 logger = logging.getLogger(__name__)
 
 OPENINFERENCE_SPAN_KIND = SpanAttributes.OPENINFERENCE_SPAN_KIND
@@ -37,7 +49,7 @@ OPENINFERENCE_SPAN_KIND = SpanAttributes.OPENINFERENCE_SPAN_KIND
 
 def _ns_timestamp(seconds_float: float) -> int:
     """
-    Convert AgentIQ’s float `event_timestamp` (in seconds) into an integer number
+    Convert AIQ Toolkit’s float `event_timestamp` (in seconds) into an integer number
     of nanoseconds, as OpenTelemetry expects.
     """
     return int(seconds_float * 1e9)
@@ -45,14 +57,14 @@ def _ns_timestamp(seconds_float: float) -> int:
 
 class AsyncOtelSpanListener:
     """
-    A separate, async class that listens to the AgentIQ intermediate step
+    A separate, async class that listens to the AIQ Toolkit intermediate step
     event stream and creates proper Otel spans:
 
     - On FUNCTION_START => open a new top-level span
     - On any other intermediate step => open a child subspan (immediate open/close)
     - On FUNCTION_END => close the function’s top-level span
 
-    This runs fully independently from the normal AgentIQ workflow, so that
+    This runs fully independently from the normal AIQ Toolkit workflow, so that
     the workflow is not blocking or entangled by OTel calls.
     """
 
@@ -70,7 +82,7 @@ class AsyncOtelSpanListener:
         self._outstanding_spans: dict[str, Span] = {}
 
         # Stack of spans, for when we need to create a child span
-        self._span_stack: list[Span] = []
+        self._span_stack: dict[str, Span] = {}
 
         self._running = False
 
@@ -84,6 +96,17 @@ class AsyncOtelSpanListener:
 
         self._tracer = trace.get_tracer("aiq-async-otel-listener")
 
+        # Initialize Weave-specific components if available
+        self.gc = None
+        self._weave_calls = {}
+        if WEAVE_AVAILABLE:
+            try:
+                # Try to get the weave client, but don't fail if Weave isn't initialized
+                self.gc = weave_client_context.require_weave_client()
+            except Exception:
+                # Weave is not initialized, so we don't do anything
+                pass
+
     def _on_next(self, step: IntermediateStep) -> None:
         """
         The main logic that reacts to each IntermediateStep.
@@ -109,11 +132,11 @@ class AsyncOtelSpanListener:
 
             otel_listener = AsyncOtelSpanListener()
             async with otel_listener.start():
-                # run your AgentIQ workflow
+                # run your AIQ Toolkit workflow
                 ...
             # cleans up
 
-        This sets up the subscription to the AgentIQ event stream and starts the background loop.
+        This sets up the subscription to the AIQ Toolkit event stream and starts the background loop.
         """
         try:
             # Subscribe to the event stream
@@ -152,13 +175,19 @@ class AsyncOtelSpanListener:
 
         self._outstanding_spans.clear()
 
-        if self._span_stack:
+        if len(self._span_stack) > 0:
             logger.error(
                 "Not all spans were closed. Ensure all start events have a corresponding end event. Remaining: %s",
                 self._span_stack)
 
         self._span_stack.clear()
 
+        # Clean up any lingering Weave calls if Weave is available and initialized
+        if self.gc is not None and self._weave_calls:
+            for _, call in list(self._weave_calls.items()):
+                self.gc.finish_call(call, {"status": "incomplete"})
+            self._weave_calls.clear()
+
     def _serialize_payload(self, input_value: Any) -> tuple[str, bool]:
         """
         Serialize the input value to a string. Returns a tuple with the serialized value and a boolean indicating if the
@@ -175,7 +204,10 @@ class AsyncOtelSpanListener:
         parent_ctx = None
 
         if (len(self._span_stack) > 0):
-            parent_span = self._span_stack[-1]
+            parent_span = self._span_stack.get(step.function_ancestry.parent_id, None)
+            if parent_span is None:
+                logger.warning("No parent span found for step %s", step.UUID)
+                return
 
             parent_ctx = set_span_in_context(parent_span)
 
@@ -230,10 +262,14 @@ class AsyncOtelSpanListener:
                 sub_span.set_attribute(SpanAttributes.INPUT_VALUE, serialized_input)
                 sub_span.set_attribute(SpanAttributes.INPUT_MIME_TYPE, "application/json" if is_json else "text/plain")
 
-        self._span_stack.append(sub_span)
+        self._span_stack[step.UUID] = sub_span
 
         self._outstanding_spans[step.UUID] = sub_span
 
+        # Create corresponding Weave call if Weave is available and initialized
+        if self.gc is not None:
+            self._create_weave_call(step, sub_span)
+
     def _process_end_event(self, step: IntermediateStep):
 
         # Find the subspan that was created in the start event
@@ -243,7 +279,7 @@ class AsyncOtelSpanListener:
             logger.warning("No subspan found for step %s", step.UUID)
             return
 
-        self._span_stack.pop()
+        self._span_stack.pop(step.UUID, None)
 
         # Optionally add more attributes from usage_info or data
         usage_info = step.payload.usage_info
@@ -268,3 +304,114 @@ class AsyncOtelSpanListener:
 
         # End the subspan
         sub_span.end(end_time=end_ns)
+
+        # Finish corresponding Weave call if Weave is available and initialized
+        if self.gc is not None:
+            self._finish_weave_call(step, sub_span)
+
+    @contextmanager
+    def parent_call(self, trace_id: str, parent_call_id: str):
+        """Context manager to set a parent call context for Weave.
+        This allows connecting AIQ spans to existing traces from other frameworks.
+        """
+        dummy_call = Call(trace_id=trace_id, id=parent_call_id, _op_name="", project_id="", parent_id=None, inputs={})
+        with set_call_stack([dummy_call]):
+            yield
+
+    def _create_weave_call(self, step: IntermediateStep, span: Span) -> None:
+        """
+        Create a Weave call directly from the span and step data,
+        connecting to existing framework traces if available.
+        """
+        # Check for existing Weave trace/call
+        existing_call = get_current_call()
+
+        # Extract parent call if applicable
+        parent_call = None
+
+        # If we have an existing Weave call from another framework (e.g., LangChain),
+        # use it as the parent
+        if existing_call is not None:
+            parent_call = existing_call
+            logger.debug(f"Found existing Weave call: {existing_call.id} from trace: {existing_call.trace_id}")
+        # Otherwise, check our internal stack for parent relationships
+        elif len(self._weave_calls) > 0 and len(self._span_stack) > 1:
+            # Get the parent span using stack position (one level up)
+            parent_span_id = self._span_stack[-2].get_span_context().span_id
+            # Find the corresponding weave call for this parent span
+            for uuid, call in self._weave_calls.items():
+                if getattr(call, "span_id", None) == parent_span_id:
+                    parent_call = call
+                    break
+
+        # Generate a meaningful operation name based on event type
+        event_type = step.payload.event_type.split(".")[-1]
+        if step.payload.name:
+            op_name = f"aiq.{event_type}.{step.payload.name}"
+        else:
+            op_name = f"aiq.{event_type}"
+
+        # Create input dictionary
+        inputs = {}
+        if step.payload.data and step.payload.data.input is not None:
+            try:
+                # Add the input to the Weave call
+                inputs["input"] = step.payload.data.input
+            except Exception:
+                # If serialization fails, use string representation
+                inputs["input"] = str(step.payload.data.input)
+
+        # Create the Weave call
+        call = self.gc.create_call(
+            op_name,
+            inputs=inputs,
+            parent=parent_call,
+            attributes=span.attributes,
+            display_name=op_name,
+        )
+
+        # Store the call with step UUID as key
+        self._weave_calls[step.UUID] = call
+
+        # Store span ID for parent reference
+        setattr(call, "span_id", span.get_span_context().span_id)
+
+        return call
+
+    def _finish_weave_call(self, step: IntermediateStep, span: Span) -> None:
+        """
+        Finish a previously created Weave call
+        """
+        # Find the call for this step
+        call = self._weave_calls.pop(step.UUID, None)
+
+        if call is None:
+            logger.warning("No Weave call found for step %s", step.UUID)
+            return
+
+        # Create output dictionary
+        outputs = {}
+        if step.payload.data and step.payload.data.output is not None:
+            try:
+                # Add the output to the Weave call
+                outputs["output"] = step.payload.data.output
+            except Exception:
+                # If serialization fails, use string representation
+                outputs["output"] = str(step.payload.data.output)
+
+        # Add usage information if available
+        usage_info = step.payload.usage_info
+        if usage_info:
+            if usage_info.token_usage:
+                outputs["prompt_tokens"] = usage_info.token_usage.prompt_tokens
+                outputs["completion_tokens"] = usage_info.token_usage.completion_tokens
+                outputs["total_tokens"] = usage_info.token_usage.total_tokens
+
+            if usage_info.num_llm_calls:
+                outputs["num_llm_calls"] = usage_info.num_llm_calls
+
+            if usage_info.seconds_between_calls:
+                outputs["seconds_between_calls"] = usage_info.seconds_between_calls
+
+        # Finish the call with outputs
+        self.gc.finish_call(call, outputs)

aiq/profiler/callbacks/agno_callback_handler.py

@@ -44,7 +44,7 @@ class AgnoProfilerHandler(BaseProfilerCallback):
       - LLM Calls
 
     to collect usage statistics (tokens, inputs, outputs, time intervals, etc.)
-    and store them in AgentIQ's usage_stats queue for subsequent analysis.
+    and store them in AIQ Toolkit's usage_stats queue for subsequent analysis.
     """
 
     def __init__(self) -> None:
@@ -73,7 +73,7 @@ class AgnoProfilerHandler(BaseProfilerCallback):
 
         # Note: Agno doesn't have a class-based tool structure to patch directly.
         # Instead, it uses decorators to convert functions to tools.
-        # In AgentIQ, tool executions are captured at the execute_agno_tool level
+        # In AIQ Toolkit, tool executions are captured at the execute_agno_tool level
         # in packages/aiqtoolkit_agno/src/aiq/plugins/agno/tool_wrapper.py
 
         # To properly monitor Agno tool executions, we would need to either:

aiq/profiler/callbacks/langchain_callback_handler.py

@@ -50,7 +50,7 @@ class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):  # p
     completion_tokens: int = 0
     successful_requests: int = 0
     raise_error = True  # Override to raise error and run inline
-    run_inline = False
+    run_inline = True
 
     def __init__(self) -> None:
         super().__init__()

aiq/profiler/callbacks/llama_index_callback_handler.py

@@ -167,7 +167,7 @@ class LlamaIndexProfilerHandler(BaseCallbackHandler, BaseProfilerCallback):
                 except Exception as e:
                     logger.exception("Error getting model name: %s", e, exc_info=True)
 
-                # Append usage data to AgentIQ usage stats
+                # Append usage data to AIQ Toolkit usage stats
                 with self._lock:
                     stats = IntermediateStepPayload(
                         event_type=IntermediateStepType.LLM_END,

aiq/profiler/callbacks/semantic_kernel_callback_handler.py

@@ -55,7 +55,7 @@ class SemanticKernelProfilerHandler(BaseProfilerCallback):
     - Tool calls
 
     to collect usage statistics (tokens, inputs, outputs, time intervals, etc.)
-    and store them in AgentIQ's usage_stats queue for subsequent analysis.
+    and store them in AIQ Toolkit's usage_stats queue for subsequent analysis.
     """
 
     def __init__(self, workflow_llms: dict) -> None:

aiq/profiler/decorators/function_tracking.py

@@ -61,7 +61,7 @@ def push_intermediate_step(step_manager: IntermediateStepManager,
                            kwargs: Any = None,
                            output: Any = None,
                            metadata: dict[str, Any] | None = None) -> None:
-    """Push an intermediate step to the AgentIQ Event Stream."""
+    """Push an intermediate step to the AIQ Toolkit Event Stream."""
 
     payload = IntermediateStepPayload(UUID=identifier,
                                       event_type=event_type,

aiq/profiler/profile_runner.py

@@ -48,7 +48,7 @@ class InferenceOptimizationHolder(BaseModel):
 
 class ProfilerRunner:
     """
-    A utility to run a series of prompts through an AgentIQ workflow for profiling:
+    A utility to run a series of prompts through an AIQ Toolkit workflow for profiling:
 
     - can load prompts from a file
     - or generate them via an LLM