@friskai/frisk-js 0.3.0 → 0.3.2

package/dist/index.js

@@ -43602,13 +43602,6 @@ class MissingToolPoliciesExtensionError extends FriskError {
   }
 }
 
-class ToolCallSpanNotInitializedError extends Error {
-  constructor(message = "Tool call span has not been initialized. Call enter() first.") {
-    super(message);
-    this.name = "ToolCallSpanNotInitializedError";
-  }
-}
-
 // src/logging/console-logger.ts
 var LEVEL_PRIORITY = {
   error: 0,
@@ -44102,7 +44095,18 @@ var TRACER_NAME = "frisk_js_sdk";
 var TRACER_VERSION = "0.1.0";
 var SPAN_NAME_DECIDE_TOOL_CALL = "frisk.tool_call.decide";
 var SPAN_NAME_OBSERVE_TOOL_CALL = "frisk.tool_call.observation";
+var SPAN_NAME_LLM_CALL = "frisk.llm_call";
+var SPAN_NAME_OPERATION = "frisk.operation";
 var SPAN_NAME_FRISK_SESSION = "frisk.session";
+var ATTRIBUTE_NAME_LLM_CALL_SPAN_ID = "frisk.tool_call.llm_call_span_id";
+var ATTRIBUTE_NAME_LLM_CALL_PROMPTS_JSON = "frisk.llm_call.prompts.json";
+var ATTRIBUTE_NAME_LLM_CALL_RESPONSES_JSON = "frisk.llm_call.responses.json";
+var ATTRIBUTE_NAME_LLM_CALL_TOOL_CALLS_JSON = "frisk.llm_call.tool_calls.json";
+var ATTRIBUTE_NAME_MODEL_NAME = "frisk.model.name";
+var ATTRIBUTE_NAME_MODEL_PROVIDER = "frisk.model.provider";
+var ATTRIBUTE_NAME_TOKEN_USAGE_INPUT_TOKENS = "frisk.token_usage.input_tokens";
+var ATTRIBUTE_NAME_TOKEN_USAGE_OUTPUT_TOKENS = "frisk.token_usage.output_tokens";
+var ATTRIBUTE_NAME_TOKEN_USAGE_TOTAL_TOKENS = "frisk.token_usage.total_tokens";
 var ATTRIBUTE_NAME_SESSION_PROMPT = "frisk.session.prompt";
 var ATTRIBUTE_NAME_SESSION_ID = "frisk.session.id";
 var ATTRIBUTE_NAME_REMOTE_SESSION_ID = "frisk.session.remote_id";
@@ -48466,6 +48470,18 @@ var llmReasoningZodShape = {
   [LLM_REASONING_ARG_NAME]: string2().describe(LLM_REASONING_ARG_DESCRIPTION)
 };
 
+// src/core/llm-reasoning/extractLlmReasoning.ts
+function extractLlmReasoning(toolArgs) {
+  if (typeof toolArgs !== "object" || toolArgs === null || Array.isArray(toolArgs)) {
+    return null;
+  }
+  const rawReasoning = toolArgs[LLM_REASONING_ARG_NAME];
+  if (rawReasoning === null || rawReasoning === undefined) {
+    return null;
+  }
+  return String(rawReasoning);
+}
+
 // src/core/llm-reasoning/removeLlmReasoningArg.ts
 function removeLlmReasoningArg(input) {
   if (!(LLM_REASONING_ARG_NAME in input)) {
@@ -48511,136 +48527,186 @@ class SessionRegistry {
   }
 }
 
-// src/core/tool-call-span.ts
+// src/core/spans/frisk-span.ts
 var import_api = __toESM(require_src4(), 1);
 
-// src/core/redaction-options.ts
-function resolveRedactionOptions(options) {
-  return {
-    redactToolArgs: options?.redactToolArgs ?? false,
-    redactAgentState: options?.redactAgentState ?? false
-  };
-}
-
-// src/core/tool-call-span.ts
-class ToolCallSpan {
-  adapter;
-  toolCall;
-  friskToolId;
-  agentState;
-  parent;
-  tracer;
-  redaction;
-  _span = null;
-  _traceContextCarrier = null;
-  sessionId;
-  friskToolVersionId;
+class FriskSpan {
+  _spanName;
+  _attributeFields;
+  _otelSpan;
+  _attributes = {};
+  _ended = false;
   constructor({
-    sessionId,
-    adapter,
-    toolCall,
-    friskToolId,
-    friskToolVersionId,
-    agentState,
-    parent,
     tracer,
-    redact
+    parent,
+    spanName,
+    attributeFields
   }) {
-    this.sessionId = sessionId;
-    this.adapter = adapter;
-    this.toolCall = toolCall;
-    this.friskToolId = friskToolId ?? null;
-    this.friskToolVersionId = friskToolVersionId ?? null;
-    this.agentState = agentState;
-    this.parent = parent;
-    this.tracer = tracer;
-    this.redaction = resolveRedactionOptions(redact);
+    this._spanName = spanName;
+    this._attributeFields = attributeFields;
+    const parentContext = parent ? import_api.trace.setSpan(import_api.context.active(), parent.otelSpan) : import_api.context.active();
+    this._otelSpan = tracer.startSpan(this._spanName, undefined, parentContext);
   }
-  get span() {
-    if (!this._span) {
-      throw new ToolCallSpanNotInitializedError;
-    }
-    return this._span;
+  get otelSpan() {
+    return this._otelSpan;
   }
-  get traceContextCarrier() {
-    return this._traceContextCarrier;
+  get spanId() {
+    return this._otelSpan.spanContext().spanId;
   }
-  run(callback) {
-    this.enter();
-    try {
-      return callback(this);
-    } finally {
-      this.exit();
+  setAttribute(field, value) {
+    this.setAttributesByField({ [field]: value });
+  }
+  getAttribute(field) {
+    return this._attributes[this.constantFor(field)];
+  }
+  end() {
+    if (this._ended) {
+      return;
     }
+    this._ended = true;
+    this._otelSpan.end();
   }
-  async runAsync(callback) {
-    this.enter();
-    try {
-      return await callback(this);
-    } finally {
-      this.exit();
+  setAttributesByField(values) {
+    for (const [field, value] of Object.entries(values)) {
+      const constant = this.constantFor(field);
+      if (value === null || value === undefined) {
+        continue;
+      }
+      this._attributes[constant] = value;
+      this._otelSpan.setAttribute(constant, value);
     }
   }
-  setAttribute(key, value) {
-    this.span.setAttribute(key, value);
+  constantFor(field) {
+    const constant = this._attributeFields[field];
+    if (constant === undefined) {
+      throw new Error(`Unknown attribute '${field}' for ${this.constructor.name}`);
+    }
+    return constant;
   }
-  setAttributes(attributes) {
-    this.span.setAttributes(attributes);
+}
+// src/core/spans/llm-call-span.ts
+var FIELDS = {
+  sessionId: ATTRIBUTE_NAME_SESSION_ID,
+  promptsJson: ATTRIBUTE_NAME_LLM_CALL_PROMPTS_JSON,
+  responsesJson: ATTRIBUTE_NAME_LLM_CALL_RESPONSES_JSON,
+  toolCallsJson: ATTRIBUTE_NAME_LLM_CALL_TOOL_CALLS_JSON,
+  modelName: ATTRIBUTE_NAME_MODEL_NAME,
+  modelProvider: ATTRIBUTE_NAME_MODEL_PROVIDER,
+  inputTokens: ATTRIBUTE_NAME_TOKEN_USAGE_INPUT_TOKENS,
+  outputTokens: ATTRIBUTE_NAME_TOKEN_USAGE_OUTPUT_TOKENS,
+  totalTokens: ATTRIBUTE_NAME_TOKEN_USAGE_TOTAL_TOKENS,
+  errorType: ATTRIBUTE_NAME_ERROR_TYPE,
+  errorMessage: ATTRIBUTE_NAME_ERROR_MESSAGE
+};
+
+class LlmCallSpan extends FriskSpan {
+  constructor(args) {
+    super({ ...args, spanName: SPAN_NAME_LLM_CALL, attributeFields: FIELDS });
   }
-  saveResult(decision) {
-    if (!this.span) {
-      return;
-    }
-    this.setAttributes({
-      [ATTRIBUTE_NAME_DECISION_OUTCOME]: decision.outcome,
-      [ATTRIBUTE_NAME_DECISION_MATCHED_RULE_COUNT]: Number(decision.rulesMatchedCount)
+  setAttributes(values) {
+    this.setAttributesByField(values);
+  }
+}
+// src/core/spans/operation-span.ts
+var FIELDS2 = {
+  sessionId: ATTRIBUTE_NAME_SESSION_ID
+};
+
+class OperationSpan extends FriskSpan {
+  constructor(args) {
+    super({ ...args, spanName: SPAN_NAME_OPERATION, attributeFields: FIELDS2 });
+  }
+  setAttributes(values) {
+    this.setAttributesByField(values);
+  }
+}
+// src/core/spans/session-span.ts
+var FIELDS3 = {
+  sessionId: ATTRIBUTE_NAME_SESSION_ID,
+  remoteSessionId: ATTRIBUTE_NAME_REMOTE_SESSION_ID,
+  prompt: ATTRIBUTE_NAME_SESSION_PROMPT,
+  toolCallCount: ATTRIBUTE_NAME_TOOL_CALL_COUNT,
+  toolCallErrorCount: ATTRIBUTE_NAME_TOOL_CALL_ERROR_COUNT,
+  inputTokens: ATTRIBUTE_NAME_TOKEN_USAGE_INPUT_TOKENS,
+  outputTokens: ATTRIBUTE_NAME_TOKEN_USAGE_OUTPUT_TOKENS,
+  totalTokens: ATTRIBUTE_NAME_TOKEN_USAGE_TOTAL_TOKENS
+};
+
+class SessionSpan extends FriskSpan {
+  constructor(args) {
+    super({
+      ...args,
+      spanName: SPAN_NAME_FRISK_SESSION,
+      attributeFields: FIELDS3
     });
-    if (decision.reason) {
-      this.setAttribute(ATTRIBUTE_NAME_DECISION_REASON, decision.reason);
-    }
   }
-  saveError(error) {
-    if (!this.span) {
-      return;
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorType = error instanceof Error ? error.constructor.name : typeof error;
-    this.setAttributes({
-      [ATTRIBUTE_NAME_ERROR_TYPE]: errorType,
-      [ATTRIBUTE_NAME_ERROR_MESSAGE]: errorMessage
+  setAttributes(values) {
+    this.setAttributesByField(values);
+  }
+}
+// src/core/spans/tool-call-decision-span.ts
+var FIELDS4 = {
+  sessionId: ATTRIBUTE_NAME_SESSION_ID,
+  toolName: ATTRIBUTE_NAME_TOOL_NAME,
+  toolCallId: ATTRIBUTE_NAME_TOOL_CALL_ID,
+  toolArgsJson: ATTRIBUTE_NAME_TOOL_ARGS_JSON,
+  toolArgsRedactedPathsJson: ATTRIBUTE_NAME_TOOL_ARGS_REDACTED_PATHS_JSON,
+  agentStateJson: ATTRIBUTE_NAME_AGENT_STATE_JSON,
+  agentStateRedactedPathsJson: ATTRIBUTE_NAME_AGENT_STATE_REDACTED_PATHS_JSON,
+  friskToolId: ATTRIBUTE_NAME_FRISK_TOOL_ID,
+  friskToolVersionId: ATTRIBUTE_NAME_FRISK_TOOL_VERSION_ID,
+  llmReasoning: ATTRIBUTE_NAME_LLM_REASONING,
+  decisionOutcome: ATTRIBUTE_NAME_DECISION_OUTCOME,
+  decisionMatchedRuleCount: ATTRIBUTE_NAME_DECISION_MATCHED_RULE_COUNT,
+  decisionReason: ATTRIBUTE_NAME_DECISION_REASON,
+  errorType: ATTRIBUTE_NAME_ERROR_TYPE,
+  errorMessage: ATTRIBUTE_NAME_ERROR_MESSAGE
+};
+
+class ToolCallDecisionSpan extends FriskSpan {
+  constructor(args) {
+    super({
+      ...args,
+      spanName: SPAN_NAME_DECIDE_TOOL_CALL,
+      attributeFields: FIELDS4
     });
   }
-  enter() {
-    const parentContext = this.parent ? import_api.trace.setSpan(import_api.context.active(), this.parent) : import_api.context.active();
-    const redactedToolArgsResult = this.adapter.serializeToolArgs(removeLlmReasoningArg(this.toolCall.args), { redact: this.redaction.redactToolArgs });
-    const redactedAgentStateResult = this.adapter.serializeAgentState(this.agentState, { redact: this.redaction.redactAgentState });
-    this._span = this.tracer.startSpan(SPAN_NAME_DECIDE_TOOL_CALL, {
-      attributes: {
-        [ATTRIBUTE_NAME_SESSION_ID]: this.sessionId,
-        [ATTRIBUTE_NAME_TOOL_NAME]: this.toolCall.name,
-        ...this.friskToolId !== null ? { [ATTRIBUTE_NAME_FRISK_TOOL_ID]: this.friskToolId } : {},
-        ...this.friskToolVersionId !== null ? {
-          [ATTRIBUTE_NAME_FRISK_TOOL_VERSION_ID]: this.friskToolVersionId
-        } : {},
-        [ATTRIBUTE_NAME_TOOL_CALL_ID]: this.toolCall.id,
-        [ATTRIBUTE_NAME_TOOL_ARGS_JSON]: redactedToolArgsResult.value ?? "",
-        [ATTRIBUTE_NAME_TOOL_ARGS_REDACTED_PATHS_JSON]: JSON.stringify(redactedToolArgsResult.redactedPaths),
-        [ATTRIBUTE_NAME_AGENT_STATE_JSON]: redactedAgentStateResult.value ?? "",
-        [ATTRIBUTE_NAME_AGENT_STATE_REDACTED_PATHS_JSON]: JSON.stringify(redactedAgentStateResult.redactedPaths)
-      }
-    }, parentContext);
-    this._traceContextCarrier = {};
-    const spanContext = import_api.trace.setSpan(import_api.context.active(), this.span);
-    import_api.propagation.inject(spanContext, this._traceContextCarrier);
-  }
-  exit() {
-    if (!this.span) {
-      return;
-    }
-    this.span.end();
+  setAttributes(values) {
+    this.setAttributesByField(values);
   }
 }
+// src/core/spans/tool-call-observation-span.ts
+var FIELDS5 = {
+  sessionId: ATTRIBUTE_NAME_SESSION_ID,
+  toolName: ATTRIBUTE_NAME_TOOL_NAME,
+  toolCallId: ATTRIBUTE_NAME_TOOL_CALL_ID,
+  toolArgsJson: ATTRIBUTE_NAME_TOOL_ARGS_JSON,
+  toolArgsRedactedPathsJson: ATTRIBUTE_NAME_TOOL_ARGS_REDACTED_PATHS_JSON,
+  agentStateJson: ATTRIBUTE_NAME_AGENT_STATE_JSON,
+  agentStateRedactedPathsJson: ATTRIBUTE_NAME_AGENT_STATE_REDACTED_PATHS_JSON,
+  toolCallSequenceNumber: ATTRIBUTE_NAME_TOOL_CALL_SEQUENCE_NUMBER,
+  friskToolId: ATTRIBUTE_NAME_FRISK_TOOL_ID,
+  friskToolVersionId: ATTRIBUTE_NAME_FRISK_TOOL_VERSION_ID,
+  llmReasoning: ATTRIBUTE_NAME_LLM_REASONING,
+  isSuccess: ATTRIBUTE_NAME_TOOL_CALL_IS_SUCCESS,
+  isError: ATTRIBUTE_NAME_TOOL_CALL_IS_ERROR,
+  errorMessage: ATTRIBUTE_NAME_ERROR_MESSAGE,
+  errorType: ATTRIBUTE_NAME_ERROR_TYPE,
+  llmCallSpanId: ATTRIBUTE_NAME_LLM_CALL_SPAN_ID
+};
 
+class ToolCallObservationSpan extends FriskSpan {
+  constructor(args) {
+    super({
+      ...args,
+      spanName: SPAN_NAME_OBSERVE_TOOL_CALL,
+      attributeFields: FIELDS5
+    });
+  }
+  setAttributes(values) {
+    this.setAttributesByField(values);
+  }
+}
 // src/core/types.ts
 var DecisionOutcome;
 ((DecisionOutcome2) => {
@@ -48664,6 +48730,9 @@ class FriskSession {
   toolCallSequenceNumber = 0;
   toolCallSequenceGenerator = this.createToolCallSequenceGenerator();
   toolCallErrorCount = 0;
+  tokenUsageInput = 0;
+  tokenUsageOutput = 0;
+  tokenUsageTotal = 0;
   constructor({ frisk, redact, tracer, logging }) {
     const sessionId = this.constructor.generateSessionId();
     this.logger = deriveSdkLogger(logging, {
@@ -48686,12 +48755,34 @@ class FriskSession {
   get rootRunId() {
     return this._rootRunId;
   }
+  createLlmCallSpan({
+    parent
+  } = {}) {
+    const span = new LlmCallSpan({
+      tracer: this.tracer,
+      parent: parent ?? this._rootSpan
+    });
+    span.setAttributes({ sessionId: this.id });
+    return span;
+  }
+  createOperationSpan({
+    parent
+  } = {}) {
+    const span = new OperationSpan({
+      tracer: this.tracer,
+      parent: parent ?? this._rootSpan
+    });
+    span.setAttributes({ sessionId: this.id });
+    return span;
+  }
   async createToolCallSpan({
     name,
     args: toolArgsInput,
-    agentState
+    agentState,
+    parent
   }) {
     const toolArgs = this.validateToolArgs(toolArgsInput);
+    const llmReasoning = extractLlmReasoning(toolArgs);
     const redactedToolArgsResult = this.frisk.adapter?.serializeToolArgs(removeLlmReasoningArg(toolArgs), { redact: this.redaction.redactToolArgs }) ?? {
       value: "{}",
       redactedPaths: []
@@ -48701,26 +48792,30 @@ class FriskSession {
       value: "{}",
       redactedPaths: []
     };
-    const sessionSpan = this.rootSpan;
-    const parentContext = sessionSpan ? import_api2.trace.setSpan(import_api2.context.active(), sessionSpan) : import_api2.context.active();
-    const spanAttributes = {
-      [ATTRIBUTE_NAME_SESSION_ID]: this.id,
-      [ATTRIBUTE_NAME_TOOL_NAME]: name,
-      [ATTRIBUTE_NAME_TOOL_ARGS_JSON]: redactedToolArgsResult.value,
-      [ATTRIBUTE_NAME_TOOL_ARGS_REDACTED_PATHS_JSON]: JSON.stringify(redactedToolArgsResult.redactedPaths),
-      [ATTRIBUTE_NAME_AGENT_STATE_JSON]: redactedAgentStateResult.value ?? "{}",
-      [ATTRIBUTE_NAME_AGENT_STATE_REDACTED_PATHS_JSON]: JSON.stringify(redactedAgentStateResult.redactedPaths),
-      [ATTRIBUTE_NAME_TOOL_CALL_SEQUENCE_NUMBER]: this.toolCallSequenceGenerator.next().value
-    };
+    const span = new ToolCallObservationSpan({
+      tracer: this.tracer,
+      parent: parent ?? this._rootSpan
+    });
+    span.setAttributes({
+      sessionId: this.id,
+      toolName: name,
+      toolArgsJson: redactedToolArgsResult.value ?? "{}",
+      toolArgsRedactedPathsJson: JSON.stringify(redactedToolArgsResult.redactedPaths),
+      agentStateJson: redactedAgentStateResult.value ?? "{}",
+      agentStateRedactedPathsJson: JSON.stringify(redactedAgentStateResult.redactedPaths),
+      toolCallSequenceNumber: this.toolCallSequenceGenerator.next().value
+    });
     await this.frisk.toolRegistrationComplete;
     const registeredTool = this.frisk.getRegisteredTool(name);
     if (registeredTool) {
-      spanAttributes[ATTRIBUTE_NAME_FRISK_TOOL_ID] = registeredTool.id;
-      spanAttributes[ATTRIBUTE_NAME_FRISK_TOOL_VERSION_ID] = registeredTool.versionId;
+      span.setAttributes({
+        friskToolId: registeredTool.id,
+        friskToolVersionId: registeredTool.versionId
+      });
+    }
+    if (llmReasoning !== null) {
+      span.setAttributes({ llmReasoning });
     }
-    const span = this.getTracer().startSpan(SPAN_NAME_OBSERVE_TOOL_CALL, {
-      attributes: spanAttributes
-    }, parentContext);
     return span;
   }
   closeToolCallSpan({
@@ -48730,19 +48825,19 @@ class FriskSession {
     status
   }) {
     if (toolCallId) {
-      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_ID, toolCallId);
+      span.setAttributes({ toolCallId });
     }
     if (status === "error" /* Error */ || !!err) {
       this.incrementToolCallErrors();
-      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_IS_ERROR, true);
-      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_IS_SUCCESS, false);
+      span.setAttributes({ isError: true, isSuccess: false });
     } else if (status === "success" /* Success */) {
-      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_IS_SUCCESS, true);
-      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_IS_ERROR, false);
+      span.setAttributes({ isSuccess: true, isError: false });
     }
-    if (err && err instanceof Error) {
-      span.setAttribute(ATTRIBUTE_NAME_ERROR_MESSAGE, `${err}`);
-      span.setAttribute(ATTRIBUTE_NAME_ERROR_TYPE, `${err.constructor.name}`);
+    if (err instanceof Error) {
+      span.setAttributes({
+        errorMessage: `${err}`,
+        errorType: `${err.constructor.name}`
+      });
     }
     span.end();
   }
@@ -48756,32 +48851,37 @@ class FriskSession {
     agentState
   }) {
     const registeredTool = this.frisk.getRegisteredTool(toolCall.name);
-    const toolCallSpan = new ToolCallSpan({
-      sessionId: this.id,
-      adapter: this.frisk.adapter,
-      toolCall,
-      friskToolId: registeredTool?.id ?? null,
-      friskToolVersionId: registeredTool?.versionId ?? null,
-      agentState,
-      parent: this._rootSpan,
+    const redactedToolArgs = this.frisk.adapter.serializeToolArgs(removeLlmReasoningArg(toolCall.args), { redact: this.redaction.redactToolArgs });
+    const redactedAgentState = this.frisk.adapter.serializeAgentState(agentState, { redact: this.redaction.redactAgentState });
+    const llmReasoning = extractLlmReasoning(toolCall.args);
+    const span = new ToolCallDecisionSpan({
       tracer: this.tracer,
-      redact: this.redaction
+      parent: this._rootSpan
     });
-    const toolArgs = toolCall.args;
-    return toolCallSpan.run((span) => {
+    try {
+      span.setAttributes({
+        sessionId: this.id,
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        toolArgsJson: redactedToolArgs.value ?? "{}",
+        toolArgsRedactedPathsJson: JSON.stringify(redactedToolArgs.redactedPaths),
+        agentStateJson: redactedAgentState.value ?? "{}",
+        agentStateRedactedPathsJson: JSON.stringify(redactedAgentState.redactedPaths),
+        friskToolId: registeredTool?.id,
+        friskToolVersionId: registeredTool?.versionId,
+        llmReasoning: llmReasoning ?? undefined
+      });
+      const spanContext = import_api2.trace.setSpan(import_api2.context.active(), span.otelSpan);
+      const traceContextCarrier = {};
+      import_api2.propagation.inject(spanContext, traceContextCarrier);
       try {
-        if (LLM_REASONING_ARG_NAME in toolArgs) {
-          const llmReasoning = toolArgs[LLM_REASONING_ARG_NAME];
-          span.setAttribute(ATTRIBUTE_NAME_LLM_REASONING, llmReasoning);
-        }
-        const baseToolCallArgs = removeLlmReasoningArg(toolCall.args);
         const coreResult = this.frisk.decideToolCall({
           toolCall: {
             ...toolCall,
-            args: baseToolCallArgs
+            args: removeLlmReasoningArg(toolCall.args)
           },
           agentState,
-          traceContextCarrier: span.traceContextCarrier ?? undefined
+          traceContextCarrier
         });
         const result = {
           outcome: coreResult.outcome,
@@ -48790,7 +48890,11 @@ class FriskSession {
           policyId: coreResult.policyId,
           policyVersionId: coreResult.policyVersionId
         };
-        span.saveResult(result);
+        span.setAttributes({
+          decisionOutcome: result.outcome,
+          decisionMatchedRuleCount: Number(result.rulesMatchedCount),
+          decisionReason: result.reason ?? undefined
+        });
         return result;
       } catch (error) {
         const wrapped = new ToolCallEvaluationError(error);
@@ -48798,14 +48902,19 @@ class FriskSession {
           toolName: toolCall.name,
           toolCallId: toolCall.id
         });
-        span.saveError(wrapped);
+        span.setAttributes({
+          errorType: wrapped.constructor.name,
+          errorMessage: wrapped.message
+        });
         return {
           outcome: "error" /* ERROR */,
           rulesMatchedCount: 0,
           reason: wrapped.message
         };
       }
-    });
+    } finally {
+      span.end();
+    }
   }
   *createToolCallSequenceGenerator() {
     while (true) {
@@ -48821,24 +48930,49 @@ class FriskSession {
   getToolCallErrorCount() {
     return this.toolCallErrorCount;
   }
+  recordTokenUsage({
+    inputTokens = 0,
+    outputTokens = 0,
+    totalTokens = 0
+  }) {
+    this.tokenUsageInput += inputTokens;
+    this.tokenUsageOutput += outputTokens;
+    this.tokenUsageTotal += totalTokens;
+    this._rootSpan?.setAttributes({
+      inputTokens: this.tokenUsageInput,
+      outputTokens: this.tokenUsageOutput,
+      totalTokens: this.tokenUsageTotal
+    });
+  }
+  getTokenUsage() {
+    return {
+      inputTokens: this.tokenUsageInput,
+      outputTokens: this.tokenUsageOutput,
+      totalTokens: this.tokenUsageTotal
+    };
+  }
   initTracing({ runId, agentState }) {
     this._rootRunId = runId;
     this._isTracing = true;
     this._agentState = agentState;
-    const span = this.tracer.startSpan(SPAN_NAME_FRISK_SESSION);
-    span.setAttribute(ATTRIBUTE_NAME_SESSION_ID, this.id);
-    span.setAttribute(ATTRIBUTE_NAME_REMOTE_SESSION_ID, runId);
+    const span = new SessionSpan({ tracer: this.tracer });
+    span.setAttributes({ sessionId: this.id, remoteSessionId: runId });
     const userPrompt = this.frisk.adapter.extractPrompt?.(agentState);
     if (userPrompt) {
-      span.setAttribute(ATTRIBUTE_NAME_SESSION_PROMPT, userPrompt);
+      span.setAttributes({ prompt: userPrompt });
     }
     this.setRootSpan(span);
     return span;
   }
   endTracing() {
     if (this._rootSpan) {
-      this._rootSpan.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_COUNT, this.getToolCallCount());
-      this._rootSpan.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_ERROR_COUNT, this.getToolCallErrorCount());
+      this._rootSpan.setAttributes({
+        toolCallCount: this.getToolCallCount(),
+        toolCallErrorCount: this.getToolCallErrorCount(),
+        inputTokens: this.tokenUsageInput,
+        outputTokens: this.tokenUsageOutput,
+        totalTokens: this.tokenUsageTotal
+      });
       this._rootSpan.end();
     }
     this._isTracing = false;
@@ -48853,6 +48987,14 @@ class FriskSession {
   }
 }
 
+// src/core/redaction-options.ts
+function resolveRedactionOptions(options) {
+  return {
+    redactToolArgs: options?.redactToolArgs ?? false,
+    redactAgentState: options?.redactAgentState ?? false
+  };
+}
+
 // src/core/sdk-attributes/detect-runtime.ts
 function detectRuntime() {
   const g = globalThis;
@@ -48893,7 +49035,7 @@ import { fileURLToPath } from "node:url";
 
 // src/generated/sdk-meta.ts
 var SDK_NAME = "@friskai/frisk-js";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.2";
 
 // src/core/sdk-attributes/read-sdk-meta.ts
 function getSdkMeta() {
@@ -49561,16 +49703,21 @@ export {
   getEnv,
   combineRedactOptions,
   UnexpectedFriskServerResponseError,
-  ToolCallSpan,
+  ToolCallObservationSpan,
+  ToolCallDecisionSpan,
   ToolApprovalStatus,
+  SessionSpan,
   SessionRegistry,
   SessionNotFoundError,
+  OperationSpan,
   MissingOtlpEndpointError,
   MissingFriskSessionContextError,
   MissingBaseURLError,
   MissingAPIKeyError,
+  LlmCallSpan,
   InvalidFriskSessionError,
   InvalidAccessTokenError,
+  FriskSpan,
   FriskSession,
   FriskInvalidAPIKeyError,
   FriskError,
@@ -49586,5 +49733,5 @@ export {
   AccessTokenProvider
 };
 
-//# debugId=2B56BC442CE3397564756E2164756E21
+//# debugId=B3770FB94B39213764756E2164756E21
 //# sourceMappingURL=index.js.map