refactor: remove AgentRunLog related code and components

- Deleted AgentRunLogResponse struct from skill_response.go.
- Removed agent_run_log_repository.go and agent_run_log_service.go files.
- Eliminated AgentRunLogDetailDialog component and its related logic from the dashboard.
- Removed agent run log fetching functions from admin API.
- Updated navigation and localization files to remove references to agent run logs.

internal/ai/runtime/reply_helpers_test.go

@@ -1,7 +1,6 @@
 package runtime
 
 import (
-	"strings"
 	"testing"
 
 	applicationruntime "agent-desk/internal/ai/application/runtime"
@@ -9,64 +8,33 @@ import (
 	"agent-desk/internal/pkg/toolx"
 )
 
-func TestSummaryPrimaryToolCodePrefersToolSearchTarget(t *testing.T) {
-	summary := &applicationruntime.Summary{
-		InvokedToolCodes: []string{toolx.BuiltinToolSearch.Code},
-		TraceData: `{
-			"toolSearch": {
-				"items": [
-					{"targetToolCode":"mcp/server/tool_a"}
-				]
-			}
-		}`,
+func TestRuntimeTraceFinalAction(t *testing.T) {
+	if got := runtimeTraceFinalAction(&applicationruntime.Summary{Status: "completed", ReplyText: "ok"}); got != "reply" {
+		t.Fatalf("expected reply final action, got %q", got)
 	}
-
-	if got := summaryPrimaryToolCode(summary); got != "mcp/server/tool_a" {
-		t.Fatalf("unexpected primary tool code: %q", got)
+	if got := runtimeTraceFinalAction(&applicationruntime.Summary{Status: "completed"}); got != "completed" {
+		t.Fatalf("expected completed final action, got %q", got)
 	}
-}
-
-func TestToRunLogFinalAction(t *testing.T) {
-	if got := toRunLogFinalAction(&applicationruntime.Summary{WorkflowVersionID: 66, ReplyText: "ok"}); got != "workflow_reply" {
-		t.Fatalf("expected workflow_reply final action, got %q", got)
-	}
-
-	if got := toRunLogFinalAction(&applicationruntime.Summary{PlannedSkillID: 44, ReplyText: "ok"}); got != "skill" {
-		t.Fatalf("expected skill final action, got %q", got)
-	}
-
-	graphSummary := &applicationruntime.Summary{
-		ReplyText: "ok",
-		TraceData: `{
-			"graphTools": {
-				"items": [
-					{"toolCode":"` + toolx.GraphAnalyzeConversation.Code + `"}
-				]
-			}
-		}`,
-	}
-	if got := toRunLogFinalAction(graphSummary); got != "graph" {
-		t.Fatalf("expected graph final action, got %q", got)
-	}
-
-	if got := toRunLogFinalAction(&applicationruntime.Summary{Status: "fallback"}); got != "fallback" {
+	if got := runtimeTraceFinalAction(&applicationruntime.Summary{Status: "fallback"}); got != "fallback" {
 		t.Fatalf("expected fallback final action, got %q", got)
 	}
 }
 
-func TestBuildRunLogPlanUsesWorkflowSummary(t *testing.T) {
-	plannedAction, plannedToolCode, planReason := buildRunLogPlan(&applicationruntime.Summary{
-		WorkflowVersionID: 66,
-		Status:            "completed",
-	})
-	if plannedAction != "workflow" {
-		t.Fatalf("expected workflow planned action, got %q", plannedAction)
+func TestExtractRuntimeToolTraces(t *testing.T) {
+	summary := &applicationruntime.Summary{
+		TraceData: `{
+			"toolSearch": {"items": [{"targetToolCode":"mcp/server/tool_a"}]},
+			"graphTools": {"items": [{"toolCode":"` + toolx.GraphAnalyzeConversation.Code + `"}]}
+		}`,
 	}
-	if plannedToolCode != "workflow/66" {
-		t.Fatalf("expected workflow planned tool code, got %q", plannedToolCode)
+	if got := extractToolSearchTrace(summary); got == "" {
+		t.Fatalf("expected tool search trace")
 	}
-	if planReason == "" {
-		t.Fatalf("expected plan reason")
+	if got := extractGraphToolTrace(summary); got == "" {
+		t.Fatalf("expected graph tool trace")
+	}
+	if got := firstGraphToolCode(summary); got != toolx.GraphAnalyzeConversation.Code {
+		t.Fatalf("unexpected graph tool code: %q", got)
 	}
 }
 
@@ -103,44 +71,6 @@ func TestBuildConversationInterruptStoresWorkflowCheckpointData(t *testing.T) {
 	}
 }
 
-func TestGraphPlanReason(t *testing.T) {
-	summary := &applicationruntime.Summary{
-		TraceData: `{
-			"graphTools": {
-				"items": [
-					{
-						"toolCode":"` + toolx.GraphTriageServiceRequest.Code + `",
-						"recommendedAction":"create_ticket",
-						"ticketDraftReady": true
-					}
-				]
-			}
-		}`,
-	}
-	got := graphPlanReason(summary)
-	if !strings.Contains(got, "create_ticket") || !strings.Contains(got, "ready ticket draft") {
-		t.Fatalf("unexpected graph plan reason: %q", got)
-	}
-}
-
-func TestExtractHandoffReason(t *testing.T) {
-	summary := &applicationruntime.Summary{
-		TraceData: `{
-			"graphTools": {
-				"items": [
-					{
-						"toolCode":"` + toolx.GraphHandoffConversation.Code + `",
-						"arguments":{"reason":"  用户明确要求人工处理  "}
-					}
-				]
-			}
-		}`,
-	}
-	if got := extractHandoffReason(summary); got != "用户明确要求人工处理" {
-		t.Fatalf("unexpected handoff reason: %q", got)
-	}
-}
-
 type fakeErr string
 
 func (e fakeErr) Error() string {

internal/ai/runtime/reply_runlog_service.go

@@ -1,407 +0,0 @@
-package runtime
-
-import (
-	"encoding/json"
-	"log/slog"
-	"strconv"
-	"strings"
-	"time"
-
-	applicationruntime "agent-desk/internal/ai/application/runtime"
-	"agent-desk/internal/models"
-	"agent-desk/internal/pkg/toolx"
-	svc "agent-desk/internal/services"
-)
-
-func newReplyRunLogService() *replyRunLogService {
-	return &replyRunLogService{}
-}
-
-type replyRunLogService struct{}
-
-type replyRunLogInput struct {
-	StartedAt    time.Time
-	Message      models.Message
-	Conversation models.Conversation
-	AIAgent      models.AIAgent
-	Question     string
-	RunErr       error
-	Trace        *aiReplyTraceData
-	Summary      *applicationruntime.Summary
-}
-
-func (s *replyRunLogService) Write(input replyRunLogInput) {
-	errorMessage := ""
-	if input.RunErr != nil {
-		errorMessage = input.RunErr.Error()
-	} else if input.Summary != nil && strings.TrimSpace(input.Summary.ErrorMessage) != "" {
-		errorMessage = strings.TrimSpace(input.Summary.ErrorMessage)
-	}
-	traceData := buildAIReplyTraceData(input.Trace)
-	plannedAction, plannedToolCode, planReason := buildRunLogPlan(input.Summary)
-	logItem := &models.AgentRunLog{
-		ConversationID:   input.Conversation.ID,
-		MessageID:        input.Message.ID,
-		RequestID:        input.Message.RequestID,
-		AIAgentID:        input.AIAgent.ID,
-		AIConfigID:       input.AIAgent.AIConfigID,
-		UserMessage:      strings.TrimSpace(input.Question),
-		PlannedAction:    plannedAction,
-		PlannedSkillID:   summaryPlannedSkillID(input.Summary),
-		PlannedSkillName: strings.TrimSpace(summaryPlannedSkillName(input.Summary)),
-		SkillRouteTrace:  strings.TrimSpace(summarySkillRouteTrace(input.Summary)),
-		ToolSearchTrace:  extractToolSearchTrace(input.Summary),
-		GraphToolTrace:   extractGraphToolTrace(input.Summary),
-		GraphToolCode:    firstGraphToolCode(input.Summary),
-		HandoffReason:    extractHandoffReason(input.Summary),
-		PlannedToolCode:  plannedToolCode,
-		PlanReason:       planReason,
-		InterruptType:    firstInterruptType(input.Summary),
-		ResumeSource:     runLogResumeSource(input.Trace),
-		FinalAction:      toRunLogFinalAction(input.Summary),
-		FinalStatus:      runLogFinalStatus(input.Summary),
-		ReplyText:        buildRunLogReplyText(input.Summary),
-		ErrorMessage:     errorMessage,
-		LatencyMs:        time.Since(input.StartedAt).Milliseconds(),
-		TraceData:        traceData,
-		CreatedAt:        time.Now(),
-	}
-	if err := svc.AgentRunLogService.Create(logItem); err != nil {
-		slog.Warn("create agent run log failed",
-			"requestId", input.Message.RequestID,
-			"message_id", input.Message.ID,
-			"conversation_id", logItem.ConversationID,
-			"ai_agent_id", input.AIAgent.ID,
-			"error", err)
-	}
-}
-
-func buildAIReplyTraceData(trace *aiReplyTraceData) string {
-	if trace == nil {
-		return ""
-	}
-	data, err := json.Marshal(trace)
-	if err != nil {
-		return ""
-	}
-	return string(data)
-}
-
-func buildRunLogPlan(summary *applicationruntime.Summary) (plannedAction, plannedToolCode, planReason string) {
-	if summary == nil {
-		return "", "", ""
-	}
-	if isWorkflowSummary(summary) {
-		return "workflow", workflowPlannedToolCode(summary), "workflow executed"
-	}
-	if summaryPlannedSkillID(summary) > 0 {
-		reason := strings.TrimSpace(summary.PlanReason)
-		if reason == "" {
-			reason = "skill_selected"
-		}
-		return "skill", "", reason
-	}
-	if strings.TrimSpace(summary.Status) == "expired" {
-		return "interrupt", "", "pending interrupt checkpoint expired"
-	}
-	if summary.Interrupted {
-		if graphToolCode := firstGraphToolCode(summary); graphToolCode != "" {
-			reason := graphPlanReason(summary)
-			if reason == "" {
-				reason = "graph tool interrupted and is waiting for user confirmation"
-			}
-			return "graph", graphToolCode, reason
-		}
-		return "tool", summaryPrimaryToolCode(summary), "agent interrupted and is waiting for user confirmation"
-	}
-	if len(summary.InvokedToolCodes) > 0 {
-		if graphToolCode := firstGraphToolCode(summary); graphToolCode != "" {
-			reason := graphPlanReason(summary)
-			if reason == "" {
-				reason = "agent invoked graph tool"
-			}
-			return "graph", graphToolCode, reason
-		}
-		toolCode := summaryPrimaryToolCode(summary)
-		reason := "agent invoked MCP tool"
-		if toolCode != "" && toolCode != firstInvokedToolCode(summary) {
-			reason = "agent invoked dynamic tool via tool_search"
-		}
-		return "tool", toolCode, reason
-	}
-	if strings.TrimSpace(summary.ReplyText) != "" {
-		return "reply", "", "agent replied directly"
-	}
-	if strings.TrimSpace(summary.ErrorMessage) != "" {
-		return "error", "", "runtime execution failed"
-	}
-	return "fallback", "", "runtime produced empty reply"
-}
-
-func toRunLogFinalAction(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	if isWorkflowSummary(summary) {
-		return workflowFinalAction(summary)
-	}
-	if summaryPlannedSkillID(summary) > 0 && strings.TrimSpace(summary.ReplyText) != "" {
-		return "skill"
-	}
-	if graphToolCode := firstGraphToolCode(summary); graphToolCode != "" && strings.TrimSpace(summary.ReplyText) != "" {
-		return "graph"
-	}
-	switch strings.TrimSpace(summary.Status) {
-	case "completed":
-		return "reply"
-	case "fallback":
-		return "fallback"
-	case "error":
-		return "error"
-	case "interrupted":
-		return "interrupted"
-	case "expired":
-		return "expired"
-	default:
-		return strings.TrimSpace(summary.Status)
-	}
-}
-
-func isWorkflowSummary(summary *applicationruntime.Summary) bool {
-	return summary != nil && summary.WorkflowVersionID > 0
-}
-
-func workflowPlannedToolCode(summary *applicationruntime.Summary) string {
-	if summary == nil || summary.WorkflowVersionID <= 0 {
-		return ""
-	}
-	return "workflow/" + strconv.FormatInt(summary.WorkflowVersionID, 10)
-}
-
-func workflowFinalAction(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	switch strings.TrimSpace(summary.Status) {
-	case "interrupted":
-		return "workflow_interrupted"
-	case "error":
-		return "workflow_error"
-	case "expired":
-		return "workflow_expired"
-	}
-	if strings.TrimSpace(summary.ReplyText) != "" {
-		return "workflow_reply"
-	}
-	return "workflow_completed"
-}
-
-func buildRunLogReplyText(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	return strings.TrimSpace(summary.ReplyText)
-}
-
-func summaryPlannedSkillID(summary *applicationruntime.Summary) int64 {
-	if summary == nil {
-		return 0
-	}
-	return summary.PlannedSkillID
-}
-
-func summaryPlannedSkillName(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	return strings.TrimSpace(summary.PlannedSkillName)
-}
-
-func summarySkillRouteTrace(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	return strings.TrimSpace(summary.SkillRouteTrace)
-}
-
-func runLogResumeSource(trace *aiReplyTraceData) string {
-	if trace == nil {
-		return ""
-	}
-	return strings.TrimSpace(trace.ResumeSource)
-}
-
-func runLogFinalStatus(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	return strings.TrimSpace(summary.Status)
-}
-
-func summaryPrimaryToolCode(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	toolCode := firstInvokedToolCode(summary)
-	if toolCode != toolx.BuiltinToolSearch.Code {
-		return toolCode
-	}
-	if targetToolCode := firstToolSearchTargetToolCode(summary); targetToolCode != "" {
-		return targetToolCode
-	}
-	return toolCode
-}
-
-func extractToolSearchTrace(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	trace := parseRuntimeTraceData(summary.TraceData)
-	if len(trace.ToolSearch.Items) == 0 {
-		return ""
-	}
-	buf, err := json.Marshal(trace.ToolSearch)
-	if err != nil {
-		return ""
-	}
-	return string(buf)
-}
-
-func extractGraphToolTrace(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	trace := parseRuntimeTraceData(summary.TraceData)
-	if len(trace.GraphTools.Items) == 0 {
-		return ""
-	}
-	buf, err := json.Marshal(trace.GraphTools)
-	if err != nil {
-		return ""
-	}
-	return string(buf)
-}
-
-func firstToolSearchTargetToolCode(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	trace := parseRuntimeTraceData(summary.TraceData)
-	for _, item := range trace.ToolSearch.Items {
-		toolCode := strings.TrimSpace(item.TargetToolCode)
-		if toolCode != "" {
-			return toolCode
-		}
-		if len(item.CandidateToolCodes) == 1 {
-			toolCode = strings.TrimSpace(item.CandidateToolCodes[0])
-			if toolCode != "" {
-				return toolCode
-			}
-		}
-	}
-	return ""
-}
-
-func firstGraphToolCode(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	trace := parseRuntimeTraceData(summary.TraceData)
-	for _, item := range trace.GraphTools.Items {
-		toolCode := strings.TrimSpace(item.ToolCode)
-		if toolCode != "" {
-			return toolCode
-		}
-	}
-	return ""
-}
-
-func extractHandoffReason(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	trace := parseRuntimeTraceData(summary.TraceData)
-	for _, item := range trace.GraphTools.Items {
-		if strings.TrimSpace(item.ToolCode) != toolx.GraphHandoffConversation.Code {
-			continue
-		}
-		if len(item.Arguments) == 0 {
-			return ""
-		}
-		var args runtimeTraceHandoffArguments
-		if err := json.Unmarshal(item.Arguments, &args); err != nil {
-			return ""
-		}
-		return strings.TrimSpace(args.Reason)
-	}
-	return ""
-}
-
-func graphPlanReason(summary *applicationruntime.Summary) string {
-	if summary == nil {
-		return ""
-	}
-	trace := parseRuntimeTraceData(summary.TraceData)
-	for _, item := range trace.GraphTools.Items {
-		toolCode := strings.TrimSpace(item.ToolCode)
-		switch toolCode {
-		case toolx.GraphTriageServiceRequest.Code:
-			recommendedAction := strings.TrimSpace(item.RecommendedAction)
-			if recommendedAction == "" {
-				return "graph tool triaged service request"
-			}
-			if item.TicketDraftReady {
-				return "graph tool triaged service request: " + recommendedAction + " with ready ticket draft"
-			}
-			return "graph tool triaged service request: " + recommendedAction
-		case toolx.GraphAnalyzeConversation.Code:
-			recommendedAction := strings.TrimSpace(item.RecommendedAction)
-			riskLevel := strings.TrimSpace(item.RiskLevel)
-			switch {
-			case recommendedAction != "" && riskLevel != "":
-				return "graph tool analyzed conversation: " + recommendedAction + " (" + riskLevel + " risk)"
-			case recommendedAction != "":
-				return "graph tool analyzed conversation: " + recommendedAction
-			case riskLevel != "":
-				return "graph tool analyzed conversation (" + riskLevel + " risk)"
-			default:
-				return "graph tool analyzed conversation"
-			}
-		}
-	}
-	return ""
-}
-
-type runtimeTraceProjection struct {
-	ToolSearch struct {
-		Items []struct {
-			TargetToolCode     string   `json:"targetToolCode"`
-			CandidateToolCodes []string `json:"candidateToolCodes"`
-		} `json:"items"`
-	} `json:"toolSearch"`
-	GraphTools struct {
-		Items []struct {
-			ToolCode          string          `json:"toolCode"`
-			Arguments         json.RawMessage `json:"arguments"`
-			RecommendedAction string          `json:"recommendedAction"`
-			RiskLevel         string          `json:"riskLevel"`
-			TicketDraftReady  bool            `json:"ticketDraftReady"`
-		} `json:"items"`
-	} `json:"graphTools"`
-}
-
-type runtimeTraceHandoffArguments struct {
-	Reason string `json:"reason"`
-}
-
-func parseRuntimeTraceData(raw string) runtimeTraceProjection {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return runtimeTraceProjection{}
-	}
-	var trace runtimeTraceProjection
-	if err := json.Unmarshal([]byte(raw), &trace); err != nil {
-		return runtimeTraceProjection{}
-	}
-	return trace
-}

internal/ai/runtime/reply_runlog_service_test.go

@@ -1,57 +0,0 @@
-package runtime
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	"agent-desk/internal/models"
-	"agent-desk/internal/pkg/enums"
-
-	"github.com/glebarez/sqlite"
-	"github.com/mlogclub/simple/sqls"
-	"gorm.io/gorm"
-	"gorm.io/gorm/schema"
-)
-
-func TestReplyRunLogStoresRequestID(t *testing.T) {
-	dbName := "reply_runlog_trace_test_" + strings.NewReplacer("/", "_").Replace(t.Name())
-	db, err := gorm.Open(sqlite.Open("file:"+dbName+"?mode=memory&cache=shared"), &gorm.Config{
-		NamingStrategy: schema.NamingStrategy{
-			TablePrefix:   "t_",
-			SingularTable: true,
-		},
-	})
-	if err != nil {
-		t.Fatalf("open sqlite db: %v", err)
-	}
-	sqlDB, err := db.DB()
-	if err != nil {
-		t.Fatalf("get sqlite db: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := sqlDB.Close(); err != nil {
-			t.Fatalf("close sqlite db: %v", err)
-		}
-	})
-	if err := db.AutoMigrate(&models.AgentRunLog{}); err != nil {
-		t.Fatalf("auto migrate: %v", err)
-	}
-	sqls.SetDB(db)
-
-	newReplyRunLogService().Write(replyRunLogInput{
-		StartedAt:    time.Now(),
-		Message:      models.Message{ID: 22, RequestID: "trace-123", SenderType: enums.IMSenderTypeCustomer, Content: "hello"},
-		Conversation: models.Conversation{ID: 11},
-		AIAgent:      models.AIAgent{ID: 33, AIConfigID: 44},
-		Question:     "hello",
-	})
-
-	var item models.AgentRunLog
-	if err := db.First(&item).Error; err != nil {
-		t.Fatalf("find run log: %v", err)
-	}
-	if item.RequestID != "trace-123" {
-		t.Fatalf("RequestID=%q want %q", item.RequestID, "trace-123")
-	}
-}

internal/ai/runtime/reply_service.go

@@ -19,7 +19,6 @@ func newAIReplyService() *aiReplyService {
 		executor:    newRuntimeReplyExecutor(),
 		interrupts:  newReplyInterruptService(),
 		commit:      newReplyCommitService(),
-		runlog:      newReplyRunLogService(),
 	}
 }
 
@@ -28,7 +27,6 @@ type aiReplyService struct {
 	executor    *runtimeReplyExecutor
 	interrupts  *replyInterruptService
 	commit      *replyCommitService
-	runlog      *replyRunLogService
 }
 
 func firstInvokedToolCode(summary *applicationruntime.Summary) string {

internal/ai/runtime/reply_service_test.go

@@ -4,11 +4,9 @@ import (
 	"testing"
 	"time"
 
+	applicationruntime "agent-desk/internal/ai/application/runtime"
 	"agent-desk/internal/models"
 	"agent-desk/internal/pkg/enums"
-	"agent-desk/internal/pkg/toolx"
-
-	applicationruntime "agent-desk/internal/ai/application/runtime"
 )
 
 func TestReplyEligibilityCanReply(t *testing.T) {
@@ -70,59 +68,6 @@ func TestResolveReplyTimeout(t *testing.T) {
 	}
 }
 
-func TestBuildRunLogPlan(t *testing.T) {
-	summary := &applicationruntime.Summary{
-		PlannedSkillID: 44,
-		PlanReason:     "manual",
-	}
-	action, toolCode, reason := buildRunLogPlan(summary)
-	if action != "skill" || toolCode != "" || reason != "manual" {
-		t.Fatalf("unexpected skill plan result: action=%q toolCode=%q reason=%q", action, toolCode, reason)
-	}
-
-	summary = &applicationruntime.Summary{
-		Interrupted: true,
-		TraceData: `{
-			"graphTools": {
-				"items": [
-					{
-						"toolCode": "` + toolx.GraphTriageServiceRequest.Code + `",
-						"recommendedAction": "create_ticket",
-						"ticketDraftReady": true
-					}
-				]
-			}
-		}`,
-	}
-	action, toolCode, reason = buildRunLogPlan(summary)
-	if action != "graph" || toolCode != toolx.GraphTriageServiceRequest.Code || reason == "" {
-		t.Fatalf("unexpected graph interrupt result: action=%q toolCode=%q reason=%q", action, toolCode, reason)
-	}
-
-	summary = &applicationruntime.Summary{
-		InvokedToolCodes: []string{toolx.BuiltinToolSearch.Code},
-		TraceData: `{
-			"toolSearch": {
-				"items": [
-					{
-						"targetToolCode": "mcp/test/search"
-					}
-				]
-			}
-		}`,
-	}
-	action, toolCode, reason = buildRunLogPlan(summary)
-	if action != "tool" || toolCode != "mcp/test/search" || reason != "agent invoked dynamic tool via tool_search" {
-		t.Fatalf("unexpected dynamic tool result: action=%q toolCode=%q reason=%q", action, toolCode, reason)
-	}
-
-	summary = &applicationruntime.Summary{ReplyText: "done"}
-	action, toolCode, reason = buildRunLogPlan(summary)
-	if action != "reply" || toolCode != "" || reason != "agent replied directly" {
-		t.Fatalf("unexpected reply result: action=%q toolCode=%q reason=%q", action, toolCode, reason)
-	}
-}
-
 func TestResolveInterruptPrompt(t *testing.T) {
 	summary := &applicationruntime.Summary{
 		Interrupts: []applicationruntime.InterruptContextSummary{

internal/ai/runtime/reply_trigger_service.go

@@ -45,7 +45,6 @@ func (s *aiReplyService) TriggerReplyAsync(conversation models.Conversation, mes
 }
 
 func (s *aiReplyService) TriggerReply(ctx context.Context, conversation models.Conversation, message models.Message, aiAgent models.AIAgent) (retErr error) {
-	startedAt := time.Now()
 	trace := &aiReplyTraceData{Status: "started"}
 	var summary *applicationruntime.Summary
 	replyCtx := aiReplyContext{
@@ -61,18 +60,6 @@ func (s *aiReplyService) TriggerReply(ctx context.Context, conversation models.C
 	if s.eligibility != nil && !s.eligibility.CanReply(conversation, message, aiAgent) {
 		return nil
 	}
-	defer func() {
-		s.runlog.Write(replyRunLogInput{
-			StartedAt:    startedAt,
-			Message:      message,
-			Conversation: conversation,
-			AIAgent:      aiAgent,
-			Question:     message.Content,
-			RunErr:       retErr,
-			Trace:        trace,
-			Summary:      summary,
-		})
-	}()
 	if pendingInterrupt := svc.ConversationInterruptService.FindLatestPendingByConversationID(conversation.ID); pendingInterrupt != nil {
 		replyCtx.PendingInterrupt = pendingInterrupt
 		return s.resumePendingInterrupt(ctx, replyCtx)

internal/ai/runtime/runtime_reply_executor.go

@@ -95,7 +95,7 @@ func (e *runtimeReplyExecutor) fillTraceFromSummary(trace *aiReplyTraceData, sum
 		return
 	}
 	trace.Status = "runtime_prepared"
-	trace.FinalAction = toRunLogFinalAction(summary)
+	trace.FinalAction = runtimeTraceFinalAction(summary)
 	if summary != nil && strings.TrimSpace(summary.TraceData) != "" {
 		trace.Runtime = json.RawMessage(summary.TraceData)
 	}

internal/ai/runtime/runtime_trace_extractors.go

@@ -0,0 +1,105 @@
+package runtime
+
+import (
+	"encoding/json"
+	"strings"
+
+	applicationruntime "agent-desk/internal/ai/application/runtime"
+)
+
+func runtimeTraceFinalAction(summary *applicationruntime.Summary) string {
+	if summary == nil {
+		return ""
+	}
+	switch strings.TrimSpace(summary.Status) {
+	case "completed":
+		if strings.TrimSpace(summary.ReplyText) != "" {
+			return "reply"
+		}
+		return "completed"
+	case "fallback":
+		return "fallback"
+	case "error":
+		return "error"
+	case "interrupted":
+		return "interrupted"
+	case "expired":
+		return "expired"
+	default:
+		return strings.TrimSpace(summary.Status)
+	}
+}
+
+func extractToolSearchTrace(summary *applicationruntime.Summary) string {
+	if summary == nil {
+		return ""
+	}
+	trace := parseRuntimeTraceData(summary.TraceData)
+	if len(trace.ToolSearch.Items) == 0 {
+		return ""
+	}
+	buf, err := json.Marshal(trace.ToolSearch)
+	if err != nil {
+		return ""
+	}
+	return string(buf)
+}
+
+func extractGraphToolTrace(summary *applicationruntime.Summary) string {
+	if summary == nil {
+		return ""
+	}
+	trace := parseRuntimeTraceData(summary.TraceData)
+	if len(trace.GraphTools.Items) == 0 {
+		return ""
+	}
+	buf, err := json.Marshal(trace.GraphTools)
+	if err != nil {
+		return ""
+	}
+	return string(buf)
+}
+
+func firstGraphToolCode(summary *applicationruntime.Summary) string {
+	if summary == nil {
+		return ""
+	}
+	trace := parseRuntimeTraceData(summary.TraceData)
+	for _, item := range trace.GraphTools.Items {
+		toolCode := strings.TrimSpace(item.ToolCode)
+		if toolCode != "" {
+			return toolCode
+		}
+	}
+	return ""
+}
+
+type runtimeTraceProjection struct {
+	ToolSearch struct {
+		Items []struct {
+			TargetToolCode     string   `json:"targetToolCode"`
+			CandidateToolCodes []string `json:"candidateToolCodes"`
+		} `json:"items"`
+	} `json:"toolSearch"`
+	GraphTools struct {
+		Items []struct {
+			ToolCode          string          `json:"toolCode"`
+			Arguments         json.RawMessage `json:"arguments"`
+			RecommendedAction string          `json:"recommendedAction"`
+			RiskLevel         string          `json:"riskLevel"`
+			TicketDraftReady  bool            `json:"ticketDraftReady"`
+		} `json:"items"`
+	} `json:"graphTools"`
+}
+
+func parseRuntimeTraceData(raw string) runtimeTraceProjection {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return runtimeTraceProjection{}
+	}
+	var trace runtimeTraceProjection
+	if err := json.Unmarshal([]byte(raw), &trace); err != nil {
+		return runtimeTraceProjection{}
+	}
+	return trace
+}

internal/bootstrap/routes.go

@@ -308,11 +308,6 @@ func registerDashboardKnowledgeRetrieveLogRoutes(group *gin.RouterGroup) {
 	group.Any("/list", dashboard.KnowledgeRetrieveLogAnyList)
 }
 
-func registerDashboardAgentRunLogRoutes(group *gin.RouterGroup) {
-	group.GET("/:id", dashboard.AgentRunLogGetBy)
-	group.Any("/list", dashboard.AgentRunLogAnyList)
-}
-
 func registerDashboardSkillDefinitionRoutes(group *gin.RouterGroup) {
 	group.GET("/:id", dashboard.SkillDefinitionGetBy)
 	group.POST("/create", dashboard.SkillDefinitionPostCreate)

internal/bootstrap/server.go

@@ -195,7 +195,6 @@ func addRouter(app *gin.Engine) {
 	registerDashboardKnowledgeFAQRoutes(dashboardGroup.Group("/knowledge-faq"))
 	registerDashboardKnowledgeRetrieveRoutes(dashboardGroup.Group("/knowledge-retrieve"))
 	registerDashboardKnowledgeRetrieveLogRoutes(dashboardGroup.Group("/knowledge-retrieve-log"))
-	registerDashboardAgentRunLogRoutes(dashboardGroup.Group("/agent-run-log"))
 	registerDashboardSkillDefinitionRoutes(dashboardGroup.Group("/skill-definition"))
 	registerDashboardMCPRoutes(dashboardGroup.Group("/mcp"))
 

internal/builders/agent_run_log_builder.go

@@ -1,94 +0,0 @@
-package builders
-
-import (
-	"agent-desk/internal/models"
-	"agent-desk/internal/pkg/dto/response"
-	"encoding/json"
-	"strings"
-)
-
-func BuildAgentRunLog(item *models.AgentRunLog) response.AgentRunLogResponse {
-	if item == nil {
-		return response.AgentRunLogResponse{}
-	}
-	hitlStatus, hitlStatusName, hitlSummary := resolveAgentRunLogHITL(item)
-	recommendedAction, riskLevel, ticketDraftReady := resolveGraphOutcome(item.GraphToolTrace)
-	return response.AgentRunLogResponse{
-		ID:                item.ID,
-		ConversationID:    item.ConversationID,
-		MessageID:         item.MessageID,
-		RequestID:         item.RequestID,
-		AIAgentID:         item.AIAgentID,
-		AIConfigID:        item.AIConfigID,
-		UserMessage:       item.UserMessage,
-		PlannedAction:     item.PlannedAction,
-		PlannedSkillID:    item.PlannedSkillID,
-		PlannedSkillName:  item.PlannedSkillName,
-		SkillRouteTrace:   item.SkillRouteTrace,
-		ToolSearchTrace:   item.ToolSearchTrace,
-		GraphToolTrace:    item.GraphToolTrace,
-		GraphToolCode:     item.GraphToolCode,
-		RecommendedAction: recommendedAction,
-		RiskLevel:         riskLevel,
-		TicketDraftReady:  ticketDraftReady,
-		HandoffReason:     item.HandoffReason,
-		PlannedToolCode:   item.PlannedToolCode,
-		PlanReason:        item.PlanReason,
-		InterruptType:     item.InterruptType,
-		ResumeSource:      item.ResumeSource,
-		HitlStatus:        hitlStatus,
-		HitlStatusName:    hitlStatusName,
-		HitlSummary:       hitlSummary,
-		FinalAction:       item.FinalAction,
-		FinalStatus:       item.FinalStatus,
-		ReplyText:         item.ReplyText,
-		ErrorMessage:      item.ErrorMessage,
-		LatencyMs:         item.LatencyMs,
-		TraceData:         item.TraceData,
-		CreatedAt:         item.CreatedAt.Format("2006-01-02 15:04:05"),
-	}
-}
-
-func resolveGraphOutcome(raw string) (recommendedAction, riskLevel string, ticketDraftReady bool) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return "", "", false
-	}
-	var payload struct {
-		Items []struct {
-			RecommendedAction string `json:"recommendedAction"`
-			RiskLevel         string `json:"riskLevel"`
-			TicketDraftReady  bool   `json:"ticketDraftReady"`
-		} `json:"items"`
-	}
-	if err := json.Unmarshal([]byte(raw), &payload); err != nil {
-		return "", "", false
-	}
-	for _, item := range payload.Items {
-		if strings.TrimSpace(item.RecommendedAction) != "" || strings.TrimSpace(item.RiskLevel) != "" || item.TicketDraftReady {
-			return strings.TrimSpace(item.RecommendedAction), strings.TrimSpace(item.RiskLevel), item.TicketDraftReady
-		}
-	}
-	return "", "", false
-}
-
-func resolveAgentRunLogHITL(item *models.AgentRunLog) (status, statusName, summary string) {
-	if item == nil {
-		return "", "", ""
-	}
-	replyText := strings.TrimSpace(item.ReplyText)
-	switch {
-	case strings.TrimSpace(item.FinalStatus) == "interrupted":
-		return "pending", "等待确认", "Graph Tool 已发起确认，正在等待用户回复。"
-	case strings.TrimSpace(item.FinalStatus) == "expired":
-		return "expired", "已过期", "确认 checkpoint 已失效，需要重新发起。"
-	case strings.Contains(replyText, "已取消本次工单创建") || strings.Contains(replyText, "已取消本次转人工"):
-		return "cancelled", "已取消", "用户已明确取消，本次确认流程已终止。"
-	case strings.TrimSpace(item.ResumeSource) != "":
-		return "confirmed", "已确认", "用户确认后已恢复执行，并完成后续流程。"
-	case strings.TrimSpace(item.InterruptType) != "":
-		return "triggered", "已触发", "本次运行涉及确认式 HITL 流程。"
-	default:
-		return "", "", ""
-	}
-}

internal/handlers/dashboard/agent_run_log_handler.go

@@ -1,66 +0,0 @@
-package dashboard
-
-import (
-	"agent-desk/internal/builders"
-	"agent-desk/internal/pkg/constants"
-	"agent-desk/internal/pkg/dto/response"
-	"agent-desk/internal/pkg/httpx"
-	"agent-desk/internal/services"
-
-	"agent-desk/internal/pkg/httpx/params"
-
-	"github.com/gin-gonic/gin"
-	"github.com/mlogclub/simple/web"
-)
-
-func AgentRunLogAnyList(ctx *gin.Context) {
-	if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionConversationView); err != nil {
-		httpx.WriteJSON(ctx, err)
-		return
-	}
-
-	cnd := params.NewPagedSqlCnd(ctx,
-		params.QueryFilter{ParamName: "conversationId"},
-		params.QueryFilter{ParamName: "messageId"},
-		params.QueryFilter{ParamName: "requestId"},
-		params.QueryFilter{ParamName: "aiAgentId"},
-		params.QueryFilter{ParamName: "plannedAction"},
-		params.QueryFilter{ParamName: "plannedSkillId"},
-		params.QueryFilter{ParamName: "graphToolCode"},
-		params.QueryFilter{ParamName: "interruptType"},
-		params.QueryFilter{ParamName: "resumeSource"},
-		params.QueryFilter{ParamName: "finalStatus"},
-		params.QueryFilter{ParamName: "handoffReason", Op: params.Like},
-		params.QueryFilter{ParamName: "finalAction"},
-		params.QueryFilter{ParamName: "userMessage", Op: params.Like},
-	).Desc("id")
-	if hitlStatus, _ := params.Get(ctx, "hitlStatus"); hitlStatus != "" && hitlStatus != "all" {
-		cnd = services.AgentRunLogService.ApplyHITLStatusFilter(cnd, hitlStatus)
-	}
-	queryParams := params.NewQueryParams(ctx)
-	queryParams.Cnd = *cnd
-	list, paging := services.AgentRunLogService.FindPageByParams(queryParams)
-	results := make([]response.AgentRunLogResponse, 0, len(list))
-	for _, item := range list {
-		results = append(results, builders.BuildAgentRunLog(&item))
-	}
-	httpx.WriteJSON(ctx, &web.PageResult{Results: results, Page: paging})
-}
-
-func AgentRunLogGetBy(ctx *gin.Context) {
-	id, ok := httpx.GetPathInt64(ctx, "id")
-	if !ok {
-		return
-	}
-	if _, err := services.AuthService.RequirePermission(ctx, constants.PermissionConversationView); err != nil {
-		httpx.WriteJSON(ctx, err)
-		return
-	}
-
-	item := services.AgentRunLogService.Get(id)
-	if item == nil {
-		httpx.WriteJSON(ctx, httpx.JsonErrorMsg(ctx, "error.e0013"))
-		return
-	}
-	httpx.WriteJSON(ctx, builders.BuildAgentRunLog(item))
-}

internal/models/models.go

@@ -57,7 +57,6 @@ var Models = []any{
 	&KnowledgeFeedback{},
 	&SkillDefinition{},
 	&SkillRunLog{},
-	&AgentRunLog{},
 	&AIWorkflow{},
 	&AIWorkflowVersion{},
 	&AIWorkflowRun{},
@@ -912,36 +911,6 @@ type SkillRunLog struct {
 	CreatedAt         time.Time        `gorm:"type:datetime;not null;index"`          // CreatedAt 为运行日志创建时间。
 }
 
-// AgentRunLog 表示一次客服 Agent 自动运行的总链路日志。
-type AgentRunLog struct {
-	ID               int64     `gorm:"primaryKey;autoIncrement"`
-	ConversationID   int64     `gorm:"type:bigint;not null;default:0;index"`
-	MessageID        int64     `gorm:"type:bigint;not null;default:0;index"`
-	RequestID        string    `gorm:"type:varchar(128);not null;default:'';index"`
-	AIAgentID        int64     `gorm:"type:bigint;not null;default:0;index"`
-	AIConfigID       int64     `gorm:"type:bigint;not null;default:0;index"`
-	UserMessage      string    `gorm:"type:longtext"`
-	PlannedAction    string    `gorm:"type:varchar(30);not null;default:'';index"`
-	PlannedSkillID   int64     `gorm:"type:bigint;not null;default:0;index"`
-	PlannedSkillName string    `gorm:"type:varchar(100);not null;default:''"`
-	SkillRouteTrace  string    `gorm:"type:text"`
-	ToolSearchTrace  string    `gorm:"type:text"`
-	GraphToolTrace   string    `gorm:"type:text"`
-	GraphToolCode    string    `gorm:"type:varchar(200);not null;default:'';index"`
-	HandoffReason    string    `gorm:"type:varchar(500);not null;default:''"`
-	PlannedToolCode  string    `gorm:"type:varchar(200);not null;default:'';index"`
-	PlanReason       string    `gorm:"type:varchar(500);not null;default:''"`
-	InterruptType    string    `gorm:"type:varchar(50);not null;default:'';index"`
-	ResumeSource     string    `gorm:"type:varchar(50);not null;default:'';index"`
-	FinalAction      string    `gorm:"type:varchar(30);not null;default:'';index"`
-	FinalStatus      string    `gorm:"type:varchar(30);not null;default:'';index"`
-	ReplyText        string    `gorm:"type:longtext"`
-	ErrorMessage     string    `gorm:"type:text"`
-	LatencyMs        int64     `gorm:"type:bigint;not null;default:0"`
-	TraceData        string    `gorm:"type:text"`
-	CreatedAt        time.Time `gorm:"type:datetime;not null;index"`
-}
-
 // ConversationInterrupt 表示会话级待恢复中断记录。
 type ConversationInterrupt struct {
 	ID                  int64      `gorm:"primaryKey;autoIncrement"`

internal/pkg/dto/response/skill_response.go

@@ -38,38 +38,3 @@ type SkillDebugRunResponse struct {
 	ConversationID    int64    `json:"conversationId"`
 	AIAgentID         int64    `json:"aiAgentId"`
 }
-
-type AgentRunLogResponse struct {
-	ID                int64  `json:"id"`
-	ConversationID    int64  `json:"conversationId"`
-	MessageID         int64  `json:"messageId"`
-	RequestID         string `json:"requestId"`
-	AIAgentID         int64  `json:"aiAgentId"`
-	AIConfigID        int64  `json:"aiConfigId"`
-	UserMessage       string `json:"userMessage"`
-	PlannedAction     string `json:"plannedAction"`
-	PlannedSkillID    int64  `json:"plannedSkillId"`
-	PlannedSkillName  string `json:"plannedSkillName"`
-	SkillRouteTrace   string `json:"skillRouteTrace"`
-	ToolSearchTrace   string `json:"toolSearchTrace"`
-	GraphToolTrace    string `json:"graphToolTrace"`
-	GraphToolCode     string `json:"graphToolCode"`
-	RecommendedAction string `json:"recommendedAction"`
-	RiskLevel         string `json:"riskLevel"`
-	TicketDraftReady  bool   `json:"ticketDraftReady"`
-	HandoffReason     string `json:"handoffReason"`
-	PlannedToolCode   string `json:"plannedToolCode"`
-	PlanReason        string `json:"planReason"`
-	InterruptType     string `json:"interruptType"`
-	ResumeSource      string `json:"resumeSource"`
-	HitlStatus        string `json:"hitlStatus"`
-	HitlStatusName    string `json:"hitlStatusName"`
-	HitlSummary       string `json:"hitlSummary"`
-	FinalAction       string `json:"finalAction"`
-	FinalStatus       string `json:"finalStatus"`
-	ReplyText         string `json:"replyText"`
-	ErrorMessage      string `json:"errorMessage"`
-	LatencyMs         int64  `json:"latencyMs"`
-	TraceData         string `json:"traceData"`
-	CreatedAt         string `json:"createdAt"`
-}

internal/repositories/agent_run_log_repository.go

@@ -1,91 +0,0 @@
-package repositories
-
-import (
-	"agent-desk/internal/models"
-
-	"agent-desk/internal/pkg/httpx/params"
-
-	"github.com/mlogclub/simple/sqls"
-	"gorm.io/gorm"
-)
-
-var AgentRunLogRepository = newAgentRunLogRepository()
-
-func newAgentRunLogRepository() *agentRunLogRepository {
-	return &agentRunLogRepository{}
-}
-
-type agentRunLogRepository struct{}
-
-func (r *agentRunLogRepository) Get(db *gorm.DB, id int64) *models.AgentRunLog {
-	ret := &models.AgentRunLog{}
-	if err := db.First(ret, "id = ?", id).Error; err != nil {
-		return nil
-	}
-	return ret
-}
-
-func (r *agentRunLogRepository) Take(db *gorm.DB, where ...interface{}) *models.AgentRunLog {
-	ret := &models.AgentRunLog{}
-	if err := db.Take(ret, where...).Error; err != nil {
-		return nil
-	}
-	return ret
-}
-
-func (r *agentRunLogRepository) Find(db *gorm.DB, cnd *sqls.Cnd) (list []models.AgentRunLog) {
-	cnd.Find(db, &list)
-	return
-}
-
-func (r *agentRunLogRepository) FindOne(db *gorm.DB, cnd *sqls.Cnd) *models.AgentRunLog {
-	ret := &models.AgentRunLog{}
-	if err := cnd.FindOne(db, &ret); err != nil {
-		return nil
-	}
-	return ret
-}
-
-func (r *agentRunLogRepository) FindPageByParams(db *gorm.DB, params *params.QueryParams) (list []models.AgentRunLog, paging *sqls.Paging) {
-	return r.FindPageByCnd(db, &params.Cnd)
-}
-
-func (r *agentRunLogRepository) FindPageByCnd(db *gorm.DB, cnd *sqls.Cnd) (list []models.AgentRunLog, paging *sqls.Paging) {
-	cnd.Find(db, &list)
-	count := cnd.Count(db, &models.AgentRunLog{})
-
-	paging = &sqls.Paging{
-		Page:  cnd.Paging.Page,
-		Limit: cnd.Paging.Limit,
-		Total: count,
-	}
-	return
-}
-
-func (r *agentRunLogRepository) Count(db *gorm.DB, cnd *sqls.Cnd) int64 {
-	return cnd.Count(db, &models.AgentRunLog{})
-}
-
-func (r *agentRunLogRepository) Create(db *gorm.DB, t *models.AgentRunLog) (err error) {
-	err = db.Create(t).Error
-	return
-}
-
-func (r *agentRunLogRepository) Update(db *gorm.DB, t *models.AgentRunLog) (err error) {
-	err = db.Save(t).Error
-	return
-}
-
-func (r *agentRunLogRepository) Updates(db *gorm.DB, id int64, columns map[string]interface{}) (err error) {
-	err = db.Model(&models.AgentRunLog{}).Where("id = ?", id).Updates(columns).Error
-	return
-}
-
-func (r *agentRunLogRepository) UpdateColumn(db *gorm.DB, id int64, name string, value interface{}) (err error) {
-	err = db.Model(&models.AgentRunLog{}).Where("id = ?", id).UpdateColumn(name, value).Error
-	return
-}
-
-func (r *agentRunLogRepository) Delete(db *gorm.DB, id int64) {
-	db.Delete(&models.AgentRunLog{}, "id = ?", id)
-}

internal/services/agent_run_log_service.go

@@ -1,86 +0,0 @@
-package services
-
-import (
-	"agent-desk/internal/models"
-	"agent-desk/internal/repositories"
-	"strings"
-
-	"agent-desk/internal/pkg/httpx/params"
-
-	"github.com/mlogclub/simple/sqls"
-)
-
-var AgentRunLogService = newAgentRunLogService()
-
-func newAgentRunLogService() *agentRunLogService {
-	return &agentRunLogService{}
-}
-
-type agentRunLogService struct{}
-
-func (s *agentRunLogService) Get(id int64) *models.AgentRunLog {
-	return repositories.AgentRunLogRepository.Get(sqls.DB(), id)
-}
-
-func (s *agentRunLogService) Take(where ...interface{}) *models.AgentRunLog {
-	return repositories.AgentRunLogRepository.Take(sqls.DB(), where...)
-}
-
-func (s *agentRunLogService) Find(cnd *sqls.Cnd) []models.AgentRunLog {
-	return repositories.AgentRunLogRepository.Find(sqls.DB(), cnd)
-}
-
-func (s *agentRunLogService) FindOne(cnd *sqls.Cnd) *models.AgentRunLog {
-	return repositories.AgentRunLogRepository.FindOne(sqls.DB(), cnd)
-}
-
-func (s *agentRunLogService) FindPageByParams(params *params.QueryParams) (list []models.AgentRunLog, paging *sqls.Paging) {
-	return repositories.AgentRunLogRepository.FindPageByParams(sqls.DB(), params)
-}
-
-func (s *agentRunLogService) FindPageByCnd(cnd *sqls.Cnd) (list []models.AgentRunLog, paging *sqls.Paging) {
-	return repositories.AgentRunLogRepository.FindPageByCnd(sqls.DB(), cnd)
-}
-
-func (s *agentRunLogService) Count(cnd *sqls.Cnd) int64 {
-	return repositories.AgentRunLogRepository.Count(sqls.DB(), cnd)
-}
-
-func (s *agentRunLogService) Create(t *models.AgentRunLog) error {
-	return repositories.AgentRunLogRepository.Create(sqls.DB(), t)
-}
-
-func (s *agentRunLogService) Update(t *models.AgentRunLog) error {
-	return repositories.AgentRunLogRepository.Update(sqls.DB(), t)
-}
-
-func (s *agentRunLogService) Updates(id int64, columns map[string]interface{}) error {
-	return repositories.AgentRunLogRepository.Updates(sqls.DB(), id, columns)
-}
-
-func (s *agentRunLogService) UpdateColumn(id int64, name string, value interface{}) error {
-	return repositories.AgentRunLogRepository.UpdateColumn(sqls.DB(), id, name, value)
-}
-
-func (s *agentRunLogService) Delete(id int64) {
-	repositories.AgentRunLogRepository.Delete(sqls.DB(), id)
-}
-
-func (s *agentRunLogService) ApplyHITLStatusFilter(cnd *sqls.Cnd, hitlStatus string) *sqls.Cnd {
-	if cnd == nil {
-		cnd = sqls.NewCnd()
-	}
-	switch strings.TrimSpace(hitlStatus) {
-	case "pending":
-		cnd.Eq("final_status", "interrupted")
-	case "expired":
-		cnd.Eq("final_status", "expired")
-	case "cancelled":
-		cnd.Where("(reply_text LIKE ? OR reply_text LIKE ?)", "%已取消本次工单创建%", "%已取消本次转人工%")
-	case "confirmed":
-		cnd.Where("resume_source <> ''")
-	case "triggered":
-		cnd.Where("interrupt_type <> ''")
-	}
-	return cnd
-}