@friskai/frisk-js 0.2.10 → 0.3.1

package/dist/adapters/langchain/index.js

@@ -2542,7 +2542,7 @@ var require_call_credentials = __commonJS((exports) => {
         if (isCurrentOauth2Client(googleCredentials)) {
           getHeaders = googleCredentials.getRequestHeaders(options.service_url);
         } else {
-          getHeaders = new Promise((resolve2, reject) => {
+          getHeaders = new Promise((resolve, reject) => {
             googleCredentials.getRequestMetadata(options.service_url, (err, headers) => {
               if (err) {
                 reject(err);
@@ -2552,7 +2552,7 @@ var require_call_credentials = __commonJS((exports) => {
                 reject(new Error("Headers not set by metadata plugin"));
                 return;
               }
-              resolve2(headers);
+              resolve(headers);
             });
           });
         }
@@ -2607,10 +2607,10 @@ var require_call_credentials = __commonJS((exports) => {
       this.metadataGenerator = metadataGenerator;
     }
     generateMetadata(options) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         this.metadataGenerator(options, (err, metadata) => {
           if (metadata !== undefined) {
-            resolve2(metadata);
+            resolve(metadata);
           } else {
             reject(err);
           }
@@ -2932,14 +2932,14 @@ var require_channel_credentials = __commonJS((exports) => {
     }
     connect(socket) {
       const tlsConnectOptions = Object.assign({ socket }, this.connectionOptions);
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         const tlsSocket = (0, tls_1.connect)(tlsConnectOptions, () => {
           var _a2;
           if (((_a2 = this.connectionOptions.rejectUnauthorized) !== null && _a2 !== undefined ? _a2 : true) && !tlsSocket.authorized) {
             reject(tlsSocket.authorizationError);
             return;
           }
-          resolve2({
+          resolve({
             socket: tlsSocket,
             secure: true
           });
@@ -3059,8 +3059,8 @@ var require_channel_credentials = __commonJS((exports) => {
       if (this.hasReceivedUpdates()) {
         return Promise.resolve(this.getLatestSecureContext());
       } else {
-        return new Promise((resolve2) => {
-          this.secureContextWatchers.push(resolve2);
+        return new Promise((resolve) => {
+          this.secureContextWatchers.push(resolve);
         });
       }
     }
@@ -3093,7 +3093,7 @@ var require_channel_credentials = __commonJS((exports) => {
       this.callCredentials = callCredentials;
     }
     connect(socket) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         const secureContext = this.parent.getLatestSecureContext();
         if (!secureContext) {
           reject(new Error("Failed to load credentials"));
@@ -3118,7 +3118,7 @@ var require_channel_credentials = __commonJS((exports) => {
             reject(tlsSocket.authorizationError);
             return;
           }
-          resolve2({
+          resolve({
             socket: tlsSocket,
             secure: true
           });
@@ -6646,7 +6646,7 @@ var require_aspromise = __commonJS((exports, module) => {
     var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
     while (index < arguments.length)
       params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve2, reject) {
+    return new Promise(function executor(resolve, reject) {
       params[offset] = function callback(err) {
         if (pending) {
           pending = false;
@@ -6656,7 +6656,7 @@ var require_aspromise = __commonJS((exports, module) => {
             var params2 = new Array(arguments.length - 1), offset2 = 0;
             while (offset2 < params2.length)
               params2[offset2++] = arguments[offset2];
-            resolve2.apply(null, params2);
+            resolve.apply(null, params2);
           }
         }
       };
@@ -8044,7 +8044,7 @@ var require_path = __commonJS((exports) => {
     }
     return prefix + parts.join("/");
   };
-  path.resolve = function resolve2(originPath, includePath, alreadyNormalized) {
+  path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
     if (!alreadyNormalized)
       includePath = normalize(includePath);
     if (isAbsolute(includePath))
@@ -8357,7 +8357,7 @@ var require_mapfield = __commonJS((exports, module) => {
       keepComments ? this.comment : undefined
     ]);
   };
-  MapField.prototype.resolve = function resolve2() {
+  MapField.prototype.resolve = function resolve() {
     if (this.resolved)
       return this;
     if (types.mapKey[this.keyType] === undefined)
@@ -8430,7 +8430,7 @@ var require_method = __commonJS((exports, module) => {
       this.parsedOptions
     ]);
   };
-  Method.prototype.resolve = function resolve2() {
+  Method.prototype.resolve = function resolve() {
     if (this.resolved)
       return this;
     this.resolvedRequestType = this.parent.lookupType(this.requestType);
@@ -9830,7 +9830,7 @@ var require_field = __commonJS((exports, module) => {
       keepComments ? this.comment : undefined
     ]);
   };
-  Field.prototype.resolve = function resolve2() {
+  Field.prototype.resolve = function resolve() {
     if (this.resolved)
       return this;
     if ((this.typeDefault = types.defaults[this.type]) === undefined) {
@@ -10084,7 +10084,7 @@ var require_object = __commonJS((exports, module) => {
     this.parent = null;
     this.resolved = false;
   };
-  ReflectionObject.prototype.resolve = function resolve2() {
+  ReflectionObject.prototype.resolve = function resolve() {
     if (this.resolved)
       return this;
     if (this.root instanceof Root)
@@ -15635,18 +15635,18 @@ var require_compression_filter = __commonJS((exports) => {
       this.maxRecvMessageLength = maxRecvMessageLength;
     }
     compressMessage(message) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         zlib.deflate(message, (err, output) => {
           if (err) {
             reject(err);
           } else {
-            resolve2(output);
+            resolve(output);
           }
         });
       });
     }
     decompressMessage(message) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         let totalLength = 0;
         const messageParts = [];
         const decompresser = zlib.createInflate();
@@ -15662,7 +15662,7 @@ var require_compression_filter = __commonJS((exports) => {
           }
         });
         decompresser.on("end", () => {
-          resolve2(Buffer.concat(messageParts));
+          resolve(Buffer.concat(messageParts));
         });
         decompresser.write(message);
         decompresser.end();
@@ -15676,18 +15676,18 @@ var require_compression_filter = __commonJS((exports) => {
       this.maxRecvMessageLength = maxRecvMessageLength;
     }
     compressMessage(message) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         zlib.gzip(message, (err, output) => {
           if (err) {
             reject(err);
           } else {
-            resolve2(output);
+            resolve(output);
           }
         });
       });
     }
     decompressMessage(message) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         let totalLength = 0;
         const messageParts = [];
         const decompresser = zlib.createGunzip();
@@ -15703,7 +15703,7 @@ var require_compression_filter = __commonJS((exports) => {
           }
         });
         decompresser.on("end", () => {
-          resolve2(Buffer.concat(messageParts));
+          resolve(Buffer.concat(messageParts));
         });
         decompresser.write(message);
         decompresser.end();
@@ -16957,7 +16957,7 @@ var require_http_proxy = __commonJS((exports) => {
     options.headers = headers;
     const proxyAddressString = (0, subchannel_address_1.subchannelAddressToString)(address);
     trace3("Using proxy " + proxyAddressString + " to connect to " + options.path);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const request = http.request(options);
       request.once("connect", (res, socket, head) => {
         request.removeAllListeners();
@@ -16968,7 +16968,7 @@ var require_http_proxy = __commonJS((exports) => {
             socket.unshift(head);
           }
           trace3("Successfully established a plaintext connection to " + options.path + " through proxy " + proxyAddressString);
-          resolve2(socket);
+          resolve(socket);
         } else {
           (0, logging_1.log)(constants_1.LogVerbosity.ERROR, "Failed to connect to " + options.path + " through proxy " + proxyAddressString + " with status " + res.statusCode);
           reject();
@@ -17840,7 +17840,7 @@ var require_transport = __commonJS((exports) => {
       if (secureConnectResult.socket.closed) {
         return Promise.reject("Connection closed before starting HTTP/2 handshake");
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         var _a2, _b, _c, _d, _e, _f, _g, _h;
         let remoteName = null;
         let realTarget = this.channelTarget;
@@ -17905,7 +17905,7 @@ var require_transport = __commonJS((exports) => {
           session.removeAllListeners();
           secureConnectResult.socket.removeListener("close", closeHandler);
           secureConnectResult.socket.removeListener("error", errorHandler);
-          resolve2(new Http2Transport(session, address, options, remoteName));
+          resolve(new Http2Transport(session, address, options, remoteName));
           this.session = null;
         });
         session.once("close", closeHandler);
@@ -17919,7 +17919,7 @@ var require_transport = __commonJS((exports) => {
         if (proxiedSocket) {
           return proxiedSocket;
         } else {
-          return new Promise((resolve2, reject) => {
+          return new Promise((resolve, reject) => {
             const closeCallback = () => {
               reject(new Error("Socket closed"));
             };
@@ -17929,7 +17929,7 @@ var require_transport = __commonJS((exports) => {
             const socket = net.connect(address, () => {
               socket.removeListener("close", closeCallback);
               socket.removeListener("error", errorCallback);
-              resolve2(socket);
+              resolve(socket);
             });
             socket.once("close", closeCallback);
             socket.once("error", errorCallback);
@@ -21143,7 +21143,7 @@ var require_server_interceptors = __commonJS((exports) => {
         } else {
           decompresser = zlib.createGunzip();
         }
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve, reject) => {
           let totalLength = 0;
           const messageParts = [];
           decompresser.on("data", (chunk) => {
@@ -21158,7 +21158,7 @@ var require_server_interceptors = __commonJS((exports) => {
             }
           });
           decompresser.on("end", () => {
-            resolve2(Buffer.concat(messageParts));
+            resolve(Buffer.concat(messageParts));
           });
           decompresser.write(messageContents);
           decompresser.end();
@@ -21751,10 +21751,10 @@ var require_server = __commonJS((exports) => {
       bindOneAddress(address, boundPortObject) {
         this.trace("Attempting to bind " + (0, subchannel_address_1.subchannelAddressToString)(address));
         const http2Server = this.createHttp2Server(boundPortObject.credentials);
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve, reject) => {
           const onError = (err) => {
             this.trace("Failed to bind " + (0, subchannel_address_1.subchannelAddressToString)(address) + " with error " + err.message);
-            resolve2({
+            resolve({
               port: "port" in address ? address.port : 1,
               error: err.message
             });
@@ -21782,7 +21782,7 @@ var require_server = __commonJS((exports) => {
             });
             boundPortObject.listeningServers.add(http2Server);
             this.trace("Successfully bound " + (0, subchannel_address_1.subchannelAddressToString)(boundSubchannelAddress));
-            resolve2({
+            resolve({
               port: "port" in boundSubchannelAddress ? boundSubchannelAddress.port : 1
             });
             http2Server.removeListener("error", onError);
@@ -21835,7 +21835,7 @@ var require_server = __commonJS((exports) => {
         }
       }
       resolvePort(port) {
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve, reject) => {
           let seenResolution = false;
           const resolverListener = (endpointList, attributes, serviceConfig, resolutionNote) => {
             if (seenResolution) {
@@ -21851,7 +21851,7 @@ var require_server = __commonJS((exports) => {
               reject(new Error(`No addresses resolved for port ${port}`));
               return true;
             }
-            resolve2(addressList);
+            resolve(addressList);
             return true;
           };
           const resolver = (0, resolver_1.createResolver)(port, resolverListener, this.options);
@@ -27564,8 +27564,8 @@ var require_promise = __commonJS((exports) => {
     _resolve;
     _reject;
     constructor() {
-      this._promise = new Promise((resolve2, reject) => {
-        this._resolve = resolve2;
+      this._promise = new Promise((resolve, reject) => {
+        this._resolve = resolve;
         this._reject = reject;
       });
     }
@@ -27653,9 +27653,9 @@ var require_exporter = __commonJS((exports) => {
   var api_1 = require_src();
   var suppress_tracing_1 = require_suppress_tracing();
   function _export(exporter, arg) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       api_1.context.with((0, suppress_tracing_1.suppressTracing)(api_1.context.active()), () => {
-        exporter.export(arg, resolve2);
+        exporter.export(arg, resolve);
       });
     });
   }
@@ -28111,22 +28111,22 @@ var require_grpc_exporter_transport = __commonJS((exports) => {
           });
         }
       }
-      return new Promise((resolve2) => {
+      return new Promise((resolve) => {
         const deadline = Date.now() + timeoutMillis;
         if (this._metadata == null) {
-          return resolve2({
+          return resolve({
             error: new Error("metadata was null"),
             status: "failure"
           });
         }
         this._client.export(buffer, this._metadata, { deadline }, (err, response) => {
           if (err) {
-            resolve2({
+            resolve({
               status: "failure",
               error: err
             });
           } else {
-            resolve2({
+            resolve({
               data: response,
               status: "success"
             });
@@ -28469,9 +28469,9 @@ var require_http_exporter_transport = __commonJS((exports) => {
     async send(data, timeoutMillis) {
       const { agent, request } = await this._loadUtils();
       const headers = await this._parameters.headers();
-      return new Promise((resolve2) => {
+      return new Promise((resolve) => {
         (0, http_transport_utils_1.sendWithHttp)(request, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, (result) => {
-          resolve2(result);
+          resolve(result);
         }, timeoutMillis);
       });
     }
@@ -28520,9 +28520,9 @@ var require_retrying_transport = __commonJS((exports) => {
       this._transport = transport;
     }
     retry(data, timeoutMillis, inMillis) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         setTimeout(() => {
-          this._transport.send(data, timeoutMillis).then(resolve2, reject);
+          this._transport.send(data, timeoutMillis).then(resolve, reject);
         }, inMillis);
       });
     }
@@ -31252,7 +31252,7 @@ var require_root2 = __commonJS((exports, module) => {
             return ScopeSpans;
           }();
           v12.Span = function() {
-            function Span2(properties) {
+            function Span(properties) {
               this.attributes = [];
               this.events = [];
               this.links = [];
@@ -31262,26 +31262,26 @@ var require_root2 = __commonJS((exports, module) => {
                     this[keys[i]] = properties[keys[i]];
               }
             }
-            Span2.prototype.traceId = null;
-            Span2.prototype.spanId = null;
-            Span2.prototype.traceState = null;
-            Span2.prototype.parentSpanId = null;
-            Span2.prototype.flags = null;
-            Span2.prototype.name = null;
-            Span2.prototype.kind = null;
-            Span2.prototype.startTimeUnixNano = null;
-            Span2.prototype.endTimeUnixNano = null;
-            Span2.prototype.attributes = $util.emptyArray;
-            Span2.prototype.droppedAttributesCount = null;
-            Span2.prototype.events = $util.emptyArray;
-            Span2.prototype.droppedEventsCount = null;
-            Span2.prototype.links = $util.emptyArray;
-            Span2.prototype.droppedLinksCount = null;
-            Span2.prototype.status = null;
-            Span2.create = function create(properties) {
-              return new Span2(properties);
-            };
-            Span2.encode = function encode2(message, writer) {
+            Span.prototype.traceId = null;
+            Span.prototype.spanId = null;
+            Span.prototype.traceState = null;
+            Span.prototype.parentSpanId = null;
+            Span.prototype.flags = null;
+            Span.prototype.name = null;
+            Span.prototype.kind = null;
+            Span.prototype.startTimeUnixNano = null;
+            Span.prototype.endTimeUnixNano = null;
+            Span.prototype.attributes = $util.emptyArray;
+            Span.prototype.droppedAttributesCount = null;
+            Span.prototype.events = $util.emptyArray;
+            Span.prototype.droppedEventsCount = null;
+            Span.prototype.links = $util.emptyArray;
+            Span.prototype.droppedLinksCount = null;
+            Span.prototype.status = null;
+            Span.create = function create(properties) {
+              return new Span(properties);
+            };
+            Span.encode = function encode2(message, writer) {
               if (!writer)
                 writer = $Writer.create();
               if (message.traceId != null && Object.hasOwnProperty.call(message, "traceId"))
@@ -31321,10 +31321,10 @@ var require_root2 = __commonJS((exports, module) => {
                 writer.uint32(133).fixed32(message.flags);
               return writer;
             };
-            Span2.encodeDelimited = function encodeDelimited(message, writer) {
+            Span.encodeDelimited = function encodeDelimited(message, writer) {
               return this.encode(message, writer).ldelim();
             };
-            Span2.decode = function decode2(reader, length, error2) {
+            Span.decode = function decode2(reader, length, error2) {
               if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
               var end = length === undefined ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.Span;
@@ -31410,12 +31410,12 @@ var require_root2 = __commonJS((exports, module) => {
               }
               return message;
             };
-            Span2.decodeDelimited = function decodeDelimited(reader) {
+            Span.decodeDelimited = function decodeDelimited(reader) {
               if (!(reader instanceof $Reader))
                 reader = new $Reader(reader);
               return this.decode(reader, reader.uint32());
             };
-            Span2.verify = function verify(message) {
+            Span.verify = function verify(message) {
               if (typeof message !== "object" || message === null)
                 return "object expected";
               if (message.traceId != null && message.hasOwnProperty("traceId")) {
@@ -31508,7 +31508,7 @@ var require_root2 = __commonJS((exports, module) => {
               }
               return null;
             };
-            Span2.fromObject = function fromObject(object2) {
+            Span.fromObject = function fromObject(object2) {
               if (object2 instanceof $root.opentelemetry.proto.trace.v1.Span)
                 return object2;
               var message = new $root.opentelemetry.proto.trace.v1.Span;
@@ -31631,7 +31631,7 @@ var require_root2 = __commonJS((exports, module) => {
               }
               return message;
             };
-            Span2.toObject = function toObject(message, options) {
+            Span.toObject = function toObject(message, options) {
               if (!options)
                 options = {};
               var object2 = {};
@@ -31730,16 +31730,16 @@ var require_root2 = __commonJS((exports, module) => {
                 object2.flags = message.flags;
               return object2;
             };
-            Span2.prototype.toJSON = function toJSON() {
+            Span.prototype.toJSON = function toJSON() {
               return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
             };
-            Span2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            Span.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
               if (typeUrlPrefix === undefined) {
                 typeUrlPrefix = "type.googleapis.com";
               }
               return typeUrlPrefix + "/opentelemetry.proto.trace.v1.Span";
             };
-            Span2.SpanKind = function() {
+            Span.SpanKind = function() {
               var valuesById = {}, values = Object.create(valuesById);
               values[valuesById[0] = "SPAN_KIND_UNSPECIFIED"] = 0;
               values[valuesById[1] = "SPAN_KIND_INTERNAL"] = 1;
@@ -31749,7 +31749,7 @@ var require_root2 = __commonJS((exports, module) => {
               values[valuesById[5] = "SPAN_KIND_CONSUMER"] = 5;
               return values;
             }();
-            Span2.Event = function() {
+            Span.Event = function() {
               function Event(properties) {
                 this.attributes = [];
                 if (properties) {
@@ -31919,7 +31919,7 @@ var require_root2 = __commonJS((exports, module) => {
               };
               return Event;
             }();
-            Span2.Link = function() {
+            Span.Link = function() {
               function Link(properties) {
                 this.attributes = [];
                 if (properties) {
@@ -32126,7 +32126,7 @@ var require_root2 = __commonJS((exports, module) => {
               };
               return Link;
             }();
-            return Span2;
+            return Span;
           }();
           v12.Status = function() {
             function Status(properties) {
@@ -42765,14 +42765,14 @@ var require_BatchSpanProcessorBase = __commonJS((exports) => {
       this._maybeStartTimer();
     }
     _flushAll() {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         const promises = [];
         const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
         for (let i = 0, j = count;i < j; i++) {
           promises.push(this._flushOneBatch());
         }
         Promise.all(promises).then(() => {
-          resolve2();
+          resolve();
         }).catch(reject);
       });
     }
@@ -42781,7 +42781,7 @@ var require_BatchSpanProcessorBase = __commonJS((exports) => {
       if (this._finishedSpans.length === 0) {
         return Promise.resolve();
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
           reject(new Error("Timeout"));
         }, this._exportTimeoutMillis);
@@ -42796,7 +42796,7 @@ var require_BatchSpanProcessorBase = __commonJS((exports) => {
           const doExport = () => this._exporter.export(spans, (result) => {
             clearTimeout(timer);
             if (result.code === core_1.ExportResultCode.SUCCESS) {
-              resolve2();
+              resolve();
             } else {
               reject(result.error ?? new Error("BatchSpanProcessor: span export failed"));
             }
@@ -42935,7 +42935,7 @@ var require_Tracer = __commonJS((exports) => {
   var utility_1 = require_utility();
   var platform_1 = require_platform4();
 
-  class Tracer2 {
+  class Tracer {
     _sampler;
     _generalLimits;
     _spanLimits;
@@ -43037,7 +43037,7 @@ var require_Tracer = __commonJS((exports) => {
       return this._spanLimits;
     }
   }
-  exports.Tracer = Tracer2;
+  exports.Tracer = Tracer;
 });
 
 // ../../node_modules/@opentelemetry/sdk-trace-base/build/src/MultiSpanProcessor.js
@@ -43056,12 +43056,12 @@ var require_MultiSpanProcessor = __commonJS((exports) => {
       for (const spanProcessor of this._spanProcessors) {
         promises.push(spanProcessor.forceFlush());
       }
-      return new Promise((resolve2) => {
+      return new Promise((resolve) => {
         Promise.all(promises).then(() => {
-          resolve2();
+          resolve();
         }).catch((error2) => {
           (0, core_1.globalErrorHandler)(error2 || new Error("MultiSpanProcessor: forceFlush failed"));
-          resolve2();
+          resolve();
         });
       });
     }
@@ -43087,9 +43087,9 @@ var require_MultiSpanProcessor = __commonJS((exports) => {
       for (const spanProcessor of this._spanProcessors) {
         promises.push(spanProcessor.shutdown());
       }
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         Promise.all(promises).then(() => {
-          resolve2();
+          resolve();
         }, reject);
       });
     }
@@ -43142,32 +43142,32 @@ var require_BasicTracerProvider = __commonJS((exports) => {
     forceFlush() {
       const timeout = this._config.forceFlushTimeoutMillis;
       const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
-        return new Promise((resolve2) => {
+        return new Promise((resolve) => {
           let state;
           const timeoutInterval = setTimeout(() => {
-            resolve2(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+            resolve(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
             state = ForceFlushState.timeout;
           }, timeout);
           spanProcessor.forceFlush().then(() => {
             clearTimeout(timeoutInterval);
             if (state !== ForceFlushState.timeout) {
               state = ForceFlushState.resolved;
-              resolve2(state);
+              resolve(state);
             }
           }).catch((error2) => {
             clearTimeout(timeoutInterval);
             state = ForceFlushState.error;
-            resolve2(error2);
+            resolve(error2);
           });
         });
       });
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         Promise.all(promises).then((results) => {
           const errors3 = results.filter((result) => result !== ForceFlushState.resolved);
           if (errors3.length > 0) {
             reject(errors3);
           } else {
-            resolve2();
+            resolve();
           }
         }).catch((error2) => reject([error2]));
       });
@@ -43618,10 +43618,10 @@ class UnexpectedFriskServerResponseError extends Error {
   }
 }
 
-class ToolCallSpanNotInitializedError extends Error {
-  constructor(message = "Tool call span has not been initialized. Call enter() first.") {
-    super(message);
-    this.name = "ToolCallSpanNotInitializedError";
+class MissingToolPoliciesExtensionError extends FriskError {
+  constructor(options) {
+    super("decide_tool_call requires the tool policies extension. Install and register the @friskai/frisk-js-tool-policies extension; calling frisk.connect() alone is not sufficient.", options);
+    this.name = "MissingToolPoliciesExtensionError";
   }
 }
 
@@ -43744,35 +43744,6 @@ function captureError(e, logger, meta) {
   logError(logger, e.message, e, meta);
 }
 
-// src/telemetry/constants.ts
-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";
-var ATTRIBUTE_NAME_AGENT_STATE_JSON = "frisk.agent_state.json";
-var ATTRIBUTE_NAME_AGENT_STATE_REDACTED_PATHS_JSON = "frisk.agent_state_redacted_paths.json";
-var ATTRIBUTE_NAME_DECISION_MATCHED_RULE_COUNT = "frisk.decision.matched_rule_count";
-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_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";
-
 // ../../node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
   status: "aborted"
@@ -48164,6 +48135,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)) {
@@ -48209,136 +48192,226 @@ class SessionRegistry {
   }
 }
 
-// src/core/tool-call-span.ts
+// src/core/spans/frisk-span.ts
 var import_api = __toESM(require_src(), 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);
+    }
+  }
+  constantFor(field) {
+    const constant = this._attributeFields[field];
+    if (constant === undefined) {
+      throw new Error(`Unknown attribute '${field}' for ${this.constructor.name}`);
     }
+    return constant;
+  }
+}
+// src/telemetry/constants.ts
+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";
+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";
+var ATTRIBUTE_NAME_AGENT_STATE_JSON = "frisk.agent_state.json";
+var ATTRIBUTE_NAME_AGENT_STATE_REDACTED_PATHS_JSON = "frisk.agent_state_redacted_paths.json";
+var ATTRIBUTE_NAME_DECISION_MATCHED_RULE_COUNT = "frisk.decision.matched_rule_count";
+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_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/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 });
   }
-  setAttribute(key, value) {
-    this.span.setAttribute(key, value);
+  setAttributes(values) {
+    this.setAttributesByField(values);
   }
-  setAttributes(attributes) {
-    this.span.setAttributes(attributes);
+}
+// 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 });
   }
-  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/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(error2) {
-    if (!this.span) {
-      return;
-    }
-    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    const errorType = error2 instanceof Error ? error2.constructor.name : typeof error2;
-    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) => {
@@ -48358,9 +48431,13 @@ class FriskSession {
   logger;
   _rootRunId = null;
   _isTracing = false;
+  _agentState = null;
   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, {
@@ -48383,33 +48460,67 @@ 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
+    args: toolArgsInput,
+    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: []
     };
-    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
+    const agentStateToUse = agentState ?? this._agentState ?? {};
+    const redactedAgentStateResult = this.frisk.adapter?.serializeAgentState(agentStateToUse, { redact: this.redaction.redactAgentState }) ?? {
+      value: "{}",
+      redactedPaths: []
     };
+    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({
@@ -48419,19 +48530,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();
   }
@@ -48445,32 +48556,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,
@@ -48479,7 +48595,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 (error2) {
         const wrapped = new ToolCallEvaluationError(error2);
@@ -48487,14 +48607,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) {
@@ -48510,23 +48635,49 @@ class FriskSession {
   getToolCallErrorCount() {
     return this.toolCallErrorCount;
   }
-  initTracing({ runId, inputs }) {
+  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;
-    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 userPrompt = this.frisk.adapter.extractPrompt?.(inputs);
+    this._agentState = agentState;
+    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;
@@ -48546,6 +48697,7 @@ class FriskCallbackHandler extends BaseCallbackHandler {
   name = "FriskCallbackHandler";
   session;
   spansByRunId;
+  llmCallSpanIdByToolCallId;
   frisk;
   logger;
   constructor({
@@ -48557,22 +48709,57 @@ class FriskCallbackHandler extends BaseCallbackHandler {
     this.session = session;
     this.frisk = frisk;
     this.spansByRunId = new Map;
+    this.llmCallSpanIdByToolCallId = new Map;
     this.logger = deriveSdkLogger(logging, {
       component: "FriskCallbackHandler"
     });
   }
   handleChainStart(_chain, inputs, runId, parentRunId) {
+    let span;
     if (parentRunId === undefined) {
-      this.session.initTracing({
+      span = this.session.initTracing({
         runId,
-        inputs
+        agentState: inputs
+      });
+    } else {
+      span = this.session.createOperationSpan({
+        parent: this.resolveParentSpan(parentRunId)
       });
     }
+    this.spansByRunId.set(runId, span);
   }
   handleChainEnd(_outputs, runId, _parentRunId, _tags, _kwargs) {
     if (this.session.rootRunId === runId) {
+      this.spansByRunId.delete(runId);
+      for (const span of this.spansByRunId.values()) {
+        span.end();
+      }
+      this.spansByRunId.clear();
+      this.llmCallSpanIdByToolCallId.clear();
       this.session.endTracing();
+      return;
     }
+    this.endSpan(runId);
+  }
+  handleChatModelStart(_llm, messages, runId, parentRunId) {
+    const span = this.openLlmCallSpan(runId, parentRunId);
+    const promptsJson = this.safeJsonStringify(this.getPromptMessages(messages), "chat prompt messages");
+    if (promptsJson !== null) {
+      span.setAttributes({ promptsJson });
+    }
+  }
+  handleLLMStart(_llm, prompts, runId, parentRunId) {
+    const span = this.openLlmCallSpan(runId, parentRunId);
+    const promptsJson = this.safeJsonStringify(prompts, "LLM prompts");
+    if (promptsJson !== null) {
+      span.setAttributes({ promptsJson });
+    }
+  }
+  handleLLMEnd(output, runId) {
+    this.finalizeLlmCall(output, runId, null);
+  }
+  handleLLMError(err, runId) {
+    this.finalizeLlmCall(null, runId, err);
   }
   async handleToolStart(tool, input, runId, parentRunId, tags, metadata, runName) {
     const toolName = runName;
@@ -48591,18 +48778,20 @@ class FriskCallbackHandler extends BaseCallbackHandler {
     }
     const span = await this.session.createToolCallSpan({
       name: toolName,
-      args: parsedToolArgs
+      args: parsedToolArgs,
+      parent: this.resolveParentSpan(parentRunId)
     });
     this.spansByRunId.set(runId, span);
   }
   async handleToolEnd(output, runId, parentRunId, tags) {
     const span = this.spansByRunId.get(runId);
-    if (!span) {
+    if (!(span instanceof ToolCallObservationSpan)) {
       captureError(new Error("Langchain invoked handleToolEnd but no span was found for the given runId. This tool call won't be included in Frisk telemetry data."), this.logger);
       return;
     }
     const toolCallId = output.tool_call_id;
     const status = output.status;
+    this.stampLlmCallSpanId(span, toolCallId);
     this.closeToolCallSpan({
       toolCallId,
       span,
@@ -48613,7 +48802,7 @@ class FriskCallbackHandler extends BaseCallbackHandler {
   }
   async handleToolError(err, runId, parentRunId, tags) {
     const span = this.spansByRunId.get(runId);
-    if (!span) {
+    if (!(span instanceof ToolCallObservationSpan)) {
       captureError(new Error("Langchain invoked handleToolError but no span was found for the given runId. This tool call won't be included in Frisk telemetry data."), this.logger);
       return;
     }
@@ -48625,6 +48814,144 @@ class FriskCallbackHandler extends BaseCallbackHandler {
     });
     this.spansByRunId.delete(runId);
   }
+  resolveParentSpan(parentRunId) {
+    if (parentRunId === undefined) {
+      return null;
+    }
+    return this.spansByRunId.get(parentRunId) ?? null;
+  }
+  openLlmCallSpan(runId, parentRunId) {
+    const existing = this.spansByRunId.get(runId);
+    if (existing instanceof LlmCallSpan) {
+      return existing;
+    }
+    const span = this.session.createLlmCallSpan({
+      parent: this.resolveParentSpan(parentRunId)
+    });
+    this.spansByRunId.set(runId, span);
+    return span;
+  }
+  safeJsonStringify(value, what) {
+    try {
+      return JSON.stringify(value);
+    } catch (e) {
+      captureError(new Error(`Failed to serialize ${what} for Frisk telemetry`, {
+        cause: e
+      }), this.logger);
+      return null;
+    }
+  }
+  getPromptMessages(messages) {
+    const lastBatch = messages[messages.length - 1];
+    if (!lastBatch || lastBatch.length === 0) {
+      return [];
+    }
+    const collected = [];
+    for (let i = lastBatch.length - 1;i >= 0; i--) {
+      const message = lastBatch[i];
+      const type = message.getType();
+      if (type === "ai") {
+        break;
+      }
+      const entry = { type, content: message.content };
+      if (type === "tool") {
+        const toolMessage = message;
+        entry.metadata = {
+          tool_name: toolMessage.name ?? null,
+          tool_call_id: toolMessage.tool_call_id ?? null
+        };
+      }
+      collected.push(entry);
+    }
+    collected.reverse();
+    return collected;
+  }
+  finalizeLlmCall(output, runId, err) {
+    const found = this.spansByRunId.get(runId) ?? null;
+    const llmCallSpan = found instanceof LlmCallSpan ? found : null;
+    const generations = output?.generations ?? [];
+    const responses = [];
+    const toolCalls = [];
+    let modelName;
+    let modelProvider;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let hasUsage = false;
+    for (const generationList of generations) {
+      for (const generation of generationList) {
+        const message = generation.message;
+        const generationInfo = generation.generationInfo ?? {};
+        const responseMetadata = message?.response_metadata ?? {};
+        modelName = modelName || generationInfo.model || generationInfo.model_name || responseMetadata.model;
+        modelProvider = modelProvider || generationInfo.model_provider || responseMetadata.model_provider;
+        if (!message || message.getType() !== "ai") {
+          if (!message && generation.text) {
+            responses.push({ content: generation.text });
+          }
+          continue;
+        }
+        responses.push({ content: message.content });
+        const usage = message.usage_metadata;
+        if (usage) {
+          inputTokens += usage.input_tokens ?? 0;
+          outputTokens += usage.output_tokens ?? 0;
+          totalTokens += usage.total_tokens ?? 0;
+          hasUsage = true;
+        }
+        const messageToolCalls = message.tool_calls ?? [];
+        for (const toolCall of messageToolCalls) {
+          const announced = { tool_name: toolCall.name };
+          const toolCallId = toolCall.id;
+          if (toolCallId) {
+            announced.tool_call_id = toolCallId;
+          }
+          toolCalls.push(announced);
+          if (llmCallSpan !== null && toolCallId) {
+            this.llmCallSpanIdByToolCallId.set(toolCallId, llmCallSpan.spanId);
+          }
+        }
+      }
+    }
+    if (hasUsage) {
+      this.session.recordTokenUsage({ inputTokens, outputTokens, totalTokens });
+    }
+    if (llmCallSpan !== null) {
+      const responsesJson = responses.length > 0 ? this.safeJsonStringify(responses, "LLM responses") : null;
+      const toolCallsJson = toolCalls.length > 0 ? this.safeJsonStringify(toolCalls, "LLM tool calls") : null;
+      llmCallSpan.setAttributes({
+        modelName,
+        modelProvider,
+        ...hasUsage ? { inputTokens, outputTokens, totalTokens } : {},
+        ...responsesJson !== null ? { responsesJson } : {},
+        ...toolCallsJson !== null ? { toolCallsJson } : {}
+      });
+      if (err !== null) {
+        llmCallSpan.setAttributes({
+          errorType: err.constructor.name,
+          errorMessage: `${err}`
+        });
+      }
+    }
+    this.endSpan(runId);
+  }
+  stampLlmCallSpanId(span, toolCallId) {
+    if (!toolCallId) {
+      return;
+    }
+    const llmCallSpanId = this.llmCallSpanIdByToolCallId.get(toolCallId);
+    if (llmCallSpanId !== undefined) {
+      span.setAttributes({ llmCallSpanId });
+    }
+    this.llmCallSpanIdByToolCallId.delete(toolCallId);
+  }
+  endSpan(runId) {
+    const span = this.spansByRunId.get(runId);
+    if (span !== undefined) {
+      span.end();
+      this.spansByRunId.delete(runId);
+    }
+  }
   closeToolCallSpan({
     toolCallId,
     span,
@@ -48679,26 +49006,52 @@ function combineRedactOptions(...options) {
   }
   return false;
 }
-function redactDictionarySimple(data, redactOption) {
+function deleteDotPath(root, path) {
+  const parts = path.split(".").filter((p) => p.length > 0);
+  if (parts.length === 0)
+    return false;
+  let cur = root;
+  for (const key of parts.slice(0, -1)) {
+    if (cur === null || typeof cur !== "object" || Array.isArray(cur))
+      return false;
+    if (!(key in cur))
+      return false;
+    cur = cur[key];
+  }
+  if (cur === null || typeof cur !== "object" || Array.isArray(cur))
+    return false;
+  const last = parts[parts.length - 1];
+  if (!(last in cur))
+    return false;
+  delete cur[last];
+  return true;
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function redactObject(data, redactOption) {
   if (redactOption === undefined || redactOption === false) {
     return { value: data, redactedPaths: [] };
   }
-  const redactedPaths = [];
-  const result = { ...data };
   if (redactOption === true) {
-    for (const key of Object.keys(result)) {
-      delete result[key];
-      redactedPaths.push(key);
-    }
-  } else if (Array.isArray(redactOption)) {
-    for (const path of redactOption) {
-      if (path in result) {
-        delete result[path];
-        redactedPaths.push(path);
-      }
+    return { value: {}, redactedPaths: ["*"] };
+  }
+  if (!Array.isArray(redactOption) || redactOption.length === 0) {
+    return { value: data, redactedPaths: [] };
+  }
+  const out = deepClone(data);
+  const hits = [];
+  const seen = new Set;
+  for (const rawPath of redactOption) {
+    const path = rawPath.trim();
+    if (path.length === 0)
+      continue;
+    if (deleteDotPath(out, path) && !seen.has(path)) {
+      seen.add(path);
+      hits.push(path);
     }
   }
-  return { value: result, redactedPaths };
+  return { value: out, redactedPaths: hits };
 }
 // src/framework-adapter/base-framework-adapter.ts
 class BaseFrameworkAdapter {
@@ -48725,10 +49078,10 @@ class BaseFrameworkAdapter {
     };
   }
   toolArgsToDict(toolArgs, options) {
-    return redactDictionarySimple(toolArgs, options?.redact);
+    return redactObject(toolArgs, options?.redact);
   }
   agentStateToDict(agentState, options) {
-    return redactDictionarySimple(agentState, options?.redact);
+    return redactObject(agentState, options?.redact);
   }
   normalizeToolCall(toolCall) {
     return {
@@ -48749,22 +49102,6 @@ class BaseFrameworkAdapter {
 var DefaultWrapToolOptions = {
   captureReasoning: true
 };
-
-// src/native-bindings/index.ts
-import { createRequire as createRequire2 } from "module";
-import { dirname, resolve } from "path";
-var require2 = createRequire2(import.meta.url);
-function resolveNativePath() {
-  const injected = process.env.FRISk_NATIVE_BINDINGS_PATH;
-  if (injected)
-    return injected;
-  const pkgJsonPath = require2.resolve("@friskai/frisk-js/package.json");
-  const pkgRoot = dirname(pkgJsonPath);
-  return resolve(pkgRoot, "native/index.cjs");
-}
-var nativeBindings = require2(resolveNativePath());
-var FriskHandle = nativeBindings.FriskHandle;
-var redactDictionary = nativeBindings.redactDictionary;
 // src/telemetry/tracing-manager.ts
 var import_grpc_js = __toESM(require_src4(), 1);
 var import_exporter_trace_otlp_grpc = __toESM(require_src12(), 1);
@@ -49040,6 +49377,14 @@ class AccessTokenProvider {
   }
 }
 
+// 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;
@@ -49075,12 +49420,12 @@ function detectRuntime() {
 
 // src/core/sdk-attributes/read-sdk-meta.ts
 import { existsSync, readFileSync } from "node:fs";
-import { dirname as dirname2, join } from "node:path";
+import { dirname, 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";
+var SDK_VERSION = "0.3.1";
 
 // src/core/sdk-attributes/read-sdk-meta.ts
 function getSdkMeta() {
@@ -49114,7 +49459,7 @@ function findNearestPackageJson(startDir) {
     if (existsSync(candidate)) {
       return candidate;
     }
-    const parent = dirname2(dir);
+    const parent = dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -49123,7 +49468,7 @@ function findNearestPackageJson(startDir) {
 }
 function tryReadPackageJson() {
   try {
-    const here = dirname2(fileURLToPath(import.meta.url));
+    const here = dirname(fileURLToPath(import.meta.url));
     const pkgPath = findNearestPackageJson(here);
     if (!pkgPath)
       return null;
@@ -49491,6 +49836,9 @@ class ToolRegistry {
 
 // src/core/frisk.ts
 class Frisk {
+  get toolPoliciesAvailable() {
+    return this.toolPolicies?.available ?? false;
+  }
   get redaction() {
     return this._redaction;
   }
@@ -49498,24 +49846,34 @@ class Frisk {
   apiBaseUrl;
   otlpEndpoint;
   accessTokenProvider;
+  get adapter() {
+    return this._adapter;
+  }
+  get logLevel() {
+    return this._logLevel;
+  }
+  get tracingManager() {
+    if (!this._tracingManager) {
+      throw new FriskNotInitializedError;
+    }
+    return this._tracingManager;
+  }
   initialized = false;
   rootLogger;
   logger;
   _logLevel;
   _adapter;
-  _friskHandle = null;
   _tracingManager = null;
-  _toolRegistry;
+  toolRegistry;
   sdkAttributes;
+  extensions = [];
+  toolPolicies = null;
   wrapToolsCalled = false;
   get toolRegistrationComplete() {
     if (!this.wrapToolsCalled) {
       return Promise.resolve(true);
     }
-    return this._toolRegistry.initialized;
-  }
-  get logLevel() {
-    return this._logLevel;
+    return this.toolRegistry.initialized;
   }
   static async connect(options) {
     const instance = new this(options);
@@ -49529,7 +49887,7 @@ class Frisk {
     this._logLevel = options?.logging?.logLevel;
     this.logger = deriveSdkLogger({
       logger: this.rootLogger,
-      logLevel: this._logLevel
+      logLevel: this.logLevel
     }, {
       component: "FriskCore"
     });
@@ -49549,10 +49907,10 @@ class Frisk {
       baseUrl,
       logging: {
         logger: this.rootLogger,
-        logLevel: this._logLevel
+        logLevel: this.logLevel
       }
     });
-    this._toolRegistry = new ToolRegistry({
+    this.toolRegistry = new ToolRegistry({
       apiBaseUrl: baseUrl,
       getAccessToken: async () => this.accessTokenProvider.getAccessToken(),
       logger: this.logger
@@ -49563,21 +49921,20 @@ class Frisk {
     }
     this.otlpEndpoint = otlpEndpoint;
     this._redaction = resolveRedactionOptions(options?.redact);
+    this.extensions = options?.extensions ?? [];
+    this.mountExtensions();
   }
-  get friskHandle() {
-    if (!this._friskHandle) {
-      throw new FriskNotInitializedError;
+  mountExtensions() {
+    for (const ext of this.extensions) {
+      if ("available" in ext && "decideToolCall" in ext) {
+        this.toolPolicies = ext;
+      }
     }
-    return this._friskHandle;
   }
-  get adapter() {
-    return this._adapter;
-  }
-  get tracingManager() {
-    if (!this._tracingManager) {
-      throw new FriskNotInitializedError;
+  async initializeExtensions() {
+    for (const ext of this.extensions) {
+      await ext.initialize(this);
     }
-    return this._tracingManager;
   }
   async connect() {
     if (!this.initialized) {
@@ -49591,20 +49948,20 @@ class Frisk {
         tracerName: TRACER_NAME,
         tracerVersion: TRACER_VERSION
       });
-      this._friskHandle = new FriskHandle(currentToken, this.apiBaseUrl, this.otlpEndpoint);
       this.accessTokenProvider.addCallback((newToken) => this.updateAccessToken(newToken));
       this.accessTokenProvider.startBackgroundRefresh();
       this.initialized = true;
+      await this.initializeExtensions();
     }
   }
   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();
@@ -49612,20 +49969,20 @@ class Frisk {
     return session;
   }
   normalizeToolCall(toolCall) {
-    return this._adapter.normalizeToolCall(toolCall);
+    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);
+    const registerToolProperties = toolList.map((tool) => this.adapter.extractRegisterToolProperties?.(tool)).filter((properties) => properties !== null && properties !== undefined);
     if (registerToolProperties.length > 0) {
-      this._toolRegistry.registerTools({
+      this.toolRegistry.registerTools({
         tools: registerToolProperties,
         sdkAttributes: this.sdkAttributes
       });
     }
-    if (this._adapter.wrapTools) {
-      return this._adapter.wrapTools(toolList, options);
+    if (this.adapter.wrapTools) {
+      return this.adapter.wrapTools(toolList, options);
     }
     return toolList;
   }
@@ -49637,8 +49994,8 @@ class Frisk {
     };
   }
   wrapTool(tool, options = DefaultWrapToolOptions) {
-    if (this._adapter.wrapTool) {
-      return this._adapter.wrapTool(tool, options);
+    if (this.adapter.wrapTool) {
+      return this.adapter.wrapTool(tool, options);
     }
     return tool;
   }
@@ -49647,30 +50004,38 @@ class Frisk {
     return registry2.get(sessionId);
   }
   updateAccessToken(authToken) {
-    this.friskHandle.updateAuthToken(authToken);
+    this.toolPolicies?.updateAccessToken(authToken);
     this.tracingManager.updateAuthToken(authToken);
   }
   getRegisteredTool(toolName) {
-    return this._toolRegistry.getRegisteredTool(toolName);
+    return this.toolRegistry.getRegisteredTool(toolName);
   }
   decideToolCall({
     toolCall,
     agentState,
     traceContextCarrier
   }) {
-    const id = toolCall.id ?? v4();
-    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 outcome = coreResult.decision === "allow" ? "allow" /* ALLOW */ : coreResult.decision === "deny" ? "deny" /* DENY */ : coreResult.decision === "escalate" ? "escalate" /* ESCALATE */ : "error" /* ERROR */;
-    return {
-      outcome,
-      rulesMatchedCount: coreResult.rulesMatchedCount,
-      reason: coreResult.reason,
-      policyId: coreResult.policyId,
-      policyVersionId: coreResult.policyVersionId
-    };
+    if (!this.toolPolicies) {
+      throw new MissingToolPoliciesExtensionError;
+    }
+    const toolArgsJson = toolCall.args ? JSON.stringify(toolCall.args) : null;
+    const agentStateJson = agentState ? JSON.stringify(agentState) : null;
+    const redactedArgs = toolCall.args ? redactObject(toolCall.args, this.redaction.redactToolArgs) : { value: {}, redactedPaths: [] };
+    const toolArgsRedactedJson = toolCall.args ? JSON.stringify(redactedArgs.value) : null;
+    const toolArgsRedactedPathsJson = JSON.stringify(redactedArgs.redactedPaths);
+    const redactedState = agentState ? redactObject(agentState, this.redaction.redactAgentState) : { value: {}, redactedPaths: [] };
+    const agentStateRedactedJson = agentState ? JSON.stringify(redactedState.value) : null;
+    const agentStateRedactedPathsJson = JSON.stringify(redactedState.redactedPaths);
+    return this.toolPolicies.decideToolCall({
+      toolCall,
+      toolArgsJson,
+      toolArgsRedactedJson,
+      toolArgsRedactedPathsJson,
+      agentStateJson,
+      agentStateRedactedJson,
+      agentStateRedactedPathsJson,
+      traceContextCarrier
+    });
   }
   async getOrCreateToolApprovalRequest({
     toolCallId,
@@ -49718,7 +50083,9 @@ class Frisk {
     if (this.tracingManager) {
       await this.tracingManager.shutdown();
     }
-    this.friskHandle.shutdown();
+    for (const ext of this.extensions) {
+      ext.shutdown();
+    }
   }
 }
 
@@ -49778,7 +50145,10 @@ class FriskToolMiddleware {
     this.logger = deriveSdkLogger(options?.logging, {
       component: "FriskToolMiddleware"
     });
-    this.toolPoliciesEnabled = options?.controls?.toolPolicies !== false;
+    this.toolPoliciesEnabled = options?.controls?.toolPolicies === true;
+    if (this.toolPoliciesEnabled && !frisk.toolPoliciesAvailable) {
+      throw new MissingToolPoliciesExtensionError;
+    }
   }
   get frisk() {
     return this._frisk;
@@ -50039,14 +50409,14 @@ function createFriskToolCallId() {
 }
 
 // src/adapters/langchain/langchain-framework-adapter/get-langchain-version.ts
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire2 } from "module";
 var langchainVersionSet = false;
 var langchainVersion = null;
 function tryGetLangchainVersion() {
   if (!langchainVersionSet) {
     try {
-      const require3 = createRequire3(import.meta.url);
-      const pkg = require3("langchain/package.json");
+      const require2 = createRequire2(import.meta.url);
+      const pkg = require2("langchain/package.json");
       langchainVersion = pkg.version ?? null;
     } catch {
       langchainVersion = null;
@@ -50147,11 +50517,11 @@ class LangchainFrameworkAdapter {
     };
   }
   toolArgsToDict(toolArgs, options) {
-    return redactDictionarySimple(toolArgs, options?.redact);
+    return redactObject(toolArgs, options?.redact);
   }
   agentStateToDict(agentState, options) {
     const combinedRedact = combineRedactOptions(EXCLUDED_STATE_KEYS, options?.redact);
-    return redactDictionarySimple(agentState, combinedRedact);
+    return redactObject(agentState, combinedRedact);
   }
   normalizeToolCall(toolCall) {
     return {
@@ -50218,7 +50588,7 @@ var FRISK_CONTEXT_SCHEMA = object({
   [FRISK_SESSION_ID_KEY]: string2().optional()
 });
 var DefaultFriskGuardControls = {
-  toolPolicies: true
+  toolPolicies: false
 };
 
 class FriskLangchain extends Frisk {
@@ -50279,5 +50649,5 @@ export {
   FRISK_SESSION_ID_KEY
 };
 
-//# debugId=A5DABECDF865C55064756E2164756E21
+//# debugId=B3DA4933179DBD8B64756E2164756E21
 //# sourceMappingURL=index.js.map