minder-cli 0.2.0__py3-none-any.whl

minder/llm/openai.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from typing import Any
+
+from minder.graph.state import GraphState
+from minder.runtime import load_attr, module_available
+
+
+class OpenAIFallbackLLM:
+    def __init__(self, api_key: str | None, model: str, runtime: str = "mock") -> None:
+        self._api_key = api_key
+        self._model = model
+        self._runtime = runtime
+        self._completion_fn: Any | None = None
+
+    def available(self) -> bool:
+        return bool(self._api_key)
+
+    @property
+    def runtime(self) -> str:
+        if self._runtime == "auto":
+            return "litellm" if module_available("litellm") else "mock"
+        return self._runtime
+
+    def generate(self, state: GraphState) -> dict[str, object]:
+        if not self.available():
+            raise RuntimeError("OpenAI fallback is not configured")
+        text = (
+            f"{state.workflow_context.get('guidance', '')}\n"
+            f"Fallback answer for '{state.query}' using {self._model}."
+        )
+        if self.runtime == "litellm":
+            text = self._generate_with_litellm(state, fallback=text)
+        return {
+            "text": text,
+            "sources": [doc["path"] for doc in state.reranked_docs[:3]],
+            "provider": "openai_fallback",
+            "model": self._model,
+            "runtime": self.runtime,
+            "stream": [text],
+        }
+
+    def stream_generate(
+        self, state: GraphState
+    ) -> Generator[dict[str, object], None, None]:
+        result = self.generate(state)
+        text = str(result.get("text", ""))
+        if text:
+            yield {"type": "chunk", "delta": text}
+        yield {"type": "result", "result": result}
+
+    def _generate_with_litellm(self, state: GraphState, *, fallback: str) -> str:
+        completion = self._litellm_completion()
+        if completion is None:
+            return fallback
+        reasoning_output = getattr(state, "reasoning_output", {}) or {}
+        try:
+            response = completion(
+                model=self._model,
+                api_key=self._api_key,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": str(reasoning_output.get("prompt") or state.query),
+                    }
+                ],
+            )
+        except Exception:
+            return fallback
+        choices = getattr(response, "choices", None)
+        if choices is None and isinstance(response, dict):
+            choices = response.get("choices", [])
+        if not choices:
+            return fallback
+        first = choices[0]
+        message = getattr(first, "message", None)
+        if message is None and isinstance(first, dict):
+            message = first.get("message", {})
+        content = getattr(message, "content", None)
+        if content is None and isinstance(message, dict):
+            content = message.get("content")
+        return str(content or fallback).strip() or fallback
+
+    def _litellm_completion(self) -> Any | None:
+        if self._completion_fn is not None:
+            return self._completion_fn
+        self._completion_fn = load_attr("litellm", "completion")
+        return self._completion_fn

minder/models/__init__.py

@@ -0,0 +1,109 @@
+# SQLAlchemy Base
+from .base import Base as Base
+
+# User
+from .user import User as User, UserSchema as UserSchema
+
+# Client/Auth Gateway
+from .client import (
+    AuditLog as AuditLog,
+    AuditLogSchema as AuditLogSchema,
+    Client as Client,
+    ClientApiKey as ClientApiKey,
+    ClientApiKeySchema as ClientApiKeySchema,
+    ClientSchema as ClientSchema,
+    ClientSession as ClientSession,
+    ClientSessionSchema as ClientSessionSchema,
+)
+
+# Skill
+from .skill import Skill as Skill, SkillSchema as SkillSchema
+
+# Admin Jobs
+from .job import AdminJob as AdminJob, AdminJobSchema as AdminJobSchema
+
+# Session
+from .session import Session as Session, SessionSchema as SessionSchema
+
+# Workflow
+from .workflow import Workflow as Workflow, WorkflowSchema as WorkflowSchema
+
+# Repository
+from .repository import (
+    Repository as Repository,
+    RepositorySchema as RepositorySchema,
+    RepositoryWorkflowState as RepositoryWorkflowState,
+    RepositoryWorkflowStateSchema as RepositoryWorkflowStateSchema,
+)
+
+# History
+from .history import History as History, HistorySchema as HistorySchema
+
+# Error
+from .error import Error as Error, ErrorSchema as ErrorSchema
+
+# Document
+from .document import Document as Document, DocumentSchema as DocumentSchema
+
+# Rules, Feedback & Misc
+from .rule import (
+    Feedback as Feedback,
+    FeedbackSchema as FeedbackSchema,
+    MetadataSchema as MetadataSchema,
+    Rule as Rule,
+    RuleSchema as RuleSchema,
+)
+
+# Knowledge Graph
+from .graph import (
+    GraphEdge as GraphEdge,
+    GraphEdgeSchema as GraphEdgeSchema,
+    GraphNode as GraphNode,
+    GraphNodeSchema as GraphNodeSchema,
+)
+
+__all__ = [
+    "Base",
+    "AuditLog",
+    "AuditLogSchema",
+    "AdminJob",
+    "AdminJobSchema",
+    "Client",
+    "ClientApiKey",
+    "ClientApiKeySchema",
+    "ClientSchema",
+    "ClientSession",
+    "ClientSessionSchema",
+    "Document",
+    "DocumentSchema",
+    "Error",
+    "ErrorSchema",
+    "Feedback",
+    "FeedbackSchema",
+    "GraphEdge",
+    "GraphEdgeSchema",
+    "GraphNode",
+    "GraphNodeSchema",
+    "History",
+    "HistorySchema",
+    "MetadataSchema",
+    "Repository",
+    "RepositorySchema",
+    "RepositoryWorkflowState",
+    "RepositoryWorkflowStateSchema",
+    "Rule",
+    "RuleSchema",
+    "Prompt",
+    "PromptSchema",
+    "Session",
+    "SessionSchema",
+    "Skill",
+    "SkillSchema",
+    "User",
+    "UserSchema",
+    "Workflow",
+    "WorkflowSchema",
+]
+
+# Prompts
+from .prompt import Prompt as Prompt, PromptSchema as PromptSchema

minder/models/base.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, ConfigDict
+from sqlalchemy.orm import DeclarativeBase
+
+class Base(DeclarativeBase):
+    pass
+
+
+class BaseModelMeta(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    company_id: str = "default"

minder/models/client.py

@@ -0,0 +1,137 @@
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic import Field
+from sqlalchemy import DateTime, JSON, String, UUID, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base, BaseModelMeta
+
+
+class ClientSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    name: str
+    slug: str
+    description: str = ""
+    status: str = "active"
+    created_by_user_id: uuid.UUID
+    owner_team: str | None = None
+    transport_modes: list[str] = Field(default_factory=lambda: ["sse", "stdio"])
+    tool_scopes: list[str] = Field(default_factory=list)
+    repo_scopes: list[str] = Field(default_factory=list)
+    workflow_scopes: list[str] = Field(default_factory=list)
+    rate_limit_policy: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class ClientApiKeySchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    client_id: uuid.UUID
+    key_prefix: str
+    secret_hash: str
+    status: str = "active"
+    last_used_at: datetime | None = None
+    created_by_user_id: uuid.UUID
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    expires_at: datetime | None = None
+    revoked_at: datetime | None = None
+
+
+class ClientSessionSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    client_id: uuid.UUID
+    access_token_id: str
+    status: str = "active"
+    scopes: list[str] = Field(default_factory=list)
+    issued_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    expires_at: datetime
+    last_seen_at: datetime | None = None
+    session_metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class AuditLogSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    actor_type: str
+    actor_id: str
+    event_type: str
+    resource_type: str
+    resource_id: str | None = None
+    request_id: str | None = None
+    tool_name: str | None = None
+    outcome: str = "success"
+    ip: str | None = None
+    user_agent: str | None = None
+    audit_metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class Client(Base):
+    __tablename__ = "clients"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    slug: Mapped[str] = mapped_column(String, unique=True, index=True, nullable=False)
+    description: Mapped[str] = mapped_column(String, default="")
+    status: Mapped[str] = mapped_column(String, default="active")
+    created_by_user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    owner_team: Mapped[str | None] = mapped_column(String, nullable=True)
+    transport_modes: Mapped[list[str]] = mapped_column(JSON, default=list)
+    tool_scopes: Mapped[list[str]] = mapped_column(JSON, default=list)
+    repo_scopes: Mapped[list[str]] = mapped_column(JSON, default=list)
+    workflow_scopes: Mapped[list[str]] = mapped_column(JSON, default=list)
+    rate_limit_policy: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+    )
+
+
+class ClientApiKey(Base):
+    __tablename__ = "client_api_keys"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    client_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    key_prefix: Mapped[str] = mapped_column(String, index=True)
+    secret_hash: Mapped[str] = mapped_column(String, nullable=False)
+    status: Mapped[str] = mapped_column(String, default="active")
+    last_used_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    created_by_user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    revoked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+
+
+class ClientSession(Base):
+    __tablename__ = "client_sessions"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    client_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    access_token_id: Mapped[str] = mapped_column(String, unique=True, index=True)
+    status: Mapped[str] = mapped_column(String, default="active")
+    scopes: Mapped[list[str]] = mapped_column(JSON, default=list)
+    issued_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+    last_seen_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    session_metadata: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_logs"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    actor_type: Mapped[str] = mapped_column(String, index=True)
+    actor_id: Mapped[str] = mapped_column(String, index=True)
+    event_type: Mapped[str] = mapped_column(String, index=True)
+    resource_type: Mapped[str] = mapped_column(String, index=True)
+    resource_id: Mapped[str | None] = mapped_column(String, nullable=True)
+    request_id: Mapped[str | None] = mapped_column(String, nullable=True)
+    tool_name: Mapped[str | None] = mapped_column(String, nullable=True)
+    outcome: Mapped[str] = mapped_column(String, default="success")
+    ip: Mapped[str | None] = mapped_column(String, nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(String, nullable=True)
+    audit_metadata: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())

minder/models/document.py

@@ -0,0 +1,34 @@
+import uuid
+from datetime import datetime, UTC
+from typing import Dict, Any, List, Optional
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, DateTime, UUID, JSON, func
+from pydantic import Field
+
+from .base import Base, BaseModelMeta
+
+class DocumentSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    title: str
+    content: str
+    doc_type: str  # enum: markdown, code, api_spec, config
+    source_path: str
+    chunks: Dict[str, Any] = Field(default_factory=dict)  # JSON list of chunks
+    embedding: Optional[List[float]] = None  # vector(default 768) stored as JSON list
+    project: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class Document(Base):
+    __tablename__ = "documents"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title: Mapped[str] = mapped_column(String)
+    content: Mapped[str] = mapped_column(String)
+    doc_type: Mapped[str] = mapped_column(String, index=True)
+    source_path: Mapped[str] = mapped_column(String)
+    chunks: Mapped[Dict[str, Any]] = mapped_column(JSON, default=dict)
+    embedding: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSON, nullable=True)
+    project: Mapped[str] = mapped_column(String, index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())

minder/models/error.py

@@ -0,0 +1,32 @@
+import uuid
+from datetime import datetime, UTC
+from typing import Dict, Any, List, Optional
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Boolean, DateTime, UUID, JSON, func
+from pydantic import Field
+
+from .base import Base, BaseModelMeta
+
+class ErrorSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    error_code: str
+    error_message: str
+    stack_trace: Optional[str] = None
+    context: Dict[str, Any] = Field(default_factory=dict)
+    resolution: Optional[str] = None
+    embedding: Optional[List[float]] = None  # vector(default 768) stored as JSON list
+    resolved: bool = False
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class Error(Base):
+    __tablename__ = "errors"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    error_code: Mapped[str] = mapped_column(String, index=True)
+    error_message: Mapped[str] = mapped_column(String)
+    stack_trace: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    context: Mapped[Dict[str, Any]] = mapped_column(JSON, default=dict)
+    resolution: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    embedding: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSON, nullable=True)  # vector as JSON fallback
+    resolved: Mapped[bool] = mapped_column(Boolean, default=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())

minder/models/graph.py

@@ -0,0 +1,114 @@
+"""
+Knowledge Graph SQLAlchemy models.
+
+GraphNode: any entity in the knowledge graph (module, file, service, owner).
+GraphEdge: directed relationship between two nodes (depends_on, imports, calls, owns).
+
+v2 schema adds repo_id + branch columns so nodes from different repositories
+and branches are stored independently.  UniqueConstraint is now
+(repo_id, branch, node_type, name).
+
+Migration from v1 is handled by KnowledgeGraphStore.init_db() which calls
+_migrate_graph_v2() on first boot when the columns are absent.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, UTC
+from typing import Any
+
+from pydantic import Field
+from sqlalchemy import DateTime, Float, JSON, String, UUID, UniqueConstraint, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base, BaseModelMeta
+
+
+# ---------------------------------------------------------------------------
+# Pydantic schemas
+# ---------------------------------------------------------------------------
+
+
+class GraphNodeSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    repo_id: str = ""
+    branch: str = ""
+    node_type: str  # module | file | service | owner | route | api_endpoint | websocket_endpoint | mq_topic | …
+    name: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class GraphEdgeSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    repo_id: str = ""
+    source_id: uuid.UUID
+    target_id: uuid.UUID
+    relation: str  # depends_on | owns | imports | calls | exposes_route | publishes | consumes | cross_repo_calls
+    weight: float = 1.0
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+# ---------------------------------------------------------------------------
+# SQLAlchemy ORM models
+# ---------------------------------------------------------------------------
+
+
+class GraphNode(Base):
+    """A node in the knowledge graph — module, file, service, or owner.
+
+    v2: scoped by (repo_id, branch) so nodes from different repositories or
+    branches never collide.  repo_id="" and branch="" denotes global/shared
+    nodes (e.g. external packages used by many repos).
+    """
+
+    __tablename__ = "graph_nodes"
+    __table_args__ = (
+        # v2 constraint: repo_id + branch + type + name must be unique
+        UniqueConstraint(
+            "repo_id", "branch", "node_type", "name",
+            name="uq_graph_node_repo_branch_type_name",
+        ),
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    # Scope columns (v2) — empty string = "global / no specific repo"
+    repo_id: Mapped[str] = mapped_column(String, index=True, default="", server_default="")
+    branch: Mapped[str] = mapped_column(String, index=True, default="", server_default="")
+    node_type: Mapped[str] = mapped_column(String, index=True)
+    name: Mapped[str] = mapped_column(String, index=True)
+    node_metadata: Mapped[dict] = mapped_column("metadata", JSON, default=dict)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+
+
+class GraphEdge(Base):
+    """A directed edge between two graph nodes.
+
+    v2: repo_id added for efficient repo-scoped edge queries.
+    """
+
+    __tablename__ = "graph_edges"
+    __table_args__ = (
+        UniqueConstraint(
+            "repo_id", "source_id", "target_id", "relation",
+            name="uq_graph_edge_repo_src_tgt_rel",
+        ),
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    # Scope column (v2)
+    repo_id: Mapped[str] = mapped_column(String, index=True, default="", server_default="")
+    source_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    target_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    relation: Mapped[str] = mapped_column(String, index=True)
+    weight: Mapped[float] = mapped_column(Float, default=1.0)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )

minder/models/history.py

@@ -0,0 +1,32 @@
+import uuid
+from datetime import datetime, UTC
+from typing import Dict, Any, Optional
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, Integer, DateTime, UUID, JSON, func
+from pydantic import Field
+
+from .base import Base, BaseModelMeta
+
+class HistorySchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    session_id: uuid.UUID
+    role: str  # enum: user, assistant, system, tool
+    content: str
+    reasoning_trace: Optional[str] = None
+    tool_calls: Dict[str, Any] = Field(default_factory=dict)  # JSON list of tool calls
+    tokens_used: int = 0
+    latency_ms: int = 0
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+class History(Base):
+    __tablename__ = "history"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    session_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), index=True)
+    role: Mapped[str] = mapped_column(String)
+    content: Mapped[str] = mapped_column(String)
+    reasoning_trace: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    tool_calls: Mapped[Dict[str, Any]] = mapped_column(JSON, default=dict)
+    tokens_used: Mapped[int] = mapped_column(Integer, default=0)
+    latency_ms: Mapped[int] = mapped_column(Integer, default=0)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())

minder/models/job.py

@@ -0,0 +1,62 @@
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic import Field
+from sqlalchemy import DateTime, JSON, String, UUID, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base, BaseModelMeta
+
+
+class AdminJobSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    job_type: str
+    title: str
+    status: str = "queued"
+    requested_by_user_id: uuid.UUID | None = None
+    payload: dict[str, Any] = Field(default_factory=dict)
+    result_payload: dict[str, Any] | None = None
+    error_message: str | None = None
+    progress_current: int = 0
+    progress_total: int = 0
+    message: str | None = None
+    events: list[dict[str, Any]] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    started_at: datetime | None = None
+    finished_at: datetime | None = None
+
+
+class AdminJob(Base):
+    __tablename__ = "admin_jobs"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    company_id: Mapped[str] = mapped_column(String, index=True, default="default")
+    job_type: Mapped[str] = mapped_column(String, index=True)
+    title: Mapped[str] = mapped_column(String)
+    status: Mapped[str] = mapped_column(String, index=True, default="queued")
+    requested_by_user_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), index=True, nullable=True
+    )
+    payload: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
+    result_payload: Mapped[dict[str, Any] | None] = mapped_column(JSON, nullable=True)
+    error_message: Mapped[str | None] = mapped_column(String, nullable=True)
+    progress_current: Mapped[int] = mapped_column(default=0)
+    progress_total: Mapped[int] = mapped_column(default=0)
+    message: Mapped[str | None] = mapped_column(String, nullable=True)
+    events: Mapped[list[dict[str, Any]]] = mapped_column(JSON, default=list)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )
+    started_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
+    finished_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )

minder/models/prompt.py

@@ -0,0 +1,41 @@
+import uuid
+from datetime import datetime, UTC
+from typing import List
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import String, DateTime, UUID, JSON, Text, func
+from pydantic import Field
+
+from .base import Base, BaseModelMeta
+
+
+# Pydantic Schema
+class PromptSchema(BaseModelMeta):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    name: str
+    title: str
+    description: str
+    content_template: str
+    arguments: List[str] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+# SQLAlchemy Model
+class Prompt(Base):
+    __tablename__ = "prompts"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    company_id: Mapped[str] = mapped_column(String, index=True, default="default")
+    name: Mapped[str] = mapped_column(String, unique=True, index=True)
+    title: Mapped[str] = mapped_column(String)
+    description: Mapped[str] = mapped_column(String)
+    content_template: Mapped[str] = mapped_column(Text)
+    arguments: Mapped[list[str]] = mapped_column(JSON, default=list)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )