aiqtoolkit 1.2.0a20250707__py3-none-any.whl → 1.2.0a20250731__py3-none-any.whl

aiq/cli/type_registry.py

@@ -30,6 +30,7 @@ from pydantic import Tag
 from pydantic import computed_field
 from pydantic import field_validator
 
+from aiq.authentication.interfaces import AuthProviderBase
 from aiq.builder.builder import Builder
 from aiq.builder.builder import EvalBuilder
 from aiq.builder.embedder import EmbedderProviderInfo
@@ -40,6 +41,8 @@ from aiq.builder.function_base import FunctionBase
 from aiq.builder.function_info import FunctionInfo
 from aiq.builder.llm import LLMProviderInfo
 from aiq.builder.retriever import RetrieverProviderInfo
+from aiq.data_models.authentication import AuthProviderBaseConfig
+from aiq.data_models.authentication import AuthProviderBaseConfigT
 from aiq.data_models.common import TypedBaseModelT
 from aiq.data_models.component import AIQComponentEnum
 from aiq.data_models.config import AIQConfig
@@ -52,66 +55,69 @@ from aiq.data_models.front_end import FrontEndBaseConfig
 from aiq.data_models.front_end import FrontEndConfigT
 from aiq.data_models.function import FunctionBaseConfig
 from aiq.data_models.function import FunctionConfigT
+from aiq.data_models.its_strategy import ITSStrategyBaseConfig
+from aiq.data_models.its_strategy import ITSStrategyBaseConfigT
 from aiq.data_models.llm import LLMBaseConfig
 from aiq.data_models.llm import LLMBaseConfigT
 from aiq.data_models.logging import LoggingBaseConfig
 from aiq.data_models.logging import LoggingMethodConfigT
 from aiq.data_models.memory import MemoryBaseConfig
 from aiq.data_models.memory import MemoryBaseConfigT
+from aiq.data_models.object_store import ObjectStoreBaseConfig
+from aiq.data_models.object_store import ObjectStoreBaseConfigT
 from aiq.data_models.registry_handler import RegistryHandlerBaseConfig
 from aiq.data_models.registry_handler import RegistryHandlerBaseConfigT
 from aiq.data_models.retriever import RetrieverBaseConfig
 from aiq.data_models.retriever import RetrieverBaseConfigT
 from aiq.data_models.telemetry_exporter import TelemetryExporterBaseConfig
 from aiq.data_models.telemetry_exporter import TelemetryExporterConfigT
+from aiq.experimental.inference_time_scaling.models.strategy_base import StrategyBase
 from aiq.memory.interfaces import MemoryEditor
+from aiq.object_store.interfaces import ObjectStore
+from aiq.observability.exporter.base_exporter import BaseExporter
 from aiq.registry_handlers.registry_handler_base import AbstractRegistryHandler
-from aiq.utils.optional_imports import TelemetryOptionalImportError
-from aiq.utils.optional_imports import try_import_opentelemetry
-
-# Try to import OpenTelemetry modules
-# If the dependencies are not installed, use a dummy span exporter here
-try:
-    opentelemetry = try_import_opentelemetry()
-    from opentelemetry.sdk.trace.export import SpanExporter
-except TelemetryOptionalImportError:
-    from aiq.utils.optional_imports import DummySpanExporter  # pylint: disable=ungrouped-imports
-    SpanExporter = DummySpanExporter
 
 logger = logging.getLogger(__name__)
 
+AuthProviderBuildCallableT = Callable[[AuthProviderBaseConfigT, Builder], AsyncIterator[AuthProviderBase]]
+EmbedderClientBuildCallableT = Callable[[EmbedderBaseConfigT, Builder], AsyncIterator[typing.Any]]
+EmbedderProviderBuildCallableT = Callable[[EmbedderBaseConfigT, Builder], AsyncIterator[EmbedderProviderInfo]]
+EvaluatorBuildCallableT = Callable[[EvaluatorBaseConfigT, EvalBuilder], AsyncIterator[EvaluatorInfo]]
 FrontEndBuildCallableT = Callable[[FrontEndConfigT, AIQConfig], AsyncIterator[FrontEndBase]]
-TelemetryExporterBuildCallableT = Callable[[TelemetryExporterConfigT, Builder], AsyncIterator[SpanExporter]]
-LoggingMethodBuildCallableT = Callable[[LoggingMethodConfigT, Builder], AsyncIterator[Handler]]
 FunctionBuildCallableT = Callable[[FunctionConfigT, Builder], AsyncIterator[FunctionInfo | Callable | FunctionBase]]
-LLMProviderBuildCallableT = Callable[[LLMBaseConfigT, Builder], AsyncIterator[LLMProviderInfo]]
+ITSStrategyBuildCallableT = Callable[[ITSStrategyBaseConfigT, Builder], AsyncIterator[StrategyBase]]
 LLMClientBuildCallableT = Callable[[LLMBaseConfigT, Builder], AsyncIterator[typing.Any]]
-EmbedderProviderBuildCallableT = Callable[[EmbedderBaseConfigT, Builder], AsyncIterator[EmbedderProviderInfo]]
-EmbedderClientBuildCallableT = Callable[[EmbedderBaseConfigT, Builder], AsyncIterator[typing.Any]]
-EvaluatorBuildCallableT = Callable[[EvaluatorBaseConfigT, EvalBuilder], AsyncIterator[EvaluatorInfo]]
+LLMProviderBuildCallableT = Callable[[LLMBaseConfigT, Builder], AsyncIterator[LLMProviderInfo]]
+LoggingMethodBuildCallableT = Callable[[LoggingMethodConfigT, Builder], AsyncIterator[Handler]]
 MemoryBuildCallableT = Callable[[MemoryBaseConfigT, Builder], AsyncIterator[MemoryEditor]]
-RetrieverProviderBuildCallableT = Callable[[RetrieverBaseConfigT, Builder], AsyncIterator[RetrieverProviderInfo]]
-RetrieverClientBuildCallableT = Callable[[RetrieverBaseConfigT, Builder], AsyncIterator[typing.Any]]
+ObjectStoreBuildCallableT = Callable[[ObjectStoreBaseConfigT, Builder], AsyncIterator[ObjectStore]]
 RegistryHandlerBuildCallableT = Callable[[RegistryHandlerBaseConfigT], AsyncIterator[AbstractRegistryHandler]]
+RetrieverClientBuildCallableT = Callable[[RetrieverBaseConfigT, Builder], AsyncIterator[typing.Any]]
+RetrieverProviderBuildCallableT = Callable[[RetrieverBaseConfigT, Builder], AsyncIterator[RetrieverProviderInfo]]
+TelemetryExporterBuildCallableT = Callable[[TelemetryExporterConfigT, Builder], AsyncIterator[BaseExporter]]
 ToolWrapperBuildCallableT = Callable[[str, Function, Builder], typing.Any]
 
-TeleExporterRegisteredCallableT = Callable[[TelemetryExporterConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
-LoggingMethodRegisteredCallableT = Callable[[LoggingMethodConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
+AuthProviderRegisteredCallableT = Callable[[AuthProviderBaseConfigT, Builder],
+                                           AbstractAsyncContextManager[AuthProviderBase]]
+EmbedderClientRegisteredCallableT = Callable[[EmbedderBaseConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
+EmbedderProviderRegisteredCallableT = Callable[[EmbedderBaseConfigT, Builder],
+                                               AbstractAsyncContextManager[EmbedderProviderInfo]]
+EvaluatorRegisteredCallableT = Callable[[EvaluatorBaseConfigT, EvalBuilder], AbstractAsyncContextManager[EvaluatorInfo]]
 FrontEndRegisteredCallableT = Callable[[FrontEndConfigT, AIQConfig], AbstractAsyncContextManager[FrontEndBase]]
 FunctionRegisteredCallableT = Callable[[FunctionConfigT, Builder],
                                        AbstractAsyncContextManager[FunctionInfo | Callable | FunctionBase]]
-LLMProviderRegisteredCallableT = Callable[[LLMBaseConfigT, Builder], AbstractAsyncContextManager[LLMProviderInfo]]
+ITSStrategyRegisterCallableT = Callable[[ITSStrategyBaseConfigT, Builder], AbstractAsyncContextManager[StrategyBase]]
 LLMClientRegisteredCallableT = Callable[[LLMBaseConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
-EmbedderProviderRegisteredCallableT = Callable[[EmbedderBaseConfigT, Builder],
-                                               AbstractAsyncContextManager[EmbedderProviderInfo]]
-EmbedderClientRegisteredCallableT = Callable[[EmbedderBaseConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
-EvaluatorRegisteredCallableT = Callable[[EvaluatorBaseConfigT, EvalBuilder], AbstractAsyncContextManager[EvaluatorInfo]]
+LLMProviderRegisteredCallableT = Callable[[LLMBaseConfigT, Builder], AbstractAsyncContextManager[LLMProviderInfo]]
+LoggingMethodRegisteredCallableT = Callable[[LoggingMethodConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
 MemoryRegisteredCallableT = Callable[[MemoryBaseConfigT, Builder], AbstractAsyncContextManager[MemoryEditor]]
-RetrieverProviderRegisteredCallableT = Callable[[RetrieverBaseConfigT, Builder],
-                                                AbstractAsyncContextManager[RetrieverProviderInfo]]
-RetrieverClientRegisteredCallableT = Callable[[RetrieverBaseConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
+ObjectStoreRegisteredCallableT = Callable[[ObjectStoreBaseConfigT, Builder], AbstractAsyncContextManager[ObjectStore]]
 RegistryHandlerRegisteredCallableT = Callable[[RegistryHandlerBaseConfigT],
                                               AbstractAsyncContextManager[AbstractRegistryHandler]]
+RetrieverClientRegisteredCallableT = Callable[[RetrieverBaseConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
+RetrieverProviderRegisteredCallableT = Callable[[RetrieverBaseConfigT, Builder],
+                                                AbstractAsyncContextManager[RetrieverProviderInfo]]
+TeleExporterRegisteredCallableT = Callable[[TelemetryExporterConfigT, Builder], AbstractAsyncContextManager[typing.Any]]
 
 
 class RegisteredInfo(BaseModel, typing.Generic[TypedBaseModelT]):
@@ -181,6 +187,14 @@ class RegisteredLLMProviderInfo(RegisteredInfo[LLMBaseConfig]):
     build_fn: LLMProviderRegisteredCallableT = Field(repr=False)
 
 
+class RegisteredAuthProviderInfo(RegisteredInfo[AuthProviderBaseConfig]):
+    """
+    Represents a registered Authentication provider. Authentication providers facilitate the authentication process.
+    """
+
+    build_fn: AuthProviderRegisteredCallableT = Field(repr=False)
+
+
 class RegisteredLLMClientInfo(RegisteredInfo[LLMBaseConfig]):
     """
     Represents a registered LLM client. LLM Clients are the clients that interact with the LLM providers and are
@@ -226,6 +240,22 @@ class RegisteredMemoryInfo(RegisteredInfo[MemoryBaseConfig]):
     build_fn: MemoryRegisteredCallableT = Field(repr=False)
 
 
+class RegisteredObjectStoreInfo(RegisteredInfo[ObjectStoreBaseConfig]):
+    """
+    Represents a registered Object Store object which adheres to the object store interface.
+    """
+
+    build_fn: ObjectStoreRegisteredCallableT = Field(repr=False)
+
+
+class RegisteredITSStrategyInfo(RegisteredInfo[ITSStrategyBaseConfig]):
+    """
+    Represents a registered Inference Time Scaling (ITS) strategy.
+    """
+
+    build_fn: ITSStrategyRegisterCallableT = Field(repr=False)
+
+
 class RegisteredToolWrapper(BaseModel):
     """
     Represents a registered tool wrapper. Tool wrappers are used to wrap the functions in a particular LLM framework.
@@ -288,6 +318,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         self._llm_client_provider_to_framework: dict[type[LLMBaseConfig], dict[str, RegisteredLLMClientInfo]] = {}
         self._llm_client_framework_to_provider: dict[str, dict[type[LLMBaseConfig], RegisteredLLMClientInfo]] = {}
 
+        # Authentication
+        self._registered_auth_provider_infos: dict[type[AuthProviderBaseConfig], RegisteredAuthProviderInfo] = {}
+
         # Embedders
         self._registered_embedder_provider_infos: dict[type[EmbedderBaseConfig], RegisteredEmbedderProviderInfo] = {}
         self._embedder_client_provider_to_framework: dict[type[EmbedderBaseConfig],
@@ -302,6 +335,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         # Memory
         self._registered_memory_infos: dict[type[MemoryBaseConfig], RegisteredMemoryInfo] = {}
 
+        # Object Stores
+        self._registered_object_store_infos: dict[type[ObjectStoreBaseConfig], RegisteredObjectStoreInfo] = {}
+
         # Retrievers
         self._registered_retriever_provider_infos: dict[type[RetrieverBaseConfig], RegisteredRetrieverProviderInfo] = {}
         self._retriever_client_provider_to_framework: dict[type[RetrieverBaseConfig],
@@ -317,6 +353,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         # Tool Wrappers
         self._registered_tool_wrappers: dict[str, RegisteredToolWrapper] = {}
 
+        # ITS Strategies
+        self._registered_its_strategies: dict[type[ITSStrategyBaseConfig], RegisteredITSStrategyInfo] = {}
+
         # Packages
         self._registered_packages: dict[str, RegisteredPackage] = {}
 
@@ -458,9 +497,29 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
                            f"Registered configs: {set(self._registered_llm_provider_infos.keys())}") from err
 
     def get_registered_llm_providers(self) -> list[RegisteredInfo[LLMBaseConfig]]:
-
         return list(self._registered_llm_provider_infos.values())
 
+    def register_auth_provider(self, info: RegisteredAuthProviderInfo):
+
+        if (info.config_type in self._registered_auth_provider_infos):
+            raise ValueError(
+                f"An Authentication Provider with the same config type `{info.config_type}` has already been "
+                "registered.")
+
+        self._registered_auth_provider_infos[info.config_type] = info
+
+        self._registration_changed()
+
+    def get_auth_provider(self, config_type: type[AuthProviderBaseConfig]) -> RegisteredAuthProviderInfo:
+        try:
+            return self._registered_auth_provider_infos[config_type]
+        except KeyError as err:
+            raise KeyError(f"Could not find a registered Authentication Provider for config `{config_type}`. "
+                           f"Registered configs: {set(self._registered_auth_provider_infos.keys())}") from err
+
+    def get_registered_auth_providers(self) -> list[RegisteredInfo[AuthProviderBaseConfig]]:
+        return list(self._registered_auth_provider_infos.values())
+
     def register_llm_client(self, info: RegisteredLLMClientInfo):
 
         if (info.config_type in self._llm_client_provider_to_framework
@@ -580,6 +639,28 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
 
         return list(self._registered_memory_infos.values())
 
+    def register_object_store(self, info: RegisteredObjectStoreInfo):
+
+        if (info.config_type in self._registered_object_store_infos):
+            raise ValueError(f"An Object Store with the same config type `{info.config_type}` has already been "
+                             "registered.")
+
+        self._registered_object_store_infos[info.config_type] = info
+
+        self._registration_changed()
+
+    def get_object_store(self, config_type: type[ObjectStoreBaseConfig]) -> RegisteredObjectStoreInfo:
+
+        try:
+            return self._registered_object_store_infos[config_type]
+        except KeyError as err:
+            raise KeyError(f"Could not find a registered Object Store for config `{config_type}`. "
+                           f"Registered configs: {set(self._registered_object_store_infos.keys())}") from err
+
+    def get_registered_object_stores(self) -> list[RegisteredInfo[ObjectStoreBaseConfig]]:
+
+        return list(self._registered_object_store_infos.values())
+
     def register_retriever_provider(self, info: RegisteredRetrieverProviderInfo):
 
         if (info.config_type in self._registered_retriever_provider_infos):
@@ -647,6 +728,25 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
             raise KeyError(f"Could not find a registered tool wrapper for LLM framework `{llm_framework}`. "
                            f"Registered LLM frameworks: {set(self._registered_tool_wrappers.keys())}") from err
 
+    def register_its_strategy(self, info: RegisteredITSStrategyInfo):
+        if (info.config_type in self._registered_its_strategies):
+            raise ValueError(
+                f"An ITS strategy with the same config type `{info.config_type}` has already been registered.")
+
+        self._registered_its_strategies[info.config_type] = info
+
+        self._registration_changed()
+
+    def get_its_strategy(self, config_type: type[ITSStrategyBaseConfig]) -> RegisteredITSStrategyInfo:
+        try:
+            strategy = self._registered_its_strategies[config_type]
+        except Exception as e:
+            raise KeyError(f"Could not find a registered ITS strategy for config `{config_type}`. ") from e
+        return strategy
+
+    def get_registered_its_strategies(self) -> list[RegisteredInfo[ITSStrategyBaseConfig]]:
+        return list(self._registered_its_strategies.values())
+
     def register_registry_handler(self, info: RegisteredRegistryHandlerInfo):
 
         if (info.config_type in self._registered_memory_infos):
@@ -684,6 +784,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         if component_type == AIQComponentEnum.FRONT_END:
             return self._registered_front_end_infos
 
+        if component_type == AIQComponentEnum.AUTHENTICATION_PROVIDER:
+            return self._registered_auth_provider_infos
+
         if component_type == AIQComponentEnum.FUNCTION:
             return self._registered_functions
 
@@ -726,6 +829,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         if component_type == AIQComponentEnum.MEMORY:
             return self._registered_memory_infos
 
+        if component_type == AIQComponentEnum.OBJECT_STORE:
+            return self._registered_object_store_infos
+
         if component_type == AIQComponentEnum.REGISTRY_HANDLER:
             return self._registered_registry_handler_infos
 
@@ -738,6 +844,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         if component_type == AIQComponentEnum.PACKAGE:
             return self._registered_packages
 
+        if component_type == AIQComponentEnum.ITS_STRATEGY:
+            return self._registered_its_strategies
+
         raise ValueError(f"Supplied an unsupported component type {component_type}")
 
     def get_registered_types_by_component_type(  # pylint: disable=R0911
@@ -787,6 +896,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         if component_type == AIQComponentEnum.PACKAGE:
             return list(self._registered_packages)
 
+        if component_type == AIQComponentEnum.ITS_STRATEGY:
+            return [i.static_type() for i in self._registered_its_strategies]
+
         raise ValueError(f"Supplied an unsupported component type {component_type}")
 
     def get_registered_channel_info_by_channel_type(self, channel_type: str) -> RegisteredRegistryHandlerInfo:
@@ -818,6 +930,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
 
     def compute_annotation(self, cls: type[TypedBaseModelT]):
 
+        if issubclass(cls, AuthProviderBaseConfig):
+            return self._do_compute_annotation(cls, self.get_registered_auth_providers())
+
         if issubclass(cls, EmbedderBaseConfig):
             return self._do_compute_annotation(cls, self.get_registered_embedder_providers())
 
@@ -836,6 +951,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         if issubclass(cls, MemoryBaseConfig):
             return self._do_compute_annotation(cls, self.get_registered_memorys())
 
+        if issubclass(cls, ObjectStoreBaseConfig):
+            return self._do_compute_annotation(cls, self.get_registered_object_stores())
+
         if issubclass(cls, RegistryHandlerBaseConfig):
             return self._do_compute_annotation(cls, self.get_registered_registry_handlers())
 
@@ -848,6 +966,9 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
         if issubclass(cls, LoggingBaseConfig):
             return self._do_compute_annotation(cls, self.get_registered_logging_method())
 
+        if issubclass(cls, ITSStrategyBaseConfig):
+            return self._do_compute_annotation(cls, self.get_registered_its_strategies())
+
         raise ValueError(f"Supplied an unsupported component type {cls}")
 
 

aiq/data_models/api_server.py

@@ -26,6 +26,7 @@ from pydantic import Discriminator
 from pydantic import Field
 from pydantic import HttpUrl
 from pydantic import conlist
+from pydantic import field_serializer
 from pydantic import field_validator
 from pydantic_core.core_schema import ValidationInfo
 
@@ -111,16 +112,47 @@ class Message(BaseModel):
 class AIQChatRequest(BaseModel):
     """
     AIQChatRequest is a data model that represents a request to the AIQ Toolkit chat API.
+    Fully compatible with OpenAI Chat Completions API specification.
     """
 
-    # Allow extra fields in the model_config to support derived models
-    model_config = ConfigDict(extra="allow")
-
+    # Required fields
     messages: typing.Annotated[list[Message], conlist(Message, min_length=1)]
-    model: str | None = None
-    temperature: float | None = None
-    max_tokens: int | None = None
-    top_p: float | None = None
+
+    # Optional fields (OpenAI Chat Completions API compatible)
+    model: str | None = Field(default=None, description="name of the model to use")
+    frequency_penalty: float | None = Field(default=0.0,
+                                            description="Penalty for new tokens based on frequency in text")
+    logit_bias: dict[str, float] | None = Field(default=None,
+                                                description="Modify likelihood of specified tokens appearing")
+    logprobs: bool | None = Field(default=None, description="Whether to return log probabilities")
+    top_logprobs: int | None = Field(default=None, description="Number of most likely tokens to return")
+    max_tokens: int | None = Field(default=None, description="Maximum number of tokens to generate")
+    n: int | None = Field(default=1, description="Number of chat completion choices to generate")
+    presence_penalty: float | None = Field(default=0.0, description="Penalty for new tokens based on presence in text")
+    response_format: dict[str, typing.Any] | None = Field(default=None, description="Response format specification")
+    seed: int | None = Field(default=None, description="Random seed for deterministic sampling")
+    service_tier: typing.Literal["auto", "default"] | None = Field(default=None,
+                                                                   description="Service tier for the request")
+    stream: bool | None = Field(default=False, description="Whether to stream partial message deltas")
+    stream_options: dict[str, typing.Any] | None = Field(default=None, description="Options for streaming")
+    temperature: float | None = Field(default=1.0, description="Sampling temperature between 0 and 2")
+    top_p: float | None = Field(default=None, description="Nucleus sampling parameter")
+    tools: list[dict[str, typing.Any]] | None = Field(default=None, description="List of tools the model may call")
+    tool_choice: str | dict[str, typing.Any] | None = Field(default=None, description="Controls which tool is called")
+    parallel_tool_calls: bool | None = Field(default=True, description="Whether to enable parallel function calling")
+    user: str | None = Field(default=None, description="Unique identifier representing end-user")
+
+    model_config = ConfigDict(extra="allow",
+                              json_schema_extra={
+                                  "example": {
+                                      "model": "nvidia/nemotron",
+                                      "messages": [{
+                                          "role": "user", "content": "who are you?"
+                                      }],
+                                      "temperature": 0.7,
+                                      "stream": False
+                                  }
+                              })
 
     @staticmethod
     def from_string(data: str,
@@ -156,10 +188,17 @@ class AIQChoiceMessage(BaseModel):
     role: str | None = None
 
 
+class AIQChoiceDelta(BaseModel):
+    """Delta object for streaming responses (OpenAI-compatible)"""
+    content: str | None = None
+    role: str | None = None
+
+
 class AIQChoice(BaseModel):
     model_config = ConfigDict(extra="allow")
 
-    message: AIQChoiceMessage
+    message: AIQChoiceMessage | None = None
+    delta: AIQChoiceDelta | None = None
     finish_reason: typing.Literal['stop', 'length', 'tool_calls', 'content_filter', 'function_call'] | None = None
     index: int
     # logprobs: AIQChoiceLogprobs | None = None
@@ -197,16 +236,24 @@ class AIQResponseBaseModelIntermediate(BaseModel, AIQResponseSerializable):
 class AIQChatResponse(AIQResponseBaseModelOutput):
     """
     AIQChatResponse is a data model that represents a response from the AIQ Toolkit chat API.
+    Fully compatible with OpenAI Chat Completions API specification.
     """
 
     # Allow extra fields in the model_config to support derived models
     model_config = ConfigDict(extra="allow")
     id: str
-    object: str
+    object: str = "chat.completion"
     model: str = ""
     created: datetime.datetime
     choices: list[AIQChoice]
     usage: AIQUsage | None = None
+    system_fingerprint: str | None = None
+    service_tier: typing.Literal["scale", "default"] | None = None
+
+    @field_serializer('created')
+    def serialize_created(self, created: datetime.datetime) -> int:
+        """Serialize datetime to Unix timestamp for OpenAI compatibility"""
+        return int(created.timestamp())
 
     @staticmethod
     def from_string(data: str,
@@ -238,6 +285,7 @@ class AIQChatResponse(AIQResponseBaseModelOutput):
 class AIQChatResponseChunk(AIQResponseBaseModelOutput):
     """
     AIQChatResponseChunk is a data model that represents a response chunk from the AIQ Toolkit chat streaming API.
+    Fully compatible with OpenAI Chat Completions API specification.
     """
 
     # Allow extra fields in the model_config to support derived models
@@ -248,6 +296,14 @@ class AIQChatResponseChunk(AIQResponseBaseModelOutput):
     created: datetime.datetime
     model: str = ""
     object: str = "chat.completion.chunk"
+    system_fingerprint: str | None = None
+    service_tier: typing.Literal["scale", "default"] | None = None
+    usage: AIQUsage | None = None
+
+    @field_serializer('created')
+    def serialize_created(self, created: datetime.datetime) -> int:
+        """Serialize datetime to Unix timestamp for OpenAI compatibility"""
+        return int(created.timestamp())
 
     @staticmethod
     def from_string(data: str,
@@ -273,6 +329,36 @@ class AIQChatResponseChunk(AIQResponseBaseModelOutput):
             model=model,
             object=object_)
 
+    @staticmethod
+    def create_streaming_chunk(content: str,
+                               *,
+                               id_: str | None = None,
+                               created: datetime.datetime | None = None,
+                               model: str | None = None,
+                               role: str | None = None,
+                               finish_reason: str | None = None,
+                               usage: AIQUsage | None = None,
+                               system_fingerprint: str | None = None) -> "AIQChatResponseChunk":
+        """Create an OpenAI-compatible streaming chunk"""
+        if id_ is None:
+            id_ = str(uuid.uuid4())
+        if created is None:
+            created = datetime.datetime.now(datetime.timezone.utc)
+        if model is None:
+            model = ""
+
+        delta = AIQChoiceDelta(content=content,
+                               role=role) if content is not None or role is not None else AIQChoiceDelta()
+
+        return AIQChatResponseChunk(
+            id=id_,
+            choices=[AIQChoice(index=0, message=None, delta=delta, finish_reason=finish_reason)],
+            created=created,
+            model=model,
+            object="chat.completion.chunk",
+            usage=usage,
+            system_fingerprint=system_fingerprint)
+
 
 class AIQResponseIntermediateStep(AIQResponseBaseModelIntermediate):
     """
@@ -563,7 +649,7 @@ GlobalTypeConverter.register_converter(_string_to_aiq_chat_response)
 
 
 def _chat_response_to_chat_response_chunk(data: AIQChatResponse) -> AIQChatResponseChunk:
-
+    # Preserve original message structure for backward compatibility
     return AIQChatResponseChunk(id=data.id, choices=data.choices, created=data.created, model=data.model)
 
 
@@ -572,7 +658,13 @@ GlobalTypeConverter.register_converter(_chat_response_to_chat_response_chunk)
 
 # ======== AIQChatResponseChunk Converters ========
 def _aiq_chat_response_chunk_to_string(data: AIQChatResponseChunk) -> str:
-    return data.choices[0].message.content or ""
+    if data.choices and len(data.choices) > 0:
+        choice = data.choices[0]
+        if choice.delta and choice.delta.content:
+            return choice.delta.content
+        if choice.message and choice.message.content:
+            return choice.message.content
+    return ""
 
 
 GlobalTypeConverter.register_converter(_aiq_chat_response_chunk_to_string)
@@ -586,3 +678,17 @@ def _string_to_aiq_chat_response_chunk(data: str) -> AIQChatResponseChunk:
 
 
 GlobalTypeConverter.register_converter(_string_to_aiq_chat_response_chunk)
+
+
+# ======== AINodeMessageChunk Converters ========
+def _ai_message_chunk_to_aiq_chat_response_chunk(data) -> AIQChatResponseChunk:
+    '''Converts LangChain AINodeMessageChunk to AIQChatResponseChunk'''
+    content = ""
+    if hasattr(data, 'content') and data.content is not None:
+        content = str(data.content)
+    elif hasattr(data, 'text') and data.text is not None:
+        content = str(data.text)
+    elif hasattr(data, 'message') and data.message is not None:
+        content = str(data.message)
+
+    return AIQChatResponseChunk.create_streaming_chunk(content=content, role="assistant", finish_reason=None)