@friskai/frisk-js 0.2.3 → 0.2.6

package/dist/index.js

@@ -44053,6 +44053,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 = {
@@ -44085,6 +44088,8 @@ 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";
@@ -47317,10 +47322,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);
@@ -47330,16 +47417,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;
@@ -47417,6 +47597,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);
@@ -47476,12 +47734,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);
@@ -48154,6 +48499,7 @@ function resolveRedactionOptions(options) {
 class ToolCallSpan {
   adapter;
   toolCall;
+  friskToolId;
   agentState;
   parent;
   tracer;
@@ -48162,10 +48508,13 @@ class ToolCallSpan {
   _startTimeNs = null;
   _traceContextCarrier = null;
   sessionId;
+  friskToolVersionId;
   constructor({
     sessionId,
     adapter,
     toolCall,
+    friskToolId,
+    friskToolVersionId,
     agentState,
     parent,
     tracer,
@@ -48174,6 +48523,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;
@@ -48242,6 +48593,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),
@@ -48305,10 +48660,13 @@ 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,
       tracer: this.tracer,
@@ -48394,6 +48752,7 @@ var ToolApprovalStatus;
   ToolApprovalStatus2["APPROVED"] = "APPROVED";
   ToolApprovalStatus2["REJECTED"] = "REJECTED";
   ToolApprovalStatus2["CANCELED"] = "CANCELED";
+  ToolApprovalStatus2["EXPIRED"] = "EXPIRED";
 })(ToolApprovalStatus ||= {});
 function getTimeoutSignal() {
   if (typeof AbortSignal === "undefined") {
@@ -48491,6 +48850,8 @@ async function safeReadErrorBody(response) {
 async function getOrCreateToolApprovalRequest({
   toolCallId,
   toolName,
+  toolId,
+  toolVersionId,
   policyId,
   policyVersionId,
   sessionId,
@@ -48503,7 +48864,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}`);
@@ -48536,7 +48899,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",
@@ -48614,6 +48979,89 @@ 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(properties) {
+    const propertiesList = [...properties];
+    if (propertiesList.length === 0) {
+      this.initialized = Promise.resolve(true);
+      return;
+    }
+    this.initialized = this.executeRegisterTools(propertiesList);
+    this.initialized;
+  }
+  async executeRegisterTools(properties) {
+    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: properties.map((property) => ({
+            name: property.name,
+            description: property.description,
+            inputJsonSchema: property.inputJsonSchema,
+            outputJsonSchema: property.outputJsonSchema,
+            responseFormat: property.responseFormat
+          }))
+        })
+      });
+      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;
@@ -48627,6 +49075,14 @@ class Frisk {
   _adapter;
   _friskHandle = null;
   _tracingManager = null;
+  _toolRegistry;
+  wrapToolsCalled = false;
+  get toolRegistrationComplete() {
+    if (!this.wrapToolsCalled) {
+      return Promise.resolve(true);
+    }
+    return this._toolRegistry.initialized;
+  }
   static async connect(options) {
     const instance = new this(options);
     await instance.connect();
@@ -48660,6 +49116,11 @@ class Frisk {
         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;
@@ -48719,10 +49180,16 @@ 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(registerToolProperties);
+    }
     if (this._adapter.wrapTools) {
-      return this._adapter.wrapTools(tools, options);
+      return this._adapter.wrapTools(toolList, options);
     }
-    return [...tools];
+    return toolList;
   }
   wrapTool(tool, options = DefaultWrapToolOptions) {
     if (this._adapter.wrapTool) {
@@ -48738,6 +49205,9 @@ class Frisk {
     this.friskHandle.updateAuthToken(authToken);
     this.tracingManager.updateAuthToken(authToken);
   }
+  getRegisteredTool(toolName) {
+    return this._toolRegistry.getRegisteredTool(toolName);
+  }
   decideToolCall({
     toolCall,
     agentState,
@@ -48746,7 +49216,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,
@@ -48759,6 +49230,8 @@ class Frisk {
   async getOrCreateToolApprovalRequest({
     toolCallId,
     toolName,
+    toolId,
+    toolVersionId,
     policyId,
     policyVersionId,
     sessionId
@@ -48766,6 +49239,8 @@ class Frisk {
     return getOrCreateToolApprovalRequest({
       toolCallId,
       toolName,
+      toolId,
+      toolVersionId,
       policyId,
       policyVersionId,
       sessionId,
@@ -48834,5 +49309,5 @@ export {
   AccessTokenProvider
 };
 
-//# debugId=538DC14259C65D6A64756E2164756E21
+//# debugId=9E26BF51C17C2C7B64756E2164756E21
 //# sourceMappingURL=index.js.map