Record logs into step artifacts

skyvern-frontend/src/api/types.ts

@@ -10,6 +10,8 @@ export const ArtifactType = {
   LLMPrompt: "llm_prompt",
   LLMRequest: "llm_request",
   HTMLScrape: "html_scrape",
+  SkyvernLog: "skyvern_log",
+  SkyvernLogRaw: "skyvern_log_raw",
 } as const;
 
 export type ArtifactType = (typeof ArtifactType)[keyof typeof ArtifactType];

skyvern-frontend/src/routes/tasks/detail/StepArtifacts.tsx

@@ -79,6 +79,10 @@ function StepArtifacts({ id, stepProps }: Props) {
     (artifact) => artifact.artifact_type === ArtifactType.HTMLScrape,
   );
 
+  const skyvernLog = artifacts?.filter(
+    (artifact) => artifact.artifact_type === ArtifactType.SkyvernLog,
+  );
+
   return (
     <Tabs
       value={artifact}
@@ -108,6 +112,7 @@ function StepArtifacts({ id, stepProps }: Props) {
         <TabsTrigger value="llm_response_parsed">Action List</TabsTrigger>
         <TabsTrigger value="html_raw">HTML (Raw)</TabsTrigger>
         <TabsTrigger value="llm_request">LLM Request (Raw)</TabsTrigger>
+        <TabsTrigger value="skyvern_log">Skyvern Log</TabsTrigger>
       </TabsList>
       <TabsContent value="info">
         <div className="flex flex-col gap-6 p-4">
@@ -209,6 +214,9 @@ function StepArtifacts({ id, stepProps }: Props) {
       <TabsContent value="llm_request">
         {llmRequest ? <Artifact type="json" artifacts={llmRequest} /> : null}
       </TabsContent>
+      <TabsContent value="skyvern_log">
+        {skyvernLog ? <Artifact type="text" artifacts={skyvernLog} /> : null}
+      </TabsContent>
     </Tabs>
   );
 }

skyvern/forge/agent.py

@@ -72,6 +72,8 @@
 from skyvern.webeye.browser_factory import BrowserState
 from skyvern.webeye.scraper.scraper import ElementTreeFormat, ScrapedPage, scrape_website
 from skyvern.webeye.utils.page import SkyvernFrame
+from skyvern.forge.skyvern_json_encoder import SkyvernJSONLogEncoder
+from skyvern.forge.skyvern_log_encoder import SkyvernLogEncoder
 
 LOG = structlog.get_logger()
 
@@ -929,7 +931,6 @@ async def agent_step(
                         complete_action.task_id = task.task_id
                         complete_action.step_id = step.step_id
                         complete_action.step_order = step.order
-                        complete_action.action_order = len(detailed_agent_step_output.actions_and_results)
                         complete_results = await ActionHandler.handle_action(
                             scraped_page, task, step, working_page, complete_action
                         )
@@ -1773,6 +1774,32 @@ async def update_step(
             step_id=step.step_id,
             diff=update_comparison,
         )
+
+        try:
+            log = skyvern_context.current().log
+            current_step_log = [entry for entry in log if entry.get("step_id", "") == step.step_id]
+
+            log_json = json.dumps(current_step_log, cls=SkyvernJSONLogEncoder, indent=2)
+            await app.ARTIFACT_MANAGER.create_artifact(
+                step=step,
+                artifact_type=ArtifactType.SKYVERN_LOG_RAW,
+                data=log_json.encode(),
+            )
+
+            formatted_log = SkyvernLogEncoder.encode(current_step_log)
+            await app.ARTIFACT_MANAGER.create_artifact(
+                step=step,
+                artifact_type=ArtifactType.SKYVERN_LOG,
+                data=formatted_log.encode(),
+            )
+        except Exception:
+            LOG.error(
+                "Failed to record skyvern log after action",
+                task_id=step.task_id,
+                step_id=step.step_id,
+                exc_info=True,
+            )
+
         return await app.DATABASE.update_step(
             task_id=step.task_id,
             step_id=step.step_id,

skyvern/forge/sdk/artifact/models.py

@@ -10,6 +10,9 @@ class ArtifactType(StrEnum):
     RECORDING = "recording"
     BROWSER_CONSOLE_LOG = "browser_console_log"
 
+    SKYVERN_LOG = "skyvern_log"
+    SKYVERN_LOG_RAW = "skyvern_log_raw"
+
     # DEPRECATED. pls use SCREENSHOT_LLM, SCREENSHOT_ACTION or SCREENSHOT_FINAL
     SCREENSHOT = "screenshot"
 

skyvern/forge/sdk/artifact/storage/base.py

@@ -10,6 +10,8 @@
     ArtifactType.SCREENSHOT_LLM: "png",
     ArtifactType.SCREENSHOT_ACTION: "png",
     ArtifactType.SCREENSHOT_FINAL: "png",
+    ArtifactType.SKYVERN_LOG: "log",
+    ArtifactType.SKYVERN_LOG_RAW: "json",
     ArtifactType.LLM_PROMPT: "txt",
     ArtifactType.LLM_REQUEST: "json",
     ArtifactType.LLM_RESPONSE: "json",

skyvern/forge/sdk/core/skyvern_context.py

@@ -11,6 +11,7 @@ class SkyvernContext:
     workflow_run_id: str | None = None
     max_steps_override: int | None = None
     totp_codes: dict[str, str | None] = field(default_factory=dict)
+    log: list[dict] = field(default_factory=list)
 
     def __repr__(self) -> str:
         return f"SkyvernContext(request_id={self.request_id}, organization_id={self.organization_id}, task_id={self.task_id}, workflow_id={self.workflow_id}, workflow_run_id={self.workflow_run_id}, max_steps_override={self.max_steps_override})"

skyvern/forge/sdk/forge_log.py

@@ -54,6 +54,21 @@ def add_kv_pairs_to_msg(logger: logging.Logger, method_name: str, event_dict: Ev
     return event_dict
 
 
+def skyvern_logs_processor(logger: logging.Logger, method_name: str, event_dict: EventDict) -> EventDict:
+    """
+    A custom processor to add skyvern logs to the context
+    """
+    if method_name not in ["info", "warning", "error", "critical", "exception"]:
+        return event_dict
+
+    context = skyvern_context.current()
+    if context:
+        log_entry = dict(event_dict)
+        context.log.append(log_entry)
+
+    return event_dict
+
+
 def setup_logger() -> None:
     """
     Setup the logger with the specified format
@@ -88,7 +103,7 @@ def setup_logger() -> None:
             structlog.processors.format_exc_info,
         ]
         + additional_processors
-        + [renderer],
+        + [skyvern_logs_processor, renderer],
     )
     uvicorn_error = logging.getLogger("uvicorn.error")
     uvicorn_error.disabled = True

skyvern/forge/skyvern_json_encoder.py

@@ -0,0 +1,22 @@
+import json
+from typing import Any
+
+class SkyvernJSONLogEncoder(json.JSONEncoder):
+    """Custom JSON encoder for Skyvern logs that handles non-serializable objects"""
+    def default(self, obj: Any) -> Any:
+        if hasattr(obj, 'model_dump'):
+            return obj.model_dump()
+
+        if hasattr(obj, '__dataclass_fields__'):
+            return {k: getattr(obj, k) for k in obj.__dataclass_fields__}
+
+        if hasattr(obj, '__dict__'):
+            return {
+                'type': obj.__class__.__name__,
+                'attributes': {k: v for k, v in obj.__dict__.items() if not k.startswith('_')}
+            }
+        # Handle other non-serializable objects
+        try:
+            return str(obj)
+        except Exception:
+            return f"<non-serializable-{obj.__class__.__name__}>"

skyvern/forge/skyvern_log_encoder.py

@@ -0,0 +1,87 @@
+from typing import Any, Dict, List
+from datetime import datetime
+import json
+
+from structlog.dev import ConsoleRenderer
+
+LOG = structlog.get_logger()
+
+class SkyvernLogEncoder:
+    """Encodes Skyvern logs from JSON format to human-readable string format"""
+
+    def __init__(self):
+        self.renderer = ConsoleRenderer(
+            pad_event=30,
+            colors=False,
+        )
+
+    @staticmethod
+    def _format_value(value: Any) -> str:
+        """Format complex values into readable strings."""
+        if isinstance(value, (dict, list)):
+            return json.dumps(value, sort_keys=True)
+        return str(value)
+
+    @staticmethod
+    def _parse_json_entry(entry: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert a JSON log entry into our standard format."""
+        event = entry.get('message', entry.get('event', ''))
+
+        clean_entry = {
+            'timestamp': entry.get('timestamp', datetime.utcnow().isoformat() + "Z"),
+            'level': entry.get('level', 'info').lower(),
+            'event': event
+        }
+
+        for key, value in entry.items():
+            if key not in ('timestamp', 'level', 'event', 'message'):
+                clean_entry[key] = SkyvernLogEncoder._format_value(value)
+
+        return clean_entry
+
+    @classmethod
+    def encode(cls, log_entries: List[Dict[str, Any]]) -> str:
+        """
+        Encode log entries into formatted string output using structlog's ConsoleRenderer.
+
+        Args:
+            log_entries: List of log entry dictionaries
+
+        Returns:
+            Formatted string with one log entry per line
+        """
+        encoder = cls()
+        formatted_lines = []
+
+        for entry in log_entries:
+            try:
+                if isinstance(entry, str):
+                    try:
+                        entry = json.loads(entry)
+                    except json.JSONDecodeError:
+                        entry = {'event': entry, 'level': 'info'}
+
+                parsed_entry = cls._parse_json_entry(entry)
+
+                formatted_line = encoder.renderer(None, None, parsed_entry)
+                formatted_lines.append(formatted_line)
+
+            except Exception as e:
+                LOG.error(
+                    "Failed to format log entry",
+                    entry=entry,
+                    error=str(e),
+                    exc_info=True
+                )
+                # Add error line to output
+                error_timestamp = datetime.utcnow().isoformat() + "Z"
+                error_entry = {
+                    'timestamp': error_timestamp,
+                    'level': 'error',
+                    'event': 'Failed to format log entry',
+                    'entry': str(entry),
+                    'error': str(e)
+                }
+                formatted_lines.append(encoder.renderer(None, None, error_entry))
+
+        return "\n".join(formatted_lines)