@almadar/integrations 2.33.0 → 2.35.0

package/dist/runtime/index.d.ts

@@ -1,5 +1,5 @@
 import { g as IntegrationParams, I as IntegrationCallContext, d as IntegrationFactory } from '../BaseIntegration-BYlbMFlf.js';
-import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-C5nb44iS.js';
+import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-BGNfuoFd.js';
 import '@almadar/core';
 
 /**

package/dist/runtime/index.js

@@ -159,6 +159,11 @@ var serviceCredentials = {
   ],
   arxiv: [
     { envVar: "ARXIV_TIMEOUT_MS", required: false, description: "Per-request timeout (ms)" }
+  ],
+  rigger: [
+    { envVar: "RIGGER_BASE_URL", required: false, description: "Local rigger service base URL (default http://127.0.0.1:8181)" },
+    { envVar: "RIGGER_TIMEOUT_MS", required: false, description: "Per-request timeout (ms)" },
+    { envVar: "RIGGER_GENERATE_TIMEOUT_MS", required: false, description: "Timeout (ms) for the 'generate' action; a local z-image-turbo run takes ~60-90 s and a kontext edit at 1024px several minutes (default 600000)" }
   ]
 };
 function allCredentialEnvVars() {
@@ -5340,6 +5345,179 @@ var ArxivIntegration = class extends BaseIntegration {
 };
 registerIntegration("arxiv", ArxivIntegration);
 
+// src/integrations/rigger/index.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:8181";
+var DEFAULT_TIMEOUT_MS5 = 3e4;
+var DEFAULT_GENERATE_TIMEOUT_MS = 6e5;
+async function riggerError(path, response) {
+  let detail = "";
+  try {
+    const body = await response.json();
+    if (typeof body.detail === "string") detail = body.detail;
+    else if (body.detail !== void 0) detail = JSON.stringify(body.detail);
+  } catch {
+    detail = "";
+  }
+  return new Error(`Rigger ${path} returned ${response.status}${detail ? `: ${detail}` : ""}`);
+}
+var RiggerIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.baseUrl = config.env.RIGGER_BASE_URL || DEFAULT_BASE_URL;
+    this.timeoutMs = Number(config.env.RIGGER_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS5;
+    this.generateTimeoutMs = Number(config.env.RIGGER_GENERATE_TIMEOUT_MS) || DEFAULT_GENERATE_TIMEOUT_MS;
+    this.logger.info("Rigger integration initialized", { baseUrl: this.baseUrl });
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "health":
+          data = await this.health();
+          break;
+        case "buildMesh":
+          data = await this.executeWithRetry(() => this.buildMesh(params));
+          break;
+        case "render":
+          data = await this.executeWithRetry(() => this.render(params));
+          break;
+        case "listPresets":
+          data = await this.executeWithRetry(() => this.listPresets());
+          break;
+        case "loadRig":
+          data = await this.executeWithRetry(() => this.loadRig(params));
+          break;
+        case "saveRig":
+          data = await this.executeWithRetry(() => this.saveRig(params));
+          break;
+        case "ownership":
+          data = await this.executeWithRetry(() => this.ownership(params));
+          break;
+        case "generate":
+          data = await this.executeWithRetry(() => this.generate(params));
+          break;
+        default:
+          throw new UnknownActionError(this.config.name, action);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async health() {
+    const response = await fetch(`${this.baseUrl}/health`, {
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    return { ok: response.ok };
+  }
+  async buildMesh(params) {
+    const { imagePath, rig } = params;
+    const response = await fetch(`${this.baseUrl}/mesh/build`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ imagePath, rig }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/mesh/build", response);
+    }
+    return await response.json();
+  }
+  async render(params) {
+    const { imagePath, rig, preset, outDir, mode, supersample } = params;
+    const response = await fetch(`${this.baseUrl}/render`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ imagePath, rig, preset, outDir, mode, supersample }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/render", response);
+    }
+    return await response.json();
+  }
+  async listPresets() {
+    const response = await fetch(`${this.baseUrl}/presets`, {
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/presets", response);
+    }
+    return await response.json();
+  }
+  async loadRig(params) {
+    const { rigPath } = params;
+    const response = await fetch(`${this.baseUrl}/rig/load`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ rigPath }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/rig/load", response);
+    }
+    return await response.json();
+  }
+  async saveRig(params) {
+    const { rigPath, rig } = params;
+    const response = await fetch(`${this.baseUrl}/rig/save`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ rigPath, rig }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/rig/save", response);
+    }
+    return await response.json();
+  }
+  async ownership(params) {
+    const { imagePath, rig, outPath } = params;
+    const response = await fetch(`${this.baseUrl}/ownership`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ imagePath, rig, outPath }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/ownership", response);
+    }
+    return await response.json();
+  }
+  async generate(params) {
+    const { model, prompt, seed, size, steps, sourcePath, outDir } = params;
+    const response = await fetch(`${this.baseUrl}/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, prompt, seed, size, steps, sourcePath, outDir }),
+      signal: AbortSignal.timeout(this.generateTimeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/generate", response);
+    }
+    return await response.json();
+  }
+};
+registerIntegration("rigger", RiggerIntegration);
+
 // src/mocks/MockIntegration.ts
 var MockIntegration = class extends BaseIntegration {
   constructor(config) {
@@ -5667,6 +5845,12 @@ var RuntimeIntegrationManager = class {
         WEBHOOK_TIMEOUT_MS: env.WEBHOOK_TIMEOUT_MS || ""
       }
     });
+    this.factory.configure("rigger", {
+      env: {
+        RIGGER_BASE_URL: env.RIGGER_BASE_URL || "",
+        RIGGER_TIMEOUT_MS: env.RIGGER_TIMEOUT_MS || ""
+      }
+    });
     const llmEnv = {};
     for (const k of ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY", "KIMI_API_KEY", "OPEN_ROUTER_API_KEY"]) {
       if (env[k]) llmEnv[k] = env[k];