lite-agent 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

lite_agent/types/messages.py

@@ -1,68 +1,343 @@
 from collections.abc import Sequence
-from typing import Literal
+from datetime import datetime, timezone
+from typing import Any, Literal, NotRequired, TypedDict
 
-from pydantic import BaseModel
-from rich import Any
+from pydantic import BaseModel, Field, model_validator
 
-from .tool_calls import ToolCall
 
+# Base metadata type
+class MessageMeta(BaseModel):
+    """Base metadata for all message types"""
 
-class AssistantMessage(BaseModel):
-    id: str
-    index: int
-    role: Literal["assistant"] = "assistant"
-    content: str = ""
-    tool_calls: list[ToolCall] | None = None
+    sent_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 
 
-class Message(BaseModel):
-    role: str
-    content: str
+class BasicMessageMeta(MessageMeta):
+    """Basic metadata for user messages and function calls"""
 
+    execution_time_ms: int | None = None
 
-class UserMessageContentItemText(BaseModel):
-    type: Literal["text"]
-    text: str
 
+class LLMResponseMeta(MessageMeta):
+    """Metadata for LLM responses, includes performance metrics"""
 
-class UserMessageContentItemImageURLImageURL(BaseModel):
-    url: str
+    latency_ms: int | None = None
+    output_time_ms: int | None = None
+    input_tokens: int | None = None
+    output_tokens: int | None = None
 
 
-class UserMessageContentItemImageURL(BaseModel):
-    type: Literal["image_url"]
-    image_url: UserMessageContentItemImageURLImageURL
+# New unified metadata types
+
+
+class MessageUsage(BaseModel):
+    """Token usage statistics for messages"""
+
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+    total_tokens: int | None = None
 
 
-class AgentUserMessage(BaseModel):
+class AssistantMessageMeta(MessageMeta):
+    """Enhanced metadata for assistant messages"""
+
+    model: str | None = None
+    usage: MessageUsage | None = None
+    total_time_ms: int | None = None
+    latency_ms: int | None = None
+    output_time_ms: int | None = None
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+
+
+class ResponseInputImageDict(TypedDict):
+    detail: NotRequired[Literal["low", "high", "auto"]]
+    type: Literal["input_image"]
+    file_id: str | None
+    image_url: str | None
+
+
+class ResponseInputTextDict(TypedDict):
+    text: str
+    type: Literal["input_text"]
+
+
+# TypedDict definitions for better type hints
+class UserMessageDict(TypedDict):
     role: Literal["user"]
-    content: str | Sequence[UserMessageContentItemText | UserMessageContentItemImageURL]
+    content: str | Sequence[ResponseInputTextDict | ResponseInputImageDict]
 
 
-class AgentAssistantMessage(BaseModel):
+class AssistantMessageDict(TypedDict):
     role: Literal["assistant"]
     content: str
 
 
-class AgentSystemMessage(BaseModel):
+class SystemMessageDict(TypedDict):
     role: Literal["system"]
     content: str
 
 
-class AgentFunctionToolCallMessage(BaseModel):
-    arguments: str
+class FunctionCallDict(TypedDict):
     type: Literal["function_call"]
-    function_call_id: str
+    call_id: str
     name: str
+    arguments: str
     content: str
 
 
-class AgentFunctionCallOutput(BaseModel):
+class FunctionCallOutputDict(TypedDict):
+    type: Literal["function_call_output"]
     call_id: str
     output: str
-    type: Literal["function_call_output"]
 
 
-RunnerMessage = AgentUserMessage | AgentAssistantMessage | AgentSystemMessage | AgentFunctionToolCallMessage | AgentFunctionCallOutput
-AgentMessage = RunnerMessage | AgentSystemMessage
-RunnerMessages = Sequence[RunnerMessage | dict[str, Any]]
+# Union type for all supported message dictionary formats
+MessageDict = UserMessageDict | AssistantMessageDict | SystemMessageDict | FunctionCallDict | FunctionCallOutputDict
+
+
+# New structured message content types
+class UserTextContent(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+
+
+class UserImageContent(BaseModel):
+    type: Literal["image"] = "image"
+    image_url: str | None = None
+    file_id: str | None = None
+    detail: Literal["low", "high", "auto"] = "auto"
+
+    @model_validator(mode="after")
+    def validate_image_source(self) -> "UserImageContent":
+        if not self.file_id and not self.image_url:
+            msg = "UserImageContent must have either file_id or image_url"
+            raise ValueError(msg)
+        return self
+
+
+class UserFileContent(BaseModel):
+    type: Literal["file"] = "file"
+    file_id: str
+    file_name: str | None = None
+
+
+UserMessageContent = UserTextContent | UserImageContent | UserFileContent
+
+
+class AssistantTextContent(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+
+
+class AssistantToolCall(BaseModel):
+    type: Literal["tool_call"] = "tool_call"
+    call_id: str
+    name: str
+    arguments: dict[str, Any] | str
+
+
+class AssistantToolCallResult(BaseModel):
+    type: Literal["tool_call_result"] = "tool_call_result"
+    call_id: str
+    output: str
+    execution_time_ms: int | None = None
+
+
+AssistantMessageContent = AssistantTextContent | AssistantToolCall | AssistantToolCallResult
+
+
+# New structured message types
+class NewUserMessage(BaseModel):
+    """User message with structured content support"""
+
+    role: Literal["user"] = "user"
+    content: list[UserMessageContent]
+    meta: MessageMeta = Field(default_factory=MessageMeta)
+
+
+class NewSystemMessage(BaseModel):
+    """System message"""
+
+    role: Literal["system"] = "system"
+    content: str
+    meta: MessageMeta = Field(default_factory=MessageMeta)
+
+
+class NewAssistantMessage(BaseModel):
+    """Assistant message with structured content and metadata"""
+
+    role: Literal["assistant"] = "assistant"
+    content: list[AssistantMessageContent]
+    meta: AssistantMessageMeta = Field(default_factory=AssistantMessageMeta)
+
+
+# Union type for new structured messages
+NewMessage = NewUserMessage | NewSystemMessage | NewAssistantMessage
+NewMessages = Sequence[NewMessage]
+
+
+# Response API format input types
+class ResponseInputText(BaseModel):
+    type: Literal["input_text"] = "input_text"
+    text: str
+
+
+class ResponseInputImage(BaseModel):
+    detail: Literal["low", "high", "auto"] = "auto"
+    type: Literal["input_image"] = "input_image"
+    file_id: str | None = None
+    image_url: str | None = None
+
+    @model_validator(mode="after")
+    def validate_image_source(self) -> "ResponseInputImage":
+        """Ensure at least one of file_id or image_url is provided."""
+        if not self.file_id and not self.image_url:
+            msg = "ResponseInputImage must have either file_id or image_url"
+            raise ValueError(msg)
+        return self
+
+
+# Compatibility types for old completion API format
+class UserMessageContentItemText(BaseModel):
+    type: Literal["text"]
+    text: str
+
+
+class UserMessageContentItemImageURLImageURL(BaseModel):
+    url: str
+
+
+class UserMessageContentItemImageURL(BaseModel):
+    type: Literal["image_url"]
+    image_url: UserMessageContentItemImageURLImageURL
+
+
+# Legacy compatibility wrapper classes
+class AgentUserMessage(NewUserMessage):
+    def __init__(
+        self,
+        content: str | list[UserMessageContent] | None = None,
+        *,
+        role: Literal["user"] = "user",
+        meta: MessageMeta | None = None,
+    ):
+        if isinstance(content, str):
+            content = [UserTextContent(text=content)]
+        elif content is None:
+            content = []
+        super().__init__(
+            role=role,
+            content=content,
+            meta=meta or MessageMeta(),
+        )
+
+
+class AgentAssistantMessage(NewAssistantMessage):
+    def __init__(
+        self,
+        content: str | list[AssistantMessageContent] | None = None,
+        *,
+        role: Literal["assistant"] = "assistant",
+        meta: AssistantMessageMeta | None = None,
+    ):
+        if isinstance(content, str):
+            content = [AssistantTextContent(text=content)]
+        elif content is None:
+            content = []
+        super().__init__(
+            role=role,
+            content=content,
+            meta=meta or AssistantMessageMeta(),
+        )
+
+
+AgentSystemMessage = NewSystemMessage
+RunnerMessage = NewMessage
+
+
+# Streaming processor types
+class AssistantMessage(BaseModel):
+    """
+    Temporary assistant message used during streaming processing.
+
+    This is a simplified message format used internally by completion event processors
+    to accumulate streaming content before converting to the final NewAssistantMessage format.
+    """
+
+    role: Literal["assistant"] = "assistant"
+    id: str = ""
+    index: int | None = None
+    content: str = ""
+    tool_calls: list[Any] | None = None
+
+
+# Enhanced type definitions for better type hints
+# Supports new message format, legacy messages, and dict (for backward compatibility)
+FlexibleRunnerMessage = NewMessage | AgentUserMessage | AgentAssistantMessage | dict[str, Any]
+RunnerMessages = Sequence[FlexibleRunnerMessage]
+
+
+# Type alias for user input - supports string, single message, or sequence of messages
+UserInput = str | FlexibleRunnerMessage | RunnerMessages
+
+
+def user_message_to_llm_dict(message: NewUserMessage) -> dict[str, Any]:
+    """Convert NewUserMessage to dict for LLM API"""
+    # Convert content to simplified format for LLM
+    content = message.content[0].text if len(message.content) == 1 and message.content[0].type == "text" else [item.model_dump() for item in message.content]
+    return {"role": message.role, "content": content}
+
+
+def system_message_to_llm_dict(message: NewSystemMessage) -> dict[str, Any]:
+    """Convert NewSystemMessage to dict for LLM API"""
+    return {"role": message.role, "content": message.content}
+
+
+def assistant_message_to_llm_dict(message: NewAssistantMessage) -> dict[str, Any]:
+    """Convert NewAssistantMessage to dict for LLM API"""
+    # Separate text content from tool calls
+    text_parts = []
+    tool_calls = []
+
+    for item in message.content:
+        if item.type == "text":
+            text_parts.append(item.text)
+        elif item.type == "tool_call":
+            tool_calls.append(
+                {
+                    "id": item.call_id,
+                    "type": "function",
+                    "function": {
+                        "name": item.name,
+                        "arguments": item.arguments if isinstance(item.arguments, str) else str(item.arguments),
+                    },
+                },
+            )
+
+    result = {
+        "role": message.role,
+        "content": " ".join(text_parts) if text_parts else None,
+    }
+
+    if tool_calls:
+        result["tool_calls"] = tool_calls
+
+    return result
+
+
+def message_to_llm_dict(message: NewMessage) -> dict[str, Any]:
+    """Convert any NewMessage to dict for LLM API"""
+    if isinstance(message, NewUserMessage):
+        return user_message_to_llm_dict(message)
+    if isinstance(message, NewSystemMessage):
+        return system_message_to_llm_dict(message)
+    if isinstance(message, NewAssistantMessage):
+        return assistant_message_to_llm_dict(message)
+    # Fallback
+    return message.model_dump(exclude={"meta"})
+
+
+def messages_to_llm_format(messages: Sequence[NewMessage]) -> list[dict[str, Any]]:
+    """Convert a sequence of NewMessage to LLM format, excluding meta data"""
+    return [message_to_llm_dict(message) for message in messages]

{lite_agent-0.2.0.dist-info → lite_agent-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-agent
-Version: 0.2.0
+Version: 0.4.0
 Summary: A lightweight, extensible framework for building AI agent.
 Author-email: Jianqi Pan <jannchie@gmail.com>
 License: MIT
@@ -18,7 +18,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: aiofiles>=24.1.0
-Requires-Dist: funcall>=0.7.0
+Requires-Dist: funcall>=0.10.0
 Requires-Dist: prompt-toolkit>=3.0.51
 Requires-Dist: rich>=14.0.0
 Description-Content-Type: text/markdown

lite_agent-0.4.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+lite_agent/__init__.py,sha256=Swuefee0etSiaDnn30K2hBNV9UI3hIValW3A-pRE7e0,338
+lite_agent/agent.py,sha256=7wM8nVXIaPvEirRiY2HV0rY0sQuYCj-_hQ6V369bB58,22897
+lite_agent/chat_display.py,sha256=b0sUH3fkutc4e_KAKH7AtPu2msyLloNIAiWqCNavdds,30533
+lite_agent/client.py,sha256=m2jfBPIsleMZ1QCczjyHND-PIF17kQh4RTuf5FaipGM,2571
+lite_agent/loggers.py,sha256=XkNkdqwD_nQGfhQJ-bBWT7koci_mMkNw3aBpyMhOICw,57
+lite_agent/message_transfers.py,sha256=9qucjc-uSIXvVfhcmVRC_0lp0Q8sWp99dV4ReCh6ZlI,4428
+lite_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lite_agent/runner.py,sha256=wi56i5cMYAJi3U9GBsBlzhGC6Do9ovMSOsA_Qqy2HtA,39642
+lite_agent/processors/__init__.py,sha256=ybpAzpMBIE9v5I24wIBZRXeaOaPNTmoKH13aofgNI6Q,234
+lite_agent/processors/completion_event_processor.py,sha256=8fQYRofgBd8t0V3oUakTOmZdv5Q9tCuzADGCGvVgy0k,13442
+lite_agent/processors/response_event_processor.py,sha256=CElJMUzLs8mklVqJtoLiVu-NTq0Dz2NNd9YdAKpjgE0,8088
+lite_agent/stream_handlers/__init__.py,sha256=a5s1GZr42uvndtcQqEhK2cnjGkK8ZFTAZCj3J61Bb5E,209
+lite_agent/stream_handlers/litellm.py,sha256=lE2whfFG-txhjeIp58yZ4nqApXjVeSACUIk-3KYcnVg,2692
+lite_agent/templates/handoffs_source_instructions.xml.j2,sha256=2XsXQlBzk38qbxGrfyt8y2b0KlZmsV_1xavLufcdkHc,428
+lite_agent/templates/handoffs_target_instructions.xml.j2,sha256=gSbWVYYcovPKbGpFc0kqGSJ5Y5UC3fOHyUmZfcrDgSE,356
+lite_agent/templates/wait_for_user_instructions.xml.j2,sha256=wXbcYD5Q1FaCGVBm3Hz_Cp7nnoK7KzloP0ao-jYMwPk,231
+lite_agent/types/__init__.py,sha256=QKuhjFWRcpAlsBK9JYgoCABpoQExwhuyGudJoiiqQfs,3093
+lite_agent/types/events.py,sha256=mFMqV55WWJbPDyb_P61nd3qMLpEnwZgVY6NTKFkINkg,2389
+lite_agent/types/messages.py,sha256=c7nTIWqXNo562het_vaWcZvsoy-adkARwAYn4JNqm0c,9897
+lite_agent/types/tool_calls.py,sha256=Xnut8-2-Ld9vgA2GKJY6BbFlBaAv_n4W7vo7Jx21A-E,260
+lite_agent-0.4.0.dist-info/METADATA,sha256=biQoUoss9DcSuUX494mPj2yoXtE0H81Far_K3IpFB30,3456
+lite_agent-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lite_agent-0.4.0.dist-info/RECORD,,

lite_agent/processors/stream_chunk_processor.py

@@ -1,106 +0,0 @@
-import litellm
-from litellm.types.utils import ChatCompletionDeltaToolCall, ModelResponseStream, StreamingChoices
-
-from lite_agent.loggers import logger
-from lite_agent.types import AssistantMessage, ToolCall, ToolCallFunction
-
-
-class StreamChunkProcessor:
-    """Processor for handling streaming responses"""
-
-    def __init__(self) -> None:
-        self._current_message: AssistantMessage | None = None
-
-    def initialize_message(self, chunk: ModelResponseStream, choice: StreamingChoices) -> None:
-        """Initialize the message object"""
-        delta = choice.delta
-        if delta.role != "assistant":
-            logger.warning("Skipping chunk with role: %s", delta.role)
-            return
-        self._current_message = AssistantMessage(
-            id=chunk.id,
-            index=choice.index,
-            role=delta.role,
-            content="",
-        )
-        logger.debug('Initialized new message: "%s"', self._current_message.id)
-
-    def update_content(self, content: str) -> None:
-        """Update message content"""
-        if self._current_message and content:
-            self._current_message.content += content
-
-    def _initialize_tool_calls(self, tool_calls: list[litellm.ChatCompletionMessageToolCall]) -> None:
-        """Initialize tool calls"""
-        if not self._current_message:
-            return
-
-        self._current_message.tool_calls = []
-        for call in tool_calls:
-            logger.debug("Create new tool call: %s", call.id)
-
-    def _update_tool_calls(self, tool_calls: list[litellm.ChatCompletionMessageToolCall]) -> None:
-        """Update existing tool calls"""
-        if not self._current_message:
-            return
-        if not hasattr(self._current_message, "tool_calls"):
-            self._current_message.tool_calls = []
-        if not self._current_message.tool_calls:
-            return
-        if not tool_calls:
-            return
-        for current_call, new_call in zip(self._current_message.tool_calls, tool_calls, strict=False):
-            if new_call.function.arguments and current_call.function.arguments:
-                current_call.function.arguments += new_call.function.arguments
-            if new_call.type and new_call.type == "function":
-                current_call.type = new_call.type
-            elif new_call.type:
-                logger.warning("Unexpected tool call type: %s", new_call.type)
-
-    def update_tool_calls(self, tool_calls: list[ChatCompletionDeltaToolCall]) -> None:
-        """Handle tool call updates"""
-        if not tool_calls:
-            return
-        for call in tool_calls:
-            if call.id:
-                if call.type == "function":
-                    new_tool_call = ToolCall(
-                        id=call.id,
-                        type=call.type,
-                        function=ToolCallFunction(
-                            name=call.function.name or "",
-                            arguments=call.function.arguments,
-                        ),
-                        index=call.index,
-                    )
-                    if self._current_message is not None:
-                        if self._current_message.tool_calls is None:
-                            self._current_message.tool_calls = []
-                        self._current_message.tool_calls.append(new_tool_call)
-                else:
-                    logger.warning("Unexpected tool call type: %s", call.type)
-            elif self._current_message is not None and self._current_message.tool_calls is not None and call.index is not None and 0 <= call.index < len(self._current_message.tool_calls):
-                existing_call = self._current_message.tool_calls[call.index]
-                if call.function.arguments:
-                    if existing_call.function.arguments is None:
-                        existing_call.function.arguments = ""
-                    existing_call.function.arguments += call.function.arguments
-            else:
-                logger.warning("Cannot update tool call: current_message or tool_calls is None, or invalid index.")
-
-    def handle_usage_info(self, chunk: ModelResponseStream) -> litellm.Usage | None:
-        """Handle usage info, return whether this chunk should be skipped"""
-        return getattr(chunk, "usage", None)
-
-    @property
-    def is_initialized(self) -> bool:
-        """Check if the current message is initialized"""
-        return self._current_message is not None
-
-    @property
-    def current_message(self) -> AssistantMessage:
-        """Get the current message being processed"""
-        if not self._current_message:
-            msg = "No current message initialized. Call initialize_message first."
-            raise ValueError(msg)
-        return self._current_message

lite_agent/types/chunks.py

@@ -1,89 +0,0 @@
-from typing import Literal
-
-from litellm import Usage
-from litellm.types.utils import ModelResponseStream
-from pydantic import BaseModel
-
-from .messages import AssistantMessage
-
-
-class CompletionRawChunk(BaseModel):
-    """
-    Define the type of chunk
-    """
-
-    type: Literal["completion_raw"]
-    raw: ModelResponseStream
-
-
-class UsageChunk(BaseModel):
-    """
-    Define the type of usage info chunk
-    """
-
-    type: Literal["usage"]
-    usage: Usage
-
-
-class FinalMessageChunk(BaseModel):
-    """
-    Define the type of final message chunk
-    """
-
-    type: Literal["final_message"]
-    message: AssistantMessage
-    finish_reason: str | None = None  # Literal["stop", "tool_calls"]
-
-
-class ToolCallChunk(BaseModel):
-    """
-    Define the type of tool call chunk
-    """
-
-    type: Literal["tool_call"]
-    name: str
-    arguments: str
-
-
-class ToolCallResultChunk(BaseModel):
-    """
-    Define the type of tool call result chunk
-    """
-
-    type: Literal["tool_call_result"]
-    tool_call_id: str
-    name: str
-    content: str
-
-
-class ContentDeltaChunk(BaseModel):
-    """
-    Define the type of message chunk
-    """
-
-    type: Literal["content_delta"]
-    delta: str
-
-
-class ToolCallDeltaChunk(BaseModel):
-    """
-    Define the type of tool call delta chunk
-    """
-
-    type: Literal["tool_call_delta"]
-    tool_call_id: str
-    name: str
-    arguments_delta: str
-
-
-AgentChunk = CompletionRawChunk | UsageChunk | FinalMessageChunk | ToolCallChunk | ToolCallResultChunk | ContentDeltaChunk | ToolCallDeltaChunk
-
-AgentChunkType = Literal[
-    "completion_raw",
-    "usage",
-    "final_message",
-    "tool_call",
-    "tool_call_result",
-    "content_delta",
-    "tool_call_delta",
-]

lite_agent-0.2.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-lite_agent/__init__.py,sha256=T-jxY0aHwqPz5gs-ZzH1zvFgFdYVmOd15fnEc5A2H6U,229
-lite_agent/agent.py,sha256=UE06H1Huk4gHGovbh9DuAJAH2zC0hqf1YXgrVa59_Os,13546
-lite_agent/loggers.py,sha256=XkNkdqwD_nQGfhQJ-bBWT7koci_mMkNw3aBpyMhOICw,57
-lite_agent/message_transfers.py,sha256=nT7-tID20RK2yoN-rDiEE6sSclluSlhYSkayCzmPwk8,3984
-lite_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lite_agent/runner.py,sha256=lO8Z5R2RxjjgYzDAeYQbO2niQeieXOEzqUEN484G7QU,21367
-lite_agent/processors/__init__.py,sha256=X78GKL_IWwW2lg8w4DD6GOFWLzAR2wTfKxHlvOkcuUQ,114
-lite_agent/processors/stream_chunk_processor.py,sha256=nMA_cW7FDpXwJvm4F8vFwBXmHHsSELQFcoNEjH3xvn8,4751
-lite_agent/stream_handlers/__init__.py,sha256=2GSiG0VUgcQlFMl6JkGAqikXMII1a43Hr-J5NIct6dk,115
-lite_agent/stream_handlers/litellm.py,sha256=NNMAl8Bvoc2xe-qWKtfqvJQA2yr3sz1IUU90rQ_9iBw,3976
-lite_agent/types/__init__.py,sha256=sc2cdX1tPisfQwu2-apZtUa3u_Q6WDEqzNglfXhwCJo,1295
-lite_agent/types/chunks.py,sha256=Ro5BtrrdsYGkKrEekIhs9vIrBM7HljtgOkHherH8B3k,1697
-lite_agent/types/messages.py,sha256=cmMcj_r1_R9Pgu6ixmBIq2uwwqi5KzIllxGoxpcxF3w,1531
-lite_agent/types/tool_calls.py,sha256=Xnut8-2-Ld9vgA2GKJY6BbFlBaAv_n4W7vo7Jx21A-E,260
-lite_agent-0.2.0.dist-info/METADATA,sha256=egjWZCc9UgPAHMCJqZrjBXlXrG39f9LoW9k6DzntMas,3455
-lite_agent-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lite_agent-0.2.0.dist-info/RECORD,,