intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/core/node.py

@@ -1,215 +0,0 @@
-import logging
-from typing import Any, Sequence
-
-from langchain_core.language_models import LanguageModelLike
-from langchain_core.messages import (
-    AIMessage,
-    AnyMessage,
-    BaseMessage,
-    HumanMessage,
-    RemoveMessage,
-    ToolMessage,
-)
-from langchain_core.messages.utils import count_tokens_approximately, trim_messages
-from langgraph.graph.message import REMOVE_ALL_MESSAGES
-from langgraph.runtime import get_runtime
-from langgraph.utils.runnable import RunnableCallable
-from langmem.short_term.summarization import (
-    DEFAULT_EXISTING_SUMMARY_PROMPT,
-    DEFAULT_FINAL_SUMMARY_PROMPT,
-    DEFAULT_INITIAL_SUMMARY_PROMPT,
-    SummarizationResult,
-    asummarize_messages,
-)
-
-from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
-from intentkit.core.credit import skill_cost
-from intentkit.models.agent import Agent
-from intentkit.models.credit import CreditAccount, OwnerType
-from intentkit.models.skill import Skill
-
-logger = logging.getLogger(__name__)
-
-
-def _validate_chat_history(
-    messages: Sequence[BaseMessage],
-) -> None:
-    """Validate that all tool calls in AIMessages have a corresponding ToolMessage."""
-    all_tool_calls = [
-        tool_call
-        for message in messages
-        if isinstance(message, AIMessage)
-        for tool_call in message.tool_calls
-    ]
-    tool_call_ids_with_results = {
-        message.tool_call_id for message in messages if isinstance(message, ToolMessage)
-    }
-    tool_calls_without_results = [
-        tool_call
-        for tool_call in all_tool_calls
-        if tool_call["id"] not in tool_call_ids_with_results
-    ]
-    if not tool_calls_without_results:
-        return
-
-    message = "Found AIMessages with tool_calls that do not have a corresponding ToolMessage. "
-    f"Here are the first few of those tool calls: {tool_calls_without_results[:3]}"
-    raise ValueError(message)
-
-
-class PreModelNode(RunnableCallable):
-    """LangGraph node that run before the LLM is called."""
-
-    def __init__(
-        self,
-        *,
-        model: LanguageModelLike,
-        short_term_memory_strategy: str,
-        max_tokens: int,
-        max_summary_tokens: int = 1024,
-    ) -> None:
-        super().__init__(self._func, self._afunc, name="pre_model_node", trace=False)
-        self.model = model
-        self.short_term_memory_strategy = short_term_memory_strategy
-        self.max_tokens = max_tokens
-        self.max_tokens_before_summary = max_tokens
-        self.max_summary_tokens = max_summary_tokens
-        self.token_counter = count_tokens_approximately
-        self.initial_summary_prompt = DEFAULT_INITIAL_SUMMARY_PROMPT
-        self.existing_summary_prompt = DEFAULT_EXISTING_SUMMARY_PROMPT
-        self.final_prompt = DEFAULT_FINAL_SUMMARY_PROMPT
-        self.func_accepts_config = True
-
-    def _parse_input(
-        self, input: AgentState
-    ) -> tuple[list[AnyMessage], dict[str, Any]]:
-        messages = input.get("messages")
-        context = input.get("context", {})
-        if messages is None or not isinstance(messages, list) or len(messages) == 0:
-            raise ValueError("Missing required field `messages` in the input.")
-        return messages, context
-
-    # overwrite old messages if summarization is used
-    def _prepare_state_update(
-        self, context: dict[str, Any], summarization_result: SummarizationResult
-    ) -> dict[str, Any]:
-        state_update = {
-            "messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]
-            + summarization_result.messages
-        }
-        if summarization_result.running_summary:
-            state_update["context"] = {
-                **context,
-                "running_summary": summarization_result.running_summary,
-            }
-        return state_update
-
-    def _func(self, AgentState) -> dict[str, Any]:
-        raise NotImplementedError("Not implemented yet")
-
-    async def _afunc(self, input: AgentState) -> dict[str, Any]:
-        messages, context = self._parse_input(input)
-        try:
-            _validate_chat_history(messages)
-        except ValueError as e:
-            logger.error(f"Invalid chat history: {e}")
-            logger.info(input)
-            # delete all messages
-            return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
-        if self.short_term_memory_strategy == "trim":
-            trimmed_messages = trim_messages(
-                messages,
-                strategy="last",
-                token_counter=self.token_counter,
-                max_tokens=self.max_summary_tokens,
-                start_on="human",
-                end_on=("human", "tool"),
-            )
-            if len(trimmed_messages) < len(messages):
-                logger.info(
-                    f"Trimmed messages: {len(messages)} -> {len(trimmed_messages)}"
-                )
-                if len(trimmed_messages) <= 3:
-                    logger.info(f"Too few messages after trim: {len(trimmed_messages)}")
-                    return {}
-                return {
-                    "messages": [RemoveMessage(REMOVE_ALL_MESSAGES)] + trimmed_messages,
-                }
-            else:
-                return {}
-        if self.short_term_memory_strategy == "summarize":
-            # if last message is not human message, skip summarize
-            if not isinstance(messages[-1], HumanMessage):
-                return {}
-            # summarization is from outside, sometimes it is not stable, so we need to try-catch it
-            try:
-                summarization_result = await asummarize_messages(
-                    messages,
-                    running_summary=context.get("running_summary"),
-                    model=self.model,
-                    max_tokens=self.max_tokens,
-                    max_tokens_before_summary=self.max_tokens_before_summary,
-                    max_summary_tokens=self.max_summary_tokens,
-                    token_counter=self.token_counter,
-                    initial_summary_prompt=self.initial_summary_prompt,
-                    existing_summary_prompt=self.existing_summary_prompt,
-                    final_prompt=self.final_prompt,
-                )
-                if summarization_result.running_summary:
-                    logger.debug(f"Summarization result: {summarization_result}")
-                else:
-                    logger.debug("Summarization not run")
-                return self._prepare_state_update(context, summarization_result)
-            except ValueError as e:
-                logger.error(f"Invalid chat history: {e}")
-                logger.info(input)
-                # delete all messages
-                return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
-        raise ValueError(
-            f"Invalid short_term_memory_strategy: {self.short_term_memory_strategy}"
-        )
-
-
-class PostModelNode(RunnableCallable):
-    def __init__(self) -> None:
-        super().__init__(self._func, self._afunc, name="post_model_node", trace=False)
-        self.func_accepts_config = True
-
-    def _func(self, input: AgentState) -> dict[str, Any]:
-        raise NotImplementedError("Not implemented yet")
-
-    async def _afunc(self, input: AgentState) -> dict[str, Any]:
-        runtime = get_runtime(AgentContext)
-        context = runtime.context
-        logger.debug(f"Running PostModelNode, input: {input}, context: {context}")
-        state_update = {}
-        messages = input.get("messages")
-        if messages is None or not isinstance(messages, list) or len(messages) == 0:
-            raise ValueError("Missing required field `messages` in the input.")
-        payer = context.payer
-        if not payer:
-            return state_update
-        logger.debug(f"last: {messages[-1]}")
-        msg = messages[-1]
-        agent_id = context.agent_id
-        agent = await Agent.get(agent_id)
-        account = await CreditAccount.get_or_create(OwnerType.USER, payer)
-        if hasattr(msg, "tool_calls") and msg.tool_calls:
-            for tool_call in msg.tool_calls:
-                skill_meta = await Skill.get(tool_call.get("name"))
-                if skill_meta:
-                    skill_cost_info = await skill_cost(skill_meta.name, payer, agent)
-                    total_paid = skill_cost_info.total_amount
-                    if not account.has_sufficient_credits(total_paid):
-                        state_update["error"] = AgentError.INSUFFICIENT_CREDITS
-                        state_update["messages"] = [RemoveMessage(id=msg.id)]
-                        state_update["messages"].append(
-                            AIMessage(
-                                content=f"Insufficient credits. Please top up your account. You need {total_paid} credits, but you only have {account.balance} credits.",
-                            )
-                        )
-                        return state_update
-        return state_update
-
-
-post_model_node = PostModelNode()

intentkit/models/conversation.py

@@ -1,286 +0,0 @@
-"""Conversation models for agent generator.
-
-This module provides models for tracking conversation history and projects
-related to agent generation sessions.
-"""
-
-from datetime import datetime
-from typing import Annotated, List, Optional
-
-from epyxid import XID
-from intentkit.models.base import Base
-from intentkit.models.db import get_session
-from pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Index,
-    String,
-    Text,
-    desc,
-    func,
-    select,
-)
-from sqlalchemy.dialects.postgresql import JSON, JSONB
-from sqlalchemy.ext.asyncio import AsyncSession
-
-
-class ConversationProjectTable(Base):
-    """Conversation project database table model."""
-
-    __tablename__ = "generator_conversation_projects"
-    __table_args__ = (
-        Index("ix_generator_conversation_projects_user_id", "user_id"),
-        Index("ix_generator_conversation_projects_created_at", "created_at"),
-    )
-
-    id = Column(
-        String,
-        primary_key=True,
-    )
-    user_id = Column(
-        String,
-        nullable=True,
-    )
-    created_at = Column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )
-    last_activity = Column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )
-
-
-class ConversationMessageTable(Base):
-    """Conversation message database table model."""
-
-    __tablename__ = "generator_conversation_messages"
-    __table_args__ = (
-        Index("ix_generator_conversation_messages_project_id", "project_id"),
-        Index("ix_generator_conversation_messages_created_at", "created_at"),
-    )
-
-    id = Column(
-        String,
-        primary_key=True,
-    )
-    project_id = Column(
-        String,
-        nullable=False,
-    )
-    role = Column(
-        String,
-        nullable=False,
-    )
-    content = Column(
-        Text,
-        nullable=False,
-    )
-    message_metadata = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-    )
-    created_at = Column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )
-
-
-class ConversationProjectCreate(BaseModel):
-    """Base model for creating conversation projects."""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: Annotated[
-        str,
-        Field(
-            default_factory=lambda: str(XID()),
-            description="Unique identifier for the conversation project",
-        ),
-    ]
-    user_id: Annotated[
-        Optional[str],
-        Field(None, description="User ID associated with this project"),
-    ]
-
-    async def save_in_session(self, db: AsyncSession) -> "ConversationProject":
-        """Save the conversation project in the given database session."""
-        db_project = ConversationProjectTable(
-            id=self.id,
-            user_id=self.user_id,
-        )
-        db.add(db_project)
-        await db.flush()
-        await db.refresh(db_project)
-        return ConversationProject.model_validate(db_project)
-
-    async def save(self) -> "ConversationProject":
-        """Save the conversation project to the database."""
-        async with get_session() as db:
-            result = await self.save_in_session(db)
-            await db.commit()
-            return result
-
-
-class ConversationProject(ConversationProjectCreate):
-    """Conversation project model with all fields including server-generated ones."""
-
-    model_config = ConfigDict(
-        from_attributes=True,
-        json_encoders={
-            datetime: lambda v: v.isoformat(timespec="milliseconds"),
-        },
-    )
-
-    created_at: Annotated[
-        datetime, Field(description="Timestamp when this project was created")
-    ]
-    last_activity: Annotated[
-        datetime, Field(description="Timestamp of last activity in this project")
-    ]
-
-    @classmethod
-    async def get(cls, project_id: str) -> Optional["ConversationProject"]:
-        """Get a conversation project by ID."""
-        async with get_session() as db:
-            result = await db.execute(
-                select(ConversationProjectTable).where(
-                    ConversationProjectTable.id == project_id
-                )
-            )
-            project = result.scalar_one_or_none()
-            if project:
-                return cls.model_validate(project)
-            return None
-
-    async def update_activity(self) -> "ConversationProject":
-        """Update the last activity timestamp for this project."""
-        async with get_session() as db:
-            from sqlalchemy import update
-
-            await db.execute(
-                update(ConversationProjectTable)
-                .where(ConversationProjectTable.id == self.id)
-                .values(last_activity=func.now())
-            )
-            await db.commit()
-            # Refresh the object
-            result = await db.execute(
-                select(ConversationProjectTable).where(
-                    ConversationProjectTable.id == self.id
-                )
-            )
-            project = result.scalar_one()
-            return ConversationProject.model_validate(project)
-
-    @classmethod
-    async def get_by_user(
-        cls, user_id: Optional[str] = None, limit: int = 50
-    ) -> List["ConversationProject"]:
-        """Get conversation projects by user ID."""
-        async with get_session() as db:
-            query = select(ConversationProjectTable).order_by(
-                desc(ConversationProjectTable.last_activity)
-            )
-
-            if user_id is not None:
-                query = query.where(ConversationProjectTable.user_id == user_id)
-
-            query = query.limit(limit)
-
-            result = await db.execute(query)
-            projects = result.scalars().all()
-            return [cls.model_validate(project) for project in projects]
-
-
-class ConversationMessageCreate(BaseModel):
-    """Base model for creating conversation messages."""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: Annotated[
-        str,
-        Field(
-            default_factory=lambda: str(XID()),
-            description="Unique identifier for the conversation message",
-        ),
-    ]
-    project_id: Annotated[str, Field(description="Project ID this message belongs to")]
-    role: Annotated[str, Field(description="Role of the message sender")]
-    content: Annotated[str, Field(description="Content of the message")]
-    message_metadata: Annotated[
-        Optional[dict],
-        Field(None, description="Additional metadata for the message"),
-    ]
-
-    async def save_in_session(self, db: AsyncSession) -> "ConversationMessage":
-        """Save the conversation message in the given database session."""
-        db_message = ConversationMessageTable(
-            id=self.id,
-            project_id=self.project_id,
-            role=self.role,
-            content=self.content,
-            message_metadata=self.message_metadata,
-        )
-        db.add(db_message)
-        await db.flush()
-        await db.refresh(db_message)
-        return ConversationMessage.model_validate(db_message)
-
-    async def save(self) -> "ConversationMessage":
-        """Save the conversation message to the database."""
-        async with get_session() as db:
-            result = await self.save_in_session(db)
-            await db.commit()
-            return result
-
-
-class ConversationMessage(ConversationMessageCreate):
-    """Conversation message model with all fields including server-generated ones."""
-
-    model_config = ConfigDict(
-        from_attributes=True,
-        json_encoders={
-            datetime: lambda v: v.isoformat(timespec="milliseconds"),
-        },
-    )
-
-    created_at: Annotated[
-        datetime, Field(description="Timestamp when this message was created")
-    ]
-
-    @classmethod
-    async def get_by_project(
-        cls, project_id: str, user_id: Optional[str] = None
-    ) -> List["ConversationMessage"]:
-        """Get conversation messages for a project."""
-        async with get_session() as db:
-            # First check if project exists and user has access
-            project_query = select(ConversationProjectTable).where(
-                ConversationProjectTable.id == project_id
-            )
-            if user_id is not None:
-                project_query = project_query.where(
-                    ConversationProjectTable.user_id == user_id
-                )
-
-            project_result = await db.execute(project_query)
-            project = project_result.scalar_one_or_none()
-
-            if not project:
-                return []
-
-            # Get messages for the project
-            messages_query = (
-                select(ConversationMessageTable)
-                .where(ConversationMessageTable.project_id == project_id)
-                .order_by(ConversationMessageTable.created_at)
-            )
-
-            result = await db.execute(messages_query)
-            messages = result.scalars().all()
-            return [cls.model_validate(message) for message in messages]