@friskai/frisk-js 0.2.6 → 0.2.10

package/dist/index.js

@@ -44016,6 +44016,8 @@ function redactDictionarySimple(data, redactOption) {
 }
 // src/framework-adapter/base-framework-adapter.ts
 class BaseFrameworkAdapter {
+  agentFramework = "none";
+  agentFrameworkVersion = null;
   serializeToolArgs(toolArgs, options) {
     if (toolArgs == null) {
       return { value: null, redactedPaths: [] };
@@ -44082,6 +44084,7 @@ var redactDictionary = nativeBindings.redactDictionary;
 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_FRISK_SESSION = "frisk.session";
 var ATTRIBUTE_NAME_SESSION_PROMPT = "frisk.session.prompt";
 var ATTRIBUTE_NAME_SESSION_ID = "frisk.session.id";
@@ -44100,7 +44103,11 @@ var ATTRIBUTE_NAME_DECISION_OUTCOME = "frisk.decision.outcome";
 var ATTRIBUTE_NAME_DECISION_REASON = "frisk.decision.reason";
 var ATTRIBUTE_NAME_ERROR_TYPE = "error.type";
 var ATTRIBUTE_NAME_ERROR_MESSAGE = "error.message";
-var ATTRIBUTE_NAME_LATENCY_NS = "latency_ns";
+var ATTRIBUTE_NAME_TOOL_CALL_IS_SUCCESS = "frisk.tool_call.is_success";
+var ATTRIBUTE_NAME_TOOL_CALL_IS_ERROR = "frisk.tool_call.is_error";
+var ATTRIBUTE_NAME_TOOL_CALL_COUNT = "frisk.tool_calls.count";
+var ATTRIBUTE_NAME_TOOL_CALL_ERROR_COUNT = "frisk.tool_calls.error_count";
+var ATTRIBUTE_NAME_TOOL_CALL_SEQUENCE_NUMBER = "frisk.tool_call.sequence_number";
 // src/telemetry/tracing-manager.ts
 var import_grpc_js = __toESM(require_src3(), 1);
 var import_exporter_trace_otlp_grpc = __toESM(require_src12(), 1);
@@ -44156,6 +44163,9 @@ class TracingManager {
   }
 }
 
+// src/core/frisk-session.ts
+var import_api2 = __toESM(require_src4(), 1);
+
 // ../../node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
   status: "aborted"
@@ -48505,7 +48515,6 @@ class ToolCallSpan {
   tracer;
   redaction;
   _span = null;
-  _startTimeNs = null;
   _traceContextCarrier = null;
   sessionId;
   friskToolVersionId;
@@ -48586,7 +48595,6 @@ class ToolCallSpan {
   }
   enter() {
     const parentContext = this.parent ? import_api.trace.setSpan(import_api.context.active(), this.parent) : import_api.context.active();
-    this._startTimeNs = process.hrtime.bigint();
     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, {
@@ -48612,11 +48620,6 @@ class ToolCallSpan {
     if (!this.span) {
       return;
     }
-    if (this._startTimeNs !== null) {
-      const endTimeNs = process.hrtime.bigint();
-      const latencyNs = endTimeNs - this._startTimeNs;
-      this.setAttribute(ATTRIBUTE_NAME_LATENCY_NS, Number(latencyNs));
-    }
     this.span.end();
   }
 }
@@ -48634,12 +48637,15 @@ var DecisionOutcome;
 class FriskSession {
   frisk;
   id;
-  rootSpan = null;
+  _rootSpan = null;
   redaction;
   tracer;
   logger;
   _rootRunId = null;
   _isTracing = false;
+  toolCallSequenceNumber = 0;
+  toolCallSequenceGenerator = this.createToolCallSequenceGenerator();
+  toolCallErrorCount = 0;
   constructor({ frisk, redact, tracer, logging }) {
     const sessionId = this.constructor.generateSessionId();
     this.logger = deriveSdkLogger(logging, {
@@ -48650,12 +48656,75 @@ class FriskSession {
     this.redaction = redact;
     this.tracer = tracer;
   }
+  get rootSpan() {
+    return this._rootSpan;
+  }
+  getTracer() {
+    return this.tracer;
+  }
   get isTracing() {
     return this._isTracing;
   }
   get rootRunId() {
     return this._rootRunId;
   }
+  async createToolCallSpan({
+    name,
+    args: toolArgsInput
+  }) {
+    const toolArgs = this.validateToolArgs(toolArgsInput);
+    const redactedToolArgsResult = this.frisk.adapter?.serializeToolArgs(removeLlmReasoningArg(toolArgs), { redact: this.redaction.redactToolArgs }) ?? {
+      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_TOOL_CALL_SEQUENCE_NUMBER]: 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;
+    }
+    const span = this.getTracer().startSpan(SPAN_NAME_OBSERVE_TOOL_CALL, {
+      attributes: spanAttributes
+    }, parentContext);
+    return span;
+  }
+  closeToolCallSpan({
+    toolCallId,
+    span,
+    err,
+    status
+  }) {
+    if (toolCallId) {
+      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_ID, 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);
+    } else if (status === "success" /* Success */) {
+      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_IS_SUCCESS, true);
+      span.setAttribute(ATTRIBUTE_NAME_TOOL_CALL_IS_ERROR, false);
+    }
+    if (err && err instanceof Error) {
+      span.setAttribute(ATTRIBUTE_NAME_ERROR_MESSAGE, `${err}`);
+      span.setAttribute(ATTRIBUTE_NAME_ERROR_TYPE, `${err.constructor.name}`);
+    }
+    span.end();
+  }
+  validateToolArgs(parsedToolArgs) {
+    const isPlainObject2 = typeof parsedToolArgs === "object" && parsedToolArgs !== null && !Array.isArray(parsedToolArgs) && (Object.getPrototypeOf(parsedToolArgs) === Object.prototype || Object.getPrototypeOf(parsedToolArgs) === null);
+    const toolArgs = isPlainObject2 ? parsedToolArgs : {};
+    return toolArgs;
+  }
   decideToolCall({
     toolCall,
     agentState
@@ -48668,7 +48737,7 @@ class FriskSession {
       friskToolId: registeredTool?.id ?? null,
       friskToolVersionId: registeredTool?.versionId ?? null,
       agentState,
-      parent: this.rootSpan,
+      parent: this._rootSpan,
       tracer: this.tracer,
       redact: this.redaction
     });
@@ -48712,6 +48781,20 @@ class FriskSession {
       }
     });
   }
+  *createToolCallSequenceGenerator() {
+    while (true) {
+      yield this.toolCallSequenceNumber++;
+    }
+  }
+  getToolCallCount() {
+    return this.toolCallSequenceNumber;
+  }
+  incrementToolCallErrors() {
+    this.toolCallErrorCount += 1;
+  }
+  getToolCallErrorCount() {
+    return this.toolCallErrorCount;
+  }
   initTracing({ runId, inputs }) {
     this._rootRunId = runId;
     this._isTracing = true;
@@ -48726,21 +48809,141 @@ class FriskSession {
     return span;
   }
   endTracing() {
-    if (this.rootSpan) {
-      this.rootSpan.end();
+    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.end();
     }
     this._isTracing = false;
     const registry2 = SessionRegistry.getInstance();
     registry2.unregister(this.id);
   }
   setRootSpan(span) {
-    this.rootSpan = span;
+    this._rootSpan = span;
   }
   static generateSessionId() {
     return v4();
   }
 }
 
+// src/core/sdk-attributes/detect-runtime.ts
+function detectRuntime() {
+  const g = globalThis;
+  if (g.Bun) {
+    return {
+      runtime: "bun",
+      runtimeVersion: g.Bun.version
+    };
+  }
+  if (g.Deno) {
+    return {
+      runtime: "deno",
+      runtimeVersion: g.Deno.version.deno
+    };
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return {
+      runtime: "node",
+      runtimeVersion: process.versions.node
+    };
+  }
+  if (typeof navigator !== "undefined") {
+    return {
+      runtime: "browser",
+      runtimeVersion: navigator.userAgent
+    };
+  }
+  return {
+    runtime: "unknown",
+    runtimeVersion: "unknown"
+  };
+}
+
+// src/core/sdk-attributes/read-sdk-meta.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/generated/sdk-meta.ts
+var SDK_NAME = "@friskai/frisk-js";
+var SDK_VERSION = "0.2.10";
+
+// src/core/sdk-attributes/read-sdk-meta.ts
+function getSdkMeta() {
+  if (isNonEmptyString(SDK_NAME) && isNonEmptyString(SDK_VERSION)) {
+    return {
+      sdkName: SDK_NAME,
+      sdkVersion: SDK_VERSION,
+      source: "injected"
+    };
+  }
+  const fromPkg = tryReadPackageJson();
+  if (fromPkg) {
+    return {
+      ...fromPkg,
+      source: "package.json"
+    };
+  }
+  return {
+    sdkName: "unknown",
+    sdkVersion: "unknown",
+    source: "unknown"
+  };
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function findNearestPackageJson(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function tryReadPackageJson() {
+  try {
+    const here = dirname2(fileURLToPath(import.meta.url));
+    const pkgPath = findNearestPackageJson(here);
+    if (!pkgPath)
+      return null;
+    const raw = readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    if (!isNonEmptyString(pkg.name) || !isNonEmptyString(pkg.version)) {
+      return null;
+    }
+    return {
+      sdkName: pkg.name,
+      sdkVersion: pkg.version
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/core/sdk-attributes/get-core-sdk-attributes.ts
+var coreSdkAttributes = null;
+function getCoreSdkAttributes() {
+  if (!coreSdkAttributes) {
+    const { sdkName, sdkVersion } = getSdkMeta();
+    const { runtime, runtimeVersion } = detectRuntime();
+    coreSdkAttributes = {
+      version: sdkVersion,
+      language: "js",
+      name: sdkName,
+      runtime,
+      runtimeVersion
+    };
+  }
+  return coreSdkAttributes;
+}
+
 // src/core/tool-approval-request.ts
 var REQUEST_TIMEOUT_MS = 1e4;
 var logger = deriveSdkLogger(undefined, {
@@ -49018,16 +49221,25 @@ class ToolRegistry {
   getRegisteredTool(toolName) {
     return this.toolNameToId.get(toolName) ?? null;
   }
-  registerTools(properties) {
-    const propertiesList = [...properties];
-    if (propertiesList.length === 0) {
+  registerTools({
+    tools,
+    sdkAttributes
+  }) {
+    const toolsList = [...tools];
+    if (toolsList.length === 0 && !sdkAttributes) {
       this.initialized = Promise.resolve(true);
       return;
     }
-    this.initialized = this.executeRegisterTools(propertiesList);
+    this.initialized = this.executeRegisterTools({
+      tools: toolsList,
+      sdkAttributes
+    });
     this.initialized;
   }
-  async executeRegisterTools(properties) {
+  async executeRegisterTools({
+    tools,
+    sdkAttributes
+  }) {
     try {
       const accessToken = await this.getAccessToken();
       const response = await fetch(buildRegisterToolsEndpoint(this.apiBaseUrl), {
@@ -49037,13 +49249,14 @@ class ToolRegistry {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          properties: properties.map((property) => ({
+          properties: tools.map((property) => ({
             name: property.name,
             description: property.description,
             inputJsonSchema: property.inputJsonSchema,
             outputJsonSchema: property.outputJsonSchema,
             responseFormat: property.responseFormat
-          }))
+          })),
+          sdk: sdkAttributes
         })
       });
       if (!response.ok) {
@@ -49064,18 +49277,22 @@ class ToolRegistry {
 
 // src/core/frisk.ts
 class Frisk {
-  redaction;
+  get redaction() {
+    return this._redaction;
+  }
+  _redaction;
   apiBaseUrl;
   otlpEndpoint;
   accessTokenProvider;
   initialized = false;
   rootLogger;
   logger;
-  logLevel;
+  _logLevel;
   _adapter;
   _friskHandle = null;
   _tracingManager = null;
   _toolRegistry;
+  sdkAttributes;
   wrapToolsCalled = false;
   get toolRegistrationComplete() {
     if (!this.wrapToolsCalled) {
@@ -49083,6 +49300,9 @@ class Frisk {
     }
     return this._toolRegistry.initialized;
   }
+  get logLevel() {
+    return this._logLevel;
+  }
   static async connect(options) {
     const instance = new this(options);
     await instance.connect();
@@ -49092,13 +49312,15 @@ class Frisk {
     this.rootLogger = deriveSdkLogger(options?.logging, {
       sdk: "frisk"
     });
-    this.logLevel = options?.logging?.logLevel;
+    this._logLevel = options?.logging?.logLevel;
     this.logger = deriveSdkLogger({
       logger: this.rootLogger,
-      logLevel: this.logLevel
+      logLevel: this._logLevel
     }, {
       component: "FriskCore"
     });
+    this._adapter = options?.adapter ?? new BaseFrameworkAdapter;
+    this.sdkAttributes = this.getSdkAttributes();
     const apiKey = options?.apiKey ?? getEnv(FRISK_API_KEY);
     if (!apiKey) {
       throw new MissingAPIKeyError;
@@ -49113,7 +49335,7 @@ class Frisk {
       baseUrl,
       logging: {
         logger: this.rootLogger,
-        logLevel: this.logLevel
+        logLevel: this._logLevel
       }
     });
     this._toolRegistry = new ToolRegistry({
@@ -49126,8 +49348,7 @@ class Frisk {
       throw new MissingOtlpEndpointError;
     }
     this.otlpEndpoint = otlpEndpoint;
-    this.redaction = resolveRedactionOptions(options?.redact);
-    this._adapter = options?.adapter ?? new BaseFrameworkAdapter;
+    this._redaction = resolveRedactionOptions(options?.redact);
   }
   get friskHandle() {
     if (!this._friskHandle) {
@@ -49165,11 +49386,11 @@ class Frisk {
   session(metadata) {
     const session = new FriskSession({
       frisk: this,
-      redact: this.redaction,
+      redact: this._redaction,
       tracer: this.tracingManager.getTracer(),
       logging: {
         logger: this.rootLogger,
-        logLevel: this.logLevel
+        logLevel: this._logLevel
       }
     });
     const registry2 = SessionRegistry.getInstance();
@@ -49184,13 +49405,23 @@ class Frisk {
     const toolList = [...tools];
     const registerToolProperties = toolList.map((tool) => this._adapter.extractRegisterToolProperties?.(tool)).filter((properties) => properties !== null && properties !== undefined);
     if (registerToolProperties.length > 0) {
-      this._toolRegistry.registerTools(registerToolProperties);
+      this._toolRegistry.registerTools({
+        tools: registerToolProperties,
+        sdkAttributes: this.sdkAttributes
+      });
     }
     if (this._adapter.wrapTools) {
       return this._adapter.wrapTools(toolList, options);
     }
     return toolList;
   }
+  getSdkAttributes() {
+    return {
+      ...getCoreSdkAttributes(),
+      agentFramework: this.adapter.agentFramework ?? null,
+      agentFrameworkVersion: this.adapter.agentFrameworkVersion ?? null
+    };
+  }
   wrapTool(tool, options = DefaultWrapToolOptions) {
     if (this._adapter.wrapTool) {
       return this._adapter.wrapTool(tool, options);
@@ -49217,7 +49448,7 @@ class Frisk {
     const argsJson = toolCall.args ? JSON.stringify(removeLlmReasoningArg(toolCall.args)) : null;
     const stateJson = agentState ? JSON.stringify(agentState) : null;
     const registeredTool = this.getRegisteredTool(toolCall.name);
-    const coreResult = this.friskHandle.process(toolCall.name, registeredTool?.id ?? null, registeredTool?.versionId ?? null, argsJson, stateJson, id, this.redaction, traceContextCarrier);
+    const coreResult = this.friskHandle.process(toolCall.name, registeredTool?.id ?? null, registeredTool?.versionId ?? null, argsJson, stateJson, id, this._redaction, traceContextCarrier);
     const outcome = coreResult.decision === "allow" ? "allow" /* ALLOW */ : coreResult.decision === "deny" ? "deny" /* DENY */ : coreResult.decision === "escalate" ? "escalate" /* ESCALATE */ : "error" /* ERROR */;
     return {
       outcome,
@@ -49309,5 +49540,5 @@ export {
   AccessTokenProvider
 };
 
-//# debugId=9E26BF51C17C2C7B64756E2164756E21
+//# debugId=40ACC90B60961E6C64756E2164756E21
 //# sourceMappingURL=index.js.map