@almadar/integrations 2.34.0 → 2.36.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-DaPuMedl.js';
+import { o as IntegrationName, m as IntegrationActionName, n as IntegrationContracts, e as CredentialStore } from '../store-OiFX0Tkn.js';
 import '@almadar/core';
 
 /**

package/dist/runtime/index.js

@@ -162,7 +162,8 @@ var serviceCredentials = {
   ],
   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_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() {
@@ -5347,11 +5348,36 @@ 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;
+var GENERATE_MODELS = ["z-image-turbo", "kontext"];
+function generateParamErrors(params) {
+  const errors = [];
+  const model = params.model;
+  if (typeof model !== "string" || !GENERATE_MODELS.includes(model)) {
+    errors.push(`model must be one of ${GENERATE_MODELS.join(", ")}`);
+  }
+  if (model === "kontext" && (typeof params.sourcePath !== "string" || params.sourcePath === "")) {
+    errors.push("sourcePath is required when model is kontext");
+  }
+  return errors;
+}
+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) {
@@ -5368,6 +5394,21 @@ var RiggerIntegration = class extends BaseIntegration {
         metadata: this.createMetadata(action, 0)
       };
     }
+    if (action === "generate") {
+      const invalid = generateParamErrors(params);
+      if (invalid.length > 0) {
+        return {
+          success: false,
+          error: {
+            name: "IntegrationError",
+            message: "Validation failed",
+            code: "VALIDATION_ERROR",
+            details: invalid
+          },
+          metadata: this.createMetadata(action, 0)
+        };
+      }
+    }
     const startTime = Date.now();
     try {
       let data;
@@ -5381,6 +5422,27 @@ var RiggerIntegration = class extends BaseIntegration {
         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 "buildLayers":
+          data = await this.executeWithRetry(() => this.buildLayers(params));
+          break;
+        case "pose":
+          data = await this.executeWithRetry(() => this.pose(params));
+          break;
+        case "generate":
+          data = await this.executeWithRetry(() => this.generate(params));
+          break;
         default:
           throw new UnknownActionError(this.config.name, action);
       }
@@ -5408,22 +5470,109 @@ var RiggerIntegration = class extends BaseIntegration {
       signal: AbortSignal.timeout(this.timeoutMs)
     });
     if (!response.ok) {
-      throw new Error(`Rigger /mesh/build returned ${response.status}`);
+      throw await riggerError("/mesh/build", response);
     }
     return await response.json();
   }
   async render(params) {
-    const { imagePath, rig, preset, outDir } = 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 }),
+      body: JSON.stringify({ imagePath, rig, preset, outDir, mode, supersample }),
       signal: AbortSignal.timeout(this.timeoutMs)
     });
     if (!response.ok) {
-      throw new Error(`Rigger /render returned ${response.status}`);
+      throw await riggerError("/render", response);
     }
-    return response.json();
+    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 buildLayers(params) {
+    const { imagePath, rig, outDir } = params;
+    const response = await fetch(`${this.baseUrl}/layers`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ imagePath, rig, outDir }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/layers", response);
+    }
+    return await response.json();
+  }
+  async pose(params) {
+    const { imagePath, rig, roles, preset, overrides } = params;
+    const response = await fetch(`${this.baseUrl}/pose`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ imagePath, rig, roles, preset, overrides }),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!response.ok) {
+      throw await riggerError("/pose", 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);
@@ -5487,28 +5636,41 @@ function createCallServiceHandler(factory) {
 }
 
 // src/runtime/RuntimeIntegrationManager.ts
-function generateMockFromShape(shape) {
-  const data = {};
-  for (const [key, type] of Object.entries(shape)) {
-    switch (type) {
+function mockValueForDescriptor(key, descriptor) {
+  if (typeof descriptor === "string") {
+    if (descriptor.endsWith("[]")) return [];
+    switch (descriptor) {
       case "string":
-        data[key] = `mock_${key}`;
-        break;
+        return `mock_${key}`;
       case "number":
-        data[key] = 42;
-        break;
+        return 42;
       case "boolean":
-        data[key] = true;
-        break;
+        return true;
       case "object":
-        data[key] = {};
-        break;
-      case "string[]":
-        data[key] = [];
-        break;
+        return {};
       default:
-        data[key] = `mock_${key}`;
+        return `mock_${key}`;
+    }
+  }
+  if (descriptor.type === "array") {
+    return descriptor.items ? [mockValueForDescriptor(`${key}Item`, descriptor.items)] : [];
+  }
+  if (descriptor.properties) {
+    const obj = {};
+    for (const [propKey, propDescriptor] of Object.entries(descriptor.properties)) {
+      obj[propKey] = mockValueForDescriptor(propKey, propDescriptor);
     }
+    return obj;
+  }
+  if (descriptor.mapValue) {
+    return { sample: mockValueForDescriptor("sample", descriptor.mapValue) };
+  }
+  return {};
+}
+function generateMockFromShape(shape) {
+  const data = {};
+  for (const [key, descriptor] of Object.entries(shape)) {
+    data[key] = mockValueForDescriptor(key, descriptor);
   }
   return data;
 }