@almadar/integrations 2.41.0 → 2.43.0

package/dist/runtime/index.d.ts

@@ -1,6 +1,7 @@
-import { g as IntegrationParams, I as IntegrationCallContext, d as IntegrationFactory } from '../BaseIntegration-CWdas-N_.js';
-import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-DG5OGiuQ.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';
 
 /**
  * Signature of the call-service handler returned by `createCallServiceHandler`

package/dist/runtime/index.js

@@ -13,6 +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, traceActivityPayload, EventPayloadSchema } from '@almadar/core';
 import { execSync, spawn } from 'child_process';
 import { tmpdir } from 'os';
 import * as oidc from 'openid-client';
@@ -409,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
@@ -423,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;
@@ -467,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);
   }
   /**
@@ -477,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);
@@ -490,6 +497,7 @@ var IntegrationFactory = class {
    */
   clear() {
     this.instances.clear();
+    this.registered.clear();
   }
   /**
    * Clear all instances and configs
@@ -497,6 +505,7 @@ var IntegrationFactory = class {
   reset() {
     this.instances.clear();
     this.configs.clear();
+    this.registered.clear();
   }
 };
 var installedStore = null;
@@ -1973,6 +1982,148 @@ var EsignIntegration = class extends BaseIntegration {
   }
 };
 registerIntegration("esign", EsignIntegration);
+var DEFAULT_MAX_STEPS = 8;
+var TOOL_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
+function toolName(raw) {
+  if (!TOOL_NAME.test(raw)) {
+    throw new Error(`call-tools: tool name '${raw}' is not a valid tool name (letters, digits, _ and -, at most 64)`);
+  }
+  return raw;
+}
+function buildTools(host, tools) {
+  const inputs = host.inputs();
+  const out = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    if (tool.event !== void 0) {
+      const input = findInputByAddress(inputs, tool.event, host.caller);
+      if (!input) throw new Error(`call-tools: '${tool.event}' is not a declared external input`);
+      const name = toolName(tool.event.split(".").join("__"));
+      out.set(name, {
+        def: {
+          type: "function",
+          function: { name, description: input.description ?? tool.event, parameters: payloadSchemaToJsonSchema(input.payloadSchema) }
+        },
+        target: { kind: "input", address: tool.event, input }
+      });
+    } else if (tool.read !== void 0) {
+      const name = toolName(`read__${tool.read}`);
+      out.set(name, {
+        def: {
+          type: "function",
+          function: { name, description: `Read the ${tool.read} rows you may see`, parameters: { type: "object", properties: {} } }
+        },
+        target: { kind: "read", entity: tool.read }
+      });
+    }
+  }
+  return out;
+}
+function dispatchFailure(response) {
+  if (response.rejections && response.rejections.length > 0) return response.rejections.map((r) => r.code).join(", ");
+  if (response.guardFailed !== void 0) return `guard failed: ${response.guardFailed}`;
+  if (!response.success) return response.error ?? "dispatch failed";
+  const failed = (response.effectResults ?? []).find((r) => !r.success);
+  if (failed) return failed.error ?? `${failed.effect} failed`;
+  if (!response.transitioned) return "no transition";
+  return void 0;
+}
+function parseArgs(args) {
+  let value;
+  try {
+    value = JSON.parse(args === "" ? "{}" : args);
+  } catch {
+    value = void 0;
+  }
+  return EventPayloadSchema.safeParse(value);
+}
+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;
+  const conversation = [
+    ...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;
+      usage.completionTokens += turn.usage.completionTokens;
+      usage.totalTokens += turn.usage.totalTokens;
+    }
+    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) {
+        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);
+        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) {
+          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, {
+            targetTrait: input.trait,
+            event: input.event,
+            payload: parsed.data
+          });
+          const detail = dispatchFailure(response);
+          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 });
+    }
+  }
+  throw new Error(`call-tools: no reply after ${maxSteps} model calls`);
+}
+
+// src/integrations/llm/index.ts
+var CallToolsParamsSchema = z.object({
+  messages: z.array(z.object({ role: z.enum(["user", "assistant"]), content: z.string() })),
+  tools: z.array(z.object({ event: z.string().optional(), read: z.string().optional() })),
+  instructions: z.string().optional(),
+  maxSteps: z.number().int().positive().optional(),
+  model: z.string().optional()
+});
 var LLMIntegration = class extends BaseIntegration {
   constructor(config) {
     super(config);
@@ -2013,7 +2164,7 @@ var LLMIntegration = class extends BaseIntegration {
     }
     return this.embeddings;
   }
-  async execute(action, params) {
+  async execute(action, params, context) {
     const validation = this.validateParams(action, params);
     if (!validation.valid) return this.validationFailure(action, validation.errors);
     const startTime = Date.now();
@@ -2035,6 +2186,10 @@ var LLMIntegration = class extends BaseIntegration {
         case "embed":
           data = await this.executeWithRetry(() => this.embed(params));
           break;
+        // Never retried: a retry would re-fire inputs the first attempt already fired.
+        case "call-tools":
+          data = await this.callTools(params, context);
+          break;
         default:
           throw new UnknownActionError(this.config.name, action);
       }
@@ -2125,6 +2280,14 @@ Return ONLY valid JSON matching the schema.`,
     });
     return result;
   }
+  async callTools(params, context) {
+    if (!context?.host) {
+      throw new Error("llm.call-tools needs host ports: run it from a host that lends the running app (call-service on a server)");
+    }
+    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, { provider: client.getProvider(), model: client.getModelName() });
+  }
   async embed(params) {
     const { texts } = params;
     if (!Array.isArray(texts)) {