@friskai/frisk-js 0.2.4 → 0.2.8

package/dist/adapters/claude/index.js

@@ -43678,6 +43678,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: [] };
@@ -43715,6 +43717,9 @@ class BaseFrameworkAdapter {
     const prompt = agentState["prompt"];
     return typeof prompt === "string" ? prompt : null;
   }
+  extractRegisterToolProperties(_tool) {
+    return null;
+  }
 }
 // src/framework-adapter/framework-adapter.ts
 var DefaultWrapToolOptions = {
@@ -43843,12 +43848,15 @@ 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";
 var ATTRIBUTE_NAME_REMOTE_SESSION_ID = "frisk.session.remote_id";
 var ATTRIBUTE_NAME_LLM_REASONING = "frisk.llm_reasoning";
 var ATTRIBUTE_NAME_TOOL_NAME = "frisk.tool.name";
+var ATTRIBUTE_NAME_FRISK_TOOL_ID = "frisk.tool.id";
+var ATTRIBUTE_NAME_FRISK_TOOL_VERSION_ID = "frisk.tool.version_id";
 var ATTRIBUTE_NAME_TOOL_CALL_ID = "frisk.tool_call.id";
 var ATTRIBUTE_NAME_TOOL_ARGS_JSON = "frisk.tool.args.json";
 var ATTRIBUTE_NAME_TOOL_ARGS_REDACTED_PATHS_JSON = "frisk.tool.args_redacted_paths.json";
@@ -43860,6 +43868,8 @@ 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";
 // src/telemetry/tracing-manager.ts
 var import_grpc_js = __toESM(require_src3(), 1);
 var import_exporter_trace_otlp_grpc = __toESM(require_src12(), 1);
@@ -47318,10 +47328,92 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
+var numberProcessor = (schema, ctx, _json, _params) => {
+  const json = _json;
+  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  if (typeof format === "string" && format.includes("int"))
+    json.type = "integer";
+  else
+    json.type = "number";
+  if (typeof exclusiveMinimum === "number") {
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+      json.minimum = exclusiveMinimum;
+      json.exclusiveMinimum = true;
+    } else {
+      json.exclusiveMinimum = exclusiveMinimum;
+    }
+  }
+  if (typeof minimum === "number") {
+    json.minimum = minimum;
+    if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
+      if (exclusiveMinimum >= minimum)
+        delete json.minimum;
+      else
+        delete json.exclusiveMinimum;
+    }
+  }
+  if (typeof exclusiveMaximum === "number") {
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+      json.maximum = exclusiveMaximum;
+      json.exclusiveMaximum = true;
+    } else {
+      json.exclusiveMaximum = exclusiveMaximum;
+    }
+  }
+  if (typeof maximum === "number") {
+    json.maximum = maximum;
+    if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
+      if (exclusiveMaximum <= maximum)
+        delete json.maximum;
+      else
+        delete json.exclusiveMaximum;
+    }
+  }
+  if (typeof multipleOf === "number")
+    json.multipleOf = multipleOf;
+};
+var booleanProcessor = (_schema, _ctx, json, _params) => {
+  json.type = "boolean";
+};
+var bigintProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("BigInt cannot be represented in JSON Schema");
+  }
+};
+var symbolProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Symbols cannot be represented in JSON Schema");
+  }
+};
+var nullProcessor = (_schema, ctx, json, _params) => {
+  if (ctx.target === "openapi-3.0") {
+    json.type = "string";
+    json.nullable = true;
+    json.enum = [null];
+  } else {
+    json.type = "null";
+  }
+};
+var undefinedProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Undefined cannot be represented in JSON Schema");
+  }
+};
+var voidProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Void cannot be represented in JSON Schema");
+  }
+};
 var neverProcessor = (_schema, _ctx, json, _params) => {
   json.not = {};
 };
+var anyProcessor = (_schema, _ctx, _json, _params) => {};
 var unknownProcessor = (_schema, _ctx, _json, _params) => {};
+var dateProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Date cannot be represented in JSON Schema");
+  }
+};
 var enumProcessor = (schema, _ctx, json, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
@@ -47331,16 +47423,109 @@ var enumProcessor = (schema, _ctx, json, _params) => {
     json.type = "string";
   json.enum = values;
 };
+var literalProcessor = (schema, ctx, json, _params) => {
+  const def = schema._zod.def;
+  const vals = [];
+  for (const val of def.values) {
+    if (val === undefined) {
+      if (ctx.unrepresentable === "throw") {
+        throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+      } else {}
+    } else if (typeof val === "bigint") {
+      if (ctx.unrepresentable === "throw") {
+        throw new Error("BigInt literals cannot be represented in JSON Schema");
+      } else {
+        vals.push(Number(val));
+      }
+    } else {
+      vals.push(val);
+    }
+  }
+  if (vals.length === 0) {} else if (vals.length === 1) {
+    const val = vals[0];
+    json.type = val === null ? "null" : typeof val;
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+      json.enum = [val];
+    } else {
+      json.const = val;
+    }
+  } else {
+    if (vals.every((v) => typeof v === "number"))
+      json.type = "number";
+    if (vals.every((v) => typeof v === "string"))
+      json.type = "string";
+    if (vals.every((v) => typeof v === "boolean"))
+      json.type = "boolean";
+    if (vals.every((v) => v === null))
+      json.type = "null";
+    json.enum = vals;
+  }
+};
+var nanProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("NaN cannot be represented in JSON Schema");
+  }
+};
+var templateLiteralProcessor = (schema, _ctx, json, _params) => {
+  const _json = json;
+  const pattern = schema._zod.pattern;
+  if (!pattern)
+    throw new Error("Pattern not found in template literal");
+  _json.type = "string";
+  _json.pattern = pattern.source;
+};
+var fileProcessor = (schema, _ctx, json, _params) => {
+  const _json = json;
+  const file = {
+    type: "string",
+    format: "binary",
+    contentEncoding: "binary"
+  };
+  const { minimum, maximum, mime } = schema._zod.bag;
+  if (minimum !== undefined)
+    file.minLength = minimum;
+  if (maximum !== undefined)
+    file.maxLength = maximum;
+  if (mime) {
+    if (mime.length === 1) {
+      file.contentMediaType = mime[0];
+      Object.assign(_json, file);
+    } else {
+      Object.assign(_json, file);
+      _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
+    }
+  } else {
+    Object.assign(_json, file);
+  }
+};
+var successProcessor = (_schema, _ctx, json, _params) => {
+  json.type = "boolean";
+};
 var customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
     throw new Error("Custom types cannot be represented in JSON Schema");
   }
 };
+var functionProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Function types cannot be represented in JSON Schema");
+  }
+};
 var transformProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
     throw new Error("Transforms cannot be represented in JSON Schema");
   }
 };
+var mapProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Map cannot be represented in JSON Schema");
+  }
+};
+var setProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Set cannot be represented in JSON Schema");
+  }
+};
 var arrayProcessor = (schema, ctx, _json, params) => {
   const json = _json;
   const def = schema._zod.def;
@@ -47418,6 +47603,84 @@ var intersectionProcessor = (schema, ctx, json, params) => {
   ];
   json.allOf = allOf;
 };
+var tupleProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "array";
+  const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+  const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
+    ...params,
+    path: [...params.path, prefixPath, i]
+  }));
+  const rest = def.rest ? process2(def.rest, ctx, {
+    ...params,
+    path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
+  }) : null;
+  if (ctx.target === "draft-2020-12") {
+    json.prefixItems = prefixItems;
+    if (rest) {
+      json.items = rest;
+    }
+  } else if (ctx.target === "openapi-3.0") {
+    json.items = {
+      anyOf: prefixItems
+    };
+    if (rest) {
+      json.items.anyOf.push(rest);
+    }
+    json.minItems = prefixItems.length;
+    if (!rest) {
+      json.maxItems = prefixItems.length;
+    }
+  } else {
+    json.items = prefixItems;
+    if (rest) {
+      json.additionalItems = rest;
+    }
+  }
+  const { minimum, maximum } = schema._zod.bag;
+  if (typeof minimum === "number")
+    json.minItems = minimum;
+  if (typeof maximum === "number")
+    json.maxItems = maximum;
+};
+var recordProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "object";
+  const keyType = def.keyType;
+  const keyBag = keyType._zod.bag;
+  const patterns = keyBag?.patterns;
+  if (def.mode === "loose" && patterns && patterns.size > 0) {
+    const valueSchema = process2(def.valueType, ctx, {
+      ...params,
+      path: [...params.path, "patternProperties", "*"]
+    });
+    json.patternProperties = {};
+    for (const pattern of patterns) {
+      json.patternProperties[pattern.source] = valueSchema;
+    }
+  } else {
+    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+      json.propertyNames = process2(def.keyType, ctx, {
+        ...params,
+        path: [...params.path, "propertyNames"]
+      });
+    }
+    json.additionalProperties = process2(def.valueType, ctx, {
+      ...params,
+      path: [...params.path, "additionalProperties"]
+    });
+  }
+  const keyValues = keyType._zod.values;
+  if (keyValues) {
+    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+    if (validKeyValues.length > 0) {
+      json.required = validKeyValues;
+    }
+  }
+};
 var nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const inner = process2(def.innerType, ctx, params);
@@ -47477,12 +47740,99 @@ var readonlyProcessor = (schema, ctx, json, params) => {
   seen.ref = def.innerType;
   json.readOnly = true;
 };
+var promiseProcessor = (schema, ctx, _json, params) => {
+  const def = schema._zod.def;
+  process2(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+};
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
+var lazyProcessor = (schema, ctx, _json, params) => {
+  const innerType = schema._zod.innerType;
+  process2(innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
+};
+var allProcessors = {
+  string: stringProcessor,
+  number: numberProcessor,
+  boolean: booleanProcessor,
+  bigint: bigintProcessor,
+  symbol: symbolProcessor,
+  null: nullProcessor,
+  undefined: undefinedProcessor,
+  void: voidProcessor,
+  never: neverProcessor,
+  any: anyProcessor,
+  unknown: unknownProcessor,
+  date: dateProcessor,
+  enum: enumProcessor,
+  literal: literalProcessor,
+  nan: nanProcessor,
+  template_literal: templateLiteralProcessor,
+  file: fileProcessor,
+  success: successProcessor,
+  custom: customProcessor,
+  function: functionProcessor,
+  transform: transformProcessor,
+  map: mapProcessor,
+  set: setProcessor,
+  array: arrayProcessor,
+  object: objectProcessor,
+  union: unionProcessor,
+  intersection: intersectionProcessor,
+  tuple: tupleProcessor,
+  record: recordProcessor,
+  nullable: nullableProcessor,
+  nonoptional: nonoptionalProcessor,
+  default: defaultProcessor,
+  prefault: prefaultProcessor,
+  catch: catchProcessor,
+  pipe: pipeProcessor,
+  readonly: readonlyProcessor,
+  promise: promiseProcessor,
+  optional: optionalProcessor,
+  lazy: lazyProcessor
+};
+function toJSONSchema(input, params) {
+  if ("_idmap" in input) {
+    const registry2 = input;
+    const ctx2 = initializeContext({ ...params, processors: allProcessors });
+    const defs = {};
+    for (const entry of registry2._idmap.entries()) {
+      const [_, schema] = entry;
+      process2(schema, ctx2);
+    }
+    const schemas = {};
+    const external = {
+      registry: registry2,
+      uri: params?.uri,
+      defs
+    };
+    ctx2.external = external;
+    for (const entry of registry2._idmap.entries()) {
+      const [key, schema] = entry;
+      extractDefs(ctx2, schema);
+      schemas[key] = finalize(ctx2, schema);
+    }
+    if (Object.keys(defs).length > 0) {
+      const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
+      schemas.__shared = {
+        [defsSegment]: defs
+      };
+    }
+    return { schemas };
+  }
+  const ctx = initializeContext({ ...params, processors: allProcessors });
+  process2(input, ctx);
+  extractDefs(ctx, input);
+  return finalize(ctx, input);
+}
 // ../../node_modules/zod/v4/classic/iso.js
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
   $ZodISODateTime.init(inst, def);
@@ -48155,6 +48505,7 @@ function resolveRedactionOptions(options) {
 class ToolCallSpan {
   adapter;
   toolCall;
+  friskToolId;
   agentState;
   parent;
   tracer;
@@ -48163,10 +48514,13 @@ class ToolCallSpan {
   _startTimeNs = null;
   _traceContextCarrier = null;
   sessionId;
+  friskToolVersionId;
   constructor({
     sessionId,
     adapter,
     toolCall,
+    friskToolId,
+    friskToolVersionId,
     agentState,
     parent,
     tracer,
@@ -48175,6 +48529,8 @@ class ToolCallSpan {
     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;
@@ -48243,6 +48599,10 @@ class ToolCallSpan {
       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),
@@ -48280,7 +48640,7 @@ var DecisionOutcome;
 class FriskSession {
   frisk;
   id;
-  rootSpan = null;
+  _rootSpan = null;
   redaction;
   tracer;
   logger;
@@ -48296,6 +48656,12 @@ class FriskSession {
     this.redaction = redact;
     this.tracer = tracer;
   }
+  get rootSpan() {
+    return this._rootSpan;
+  }
+  getTracer() {
+    return this.tracer;
+  }
   get isTracing() {
     return this._isTracing;
   }
@@ -48306,12 +48672,15 @@ class FriskSession {
     toolCall,
     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,
+      parent: this._rootSpan,
       tracer: this.tracer,
       redact: this.redaction
     });
@@ -48369,21 +48738,139 @@ class FriskSession {
     return span;
   }
   endTracing() {
-    if (this.rootSpan) {
-      this.rootSpan.end();
+    if (this._rootSpan) {
+      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.8";
+
+// 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, {
@@ -48493,6 +48980,8 @@ async function safeReadErrorBody(response) {
 async function getOrCreateToolApprovalRequest({
   toolCallId,
   toolName,
+  toolId,
+  toolVersionId,
   policyId,
   policyVersionId,
   sessionId,
@@ -48505,7 +48994,9 @@ async function getOrCreateToolApprovalRequest({
     policyId,
     policyVersionId,
     sessionId,
-    toolName
+    toolName,
+    ...toolId == null ? {} : { toolId },
+    ...toolVersionId == null ? {} : { toolVersionId }
   };
   try {
     logger.debug?.(`Creating tool approval request for tool call ${toolCallId}`);
@@ -48538,7 +49029,9 @@ async function getOrCreateManyToolApprovalRequests({
       toolCallId: input.toolCallId,
       policyId: input.policyId,
       policyVersionId: input.policyVersionId,
-      toolName: input.toolName
+      toolName: input.toolName,
+      toolId: input.toolId ?? null,
+      toolVersionId: input.toolVersionId ?? null
     })),
     agentId: "unknown",
     organizationId: "unknown",
@@ -48616,19 +49109,127 @@ async function cancelManyToolApprovalRequests({
   }
 }
 
+// src/core/tool-registry.ts
+function buildRegisterToolsEndpoint(apiBaseUrl) {
+  return new URL("/tool-registry/register-tools", apiBaseUrl).toString();
+}
+function parseRegisterToolsResponse(responseJson) {
+  if (!Array.isArray(responseJson)) {
+    throw new TypeError("registerTools response must be an array");
+  }
+  const toolNameToId = {};
+  for (const [index, item] of responseJson.entries()) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      throw new TypeError(`registerTools response item at index ${index} must be an object`);
+    }
+    const { id: toolId, name: toolName } = item;
+    if (typeof toolId !== "string" || toolId.length === 0) {
+      throw new TypeError(`registerTools response item at index ${index} is missing a valid id`);
+    }
+    if (typeof toolName !== "string" || toolName.length === 0) {
+      throw new TypeError(`registerTools response item at index ${index} is missing a valid name`);
+    }
+    toolNameToId[toolName] = item;
+  }
+  return toolNameToId;
+}
+
+class ToolRegistry {
+  initialized = Promise.resolve(true);
+  apiBaseUrl;
+  getAccessToken;
+  logger;
+  toolNameToId = new Map;
+  constructor({ apiBaseUrl, getAccessToken, logger: logger2 }) {
+    this.apiBaseUrl = apiBaseUrl;
+    this.getAccessToken = getAccessToken;
+    this.logger = logger2;
+  }
+  getRegisteredTool(toolName) {
+    return this.toolNameToId.get(toolName) ?? null;
+  }
+  registerTools({
+    tools,
+    sdkAttributes
+  }) {
+    const toolsList = [...tools];
+    if (toolsList.length === 0 && !sdkAttributes) {
+      this.initialized = Promise.resolve(true);
+      return;
+    }
+    this.initialized = this.executeRegisterTools({
+      tools: toolsList,
+      sdkAttributes
+    });
+    this.initialized;
+  }
+  async executeRegisterTools({
+    tools,
+    sdkAttributes
+  }) {
+    try {
+      const accessToken = await this.getAccessToken();
+      const response = await fetch(buildRegisterToolsEndpoint(this.apiBaseUrl), {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          properties: tools.map((property) => ({
+            name: property.name,
+            description: property.description,
+            inputJsonSchema: property.inputJsonSchema,
+            outputJsonSchema: property.outputJsonSchema,
+            responseFormat: property.responseFormat
+          })),
+          sdk: sdkAttributes
+        })
+      });
+      if (!response.ok) {
+        this.logger?.error?.(`Failed to register tools: HTTP ${response.status} ${await response.text()}`);
+        return true;
+      }
+      const responseJson = await response.json();
+      const registerToolsResponse = parseRegisterToolsResponse(responseJson);
+      for (const [toolName, tool] of Object.entries(registerToolsResponse)) {
+        this.toolNameToId.set(toolName, tool);
+      }
+    } catch (error) {
+      this.logger?.error?.(`Failed to register tools: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return true;
+  }
+}
+
 // 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) {
+      return Promise.resolve(true);
+    }
+    return this._toolRegistry.initialized;
+  }
+  get logLevel() {
+    return this._logLevel;
+  }
   static async connect(options) {
     const instance = new this(options);
     await instance.connect();
@@ -48638,13 +49239,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;
@@ -48659,16 +49262,20 @@ class Frisk {
       baseUrl,
       logging: {
         logger: this.rootLogger,
-        logLevel: this.logLevel
+        logLevel: this._logLevel
       }
     });
+    this._toolRegistry = new ToolRegistry({
+      apiBaseUrl: baseUrl,
+      getAccessToken: async () => this.accessTokenProvider.getAccessToken(),
+      logger: this.logger
+    });
     const otlpEndpoint = options?.otlpEndpoint ?? getEnv(FRISK_TELEMETRY_ENDPOINT, FRISK_TELEMETRY_ENDPOINT_DEFAULT);
     if (!otlpEndpoint) {
       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) {
@@ -48706,11 +49313,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();
@@ -48721,10 +49328,26 @@ class Frisk {
     return this._adapter.normalizeToolCall(toolCall);
   }
   wrapTools(tools, options = DefaultWrapToolOptions) {
+    this.wrapToolsCalled = true;
+    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({
+        tools: registerToolProperties,
+        sdkAttributes: this.sdkAttributes
+      });
+    }
     if (this._adapter.wrapTools) {
-      return this._adapter.wrapTools(tools, options);
+      return this._adapter.wrapTools(toolList, options);
     }
-    return [...tools];
+    return toolList;
+  }
+  getSdkAttributes() {
+    return {
+      ...getCoreSdkAttributes(),
+      agentFramework: this.adapter.agentFramework ?? null,
+      agentFrameworkVersion: this.adapter.agentFrameworkVersion ?? null
+    };
   }
   wrapTool(tool, options = DefaultWrapToolOptions) {
     if (this._adapter.wrapTool) {
@@ -48740,6 +49363,9 @@ class Frisk {
     this.friskHandle.updateAuthToken(authToken);
     this.tracingManager.updateAuthToken(authToken);
   }
+  getRegisteredTool(toolName) {
+    return this._toolRegistry.getRegisteredTool(toolName);
+  }
   decideToolCall({
     toolCall,
     agentState,
@@ -48748,7 +49374,8 @@ class Frisk {
     const id = toolCall.id ?? v4();
     const argsJson = toolCall.args ? JSON.stringify(removeLlmReasoningArg(toolCall.args)) : null;
     const stateJson = agentState ? JSON.stringify(agentState) : null;
-    const coreResult = this.friskHandle.process(toolCall.name, argsJson, stateJson, id, this.redaction, traceContextCarrier);
+    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 outcome = coreResult.decision === "allow" ? "allow" /* ALLOW */ : coreResult.decision === "deny" ? "deny" /* DENY */ : coreResult.decision === "escalate" ? "escalate" /* ESCALATE */ : "error" /* ERROR */;
     return {
       outcome,
@@ -48761,6 +49388,8 @@ class Frisk {
   async getOrCreateToolApprovalRequest({
     toolCallId,
     toolName,
+    toolId,
+    toolVersionId,
     policyId,
     policyVersionId,
     sessionId
@@ -48768,6 +49397,8 @@ class Frisk {
     return getOrCreateToolApprovalRequest({
       toolCallId,
       toolName,
+      toolId,
+      toolVersionId,
       policyId,
       policyVersionId,
       sessionId,
@@ -48809,12 +49440,30 @@ function createFriskToolCallId() {
   return v4();
 }
 
+// src/adapters/claude/claude-framework-adapter/get-claude-agent-sdk-version.ts
+import { createRequire as createRequire3 } from "node:module";
+var require3 = createRequire3(import.meta.url);
+var versionSet = false;
+var version3 = null;
+function getClaudeAgentSdkVersion() {
+  if (!versionSet) {
+    try {
+      const pkg = require3("@anthropic-ai/claude-agent-sdk/package.json");
+      version3 = typeof pkg.version === "string" ? pkg.version : null;
+    } catch {
+      version3 = null;
+    }
+    versionSet = true;
+  }
+  return version3;
+}
+
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import * as fs from "fs";
 import { stat as statPromise, open } from "fs/promises";
-import { join } from "path";
+import { join as join2 } from "path";
 import { homedir } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname3, join as join22 } from "path";
 import { cwd } from "process";
 import { realpathSync as realpathSync2 } from "fs";
 import { randomUUID } from "crypto";
@@ -55533,7 +56182,7 @@ function shouldShowDebugMessage(message, filter) {
   return shouldShowDebugCategories(categories, filter);
 }
 function getClaudeConfigHomeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join2(homedir(), ".claude");
 }
 function isEnvTruthy(envVar) {
   if (!envVar)
@@ -55819,8 +56468,8 @@ function getDebugWriter() {
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
         const path = getDebugLogPath();
-        if (!getFsImplementation().existsSync(dirname2(path))) {
-          getFsImplementation().mkdirSync(dirname2(path));
+        if (!getFsImplementation().existsSync(dirname3(path))) {
+          getFsImplementation().mkdirSync(dirname3(path));
         }
         getFsImplementation().appendFileSync(path, content);
         updateLatestDebugLogSymlink();
@@ -55853,7 +56502,7 @@ function logForDebugging(message, { level } = {
   getDebugWriter().write(output);
 }
 function getDebugLogPath() {
-  return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join2(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
+  return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join22(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
 }
 var updateLatestDebugLogSymlink = memoize_default(() => {
   if (process.argv[2] === "--ripgrep") {
@@ -55861,8 +56510,8 @@ var updateLatestDebugLogSymlink = memoize_default(() => {
   }
   try {
     const debugLogPath = getDebugLogPath();
-    const debugLogsDir = dirname2(debugLogPath);
-    const latestSymlinkPath = join2(debugLogsDir, "latest");
+    const debugLogsDir = dirname3(debugLogPath);
+    const latestSymlinkPath = join22(debugLogsDir, "latest");
     if (!getFsImplementation().existsSync(debugLogsDir)) {
       getFsImplementation().mkdirSync(debugLogsDir);
     }
@@ -57400,11 +58049,11 @@ function datetimeRegex(args) {
   regex = `${regex}(${opts.join("|")})`;
   return new RegExp(`^${regex}$`);
 }
-function isValidIP(ip, version3) {
-  if ((version3 === "v4" || !version3) && ipv4Regex.test(ip)) {
+function isValidIP(ip, version4) {
+  if ((version4 === "v4" || !version4) && ipv4Regex.test(ip)) {
     return true;
   }
-  if ((version3 === "v6" || !version3) && ipv6Regex.test(ip)) {
+  if ((version4 === "v6" || !version4) && ipv6Regex.test(ip)) {
     return true;
   }
   return false;
@@ -57431,11 +58080,11 @@ function isValidJWT2(jwt, alg) {
     return false;
   }
 }
-function isValidCidr(ip, version3) {
-  if ((version3 === "v4" || !version3) && ipv4CidrRegex.test(ip)) {
+function isValidCidr(ip, version4) {
+  if ((version4 === "v4" || !version4) && ipv4CidrRegex.test(ip)) {
     return true;
   }
-  if ((version3 === "v6" || !version3) && ipv6CidrRegex.test(ip)) {
+  if ((version4 === "v6" || !version4) && ipv6CidrRegex.test(ip)) {
     return true;
   }
   return false;
@@ -61053,10 +61702,10 @@ var ksuid2 = /^[A-Za-z0-9]{27}$/;
 var nanoid2 = /^[a-zA-Z0-9_-]{21}$/;
 var duration3 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
 var guid2 = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-var uuid3 = (version3) => {
-  if (!version3)
+var uuid3 = (version4) => {
+  if (!version4)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version3}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version4}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 };
 var email2 = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
 var _emoji3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
@@ -61517,7 +62166,7 @@ class Doc2 {
 `));
   }
 }
-var version3 = {
+var version4 = {
   major: 4,
   minor: 0,
   patch: 0
@@ -61527,7 +62176,7 @@ var $ZodType2 = /* @__PURE__ */ $constructor2("$ZodType", (inst, def) => {
   inst ?? (inst = {});
   inst._zod.def = def;
   inst._zod.bag = inst._zod.bag || {};
-  inst._zod.version = version3;
+  inst._zod.version = version4;
   const checks2 = [...inst._zod.def.checks ?? []];
   if (inst._zod.traits.has("$ZodCheck")) {
     checks2.unshift(inst);
@@ -64832,6 +65481,8 @@ function wrapToolWithLlmReasoning(originalTool) {
 
 // src/adapters/claude/claude-framework-adapter/claude-framework-adapter.ts
 class ClaudeFrameworkAdapter {
+  agentFramework = "@anthropic-ai/claude-agent-sdk";
+  agentFrameworkVersion = getClaudeAgentSdkVersion();
   serializeToolArgs(toolArgs, options) {
     if (toolArgs == null) {
       return { value: null, redactedPaths: [] };
@@ -64890,6 +65541,9 @@ class ClaudeFrameworkAdapter {
     }
     return result;
   }
+  extractRegisterToolProperties(_tool) {
+    return null;
+  }
 }
 
 // src/adapters/claude/resolve-claude-tool-name.ts
@@ -64987,7 +65641,7 @@ class FriskClaude extends Frisk {
     return session;
   }
   wrapTools(tools, options = DefaultWrapToolOptions) {
-    return this.adapter.wrapTools(tools, options);
+    return super.wrapTools(tools, options);
   }
   wrapTool(tool2, options = DefaultWrapToolOptions) {
     return this.adapter.wrapTool(tool2, options);
@@ -65000,5 +65654,5 @@ export {
   FriskClaude as Frisk
 };
 
-//# debugId=14E67C8BC2F5F26C64756E2164756E21
+//# debugId=62340F95406CA2D464756E2164756E21
 //# sourceMappingURL=index.js.map