forge-openai 0.1.0__tar.gz

forge_openai-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: forge-openai
+Version: 0.1.0
+Summary: Forge Verify guardrail for OpenAI Agents SDK — verify every tool call before execution
+Author-email: Veritera AI <engineering@veritera.ai>
+License: MIT
+Project-URL: Homepage, https://veritera.ai
+Project-URL: Documentation, https://veritera.ai/docs
+Project-URL: Repository, https://github.com/VeriteraAI/forge-openai
+Keywords: veritera,forge,openai,agents,guardrail,verification,ai-safety
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: veritera>=0.2.0
+Requires-Dist: openai-agents>=0.1.0
+
+# forge-openai
+
+Forge Verify guardrail for the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python). Verifies every AI agent tool call against your policies **before** execution.
+
+## Install
+
+```bash
+pip install forge-openai
+```
+
+## Quick Start
+
+```python
+import os
+from agents import Agent, Runner, function_tool
+from forge_openai import forge_tool_guardrail, forge_protect
+
+os.environ["VERITERA_API_KEY"] = "vt_live_..."
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+# Define your tools
+@function_tool
+def send_payment(amount: float, recipient: str) -> str:
+    """Send a payment to a recipient."""
+    return f"Sent ${amount} to {recipient}"
+
+@function_tool
+def delete_record(record_id: str) -> str:
+    """Delete a database record."""
+    return f"Deleted {record_id}"
+
+@function_tool
+def read_balance() -> str:
+    """Check account balance."""
+    return "Balance: $50,000"
+
+# Protect all tools with Forge — one line
+agent = Agent(
+    name="finance-bot",
+    instructions="You help with financial operations.",
+    tools=forge_protect(
+        send_payment, delete_record, read_balance,
+        policy="finance-controls",
+        skip_actions=["read_balance"],  # read-only tools don't need verification
+    ),
+)
+
+# Run the agent — Forge checks every tool call automatically
+result = await Runner.run(agent, "Send $500 to vendor@acme.com")
+```
+
+## How It Works
+
+1. Your agent decides to call a tool (e.g. `send_payment`)
+2. **Before execution**, Forge checks the action against your policies
+3. If **approved**: the tool runs normally
+4. If **denied**: the LLM receives a denial message and can explain why to the user
+
+No tool ever executes without verification. Every decision is logged with a cryptographic proof.
+
+## Per-Tool Guardrail
+
+```python
+from forge_openai import forge_tool_guardrail
+
+guardrail = forge_tool_guardrail(policy="email-controls")
+
+@function_tool(tool_input_guardrails=[guardrail])
+def send_email(to: str, subject: str, body: str) -> str:
+    """Send an email."""
+    return f"Email sent to {to}"
+```
+
+## Full Control
+
+```python
+from forge_openai import ForgeGuardrail
+
+forge = ForgeGuardrail(
+    api_key="vt_live_...",
+    agent_id="prod-finance-bot",
+    policy="finance-controls",
+    fail_closed=True,
+    skip_actions=["read_balance", "get_time"],
+    on_blocked=lambda action, reason, result: print(f"BLOCKED: {action} — {reason}"),
+    on_verified=lambda action, result: print(f"APPROVED: {action}"),
+)
+
+agent = Agent(
+    name="finance-bot",
+    tools=forge.protect(send_payment, delete_record),
+    input_guardrails=[forge.input_guardrail()],  # also screen agent input
+)
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `VERITERA_API_KEY` | Your Forge API key (starts with `vt_live_` or `vt_test_`) |
+
+## License
+
+MIT — [Veritera AI](https://veritera.ai)

forge_openai-0.1.0/README.md

@@ -0,0 +1,104 @@
+# forge-openai
+
+Forge Verify guardrail for the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python). Verifies every AI agent tool call against your policies **before** execution.
+
+## Install
+
+```bash
+pip install forge-openai
+```
+
+## Quick Start
+
+```python
+import os
+from agents import Agent, Runner, function_tool
+from forge_openai import forge_tool_guardrail, forge_protect
+
+os.environ["VERITERA_API_KEY"] = "vt_live_..."
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+# Define your tools
+@function_tool
+def send_payment(amount: float, recipient: str) -> str:
+    """Send a payment to a recipient."""
+    return f"Sent ${amount} to {recipient}"
+
+@function_tool
+def delete_record(record_id: str) -> str:
+    """Delete a database record."""
+    return f"Deleted {record_id}"
+
+@function_tool
+def read_balance() -> str:
+    """Check account balance."""
+    return "Balance: $50,000"
+
+# Protect all tools with Forge — one line
+agent = Agent(
+    name="finance-bot",
+    instructions="You help with financial operations.",
+    tools=forge_protect(
+        send_payment, delete_record, read_balance,
+        policy="finance-controls",
+        skip_actions=["read_balance"],  # read-only tools don't need verification
+    ),
+)
+
+# Run the agent — Forge checks every tool call automatically
+result = await Runner.run(agent, "Send $500 to vendor@acme.com")
+```
+
+## How It Works
+
+1. Your agent decides to call a tool (e.g. `send_payment`)
+2. **Before execution**, Forge checks the action against your policies
+3. If **approved**: the tool runs normally
+4. If **denied**: the LLM receives a denial message and can explain why to the user
+
+No tool ever executes without verification. Every decision is logged with a cryptographic proof.
+
+## Per-Tool Guardrail
+
+```python
+from forge_openai import forge_tool_guardrail
+
+guardrail = forge_tool_guardrail(policy="email-controls")
+
+@function_tool(tool_input_guardrails=[guardrail])
+def send_email(to: str, subject: str, body: str) -> str:
+    """Send an email."""
+    return f"Email sent to {to}"
+```
+
+## Full Control
+
+```python
+from forge_openai import ForgeGuardrail
+
+forge = ForgeGuardrail(
+    api_key="vt_live_...",
+    agent_id="prod-finance-bot",
+    policy="finance-controls",
+    fail_closed=True,
+    skip_actions=["read_balance", "get_time"],
+    on_blocked=lambda action, reason, result: print(f"BLOCKED: {action} — {reason}"),
+    on_verified=lambda action, result: print(f"APPROVED: {action}"),
+)
+
+agent = Agent(
+    name="finance-bot",
+    tools=forge.protect(send_payment, delete_record),
+    input_guardrails=[forge.input_guardrail()],  # also screen agent input
+)
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `VERITERA_API_KEY` | Your Forge API key (starts with `vt_live_` or `vt_test_`) |
+
+## License
+
+MIT — [Veritera AI](https://veritera.ai)

forge_openai-0.1.0/forge_openai/__init__.py

@@ -0,0 +1,36 @@
+"""Forge Verify guardrail for OpenAI Agents SDK.
+
+Verify every AI agent tool call against your policies before execution.
+
+Usage:
+    from forge_openai import forge_tool_guardrail, forge_protect
+
+    # Option 1: Attach guardrail to individual tools
+    guardrail = forge_tool_guardrail(policy="finance-controls")
+
+    @function_tool(tool_input_guardrails=[guardrail])
+    def send_payment(amount: float, to: str) -> str:
+        ...
+
+    # Option 2: Protect all tools at once
+    agent = Agent(
+        name="finance-bot",
+        tools=forge_protect(send_payment, read_balance, policy="finance-controls"),
+    )
+"""
+
+__version__ = "0.1.0"
+
+from .guardrail import (
+    ForgeGuardrail,
+    forge_tool_guardrail,
+    forge_protect,
+    forge_input_guardrail,
+)
+
+__all__ = [
+    "ForgeGuardrail",
+    "forge_tool_guardrail",
+    "forge_protect",
+    "forge_input_guardrail",
+]

forge_openai-0.1.0/forge_openai/guardrail.py

@@ -0,0 +1,312 @@
+"""Forge Verify guardrails for OpenAI Agents SDK.
+
+Provides ToolInputGuardrail (pre-tool) and InputGuardrail (pre-agent)
+that call the Forge /v1/verify API before execution proceeds.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import logging
+import os
+from typing import Any, Optional
+
+from veritera import Forge, ForgeError
+
+from agents import (
+    Agent,
+    FunctionTool,
+    GuardrailFunctionOutput,
+    InputGuardrail,
+    RunContextWrapper,
+    ToolInputGuardrail,
+    ToolInputGuardrailData,
+    ToolGuardrailFunctionOutput,
+)
+
+logger = logging.getLogger("forge_openai")
+
+
+class ForgeGuardrail:
+    """Configurable Forge verification client for OpenAI Agents SDK.
+
+    Args:
+        api_key: Forge API key (or set VERITERA_API_KEY env var).
+        base_url: Forge API endpoint.
+        agent_id: Identifier for this agent in Forge audit logs.
+        policy: Default policy to evaluate against.
+        fail_closed: If True (default), deny actions when Forge API is unreachable.
+        timeout: Request timeout in seconds.
+        skip_actions: Tool names to skip verification for (e.g. read-only tools).
+        on_verified: Callback(action, result) when a tool call is approved.
+        on_blocked: Callback(action, reason, result) when a tool call is denied.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://veritera.ai",
+        agent_id: str = "openai-agent",
+        policy: Optional[str] = None,
+        fail_closed: bool = True,
+        timeout: float = 10.0,
+        skip_actions: Optional[list[str]] = None,
+        on_verified: Optional[Any] = None,
+        on_blocked: Optional[Any] = None,
+    ):
+        key = api_key or os.environ.get("VERITERA_API_KEY", "")
+        if not key:
+            raise ValueError(
+                "Forge API key required. Pass api_key= or set VERITERA_API_KEY env var."
+            )
+        self._client = Forge(
+            api_key=key,
+            base_url=base_url,
+            timeout=timeout,
+            fail_closed=fail_closed,
+        )
+        self.agent_id = agent_id
+        self.policy = policy
+        self.fail_closed = fail_closed
+        self.skip_actions = set(skip_actions or [])
+        self.on_verified = on_verified
+        self.on_blocked = on_blocked
+
+    def tool_guardrail(self) -> ToolInputGuardrail:
+        """Create a ToolInputGuardrail that verifies each tool call through Forge.
+
+        Attach to individual tools:
+            @function_tool(tool_input_guardrails=[guard.tool_guardrail()])
+            def send_email(...): ...
+
+        Or use forge_protect() to attach to multiple tools at once.
+        """
+
+        async def _verify_tool(
+            data: ToolInputGuardrailData,
+        ) -> ToolGuardrailFunctionOutput:
+            tool_name = data.context.tool_name
+
+            # Skip configured actions
+            if tool_name in self.skip_actions:
+                return ToolGuardrailFunctionOutput.allow(
+                    output_info={"skipped": True, "action": tool_name}
+                )
+
+            # Parse tool arguments
+            try:
+                params = (
+                    json.loads(data.context.tool_arguments)
+                    if data.context.tool_arguments
+                    else {}
+                )
+            except (json.JSONDecodeError, TypeError):
+                params = {"raw": data.context.tool_arguments}
+
+            # Call Forge /v1/verify
+            try:
+                result = await self._client.verify_decision(
+                    agent_id=self.agent_id,
+                    action=tool_name,
+                    params=params,
+                    policy=self.policy,
+                )
+            except Exception as exc:
+                logger.error("Forge verify error for %s: %s", tool_name, exc)
+                if self.fail_closed:
+                    if self.on_blocked:
+                        self.on_blocked(tool_name, str(exc), None)
+                    return ToolGuardrailFunctionOutput.reject_content(
+                        message=f"Action '{tool_name}' blocked — policy verification unavailable.",
+                        output_info={"error": str(exc), "fail_mode": "closed"},
+                    )
+                return ToolGuardrailFunctionOutput.allow(
+                    output_info={"error": str(exc), "fail_mode": "open"}
+                )
+
+            if result.verified:
+                logger.debug("Forge APPROVED: %s (proof=%s)", tool_name, result.proof_id)
+                if self.on_verified:
+                    self.on_verified(tool_name, result)
+                return ToolGuardrailFunctionOutput.allow(
+                    output_info={
+                        "verified": True,
+                        "proof_id": result.proof_id,
+                        "latency_ms": result.latency_ms,
+                    }
+                )
+
+            reason = result.reason or "Policy violation"
+            logger.warning("Forge DENIED: %s — %s", tool_name, reason)
+            if self.on_blocked:
+                self.on_blocked(tool_name, reason, result)
+            return ToolGuardrailFunctionOutput.reject_content(
+                message=f"Action '{tool_name}' denied by Forge: {reason}",
+                output_info={
+                    "verified": False,
+                    "reason": reason,
+                    "proof_id": result.proof_id,
+                    "latency_ms": result.latency_ms,
+                },
+            )
+
+        return ToolInputGuardrail(
+            guardrail_function=_verify_tool,
+            name="forge_verify",
+        )
+
+    def input_guardrail(self) -> InputGuardrail:
+        """Create an InputGuardrail that screens agent input through Forge.
+
+        Useful for blocking entire conversation turns based on policy.
+        """
+
+        async def _screen_input(
+            ctx: RunContextWrapper, agent: Agent, input: Any
+        ) -> GuardrailFunctionOutput:
+            input_text = str(input) if input else ""
+            try:
+                result = await self._client.verify_decision(
+                    agent_id=self.agent_id,
+                    action="agent.input",
+                    params={"input": input_text[:2000]},
+                    policy=self.policy,
+                )
+                return GuardrailFunctionOutput(
+                    output_info={
+                        "verified": result.verified,
+                        "reason": result.reason,
+                    },
+                    tripwire_triggered=not result.verified,
+                )
+            except Exception as exc:
+                logger.error("Forge input guardrail error: %s", exc)
+                return GuardrailFunctionOutput(
+                    output_info={"error": str(exc)},
+                    tripwire_triggered=self.fail_closed,
+                )
+
+        return InputGuardrail(
+            guardrail_function=_screen_input,
+            name="forge_input_screen",
+        )
+
+    def protect(self, *tools: FunctionTool, policy: Optional[str] = None) -> list[FunctionTool]:
+        """Attach Forge guardrail to multiple tools at once.
+
+        Returns new tool instances — originals are not mutated.
+        """
+        guardrail = self.tool_guardrail()
+        if policy and policy != self.policy:
+            # Create a separate guardrail with the override policy
+            original_policy = self.policy
+            self.policy = policy
+            guardrail = self.tool_guardrail()
+            self.policy = original_policy
+
+        protected = []
+        for tool in tools:
+            t = copy.copy(tool)
+            existing = list(t.tool_input_guardrails or [])
+            existing.append(guardrail)
+            t.tool_input_guardrails = existing
+            protected.append(t)
+        return protected
+
+
+# ── Convenience functions ──
+
+
+def forge_tool_guardrail(
+    api_key: Optional[str] = None,
+    base_url: str = "https://veritera.ai",
+    agent_id: str = "openai-agent",
+    policy: Optional[str] = None,
+    fail_closed: bool = True,
+    timeout: float = 10.0,
+    skip_actions: Optional[list[str]] = None,
+    on_verified: Optional[Any] = None,
+    on_blocked: Optional[Any] = None,
+) -> ToolInputGuardrail:
+    """Create a ToolInputGuardrail that verifies tool calls through Forge.
+
+    Usage:
+        guardrail = forge_tool_guardrail(policy="finance-controls")
+
+        @function_tool(tool_input_guardrails=[guardrail])
+        def send_payment(amount: float, recipient: str) -> str:
+            \"\"\"Send a payment.\"\"\"
+            return process_payment(amount, recipient)
+    """
+    guard = ForgeGuardrail(
+        api_key=api_key,
+        base_url=base_url,
+        agent_id=agent_id,
+        policy=policy,
+        fail_closed=fail_closed,
+        timeout=timeout,
+        skip_actions=skip_actions,
+        on_verified=on_verified,
+        on_blocked=on_blocked,
+    )
+    return guard.tool_guardrail()
+
+
+def forge_input_guardrail(
+    api_key: Optional[str] = None,
+    base_url: str = "https://veritera.ai",
+    agent_id: str = "openai-agent",
+    policy: Optional[str] = None,
+    fail_closed: bool = True,
+) -> InputGuardrail:
+    """Create an InputGuardrail that screens agent input through Forge.
+
+    Usage:
+        agent = Agent(
+            name="my-agent",
+            input_guardrails=[forge_input_guardrail(policy="content-policy")],
+            tools=[...],
+        )
+    """
+    guard = ForgeGuardrail(
+        api_key=api_key,
+        base_url=base_url,
+        agent_id=agent_id,
+        policy=policy,
+        fail_closed=fail_closed,
+    )
+    return guard.input_guardrail()
+
+
+def forge_protect(
+    *tools: FunctionTool,
+    api_key: Optional[str] = None,
+    base_url: str = "https://veritera.ai",
+    agent_id: str = "openai-agent",
+    policy: Optional[str] = None,
+    fail_closed: bool = True,
+    timeout: float = 10.0,
+    skip_actions: Optional[list[str]] = None,
+) -> list[FunctionTool]:
+    """Attach Forge verification to multiple tools at once.
+
+    Usage:
+        agent = Agent(
+            name="finance-bot",
+            tools=forge_protect(
+                send_payment, read_balance, delete_record,
+                policy="finance-controls",
+            ),
+        )
+    """
+    guard = ForgeGuardrail(
+        api_key=api_key,
+        base_url=base_url,
+        agent_id=agent_id,
+        policy=policy,
+        fail_closed=fail_closed,
+        timeout=timeout,
+        skip_actions=skip_actions,
+    )
+    return guard.protect(*tools)

forge_openai-0.1.0/forge_openai.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: forge-openai
+Version: 0.1.0
+Summary: Forge Verify guardrail for OpenAI Agents SDK — verify every tool call before execution
+Author-email: Veritera AI <engineering@veritera.ai>
+License: MIT
+Project-URL: Homepage, https://veritera.ai
+Project-URL: Documentation, https://veritera.ai/docs
+Project-URL: Repository, https://github.com/VeriteraAI/forge-openai
+Keywords: veritera,forge,openai,agents,guardrail,verification,ai-safety
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: veritera>=0.2.0
+Requires-Dist: openai-agents>=0.1.0
+
+# forge-openai
+
+Forge Verify guardrail for the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python). Verifies every AI agent tool call against your policies **before** execution.
+
+## Install
+
+```bash
+pip install forge-openai
+```
+
+## Quick Start
+
+```python
+import os
+from agents import Agent, Runner, function_tool
+from forge_openai import forge_tool_guardrail, forge_protect
+
+os.environ["VERITERA_API_KEY"] = "vt_live_..."
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+# Define your tools
+@function_tool
+def send_payment(amount: float, recipient: str) -> str:
+    """Send a payment to a recipient."""
+    return f"Sent ${amount} to {recipient}"
+
+@function_tool
+def delete_record(record_id: str) -> str:
+    """Delete a database record."""
+    return f"Deleted {record_id}"
+
+@function_tool
+def read_balance() -> str:
+    """Check account balance."""
+    return "Balance: $50,000"
+
+# Protect all tools with Forge — one line
+agent = Agent(
+    name="finance-bot",
+    instructions="You help with financial operations.",
+    tools=forge_protect(
+        send_payment, delete_record, read_balance,
+        policy="finance-controls",
+        skip_actions=["read_balance"],  # read-only tools don't need verification
+    ),
+)
+
+# Run the agent — Forge checks every tool call automatically
+result = await Runner.run(agent, "Send $500 to vendor@acme.com")
+```
+
+## How It Works
+
+1. Your agent decides to call a tool (e.g. `send_payment`)
+2. **Before execution**, Forge checks the action against your policies
+3. If **approved**: the tool runs normally
+4. If **denied**: the LLM receives a denial message and can explain why to the user
+
+No tool ever executes without verification. Every decision is logged with a cryptographic proof.
+
+## Per-Tool Guardrail
+
+```python
+from forge_openai import forge_tool_guardrail
+
+guardrail = forge_tool_guardrail(policy="email-controls")
+
+@function_tool(tool_input_guardrails=[guardrail])
+def send_email(to: str, subject: str, body: str) -> str:
+    """Send an email."""
+    return f"Email sent to {to}"
+```
+
+## Full Control
+
+```python
+from forge_openai import ForgeGuardrail
+
+forge = ForgeGuardrail(
+    api_key="vt_live_...",
+    agent_id="prod-finance-bot",
+    policy="finance-controls",
+    fail_closed=True,
+    skip_actions=["read_balance", "get_time"],
+    on_blocked=lambda action, reason, result: print(f"BLOCKED: {action} — {reason}"),
+    on_verified=lambda action, result: print(f"APPROVED: {action}"),
+)
+
+agent = Agent(
+    name="finance-bot",
+    tools=forge.protect(send_payment, delete_record),
+    input_guardrails=[forge.input_guardrail()],  # also screen agent input
+)
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `VERITERA_API_KEY` | Your Forge API key (starts with `vt_live_` or `vt_test_`) |
+
+## License
+
+MIT — [Veritera AI](https://veritera.ai)

forge_openai-0.1.0/forge_openai.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+forge_openai/__init__.py
+forge_openai/guardrail.py
+forge_openai.egg-info/PKG-INFO
+forge_openai.egg-info/SOURCES.txt
+forge_openai.egg-info/dependency_links.txt
+forge_openai.egg-info/requires.txt
+forge_openai.egg-info/top_level.txt

forge_openai-0.1.0/forge_openai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

forge_openai-0.1.0/forge_openai.egg-info/requires.txt

@@ -0,0 +1,2 @@
+veritera>=0.2.0
+openai-agents>=0.1.0

forge_openai-0.1.0/forge_openai.egg-info/top_level.txt

@@ -0,0 +1 @@
+forge_openai

forge_openai-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "forge-openai"
+version = "0.1.0"
+description = "Forge Verify guardrail for OpenAI Agents SDK — verify every tool call before execution"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{name = "Veritera AI", email = "engineering@veritera.ai"}]
+keywords = ["veritera", "forge", "openai", "agents", "guardrail", "verification", "ai-safety"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "veritera>=0.2.0",
+    "openai-agents>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://veritera.ai"
+Documentation = "https://veritera.ai/docs"
+Repository = "https://github.com/VeriteraAI/forge-openai"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["forge_openai*"]

forge_openai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+