@almadar/integrations 2.42.0 → 2.43.0

package/dist/runtime/index.d.ts

@@ -1,5 +1,5 @@
-import { g as IntegrationParams, I as IntegrationCallContext, d as IntegrationFactory } from '../BaseIntegration-D_iNTesu.js';
-import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-DcennSSh.js';
+import { g as IntegrationParams, I as IntegrationCallContext, d as IntegrationFactory } from '../BaseIntegration-Dgwn1ZR6.js';
+import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-DP3gfEfJ.js';
 import '@almadar/core';
 import '@almadar/llm';
 

package/dist/runtime/index.js

@@ -13,7 +13,7 @@ import webpush from 'web-push';
 import { Readable } from 'stream';
 import { getAvailableProvider, LLMClient, EmbeddingClient } from '@almadar/llm';
 import { z } from 'zod';
-import { findInputByAddress, payloadSchemaToJsonSchema, EventPayloadSchema } from '@almadar/core';
+import { findInputByAddress, payloadSchemaToJsonSchema, traceActivityPayload, EventPayloadSchema } from '@almadar/core';
 import { execSync, spawn } from 'child_process';
 import { tmpdir } from 'os';
 import * as oidc from 'openid-client';
@@ -410,6 +410,8 @@ var IntegrationFactory = class {
   constructor() {
     this.instances = /* @__PURE__ */ new Map();
     this.configs = /* @__PURE__ */ new Map();
+    /** Names whose app-wide instance was registered directly (mock infrastructure). */
+    this.registered = /* @__PURE__ */ new Set();
   }
   /**
    * Configure an integration (doesn't instantiate yet). A `principal` scopes
@@ -424,7 +426,8 @@ var IntegrationFactory = class {
    * back to the app-wide config when no per-principal config exists.
    */
   get(name, principal) {
-    const key = instanceKey(name, principal);
+    const registered = this.registered.has(name) && !this.configs.has(instanceKey(name, principal));
+    const key = registered ? name : instanceKey(name, principal);
     const cached = this.instances.get(key);
     if (cached) {
       return cached;
@@ -468,6 +471,7 @@ var IntegrationFactory = class {
    * Register an integration instance directly (used by mock infrastructure)
    */
   registerInstance(name, instance, principal) {
+    if (principal === void 0) this.registered.add(name);
     this.instances.set(instanceKey(name, principal), instance);
   }
   /**
@@ -478,8 +482,10 @@ var IntegrationFactory = class {
   invalidate(name) {
     if (name === void 0) {
       this.instances.clear();
+      this.registered.clear();
       return;
     }
+    this.registered.delete(name);
     for (const key of this.instances.keys()) {
       if (key === name || key.startsWith(`${name}\0`)) {
         this.instances.delete(key);
@@ -491,6 +497,7 @@ var IntegrationFactory = class {
    */
   clear() {
     this.instances.clear();
+    this.registered.clear();
   }
   /**
    * Clear all instances and configs
@@ -498,6 +505,7 @@ var IntegrationFactory = class {
   reset() {
     this.instances.clear();
     this.configs.clear();
+    this.registered.clear();
   }
 };
 var installedStore = null;
@@ -2028,7 +2036,7 @@ function parseArgs(args) {
   }
   return EventPayloadSchema.safeParse(value);
 }
-async function runToolLoop(client, host, request) {
+async function runToolLoop(client, host, request, model, now = Date.now) {
   const tools = buildTools(host, request.tools);
   const defs = [...tools.values()].map((t) => t.def);
   const maxSteps = request.maxSteps ?? DEFAULT_MAX_STEPS;
@@ -2036,10 +2044,17 @@ async function runToolLoop(client, host, request) {
     ...request.instructions !== void 0 ? [{ role: "system", content: request.instructions }] : [],
     ...request.messages.map((m) => ({ role: m.role, content: m.content }))
   ];
+  const userPrompt = [...request.messages].reverse().find((m) => m.role === "user")?.content ?? "";
   const steps = [];
+  const record = (activity) => {
+    steps.push(activity);
+    host.message(traceActivityPayload(activity));
+  };
   const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0, modelCalls: 0 };
   while (usage.modelCalls < maxSteps) {
+    const started = now();
     const turn = await client.callWithTools({ messages: conversation, tools: defs });
+    const ended = now();
     usage.modelCalls += 1;
     if (turn.usage) {
       usage.promptTokens += turn.usage.promptTokens;
@@ -2048,23 +2063,41 @@ async function runToolLoop(client, host, request) {
     }
     conversation.push(turn.message);
     const calls = turn.message.tool_calls ?? [];
+    record({
+      type: "llm_response",
+      content: turn.message.content ?? "",
+      llm: {
+        service: "llm",
+        provider: model.provider,
+        model: model.model,
+        systemPrompt: request.instructions ?? "",
+        userPrompt,
+        ...calls.length > 0 ? { toolCallsJson: JSON.stringify(calls) } : {},
+        durationMs: ended - started,
+        ...turn.usage ? { promptTokens: turn.usage.promptTokens, completionTokens: turn.usage.completionTokens } : {}
+      },
+      timestamp: ended
+    });
     if (calls.length === 0) return { reply: turn.message.content ?? "", steps, usage };
     for (const call of calls) {
       const args = call.function.arguments;
       const tool = tools.get(call.function.name);
+      const kind = tool === void 0 ? "invalid" : tool.target.kind;
+      const label = tool === void 0 ? call.function.name : tool.target.kind === "input" ? tool.target.address : tool.target.entity;
+      record({ type: "tool_call", tool: label, kind, argsText: args, timestamp: now() });
       let content;
       if (!tool) {
-        steps.push({ kind: "invalid", target: call.function.name, args, ok: false, detail: "not an allowed tool" });
         content = JSON.stringify({ error: `'${call.function.name}' is not one of your tools` });
+        record({ type: "tool_result", tool: label, kind, success: false, detail: "not an allowed tool", resultText: content, timestamp: now() });
       } else if (tool.target.kind === "read") {
         const rows = await host.read(tool.target.entity);
-        steps.push({ kind: "read", target: tool.target.entity, args, ok: true });
         content = JSON.stringify({ rows });
+        record({ type: "tool_result", tool: label, kind, success: true, rows: rows.length, resultText: content, timestamp: now() });
       } else {
         const parsed = parseArgs(args);
         if (!parsed.success) {
-          steps.push({ kind: "input", target: tool.target.address, args, ok: false, detail: "arguments are not a JSON object" });
           content = JSON.stringify({ error: "arguments must be a JSON object" });
+          record({ type: "tool_result", tool: label, kind, success: false, detail: "arguments are not a JSON object", resultText: content, timestamp: now() });
         } else {
           const { input } = tool.target;
           const response = await host.dispatchInput(input.orbital, {
@@ -2073,8 +2106,8 @@ async function runToolLoop(client, host, request) {
             payload: parsed.data
           });
           const detail = dispatchFailure(response);
-          steps.push({ kind: "input", target: tool.target.address, args, ok: detail === void 0, ...detail !== void 0 ? { detail } : {} });
           content = JSON.stringify(response);
+          record({ type: "tool_result", tool: label, kind, success: detail === void 0, ...detail !== void 0 ? { detail } : {}, resultText: content, timestamp: now() });
         }
       }
       conversation.push({ role: "tool", content, tool_call_id: call.id });
@@ -2253,7 +2286,7 @@ Return ONLY valid JSON matching the schema.`,
     }
     const request = CallToolsParamsSchema.parse(params);
     const client = request.model !== void 0 ? new LLMClient({ provider: this.provider, model: request.model }) : this.getClient();
-    return runToolLoop(client, context.host, request);
+    return runToolLoop(client, context.host, request, { provider: client.getProvider(), model: client.getModelName() });
   }
   async embed(params) {
     const { texts } = params;