可观测与评估

          fi
          echo "::notice::Skill output captured to .outputs/${SKILL}.md ($(wc -c < ".outputs/${SKILL}.md") bytes)"

      - name: Analyze skill output
        id: analyze
        if: steps.work.outputs.mode != '' && steps.run.outcome == 'success'
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
          ANTHROPIC_BASE_URL: ${{ vars.ANTHROPIC_BASE_URL }}
          BANKR_LLM_KEY: ${{ secrets.BANKR_LLM_KEY }}
        run: |
          SKILL="${{ steps.skill.outputs.name }}"

LLMConfig = dict[str, None | float | int | ConfigItem | list[ConfigItem]]


class BaseLogger(ABC):
    @abstractmethod
    def start(self) -> str:
        """Open a connection to the logging database, and start recording.

        Returns:
            session_id (str):     a unique id for the logging session
        """
        ...

# ────────────────────────────────
# Example tracing wrappers
# ────────────────────────────────
async def openai_tracing(input_message: str) -> str:
    agency_instance = create_agency()
    with trace("OpenAI tracing"):
        response = await agency_instance.get_response(message=input_message)
    return response.final_output


async def langfuse_tracing(input_message: str) -> str:
    if os.getenv("LANGFUSE_SECRET_KEY") is None or os.getenv("LANGFUSE_PUBLIC_KEY") is None:
        raise ValueError("LANGFUSE api keys are not set")

                        c.log_interaction(
                            role=self.agent_name,
                            message=f"[SUBACTIVITY][{thinking_id}][EXECUTION] `{command_name}` was executed successfully.\n{command_output}",
                        )

                        # Emit webhook event for successful command execution
                        await webhook_emitter.emit_event(
                            event_type="command.execution.completed",
                            data={
                                "conversation_id": c.get_conversation_id(),
                                "conversation_name": conversation_name,
                                "agent_name": self.agent_name,

  /**
   * Performs the actual token usage update operation.
   */
  private async performTokenUsageUpdate(usage: TokenUsage): Promise<void> {
    try {
      // Get current state
      const currentState = await this.orchestrationManager.getState(
        this.sessionId
      );
      const currentUsage = currentState?.cumulativeTokenUsage || {
        promptTokens: 0,
        completionTokens: 0,
        totalTokens: 0

	"github.com/Agent-Field/agentfield/control-plane/internal/logger"
	"github.com/Agent-Field/agentfield/control-plane/pkg/types"
	"github.com/gin-gonic/gin"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
)

// AgentLister is the minimal dependency required for discovery.
type AgentLister interface {
	ListAgents(ctx context.Context, filters types.AgentFilters) ([]*types.AgentNode, error)
}

// DiscoveryFilters captures query parameters for capability discovery.

    pip install ace-framework[tracing]
"""

from kayba_tracing import (
    configure,
    disable,
    enable,
    get_folder,
    get_trace,
    search_traces,
    set_folder,
    start_span,
    trace,

# ---------------------------------------------------------------------------


class TracingMiddleware(MiddlewareBase):
    """Agent middleware that adds OpenTelemetry tracing to the reply,
    model-call and tool-execution lifecycles.

    When tracing has not been configured (``setup_tracing`` was not called),
    every hook short-circuits to ``next_handler`` with near-zero overhead.

    Example::

        from agentscope.middleware import TracingMiddleware

        type: "start-step",
      });

      writer.write({
        type: "data-status",
        data: { value: "generating-queries" },
      });

      // step 1. generate queries
      const { chunks, queryToResult, totalQueries } = await agenticSearch({
        model,
        messages,
        queryOptions,

        return record.msg


class Logger(metaclass=Singleton):
    """
    Logger that handle titles in different colors.
    Outputs logs in console, activity.log, and errors.log
    For console handler: simulates typing
    """

    def __init__(self):
        # create log directory if it doesn't exist
        this_files_dir_path = os.path.dirname(__file__)

            node_end_time = int(round(time.time() * 1000))
            data_llm_output = answers
            node_trace_log.trace.append(
                NodeLog(
                    id=node_id,
                    sid=node_sid,
                    node_id=node_node_id,
                    node_name=node_name,
                    node_type=node_type,
                    start_time=node_start_time,
                    end_time=node_end_time,
                    duration=node_end_time - node_start_time,

        tracer_provider: TracerProvider | None = None,
        ignore_unhandled_exceptions: bool = True,
    ) -> None:
        self._tracer_helper = TraceHelper(tracer_provider, MessageRuntimeTracingConfig("SingleThreadedAgentRuntime"))
        self._message_queue: Queue[PublishMessageEnvelope | SendMessageEnvelope | ResponseMessageEnvelope] = Queue()
        # (namespace, type) -> List[AgentId]
        self._agent_factories: Dict[
            str, Callable[[], Agent | Awaitable[Agent]] | Callable[[AgentRuntime, AgentId], Agent | Awaitable[Agent]]
        ] = {}
        self._instantiated_agents: Dict[AgentId, Agent] = {}
        self._intervention_handlers = intervention_handlers
        self._background_tasks: Set[Task[Any]] = set()
        self._subscription_manager = SubscriptionManager()

      }

      cleanups.push(
        iteration.traces.onPush((traces) => {
          for (const trace of traces) {
            onTrace?.({ trace, iteration: ctx.iterations.length })
          }
        })
      )

      try {
        await executeIteration({
          iteration,

        import uuid
        return str(uuid.uuid4())

    def _record_trace(self, entry: dict) -> None:
        """Record trace entry and stream to io if connected.

        This is the single place where trace entries are recorded.
        Ensures both local trace and remote streaming stay in sync.
        Also includes current session state so client can persist it
        (client-side is source of truth for session state).
        """
        if 'id' not in entry:
            entry['id'] = self._next_trace_id()

// Seq and EventHash cleared. PrevHash is part of the hashed bytes so any
// tampering with a predecessor (direct mutation or reordering) invalidates
// every descendant hash — this is what gives the chain its tamper-evidence.
func (c *Chainer) Append(ctx context.Context, event *SIEMEvent) error {
	if event == nil {
		return ErrNilEvent
	}
	if event.TenantID == "" {
		return ErrTenantRequired
	}
	unlockTenant := c.lockTenant(event.TenantID)
	defer unlockTenant()

        self.updated_count + self.skipped_count
    }
    
    pub fn skip_rate(&self) -> f64 {
        if self.total_operations() == 0 {
            0.0
        } else {
            self.skipped_count as f64 / self.total_operations() as f64
        }
    }
    
    pub fn cache_hit_rate(&self) -> f64 {
        let total = self.cache_hits + self.cache_misses;

"""Telemetry module for CrewAI.

This module provides anonymous telemetry collection for development purposes.
No prompts, task descriptions, agent backstories/goals, responses, or sensitive
data is collected. Users can opt-in to share more complete data using the
`share_crew` attribute.
"""

from __future__ import annotations

} from "@temporalio/interceptors-opentelemetry/lib/workflow";

// Export an interceptors variable to add OpenTelemetry interceptors to the workflow.
export const interceptors: WorkflowInterceptorsFactory = () => ({
  inbound: [new OpenTelemetryInboundInterceptor()],
  outbound: [new OpenTelemetryOutboundInterceptor()],
  internals: [new OpenTelemetryInternalsInterceptor()],
});

const { runModelAndCreateActionsActivity } = proxyActivities<
  typeof runModelAndCreateWrapperActivities
>({
  startToCloseTimeout: "10 minutes",

   *
   * @returns  List of sandbox metrics containing CPU, memory and disk usage information.
   */
  async getMetrics(opts?: SandboxMetricsOpts) {
    if (this.envdApi.version) {
      if (compareVersions(this.envdApi.version, '0.1.5') < 0) {
        throw new SandboxError(
          'You need to update the template to use the new SDK. ' +
            'You can do this by running `e2b template build` in the directory with the template.'
        )
      }

      if (compareVersions(this.envdApi.version, '0.2.4') < 0) {

        return {}


class Tracer(abc.ABC):
    """Interface for instrumenting code by creating and submitting spans."""

    @abc.abstractmethod
    @contextlib.contextmanager
    def trace(
        self, operation_name: str, tags: dict[str, Any] | None = None, parent_span: Span | None = None
    ) -> Iterator[Span]:
        """
        Trace the execution of a block of code.

/// Look up inject port for an instance.
///
/// The inject port is a bidirectional RPC server (input bytes / `\x00SCREEN\n`
/// query) — it shares the `notify_endpoints` table with wake endpoints but
/// uses a different protocol. See `crate::notify::WakeKind` for the wake kinds.
fn get_inject_port(db: &HcomDb, instance_name: &str) -> Option<i32> {
    db.conn()
        .query_row(
            "SELECT port FROM notify_endpoints WHERE instance = ?1 AND kind = 'inject'",
            rusqlite::params![instance_name],
            |row| row.get(0),
        )

#!/usr/bin/env python3
"""
Session Search Tool - Long-Term Conversation Recall

Single-shape tool with three calling modes (inferred from args, no explicit
mode parameter):

  1. DISCOVERY — pass ``query``. Runs FTS5, dedupes hits by session lineage,
     returns top N sessions each with: snippet, ±5 message window around the
     match, plus bookend_start (first 3 user+assistant msgs of session) and

logger = logging.getLogger(__name__)


class DecisionTracker:
    """
    The runtime environment that agents execute within.

    Usage:
        runtime = Runtime("/path/to/storage")

        # Start a run
        run_id = runtime.start_run("goal_123", "Qualify sales leads")

from .hook import Hook


class MessageLogger(Hook):
    def __init__(self, name: str = 'lagent', add_file_handler: bool = False):
        self.logger = get_logger(
            name, 'info', '%(asctime)s %(levelname)8s %(name)8s - %(message)s', add_file_handler=add_file_handler
        )
        self.sender2color = {}

    def before_agent(self, agent, messages, session_id):
        for message in messages:
            self._process_message(message, session_id)

""".strip()


def _scrub_inputs(inputs: dict[str, Any]) -> dict[str, Any]:
    """Remove ``runtime`` and ``handler`` from trace inputs before sending to LangSmith."""
    filtered = inputs.copy()
    filtered.pop("handler", None)
    req = filtered.get("request")
    if isinstance(req, (ModelRequest, ToolCallRequest)):
        filtered["request"] = {
            f.name: getattr(req, f.name) for f in fields(req) if f.name != "runtime"
        }
    return filtered

        session_id=session_id,
        stream=True,
    )
    for log in EventLogger().log(response):
        log.print()

    user_prompt2 = "What are the popular llms supported in torchtune?"
    print(colored(f"User> {user_prompt2}", "blue"))
    response2 = agent.create_turn(
        messages=[{"role": "user", "content": user_prompt2}],
        session_id=session_id,
        stream=True,
    )

from llama_index_instrumentation import (
    DispatcherSpanMixin,  # noqa
    get_dispatcher,  # noqa
    root_dispatcher,  # noqa
    root_manager,  # noqa
)
from llama_index_instrumentation.dispatcher import (
    DISPATCHER_SPAN_DECORATED_ATTR,  # noqa
    Dispatcher,  # noqa
    Manager,  # noqa

                question=question,
                previous_responses='{previous_responses}'
        )
        print(prompt.format(previous_responses=''))
        while num_loops < self.max_loops:
            num_loops += 1
            curr_prompt = prompt.format(previous_responses='\n'.join(previous_responses))
            generated, tool, tool_input = self.decide_next_action(curr_prompt)
            if tool == 'Final Answer':
                return tool_input
            if tool not in self.tool_by_names:
                raise ValueError(f"Unknown tool: {tool}")
            tool_result = self.tool_by_names[tool].use(tool_input)

        pass


class LoongFlowEvaluator(Evaluator):
    """
    LoongFlow Evaluator
    """

    def __init__(self, config: EvaluatorConfig):
        self.config = config
        self._logger = get_logger(self.__class__.__name__)
        self._thread_executor = concurrent.futures.ThreadPoolExecutor()

SUB_AGENT_MODEL = "claude-3-5-sonnet-20240620"
REFINER_MODEL = "claude-3-5-sonnet-20240620"

def calculate_subagent_cost(model, input_tokens, output_tokens):
    # Pricing information per model
    pricing = {
        "claude-3-opus-20240229": {"input_cost_per_mtok": 15.00, "output_cost_per_mtok": 75.00},
        "claude-3-haiku-20240307": {"input_cost_per_mtok": 0.25, "output_cost_per_mtok": 1.25},
        "claude-3-sonnet-20240229": {"input_cost_per_mtok": 3.00, "output_cost_per_mtok": 15.00},
        "claude-3-5-sonnet-20240620": {"input_cost_per_mtok": 3.00, "output_cost_per_mtok": 15.00},
    }

    # Calculate cost

/**
 * AI-specific span types with their associated metadata
 */
export enum SpanType {
  /** Agent run - root span for agent processes */
  AGENT_RUN = 'agent_run',
  /** Scorer execution */
  SCORER_RUN = 'scorer_run',
  /** Individual scorer pipeline step */
  SCORER_STEP = 'scorer_step',
  /** Generic span for custom operations */
  GENERIC = 'generic',
  /** Model generation with model calls, token usage, prompts, completions */

    def _default_system_msg(self):
        return self._system_msg(self.system_prompt)

    def _update_costs(self, usage: Union[dict, BaseModel], model: str = None, local_calc_usage: bool = True):
        """update each request's token cost
        Args:
            model (str): model name or in some scenarios called endpoint
            local_calc_usage (bool): some models don't calculate usage, it will overwrite LLMConfig.calc_usage
        """
        calc_usage = self.config.calc_usage and local_calc_usage
        model = model or self.pricing_plan
        model = model or self.model
        usage = usage.model_dump() if isinstance(usage, BaseModel) else usage

	Log(fmt.Sprintf(format, args...))
}

func Debug(message string) {
	hostLogMessage("debug", message)
}

func Debugf(format string, args ...any) {
	Debug(fmt.Sprintf(format, args...))
}

func Info(message string) {
	hostLogMessage("info", message)

@dataclass
class StateTraceEntry:
    state: TurnState
    started_at: float
    duration_ms: float
    event: str
    error: str | None = None


@dataclass
class TurnContext:

        return
      }

      config.onProgress?.({
        type: 'task_start',
        task: task.id,
        agent: assignee,
        data: task,
      } satisfies OrchestratorEvent)

      config.onProgress?.({
        type: 'agent_start',
        agent: assignee,

import { validateToolArguments } from "./validation.js";

/** Callback used by synchronous loop runners to publish agent lifecycle events. */
export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;

const EMPTY_USAGE = {
  input: 0,
  output: 0,
  cacheRead: 0,
  cacheWrite: 0,
  totalTokens: 0,
  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
};

<summary><strong>Example JSON output</strong></summary>

```json
$ pilotctl --json info
{"status":"ok","data":{"address":"0:0000.0000.0005","node_id":5,"hostname":"my-agent","peers":3,"connections":1,"uptime_secs":3600}}

$ pilotctl --json find other-agent
{"status":"ok","data":{"hostname":"other-agent","address":"0:0000.0000.0003"}}

$ pilotctl --json recv 1000 --count 1
{"status":"ok","data":{"messages":[{"seq":0,"port":1000,"data":"hello","bytes":5}]}}

$ pilotctl --json find nonexistent

            self._idle_event.set()


class PipelineParams(BaseModel):
    """Configuration parameters for pipeline execution.

    These parameters are usually passed to all frame processors through
    StartFrame. For other generic pipeline worker parameters use PipelineWorker
    constructor arguments instead.

    Parameters:
        audio_in_sample_rate: Input audio sample rate in Hz.
        audio_out_sample_rate: Output audio sample rate in Hz.

    _TELEMETRY_DISABLED_CACHE = not explicitly_enabled
    return _TELEMETRY_DISABLED_CACHE

class MinimalTelemetry:
    """
    Minimal telemetry collector for anonymous usage tracking.
    
    Privacy guarantees:
    - No personal data is collected
    - No prompts, responses, or user content is tracked
    - Only anonymous metrics about feature usage
    - Respects DO_NOT_TRACK standard
    - Can be disabled via environment variables

    private protected const string MeasurementErrorTagName = "error.type";

    /// <summary><see cref="ActivitySource"/> for function-related activities.</summary>
    private static readonly ActivitySource s_activitySource = new("Microsoft.SemanticKernel");

    /// <summary><see cref="Meter"/> for function-related metrics.</summary>
    private protected static readonly Meter s_meter = new("Microsoft.SemanticKernel");

    /// <summary>The <see cref="JsonSerializerOptions"/> to use for serialization and deserialization of various aspects of the function.</summary>
    private readonly JsonSerializerOptions? _jsonSerializerOptions;

    /// <summary>The underlying method, if this function was created from a method.</summary>
#pragma warning disable CA1051

        return f"Timing(start_time={self.start_time}, end_time={self.end_time}, duration={self.duration})"


class Monitor:
    def __init__(self, tracked_model, logger):
        self.step_durations = []
        self.tracked_model = tracked_model
        self.logger = logger
        self.total_input_token_count = 0
        self.total_output_token_count = 0

    def get_total_token_counts(self) -> TokenUsage:
        return TokenUsage(

                return "<replaced>"


class Tracer:
    """Handles OpenTelemetry tracing.

    This class provides a simple interface for creating and managing traces,
    with support for sending to OTLP endpoints.

    When the OTEL_EXPORTER_OTLP_ENDPOINT environment variable is set, traces
    are sent to the OTLP endpoint.

    Both attributes are controlled by including "gen_ai_latest_experimental", "gen_ai_tool_definitions",

export interface OTelConfig {
  enabled: true
  serviceName: string
  tracesEndpoint: string
  headers: Record<string, string>
}

function parseBooleanFlag(value: string | undefined): boolean {
  if (typeof value !== 'string') return false
  const normalized = value.trim().toLowerCase()

    return system_data


def _log_agent_data(data_dict: dict):
    """
    Logs agent data and system information to the swarms.world telemetry endpoint via a POST request.

    This function is a low-level, internal utility that sends the provided agent state along with current
    system telemetry to the Swarms service for analytics and diagnostics. Data includes a timestamp,
    comprehensive system information, and the state of the agent as passed in `data_dict`.

    Args:
        data_dict (dict): Dictionary representing the current agent's state/config/data.

    from upsonic.integrations.langfuse import Langfuse


class AccuracyEvaluator:
    """
    The main orchestrator for running accuracy evaluations on Upsonic agents,
    graphs, or teams using the LLM-as-a-judge pattern.
    """

    def __init__(
        self,
        judge_agent: Agent,
        agent_under_test: Union[Agent, Graph, Team],

SPAN_NAME: str = "VectaraQueryEngine._query"


def setup_observer(config: AgentConfig, verbose: bool) -> bool:
    """
    Setup the observer.
    """
    if config.observer != ObserverType.ARIZE_PHOENIX:
        if verbose:
            print("No Phoenix observer set.")
        return False

    try:

/**
 * VoltAgent Observability - Built on OpenTelemetry
 *
 * This module provides OpenTelemetry-based observability with:
 * - WebSocket real-time events via custom SpanProcessor
 * - Local storage via custom SpanProcessor
 * - OTLP export support
 * - Zero-configuration defaults
 */