@almadar/integrations 2.41.0 → 2.42.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-D_iNTesu.js';
+import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-DcennSSh.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, EventPayloadSchema } from '@almadar/core';
 import { execSync, spawn } from 'child_process';
 import { tmpdir } from 'os';
 import * as oidc from 'openid-client';
@@ -1973,6 +1974,123 @@ 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) {
+  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 steps = [];
+  const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0, modelCalls: 0 };
+  while (usage.modelCalls < maxSteps) {
+    const turn = await client.callWithTools({ messages: conversation, tools: defs });
+    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 ?? [];
+    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);
+      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` });
+      } 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 });
+      } 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" });
+        } 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);
+          steps.push({ kind: "input", target: tool.target.address, args, ok: detail === void 0, ...detail !== void 0 ? { detail } : {} });
+          content = JSON.stringify(response);
+        }
+      }
+      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 +2131,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 +2153,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 +2247,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);
+  }
   async embed(params) {
     const { texts } = params;
     if (!Array.isArray(texts)) {