@silvana-one/coordination 1.0.24 → 1.0.26

package/src/agent.ts

@@ -5,6 +5,7 @@ import {
   fetchSuiDynamicFieldsList,
   fetchSuiObject,
 } from "./fetch.js";
+import { silvanaRegistryPackage } from "./package.js";
 
 type AgentChain =
   | "ethereum-mainnet"
@@ -26,18 +27,23 @@ type AgentChain =
   | "walrus-testnet"
   | string; // other chains
 
+export interface AgentMethod {
+  dockerImage: string;
+  dockerSha256?: string;
+  minMemoryGb: number;
+  minCpuCores: number;
+  requiresTee: boolean;
+}
+
 export interface Agent {
   id: string;
   name: string;
   image?: string;
   description?: string;
   site?: string;
-  dockerImage: string;
-  dockerSha256?: string;
-  minMemoryGb: number;
-  minCpuCores: number;
-  supportsTEE: boolean;
   chains: AgentChain[];
+  methods: Record<string, AgentMethod>;
+  defaultMethod?: AgentMethod;
   createdAt: number;
   updatedAt: number;
   version: number;
@@ -75,7 +81,7 @@ export class AgentRegistry {
     console.log("Creating agent registry", params.name);
     const transaction = new Transaction();
     transaction.moveCall({
-      target: `@silvana/agent::registry::create_registry`,
+      target: `${silvanaRegistryPackage}::registry::create_registry`,
       arguments: [transaction.pure.string(params.name)],
     });
 
@@ -93,7 +99,7 @@ export class AgentRegistry {
     const tx = new Transaction();
 
     tx.moveCall({
-      target: `@silvana/agent::registry::add_developer`,
+      target: `${silvanaRegistryPackage}::registry::add_developer`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(name),
@@ -119,7 +125,7 @@ export class AgentRegistry {
     const tx = new Transaction();
 
     tx.moveCall({
-      target: `@silvana/agent::registry::update_developer`,
+      target: `${silvanaRegistryPackage}::registry::update_developer`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(name),
@@ -139,7 +145,7 @@ export class AgentRegistry {
     const tx = new Transaction();
 
     tx.moveCall({
-      target: `@silvana/agent::registry::remove_developer`,
+      target: `${silvanaRegistryPackage}::registry::remove_developer`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(name),
@@ -157,11 +163,6 @@ export class AgentRegistry {
     image?: string;
     description?: string;
     site?: string;
-    docker_image: string;
-    docker_sha256?: string;
-    min_memory_gb: number;
-    min_cpu_cores: number;
-    supports_tee: boolean;
     chains: AgentChain[];
   }): Transaction {
     const {
@@ -170,17 +171,12 @@ export class AgentRegistry {
       image,
       description,
       site,
-      docker_image,
-      docker_sha256,
-      min_memory_gb,
-      min_cpu_cores,
-      supports_tee,
       chains,
     } = params;
     const tx = new Transaction();
 
     tx.moveCall({
-      target: `@silvana/agent::registry::add_agent`,
+      target: `${silvanaRegistryPackage}::registry::add_agent`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(developer),
@@ -188,11 +184,6 @@ export class AgentRegistry {
         tx.pure.option("string", image ?? null),
         tx.pure.option("string", description ?? null),
         tx.pure.option("string", site ?? null),
-        tx.pure.string(docker_image),
-        tx.pure.option("string", docker_sha256 ?? null),
-        tx.pure.u16(min_memory_gb),
-        tx.pure.u16(min_cpu_cores),
-        tx.pure.bool(supports_tee),
         tx.pure.vector("string", chains),
         tx.object(SUI_CLOCK_OBJECT_ID),
       ],
@@ -207,11 +198,6 @@ export class AgentRegistry {
     image?: string;
     description?: string;
     site?: string;
-    docker_image: string;
-    docker_sha256?: string;
-    min_memory_gb: number;
-    min_cpu_cores: number;
-    supports_tee: boolean;
     chains: AgentChain[];
   }): Transaction {
     const {
@@ -220,17 +206,12 @@ export class AgentRegistry {
       image,
       description,
       site,
-      docker_image,
-      docker_sha256,
-      min_memory_gb,
-      min_cpu_cores,
-      supports_tee,
       chains,
     } = params;
     const tx = new Transaction();
 
     tx.moveCall({
-      target: `@silvana/agent::registry::update_agent`,
+      target: `${silvanaRegistryPackage}::registry::update_agent`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(developer),
@@ -238,11 +219,6 @@ export class AgentRegistry {
         tx.pure.option("string", image ?? null),
         tx.pure.option("string", description ?? null),
         tx.pure.option("string", site ?? null),
-        tx.pure.string(docker_image),
-        tx.pure.option("string", docker_sha256 ?? null),
-        tx.pure.u16(min_memory_gb),
-        tx.pure.u16(min_cpu_cores),
-        tx.pure.bool(supports_tee),
         tx.pure.vector("string", chains),
         tx.object(SUI_CLOCK_OBJECT_ID),
       ],
@@ -256,7 +232,153 @@ export class AgentRegistry {
     const tx = new Transaction();
 
     tx.moveCall({
-      target: `@silvana/agent::registry::remove_agent`,
+      target: `${silvanaRegistryPackage}::registry::remove_agent`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  addAgentMethod(params: {
+    developer: string;
+    agent: string;
+    method: string;
+    dockerImage: string;
+    dockerSha256?: string;
+    minMemoryGb: number;
+    minCpuCores: number;
+    requiresTee: boolean;
+  }): Transaction {
+    const {
+      developer,
+      agent,
+      method,
+      dockerImage,
+      dockerSha256,
+      minMemoryGb,
+      minCpuCores,
+      requiresTee,
+    } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::add_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.pure.string(dockerImage),
+        tx.pure.option("string", dockerSha256 ?? null),
+        tx.pure.u16(minMemoryGb),
+        tx.pure.u16(minCpuCores),
+        tx.pure.bool(requiresTee),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  updateAgentMethod(params: {
+    developer: string;
+    agent: string;
+    method: string;
+    dockerImage: string;
+    dockerSha256?: string;
+    minMemoryGb: number;
+    minCpuCores: number;
+    requiresTee: boolean;
+  }): Transaction {
+    const {
+      developer,
+      agent,
+      method,
+      dockerImage,
+      dockerSha256,
+      minMemoryGb,
+      minCpuCores,
+      requiresTee,
+    } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::update_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.pure.string(dockerImage),
+        tx.pure.option("string", dockerSha256 ?? null),
+        tx.pure.u16(minMemoryGb),
+        tx.pure.u16(minCpuCores),
+        tx.pure.bool(requiresTee),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  removeAgentMethod(params: {
+    developer: string;
+    agent: string;
+    method: string;
+  }): Transaction {
+    const { developer, agent, method } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::remove_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  setDefaultMethod(params: {
+    developer: string;
+    agent: string;
+    method: string;
+  }): Transaction {
+    const { developer, agent, method } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::set_default_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  removeDefaultMethod(params: {
+    developer: string;
+    agent: string;
+  }): Transaction {
+    const { developer, agent } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::remove_default_method`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(developer),
@@ -367,32 +489,58 @@ export class AgentRegistry {
     if (!agentObject) {
       return undefined;
     }
+    
+    // Parse methods from VecMap structure
+    const methods: Record<string, AgentMethod> = {};
+    const methodsData = (agentObject as any)?.methods?.fields?.contents;
+    if (methodsData && Array.isArray(methodsData)) {
+      for (const entry of methodsData) {
+        const key = entry?.fields?.key;
+        const value = entry?.fields?.value;
+        if (key && value) {
+          methods[key] = {
+            dockerImage: value.docker_image,
+            dockerSha256: value.docker_sha256 ?? undefined,
+            minMemoryGb: Number(value.min_memory_gb),
+            minCpuCores: Number(value.min_cpu_cores),
+            requiresTee: Boolean(value.requires_tee),
+          };
+        }
+      }
+    }
+    
+    // Parse default method if it exists
+    let defaultMethod: AgentMethod | undefined;
+    const defaultMethodData = (agentObject as any)?.default_method;
+    if (defaultMethodData && typeof defaultMethodData === 'object' && !Array.isArray(defaultMethodData)) {
+      defaultMethod = {
+        dockerImage: defaultMethodData.docker_image,
+        dockerSha256: defaultMethodData.docker_sha256 ?? undefined,
+        minMemoryGb: Number(defaultMethodData.min_memory_gb),
+        minCpuCores: Number(defaultMethodData.min_cpu_cores),
+        requiresTee: Boolean(defaultMethodData.requires_tee),
+      };
+    }
+    
     const agent = {
       id: (agentObject as any)?.id?.id,
       name: (agentObject as any).name,
       image: (agentObject as any)?.image ?? undefined,
       description: (agentObject as any)?.description ?? undefined,
       site: (agentObject as any)?.site ?? undefined,
-      dockerImage: (agentObject as any).docker_image,
-      dockerSha256: (agentObject as any)?.docker_sha256 ?? undefined,
-      minMemoryGb: Number((agentObject as any).min_memory_gb),
-      minCpuCores: Number((agentObject as any).min_cpu_cores),
-      supportsTEE: Boolean((agentObject as any).supports_tee),
+      chains: (agentObject as any)?.chains ?? [],
+      methods,
+      defaultMethod,
       createdAt: Number((agentObject as any).created_at),
       updatedAt: Number((agentObject as any).updated_at),
       version: Number((agentObject as any).version),
     };
-    if (
-      !agent.id ||
-      !agent.name ||
-      !agent.dockerImage ||
-      !agent.minMemoryGb ||
-      !agent.minCpuCores ||
-      !agent.createdAt ||
-      !agent.updatedAt
-    ) {
+    
+    // Only check for essential fields
+    if (!agent.id || !agent.name) {
       return undefined;
     }
+    
     return agent as Agent;
   }
 

package/src/app_instance.ts

@@ -0,0 +1,264 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { silvanaRegistryPackage } from "./package.js";
+import { fetchSuiDynamicField, fetchSuiObject } from "./fetch.js";
+import { Job, JobStatus } from "./job.js";
+
+export interface AppMethod {
+  description?: string;
+  developer: string;
+  agent: string;
+  agentMethod: string;
+}
+
+export interface AppInstance {
+  id: string;
+  silvanaAppName: string;
+  description?: string;
+  metadata?: string;
+  methods: Record<string, AppMethod>;
+  admin: string;
+  sequence: number;
+  blockNumber: number;
+  previousBlockTimestamp: number;
+  previousBlockLastSequence: number;
+  lastProvedBlockNumber: number;
+  isPaused: boolean;
+  jobsId: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface CreateAppJobParams {
+  appInstance: string;
+  description?: string;
+  method: string;
+  sequences?: number[];
+  data: Uint8Array;
+}
+
+export class AppInstanceManager {
+  private readonly registry: string;
+
+  constructor(params: { registry: string }) {
+    this.registry = params.registry;
+  }
+
+  // Note: update_method and remove_method functions are not available in the Move module
+  // These would need to be implemented in app_instance.move if needed
+
+  createAppJob(params: CreateAppJobParams): Transaction {
+    const { appInstance, description, method, sequences, data } = params;
+
+    // Debug logging
+    console.log("createAppJob params:", {
+      appInstance,
+      description,
+      method,
+      sequences,
+      data:
+        data instanceof Uint8Array ? `Uint8Array(${data.length})` : typeof data,
+      dataContent: data instanceof Uint8Array ? Array.from(data) : data,
+    });
+
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::create_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.string(method),
+        tx.pure.option("string", description ?? null),
+        tx.pure.option("vector<u64>", sequences ?? null),
+        tx.pure.vector("u8", data),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  startAppJob(params: { appInstance: string; jobId: number }): Transaction {
+    const { appInstance, jobId } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::start_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.u64(jobId),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  completeAppJob(params: { appInstance: string; jobId: number }): Transaction {
+    const { appInstance, jobId } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::complete_app_job`,
+      arguments: [
+        tx.object(appInstance), 
+        tx.pure.u64(jobId),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  failAppJob(params: {
+    appInstance: string;
+    jobId: number;
+    error: string;
+  }): Transaction {
+    const { appInstance, jobId, error } = params;
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::fail_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.u64(jobId),
+        tx.pure.string(error),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+
+    return tx;
+  }
+
+  async getAppInstance(
+    appInstanceId: string
+  ): Promise<AppInstance | undefined> {
+    try {
+      const appInstance = await fetchSuiObject(appInstanceId);
+      if (!appInstance) return undefined;
+
+      const fields = (appInstance as any)?.data?.content?.fields;
+      if (!fields) return undefined;
+
+      // Parse methods from VecMap
+      const methods: Record<string, AppMethod> = {};
+      const methodsArray = fields?.methods?.fields?.contents;
+      if (Array.isArray(methodsArray)) {
+        for (const entry of methodsArray) {
+          const key = entry?.fields?.key;
+          const value = entry?.fields?.value;
+          if (key && value) {
+            // Value might have a fields property too
+            const methodFields = value.fields || value;
+            methods[key] = {
+              description: methodFields.description ?? undefined,
+              developer: methodFields.developer,
+              agent: methodFields.agent,
+              agentMethod: methodFields.agent_method || methodFields.agentMethod,
+            };
+          }
+        }
+      }
+
+      return {
+        id: fields?.id?.id,
+        silvanaAppName: fields.silvana_app_name,
+        description: fields?.description ?? undefined,
+        metadata: fields?.metadata ?? undefined,
+        methods,
+        admin: fields.admin,
+        sequence: Number(fields.sequence),
+        blockNumber: Number(fields.block_number),
+        previousBlockTimestamp: Number(fields.previous_block_timestamp),
+        previousBlockLastSequence: Number(fields.previous_block_last_sequence),
+        lastProvedBlockNumber: Number(fields.last_proved_block_number),
+        isPaused: Boolean(fields.isPaused),
+        jobsId: String(fields.jobs?.fields?.id?.id ?? ""),
+        createdAt: Number(fields.created_at),
+        updatedAt: Number(fields.updated_at),
+      };
+    } catch (error) {
+      console.error("Error fetching app instance:", error);
+      return undefined;
+    }
+  }
+
+  async getAppJob(params: {
+    appInstance: string;
+    jobId: number;
+  }): Promise<Job | undefined> {
+    try {
+      const appInstanceObj = await fetchSuiObject(params.appInstance);
+      if (!appInstanceObj) return undefined;
+
+      // Jobs are embedded in the AppInstance - use correct path
+      const jobsTableId = (appInstanceObj as any)?.data?.content?.fields?.jobs?.fields?.jobs?.fields?.id?.id;
+      if (!jobsTableId) return undefined;
+
+      const job = await fetchSuiDynamicField({
+        parentID: jobsTableId,
+        fieldName: "jobs",
+        type: "u64",
+        key: String(params.jobId),
+      });
+
+      if (!job) return undefined;
+
+      const parseStatus = (status: any): JobStatus => {
+        // Check variant field format (used by Sui dynamic fields)
+        if (status?.variant === "Pending") return { type: "Pending" };
+        if (status?.variant === "Running") return { type: "Running" };
+        if (status?.variant === "Failed") {
+          // Get error from fields or from direct property
+          const error = status?.fields?.error || status?.fields?.[0] || "Unknown error";
+          return { type: "Failed", error };
+        }
+        // Legacy formats
+        if (status?.Pending !== undefined) return { type: "Pending" };
+        if (status?.Running !== undefined) return { type: "Running" };
+        if (status?.Failed !== undefined) return { type: "Failed", error: status.Failed };
+        return { type: "Pending" };
+      };
+
+      return {
+        id: (job as any)?.id?.id,
+        jobId: Number((job as any).job_id),
+        description: (job as any)?.description ?? undefined,
+        developer: (job as any).developer,
+        agent: (job as any).agent,
+        agentMethod: (job as any).agent_method,
+        app: (job as any).app,
+        appInstance: (job as any).app_instance,
+        appInstanceMethod: (job as any).app_instance_method,
+        sequences:
+          (job as any)?.sequences?.map((s: string) => Number(s)) ?? undefined,
+        data: new Uint8Array((job as any).data),
+        status: parseStatus((job as any).status),
+        attempts: Number((job as any).attempts),
+        createdAt: Number((job as any).created_at),
+        updatedAt: Number((job as any).updated_at),
+      };
+    } catch (error) {
+      console.error("Error fetching app job:", error);
+      return undefined;
+    }
+  }
+
+  async getAppPendingJobs(appInstance: string): Promise<number[]> {
+    try {
+      const appInstanceObj = await fetchSuiObject(appInstance);
+      if (!appInstanceObj) return [];
+
+      // Jobs are embedded in the AppInstance - use correct path
+      const pendingJobs = (appInstanceObj as any)?.data?.content?.fields?.jobs?.fields?.pending_jobs?.fields?.contents;
+      
+      if (!Array.isArray(pendingJobs)) return [];
+
+      return pendingJobs.map((id: string) => Number(id));
+    } catch (error) {
+      console.error("Error fetching app pending jobs:", error);
+      return [];
+    }
+  }
+}

package/src/build.ts

@@ -0,0 +1,33 @@
+export async function buildMovePackage(path: string): Promise<{
+  modules: string[];
+  dependencies: string[];
+  digest: number[];
+}> {
+  const { execSync } = await import("child_process");
+  let bytes:
+    | {
+        modules: string[];
+        dependencies: string[];
+        digest: number[];
+      }
+    | undefined = undefined;
+
+  console.log("Running sui client publish command...");
+  try {
+    const output = execSync(
+      `sui move build --dump-bytecode-as-base64 --ignore-chain --path ${path}`,
+      {
+        encoding: "utf-8",
+      }
+    );
+    bytes = JSON.parse(output);
+    if (!bytes) {
+      throw new Error("Error building package");
+    }
+    return bytes;
+    //console.log("Command output:", bytes);
+  } catch (error) {
+    console.error("Error running command:", error);
+    throw error;
+  }
+}

package/src/execute.ts

@@ -66,6 +66,7 @@ export async function executeTx(params: {
       digest: string;
       events: object;
       executeTime: number;
+      error?: string;
     }
   | undefined
 > {
@@ -136,13 +137,21 @@ export async function executeTx(params: {
     }
 
     if (executedTx?.effects?.status?.status === "failure") {
+      const errorMessage = executedTx?.effects?.status?.error || "Unknown error";
       if (showErrors) {
         console.log(
           `Errors for tx ${executedTx.digest}:`,
-          executedTx?.effects?.status?.error
+          errorMessage
         );
-        throw new Error(`tx execution failed: ${executedTx.digest}`);
       }
+      // Return the transaction with error information instead of throwing
+      return {
+        tx: executedTx,
+        digest: executedTx.digest,
+        events: (executedTx?.events as SuiEvent[])?.[0]?.parsedJson as object,
+        executeTime: end - start,
+        error: errorMessage,
+      };
     }
     return {
       tx: executedTx,