@belticlabs/agent-risk-sdk 0.5.0 → 0.7.0

package/dist/ai/index.d.ts

@@ -1,19 +1,9 @@
-import { P as PaymentMomentPayload } from '../verdict-DMnbFuS5.js';
-import { LanguageModelMiddleware, Tool, ToolSet } from 'ai';
-import { S as SessionSource } from '../session-D9E-efc0.js';
+import { LanguageModelMiddleware, ToolSet } from 'ai';
+import { S as Session } from '../session-DAN29XoB.js';
+import '../index-DAVKGJs5.js';
 import 'zod';
 
-interface PaymentMoments {
-    requested?: PaymentMomentPayload;
-    presented?: PaymentMomentPayload;
-}
-interface WrapToolOptions<I = unknown, O = unknown> {
-    name?: string;
-    /** When the tool performs a purchase, map its input/output to the payment moments it produced. */
-    payment?: (input: I, output: O) => PaymentMoments | null;
-}
-declare function middleware(source: SessionSource): LanguageModelMiddleware;
-declare function wrapTool<T extends Tool>(source: SessionSource, tool: T, opts?: WrapToolOptions): T;
-declare function wrapTools<T extends ToolSet>(source: SessionSource, tools: T, opts?: Record<string, WrapToolOptions>): T;
+declare function middleware(session: Session): LanguageModelMiddleware;
+declare function wrapTools<T extends ToolSet>(session: Session, tools: T): T;
 
-export { type PaymentMoments, type WrapToolOptions, middleware, wrapTool, wrapTools };
+export { middleware, wrapTools };

package/dist/ai/index.js

@@ -1,14 +1,14 @@
 import {
-  Sessions,
   recordCall
-} from "../chunk-JSE6JQJC.js";
+} from "../chunk-JGVVQUXQ.js";
 import {
   toJson,
   toJsonObject
 } from "../chunk-FQDHFTVR.js";
 import {
   uuidv7
-} from "../chunk-X3W2Z5GC.js";
+} from "../chunk-UXXSE643.js";
+import "../chunk-FNU4CRJJ.js";
 
 // src/ai/index.ts
 var PARAM_KEYS = [
@@ -23,16 +23,18 @@ var PARAM_KEYS = [
   "responseFormat",
   "stopSequences"
 ];
-function middleware(source) {
+function middleware(session) {
   return {
     wrapGenerate: async ({ doGenerate, params, model }) => {
-      const session = await Sessions.resolve(source);
-      if (!session) return doGenerate();
+      const stream = await session.stream();
+      if (!stream) return doGenerate();
       return recordCall(
-        session,
-        "llm_call",
-        uuidv7(),
-        { provider: model.provider, modelId: model.modelId, params: pick(params) },
+        stream.llmCall({
+          callId: uuidv7(),
+          provider: model.provider,
+          modelId: model.modelId,
+          params: pick(params)
+        }),
         doGenerate,
         (result) => ({
           content: toJson(result.content),
@@ -43,16 +45,15 @@ function middleware(source) {
     },
     // A stream ends when it drains, not when doStream resolves — so its end is emitted at flush.
     wrapStream: async ({ doStream, params, model }) => {
-      const session = await Sessions.resolve(source);
-      if (!session) return doStream();
-      const callId = uuidv7();
-      const started = Date.now();
-      await session.emit("llm_call.start", {
-        callId,
+      const evidence = await session.stream();
+      if (!evidence) return doStream();
+      const span = evidence.llmCall({
+        callId: uuidv7(),
         provider: model.provider,
         modelId: model.modelId,
         params: pick(params)
       });
+      await span.opened;
       const { stream, ...rest } = await doStream();
       const parts = [];
       let finish = {};
@@ -65,12 +66,10 @@ function middleware(source) {
           controller.enqueue(part);
         },
         flush: async () => {
-          await session.emit("llm_call.end", {
-            callId,
+          await span.end({
             content: toJson(parts),
             ...finish.finishReason ? { finishReason: finish.finishReason } : {},
-            ...finish.usage ? { usage: toJsonObject(finish.usage) } : {},
-            durationMs: Date.now() - started
+            ...finish.usage ? { usage: toJsonObject(finish.usage) } : {}
           });
         }
       });
@@ -78,38 +77,29 @@ function middleware(source) {
     }
   };
 }
-function wrapTool(source, tool, opts = {}) {
+function wrapTools(session, tools) {
+  const out = {};
+  for (const [name, tool] of Object.entries(tools))
+    out[name] = wrapTool(session, name, tool);
+  return out;
+}
+function wrapTool(session, toolName, tool) {
   if (!tool.execute) return tool;
   const original = tool.execute;
-  const toolName = opts.name ?? tool.name ?? "tool";
   const execute = async (input, options) => {
-    const session = await Sessions.resolve(source);
-    if (!session) return original(input, options);
+    const stream = await session.stream();
+    if (!stream) return original(input, options);
     return recordCall(
-      session,
-      "tool_call",
-      options.toolCallId,
-      { toolName, input: toJson(input), transport: "local" },
+      stream.toolCall({ callId: options.toolCallId, toolName, input: toJson(input) }),
       async () => {
         const output = await original(input, options);
         return output && typeof output === "object" && Symbol.asyncIterator in output ? collect(output) : output;
       },
-      async (output) => {
-        const moments = opts.payment?.(input, output) ?? null;
-        if (moments?.requested) await session.emit("payment.requested", moments.requested);
-        if (moments?.presented) await session.emit("payment.presented", moments.presented);
-        return { output: toJson(output) };
-      }
+      (output) => ({ output: toJson(output) })
     );
   };
   return { ...tool, execute };
 }
-function wrapTools(source, tools, opts = {}) {
-  const out = {};
-  for (const [name, tool] of Object.entries(tools))
-    out[name] = wrapTool(source, tool, { name, ...opts[name] });
-  return out;
-}
 function pick(params) {
   const out = {};
   for (const k of PARAM_KEYS) {
@@ -125,6 +115,5 @@ async function collect(it) {
 }
 export {
   middleware,
-  wrapTool,
   wrapTools
 };